yeptris 0.6.17.1-powerpc64le-linux → 0.6.18.2-powerpc64le-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36cb17a206c740954fafe1ce7b1fcbb6f94a47179e22beeee390498d20b1d07f
-  data.tar.gz: 8db951649c7030a30d94fdbba0778fefef872d222ed479a83d459a1c0a36cfd9
+  metadata.gz: acff06db51e1b2f75561cdf73ea0e73555687c81fbcd347cc622ac0ec6b68fd5
+  data.tar.gz: dd5ebf0312542655c8f85c25426746310e1acfd362a88ce0facde164a7690928
 SHA512:
-  metadata.gz: 19b0c83147c2c5f0882efb9bc32bedd6be9c7c8d80b50c86b985f36ddc6fe0d051b31c7a0795ee9340cf47dab64825072d0012d1dede882ad8497f24dbb45e85
-  data.tar.gz: 3146be4e5e094c747fa2bb0335bba6bf35a7fdee4190428d6883341f8003f472a50505e63d60c6ba59428031e7204cb70f64a1e169d2dc1932abc0604c3bc06a
+  metadata.gz: 9cb10bafe45359a09efd903970613995b1665a6aa6137c1a5f8d1cd3b6d13cea142a01ac2061892e3d3ebcc1c003c17c9153aeddc54f196ced37f0ec3ef8eb46
+  data.tar.gz: 625deef05e540b5dfc35d73943324cf62f3fbf59a617d515dcf0499b8ef6950197c2907345dfa14083457a12299b954c93c64cc8f11f609856765c293fcd8b0e

data/lib/yeptris/cbor.rb

@@ -121,7 +121,7 @@ module Yeptris
     def take_buffer(ptr, len_ptr)
       raise UnencodableError, ::Yeptris::FFI.last_error_message if ptr.null?
 
-      len = len_ptr.read_uint64
+      len = Yeptris::FFI.read_c_size_t(len_ptr)
       ptr.read_bytes(len).force_encoding(Encoding::BINARY)
     ensure
       ::Yeptris::FFI.yeptris_free(ptr) if ptr && !ptr.null?

data/lib/yeptris/document.rb

@@ -164,7 +164,7 @@ class Yeptris::Document
 
   def serialize(canonical: false, best_width: 0, explicit_doc_start: false)
     ensure_alive!
-    len = ::FFI::MemoryPointer.new(:uint64)
+    len = ::FFI::MemoryPointer.new(:size_t)
     ptr =
       if canonical || best_width.positive? || explicit_doc_start
         opts = Yeptris::FFI::EmitOptions.new
@@ -180,13 +180,13 @@ class Yeptris::Document
   end
 
   def serialize_json_compact
-    len = ::FFI::MemoryPointer.new(:uint64)
+    len = ::FFI::MemoryPointer.new(:size_t)
     Yeptris::FFI::Owned.string(Yeptris::FFI.yeptris_serialize_json_ex(@c_ptr, len, 1), len)
   end
 
   def serialize_json
     ensure_alive!
-    len = ::FFI::MemoryPointer.new(:uint64)
+    len = ::FFI::MemoryPointer.new(:size_t)
     Yeptris::FFI::Owned.string(Yeptris::FFI.yeptris_serialize_json(@c_ptr, len), len)
   end
 

data/lib/yeptris/ffi.rb

@@ -301,6 +301,17 @@ module Yeptris
       end
     end
 
+    # C out-params are size_t — native width (8 everywhere we ship
+    # except ILP32 armv7, where it is 4). The ffi gem (1.17.4) has no
+    # read_size_t, so dispatch on the measured type size: read_uint64
+    # on a 4-byte :size_t buffer ran out of bounds on arm-linux (the
+    # 0.6.18.1 armv7 smoke, valueml.rb:118).
+    SIZE_T_WIDTH = ::FFI.type_size(:size_t)
+
+    def self.read_c_size_t(ptr)
+      SIZE_T_WIDTH == 8 ? ptr.read_uint64 : ptr.read_uint32
+    end
+
     module Owned
       module_function
 
@@ -310,7 +321,7 @@ module Yeptris
       def string(ptr, len_out = nil)
         return nil if ptr.null?
 
-        len = len_out&.read_uint64
+        len = len_out && Yeptris::FFI.read_c_size_t(len_out)
         s = if len && len > 0
               ptr.read_bytes(len).force_encoding(Encoding::UTF_8)
             else

data/lib/yeptris/materializer.rb

@@ -78,10 +78,10 @@ module Yeptris
           end
           count_p = ::FFI::MemoryPointer.new(:size_t)
           records = Yeptris::FFI.yeptris_recorder_records(rec, count_p)
-          count = count_p.read_uint64
+          count = Yeptris::FFI.read_c_size_t(count_p)
           arena_len = ::FFI::MemoryPointer.new(:size_t)
           arena_ptr = Yeptris::FFI.yeptris_recorder_arena(rec, arena_len)
