cloudsmith-api 2.0.22 → 2.0.23

data/vendor/bundle/ruby/2.6.0/gems/{bigdecimal-3.2.3 → bigdecimal-4.0.1}/lib/bigdecimal/newton.rb

@@ -2,6 +2,8 @@
 require "bigdecimal/ludcmp"
 require "bigdecimal/jacobian"
 
+warn "'bigdecimal/newton' is deprecated and will be removed in a future release."
+
 #
 # newton.rb
 #

data/vendor/bundle/ruby/2.6.0/gems/{bigdecimal-3.2.3 → bigdecimal-4.0.1}/lib/bigdecimal/util.rb

@@ -119,8 +119,11 @@ class Rational < Numeric
   #
   # Returns the value as a BigDecimal.
   #
-  # The required +precision+ parameter is used to determine the number of
-  # significant digits for the result.
+  # The +precision+ parameter is used to determine the number of
+  # significant digits for the result. When +precision+ is set to +0+,
+  # the number of digits to represent the float being converted is determined
+  # automatically.
+  # The default +precision+ is +0+.
   #
   #     require 'bigdecimal'
   #     require 'bigdecimal/util'
@@ -129,7 +132,7 @@ class Rational < Numeric
   #
   # See also Kernel.BigDecimal.
   #
-  def to_d(precision)
+  def to_d(precision=0)
     BigDecimal(self, precision)
   end
 end
@@ -141,29 +144,27 @@ class Complex < Numeric
   #     cmp.to_d(precision)  -> bigdecimal
   #
   # Returns the value as a BigDecimal.
+  # If the imaginary part is not +0+, an error is raised
   #
-  # The +precision+ parameter is required for a rational complex number.
-  # This parameter is used to determine the number of significant digits
-  # for the result.
+  # The +precision+ parameter is used to determine the number of
+  # significant digits for the result. When +precision+ is set to +0+,
+  # the number of digits to represent the float being converted is determined
+  # automatically.
+  # The default +precision+ is +0+.
   #
   #     require 'bigdecimal'
   #     require 'bigdecimal/util'
   #
   #     Complex(0.1234567, 0).to_d(4)   # => 0.1235e0
   #     Complex(Rational(22, 7), 0).to_d(3)   # => 0.314e1
+  #     Complex(1, 1).to_d   # raises ArgumentError
   #
   # See also Kernel.BigDecimal.
   #
-  def to_d(*args)
+  def to_d(precision=0)
     BigDecimal(self) unless self.imag.zero? # to raise error
 
-    if args.length == 0
-      case self.real
-      when Rational
-        BigDecimal(self.real) # to raise error
-      end
-    end
-    self.real.to_d(*args)
+    BigDecimal(self.real, precision)
   end
 end
 

data/vendor/bundle/ruby/2.6.0/gems/{bigdecimal-3.2.3 → bigdecimal-4.0.1}/lib/bigdecimal.rb

@@ -1,6 +1,11 @@
 if RUBY_ENGINE == 'jruby'
   JRuby::Util.load_ext("org.jruby.ext.bigdecimal.BigDecimalLibrary")
-  return
+
+  class BigDecimal
+    def _decimal_shift(i) # :nodoc:
+      to_java.move_point_right(i).to_d
+    end
+  end
 else
   require 'bigdecimal.so'
 end
@@ -15,20 +20,31 @@ class BigDecimal
       when BigDecimal
         return x
       when Integer, Float
-        return BigDecimal(x)
+        return BigDecimal(x, 0)
       when Rational
         return BigDecimal(x, [prec, 2 * BigDecimal.double_fig].max)
       end
       raise ArgumentError, "#{x.inspect} can't be coerced into BigDecimal"
     end
 
-    def self.validate_prec(prec, method_name, accept_zero: false) # :nodoc:
-      raise ArgumentError, 'precision must be an Integer' unless Integer === prec
+    def self.coerce_validate_prec(prec, method_name, accept_zero: false) # :nodoc:
+      unless Integer === prec
+        original = prec
+        # Emulate Integer.try_convert for ruby < 3.1
+        if prec.respond_to?(:to_int)
+          prec = prec.to_int
+        else
+          raise TypeError, "no implicit conversion of #{original.class} into Integer"
+        end
+        raise TypeError, "can't convert #{original.class} to Integer" unless Integer === prec
+      end
+
       if accept_zero
         raise ArgumentError, "Negative precision for #{method_name}" if prec < 0
       else
         raise ArgumentError, "Zero or negative precision for #{method_name}" if prec <= 0
       end
