fiddle 1.1.6 → 1.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a45e277aca605b7e6ca64874fcb263a34c4ec365ee3c718c3df7e6d37e0786d7
-  data.tar.gz: a441f4a982a218093e53de55f101f1afb0307c8764a028ad60b703d0f81c906e
+  metadata.gz: 1afa5c96f5b8b581a576ab625a4f9b5816ff859fc71c446174e51a7448200f0b
+  data.tar.gz: 60bad8470283ab5b5c65561b5069fc793c7374d73b7812e811361bac90ef7afd
 SHA512:
-  metadata.gz: 4abc678600a35970e801719b4319908312e312db6ff987c020b52047c37ec123e2168346db6ad534462d0591645eaa40ea57851fd0e2e7bab92e297928c0d464
-  data.tar.gz: 9a8cbe9817d22c1d740caecf58252781c8268eea84a9957fe1704ac917482981fe4fe862d6d95d4a17ce8ac94a6b9cbc1272609ae77ab6d1f97901dcb2239a09
+  metadata.gz: f674fef3c10f2d667c9de9decb69782a12a7d27b5797964d5b6a3a28e76e4021064cfd338e746a93e8dd00f1230a9bf8c7ba9b6588cec0f16d190f100d9f8261
+  data.tar.gz: bb36a9ea6cf98d2f7b805b4435456a859bff7f427aa5e40f40895bff1a9fbf7f47d8c6213d352a19c754ca1e0265a1942c557bbc8b6bfa0ce31f21a00e526e9a

data/Rakefile

@@ -5,6 +5,15 @@ task :test do
   ruby("test/run.rb")
 end
 
+release_task = Rake.application["release"]
+release_task.prerequisites.delete("build")
+release_task.prerequisites.delete("release:rubygem_push")
+release_task_comment = release_task.comment
+if release_task_comment
+  release_task.clear_comments
+  release_task.comment = release_task_comment.gsub(/ and build.*$/, "")
+end
+
 namespace :version do
   desc "Bump version"
   task :bump do

data/lib/fiddle/cparser.rb

@@ -247,7 +247,7 @@ module Fiddle
         return TYPE_INTPTR_T
       when /\Auintptr_t(?:\s+\w+)?\z/
         return TYPE_UINTPTR_T
-      when "bool"
+      when /\Abool(?:\s+\w+)?\z/
         return TYPE_BOOL
       when /\*/, /\[[\s\d]*\]/
         return TYPE_VOIDP

data/lib/fiddle/ffi_backend.rb

@@ -188,8 +188,10 @@ module Fiddle
       end
       return_type = Fiddle::FFIBackend.to_ffi_type(@ctype)
       raise "#{self.class} must implement #call" unless respond_to?(:call)
-      callable = method(:call)
-      @function = FFI::Function.new(return_type, ffi_args, callable, convention: abi)
+      wrapper = lambda do |*args|
+        call(*args.map { |v| v.is_a?(FFI::Pointer) ? Pointer.new(v) : v })
+      end
+      @function = FFI::Function.new(return_type, ffi_args, wrapper, convention: abi)
       @freed = false
     end
 
@@ -216,8 +218,8 @@ module Fiddle
   class DLError < Error; end
   class ClearedReferenceError < Error; end
 
+  # Pointer isn't thread safe for now
   class Pointer
-    attr_reader :ffi_ptr
     extend FFI::DataConverter
     native_type FFI::Type::Builtin::POINTER
 
@@ -239,9 +241,7 @@ module Fiddle
 
     def self.to_ptr(value)
       if value.is_a?(String)
-        cptr = Pointer.malloc(value.bytesize)
-        cptr.ffi_ptr.put_string(0, value)
-        cptr
+        Pointer.new(FFI::MemoryPointer.from_string(value), value.bytesize)
 
       elsif value.is_a?(Array)
         raise NotImplementedError, "array ptr"
@@ -283,7 +283,7 @@ module Fiddle
           value = value.to_str(args[1])
         end
 
-        @ffi_ptr.put_bytes(args[0], value, 0, args[1])
+        ffi_ptr.put_bytes(args[0], value, 0, args[1])
       elsif args.size == 1
         if value.is_a?(Fiddle::Pointer)
           value = value.to_str(args[0] + 1)
@@ -291,7 +291,7 @@ module Fiddle
           value = value.chr
         end
 
-        @ffi_ptr.put_bytes(args[0], value, 0, 1)
+        ffi_ptr.put_bytes(args[0], value, 0, 1)
       end
     rescue FFI::NullPointerError
       raise DLError.new("NULL pointer access")
@@ -321,12 +321,23 @@ module Fiddle
               FFI::Pointer.new(Integer(addr))
             end
 
-      @size = size ? size : ptr.size
+      if size
+        @size = size
+      elsif ptr.size_limit?
+        @size = ptr.size
+      else
+        @size = 0
+      end
       @free = free
       @ffi_ptr = ptr
+      @addr_ptr = nil
       @freed = false
     end
 
