yeptris 0.6.59.1-arm-linux-eabihf → 0.6.61.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;
@@ -64,13 +69,16 @@ typedef struct yep_writer {
      * grow/flush checks run once per refill instead of once per byte;
      * 0 at run entry and whenever the guarantee lapses. */
     size_t reserve;
-    int in_flow;        /* scalars inside flow collections: plain must drop
-                           ',', '[', ']', '{', '}' — flow terminators */
-    int flow_item;      /* the NEXT scalar is a flow-SEQ item: a null must
-                           emit '~' (a bare nothing reads as "[, x]") */
-    int unserializable; /* an anchor name that cannot ride raw in flow
-                           context: the document has no safe spelling —
-                           serialize fails rather than corrupt */
+    int in_flow;                         /* scalars inside flow collections: plain must drop
+                                            ',', '[', ']', '{', '}' — flow terminators */
+    int flow_item;                       /* the NEXT scalar is a flow-SEQ item: a null must
+                                            emit '~' (a bare nothing reads as "[, x]") */
+    int unserializable;                  /* an anchor name that cannot ride raw in flow
+                                            context: the document has no safe spelling —
+                                            serialize fails rather than corrupt */
+    const struct yep_resolver* resolver; /* the document's implicit-typing
+        family (NULL = core12): the INT arm's decode needs the family's
+        own forms (leading-0 is octal in compat, decimal in core) */
 } yep_writer;
 
 typedef struct yep_emitter {
@@ -82,6 +90,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) {
@@ -428,6 +452,28 @@ int yep_values_from_input(const char* yaml, size_t len, int schema_compat, yep_v
             }
             /* fall through: engine */
         }
+        /* Unicode breaks (NEL/LS/PS) normalize to '\n' BEFORE the
+         * engine, exactly as the parse entry's front-end does
+         * (parse_frontend): this drain feeds the SAME compat-grammar
+         * engine, and a raw NEL it never normalized errors where
+         * parse accepts -- the nightly's round 239 roundtrip catch
+         * ("<NEL>...<NEL> >\n <NEL>...<NEL>\nt": marshal returned
+         * ERROR_PARSE on a document yeptris_parse_ex accepted and
+         * serialized cleanly). JSON stays above this: the JSON reader
+         * keeps U+0085 raw inside strings, only the YAML reader
+         * normalizes (the parse_frontend law). Ownership rides the
+         * same `transcoded` plumbing the transcode above installed. */
+        {
+            size_t nlen = 0;
+            int kept_raw = 0;
+            char* norm = yep_engine_normalize_breaks(sys, data, data_len, &nlen, &kept_raw);
+            if (norm != NULL) {
+                yep_free(sys, transcoded);
+                transcoded = (unsigned char*)norm;
+                data = (const char*)norm;
+                data_len = nlen;
+            }
+        }
         yep_engine* eng = yep_engine_create(yep_system_allocator());
         if (eng == NULL) {
             return -1;