ffi 1.17.3-aarch64-mingw-ucrt

data/samples/getlogin.rb

@@ -0,0 +1,8 @@
+require 'ffi'
+
+module Foo
+  extend FFI::Library
+  ffi_lib FFI::Library::LIBC
+  attach_function :getlogin, [ ], :string
+end
+puts "getlogin=#{Foo.getlogin}"

data/samples/getpid.rb

@@ -0,0 +1,8 @@
+require 'ffi'
+
+module Foo
+  extend FFI::Library
+  ffi_lib FFI::Library::LIBC
+  attach_function :getpid, [ ], :int
+end
+puts "My pid=#{Foo.getpid}"

data/samples/gettimeofday.rb

@@ -0,0 +1,18 @@
+require 'ffi'
+require 'rbconfig'
+
+class Timeval < FFI::Struct
+  layout tv_sec: :ulong, tv_usec: :ulong
+end
+module LibC
+  extend FFI::Library
+  if FFI::Platform.windows?
+    ffi_lib RbConfig::CONFIG["LIBRUBY_SO"]
+  else
+    ffi_lib FFI::Library::LIBC
+  end
+  attach_function :gettimeofday, [ :pointer, :pointer ], :int
+end
+t = Timeval.new
+LibC.gettimeofday(t.pointer, nil)
+puts "t.tv_sec=#{t[:tv_sec]} t.tv_usec=#{t[:tv_usec]}"

data/samples/hello.rb

@@ -0,0 +1,8 @@
+require 'ffi'
+
+module Foo
+  extend FFI::Library
+  ffi_lib FFI::Library::LIBC
+  attach_function("cputs", "puts", [ :string ], :int)
+end
+Foo.cputs("Hello, World via libc puts using FFI on MRI ruby")

data/samples/hello_ractor.rb

@@ -0,0 +1,19 @@
+# See the ffi wiki for how to use FFI with Ractors:
+# https://github.com/ffi/ffi/wiki/Ractors
+
+require 'ffi'
+
+class Ractor
+  # compat with Ruby-3.4 and older
+  alias value take unless method_defined? :value
+end
+
+module Foo
+  extend FFI::Library
+  ffi_lib FFI::Library::LIBC
+  attach_function("cputs", "puts", [ :string ], :int)
+  freeze
+end
+Ractor.new do
+  Foo.cputs("Hello, World via libc puts using FFI in a Ractor")
+end.value

data/samples/inotify.rb

@@ -0,0 +1,60 @@
+require 'ffi'
+
+module Inotify
+  extend FFI::Library
+  ffi_lib FFI::Library::LIBC
+  class Event < FFI::Struct
+    layout \
+      :wd, :int,
+      :mask, :uint,
+      :cookie, :uint,
+      :len, :uint
+  end
+  attach_function :init, :inotify_init, [ ], :int
+  attach_function :add_watch, :inotify_add_watch, [ :int, :string, :uint ], :int
+  attach_function :rm_watch, :inotify_rm_watch, [ :int, :uint ], :int
+  attach_function :read, [ :int, :buffer_out, :uint ], :int
+  IN_ACCESS=0x00000001
+  IN_MODIFY=0x00000002
+  IN_ATTRIB=0x00000004
+  IN_CLOSE_WRITE=0x00000008
+  IN_CLOSE_NOWRITE=0x00000010
+  IN_CLOSE=(IN_CLOSE_WRITE | IN_CLOSE_NOWRITE)
+  IN_OPEN=0x00000020
+  IN_MOVED_FROM=0x00000040
+  IN_MOVED_TO=0x00000080
+  IN_MOVE= (IN_MOVED_FROM | IN_MOVED_TO)
+  IN_CREATE=0x00000100
+  IN_DELETE=0x00000200
+  IN_DELETE_SELF=0x00000400
+  IN_MOVE_SELF=0x00000800
+  # Events sent by the kernel.
+  IN_UNMOUNT=0x00002000
+  IN_Q_OVERFLOW=0x00004000
+  IN_IGNORED=0x00008000
+  IN_ONLYDIR=0x01000000
+  IN_DONT_FOLLOW=0x02000000
+  IN_MASK_ADD=0x20000000
+  IN_ISDIR=0x40000000
+  IN_ONESHOT=0x80000000
+  IN_ALL_EVENTS=(IN_ACCESS | IN_MODIFY | IN_ATTRIB | IN_CLOSE_WRITE \
+                          | IN_CLOSE_NOWRITE | IN_OPEN | IN_MOVED_FROM \
+                          | IN_MOVED_TO | IN_CREATE | IN_DELETE \
+                          | IN_DELETE_SELF | IN_MOVE_SELF)
+
+end
+if $0 == __FILE__
+  fd = Inotify.init
+  puts "fd=#{fd}"
+  wd = Inotify.add_watch(fd, "/tmp/", Inotify::IN_ALL_EVENTS)
+  fp = FFI::IO.for_fd(fd)
+  puts "wfp=#{fp}"
+  while true
+    buf = FFI::Buffer.alloc_out(Inotify::Event.size + 4096, 1, false)
+    ev = Inotify::Event.new buf
+    ready = IO.select([ fp ], nil, nil, nil)
+    n = Inotify.read(fd, buf, buf.total)
+    puts "Read #{n} bytes from inotify fd"
+    puts "event.wd=#{ev[:wd]} mask=#{ev[:mask]} len=#{ev[:len]} name=#{ev[:len] > 0 ? buf.get_string(16) : 'unknown'}"
+  end
+end

