require 'fiddle'

libm = Fiddle.dlopen('/lib/libm.so.6')

floor = Fiddle::Function.new(
  libm['floor'],
  [Fiddle::TYPE_DOUBLE],
  Fiddle::TYPE_DOUBLE
)

puts floor.call(3.14159) #=> 3.0

• MODULE Fiddle::BasicTypes
• MODULE Fiddle::CParser
• MODULE Fiddle::CStructBuilder
• MODULE Fiddle::Importer
• MODULE Fiddle::Types
• MODULE Fiddle::Win32Types
• CLASS Fiddle::CStruct
• CLASS Fiddle::CStructEntity
• CLASS Fiddle::CUnion
• CLASS Fiddle::CUnionEntity
• CLASS Fiddle::ClearedReferenceError
• CLASS Fiddle::Closure
• CLASS Fiddle::CompositeHandler
• CLASS Fiddle::DLError
• CLASS Fiddle::Error
• CLASS Fiddle::Function
• CLASS Fiddle::Handle
• CLASS Fiddle::Pinned
• CLASS Fiddle::Pointer
• CLASS Fiddle::StructArray

D

• dlopen,
• dlunwrap,
• dlwrap

F

• free

L

• last_error,
• last_error=

M

• malloc

R

• realloc

W

• win32_last_error,
• win32_last_error=,
• win32_last_socket_error,
• win32_last_socket_error=

Constants

Class Public methods

lib = Fiddle.dlopen(nil)

# File ruby/ext/fiddle/lib/fiddle.rb, line 60
def dlopen library
  begin
    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
    else
      raise
    end

    File.open(path) do |input|
      input.each_line do |line|
        case line
        when /\A\s*(?:INPUT|GROUP)\s*\(\s*([^\s,\)]+)/
          # TODO: Should we support multiple files?
          return dlopen($1)
        end
      end
    end

    # Not found
    raise
  end
end

x = Object.new
# => #<Object:0x0000000107c7d870>
Fiddle.dlwrap(x)
# => 4425504880
Fiddle.dlunwrap(_)
# => #<Object:0x0000000107c7d870>

VALUE
rb_fiddle_ptr2value(VALUE self, VALUE addr)
{
    return (VALUE)NUM2PTR(addr);
}

x = Object.new
# => #<Object:0x0000000107c7d870>
Fiddle.dlwrap(x)
# => 4425504880

Fiddle.dlwrap(123)
# => 247

static VALUE
rb_fiddle_value2ptr(VALUE self, VALUE val)
{
    return PTR2NUM((void*)val);
}

VALUE
rb_fiddle_free(VALUE self, VALUE addr)
{
    void *ptr = NUM2PTR(addr);

    ruby_xfree(ptr);
    return Qnil;
}

# File ruby/ext/fiddle/lib/fiddle.rb, line 35
def self.last_error
  Thread.current[:__FIDDLE_LAST_ERROR__]
end

# File ruby/ext/fiddle/lib/fiddle.rb, line 40
def self.last_error= error
  Thread.current[:__DL2_LAST_ERROR__] = error
  Thread.current[:__FIDDLE_LAST_ERROR__] = error
end

static VALUE
rb_fiddle_malloc(VALUE self, VALUE size)
{
    void *ptr;
    ptr = (void*)ruby_xcalloc(1, NUM2SIZET(size));
    return PTR2NUM(ptr);
}

static VALUE
rb_fiddle_realloc(VALUE self, VALUE addr, VALUE size)
{
    void *ptr = NUM2PTR(addr);

    ptr = (void*)ruby_xrealloc(ptr, NUM2SIZET(size));
    return PTR2NUM(ptr);
}

# File ruby/ext/fiddle/lib/fiddle.rb, line 12
def self.win32_last_error
  Thread.current[:__FIDDLE_WIN32_LAST_ERROR__]
end

# File ruby/ext/fiddle/lib/fiddle.rb, line 17
def self.win32_last_error= error
  Thread.current[:__FIDDLE_WIN32_LAST_ERROR__] = error
end

# File ruby/ext/fiddle/lib/fiddle.rb, line 23
def self.win32_last_socket_error
  Thread.current[:__FIDDLE_WIN32_LAST_SOCKET_ERROR__]
end

# File ruby/ext/fiddle/lib/fiddle.rb, line 29
def self.win32_last_socket_error= error
  Thread.current[:__FIDDLE_WIN32_LAST_SOCKET_ERROR__] = error
end