+      prec
     end
 
     def self.infinity_computation_result # :nodoc:
@@ -78,10 +94,10 @@ class BigDecimal
   #
   # Also available as the operator **.
   #
-  def power(y, prec = nil)
-    Internal.validate_prec(prec, :power) if prec
+  def power(y, prec = 0)
+    prec = Internal.coerce_validate_prec(prec, :power, accept_zero: true)
     x = self
-    y = Internal.coerce_to_bigdecimal(y, prec || n_significant_digits, :power)
+    y = Internal.coerce_to_bigdecimal(y, prec.nonzero? || n_significant_digits, :power)
 
     return Internal.nan_computation_result if x.nan? || y.nan?
     return BigDecimal(1) if y.zero?
@@ -128,10 +144,10 @@ class BigDecimal
       return BigDecimal(1)
     end
 
-    prec ||= BigDecimal.limit.nonzero?
+    limit = BigDecimal.limit
     frac_part = y.frac
 
-    if frac_part.zero? && !prec
+    if frac_part.zero? && prec.zero? && limit.zero?
       # Infinite precision calculation for `x ** int` and `x.power(int)`
       int_part = y.fix.to_i
       int_part = -int_part if (neg = int_part < 0)
@@ -151,31 +167,42 @@ class BigDecimal
       return neg ? BigDecimal(1) / ans : ans
     end
 
-    prec ||= [x.n_significant_digits, y.n_significant_digits, BigDecimal.double_fig].max + BigDecimal.double_fig
+    result_prec = prec.nonzero? || [x.n_significant_digits, y.n_significant_digits, BigDecimal.double_fig].max + BigDecimal.double_fig
+    result_prec = [result_prec, limit].min if prec.zero? && limit.nonzero?
+
+    prec2 = result_prec + BigDecimal.double_fig
 
     if y < 0
-      inv = x.power(-y, prec)
+      inv = x.power(-y, prec2)
       return BigDecimal(0) if inv.infinite?
       return BigDecimal::Internal.infinity_computation_result if inv.zero?
-      return BigDecimal(1).div(inv, prec)
+      return BigDecimal(1).div(inv, result_prec)
     end
 
-    int_part = y.fix.to_i
-    prec2 = prec + BigDecimal.double_fig
-    pow_prec = prec2 + (int_part > 0 ? y.exponent : 0)
-    ans = BigDecimal(1)
-    n = 1
-    xn = x
-    while true
-      ans = ans.mult(xn, pow_prec) if int_part.allbits?(n)
-      n <<= 1
-      break if n > int_part
-      xn = xn.mult(xn, pow_prec)
-    end
-    unless frac_part.zero?
-      ans = ans.mult(BigMath.exp(BigMath.log(x, prec2).mult(frac_part, prec2), prec2), prec2)
+    if frac_part.zero? && y.exponent < Math.log(result_prec) * 5 + 20
+      # Use exponentiation by squaring if y is an integer and not too large
+      pow_prec = prec2 + y.exponent
+      n = 1
+      xn = x
+      ans = BigDecimal(1)
+      int_part = y.fix.to_i
+      while true
+        ans = ans.mult(xn, pow_prec) if int_part.allbits?(n)
+        n <<= 1
+        break if n > int_part
+        xn = xn.mult(xn, pow_prec)
+      end
+      ans.mult(1, result_prec)
+    else
+      if x > 1 && x.finite?
+        # To calculate exp(z, prec), z needs prec+max(z.exponent, 0) precision if z > 0.
+        # Estimate (y*log(x)).exponent
+        logx_exponent = x < 2 ? (x - 1).exponent : Math.log10(x.exponent).round
+        ylogx_exponent = y.exponent + logx_exponent
+        prec2 += [ylogx_exponent, 0].max
+      end
+      BigMath.exp(BigMath.log(x, prec2).mult(y, prec2), result_prec)
     end
-    ans.mult(1, prec)
   end
 
   # Returns the square root of the value.
@@ -183,36 +210,35 @@ class BigDecimal
   # Result has at least prec significant digits.
   #
   def sqrt(prec)
-    Internal.validate_prec(prec, :sqrt, accept_zero: true)
+    prec = Internal.coerce_validate_prec(prec, :sqrt, accept_zero: true)
     return Internal.infinity_computation_result if infinite? == 1
 
     raise FloatDomainError, 'sqrt of negative value' if self < 0
     raise FloatDomainError, "sqrt of 'NaN'(Not a Number)" if nan?
     return self if zero?
 
