korlibs-ffi-legacy/korlibs.ffi

Package-level declarations

Types

ExecutableResolver

open class ExecutableResolver

FFIArena

actual class FFIArena

expect class FFIArena

actual class FFIArena

FFICallback

interface FFICallback

FFIDelegateBoolProperty

inline class FFIDelegateBoolProperty(val offset: Int)

FFIDelegateByteProperty

inline class FFIDelegateByteProperty(val offset: Int)

FFIDelegateDoubleProperty

inline class FFIDelegateDoubleProperty(val offset: Int)

FFIDelegateFFIPointerProperty

inline class FFIDelegateFFIPointerProperty(val offset: Int)

FFIDelegateFFIPointerPropertyT

inline class FFIDelegateFFIPointerPropertyT<T>(val offset: Int)

FFIDelegateFixedBytesProperty

class FFIDelegateFixedBytesProperty(val offset: Int, val size: Int)

FFIDelegateFloatProperty

inline class FFIDelegateFloatProperty(val offset: Int)

FFIDelegateIntProperty

inline class FFIDelegateIntProperty(val offset: Int)

FFIDelegateLongProperty

inline class FFIDelegateLongProperty(val offset: Int)

FFIDelegateNativeDoubleProperty

inline class FFIDelegateNativeDoubleProperty(val offset: Int)

FFIDelegateNativeLongProperty

inline class FFIDelegateNativeLongProperty(val offset: Int)

FFIDelegateShortProperty

inline class FFIDelegateShortProperty(val offset: Int)

FFIFuncConfig

data class FFIFuncConfig(val wideString: Boolean = false, val altAbiConvention: Boolean = false)

FFILib

open class FFILib(val paths: List<String>, val lazyCreate: Boolean = true) : AutoCloseable

FFILibSym

interface FFILibSym : AutoCloseable

FFILibSymJS

class FFILibSymJS(val lib: FFILib) : FFILibSym

FFILibSymJVM

class FFILibSymJVM(val lib: FFILib) : FFILibSym

FFIMemLayoutBuilder

open class FFIMemLayoutBuilder

FFIMemory

actual class FFIMemory

expect class FFIMemory

actual typealias FFIMemory = Uint8Array

actual typealias FFIMemory = Memory

actual typealias FFIMemory = ByteArray

actual class FFIMemory

FFINativeLong

class FFINativeLong(val value: Long)

Might be 32-bit or 64-bit depending on the OS

FFIPointer

actual class FFIPointer

expect class FFIPointer

actual typealias FFIPointer = DenoPointer

actual typealias FFIPointer = Pointer

actual class FFIPointer

FFIPointerArray

data class FFIPointerArray(val data: IntArray) : List<FFIPointer?>

FFIStructure

open class FFIStructure(var ptr: FFIPointer?)

FFITypedPointer

inline class FFITypedPointer<T>(val pointer: FFIPointer)

FFIVarargs

@JvmInline

value class FFIVarargs(val args: List<Any?>)

FuncType

class FuncType(val params: List<KType?>, val ret: KType?)

LDLibraries

open class LDLibraries

LibraryResolver

open class LibraryResolver

SymbolResolverFFILib

open class SymbolResolverFFILib(val resolve: (String) -> FFIPointer?) : FFILib

WebAssembly

external class WebAssembly

Properties

address

actual val FFIPointer?.address: Long

expect val FFIPointer?.address: Long

actual val FFIPointer?.address: Long

DirectBuffer_addressHandle

val DirectBuffer_addressHandle: MethodHandle

FFI_NATIVE_LONG_SIZE

val FFI_NATIVE_LONG_SIZE: Int

FFI_POINTER_SIZE

actual val FFI_POINTER_SIZE: Int

expect val FFI_POINTER_SIZE: Int

actual val FFI_POINTER_SIZE: Int = 8

actual val FFI_POINTER_SIZE: Int

FFI_SUPPORTED

actual val FFI_SUPPORTED: Boolean = false

expect val FFI_SUPPORTED: Boolean

actual val FFI_SUPPORTED: Boolean

actual val FFI_SUPPORTED: Boolean = true

actual val FFI_SUPPORTED: Boolean = false

pointer

actual val FFIMemory.pointer: FFIPointer

actual val Buffer.pointer: FFIPointer

