yeptris 0.6.41.0-powerpc64le-linux → 0.6.43.0-powerpc64le-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3aed54da7f15bc22c5f779f2529df1723c7c2b36e75cf167ce64d91509fd5bcb
-  data.tar.gz: 30558d753e8daa9bc6abb53301d77c2d08a22f289d208dbe7ec51ecbdf3e0f2b
+  metadata.gz: f91368a63c01ce77d1dec0fabb6ea9dc175cae7c68bb21e34635aca468319724
+  data.tar.gz: 20fe41b400a6261b2f5d18d302994f0b1fb3450b00d06f6a6be40270504aecaf
 SHA512:
-  metadata.gz: 5c533248db34c2f814cb1811725ff2d68664e8b9e2a7742f0653d840f16df4bcceb4adf6fa8b657bfce646092f0ca960ab056e096b78ee9e2c48ff931fc17251
-  data.tar.gz: 447c30099bf87a3203f95c7c0258adb13a9fd37367a422703d8817faae440fdcd9bd5e50fdaddcfdf10f91dbee6102996a845ee8889aa5effa112ef5418c90a8
+  metadata.gz: 450f4911af194dadebc41a221ce52e65c4d0b1affce6fda8f7c03ecb90aed5b61408e8e9b7febf5965da873b07b99592fe9b9d8da90e252cffff2173a153e530
+  data.tar.gz: 55eb5c0515983584e4f22ed405afe0515251f3856a9b62ea17288a9ea260b906d062b23d76590be2b6e889a8c8d0c842e506c58b9e37132bc1bd298f476b38a9

data/ext/yeptris_native/version.h

@@ -11,8 +11,8 @@
 
 #define YEPTRIS_VERSION_MAJOR 0
 #define YEPTRIS_VERSION_MINOR 6