data/samples/pty.rb

@@ -0,0 +1,75 @@
+require 'ffi'
+
+module PTY
+  private
+  module LibC
+    extend FFI::Library
+    ffi_lib FFI::Library::LIBC
+    attach_function :forkpty, [ :buffer_out, :buffer_out, :buffer_in, :buffer_in ], :int
+    attach_function :openpty, [ :buffer_out, :buffer_out, :buffer_out, :buffer_in, :buffer_in ], :int
+    attach_function :login_tty, [ :int ], :int
+    attach_function :close, [ :int ], :int
+    attach_function :strerror, [ :int ], :string
+    attach_function :fork, [], :int
+    attach_function :execv, [ :string, :buffer_in ], :int
+    attach_function :execvp, [ :string, :buffer_in ], :int
+    attach_function :dup2, [ :int, :int ], :int
+    attach_function :dup, [ :int ], :int
+  end
+  Buffer = FFI::Buffer
+  def self.build_args(args)
+    cmd = args.shift
+    cmd_args = args.map do |arg|
+      MemoryPointer.from_string(arg)
+    end
+    exec_args = MemoryPointer.new(:pointer, 1 + cmd_args.length + 1)
+    exec_cmd = MemoryPointer.from_string(cmd)
+    exec_args[0].put_pointer(0, exec_cmd)
+    cmd_args.each_with_index do |arg, i|
+      exec_args[i + 1].put_pointer(0, arg)
+    end
+    [ cmd, exec_args ]
+  end
+  public
+  def self.getpty(*args)
+    mfdp = Buffer.new :int
+    name = Buffer.new 1024
+    #
+    # All the execv setup is done in the parent, since doing anything other than
+    # execv in the child after fork is really flakey
+    #
+    exec_cmd, exec_args = build_args(args)
+    pid = LibC.forkpty(mfdp, name, nil, nil)
+    raise "forkpty failed: #{LibC.strerror(FFI.errno)}" if pid < 0
+    if pid == 0
+      LibC.execvp(exec_cmd, exec_args)
+      exit 1
+    end
+    masterfd = mfdp.get_int(0)
+    rfp = FFI::IO.for_fd(masterfd, "r")
+    wfp = FFI::IO.for_fd(LibC.dup(masterfd), "w")
+    if block_given?
+      yield rfp, wfp, pid
+      rfp.close unless rfp.closed?
+      wfp.close unless wfp.closed?
+    else
+      [ rfp, wfp, pid ]
+    end
+  end
+  def self.spawn(*args, &block)
+    self.getpty("/bin/sh", "-c", args[0], &block)
+  end
+end
+module LibC
+  extend FFI::Library
+  attach_function :close, [ :int ], :int
+  attach_function :write, [ :int, :buffer_in, :ulong ], :long
+  attach_function :read, [ :int, :buffer_out, :ulong ], :long
+end
+PTY.getpty("/bin/ls", "-alR", "/") { |rfd, wfd, pid|
+#PTY.spawn("ls -laR /") { |rfd, wfd, pid|
+  puts "child pid=#{pid}"
+  while !rfd.eof? && (buf = rfd.gets)
+    puts "child: '#{buf.strip}'"
+  end
+}

