yeptris 0.6.53.0-powerpc64le-linux → 0.6.55.1-powerpc64le-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f652f42d46c1ea6642ce221feec2ed9d0e1838e09454ca8c97cb9f17d2e1b05a
-  data.tar.gz: 2d22ac11686b416e0f910673b50be0549455ab3faf2f9f4228963ee121202011
+  metadata.gz: fe145d6313f44dbc27dea1123d2c2d22c0aedd1412e05a28ec0a4c122fb5f3fe
+  data.tar.gz: 01dbaf018c8b23fc223e20c62bae3e3fc3ae22696a3bcf96fccf78c13008f746
 SHA512:
-  metadata.gz: 753c7221e3e6d99d237e9e67008369426843040f8bfe2861936b35692e44b1749fe6af3cb1385ccbd4e8f08686ad16c45ed7f077a06693b0458042042926358f
-  data.tar.gz: 19bd51b1bb1edd73d17a053cbfdddcbd8a18c9ed055a6b191f328cef51e49ca656b9f0c1d49c62ad78f8274a0143b139301c232537c61c1766a0d3bce4642b7d
+  metadata.gz: 7297b661facad32bb5b26a3f26a25b3e98bbda7a490fad9114f325be56a6dc3f4cdf8bf4e399f7948c071f47ce4bfcb33c5c84602c686369de3bf6730b9c8493
+  data.tar.gz: c77ceaa8e7f7075162818d4af5ba183e842fd8ef3f047effea5fa97373e6c32f7c202faf1859b30529e33f11c0ab86e757c03d3b840d898a515e1416a2fd23e9

data/ext/yeptris_native/version.h

@@ -11,8 +11,8 @@
 
 #define YEPTRIS_VERSION_MAJOR 0
 #define YEPTRIS_VERSION_MINOR 6
-#define YEPTRIS_VERSION_PATCH 53
-#define YEPTRIS_VERSION_STRING "0.6.53"
+#define YEPTRIS_VERSION_PATCH 55
+#define YEPTRIS_VERSION_STRING "0.6.55"
 
 #ifdef __cplusplus
 extern "C" {

data/lib/yeptris/materializer.rb

@@ -320,6 +320,10 @@ module Yeptris
           target = merge_target.pop
           merge_into(target, done) if target
         when DOCUMENT_START
+          # anchors are per-document (the engine memo law; PyYAML's
+          # composer resets per document): a later document's alias
+          # must not resolve into an earlier one's name
+          anchors.clear
           docs.push(nil)
         end
         i += FIELDS

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.53.0".freeze
+  VERSION = "0.6.55.1".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.53
+    VERSION 0.6.55
     DESCRIPTION "Ultra-fast YAML 1.2 parser, emitter and streamer in C"
     LANGUAGES C CXX
 )

data/vendor/libyeptris/src/include/yeptris/events.h

@@ -105,8 +105,8 @@ typedef struct {
     uint8_t style;
     uint8_t flags;  /* YEPTRIS_EF_* */
     uint8_t tag_id; /* resolved implicit tag (YeptrisTagId, resolve.h) —
-                     * the typing SSOT, so hosts never re-scan. Uses the
-                     * struct's pad byte: sizeof stays 36 (ABI-pinned) */
+                     * the typing SSOT, so hosts never re-scan (the
+                     * struct is 44B, ABI-pinned; the bindings mirror it) */
     uint32_t line;
     uint32_t col;
     uint32_t end_line; /* #179: libyaml end_mark semantics (see the

data/vendor/libyeptris/src/yeptris/common/simd_text_avx2.c

@@ -92,7 +92,9 @@ static void yep_avx2_copy_count3(char* dst, const char* src, size_t len, char c0
         memcpy(dst + i, src + i, len - i);
     }
     size_t ta = 0, tb = 0, td = 0;
-    yep_text_count3_scalar(dst + i, len - i, c0, c1, c2, &ta, &tb, &td);
+    if (i < len) { /* NULL dst + 0 offset is still UB to form */
+        yep_text_count3_scalar(dst + i, len - i, c0, c1, c2, &ta, &tb, &td);
+    }
     *n0 = a + ta;
     *n1 = b + tb;
     *n2 = d + td;

data/vendor/libyeptris/src/yeptris/dom/ytape.c

@@ -590,6 +590,8 @@ void ytap_sink(yep_ytape* t, yep_sink* sink) {
     sink->on_scalar = yt_on_scalar;
     sink->on_block_open = yt_on_block_open;
     sink->on_block_item = yt_on_block_item;
+    sink->compose = 1; /* the tape replays into a DOM: the composer's
+                        * undefined-alias rejection stays at parse time */
 }
 
 /* ---- replay ---- */

data/vendor/libyeptris/src/yeptris/encoding/transcode.c