-#define YEPTRIS_VERSION_PATCH 41
-#define YEPTRIS_VERSION_STRING "0.6.41"
+#define YEPTRIS_VERSION_PATCH 43
+#define YEPTRIS_VERSION_STRING "0.6.43"
 
 #ifdef __cplusplus
 extern "C" {

data/lib/yeptris.rb

@@ -3,7 +3,7 @@
 module Yeptris
   # The gem's version lives in the parent namespace's file — the last
   # internal require (yeptris/version) retired with it.
-  VERSION = "0.6.41.0".freeze
+  VERSION = "0.6.43.0".freeze
 
   # Informational notices are OPT-IN (yeptris-ruby#217): consumers
   # embed yeptris inside CLIs that assert clean stderr, and a

data/vendor/libyeptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(yeptris
-    VERSION 0.6.41
+    VERSION 0.6.43
     DESCRIPTION "Ultra-fast YAML 1.2 parser, emitter and streamer in C"
     LANGUAGES C CXX
 )

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

@@ -293,8 +293,15 @@ YEPTRIS_API char* yeptris_serialize_json(YeptrisDocument handle, size_t* len) {
     if (em.w.canonical && !yep_nametab_init(&em.canon_names, yep_system_allocator())) {
         return NULL;
     }
-    size_t need = yep_emit_run(&em, 1);
-    char* out = malloc(need + 1);
+    /* #739: ONE wet pass into a growable buffer — the dry exact-sizing
+     * pass priced ~2x on the json lane (the #352 slice-2 pattern);
+     * the estimate starts at the input size (+64) and doubles on
+     * demand, shrink-to-fit at the end. */
+    size_t est = em.doc->dom->input_len + 64;
+    if (est < 256) {
+        est = 256;
+    }
+    char* out = (char*)malloc(est);
     if (out == NULL) {
         if (em.canon_names.sys != NULL) {
             yep_nametab_free(&em.canon_names);
@@ -302,7 +309,24 @@ YEPTRIS_API char* yeptris_serialize_json(YeptrisDocument handle, size_t* len) {
         return NULL;
     }
     em.w.p = out;
+    em.w.cap = est;
+    em.w.grow = 1;
     size_t wrote = yep_emit_run(&em, 0);
+    em.w.grow = 0;
+    out = em.w.p; /* wr_grow reallocs through w->p — the local is stale */
+    if (em.w.oom || em.w.unserializable) {
+        free(out);
+        if (em.canon_names.sys != NULL) {
+            yep_nametab_free(&em.canon_names);
+        }
+        return NULL;
+    }
+    if (em.w.cap - (wrote + 1) > em.w.cap / 8) {
+        char* tight = (char*)realloc(out, wrote + 1);
+        if (tight != NULL) {
+            out = tight;
+        }
+    }
     if (em.canon_names.sys != NULL) {
         yep_nametab_free(&em.canon_names);
     }

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

@@ -66,6 +66,8 @@ static void wr_col_update(yep_writer* w, const char* p, uint32_t n) {
     w->col += (int)n;
 }
 
+static void wr_reserve(yep_writer* w, size_t need);
+
 static void wr_grow(yep_writer* w, size_t need) {
     if (w->oom || w->p == NULL) {
         w->oom = w->p == NULL;
@@ -98,20 +100,53 @@ static void wr_put(yep_writer* w, const char* p, uint32_t n) {
      * (len + n == cap) put that NUL one byte past the buffer — the
      * first byte of the next heap block's header (the #182 flake:
      * corrupt deterministic, detected later, timing-varying) */
-    if (w->grow && w->len + n + 1 > w->cap) {
-        if (w->bounded) {
-            w->oom = 1; /* keep counting: the trusted caller reads the size */
-        } else {
-            wr_grow(w, n);
+    if (w->reserve < (size_t)n) {
+        wr_reserve(w, n);
+        if (w->oom) {
+            w->len += n; /* keep counting: the caller fails on oom */
+            return;
         }
     }
-    if (w->oom) {
-        w->len += n; /* keep counting: the caller fails on oom */
-        return;
+    if ((size_t)n <= w->reserve) {
+        w->reserve -= n;
+    } else {
+        w->reserve = 0; /* grow=0 trusts the count: the write rides past
+                         * the bookkeeping exactly as before */
     }
     memcpy(w->p + w->len, p, n);
     w->len += n;
+}
+
+/* #739 lane 1: refill the writable reservation. The grow and flush
+ * checks move from every byte to every refill; the watermark law is
+ * unchanged in spirit (append-only output — any crossing is a safe
+ * cut, a sink just sees chunks up to one reserve past the mark).
+ * ONLY the growing routes hold a reservation: the caller-buffer and
+ * trusted-count routes keep cap bookkeeping that is not the writer's
+ * to reason about (several set cap=0), so their writes stay exactly
+ * the old per-call trust. */
+static void wr_reserve(yep_writer* w, size_t need) {
+    /* the FLUSH runs for every route: the fixed-window streaming route
+     * (grow=0) has no reservation, so this refill path is its ONLY
+     * flush point -- skipping it let len ride to cap and the next
+     * write landed past the window (ASan: heap-buffer-overflow WRITE
+     * of size 2 exactly 0 bytes after the 128K region; ubuntu's
+     * allocator freed-corrupted, macOS's slack absorbed it). */
     wr_maybe_flush(w);
+    if (!w->grow || w->bounded) {
+        w->reserve = 0;
+        return;
+    }
+    if (w->oom) {
+        return;
+    }
+    if (w->len + need + 1 > w->cap) { /* +1: the terminator */
+        wr_grow(w, need);
+        if (w->oom) {
+            return;
+        }
+    }
+    w->reserve = w->cap - w->len - 1;
 }
 
 static void wr_byte(yep_writer* w, char c) {
@@ -125,20 +160,17 @@ static void wr_byte(yep_writer* w, char c) {
         w->len++;
         return;
     }
-    if (w->grow && w->len + 2 > w->cap) { /* +1 write, +1 terminator */
-        if (w->bounded) {
-            w->oom = 1; /* keep counting: the trusted caller reads the size */
-        } else {
-            wr_grow(w, 1);
+    if (w->reserve == 0) {
+        wr_reserve(w, 1);
+        if (w->oom) {
+            w->len++;
+            return;
         }
     }
-    if (w->oom) {
-        w->len++;
-        return;
+    if (w->reserve > 0) {
+        w->reserve--; /* grow=0 routes keep it at 0: per-call trust */
     }
-    w->p[w->len] = c;
-    w->len++;
-    wr_maybe_flush(w);
+    w->p[w->len++] = c;
 }
 
 static void wr_indent(yep_writer* w, int depth) {
@@ -299,21 +331,34 @@ static void emit_dq_json(yep_writer* w, const char* p, uint32_t n) {
         NULL, "\\f", "\\r", NULL, NULL, NULL, NULL, NULL, NULL,  NULL,  NULL,
         NULL, NULL,  NULL,  NULL, NULL, NULL, NULL, NULL, NULL,  NULL,
     };
+    static const char hd[] = "0123456789abcdef";
+    /* run-batched (the #352 emit_dq shape): clean spans ride one
+     * wr_put each — per-byte wr_byte calls were 14% of the json
+     * write lane's leaf samples (yeptris#739) */
+    uint32_t run = 0;
     for (uint32_t i = 0; i < n; i++) {
         unsigned char c = (unsigned char)p[i];
+        if (c >= 0x20 && c != '"' && c != '\\') {
+            run++;
+            continue;
+        }
+        if (run) {
+            wr_put(w, p + i - run, run);
+            run = 0;
+        }
         if (c < 32 && named[c] != NULL) {
             wr_put(w, named[c], 2);
         } else if (c == '"' || c == '\\') {
             wr_byte(w, '\\');
             wr_byte(w, (char)c);
-        } else if (c < 0x20) {
-            static const char hd[] = "0123456789abcdef";
+        } else {
             char hex[6] = {'\\', 'u', '0', '0', hd[(c >> 4) & 0xf], hd[c & 0xf]};
             wr_put(w, hex, 6);
-        } else {
-            wr_byte(w, (char)c);
         }
     }
+    if (run) {
+        wr_put(w, p + n - run, run);
+    }
     wr_byte(w, '"');
 }
 
@@ -912,6 +957,9 @@ static void emit_node(yep_emitter* em, uint32_t id, int parent_col, int as_key);
  * written). Conservative factor-4 estimate for every expandable
  * byte — overestimating only takes the (always-legal) explicit form. */
 static int key_written_over_limit(yep_writer* w, const yep_dnode* kn) {
+    if (w->json) {
+        return 0; /* JSON has no simple-key law: every key writes (#739) */
+    }
     uint64_t est = 2; /* the quotes */
     yep_view kv_ = wv(w, kn->value);
     const unsigned char* q = (const unsigned char*)kv_.p;
@@ -1098,6 +1146,9 @@ static void emit_block_map(yep_emitter* em, uint32_t id, int content_col) {
                     if (w->oom) {
                         w->len += total; /* keep counting: the caller fails on oom */
                     } else {
+                        /* the fused write bypasses wr_put/wr_byte: keep
+                         * the reservation honest (the #739 lane-1 law) */
+                        w->reserve = (size_t)total <= w->reserve ? w->reserve - (size_t)total : 0;
                         char* q = w->p + w->len;
                         if (nl) {
                             *q++ = '\n';
@@ -1357,6 +1408,7 @@ size_t yep_emit_run(yep_emitter* em, int dry) {
     const yep_dom* d = em->doc->dom;
     w->dry = dry;
     w->len = 0;
+    w->reserve = 0;
     w->last = 0;
     w->force_flow = 0;
     w->flushed = 0;

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

@@ -57,9 +57,13 @@ typedef struct yep_writer {
     size_t cap;
     int grow;
     int oom;
-    int bounded;        /* #352: caller-owned fixed buffer — an oversized write
-                           sets oom and keeps counting (the needed size falls
-                           out of the same pass); wr_grow is never called */
+    int bounded; /* #352: caller-owned fixed buffer — an oversized write
+                    sets oom and keeps counting (the needed size falls
+                    out of the same pass); wr_grow is never called */
+    /* #739 lane 1: writable bytes guaranteed at w->p + w->len. The
+     * 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

data/vendor/libyeptris/src/yeptris/parse/engine.c

@@ -1207,10 +1207,18 @@ static yep_view e_resolve_tag_raw(yep_engine* e, yep_view tag) {
     if (tag.len == 1 && tag.p[0] == '!') {
         return tag;
     }
-    /* longest matching handle wins */
+    /* longest matching handle wins; a redefined PRIMARY ('%TAG ! ...')
+     * cannot capture a '!!'-led tag — the secondary handle resolves
+     * through its own entry or the fixed tag:yaml.org,2002: default
+     * (spec 6.8.2.2; libyaml: "%TAG ! !p/" + "!!i" is
+     * tag:yaml.org,2002:i, the nightly's round 52, crash-763bb852) */
+    int secondary = tag.len >= 2 && tag.p[0] == '!' && tag.p[1] == '!';
     int best = -1;
     uint32_t best_len = 0;
     for (int i = 0; i < e->tagmap_n; i++) {
+        if (secondary && e->tagmap[i].handle.len == 1) {
+            continue;
+        }
         if (tag.len >= e->tagmap[i].handle.len && e->tagmap[i].handle.len > best_len &&
             memcmp(tag.p, e->tagmap[i].handle.p, e->tagmap[i].handle.len) == 0) {
             best = i;

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.41.0
+  version: 0.6.43.0
 platform: powerpc64le-linux
 authors:
 - Ribose Inc.