data/samples/qsort.rb

@@ -0,0 +1,20 @@
+require 'ffi'
+
+module LibC
+  extend FFI::Library
+  ffi_lib FFI::Library::LIBC
+  callback :qsort_cmp, [ :pointer, :pointer ], :int
+  attach_function :qsort, [ :pointer, :ulong, :ulong, :qsort_cmp ], :int
+end
+
+p = FFI::MemoryPointer.new(:int, 2)
+p.put_array_of_int32(0, [ 2, 1 ])
+puts "ptr=#{p.inspect}"
+puts "Before qsort #{p.get_array_of_int32(0, 2).join(', ')}"
+LibC.qsort(p, 2, 4) do |p1, p2|
+  i1 = p1.get_int32(0)
+  i2 = p2.get_int32(0)
+  puts "In block: comparing #{i1} and #{i2}"
+  i1 < i2 ? -1 : i1 > i2 ? 1 : 0
+end
+puts "After qsort #{p.get_array_of_int32(0, 2).join(', ')}"

data/samples/qsort_ractor.rb

@@ -0,0 +1,36 @@
+# See the ffi wiki for how to use FFI with Ractors:
+# https://github.com/ffi/ffi/wiki/Ractors
+
+require 'ffi'
+
+class Ractor
+  # compat with Ruby-3.4 and older
+  alias value take unless method_defined? :value
+end
+
+module LibC
+  extend FFI::Library
+  ffi_lib FFI::Library::LIBC
+  callback :qsort_cmp, [ :pointer, :pointer ], :int
+  attach_function :qsort, [ :pointer, :ulong, :ulong, :qsort_cmp ], :int
+
+  freeze # Freeze the module variables, so that it can be shared across ractors.
+end
+
+p = FFI::MemoryPointer.new(:int, 3)
+p.put_array_of_int32(0, [ 2, 3, 1 ])   # Write some unsorted data into the memory
+# Ractor.make_shareable(p)             # freeze the pointer to be shared between ractors instead of copied
+puts "main  -ptr=#{p.inspect}"
+res = Ractor.new(p) do |p|
+  puts "ractor-ptr=#{p.inspect}"
+  puts "Before qsort #{p.get_array_of_int32(0, 3).join(', ')}"
+  LibC.qsort(p, 3, 4) do |p1, p2|
+    i1 = p1.get_int32(0)
+    i2 = p2.get_int32(0)
+    puts "In block: comparing #{i1} and #{i2}"
+    i1 < i2 ? -1 : i1 > i2 ? 1 : 0
+  end
+  puts "After qsort #{p.get_array_of_int32(0, 3).join(', ')}"
+end.value
+
+puts "After ractor termination #{p.get_array_of_int32(0, 3).join(', ')}"

data/sig/ffi/abstract_memory.rbs