expect val FFIMemory.~~pointer~~: FFIPointer

expect val Buffer.~~pointer~~: FFIPointer

actual val Buffer.pointer: FFIPointer

actual val FFIMemory.pointer: FFIPointer

actual val Buffer.pointer: FFIPointer

str

actual val FFIPointer?.str: String

expect val FFIPointer?.str: String

actual val FFIPointer?.str: String

Functions

allocBytes

inline fun FFIArena.allocBytes(size: Int, gen: (Int) -> Byte): FFIPointer

arraycopy

actual fun arraycopy(src: FFIPointer, srcPos: Int, dst: FFIPointer, dstPos: Int, length: Int)

expect fun arraycopy(src: FFIPointer, srcPos: Int, dst: FFIPointer, dstPos: Int, length: Int)

fun arraycopy(src: FFIPointer, srcPos: Int, dst: Buffer, dstPos: Int, length: Int)

fun arraycopy(src: Buffer, srcPos: Int, dst: FFIPointer, dstPos: Int, length: Int)

actual fun arraycopy(src: FFIPointer, srcPos: Int, dst: FFIPointer, dstPos: Int, length: Int)

castToFunc

actual fun <T> FFIPointer.castToFunc(type: KType, config: FFIFuncConfig): T

inline fun <T> FFIPointer.castToFunc(): T

expect fun <T> FFIPointer.castToFunc(type: KType, config: FFIFuncConfig = FFIFuncConfig.DEFAULT): T

actual fun <T> FFIPointer.castToFunc(type: KType, config: FFIFuncConfig): T

CreateFFIMemory

actual fun CreateFFIMemory(bytes: ByteArray): FFIMemory

actual fun CreateFFIMemory(size: Int): FFIMemory

expect fun ~~CreateFFIMemory~~(bytes: ByteArray): FFIMemory

expect fun ~~CreateFFIMemory~~(size: Int): FFIMemory

actual fun CreateFFIMemory(bytes: ByteArray): FFIMemory

actual fun CreateFFIMemory(size: Int): FFIMemory

actual fun CreateFFIMemory(bytes: ByteArray): FFIMemory

actual fun CreateFFIMemory(size: Int): FFIMemory

actual fun CreateFFIMemory(bytes: ByteArray): FFIMemory

actual fun CreateFFIMemory(size: Int): FFIMemory

actual fun CreateFFIMemory(bytes: ByteArray): FFIMemory

actual fun CreateFFIMemory(size: Int): FFIMemory

CreateFFIPointer

actual fun CreateFFIPointer(ptr: Long): FFIPointer?

expect fun ~~CreateFFIPointer~~(ptr: Long): FFIPointer?

actual fun CreateFFIPointer(ptr: Long): FFIPointer?

@JvmName(name = "FFIPointerCreation")

actual fun CreateFFIPointer(ptr: Long): FFIPointer?

createJNAFunctionToPlainFunc

inline fun <T : Function<*>> createJNAFunctionToPlainFunc(func: Function, config: FFIFuncConfig): T

fun <T : Function<*>> createJNAFunctionToPlainFunc(func: Function?, type: KType, config: FFIFuncConfig, name: String?): T

FFICreateProxyFunction

actual fun <T> FFICreateProxyFunction(type: KType, handler: (args: Array<Any?>) -> Any?): T

inline fun <T> FFICreateProxyFunction(noinline handler: (args: Array<Any?>) -> Any?): T

expect fun <T> FFICreateProxyFunction(type: KType, handler: (args: Array<Any?>) -> Any?): T

actual fun <T> FFICreateProxyFunction(type: KType, handler: (args: Array<Any?>) -> Any?): T

FFILibSym

actual fun FFILibSym(lib: FFILib): FFILibSym

expect fun FFILibSym(lib: FFILib): FFILibSym

actual fun FFILibSym(lib: FFILib): FFILibSym

FFIMemory

inline fun FFIMemory(bytes: ByteArray, unit: Unit = Unit): FFIMemory

inline fun FFIMemory(size: Int, unit: Unit = Unit): FFIMemory

FFIPointer

inline fun FFIPointer(ptr: Long, unit: Unit = Unit): FFIPointer?

ffiPointerArrayOf

fun ffiPointerArrayOf(vararg pointers: FFIPointer?): FFIPointerArray

