mirror of
https://github.com/lune-org/lune.git
synced 2025-04-05 02:50:57 +01:00
140 lines
3 KiB
Text
140 lines
3 KiB
Text
export type CType<T> = {
|
|
size: number,
|
|
signedness: boolean,
|
|
|
|
ptr: <K>(self: CType<T>) -> CPtr<K>,
|
|
box: <K>(self: CType<T>, val: K) -> Box,
|
|
from: <K>(self: CType<T>, ud: any, offset: number?) -> K,
|
|
into: <K>(self: CType<T>, ud: any, value: K, offset: number?) -> (),
|
|
arr: <K>(self: CType<T>, len: number) -> CArr<K>,
|
|
-- FIXME: intoType is of type `CTypes`, but that leads to recursive types
|
|
cast: <F, I>(self: CType<T>, intoType: any, from: F, into: I) -> ()
|
|
} & { ["__phantom"]: T }
|
|
|
|
export type CPtr<T> = {
|
|
size: number,
|
|
inner: T?,
|
|
}
|
|
|
|
export type CArr<T> = {
|
|
size: number,
|
|
length: number,
|
|
inner: {T}?,
|
|
|
|
offset: (self: CArr<T>, offset: number) -> number,
|
|
ptr: <K>(self: CArr<T>) -> CPtr<K>,
|
|
box: <K>(self: CArr<T>, table: { K }) -> Box,
|
|
from: <K>(self: CArr<T>, ud: any, offset: number?) -> { K },
|
|
into: <K>(self: CArr<T>, ud: any, value: { K }, offset: number?) -> (),
|
|
}
|
|
|
|
-- Numeric types --
|
|
export type u8 = CType<"u8">
|
|
export type u16 = CType<"u16">
|
|
export type u32 = CType<"u32">
|
|
export type u64 = CType<"u64">
|
|
export type u128 = CType<"u128">
|
|
export type i8 = CType<"i8">
|
|
export type i16 = CType<"i16">
|
|
export type i32 = CType<"i32">
|
|
export type i64 = CType<"i64">
|
|
export type i128 = CType<"i128">
|
|
export type f32 = CType<"f32">
|
|
export type f64 = CType<"f64">
|
|
export type usize = CType<"usize">
|
|
export type isize = CType<"isize">
|
|
|
|
-- C types --
|
|
export type char = CType<"char">
|
|
export type float = CType<"float">
|
|
export type double = CType<"double">
|
|
export type uchar = CType<"uchar">
|
|
export type schar = CType<"schar">
|
|
export type short = CType<"short">
|
|
export type ushort = CType<"ushort">
|
|
export type int = CType<"int">
|
|
export type uint = CType<"uint">
|
|
export type long = CType<"long">
|
|
export type ulong = CType<"ulong">
|
|
export type longlong = CType<"longlong">
|
|
export type ulonglong = CType<"ulonglong">
|
|
export type CFn = {
|
|
caller: () -> Callable
|
|
}
|
|
|
|
export type CTypes =
|
|
| u8
|
|
| u16
|
|
| u32
|
|
| u64
|
|
| u128
|
|
| i8
|
|
| i16
|
|
| i32
|
|
| i64
|
|
| i128
|
|
| f32
|
|
| f64
|
|
| usize
|
|
| isize
|
|
| char
|
|
| float
|
|
| double
|
|
| uchar
|
|
| schar
|
|
| short
|
|
| ushort
|
|
| int
|
|
| uint
|
|
| long
|
|
| ulong
|
|
| longlong
|
|
| ulonglong
|
|
|
|
export type Ref = {
|
|
deref: (self: Ref) -> Ref,
|
|
offset: (self: Ref, offset: number) -> Ref,
|
|
ref: (self: Ref) -> Ref,
|
|
isNullptr: (self: Ref) -> boolean,
|
|
}
|
|
|
|
export type Box = {
|
|
size: number,
|
|
|
|
zero: (self: Box) -> Box,
|
|
leak: (self: Box, offset: number?) -> Ref,
|
|
ref: (self: Box, offset: number?) -> Ref,
|
|
}
|
|
|
|
export type Library = {
|
|
find: (sym: string) -> Ref,
|
|
}
|
|
|
|
export type Callable = {
|
|
call: (...any) -> (),
|
|
}
|
|
|
|
local ffi = {}
|
|
|
|
ffi.u8 = {} :: u8
|
|
ffi.nullptr = {} :: Ref
|
|
|
|
function ffi.box(size: number): Box
|
|
return nil :: any
|
|
end
|
|
|
|
function ffi.open(path: string): Library
|
|
return nil :: any
|
|
end
|
|
|
|
function ffi.ref(): Ref
|
|
return nil :: any
|
|
end
|
|
|
|
function ffi.isInteger<T>(val: T): boolean
|
|
return nil :: any
|
|
end
|
|
|
|
function ffi.fn<T>(args: { any }, ret: CPtr<T>): CFn
|
|
return nil :: any
|
|
end
|