yeptris 0.6.8.2-aarch64-linux → 0.6.9.2-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46a4f1d6dc8636db7110437e3afe0985f49152298c060fc73d4b02f5ed2e6abc
-  data.tar.gz: d92e8fde0b7426298944b1f924c399d5058b2617735d95a748efdf97cc185c27
+  metadata.gz: de9190cb1b45e6e54c7adf24792a90110c20c0bad9a6e2ef07bc028f1b8227e9
+  data.tar.gz: 389b84e8a518250c9f2d74bda218ed958fbb3c67678f2cf7272a3d71f2312d43
 SHA512:
-  metadata.gz: d4bc2b0bed370abc98f07715e7df696fd6f5516c483bb29f17caafcc073dda41fd5f60a4a4e3203626b53d040e05a79cba50032dafdbf3cf6257e3f9496ff58b
-  data.tar.gz: eec5e2d60e290339cf003ac2a7bc5b27a736ea48ac0f38c13161ec3f8fa008b85ead5b927c1f5799761ef674fb87467f05b0cb20584dc7dd8df573c75d716c6b
+  metadata.gz: 87ddaf244d1bb123e09fda719a3efe89e61fc6028928eae24044b9518a8c75376cfdc69451d3fd27692c760c26bd1f847200526b8517eefdafe7e745764cf761
+  data.tar.gz: 46e02cf83871371caee306ac22cc4ce51e76fe9f2f62a6e3346bbc58e0af9cdc1dec0b81bfa500d58ca5fa33dab7aa5996725713f08545ce6e3209d24ffc9db6

data/ext/yeptris_native/cbor_ruby.c

@@ -0,0 +1,134 @@
+/* cbor_ruby.c — CBOR decode → Ruby VALUE in one C pass (#157).
+ *
+ * The FFI ladder's CBOR.load pays decode + a Marshal emit/load round
+ * trip; this walks the decoded DOM directly, building the same VALUEs
+ * the materializer builds (tag-driven scalar semantics, insertion-
+ * order mappings), with no intermediate representation.
+ */
+#include <ruby.h>
+/* rb_hash_new_capa is Ruby 3.2+; older Rubies grow dynamically (the
+ * json_ruby.c guard, verbatim). */
+#if RUBY_API_VERSION_MAJOR > 3 || (RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR >= 2)
+#define HASH_NEW_CAPA(n) rb_hash_new_capa(n)
+#else
+#define HASH_NEW_CAPA(n) rb_hash_new()
+#endif
+#include <ruby/encoding.h>
+#include <stdlib.h>
+#include <string.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);
+}
+
+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 */
+    }
+    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);
+    }
+    default:
+        return rb_utf8_str_new(p, len);
+    }
+}
+
+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;
+    }
+    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 = 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;
+    }
+    default: /* ALIAS: CBOR decode never produces one */
+        return Qnil;
+    }
+}
+
+VALUE yep_rb_cbor_load(const char* p, size_t len, int strict) {
+    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 */
+    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);
+    if (RTEST(gc_on)) {
+        rb_gc_enable();
+    }
+    return v;
+}

data/ext/yeptris_native/yeptris_native.c