-    limit = BigDecimal.limit.nonzero? if prec == 0
-
-    # BigDecimal#sqrt calculates at least n_significant_digits precision.
-    # This feature maybe problematic for some cases.
-    n_digits = n_significant_digits
-    prec = [prec, n_digits].max
+    if prec == 0
+      limit = BigDecimal.limit
+      prec = n_significant_digits + BigDecimal.double_fig
+      prec = [limit, prec].min if limit.nonzero?
+    end
 
     ex = exponent / 2
     x = _decimal_shift(-2 * ex)
-    y = BigDecimal(Math.sqrt(x.to_f))
+    y = BigDecimal(Math.sqrt(x.to_f), 0)
     precs = [prec + BigDecimal.double_fig]
     precs << 2 + precs.last / 2 while precs.last > BigDecimal.double_fig
     precs.reverse_each do |p|
       y = y.add(x.div(y, p), p).div(2, p)
     end
-    y = y.mult(1, limit) if limit
-    y._decimal_shift(ex)
+    y._decimal_shift(ex).mult(1, prec)
   end
 end
 
 # Core BigMath methods for BigDecimal (log, exp) are defined here.
 # Other methods (sin, cos, atan) are defined in 'bigdecimal/math.rb'.
 module BigMath
+  module_function
 
   # call-seq:
   #   BigMath.log(decimal, numeric)    -> BigDecimal
@@ -226,62 +252,73 @@ module BigMath
   #
   # If +decimal+ is NaN, returns NaN.
   #
-  def self.log(x, prec)
-    BigDecimal::Internal.validate_prec(prec, :log)
+  def log(x, prec)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :log)
     raise Math::DomainError, 'Complex argument for BigMath.log' if Complex === x
 
     x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :log)
     return BigDecimal::Internal.nan_computation_result if x.nan?
-    raise Math::DomainError, 'Zero or negative argument for log' if x <= 0
+    raise Math::DomainError, 'Negative argument for log' if x < 0
+    return -BigDecimal::Internal.infinity_computation_result if x.zero?
     return BigDecimal::Internal.infinity_computation_result if x.infinite?
     return BigDecimal(0) if x == 1
 
+    prec2 = prec + BigDecimal.double_fig
     BigDecimal.save_limit do
       BigDecimal.limit(0)
       if x > 10 || x < 0.1
-        log10 = log(BigDecimal(10), prec)
+        log10 = log(BigDecimal(10), prec2)
         exponent = x.exponent
         x = x._decimal_shift(-exponent)
         if x < 0.3
           x *= 10
           exponent -= 1
         end
-        return log10 * exponent + log(x, prec)
+        return (log10 * exponent).add(log(x, prec2), prec)
       end
 
       x_minus_one_exponent = (x - 1).exponent
-      prec += BigDecimal.double_fig
 
       # log(x) = log(sqrt(sqrt(sqrt(sqrt(x))))) * 2**sqrt_steps
-      sqrt_steps = [Integer.sqrt(prec) + 3 * x_minus_one_exponent, 0].max
+      sqrt_steps = [Integer.sqrt(prec2) + 3 * x_minus_one_exponent, 0].max
 
       lg2 = 0.3010299956639812
-      prec2 = prec + [-x_minus_one_exponent, 0].max + (sqrt_steps * lg2).ceil
+      sqrt_prec = prec2 + [-x_minus_one_exponent, 0].max + (sqrt_steps * lg2).ceil
 
       sqrt_steps.times do
-        x = x.sqrt(prec2)
-
-        # Workaround for https://github.com/ruby/bigdecimal/issues/354
-        x = x.mult(1, prec2 + BigDecimal.double_fig)
+        x = x.sqrt(sqrt_prec)
       end
 
       # Taylor series for log(x) around 1
       # log(x) = -log((1 + X) / (1 - X)) where X = (x - 1) / (x + 1)
       # log(x) = 2 * (X + X**3 / 3 + X**5 / 5 + X**7 / 7 + ...)
-      x = (x - 1).div(x + 1, prec2)
+      x = (x - 1).div(x + 1, sqrt_prec)
       y = x
-      x2 = x.mult(x, prec)
+      x2 = x.mult(x, prec2)
       1.step do |i|
-        n = prec + x.exponent - y.exponent + x2.exponent
+        n = prec2 + x.exponent - y.exponent + x2.exponent
         break if n <= 0 || x.zero?
         x = x.mult(x2.round(n - x2.exponent), n)