ffiScoped

inline fun <T> ffiScoped(block: FFIArena.() -> T): T

funcToDenoDef

fun KType.funcToDenoDef(): dynamic

get

operator fun FFITypedPointer<FFIPointer?>.get(index: Int): FFIPointer?

@JvmName(name = "set_typedPointer")

operator fun <T> FFITypedPointer<FFITypedPointer<T>>.get(index: Int): FFITypedPointer<T>?

operator fun FFITypedPointer<Byte>.get(index: Int): Byte

operator fun FFITypedPointer<Double>.get(index: Int): Double

operator fun FFITypedPointer<Float>.get(index: Int): Float

operator fun FFITypedPointer<Int>.get(index: Int): Int

operator fun FFITypedPointer<Long>.get(index: Int): Long

operator fun FFITypedPointer<Short>.get(index: Int): Short

getAlignedF32

fun FFIPointer.getAlignedF32(offset: Int = 0): Float

getAlignedF64

fun FFIPointer.getAlignedF64(offset: Int = 0): Double

getAlignedFFIPointer

fun FFIPointer.getAlignedFFIPointer(offset: Int = 0): FFIPointer?

getAlignedS16

fun FFIPointer.getAlignedS16(offset: Int = 0): Short

getAlignedS32

fun FFIPointer.getAlignedS32(offset: Int = 0): Int

getAlignedS64

fun FFIPointer.getAlignedS64(offset: Int = 0): Long

getByteArray

fun FFIPointer.getByteArray(size: Int, byteOffset: Int = 0): ByteArray

getCString

fun getCString(ptr: FFIPointer?): String?

getDataView

fun FFIPointer.getDataView(offset: Int, size: Int): DataView

getF32

actual fun FFIPointer.getF32(byteOffset: Int): Float

expect fun FFIPointer.getF32(byteOffset: Int = 0): Float

actual fun FFIPointer.getF32(byteOffset: Int): Float

getF64

actual fun FFIPointer.getF64(byteOffset: Int): Double

expect fun FFIPointer.getF64(byteOffset: Int = 0): Double

actual fun FFIPointer.getF64(byteOffset: Int): Double

getFFIPointer

fun FFIPointer.getFFIPointer(byteOffset: Int = 0): FFIPointer?

fun Buffer.getFFIPointer(offset: Int): FFIPointer?

getIntArray

actual fun FFIPointer.getIntArray(size: Int, byteOffset: Int): IntArray

expect fun FFIPointer.getIntArray(size: Int, byteOffset: Int = 0): IntArray

actual fun FFIPointer.getIntArray(size: Int, byteOffset: Int): IntArray

getS16

actual fun FFIPointer.getS16(byteOffset: Int): Short

expect fun FFIPointer.getS16(byteOffset: Int = 0): Short

actual fun FFIPointer.getS16(byteOffset: Int): Short

getS32

actual fun FFIPointer.getS32(byteOffset: Int): Int

expect fun FFIPointer.getS32(byteOffset: Int = 0): Int

actual fun FFIPointer.getS32(byteOffset: Int): Int

getS64

actual fun FFIPointer.getS64(byteOffset: Int): Long

expect fun FFIPointer.getS64(byteOffset: Int = 0): Long

actual fun FFIPointer.getS64(byteOffset: Int): Long

getS8

actual fun FFIPointer.getS8(byteOffset: Int): Byte

expect fun FFIPointer.getS8(byteOffset: Int = 0): Byte

actual fun FFIPointer.getS8(byteOffset: Int): Byte

getShortArray

fun FFIPointer.getShortArray(size: Int, byteOffset: Int = 0): ShortArray

getStringz

actual fun FFIPointer.getStringz(): String

expect fun FFIPointer.getStringz(): String

actual fun FFIPointer.getStringz(): String

getUnalignedFFIPointer

fun Buffer.getUnalignedFFIPointer(offset: Int): FFIPointer?

getWideStringz

actual fun FFIPointer.getWideStringz(): String

expect fun FFIPointer.getWideStringz(): String

actual fun FFIPointer.getWideStringz(): String

plus

operator fun FFIPointer.plus(offset: Int): FFIPointer

reinterpret

fun <T> FFITypedPointer<*>.reinterpret(): FFITypedPointer<T>