@@ -0,0 +1,165 @@
+module FFI
+  class AbstractMemory
+    interface _Size
+      def size: () -> Integer
+    end
+    include _Size
+    type type_size = Integer | _Size | Symbol
+
+    type order_out = :big | :little
+    type order_in = order_out | :network
+
+    def []: (Integer idx) -> instance
+    def clear: () -> self
+    def freeze: ...
+    def get: (ffi_type type, Integer offset) -> top
+    def put: (ffi_type type, Integer offset, top value) -> nil
+    def size_limit?: () -> bool
+    def type_size: () -> Integer
+    alias total size
+
+    def get_int8: (Integer offset) -> Integer
+    def get_int16: (Integer offset) -> Integer
+    def get_int32: (Integer offset) -> Integer
+    def get_int64: (Integer offset) -> Integer
+    def get_uint8: (Integer offset) -> Integer
+    def get_uint16: (Integer offset) -> Integer
+    def get_uint32: (Integer offset) -> Integer
+    def get_uint64: (Integer offset) -> Integer
+    def get_char: (Integer offset) -> Integer
+    def get_short: (Integer offset) -> Integer
+    def get_int: (Integer offset) -> Integer
+    def get_long_long: (Integer offset) -> Integer
+    def get_float32: (Integer offset) -> Float
+    def get_float64: (Integer offset) -> Float
+    def get_pointer: (Integer offset) -> Pointer
+    def get_bytes: (Integer offset, Integer length) -> String
+    def get_string: (Integer offset, ?Integer? length) -> String
+    alias get_float get_float32
+    alias get_double get_float64
+
+    def put_int8: (Integer offset, int value) -> self
+    def put_int16: (Integer offset, int value) -> self
+    def put_int32: (Integer offset, int value) -> self
+    def put_int64: (Integer offset, int value) -> self
+    def put_uint8: (Integer offset, int value) -> self
+    def put_uint16: (Integer offset, int value) -> self
+    def put_uint32: (Integer offset, int value) -> self
+    def put_uint64: (Integer offset, int value) -> self
+    def put_char: (Integer offset, int value) -> self
+    def put_short: (Integer offset, int value) -> self
+    def put_int: (Integer offset, int value) -> self
+    def put_long_long: (Integer offset, int value) -> self
+    def put_float32: (Integer offset, Numeric value) -> self
+    def put_float64: (Integer offset, Numeric value) -> self
+    def put_pointer: (Integer offset, pointer value) -> self
+    def put_bytes: (Integer offset, String str, ?Integer index, ?Integer? length) -> self
+    def put_string: (Integer offset, String value) -> self
+    alias put_float put_float32
+    alias put_double put_float64
+
+    def read_int8: () -> Integer
+    def read_int16: () -> Integer
+    def read_int32: () -> Integer
+    def read_int64: () -> Integer
+    def read_uint8: () -> Integer
+    def read_uint16: () -> Integer
+    def read_uint32: () -> Integer
+    def read_uint64: () -> Integer
+    def read_char: () -> Integer
+    def read_short: () -> Integer
+    def read_int: () -> Integer
+    def read_long_long: () -> Integer
+    def read_float: () -> Float
+    def read_double: () -> Float
+    def read_pointer: () -> Pointer
+    def read_bytes: (Integer length) -> String
+
+    def write_int8: (int value) -> self
+    def write_int16: (int value) -> self
+    def write_int32: (int value) -> self
+    def write_int64: (int value) -> self
+    def write_uint8: (int value) -> self
+    def write_uint16: (int value) -> self
+    def write_uint32: (int value) -> self
+    def write_uint64: (int value) -> self
+    def write_char: (int value) -> self
+    def write_short: (int value) -> self
+    def write_int: (int value) -> self
+    def write_long_long: (int value) -> self
+    def write_float: (Numeric value) -> self
+    def write_double: (Numeric value) -> self
+    def write_pointer: (pointer value) -> self
+    def write_bytes: (String str, ?Integer index, ?Integer? length) -> self
+
+    def get_array_of_int8: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_int16: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_int32: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_int64: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_uint8: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_uint16: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_uint32: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_uint64: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_char: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_short: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_int: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_long_long: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_float32: (Integer offset, Integer length) -> Array[Float]
+    def get_array_of_float64: (Integer offset, Integer length) -> Array[Float]
+    def get_array_of_pointer: (Integer offset, Integer length) -> Array[Pointer]
+    def get_array_of_string: (Integer offset, ?Integer? count) -> Array[String?]
+    alias get_array_of_float get_array_of_float32
+    alias get_array_of_double get_array_of_float64
+
+    def put_array_of_int8: (Integer offset, Array[int] ary) -> self
+    def put_array_of_int16: (Integer offset, Array[int] ary) -> self
+    def put_array_of_int32: (Integer offset, Array[int] ary) -> self
+    def put_array_of_int64: (Integer offset, Array[int] ary) -> self
+    def put_array_of_uint8: (Integer offset, Array[int] ary) -> self
+    def put_array_of_uint16: (Integer offset, Array[int] ary) -> self
+    def put_array_of_uint32: (Integer offset, Array[int] ary) -> self
+    def put_array_of_uint64: (Integer offset, Array[int] ary) -> self
+    def put_array_of_char: (Integer offset, Array[int] ary) -> self
+    def put_array_of_short: (Integer offset, Array[int] ary) -> self
+    def put_array_of_int: (Integer offset, Array[int] ary) -> self
+    def put_array_of_long_long: (Integer offset, Array[int] ary) -> self
+    def put_array_of_float32: (Integer offset, Array[Numeric] ary) -> self
+    def put_array_of_float64: (Integer offset, Array[Numeric] ary) -> self
+    def put_array_of_pointer: (Integer offset, Array[pointer] ary) -> self
+    alias put_array_of_float put_array_of_float32
+    alias put_array_of_double put_array_of_float64
+
+    def read_array_of_int8: (Integer length) -> Array[Integer]
+    def read_array_of_int16: (Integer length) -> Array[Integer]
+    def read_array_of_int32: (Integer length) -> Array[Integer]
+    def read_array_of_int64: (Integer length) -> Array[Integer]
+    def read_array_of_uint8: (Integer length) -> Array[Integer]
+    def read_array_of_uint16: (Integer length) -> Array[Integer]
+    def read_array_of_uint32: (Integer length) -> Array[Integer]
+    def read_array_of_uint64: (Integer length) -> Array[Integer]
+    def read_array_of_char: (Integer length) -> Array[Integer]
+    def read_array_of_short: (Integer length) -> Array[Integer]
+    def read_array_of_int: (Integer length) -> Array[Integer]
+    def read_array_of_long_long: (Integer length) -> Array[Integer]
+    def read_array_of_float: (Integer length) -> Array[Float]
+    def read_array_of_double: (Integer length) -> Array[Float]
+    def read_array_of_pointer: (Integer length) -> Array[Pointer]
+    def read_array_of_string: (?Integer? count) -> Array[String?]
+
+    def write_array_of_int8: (Array[int] ary) -> self
+    def write_array_of_int16: (Array[int] ary) -> self
+    def write_array_of_int32: (Array[int] ary) -> self
+    def write_array_of_int64: (Array[int] ary) -> self
+    def write_array_of_uint8: (Array[int] ary) -> self
+    def write_array_of_uint16: (Array[int] ary) -> self
+    def write_array_of_uint32: (Array[int] ary) -> self
+    def write_array_of_uint64: (Array[int] ary) -> self
+    def write_array_of_char: (Array[int] ary) -> self
+    def write_array_of_short: (Array[int] ary) -> self
+    def write_array_of_int: (Array[int] ary) -> self
+    def write_array_of_long_long: (Array[int] ary) -> self
+    def write_array_of_float: (Array[Numeric] ary) -> self
+    def write_array_of_double: (Array[Numeric] ary) -> self
+    def write_array_of_pointer: (Array[pointer] ary) -> self
+  end
+end