-        y = y.add(x.div(2 * i + 1, n), prec)
+        y = y.add(x.div(2 * i + 1, n), prec2)
       end
 
       y.mult(2 ** (sqrt_steps + 1), prec)
     end
   end
 
+  # Taylor series for exp(x) around 0
+  private_class_method def _exp_taylor(x, prec) # :nodoc:
+    xn = BigDecimal(1)
+    y = BigDecimal(1)
+    1.step do |i|
+      n = prec + xn.exponent
+      break if n <= 0 || xn.zero?
+      xn = xn.mult(x, n).div(i, n)
+      y = y.add(xn, prec)
+    end
+    y
+  end
+
   # call-seq:
   #   BigMath.exp(decimal, numeric)    -> BigDecimal
   #
@@ -292,29 +329,23 @@ module BigMath
   #
   # If +decimal+ is NaN, returns NaN.
   #
-  def self.exp(x, prec)
-    BigDecimal::Internal.validate_prec(prec, :exp)
+  def exp(x, prec)
+    prec = BigDecimal::Internal.coerce_validate_prec(prec, :exp)
     x = BigDecimal::Internal.coerce_to_bigdecimal(x, prec, :exp)
     return BigDecimal::Internal.nan_computation_result if x.nan?
     return x.positive? ? BigDecimal::Internal.infinity_computation_result : BigDecimal(0) if x.infinite?
     return BigDecimal(1) if x.zero?
-    return BigDecimal(1).div(exp(-x, prec), prec) if x < 0
 
     # exp(x * 10**cnt) = exp(x)**(10**cnt)
-    cnt = x > 1 ? x.exponent : 0
+    cnt = x < -1 || x > 1 ? x.exponent : 0
     prec2 = prec + BigDecimal.double_fig + cnt
     x = x._decimal_shift(-cnt)
-    xn = BigDecimal(1)
-    y = BigDecimal(1)
 
-    # Taylor series for exp(x) around 0
-    1.step do |i|
-      n = prec2 + xn.exponent
-      break if n <= 0 || xn.zero?
-      x = x.mult(1, n)
-      xn = xn.mult(x, n).div(i, n)
-      y = y.add(xn, prec2)
-    end
+    # Calculation of exp(small_prec) is fast because calculation of x**n is fast
+    # Calculation of exp(small_abs) converges fast.
+    # exp(x) = exp(small_prec_part + small_abs_part) = exp(small_prec_part) * exp(small_abs_part)
+    x_small_prec = x.round(Integer.sqrt(prec2))
+    y = _exp_taylor(x_small_prec, prec2).mult(_exp_taylor(x.sub(x_small_prec, prec2), prec2), prec2)
 
     # calculate exp(x * 10**cnt) from exp(x)
     # exp(x * 10**k) = exp(x * 10**(k - 1)) ** 10

data/vendor/bundle/ruby/2.6.0/gems/{crack-1.0.0 → crack-1.0.1}/History

@@ -1,3 +1,9 @@
+== 1.0.1 2025-09-22
+
+* minor patches
+  * Ruby 3.4 support
+  * Handle new "No root element" error from REXML
+
 == 1.0.0 2024-02-09
 
 This version is identical with the previous one, there's no code changes.

data/vendor/bundle/ruby/2.6.0/gems/crack-1.0.1/lib/crack/version.rb

@@ -0,0 +1,3 @@
+module Crack
+  VERSION = "1.0.1"
+end

data/vendor/bundle/ruby/2.6.0/gems/{crack-1.0.0 → crack-1.0.1}/lib/crack/xml.rb

@@ -232,6 +232,8 @@ module Crack
     end
 
     def self.parse(xml)
+      return {} if xml.strip == ''
+
       parser.parse(xml)
     end
   end

data/vendor/bundle/ruby/2.6.0/gems/{ffi-1.17.2 → ffi-1.17.3}/CHANGELOG.md

