This commit is contained in:
@@ -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
|
||||
@@ -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 | ^(self) -> void | Releaser::_Proc[self] 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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -0,0 +1,9 @@
|
||||
module FFI
|
||||
class DynamicLibrary
|
||||
# TODO
|
||||
|
||||
class Symbol < Pointer
|
||||
# TODO
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -0,0 +1,86 @@
|
||||
module FFI
|
||||
class Type
|
||||
INT8: Builtin
|
||||
SCHAR: Builtin
|
||||
CHAR: Builtin
|
||||
UINT8: Builtin
|
||||
UCHAR: Builtin
|
||||
INT16: Builtin
|
||||
SHORT: Builtin
|
||||
SSHORT: Builtin
|
||||
UINT16: Builtin
|
||||
USHORT: Builtin
|
||||
INT32: Builtin
|
||||
INT: Builtin
|
||||
SINT: Builtin
|
||||
UINT32: Builtin
|
||||
UINT: Builtin
|
||||
INT64: Builtin
|
||||
LONG_LONG: Builtin
|
||||
SLONG_LONG: Builtin
|
||||
UINT64: Builtin
|
||||
ULONG_LONG: Builtin
|
||||
LONG: Builtin
|
||||
SLONG: Builtin
|
||||
ULONG: Builtin
|
||||
FLOAT32: Builtin
|
||||
FLOAT: Builtin
|
||||
FLOAT64: Builtin
|
||||
DOUBLE: Builtin
|
||||
LONGDOUBLE: Builtin
|
||||
POINTER: Builtin
|
||||
BOOL: Builtin
|
||||
STRING: Builtin
|
||||
BUFFER_IN: Builtin
|
||||
BUFFER_OUT: Builtin
|
||||
BUFFER_INOUT: Builtin
|
||||
VARARGS: Builtin
|
||||
VOID: Builtin
|
||||
end
|
||||
|
||||
module NativeType
|
||||
INT8: Type::Builtin
|
||||
UINT8: Type::Builtin
|
||||
INT16: Type::Builtin
|
||||
UINT16: Type::Builtin
|
||||
INT32: Type::Builtin
|
||||
UINT32: Type::Builtin
|
||||
INT64: Type::Builtin
|
||||
UINT64: Type::Builtin
|
||||
LONG: Type::Builtin
|
||||
ULONG: Type::Builtin
|
||||
FLOAT32: Type::Builtin
|
||||
FLOAT64: Type::Builtin
|
||||
LONGDOUBLE: Type::Builtin
|
||||
POINTER: Type::Builtin
|
||||
BOOL: Type::Builtin
|
||||
STRING: Type::Builtin
|
||||
BUFFER_IN: Type::Builtin
|
||||
BUFFER_OUT: Type::Builtin
|
||||
BUFFER_INOUT: Type::Builtin
|
||||
VARARGS: Type::Builtin
|
||||
VOID: Type::Builtin
|
||||
end
|
||||
|
||||
TYPE_INT8: Type::Builtin
|
||||
TYPE_UINT8: Type::Builtin
|
||||
TYPE_INT16: Type::Builtin
|
||||
TYPE_UINT16: Type::Builtin
|
||||
TYPE_INT32: Type::Builtin
|
||||
TYPE_UINT32: Type::Builtin
|
||||
TYPE_INT64: Type::Builtin
|
||||
TYPE_UINT64: Type::Builtin
|
||||
TYPE_LONG: Type::Builtin
|
||||
TYPE_ULONG: Type::Builtin
|
||||
TYPE_FLOAT32: Type::Builtin
|
||||
TYPE_FLOAT64: Type::Builtin
|
||||
TYPE_LONGDOUBLE: Type::Builtin
|
||||
TYPE_POINTER: Type::Builtin
|
||||
TYPE_BOOL: Type::Builtin
|
||||
TYPE_STRING: Type::Builtin
|
||||
TYPE_BUFFER_IN: Type::Builtin
|
||||
TYPE_BUFFER_OUT: Type::Builtin
|
||||
TYPE_BUFFER_INOUT: Type::Builtin
|
||||
TYPE_VARARGS: Type::Builtin
|
||||
TYPE_VOID: Type::Builtin
|
||||
end
|
||||
@@ -0,0 +1,42 @@
|
||||
module FFI
|
||||
type pointer = Pointer::_ToPtr? | Integer
|
||||
class Pointer < AbstractMemory
|
||||
interface _ToPtr
|
||||
def to_ptr: () -> Pointer
|
||||
end
|
||||
include _ToPtr
|
||||
|
||||
SIZE: Integer
|
||||
NULL: Pointer
|
||||
def self.size: () -> Integer
|
||||
|
||||
def initialize: (?AbstractMemory::type_size type, (Pointer | Integer) address) -> void
|
||||
def +: (Integer offset) -> Pointer
|
||||
def ==: (Pointer? other) -> bool
|
||||
def address: () -> Integer
|
||||
alias to_i address
|
||||
def autorelease?: () -> bool
|
||||
def autorelease=: (boolish autorelease) -> boolish
|
||||
def free: () -> self
|
||||
def inspect: ...
|
||||
def null?: () -> bool
|
||||
def order: () -> AbstractMemory::order_out
|
||||
| (AbstractMemory::order_in) -> Pointer
|
||||
def read: (ffi_type type) -> top
|
||||
def read_array_of_type: (ffi_auto_type type, Symbol reader, Integer length) -> Array[top]
|
||||
def read_string: (?Integer? len) -> String
|
||||
def read_string_length: (Integer len) -> String
|
||||
def read_string_to_null: () -> String
|
||||
def slice: (Integer offset, Integer length) -> Pointer
|
||||
def type_size: () -> Integer
|
||||
def write: (ffi_type type, top value) -> nil
|
||||
def write_array_of_type: (ffi_auto_type type, Symbol writer, Array[top]) -> self
|
||||
def write_string: (String str, ?Integer? len) -> self
|
||||
def write_string_length: (String str, Integer len) -> self
|
||||
end
|
||||
|
||||
class MemoryPointer < Pointer
|
||||
def initialize: (AbstractMemory::type_size size, ?Integer count, ?boolish clear) -> self
|
||||
def self.from_string: (String s) -> instance
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,76 @@
|
||||
module FFI
|
||||
class Struct[out P < AbstractMemory, unchecked out E]
|
||||
type layout = Library::ffi_lib_type | singleton(StructLayout::Field) | [layout, Integer]
|
||||
|
||||
type ptr = Type::Mapped[
|
||||
StructByReference[Struct[AbstractMemory, untyped], AbstractMemory],
|
||||
AbstractMemory, instance, untyped
|
||||
]
|
||||
def self.ptr: (?untyped flags) -> ptr # https://github.com/ffi/ffi/issues/1073
|
||||
alias self.by_ref self.ptr
|
||||
def self.in: () -> ptr
|
||||
def self.out: () -> ptr
|
||||
def self.val: () -> StructByValue[singleton(Struct)]
|
||||
alias self.by_value self.val
|
||||
|
||||
alias self.alloc_inout self.new
|
||||
alias self.alloc_in self.new
|
||||
alias self.alloc_out self.new
|
||||
alias self.new_inout self.new
|
||||
alias self.new_in self.new
|
||||
alias self.new_out self.new
|
||||
|
||||
def self.auto_ptr: () -> Type::Mapped[
|
||||
ManagedStructConverter[ManagedStruct[AutoPointer, untyped], AutoPointer],
|
||||
Pointer, instance, untyped
|
||||
]
|
||||
def self.layout: (*layout | Integer) -> StructLayout
|
||||
| (Hash[Symbol, layout]) -> StructLayout
|
||||
def self.size=: (Integer size) -> Integer
|
||||
|
||||
def self?.alignment: () -> Integer
|
||||
def self?.members: () -> Array[Symbol]
|
||||
def self?.offset_of: (Symbol name) -> Integer
|
||||
def self?.offsets: () -> Array[[Symbol, Integer]]
|
||||
def self?.size: -> Integer
|
||||
|
||||
def initialize: (?P pointer, *layout args) -> void
|
||||
def []: (Symbol field_name) -> E
|
||||
def []=: (Symbol field_name, E value) -> E
|
||||
alias align alignment
|
||||
def clear: () -> self
|
||||
def layout: () -> StructLayout
|
||||
def null?: () -> bool
|
||||
def order: (AbstractMemory::order_in order) -> Struct[P, E]
|
||||
| () -> AbstractMemory::order_out
|
||||
def pointer: () -> P
|
||||
alias to_ptr pointer
|
||||
def values: () -> Array[E]
|
||||
|
||||
class InlineArray[out P < AbstractMemory, unchecked out E]
|
||||
include Enumerable[E]
|
||||
include AbstractMemory::_Size
|
||||
|
||||
def initialize: (P memory, StructLayout::Field field) -> self
|
||||
def []: (Integer index) -> E
|
||||
def []=: (Integer index, E value) -> E
|
||||
def each: () { (E) -> void } -> self
|
||||
def to_a: () -> Array[E]
|
||||
def to_ptr: () -> P
|
||||
end
|
||||
|
||||
class ManagedStructConverter[S < ManagedStruct[P, untyped], P < AutoPointer] < StructByReference[S, P]
|
||||
def initialize: ...
|
||||
def from_native: (Pointer ptr, untyped ctx) -> S
|
||||
end
|
||||
end
|
||||
|
||||
class ManagedStruct[out P < AutoPointer, unchecked out E] < Struct[P, E]
|
||||
def self.release: (AbstractMemory ptr) -> void
|
||||
def initialize: (Pointer pointer) -> self
|
||||
end
|
||||
|
||||
class Union[out P < AbstractMemory, unchecked out E] < Struct[P, E]
|
||||
def self.builder: () -> StructLayoutBuilder
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,11 @@
|
||||
module FFI
|
||||
class StructByReference[S < Struct[P, untyped], P < AbstractMemory]
|
||||
include DataConverter[P, S, untyped]
|
||||
attr_reader struct_class: Struct[P, untyped]
|
||||
|
||||
def initialize: (S struct_class) -> void
|
||||
def from_native: (P value, untyped ctx) -> S
|
||||
def native_type: () -> Type::Builtin
|
||||
def to_native: (S? value, untyped ctx) -> P
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,7 @@
|
||||
module FFI
|
||||
class StructByValue[C < singleton(Struct)] < Type
|
||||
def initialize: (C) -> self
|
||||
def layout: () -> StructLayout
|
||||
def struct_class: () -> C
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,9 @@
|
||||
module FFI
|
||||
class StructLayout
|
||||
#TODO
|
||||
|
||||
class Field
|
||||
#TODO
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,5 @@
|
||||
module FFI
|
||||
class StructLayoutBuilder
|
||||
#TODO
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,39 @@
|
||||
module FFI
|
||||
class Type
|
||||
class Array = ArrayType
|
||||
class Function = FunctionType
|
||||
class Struct = StructByValue
|
||||
|
||||
include AbstractMemory::_Size
|
||||
def initialize: (Integer | Type value) -> self
|
||||
def alignment: () -> Integer
|
||||
def inspect: ...
|
||||
|
||||
class Builtin < Type
|
||||
def inspect: ...
|
||||
end
|
||||
|
||||
class Mapped[X < _DataConverter[N, R, C], N, R, C]
|
||||
include _DataConverter[N, R, C]
|
||||
|
||||
def initialize: (X converter) -> self
|
||||
def converter: () -> X
|
||||
end
|
||||
end
|
||||
|
||||
class ArrayType
|
||||
def initialize: (Type component_type, Integer length) -> self
|
||||
def element_type: -> Type
|
||||
def length: -> Integer
|
||||
end
|
||||
|
||||
class FunctionType < Type
|
||||
def initialize:
|
||||
(
|
||||
ffi_type return_type, Array[ffi_type] param_types,
|
||||
?blocking: boolish, ?convention: Library::convention, ?enums: Enums
|
||||
) -> self
|
||||
def param_types: () -> Array[Type]
|
||||
def return_type: () -> Type
|
||||
end
|
||||
end
|
||||
Reference in New Issue
Block a user