yeptris 0.6.16.2 → 0.6.18.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6b3f2406ea8b763cfa7bd0d0a36ea30ba7bb80c8322c6ebe5fd8300725e47d2
-  data.tar.gz: 9a500939ce7f65be9219acc0a44c62819ddd09f4f64486177065681b8490e686
+  metadata.gz: 658657a4f718471797ff0c61fea6a4549a990974827b6946a1246bbd8249b4a6
+  data.tar.gz: 6e3b1331c96a030091ce62ddf51b7a1a001fa137c45306441d9e19bca43d3d72
 SHA512:
-  metadata.gz: 6c4eeced42673cb9613462d239f6427bdb1190e14b0a733976e3bd9c17ee061a4fe7fb5f14ace52ea05242b186410570b8d44f1fc5bbc2ab2aacbcd65188d7ef
-  data.tar.gz: 5b84d8229ff419ab0c04fba154088775776ed5f70f4e6be5a9939e9b495e61ac82656a1bf0d7cbddbdf55ae9c1ba1912c44fc2af5b22e16d40a432e71009b185
+  metadata.gz: 9636825560b2ec8aebb29a42bccc9b25ce357d7e3800cc2f349bce9f0fa68d2934bfc7e545e8050c20d200b0d7301eda04c21d03787db86e4078948c824112cd
+  data.tar.gz: 56b6bc6ece08fe4dd01d4929a727527fbe4894f5d7d44aab0b35e8010b797309aef0cd375db13a59532f1e745c8afcb013bc9f1cd82869c6d1d98ccf36963d8e

data/ext/yeptris_native/cbor_ruby.c

@@ -25,102 +25,144 @@ static VALUE cr_key_str(const char* p, size_t len) {
     return rb_enc_interned_str(p, (long)len, cr_utf8_enc);
 }
 
+#include "cbor/sink.h"
 #include "dom/dom.h"
 #include "doc.h" /* the public YeptrisDocument wrapper: ->dom */
 #include <yeptris/cbor.h>
 #include <yeptris/dom.h>
 #include <yeptris/resolve.h>
 
