fiddle 1.1.5 → 1.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0f57583928674b1ebb1313d3d079afd7f72b7103f1cdff830ef5aa77f868faa
-  data.tar.gz: 0c2d7bbb4d6efd3da8f8023cb9b0d8de11b9baa3ab4e4f82d13e126e7eb301fd
+  metadata.gz: b031b86e4ccc2f94430cb9322a38e7d06932800eb597452f130f01329ecd78ed
+  data.tar.gz: 0b6ccf708b048792e7e6afec9f3f7114289b0d9755353c37d95857085f1fadef
 SHA512:
-  metadata.gz: 6c7a270b8a8d967fcff910335e93051d8aaddaa0617387598ce90031f1c92170f58ba255de84b742a16eb6a2b647df45b07c91ee712c5c34247a6adceaacadc6
-  data.tar.gz: 121958d7cc7be584a1146c3a1ded233ab52facc1f4a31e4e02e49a91b5293897b3e6ae9f5280264ecc5adfbf72165a84837c05a75a82eae70764f16f48d567ef
+  metadata.gz: 4e98b34f7c1deed926635fa0a99c24beadf19d4f5804acc87dec5ceab87a364a27538d5e715b1c7064b34cce8966de0b594a0a4c4131a3f9dfa5952935b2d1d5
+  data.tar.gz: 52782b8d2ab08ef3ac8cdecf78271b7e6fdcbc62e0e27bdad576034dfe0eabf410ba57f4809b14e0f26e24180c80f89234a812ead950088e1b56b80444e3ad47

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/ext/fiddle/pointer.c

@@ -827,7 +827,8 @@ rb_fiddle_ptr_read_mem(VALUE klass, VALUE address, VALUE len)
 static VALUE
 rb_fiddle_ptr_write_mem(VALUE klass, VALUE addr, VALUE str)
 {
-    memcpy(NUM2PTR(addr), StringValuePtr(str), RSTRING_LEN(str));
+    const char *ptr = StringValuePtr(str);
+    memcpy(NUM2PTR(addr), ptr, RSTRING_LEN(str));
     return str;
 }
 

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

@@ -159,15 +159,16 @@ module Fiddle
           args[i] = Fiddle::FFIBackend.to_ffi_type(args[i])
         end
       else
-        args.map! do |arg|
-          if arg.respond_to?(:to_ptr)
-            begin
-              arg = arg.to_ptr
-            end until arg.is_a?(FFI::Pointer) || !arg.respond_to?(:to_ptr)
-            arg
-          else
-            arg
-          end
+        @args.each_with_index do |arg_type, i|
+          next unless arg_type == Types::VOIDP
+
+          src = args[i]
+          next if src.nil?
+          next if src.is_a?(String)
+          next if src.is_a?(FFI::AbstractMemory)
+          next if src.is_a?(FFI::Struct)
+
+          args[i] = Pointer[src]
         end
       end
       result = @function.call(*args, &block)
@@ -187,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
 
@@ -215,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,7 +242,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.ffi_ptr.put_bytes(0, value)
         cptr
 
       elsif value.is_a?(Array)
@@ -261,6 +264,14 @@ module Fiddle
       end
     end
 
+    def self.write(addr, bytes)
+      FFI::Pointer.new(addr).write_bytes(bytes)
+    end
+
+    def self.read(addr, len)
+      FFI::Pointer.new(addr).read_bytes(len)
+    end
+
     class << self
       alias [] to_ptr
     end
@@ -274,7 +285,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)
@@ -282,7 +293,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")
@@ -308,14 +319,27 @@ module Fiddle
               end
             elsif addr.is_a?(IO)
               raise NotImplementedError, "IO ptr isn't supported"
+            else
+              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
@@ -344,11 +368,11 @@ module Fiddle
     end
 
     def null?
-      @ffi_ptr.null?
+      ffi_ptr.null?
     end
 
     def to_ptr
-      @ffi_ptr
+      ffi_ptr
     end
 
     def size
@@ -367,9 +391,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
@@ -397,12 +421,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")
@@ -412,6 +437,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
@@ -423,7 +451,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)
@@ -463,9 +500,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.5"
+  VERSION = "1.1.7"
 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
@@ -111,7 +93,11 @@ module Fiddle
           case line
           when /\A\s*(?:INPUT|GROUP)\s*\(\s*([^\s,\)]+)/
             # TODO: Should we support multiple files?
-            return dlopen($1)
+            first_input = $1
+            if first_input.start_with?("-l")
+              first_input = "lib#{first_input[2..-1]}.so"
+            end
+            return dlopen(first_input)
           end
         end
       end
@@ -119,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.5
+  version: 1.1.7
 platform: ruby
-original_platform: ''
 authors:
 - Aaron Patterson
 - SHIBATA Hiroshi
 bindir: bin
 cert_chain: []
-date: 2024-11-09 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: A libffi wrapper for Ruby.
 email:
@@ -70,7 +69,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.0.dev
+rubygems_version: 3.6.7
 specification_version: 4
 summary: A libffi wrapper for Ruby.
 test_files: []