+    def ffi_ptr
+      @addr_ptr ? @addr_ptr.get_pointer(0) : @ffi_ptr
+    end
+
     module LibC
       extend FFI::Library
       ffi_lib FFI::Library::LIBC
@@ -355,11 +366,11 @@ module Fiddle
     end
 
     def null?
-      @ffi_ptr.null?
+      ffi_ptr.null?
     end
 
     def to_ptr
-      @ffi_ptr
+      ffi_ptr
     end
 
     def size
@@ -378,9 +389,9 @@ module Fiddle
       return if @free.nil?
       return if @freed
       if @free == RUBY_FREE
-        LibC::FREE.call(@ffi_ptr)
+        LibC::FREE.call(ffi_ptr)
       else
-        @free.call(@ffi_ptr)
+        @free.call(ffi_ptr)
       end
       @freed = true
     end
@@ -408,12 +419,13 @@ module Fiddle
     end
     alias to_int to_i
 
-    # without \0
     def to_s(len = nil)
       if len
-        ffi_ptr.get_string(0, len)
+        ffi_ptr.read_string(len)
+      elsif @size == 0
+        ffi_ptr.read_string
       else
-        ffi_ptr.get_string(0)
+        ffi_ptr.get_string(0, @size)
       end
     rescue FFI::NullPointerError
       raise DLError.new("NULL pointer access")
@@ -423,6 +435,9 @@ module Fiddle
       if len
         ffi_ptr.read_string(len)
       else
+        if @size < 0
+          raise ArgumentError.new("negative string size (or size too big)")
+        end
         ffi_ptr.read_string(@size)
       end
     rescue FFI::NullPointerError
@@ -434,7 +449,16 @@ module Fiddle
     end
 
     def inspect
-      "#<#{self.class.name} ptr=#{to_i.to_s(16)} size=#{@size} free=#{@free.inspect}>"
+      # SIZEOF_VOIDP * 2 == Math.log(2 ** (SIZEOF_VOIDP * 8), 16)
+      pointer_inspect_width = SIZEOF_VOIDP * 2
+      "#<%s ptr=0x%0.*x size=%d free=0x%0.*x>" % [
+        self.class.name,
+        pointer_inspect_width,
+        to_i,
+        size,
+        pointer_inspect_width,
+        @free || 0,
+      ]
     end
 
     def +(delta)
@@ -474,9 +498,8 @@ module Fiddle
     end
 
     def ref
-      cptr = Pointer.malloc(FFI::Type::POINTER.size, RUBY_FREE)
-      cptr.ffi_ptr.put_pointer(0, ffi_ptr)
-      cptr
+      @addr_ptr ||= FFI::MemoryPointer.new(:pointer).put_pointer(0, @ffi_ptr)
+      Pointer.new(@addr_ptr, 0)
     end
   end
 

data/lib/fiddle/version.rb

@@ -1,3 +1,3 @@
 module Fiddle
-  VERSION = "1.1.6"
+  VERSION = "1.1.8"
 end

data/lib/fiddle.rb

@@ -10,98 +10,80 @@ require 'fiddle/function'
 require 'fiddle/version'
 
 module Fiddle
-  if WINDOWS
-    # Returns the last win32 +Error+ of the current executing +Thread+ or nil
-    # if none
-    def self.win32_last_error
-      if RUBY_ENGINE == 'jruby'
-        errno = FFI.errno
-        errno == 0 ? nil : errno
-      else
-        Thread.current[:__FIDDLE_WIN32_LAST_ERROR__]
-      end
+  if RUBY_ENGINE != 'ruby' # FFI backend
+    def self.last_error
+      FFI.errno
     end
 
-    # Sets the last win32 +Error+ of the current executing +Thread+ to +error+
-    def self.win32_last_error= error
-      if RUBY_ENGINE == 'jruby'
-        FFI.errno = error || 0
-      else
-        Thread.current[:__FIDDLE_WIN32_LAST_ERROR__] = error
-      end
+    def self.last_error=(error)
+      FFI.errno = error || 0
     end
 
-    # Returns the last win32 socket +Error+ of the current executing
-    # +Thread+ or nil if none
-    def self.win32_last_socket_error
-      if RUBY_ENGINE == 'jruby'
-        errno = FFI.errno
-        errno == 0 ? nil : errno
-      else
-        Thread.current[:__FIDDLE_WIN32_LAST_SOCKET_ERROR__]
-      end
-    end
+    if WINDOWS
+      class << self
+        def win32_last_error
+          FFI.errno.nonzero?
+        end
+        def win32_last_error=(error)
+          FFI.errno = error || 0
+        end
 
-    # Sets the last win32 socket +Error+ of the current executing
-    # +Thread+ to +error+
-    def self.win32_last_socket_error= error
-      if RUBY_ENGINE == 'jruby'
-        FFI.errno = error || 0
-      else
-        Thread.current[:__FIDDLE_WIN32_LAST_SOCKET_ERROR__] = error
+        def win32_last_socket_error
+          FFI.errno.nonzero?
+        end
+        def win32_last_socket_error=(error)
+          FFI.errno = error || 0
+        end
       end
     end