@@ -95,6 +95,15 @@ static int yep_transcode_utf16(const yep_allocator* sys, int big_endian, const u
 static int yep_transcode_utf32(const yep_allocator* sys, int big_endian, const unsigned char* src,
                                size_t len, unsigned char** out, size_t* out_len, size_t* err_pos) {
     size_t units = len / 4;
+    if (len % 4 != 0) {
+        /* a dangling final unit is an error, not a silent truncation
+         * (the UTF-16 twin rejects its own; the header contract says
+         * truncated units error at the offending byte) */
+        if (err_pos != NULL) {
+            *err_pos = units * 4;
+        }
+        return -2;
+    }
     unsigned char* dst = yep_alloc(sys, len ? len : 1);
     if (dst == NULL) {
         return -1;

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

@@ -29,8 +29,14 @@ void yep_rec_free(yep_rec_store* s) {
     yep_rec_init(s);
 }
 
-static uint32_t arena_put(yep_rec_store* s, const char* p, uint32_t len) {
+/* Returns 0 ok / -1 OOM. On OOM the record is NOT committed (the
+ * caller unwinds before s->n++): the old drop-the-string form left
+ * value_len set with offset 0, so materialize read whatever string
+ * lived at the arena head - or past a NULL arena on first-alloc
+ * failure. */
+static int arena_put(yep_rec_store* s, const char* p, uint32_t len, uint32_t* off) {
     if (len == 0 || p == NULL) {
+        *off = 0;
         return 0;
     }
     if (s->arena_len + len > s->arena_cap) {
@@ -40,15 +46,15 @@ static uint32_t arena_put(yep_rec_store* s, const char* p, uint32_t len) {
         }
         char* na = realloc(s->arena, cap);
         if (na == NULL) {
-            return 0; /* OOM: the string is dropped, not fatal */
+            return -1;
         }
         s->arena = na;
         s->arena_cap = cap;
     }
     memcpy(s->arena + s->arena_len, p, len);
-    uint32_t off = (uint32_t)s->arena_len;
+    *off = (uint32_t)s->arena_len;
     s->arena_len += len;
-    return off;
+    return 0;
 }
 
 int yep_rec_on_event(void* ctx, const yep_event* ev) {
@@ -116,11 +122,17 @@ int yep_rec_on_event(void* ctx, const yep_event* ev) {
     r->col = ev->col;
     r->end_line = ev->end_line;
     r->end_col = ev->end_col;
-    r->value_off = arena_put(s, (const char*)ev->value.p, (uint32_t)ev->value.len);
+    if (arena_put(s, (const char*)ev->value.p, (uint32_t)ev->value.len, &r->value_off) != 0) {
+        return -1;
+    }
     r->value_len = (uint32_t)ev->value.len;
-    r->anchor_off = arena_put(s, (const char*)ev->anchor.p, (uint32_t)ev->anchor.len);
+    if (arena_put(s, (const char*)ev->anchor.p, (uint32_t)ev->anchor.len, &r->anchor_off) != 0) {
+        return -1;
+    }
     r->anchor_len = (uint32_t)ev->anchor.len;
-    r->tag_off = arena_put(s, (const char*)ev->tag.p, (uint32_t)ev->tag.len);
+    if (arena_put(s, (const char*)ev->tag.p, (uint32_t)ev->tag.len, &r->tag_off) != 0) {
+        return -1;
+    }
     r->tag_len = (uint32_t)ev->tag.len;
     s->n++;
     return 0;

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

@@ -161,7 +161,7 @@ YEPTRIS_API const YeptrisEvent* yeptris_iterparse_next(YeptrisIterparse it, size
         yep_engine_destroy(eng);
         if (rc == -1) {
             it->done = 1;
-            it->status = YEPTRIS_ERROR_PARSE;
+            it->status = err != NULL ? YEPTRIS_ERROR_PARSE : YEPTRIS_ERROR_MEMORY;
             if (it->store.n == 0) {
                 if (!it->emitted_stream_start) {
                     /* the engine emitted +STR before failing: match it */

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

@@ -74,9 +74,13 @@ YEPTRIS_API YeptrisStatus yeptris_recorder_feed(YeptrisRecorder rec, const char*
         if (err != NULL) {
             rec->err_line = err->line;
             rec->err_col = err->col;
+            rec->status = YEPTRIS_ERROR_PARSE;
+        } else {
+            /* a clean error channel means the SINK failed: the capture
+             * ran out of memory, the bytes never were a parse error */
+            rec->status = YEPTRIS_ERROR_MEMORY;
         }
-        rec->final_fed = 1; /* a parse error kills the stream */
-        rec->status = YEPTRIS_ERROR_PARSE;
+        rec->final_fed = 1; /* a failed feed kills the stream */
         return rec->status;
     }
     rec->status = YEPTRIS_OK;

data/vendor/libyeptris/src/yeptris/memory/arena.c

@@ -85,6 +85,14 @@ void* yep_arena_alloc(yep_arena* arena, size_t size, size_t align) {
     if (arena == NULL || size == 0 || !yep_align_ok(align)) {
         return NULL;
     }
+    /* a hostile size near SIZE_MAX must FAIL the fit test, not wrap
+     * start+size past the pointer space and pass it (the sizing sums
+     * below stay inside the guard's slack) */
+    if (size > (SIZE_MAX - align) / 2) {
+        /* half the pointer space: both the fit test's start+size and
+         * the new-block payload sums stay wrap-free below this */
+        return NULL;
+    }
 
     yep_arena_block* b = arena->head;
     uintptr_t base = (uintptr_t)b + sizeof(yep_arena_block);

data/vendor/libyeptris/src/yeptris/memory/pool.c

@@ -43,6 +43,13 @@ void* yep_pool_alloc(yep_pool* pool, size_t size, size_t align) {
     if (pool == NULL || size == 0 || !yep_align_ok(align)) {
         return NULL;
     }
+    /* mirror of the arena guard: the fit test's start+size and the
+     * payload sums must not wrap on a hostile size */
+    if (size > (SIZE_MAX - align) / 2) {
+        /* half the pointer space: both the fit test's start+size and
+         * the new-block payload sums stay wrap-free below this */
+        return NULL;
+    }
 
     yep_block* b = pool->head;
     if (b == NULL) { /* the lazy first block (#157) */

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

@@ -1435,13 +1435,22 @@ static int e_alias(yep_engine* e, yep_event* ev) {
         return e_fail(e, YEP_ERR_UNEXPECTED, star);
     }
     uint32_t target = anchor_id_of(e, name);
-    if (target == 0 || (target <= e->anchor_serial && e->anchor_placed != NULL &&
-                        e->anchor_placed[target - 1] == 0)) {
+    /* libyaml's scanner/composer split: the scanner emits the ALIAS
+     * event for ANY name; the composer rejects what it cannot resolve
+     * ("found undefined alias"). Rejecting here unconditionally made
+     * event streams (recorder/pull/push) diverge from libyaml's for
+     * every dangling alias ({?\n:*c }, the nightly's r101), so the
+     * rejection rides the sink's compose bit: document builders (the
+     * DOM, the record tape) keep the parse-time error, event
+     * consumers carry the name for their host's resolution (the ruby
+     * materializer raises; the py loader does since this change too). */
+    if (e->sink != NULL && e->sink->compose &&
+        (target == 0 || (target <= e->anchor_serial && e->anchor_placed != NULL &&
+                         e->anchor_placed[target - 1] == 0))) {
         /* undefined, or defined-but-not-yet-placed: the props scan
          * registers the name before the anchor's node reaches the
          * output, so an alias here would precede its definition and
-         * the re-parse would reject the document (libyaml: "found
-         * undefined alias") */
+         * the re-parse would reject the document */
         e->pos = star;
         return e_fail(e, YEP_ERR_UNDEFINED_ALIAS, star);
     }

data/vendor/libyeptris/src/yeptris/parse/events.h

@@ -110,6 +110,13 @@ typedef struct yep_sink {
     int (*on_scalar)(void* ctx, const struct yep_view* value, const struct yep_view* tag,
                      const struct yep_view* anchor, uint32_t anchor_id, uint8_t tag_id,
                      uint8_t style, uint8_t implicit, uint8_t flow, int borrowed);
+    /* Document composers (libyaml's scanner/composer split): the
+     * scanner emits the ALIAS event for ANY name, while a sink that
+     * builds a document rejects an alias whose target is undefined or
+     * not yet placed ("found undefined alias"). Set for the DOM and
+     * record-tape routes; event consumers (recorder/pull/push) leave
+     * it 0 so their streams carry every alias like libyaml's. */
+    uint8_t compose;
 } yep_sink;
 
 /* Value facts for on_block_pair (the classified value classes the

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

@@ -410,7 +410,8 @@ engine_enter:
                           .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};
+                          .on_block_item = dom_on_block_item,
+                          .compose = 1};
     }
     int rc = 0;
     if (have_tape && !norm_kept_raw && ytap_flow_rooted(&yt) == 0) {

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

@@ -248,7 +248,8 @@ YEPTRIS_API YeptrisStatus yeptris_schema_load(const char* source, size_t len, Ye
                      .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};
+                     .on_block_item = dom_on_block_item,
+                     .compose = 1};
     if (eng == NULL || dom == NULL) {
         st = YEPTRIS_ERROR_MEMORY;
         goto out;

metadata

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