data/sig/ffi/auto_pointer.rbs

@@ -0,0 +1,26 @@
+module FFI
+  class AutoPointer < Pointer
+    class Releaser
+      attr_accessor autorelease: boolish
+      interface _Proc[P < Pointer]
+        def call: (P) -> void
+      end
+      def initialize: [P < Pointer] (P ptr, _Proc[P] proc) -> void
+
+      def call: (*untyped) -> void
+      def free: () -> nil
+      def release: (Pointer ptr) -> void
+    end
+
+    def initialize: (Pointer pointer, Method | ^(instance) -> void | Releaser::_Proc[instance] callable) -> self
+                  | (Pointer pointer) -> self # where class < `def self.release: (instance pointer) -> void`
+
+    extend DataConverter[Pointer, instance, nil]
+    def self.from_native: ...
+    def self.native_type: () -> Type::Builtin
+
+    def autorelease?: ...
+    def autorelease=: ...
+    def free: () -> nil
+  end
+end

data/sig/ffi/buffer.rbs

@@ -0,0 +1,18 @@
+module FFI
+  class Buffer < AbstractMemory
+    def initialize: (AbstractMemory::type_size, ?Integer count, boolish clear) -> self
+    alias self.alloc_inout self.new
+    alias self.new_inout self.alloc_inout
+    alias self.alloc_in self.alloc_inout
+    alias self.new_in self.alloc_in
+    alias self.alloc_out self.alloc_inout
+    alias self.new_out self.alloc_out
+
+    def +: (Integer) -> Buffer
+    def inspect: ...
+    def order: () -> AbstractMemory::order_out
+             | (AbstractMemory::order_in order) -> Buffer
+             | (untyped order) -> (self | Buffer)
+    def slice: (Integer offset, Integer length) -> Buffer
+  end
+end