-static const char* cr_view(const yep_dom* d, yep_sview sv, uint32_t* len) {
-    *len = sv.len;
-    if (sv.len == 0) {
-        return "";
-    }
-    return (sv.off & YEP_SV_INPUT) ? (d->str + (sv.off & YEP_SV_OFF)) : (d->input_base + sv.off);
+/* ---- the VALUE sink (#157): bytes -> VALUE in ONE pass ----
+ *
+ * The decode grammar drives; these callbacks build the same VALUEs
+ * the old DOM + cr_walk pair produced (verified by the binding's
+ * differential suite): nil/true/false by tag, ints via LL2NUM (the
+ * INT64_MIN text parity wart kept), floats via DBL2NUM (no
+ * text round trip), strings copied utf8 (byte strings today ride the
+ * same utf8 String), map keys interned (values never are).
+ *
+ * GC: the container stack is a Ruby array (every VALUE reachable);
+ * the input buffer is read directly, so decode runs with GC disabled
+ * (the caller's String may move otherwise — the #160 bus error). */
+
+struct rv_ctx {
+    VALUE stack; /* [.., container, (pending-key)?] */
+    VALUE root;  /* Qnil until the top item closes */
+};
+
+static VALUE rv_top(const struct rv_ctx* c) {
+    long n = RARRAY_LEN(c->stack);
+    return n > 0 ? rb_ary_entry(c->stack, n - 1) : Qnil;
 }
 
-static VALUE cr_scalar(const yep_dom* d, const yep_dnode* n) {
-    uint32_t len = 0;
-    const char* p = cr_view(d, n->value, &len);
-    switch (n->tag_id) {
-    case YEPTRIS_TAG_NULL:
-        return Qnil;
-    case YEPTRIS_TAG_BOOL:
-        if (len == 1) { /* Psych: "y"/"n" stay Strings */
-            return rb_utf8_str_new(p, len);
-        }
-        return (len == 4 && memcmp(p, "true", 4) == 0) ? Qtrue : Qfalse;
-    case YEPTRIS_TAG_INT: {
-        char buf[32];
-        size_t cp = len < sizeof(buf) - 1 ? len : sizeof(buf) - 1;
-        memcpy(buf, p, cp);
-        buf[cp] = '\0';
-        char* end = NULL;
-        long long v = strtoll(buf, &end, 10);
-        if (end != buf && *end == '\0' && end == buf + len && v > INT64_MIN) {
-            return LL2NUM(v);
-        }
-        return rb_utf8_str_new(p, len); /* int_or_string's fallback */
+static VALUE rv_attach(struct rv_ctx* c, VALUE v) {
+    VALUE top = rv_top(c);
+    if (RB_TYPE_P(top, T_ARRAY)) {
+        rb_ary_push(top, v);
+        return v;
     }
-    case YEPTRIS_TAG_FLOAT: {
-        char buf[64];
-        size_t cp = len < sizeof(buf) - 1 ? len : sizeof(buf) - 1;
-        memcpy(buf, p, cp);
-        buf[cp] = '\0';
-        char* end = NULL;
-        double v = strtod(buf, &end);
-        if (end != buf && end != buf + len) {
-            return rb_utf8_str_new(p, len); /* float_or_string's fallback */
-        }
-        return DBL2NUM(v);
+    if (RB_TYPE_P(top, T_HASH)) {
+        rb_ary_push(c->stack, v); /* becomes the pending key */
+        return v;
     }
-    default:
-        return rb_utf8_str_new(p, len);
+    /* a pending key: pop it, land v in the map */
+    VALUE k = rb_ary_pop(c->stack);
+    VALUE map = rv_top(c);
+    if (RB_TYPE_P(map, T_HASH)) {
+        rb_hash_aset(map, k, v);
+        return v;
     }
+    /* the stack emptied: v is the root */
+    c->root = v;
+    return v;
 }
 
-static VALUE cr_walk(const yep_dom* d, uint32_t id) {
-    const yep_dnode* n = &d->nodes[id];
-    switch (n->kind) {
-    case YEP_DOM_SCALAR:
-        return cr_scalar(d, n);
-    case YEP_DOM_SEQUENCE: {
-        long cnt = (long)n->count;
-        VALUE a = rb_ary_new_capa(cnt);
-        uint32_t c = n->first_child;
-        for (long i = 0; i < cnt && c != UINT32_MAX; i++) {
-            rb_ary_push(a, cr_walk(d, c));
-            c = d->nodes[c].next_sibling;
-        }
-        return a;
+static int rv_text(void* ctx, const char* s, uint32_t n, uint8_t tag_id, int is_key,
+                   const char* tag, uint32_t tag_len) {
+    (void)tag;
+    (void)tag_len;
+    struct rv_ctx* c = ctx;
+    VALUE v;
+    switch (tag_id) {
+    case YEPTRIS_TAG_NULL:
+        v = Qnil;
+        break;
+    case YEPTRIS_TAG_BOOL:
+        v = (n == 4 && memcmp(s, "true", 4) == 0) ? Qtrue : Qfalse;
+        break;
+    default: /* rendered text (diagnostics, simple(N), key ints) */
+        v = rb_utf8_str_new(s, (long)n);
+        break;
     }
-    case YEP_DOM_MAPPING: {
-        long pairs = (long)(n->count / 2);
-        VALUE h = HASH_NEW_CAPA(pairs);
-        uint32_t c = n->first_child;
-        for (long i = 0; i < pairs && c != UINT32_MAX; i++) {
-            VALUE k;
-            const yep_dnode* kn = &d->nodes[c];
-            if (kn->kind == YEP_DOM_SCALAR && kn->tag_id == YEPTRIS_TAG_STR) {
-                uint32_t klen = 0;
-                const char* kp = cr_view(d, kn->value, &klen);
-                k = cr_key_str(kp, klen);
-                c = kn->next_sibling;
-            } else {
-                k = cr_walk(d, c);
-                c = d->nodes[c].next_sibling;
-            }
-            VALUE v = (c != UINT32_MAX) ? cr_walk(d, c) : Qnil;
-            if (c != UINT32_MAX) {
-                c = d->nodes[c].next_sibling;
-            }
-            rb_hash_aset(h, k, v);
-        }
-        return h;
+    (void)is_key;
+    rv_attach(c, v);
+    return 1;
+}
+
+static int rv_int(void* ctx, int negative, uint64_t mag, int is_key, const char* tag,
+                  uint32_t tag_len) {
+    (void)tag;
+    (void)tag_len;
+    struct rv_ctx* c = ctx;
+    VALUE v;
+    if (negative && mag == (uint64_t)1 << 63) {
+        /* parity: the DOM path's strtoll guard renders INT64_MIN a
+         * String today; the differential suite pins it */
+        v = rb_utf8_str_new("-9223372036854775808", 20);
+    } else {
+        v = LL2NUM(negative ? -(int64_t)mag : (int64_t)mag);
     }
-    default: /* ALIAS: CBOR decode never produces one */
-        return Qnil;
+    rv_attach(c, v);
+    return 1;
+}
+
+static int rv_float(void* ctx, double dv, int is_key, const char* tag, uint32_t tag_len) {
+    (void)is_key;
+    (void)tag;
+    (void)tag_len;
+    rv_attach(ctx, DBL2NUM(dv));
+    return 1;
+}
+
+static int rv_str(void* ctx, const unsigned char* p, uint32_t n, int borrowed, int is_key,
+                  const char* tag, uint32_t tag_len) {
+    (void)borrowed;
+    (void)tag;
+    (void)tag_len;
+    struct rv_ctx* c = ctx;
+    VALUE v = is_key ? rb_enc_interned_str((const char*)p, (long)n, cr_utf8_enc)
+                     : rb_utf8_str_new((const char*)p, (long)n);
+    rv_attach(c, v);
+    return 1;
+}
+
+static int rv_bytes(void* ctx, const unsigned char* p, uint32_t n, int borrowed, int is_key,
+                    const char* tag, uint32_t tag_len) {
+    /* parity: byte strings ride the same utf8 String today */
+    return rv_str(ctx, p, n, borrowed, is_key, tag, tag_len);
+}
+
+static int rv_open(void* ctx, int is_map, uint64_t cap, const char* tag, uint32_t tag_len) {
+    (void)tag;
+    (void)tag_len;
+    struct rv_ctx* c = ctx;
+    VALUE v;
+    if (is_map) {
+        v = (cap != UINT64_MAX && cap / 2 <= 4096) ? HASH_NEW_CAPA((long)(cap / 2))
+                                                   : rb_hash_new();
+    } else {
+        v = (cap != UINT64_MAX && cap <= 8192) ? rb_ary_new_capa((long)cap) : rb_ary_new();
     }
+    rb_ary_push(c->stack, v);
+    return 1;
+}
+
+static int rv_close(void* ctx, int is_map) {
+    (void)is_map;
+    struct rv_ctx* c = ctx;
+    VALUE v = rb_ary_pop(c->stack);
+    rv_attach(c, v);
+    return 1;
 }
 
 VALUE yep_rb_cbor_load(const char* p, size_t len, int strict) {
@@ -128,27 +170,24 @@ VALUE yep_rb_cbor_load(const char* p, size_t len, int strict) {
         cr_utf8_enc = rb_utf8_encoding();
     }
     YeptrisStatus st = YEPTRIS_OK;
-    /* the DOM borrows the input buffer zero-copy; the walk ALLOCATES,
-     * and a GC compaction mid-walk moves the caller's String — the
-     * borrowed base dangles (the #160 CI bus error on 3.2/linux).
-     * Same discipline as the JSON walk: GC off across decode+walk */
+    /* the decoder reads the caller's buffer directly; GC off across
+     * the pass (a compaction would move the String under p — the
+     * #160 bus error) */
     VALUE gc_on = rb_gc_disable();
-    /* YeptrisDocument is a WRAPPER (doc.h) — ->dom is the tree; a raw
-     * yep_dom* cast read the wrapper's fields as the dom (the CI
-     * segfaults: docs at the wrong offset) */
-    yeptris_document* doc = (yeptris_document*)yeptris_cbor_decode(
-        p, len, strict ? YEPTRIS_CBOR_STRICT : 0, &st);
-    yep_dom* d = (doc != NULL) ? doc->dom : NULL;
-    if (d == NULL) {
-        if (RTEST(gc_on)) {
-            rb_gc_enable();
-        }
-        return Qundef;
-    }
-    VALUE v = (d->dcount > 0 && d->docs[0] != UINT32_MAX) ? cr_walk(d, d->docs[0]) : Qnil;
-    yeptris_document_free((YeptrisDocument)doc);
+    struct rv_ctx ctx;
+    ctx.stack = rb_ary_new();
+    ctx.root = Qnil;
+    static const yep_cbor_sink RV_SINK = {
+        NULL, rv_text, rv_int, rv_float, rv_str, rv_bytes, rv_open, rv_close,
+    };
+    yep_cbor_sink sink = RV_SINK;
+    sink.ctx = &ctx;
+    st = yep_cbor_decode_gen((const unsigned char*)p, len, strict, NULL, &sink);
     if (RTEST(gc_on)) {
         rb_gc_enable();
     }
-    return v;
+    if (st != YEPTRIS_OK) {
+        return Qundef;
+    }
+    return ctx.root;
 }

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.16.2".freeze
+  VERSION = "0.6.18.1".freeze
   # The error hierarchy lives in THIS file (the parent namespace's
   # own file): nested constants do not trigger a parent-constant
   # autoload, and the law forbids internal requires — defining the

data/vendor/libyeptris/CMakeLists.txt

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

data/vendor/libyeptris/src/yeptris/emit/float/floatint.h

@@ -23,10 +23,13 @@
 
 #include "emit/float/api.h"
 
-#if defined(__SIZEOF_INT128__)
+/* YEP_FLOAT_FORCE_LIMBS: test hook — exercises the portable lo/hi
+ * tier on hosts that also have __int128 (the limbs math is otherwise
+ * only compiled on 32-bit targets). */
+#if defined(__SIZEOF_INT128__) && !defined(YEP_FLOAT_FORCE_LIMBS) && !defined(YEP_FLOAT_FORCE_LIMBS)
 typedef unsigned __int128 yep_u128;
 #define YEP_MUL64(a, b) ((yep_u128)(uint64_t)(a) * (uint64_t)(b))
-#elif defined(_MSC_VER)
+#elif defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM64))
 #include <intrin.h>
 /* MSVC has no __int128: the lo/hi pair behind the SAME helper surface
  * (print.c's interval loop rides only these — no operator arithmetic
@@ -35,10 +38,17 @@ typedef struct {
     uint64_t lo, hi;
 } yep_u128;
 #define YEP_MUL64(a, b) yep_u128_mul64(a, b)
+#else
+/* Any compiler without __int128 (32-bit GCC/Clang, MSVC x86-32): the
+ * same lo/hi pair; multiplication via 32-bit limbs (below). */
+typedef struct {
+    uint64_t lo, hi;
+} yep_u128;
+#define YEP_MUL64(a, b) yep_u128_mul64(a, b)
 #endif
 
 static inline yep_u128 yep_u128_of(uint64_t v) {
-#if defined(__SIZEOF_INT128__)
+#if defined(__SIZEOF_INT128__) && !defined(YEP_FLOAT_FORCE_LIMBS)
     return (yep_u128)v;
 #else
     yep_u128 r = {v, 0};
@@ -47,7 +57,7 @@ static inline yep_u128 yep_u128_of(uint64_t v) {
 }
 
 static inline yep_u128 yep_u128_max(void) {
-#if defined(__SIZEOF_INT128__)
+#if defined(__SIZEOF_INT128__) && !defined(YEP_FLOAT_FORCE_LIMBS)
     return ~(yep_u128)0;
 #else
     yep_u128 r = {~(uint64_t)0, ~(uint64_t)0};
@@ -56,7 +66,7 @@ static inline yep_u128 yep_u128_max(void) {
 }
 
 static inline yep_u128 yep_u128_add(yep_u128 a, yep_u128 b) {
-#if defined(__SIZEOF_INT128__)
+#if defined(__SIZEOF_INT128__) && !defined(YEP_FLOAT_FORCE_LIMBS)
     return a + b;
 #else
     yep_u128 r;
@@ -67,7 +77,7 @@ static inline yep_u128 yep_u128_add(yep_u128 a, yep_u128 b) {
 }
 
 static inline yep_u128 yep_u128_sub(yep_u128 a, yep_u128 b) {
-#if defined(__SIZEOF_INT128__)
+#if defined(__SIZEOF_INT128__) && !defined(YEP_FLOAT_FORCE_LIMBS)
     return a - b;
 #else
     yep_u128 r;
@@ -79,7 +89,7 @@ static inline yep_u128 yep_u128_sub(yep_u128 a, yep_u128 b) {
 
 /* n < 128 */
 static inline yep_u128 yep_u128_shl(yep_u128 a, unsigned n) {
-#if defined(__SIZEOF_INT128__)
+#if defined(__SIZEOF_INT128__) && !defined(YEP_FLOAT_FORCE_LIMBS)
     return a << n;
 #else
     yep_u128 r = {0, 0};
@@ -98,7 +108,7 @@ static inline yep_u128 yep_u128_shl(yep_u128 a, unsigned n) {
 
 /* n < 128 */
 static inline yep_u128 yep_u128_shr(yep_u128 a, unsigned n) {
-#if defined(__SIZEOF_INT128__)
+#if defined(__SIZEOF_INT128__) && !defined(YEP_FLOAT_FORCE_LIMBS)
     return a >> n;
 #else
     yep_u128 r = {0, 0};
@@ -116,7 +126,7 @@ static inline yep_u128 yep_u128_shr(yep_u128 a, unsigned n) {
 }
 
 static inline int yep_u128_cmp(yep_u128 a, yep_u128 b) {
-#if defined(__SIZEOF_INT128__)
+#if defined(__SIZEOF_INT128__) && !defined(YEP_FLOAT_FORCE_LIMBS)
     return a < b ? -1 : (a > b ? 1 : 0);
 #else
     if (a.hi != b.hi) {
@@ -142,29 +152,47 @@ static inline yep_u128 yep_u128_mul64(uint64_t a, uint64_t b) {
     r.lo = a * b;
     return r;
 }
+#elif !defined(__SIZEOF_INT128__) || defined(YEP_FLOAT_FORCE_LIMBS)
+/* portable: 32-bit limbs, exact (the struct tier only) */
+static inline yep_u128 yep_u128_mul64(uint64_t a, uint64_t b) {
+    uint64_t a0 = (uint32_t)a, a1 = a >> 32;
+    uint64_t b0 = (uint32_t)b, b1 = b >> 32;
+    uint64_t ll = a0 * b0;
+    uint64_t lh = a0 * b1;
+    uint64_t hl = a1 * b0;
+    uint64_t mid = (ll >> 32) + (uint32_t)lh + (uint32_t)hl;
+    yep_u128 r;
+    r.lo = (mid << 32) | (uint32_t)ll;
+    r.hi = (a1 * b1) + (lh >> 32) + (hl >> 32) + (mid >> 32);
+    return r;
+}
 #endif
 
 /* x * 10 stays in range */
 static inline int yep_u128_fits10(yep_u128 x) {
-#if defined(__SIZEOF_INT128__)
+#if defined(__SIZEOF_INT128__) && !defined(YEP_FLOAT_FORCE_LIMBS)
     return x <= (~(yep_u128)0) / 10;
 #else
-    /* exact: hi*10 must not overflow 64 bits (with the lo carry) */
-    uint64_t hi_prod_hi = __umulh(x.hi, 10u);
-    uint64_t hi_prod_lo = x.hi * 10u;
-    uint64_t lo_carry = __umulh(x.lo, 10u);
-    return hi_prod_hi == 0 && hi_prod_lo + lo_carry >= hi_prod_lo;
+    /* exact: x*10 = (hi*10 << 64) + lo*10 — overflow iff hi*10
+     * escapes 64 bits or the lo-carry wraps the sum */
+    yep_u128 hp = YEP_MUL64(x.hi, 10u);
+    if (hp.hi != 0) {
+        return 0;
+    }
+    yep_u128 lp = YEP_MUL64(x.lo, 10u);
+    return hp.lo + lp.hi >= hp.lo;
 #endif
 }
 
 /* m small (< 2^32); caller guarantees no overflow (fits10 guarded) */
 static inline yep_u128 yep_u128_mul_small(yep_u128 a, uint32_t m) {
-#if defined(__SIZEOF_INT128__)
+#if defined(__SIZEOF_INT128__) && !defined(YEP_FLOAT_FORCE_LIMBS)
     return a * m;
 #else
     yep_u128 r;
-    r.lo = a.lo * m;
-    r.hi = a.hi * m + __umulh(a.lo, m);
+    yep_u128 lp = YEP_MUL64(a.lo, m);
+    r.lo = lp.lo;
+    r.hi = a.hi * m + lp.hi;
     return r;
 #endif
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.16.2
+  version: 0.6.18.1
 platform: ruby
 authors:
 - Ribose Inc.