-          arena_len_v = arena_len.read_uint64
+          arena_len_v = Yeptris::FFI.read_c_size_t(arena_len)
           arena = arena_ptr.null? || arena_len_v.zero? ? +"" : arena_ptr.read_bytes(arena_len_v)
           flat = records.read_bytes(count * RECORD_SIZE)
                      .unpack(RECORD_UNPACK * count)

data/lib/yeptris/node.rb

@@ -50,11 +50,11 @@ class Yeptris::Node
 
   # Scalar content / alias name (UTF-8 String), nil for collections.
   def value
-    len = ::FFI::MemoryPointer.new(:uint64)
+    len = ::FFI::MemoryPointer.new(:size_t)
     ptr = alive { Yeptris::FFI.yeptris_node_value(@c_ptr, len) }
     return nil if ptr.null?
 
-    ptr.read_bytes(len.read_uint64).force_encoding(Encoding::UTF_8)
+    ptr.read_bytes(Yeptris::FFI.read_c_size_t(len)).force_encoding(Encoding::UTF_8)
   end
 
   STYLES = {
@@ -71,19 +71,19 @@ class Yeptris::Node
 
   # Explicit tag URI when present, else nil.
   def tag
-    len = ::FFI::MemoryPointer.new(:uint64)
+    len = ::FFI::MemoryPointer.new(:size_t)
     ptr = alive { Yeptris::FFI.yeptris_node_tag(@c_ptr, len) }
     return nil if ptr.null?
 
-    ptr.read_bytes(len.read_uint64).force_encoding(Encoding::UTF_8)
+    ptr.read_bytes(Yeptris::FFI.read_c_size_t(len)).force_encoding(Encoding::UTF_8)
   end
 
   def anchor
-    len = ::FFI::MemoryPointer.new(:uint64)
+    len = ::FFI::MemoryPointer.new(:size_t)
     ptr = alive { Yeptris::FFI.yeptris_node_anchor(@c_ptr, len) }
     return nil if ptr.null?
 
-    ptr.read_bytes(len.read_uint64).force_encoding(Encoding::UTF_8)
+    ptr.read_bytes(Yeptris::FFI.read_c_size_t(len)).force_encoding(Encoding::UTF_8)
   end
 
   def alias_target
@@ -293,7 +293,7 @@ class Yeptris::Node
     elsif st != Yeptris::FFI::OK
       raise Yeptris::ParseError, Yeptris::FFI.last_error_message
     else
-      bytes = out_p.read_pointer.read_bytes(olen_p.read_uint64)
+      bytes = out_p.read_pointer.read_bytes(Yeptris::FFI.read_c_size_t(olen_p))
       bytes.force_encoding(Encoding::ASCII_8BIT)
       ::Marshal.load(bytes)
     end

data/lib/yeptris/valueml.rb

@@ -38,9 +38,9 @@ module Yeptris
       yaml = Yeptris.read_input(yaml)
       yaml = yaml.to_s
       vals_p = ::FFI::MemoryPointer.new(:pointer)
-      count_p = ::FFI::MemoryPointer.new(:uint64)
+      count_p = ::FFI::MemoryPointer.new(:size_t)
       arena_p = ::FFI::MemoryPointer.new(:pointer)
-      alen_p = ::FFI::MemoryPointer.new(:uint64)
+      alen_p = ::FFI::MemoryPointer.new(:size_t)
       st = FFI.yeptris_value_drain(
         yaml, yaml.bytesize,
         schema == :compat_11 ? FFI::SCHEMA_11_COMPAT : FFI::SCHEMA_12_CORE,
@@ -51,9 +51,9 @@ module Yeptris
       vals = vals_p.read_pointer
       arena = arena_p.read_pointer
       begin
-        count = count_p.read_uint64
+        count = Yeptris::FFI.read_c_size_t(count_p)
         flat = vals.read_bytes(count * VALUE_SIZE).unpack(UNPACK * count)
-        arena_bytes = arena.read_bytes(alen_p.read_uint64)
+        arena_bytes = arena.read_bytes(Yeptris::FFI.read_c_size_t(alen_p))
         arena_bytes.force_encoding(Encoding::UTF_8)
         walk(flat, arena_bytes, schema == :compat_11)
       ensure
@@ -115,7 +115,7 @@ module Yeptris
       return nil if st == FFI::ERROR_UNSUPPORTED
       raise ParseError, FFI.last_error_message if st != FFI::OK
       buf = out_p.read_pointer
-      len = olen_p.read_uint64
+      len = Yeptris::FFI.read_c_size_t(olen_p)
       bytes = buf.read_bytes(len)
       bytes.force_encoding(Encoding::ASCII_8BIT)
       ::Marshal.load(bytes)

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.17.1".freeze
+  VERSION = "0.6.18.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.17
+    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.17.1
+  version: 0.6.18.2
 platform: powerpc64le-linux
 authors:
 - Ribose Inc.