data/sig/ffi/data_converter.rbs

@@ -0,0 +1,10 @@
+module FFI
+  interface _DataConverter[N, R, in C]
+    def from_native: (N value, C ctx) -> R
+    def native_type: (?ffi_auto_type? type) -> Type
+    def to_native: (R value, C ctx) -> N
+  end
+  module DataConverter[N, R, in C]
+    include _DataConverter[N, R, C]
+  end
+end

data/sig/ffi/dynamic_library.rbs

@@ -0,0 +1,9 @@
+module FFI
+  class DynamicLibrary
+    # TODO
+
+    class Symbol < Pointer
+      # TODO
+    end
+  end
+end

data/sig/ffi/enum.rbs

@@ -0,0 +1,38 @@
+module FFI
+  class Enums
+    def initialize: () -> void
+
+    def <<: (Enum enum) -> void
+    def __map_symbol: (Symbol symbol) -> Integer?
+    def find: (Symbol query) -> Enum
+  end
+
+  class Enum
+    include DataConverter[Integer, Symbol | Integer, untyped]
+
+    attr_reader native_type: Type
+    attr_reader tag: Symbol?
+    def initialize: (Enumerable[Symbol | Integer], ?Symbol? tag, *untyped) -> void
+                  | (Type native_type, Enumerable[Symbol | Integer], ?Symbol? tag, *untyped) -> void
+
+    def []: (Symbol query) -> Integer?
+          | (Integer query) -> Symbol?
+    def symbol_map: () -> Hash[Symbol, Integer]
+    alias to_h symbol_map
+    alias to_hash symbol_map
+    def symbols: () -> Array[Symbol]
+    def to_native: (Symbol | int value, untyped ctx) -> Integer
+  end
+
+  class Bitmask < Enum
+    def initialize: ...
+
+    def []: (*Symbol query) -> Integer
+          | (Array[Symbol] query) -> Integer
+          | (*Integer query) -> Array[Symbol]
+          | (Array[Integer] query) -> Array[Symbol]
+    def from_native: (Integer, untyped ctx) -> Array[Symbol | Integer]
+    def to_native: (Array[Symbol | int] value, untyped ctx) -> Integer
+                 | ...
+  end
+end

data/sig/ffi/errno.rbs

@@ -0,0 +1,8 @@
+module FFI
+  module LastError
+    def self?.error: () -> Integer
+    def self?.error=: (Integer) -> Integer
+    def self?.winapi_error: () -> Integer?
+    def self?.winapi_error=: (Integer? error) -> void
+  end
+end

data/sig/ffi/function.rbs