@@ -1,3 +1,28 @@
+1.17.3 / 2025-12-29
+-------------------
+
+Fixed:
+* Opt-in for MFA requirement explicitly. #1159
+* Fix type signature for FFI::AutoPointer#initialize, FFI::StructByReference#native_type and FFI::Struct#auto_ptr . #1158
+* Fix function signature of function_call in FFI trampoline. #1154
+  It failed on `aarch64-mingw-ucrt`.
+* Add workaround for segmentation faults on `aarch64-mingw-ucrt`. #1154
+* Call super in `Library#freeze` . #1154
+* Deny duplication of AutoPointer per #dup and #clone . #1173
+  They led to double free before.
+
+Added:
+* Add binary gems for Ruby-4.0, now providing binary gems for Ruby-3.0 to 4.0.
+* Add msys2_mingw_dependencies for Windows Mingw for automatic installation of libffi. #1143
+* Mark callback dispatcher thread as fork safe for Puma. #1156
+* Add missing FFI::Platform module and LastError signatures. #1169
+
+Removed:
+* Drop fat binary gems for Ruby-2.7
+* Remove `FFI::TypesGenerator` from distributed gems. #1164
+* Remove libffi build dir after install, safing some install space. #1157
+
+
 1.17.2 / 2025-04-15
 -------------------
 

data/vendor/bundle/ruby/2.6.0/gems/{ffi-1.17.2 → ffi-1.17.3}/Gemfile

@@ -1,13 +1,15 @@
 source 'https://rubygems.org'
 
+gemspec
+
 group :development do
   gem 'benchmark' # necessary on ruby-3.5+
   gem 'bigdecimal' # necessary on ruby-3.3+
-  gem 'bundler', '>= 1.16', '< 3'
-  gem 'fiddle', platforms: %i[mri windows] # necessary on ruby-3.5+
+  gem 'bundler', '>= 1.16', '< 5.dev'
+  gem 'fiddle' # necessary on ruby-4.0+
   gem 'rake', '~> 13.0'
   gem 'rake-compiler', '~> 1.1'
-  gem 'rake-compiler-dock', '~> 1.9.0'
+  gem 'rake-compiler-dock', '~> 1.11.0'
   gem 'rspec', '~> 3.0'
 end
 
@@ -17,7 +19,8 @@ group :doc do
 end
 
 group :type_check do
-  if RUBY_VERSION >= "2.6" && %w[ ruby truffleruby ].include?(RUBY_ENGINE)
+  if RUBY_VERSION >= "3.0" && %w[ ruby truffleruby ].include?(RUBY_ENGINE)
     gem 'rbs', '~> 3.0'
+    gem 'steep', '~> 1.6'
   end
 end

data/vendor/bundle/ruby/2.6.0/gems/{ffi-1.17.2 → ffi-1.17.3}/README.md

@@ -33,6 +33,7 @@ MyLib.puts 'Hello, World using libc!'
 
 For less minimalistic and more examples you may look at:
 