@@ -230,6 +230,7 @@ static const YeptrisVisitVTable k_vt = {
 
 /* fused JSON→Ruby (json_ruby.c) — no vtable, beats JSON.parse */
 VALUE yep_rb_parse_json(const char* p, size_t len, int strict_dup);
+VALUE yep_rb_cbor_load(const char* p, size_t len, int strict);
 
 static VALUE ctx_result(rb_ctx* c, YeptrisStatus st) {
     if (st != YEPTRIS_OK || c->failed) {
@@ -244,6 +245,18 @@ static VALUE ctx_result(rb_ctx* c, YeptrisStatus st) {
     return c->root;
 }
 
+static VALUE native_cbor_load(int argc, VALUE* argv, VALUE self) {
+    (void)self;
+    VALUE input, strict;
+    rb_scan_args(argc, argv, "11", &input, &strict);
+    StringValue(input);
+    VALUE v = yep_rb_cbor_load(RSTRING_PTR(input), (size_t)RSTRING_LEN(input), RTEST(strict));
+    if (v == Qundef) {
+        rb_raise(rb_path2class("Yeptris::ParseError"), "native cbor decode failed");
+    }
+    return v;
+}
+
 static VALUE native_load_json(int argc, VALUE* argv, VALUE self) {
     (void)self;
     VALUE input, strict;
@@ -415,6 +428,7 @@ RUBY_FUNC_EXPORTED void Init_native(void) {
     VALUE mYep = rb_define_module("Yeptris");
     VALUE mNat = rb_define_module_under(mYep, "Native");
     rb_define_singleton_method(mNat, "load_json", native_load_json, -1);
+    rb_define_singleton_method(mNat, "cbor_load", native_cbor_load, -1);
     rb_define_singleton_method(mNat, "load", native_load, 2);
     rb_define_singleton_method(mNat, "load_stream", native_load_stream, 2);
     rb_define_singleton_method(mNat, "gc_mode", native_gc_mode, 0);

data/lib/yeptris/cbor.rb

@@ -26,6 +26,13 @@ module Yeptris
     def load(data, strict: false)
       raise Error, "libyeptris has no CBOR support" unless available?
 
+      # #157: the native materializer (decode + direct VALUE
+      # construction in one C pass) when the extension is loaded;
+      # the FFI ladder otherwise
+      if defined?(::Yeptris::Native) && ::Yeptris::Native.respond_to?(:cbor_load)
+        return ::Yeptris::Native.cbor_load(data, strict)
+      end
+
       doc_ptr = ::Yeptris::FFI.yeptris_cbor_decode(data, data.bytesize, strict ? STRICT : 0, nil)
       raise ParseError, ::Yeptris::FFI.last_error_message if doc_ptr.null?
 

data/lib/yeptris/ffi.rb

@@ -66,10 +66,16 @@ module Yeptris
     # the caller's string (no arena copy, no second validating parse).
     # v2 records: numbers are spans at parse; yeptris_tape_convert
     # materializes them in one bulk call.
+    # v3 (libyeptris 0.6.9): the interleaved records (recs) are the
+    # primary storage on the lenient route; the strict route keeps the
+    # columns eager. The layout MUST mirror yeptris_json_tape — a stale
+    # layout makes C write past the FFI buffer (a silent heap overflow
+    # that only some allocators catch; the 0.6.9.1 windows crash).
     class JsonTape < ::FFI::Struct
       layout :count, :size_t, :kinds, :pointer, :offs, :pointer,
-             :lens, :pointer, :int_min, :int64, :_src, :pointer, :_srclen, :size_t,
-             :_block, :pointer
+             :lens, :pointer, :recs, :pointer, :_cols_ready, :int,
+             :_rec_primary, :int, :int_min, :int64, :_src, :pointer,
+             :_srclen, :size_t, :_block, :pointer
     end
 
     attach_function :yeptris_parse_json_tape, %i[pointer size_t pointer], :int

data/lib/yeptris/json.rb

@@ -24,6 +24,7 @@ module Yeptris
     # behavior — strictness follows it (issue #37, found by canon's
     # CI where json 3.0.0 resolved while the dev box had 2.x).
     require "json"
+    require "date" # place_obj's `when Date` — psych loads it elsewhere, JSON.dump must not depend on that
     STRICT_DUPLICATE_KEYS = Gem::Version.new(::JSON::VERSION) >= Gem::Version.new("3")
 
     module_function

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.8.2".freeze
+  VERSION = "0.6.9.2".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.8
+    VERSION 0.6.9
     DESCRIPTION "Ultra-fast YAML 1.2 parser, emitter and streamer in C"
     LANGUAGES C CXX
 )

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

@@ -46,15 +46,32 @@ enum {
                         spans; simdjson's deferred contract) */
 };
 
+/* The interleaved record (TODO.max-perf/07): one 8-byte store per
+ * token instead of three column stores. Layout: off:u32 | len:u23 |
+ * kind:u8 — a span longer than 0xFEFFFF bytes carries len == 0xFFFFFF
+ * with the true length stored as a CONT-terminated extension record
+ * (kind YEP_T_CONT; unreachable for <16 MiB tokens). The columns
+ * stay the compatibility ABI: yeptris_tape_columns materializes them
+ * lazily from the records on first touch. */
+#define YEP_T_CONT 8 /* record-length extension (not a token kind) */
+typedef uint64_t yeptris_tape_rec;
+
 typedef struct yeptris_json_tape {
     size_t count;
-    uint8_t* kinds;   /* yeptris tape kind per record */
-    uint32_t* offs;   /* span starts (STR/INT/FLOAT); container links */
-    uint32_t* lens;   /* span lengths (STR/INT/FLOAT) */
-    int64_t int_min;  /* set by yeptris_tape_convert when an INT span
-                         exceeds int64 (materialize-time discovery) */
-    const void* _src; /* the parsed buffer (spans borrow it; it must
-                         outlive the tape — same contract as the spans) */
+    uint8_t* kinds;         /* compat columns — materialized lazily (see
+                               yeptris_tape_columns) when the interleaved
+                               records are the primary storage */
+    uint32_t* offs;         /* span starts (STR/INT/FLOAT); container links */
+    uint32_t* lens;         /* span lengths (STR/INT/FLOAT) */
+    yeptris_tape_rec* recs; /* primary storage (may be NULL on legacy
+                               column-built tapes: the strict route) */
+    int _cols_ready;        /* columns materialized from recs already */
+    int _rec_primary;       /* the lenient route: recs carry the data and
+                               the columns are lazy */
+    int64_t int_min;        /* set by yeptris_tape_convert when an INT span
+                               exceeds int64 (materialize-time discovery) */
+    const void* _src;       /* the parsed buffer (spans borrow it; it must
+                               outlive the tape — same contract as the spans) */
     size_t _srclen;
     void* _block; /* the carved allocation base */
 } yeptris_json_tape;
@@ -89,6 +106,13 @@ YEPTRIS_API void yeptris_tape_free(yeptris_json_tape* tape);
  * number records converted, or SIZE_MAX if a span does not re-scan
  * as a number (impossible for a tape this library produced).
  * Sets t->int_min when an INT span exceeds int64. */
+/* Materializes the kinds/offs/lens columns from the interleaved
+ * records (no-op when the tape was built column-primary or the
+ * columns are already materialized). Consumers reading the column
+ * pointers directly (the FFI binding) must call this once first.
+ * Returns 0 on success, nonzero on allocation failure. */
+YEPTRIS_API int yeptris_tape_columns(yeptris_json_tape* t);
+
 YEPTRIS_API size_t yeptris_tape_convert(yeptris_json_tape* t, size_t from, size_t to,
                                         int64_t* ivals, double* dvals);
 

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

@@ -415,6 +415,9 @@ static yeptris_plan_result* plan_result_carve(const yeptris_plan* plan, size_t r
 
 YEPTRIS_API yeptris_plan_result*
 yeptris_tape_plan_walk(const yeptris_json_tape* tape, const yeptris_plan* plan, YeptrisStatus* st) {
+    /* item 07: the lenient tape's columns are lazy — materialize (a
+     * cache write through a const view; idempotent) */
+    yeptris_tape_columns((yeptris_json_tape*)tape);
     if (st != NULL) {
         *st = YEPTRIS_OK;
     }

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

@@ -59,7 +59,8 @@ static int rec_put(tape_ctx* c, uint8_t kind, uint32_t off, uint32_t len) {
 static YeptrisStatus tape_carve(yeptris_json_tape* t, size_t len) {
     size_t cap = len + 2;
     size_t off_o = (cap + 15) & ~(size_t)15;
-    char* block = yep_alloc(yep_system_allocator(), off_o + 2 * cap * sizeof(uint32_t));
+    char* block = yep_alloc(yep_system_allocator(),
+                            off_o + 2 * cap * sizeof(uint32_t) + cap * sizeof(yeptris_tape_rec));
     if (block == NULL) {
         return YEPTRIS_ERROR_MEMORY;
     }
@@ -67,11 +68,31 @@ static YeptrisStatus tape_carve(yeptris_json_tape* t, size_t len) {
     t->kinds = (uint8_t*)block;
     t->offs = (uint32_t*)(void*)(block + off_o);
     t->lens = t->offs + cap;
+    t->recs = (yeptris_tape_rec*)(void*)(t->lens + cap);
     t->count = 0;
     t->int_min = 0;
+    t->_rec_primary = 0;
+    t->_cols_ready = 0;
     return YEPTRIS_OK;
 }
 
+/* The lazy column materialization (TODO.max-perf/07): records are the
+ * primary storage on the lenient route; the column ABI materializes
+ * from them on first touch. */
+YEPTRIS_API int yeptris_tape_columns(yeptris_json_tape* t) {
+    if (t == NULL || !t->_rec_primary || t->recs == NULL || t->_cols_ready) {
+        return 0; /* column-primary (the strict route) or ready */
+    }
+    for (size_t i = 0; i < t->count; i++) {
+        yeptris_tape_rec r = t->recs[i];
+        t->lens[i] = (uint32_t)((r >> 8) & 0xFFFFFFu);
+        t->offs[i] = (uint32_t)(r >> 32);
+        t->kinds[i] = (uint8_t)(r & 0xFFu);
+    }
+    t->_cols_ready = 1;
+    return 0;
+}
+
 /* Scalar roots: the walk needs an opener, so a bare root value
  * converts through the same kernels. */
 static int tape_put_root_scalar(tape_ctx* c, const char* p, size_t len, size_t at) {
@@ -585,20 +606,18 @@ static YeptrisStatus tape_walk_lnt_fused(const char* p, size_t len, size_t open,
     if (tape_carve(t, len) != YEPTRIS_OK) {
         return YEPTRIS_ERROR_MEMORY;
     }
-    uint8_t* kinds = t->kinds;
-    uint32_t* offs = t->offs;
-    uint32_t* lens = t->lens;
+    /* the interleaved records are the primary storage (item 07); the
+     * columns materialize lazily via yeptris_tape_columns */
+    t->_rec_primary = 1;
+    yeptris_tape_rec* recs = t->recs;
     uint32_t open_at[YEP_JSON_WALK_DEPTH];
     uint8_t kind[YEP_JSON_WALK_DEPTH];
 
-    kinds[0] = YEP_T_DOC;
-    offs[0] = 0;
-    lens[0] = 0;
+    recs[0] = ((uint64_t)0 << 32) | ((uint64_t)0 << 8) | YEP_T_DOC;
 
     uint8_t top_kind = p[open] == '[' ? 0 : 1;
-    kinds[1] = top_kind ? YEP_T_MAP_OPEN : YEP_T_SEQ_OPEN;
-    offs[1] = 0;
-    lens[1] = 0;
+    recs[1] =
+        ((uint64_t)0 << 32) | ((uint64_t)0 << 8) | (top_kind ? YEP_T_MAP_OPEN : YEP_T_SEQ_OPEN);
     uint32_t top_open = 1;
     size_t count = 2;
     uint8_t top_expect = top_kind ? JW_KEY_OR_CLOSE : JW_VALUE_OR_CLOSE;
@@ -656,9 +675,8 @@ static YeptrisStatus tape_walk_lnt_fused(const char* p, size_t len, size_t open,
                 uint64_t c0 = (w - 0x2020202020202020ull) & ~w & 0x8080808080808080ull;
                 if (qm != 0 && ((bm | c0) & (qm - 1)) == 0) {
                     close = j + (size_t)yep_ctz64(qm) / 8;
-                    kinds[count] = YEP_T_STR;
-                    offs[count] = (uint32_t)j;
-                    lens[count] = (uint32_t)(close - j);
+                    recs[count] = ((uint64_t)((uint32_t)j) << 32) |
+                                  ((uint64_t)((uint32_t)(close - j)) << 8) | (uint64_t)(YEP_T_STR);
                     count++;
                     i = close + 1;
                     goto lstr_done;
@@ -668,9 +686,8 @@ static YeptrisStatus tape_walk_lnt_fused(const char* p, size_t len, size_t open,
             if (!yep_json_string(p, len, &i, &close, &esc)) {
                 goto lreject;
             }
-            kinds[count] = YEP_T_STR;
-            offs[count] = (uint32_t)(at + 1);
-            lens[count] = (uint32_t)(close - at - 1);
+            recs[count] = ((uint64_t)((uint32_t)(at + 1)) << 32) |
+                          ((uint64_t)((uint32_t)(close - at - 1)) << 8) | (uint64_t)(YEP_T_STR);
             count++;
         lstr_done:
             if (key_slot) {
@@ -698,9 +715,8 @@ static YeptrisStatus tape_walk_lnt_fused(const char* p, size_t len, size_t open,
                 }
                 break;
             }
-            kinds[count] = YEP_T_NUM;
-            offs[count] = (uint32_t)at;
-            lens[count] = (uint32_t)(i - at);
+            recs[count] = ((uint64_t)((uint32_t)at) << 32) | ((uint64_t)((uint32_t)(i - at)) << 8) |
+                          (uint64_t)(YEP_T_NUM);
             count++;
         lcomma:
             if (i < len && p[i] == ',') {
@@ -719,10 +735,11 @@ static YeptrisStatus tape_walk_lnt_fused(const char* p, size_t len, size_t open,
                  top_expect != JW_COMMA_OR_CLOSE)) {
                 goto lreject;
             }
-            kinds[count] = YEP_T_CLOSE;
-            offs[count] = top_open;
-            lens[count] = 0;
-            offs[top_open] = (uint32_t)count;
+            recs[count] = ((uint64_t)top_open << 32) | ((uint64_t)0 << 8) | YEP_T_CLOSE;
+            /* back-patch the opener's count link: keep the original
+             * off/len, set the link into the record's off word */
+            recs[top_open] = (recs[top_open] & ~(uint64_t)0xFFFFFFFF00000000u) |
+                             ((uint64_t)(uint32_t)count << 32);
             count++;
             i = at + 1;
             depth--;
@@ -745,9 +762,8 @@ static YeptrisStatus tape_walk_lnt_fused(const char* p, size_t len, size_t open,
             kind[depth - 1] = top_kind;
             open_at[depth - 1] = top_open;
             top_kind = c == '[' ? 0 : 1;
-            kinds[count] = c == '[' ? YEP_T_SEQ_OPEN : YEP_T_MAP_OPEN;
-            offs[count] = 0;
-            lens[count] = 0;
+            recs[count] = ((uint64_t)0 << 32) | ((uint64_t)0 << 8) |
+                          (uint64_t)(c == '[' ? YEP_T_SEQ_OPEN : YEP_T_MAP_OPEN);
             top_open = (uint32_t)count;
             count++;
             top_expect = top_kind ? JW_KEY_OR_CLOSE : JW_VALUE_OR_CLOSE;
@@ -778,9 +794,8 @@ static YeptrisStatus tape_walk_lnt_fused(const char* p, size_t len, size_t open,
                     goto lreject;
                 }
             }
-            kinds[count] = c == 'n' ? YEP_T_NULL : (c == 't' ? YEP_T_TRUE : YEP_T_FALSE);
-            offs[count] = (uint32_t)at;
-            lens[count] = (uint32_t)wl;
+            recs[count] = ((uint64_t)((uint32_t)at) << 32) | ((uint64_t)((uint32_t)wl) << 8) |
+                          (uint64_t)(c == 'n' ? YEP_T_NULL : (c == 't' ? YEP_T_TRUE : YEP_T_FALSE));
             count++;
             i = at + wl;
             goto lcomma;
@@ -1244,6 +1259,7 @@ YEPTRIS_API YeptrisStatus yeptris_parse_json_tape(const char* source, size_t len
 
 YEPTRIS_API size_t yeptris_tape_convert(yeptris_json_tape* t, size_t from, size_t to,
                                         int64_t* ivals, double* dvals) {
+    yeptris_tape_columns(t);
     if (t == NULL || t->_src == NULL || from > to || to > t->count) {
         return SIZE_MAX;
     }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.8.2
+  version: 0.6.9.2
 platform: aarch64-linux
 authors:
 - Ribose Inc.
@@ -36,6 +36,7 @@ files:
 - README.adoc
 - ext/build_windows_native.rb
 - ext/libyeptris/extconf.rb
+- ext/yeptris_native/cbor_ruby.c
 - ext/yeptris_native/extconf.rb
 - ext/yeptris_native/json_ruby.c
 - ext/yeptris_native/yeptris_native.c