@@ -0,0 +1,39 @@
+module FFI
+  interface _Function
+    # TODO: leads to a endless recursion when used with -rrbs/test/setup
+    # def attach: (Module mod, String name) -> self
+    def call: (*untyped args) -> untyped
+    def param_types: () -> Array[Type]
+    def return_type: () -> Type
+  end
+
+  class Function < Pointer
+    include _Function
+    # ?blocking: boolish?, ?convention: Library::convention?, ?enums: Enums?
+    def initialize:
+      (
+        ffi_type return_type, Array[ffi_type] param_types,
+        ?Hash[Symbol, untyped] options
+      ) { (*untyped) -> untyped } -> self
+    | (
+        ffi_type return_type, Array[ffi_type] param_types, Proc | Pointer proc,
+        ?Hash[Symbol, untyped] options
+      ) -> self
+
+    def autorelease?: ...
+    alias autorelease autorelease?
+    def autorelease=: ...
+    def free: () -> self
+  end
+
+  class VariadicInvoker
+    include _Function
+    def initialize:
+      (
+        Pointer function, Array[ffi_type] parameter_types, ffi_type return_type,
+        Hash[Symbol, untyped] options #TODO
+      ) -> void
+
+    def invoke: (Array[Type] parameter_types, Array[untyped] parameter_values) -> untyped
+  end
+end

data/sig/ffi/library.rbs

@@ -0,0 +1,42 @@
+module FFI
+  module Library
+    type convention = :default | :stdcall
+    type ffi_lib_flag = :global | :local | :lazy | :now
+    type ffi_lib_type = ffi_auto_type | singleton(Struct)
+
+    CURRENT_PROCESS: current_process
+    LIBC: String
+    FlagsMap: Hash[ffi_lib_flag, Integer]
+
+    def self.extended: ...
+
+    def attach_function: (           _ToS func, Array[ffi_lib_type] args,  ffi_lib_type? returns, ?blocking: boolish, ?convention: convention, ?enums: Enums, ?type_map: type_map) -> (Function | VariadicInvoker)
+                       | (_ToS name, _ToS func, Array[ffi_lib_type] args, ?ffi_lib_type? returns, ?blocking: boolish, ?convention: convention, ?enums: Enums, ?type_map: type_map) -> (Function | VariadicInvoker)
+    def attach_variable: (?_ToS mname, _ToS cname, ffi_lib_type type) -> DynamicLibrary::Symbol
+    def attached_functions: () -> Hash[Symbol, Function | VariadicInvoker]
+    def attached_variables: () -> Hash[Symbol, Type | singleton(Struct)]
+
+    def bitmask: (?Type native_type, Symbol name, Array[Symbol | Integer] values) -> Bitmask
+               | (?Type native_type, *Symbol | Integer args) -> Bitmask
+               | (?Type native_type, Array[Symbol | Integer] values) -> Bitmask
+    def enum: (?Type native_type, Symbol name, Array[Symbol | Integer] values) -> Enum
+            | (?Type native_type, *Symbol | Integer args) -> Enum
+            | (?Type native_type, Array[Symbol | Integer] values) -> Enum
+    def enum_type: (Symbol name) -> Enum?
+    def enum_for: (Symbol name) -> Integer?
+
+    def callback: (?Symbol name, Array[ffi_lib_type] params, ffi_lib_type ret) -> CallbackInfo
+    def ffi_convention: (?convention? convention) -> convention
+    def ffi_lib: (*_ToS names) -> Array[DynamicLibrary]
+    def ffi_lib_flags: (*ffi_lib_flag flags) -> Integer
+    def ffi_libraries: () -> Array[DynamicLibrary]
+    def find_type: (ffi_lib_type t) -> Type
+    def freeze: () -> void
+    def function_names: (_ToS name, Array[Type | singleton(Struct)] arg_types) -> Array[String]
+    def typedef: [T < Type, N, R, C] (T old, Symbol | DataConverter[N, R, C] add, ?untyped) -> T
+               | (Symbol old, Symbol add, ?untyped) -> (Type | Enum)
+               | [X < DataConverter[N, R, C], N, R, C] (X old, Symbol add, ?untyped) -> Type::Mapped[X, N, R, C]
+               | (:enum old, Array[Symbol | Integer] add, ?untyped) -> Enum
+               | (:enum old, Symbol | Type add, Array[Symbol | Integer] info) -> Enum
+  end
+end