+* The [documentation](https://www.rubydoc.info/gems/ffi)
 * the `samples/` folder
 * the examples on the [wiki](https://github.com/ffi/ffi/wiki)
 * the projects using FFI listed on the wiki: https://github.com/ffi/ffi/wiki/projects-using-ffi

data/vendor/bundle/ruby/2.6.0/gems/{ffi-1.17.2 → ffi-1.17.3}/Rakefile

@@ -97,6 +97,7 @@ Bundler::GemHelper.instance.cross_platforms = %w[
   arm-linux-musl
   aarch64-linux-gnu
   aarch64-linux-musl
+  aarch64-mingw-ucrt
   x86_64-darwin
   arm64-darwin
 ]
@@ -111,6 +112,8 @@ if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'rbx'
     ext.cross_platform = Bundler::GemHelper.instance.cross_platforms
     ext.cross_compiling do |spec|
       spec.files.reject! { |path| File.fnmatch?('ext/*', path) }
+      # Binary gems don't need libffi header+lib files
+      spec.metadata.delete("msys2_mingw_dependencies")
     end
     # Enable debug info for 'rake compile' but not for 'gem install'
     ext.config_options << "--enable-debug"
@@ -126,7 +129,7 @@ end
 namespace "gem" do
   task 'prepare' do
     require 'rake_compiler_dock'
-    sh "bundle package --all"
+    sh "bundle package"
   end
 
   Bundler::GemHelper.instance.cross_platforms.each do |plat|
@@ -137,8 +140,8 @@ namespace "gem" do
     task plat => ['prepare', 'build'] do
       RakeCompilerDock.sh <<-EOT, platform: plat
         sudo apt-get update && sudo apt-get install -y libltdl-dev &&
-        bundle --local &&
-        rake native:#{plat} pkg/#{gem_spec.full_name}-#{plat}.gem MAKE='nice make -j`nproc`' RUBY_CC_VERSION=#{RakeCompilerDock.ruby_cc_version("~>2.5", "~>3.0")}
+        bundle install --local &&
+        rake native:#{plat} pkg/#{gem_spec.full_name}-#{plat}.gem MAKE='nice make -j`nproc`' RUBY_CC_VERSION=#{RakeCompilerDock.ruby_cc_version("~>4.0", "~>3.0")}
       EOT
     end
   end
@@ -180,7 +183,7 @@ logfile = File.join(File.dirname(__FILE__), 'types_log')
 
 task types_conf do |task|
   require 'fileutils'
-  require_relative "lib/ffi/tools/types_generator"
+  require_relative "rakelib/types_generator"
   options = {}
   FileUtils.mkdir_p(File.dirname(task.name), mode: 0755 )
   File.open(task.name, File::CREAT|File::TRUNC|File::RDWR, 0644) do |f|

data/vendor/bundle/ruby/2.6.0/gems/ffi-1.17.3/Steepfile

@@ -0,0 +1,8 @@
+target :lib do
+  signature "sig"
+
+  check "lib"
+
+  # ignore whole of lib, to just validate RBS in sig
+  ignore "lib"
+end

data/vendor/bundle/ruby/2.6.0/gems/{ffi-1.17.2 → ffi-1.17.3}/ext/ffi_c/DynamicLibrary.c

@@ -236,7 +236,7 @@ dl_error(char* buf, int size)
                    NULL, error, 0, (LPSTR)&message, 0, NULL);
 
     // Update the passed in buffer
-    snprintf(buf, size, "Failed with error %d: %s", error, message);
+    snprintf(buf, size, "Failed with error %lu: %s", error, message);
 
     // Free the allocated message
     LocalFree(message);

data/vendor/bundle/ruby/2.6.0/gems/{ffi-1.17.2 → ffi-1.17.3}/ext/ffi_c/Function.c

@@ -237,6 +237,8 @@ async_cb_dispatcher_initialize(struct async_cb_dispatcher *ctx)
 
     /* Name thread, for better debugging */
     rb_funcall(ctx->thread, rb_intern("name="), 1, rb_str_new2("FFI Callback Dispatcher"));
+    /* Advise multi-threaded app servers to ignore this thread for the purposes of fork safety warnings */
+    rb_funcall(ctx->thread, rb_intern("thread_variable_set"), 2, ID2SYM(rb_intern("fork_safe")), Qtrue);
 }
 
 static struct async_cb_dispatcher *

data/vendor/bundle/ruby/2.6.0/gems/{ffi-1.17.2 → ffi-1.17.3}/ext/ffi_c/Makefile

@@ -31,8 +31,8 @@ rubyhdrdir = $(includedir)/$(RUBY_VERSION_NAME)
 vendorarchdir = $(vendorlibdir)/$(sitearch)
 vendorlibdir = $(vendordir)/$(ruby_version)
 vendordir = $(rubylibprefix)/vendor_ruby
-sitearchdir = $(DESTDIR)./.gem.20251002-861-197h5hs
-sitelibdir = $(DESTDIR)./.gem.20251002-861-197h5hs
+sitearchdir = $(DESTDIR)./.gem.20260109-886-kvbzug
+sitelibdir = $(DESTDIR)./.gem.20260109-886-kvbzug
 sitedir = $(rubylibprefix)/site_ruby
 rubyarchdir = $(rubylibdir)/$(arch)
 rubylibdir = $(rubylibprefix)/$(ruby_version)

data/vendor/bundle/ruby/2.6.0/gems/{ffi-1.17.2 → ffi-1.17.3}/ext/ffi_c/MethodHandle.c

@@ -336,11 +336,13 @@ rbffi_MethodHandle_Init(VALUE module)
         rb_raise(rb_eFatal, "Could not locate offsets in trampoline code");
     }
 #else
+
+    /* static VALUE function_call(int argc, VALUE* argv, VALUE self) */
     methodHandleParamTypes[0] = &ffi_type_sint;
     methodHandleParamTypes[1] = &ffi_type_pointer;
-    methodHandleParamTypes[2] = &ffi_type_ulong;
+    methodHandleParamTypes[2] = &ffi_type_pointer;
 
-    ffiStatus = ffi_prep_cif(&mh_cif, FFI_DEFAULT_ABI, 3, &ffi_type_ulong,
+    ffiStatus = ffi_prep_cif(&mh_cif, FFI_DEFAULT_ABI, 3, &ffi_type_pointer,
             methodHandleParamTypes);
     if (ffiStatus != FFI_OK) {
         rb_raise(rb_eFatal, "ffi_prep_cif failed.  status=%#x", ffiStatus);