set

operator fun FFITypedPointer<FFIPointer?>.set(index: Int, value: FFIPointer?)

@JvmName(name = "set_typedPointer")

operator fun <T> FFITypedPointer<FFITypedPointer<T>>.set(index: Int, value: FFITypedPointer<T>?)

operator fun FFITypedPointer<Byte>.set(index: Int, value: Byte)

operator fun FFITypedPointer<Double>.set(index: Int, value: Double)

operator fun FFITypedPointer<Float>.set(index: Int, value: Float)

operator fun FFITypedPointer<Int>.set(index: Int, value: Int)

operator fun FFITypedPointer<Long>.set(index: Int, value: Long)

operator fun FFITypedPointer<Short>.set(index: Int, value: Short)

set16

actual fun FFIPointer.set16(value: Short, byteOffset: Int)

expect fun FFIPointer.set16(value: Short, byteOffset: Int = 0)

actual fun FFIPointer.set16(value: Short, byteOffset: Int)

set32

actual fun FFIPointer.set32(value: Int, byteOffset: Int)

expect fun FFIPointer.set32(value: Int, byteOffset: Int = 0)

actual fun FFIPointer.set32(value: Int, byteOffset: Int)

set64

actual fun FFIPointer.set64(value: Long, byteOffset: Int)

expect fun FFIPointer.set64(value: Long, byteOffset: Int = 0)

actual fun FFIPointer.set64(value: Long, byteOffset: Int)

set8

actual fun FFIPointer.set8(value: Byte, byteOffset: Int)

expect fun FFIPointer.set8(value: Byte, byteOffset: Int = 0)

actual fun FFIPointer.set8(value: Byte, byteOffset: Int)

setAligned16

fun FFIPointer.setAligned16(value: Short, offset: Int = 0)

setAligned32

fun FFIPointer.setAligned32(value: Int, offset: Int = 0)

setAligned64

fun FFIPointer.setAligned64(value: Long, offset: Int = 0)

setAlignedF32

fun FFIPointer.setAlignedF32(value: Float, offset: Int = 0)

setAlignedF64

fun FFIPointer.setAlignedF64(value: Double, offset: Int = 0)

setAlignedFFIPointer

fun FFIPointer.setAlignedFFIPointer(value: FFIPointer?, offset: Int = 0)

setF32

actual fun FFIPointer.setF32(value: Float, byteOffset: Int)

expect fun FFIPointer.setF32(value: Float, byteOffset: Int = 0)

actual fun FFIPointer.setF32(value: Float, byteOffset: Int)

setF64

actual fun FFIPointer.setF64(value: Double, byteOffset: Int)

expect fun FFIPointer.setF64(value: Double, byteOffset: Int = 0)

actual fun FFIPointer.setF64(value: Double, byteOffset: Int)

setFFIPointer

fun FFIPointer.setFFIPointer(value: FFIPointer?, byteOffset: Int = 0)

fun Buffer.setFFIPointer(offset: Int, value: FFIPointer?)

setUnalignedFFIPointer

fun Buffer.setUnalignedFFIPointer(offset: Int, value: FFIPointer?)

strlen

fun FFIPointer.strlen(max: Int = Int.MAX_VALUE): Int

toDenoFFI

fun KClassifier.toDenoFFI(ret: Boolean): dynamic

fun KType.toDenoFFI(ret: Boolean): dynamic

typed

fun <T> FFIPointer.typed(): FFITypedPointer<T>

usePointer

actual inline fun <T> FFIMemory.usePointer(block: (pointer: FFIPointer) -> T): T

actual inline fun <T> Buffer.usePointer(block: (pointer: FFIPointer) -> T): T

expect inline fun <T> FFIMemory.usePointer(block: (pointer: FFIPointer) -> T): T

expect inline fun <T> Buffer.usePointer(block: (pointer: FFIPointer) -> T): T

actual inline fun <T> Buffer.usePointer(block: (pointer: FFIPointer) -> T): T

actual inline fun <T> FFIMemory.usePointer(block: (pointer: FFIPointer) -> T): T

actual inline fun <T> Buffer.usePointer(block: (pointer: FFIPointer) -> T): T

withOffset

fun FFIPointer.withOffset(offset: Int): FFIPointer?