-  end
-
-  # Returns the last +Error+ of the current executing +Thread+ or nil if none
-  def self.last_error
-    if RUBY_ENGINE == 'jruby'
-      errno = FFI.errno
-      errno == 0 ? nil : errno
-    else
+  else
+    # Returns the last +Error+ of the current executing +Thread+ or nil if none
+    def self.last_error
       Thread.current[:__FIDDLE_LAST_ERROR__]
     end
-  end
 
-  # Sets the last +Error+ of the current executing +Thread+ to +error+
-  def self.last_error= error
-    if RUBY_ENGINE == 'jruby'
-      FFI.errno = error || 0
-    else
+    # Sets the last +Error+ of the current executing +Thread+ to +error+
+    def self.last_error= error
       Thread.current[:__DL2_LAST_ERROR__] = error
       Thread.current[:__FIDDLE_LAST_ERROR__] = error
     end
+
+    if WINDOWS
+      # Returns the last win32 +Error+ of the current executing +Thread+ or nil
+      # if none
+      def self.win32_last_error
+        Thread.current[:__FIDDLE_WIN32_LAST_ERROR__]
+      end
+
+      # Sets the last win32 +Error+ of the current executing +Thread+ to +error+
+      def self.win32_last_error= error
+        Thread.current[:__FIDDLE_WIN32_LAST_ERROR__] = error
+      end
+
+      # Returns the last win32 socket +Error+ of the current executing
+      # +Thread+ or nil if none
+      def self.win32_last_socket_error
+        Thread.current[:__FIDDLE_WIN32_LAST_SOCKET_ERROR__]
+      end
+
+      # Sets the last win32 socket +Error+ of the current executing
+      # +Thread+ to +error+
+      def self.win32_last_socket_error= error
+        Thread.current[:__FIDDLE_WIN32_LAST_SOCKET_ERROR__] = error
+      end
+    end
   end
 
-  # call-seq: dlopen(library) => Fiddle::Handle
-  #
-  # Creates a new handler that opens +library+, and returns an instance of
-  # Fiddle::Handle.
-  #
-  # If +nil+ is given for the +library+, Fiddle::Handle::DEFAULT is used, which
-  # is the equivalent to RTLD_DEFAULT. See <code>man 3 dlopen</code> for more.
-  #
-  #   lib = Fiddle.dlopen(nil)
-  #
-  # The default is dependent on OS, and provide a handle for all libraries
-  # already loaded. For example, in most cases you can use this to access
-  # +libc+ functions, or ruby functions like +rb_str_new+.
-  #
-  # See Fiddle::Handle.new for more.
-  def dlopen library
-    begin
+  case RUBY_PLATFORM
+  when /linux/
+    def dlopen library
       Fiddle::Handle.new(library)
     rescue DLError => error
-      case RUBY_PLATFORM
-      when /linux/
-        case error.message
-        when /\A(\/.+?): (?:invalid ELF header|file too short)/
-          # This may be a linker script:
-          # https://sourceware.org/binutils/docs/ld.html#Scripts
-          path = $1
-        else
-          raise
-        end
+      case error.message
+      when /\A(\/.+?): (?:invalid ELF header|file too short)/
+        # This may be a linker script:
+        # https://sourceware.org/binutils/docs/ld.html#Scripts
+        path = $1
       else
         raise
       end
@@ -123,6 +105,25 @@ module Fiddle
       # Not found
       raise
     end
+  else
+    # call-seq: dlopen(library) => Fiddle::Handle
+    #
+    # Creates a new handler that opens +library+, and returns an instance of
+    # Fiddle::Handle.
+    #
+    # If +nil+ is given for the +library+, Fiddle::Handle::DEFAULT is used, which
+    # is the equivalent to RTLD_DEFAULT. See <code>man 3 dlopen</code> for more.
+    #
+    #   lib = Fiddle.dlopen(nil)
+    #
+    # The default is dependent on OS, and provide a handle for all libraries
+    # already loaded. For example, in most cases you can use this to access
+    # +libc+ functions, or ruby functions like +rb_str_new+.
+    #
+    # See Fiddle::Handle.new for more.
+    def dlopen library
+      Fiddle::Handle.new(library)
+    end
   end
   module_function :dlopen
 

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fiddle
 version: !ruby/object:Gem::Version
-  version: 1.1.6
+  version: 1.1.8
 platform: ruby
 authors:
 - Aaron Patterson
 - SHIBATA Hiroshi
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-12 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: A libffi wrapper for Ruby.
 email:
@@ -56,7 +55,6 @@ licenses:
 metadata:
   msys2_mingw_dependencies: libffi
   changelog_uri: https://github.com/ruby/fiddle/releases
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -71,8 +69,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: A libffi wrapper for Ruby.
 test_files: []