korge-core/korlibs.ffi

Package-level declarations

Types

ExecutableResolver

open class ExecutableResolver(val fs: SyncIO)

actual class FFIArena

expect class FFIArena

actual class FFIArena

actual class FFIArena

actual class FFIArena

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)

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

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

interface FFILibSym : Closeable

class FFILibSymJS(val lib: FFILib) : FFILibSym

class FFILibSymJVM(val lib: FFILib) : FFILibSym

FFIMemLayoutBuilder

open class FFIMemLayoutBuilder

actual class FFIMemory

expect class FFIMemory

actual class FFIMemory

actual typealias FFIMemory = Uint8Array

actual typealias FFIMemory = Memory

class FFINativeLong(val value: Long)

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

actual class FFIPointer

expect class FFIPointer

actual class FFIPointer

actual typealias FFIPointer = DenoPointer

actual typealias FFIPointer = Pointer

FFIPointerArray

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

open class FFIStructure(var ptr: FFIPointer?)

FFITypedPointer

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

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

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

open class LDLibraries(val fs: SyncIO)

LibraryResolver

open class LibraryResolver(val fs: SyncIO, val platform: Platform)

SymbolResolverFFILib

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

external class WebAssembly

Properties

actual val FFIPointer?.address: Long

expect val FFIPointer?.address: Long

actual val FFIPointer?.address: Long

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

actual val FFI_POINTER_SIZE: Int = 8

actual val FFI_POINTER_SIZE: Int = 8

actual val FFI_SUPPORTED: Boolean = false

expect val FFI_SUPPORTED: Boolean

actual val FFI_SUPPORTED: Boolean = false

actual val FFI_SUPPORTED: Boolean

actual val FFI_SUPPORTED: Boolean = true

actual val FFIMemory.pointer: FFIPointer

expect val FFIMemory.pointer: FFIPointer

actual val FFIMemory.pointer: FFIPointer

actual val FFIPointer?.str: String

expect val FFIPointer?.str: String

actual val FFIPointer?.str: String

Functions

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

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

CreateFFIPointer

actual fun CreateFFIPointer(ptr: Long): FFIPointer?

expect fun CreateFFIPointer(ptr: Long): FFIPointer?

actual 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

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

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

actual fun FFILibSym(lib: FFILib): FFILibSym

expect fun FFILibSym(lib: FFILib): FFILibSym

actual fun FFILibSym(lib: FFILib): FFILibSym

actual fun FFILibSym(lib: FFILib): FFILibSym

actual fun FFILibSym(lib: FFILib): FFILibSym

ffiPointerArrayOf

fun ffiPointerArrayOf(vararg pointers: FFIPointer?): FFIPointerArray

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

fun KType.funcToDenoDef(): dynamic

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

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

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

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

getAlignedFFIPointer

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

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

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

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

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

fun getCString(ptr: FFIPointer?): String?

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

actual fun FFIPointer.getStringz(): String

expect fun FFIPointer.getStringz(): String

actual fun FFIPointer.getStringz(): String

getUnalignedFFIPointer

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

actual fun FFIPointer.getWideStringz(): String

expect fun FFIPointer.getWideStringz(): String

actual fun FFIPointer.getWideStringz(): String

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

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

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)

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)

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)

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)

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)

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

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

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

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

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

setAlignedFFIPointer

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

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)

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)

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

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

setUnalignedFFIPointer

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

fun KClassifier.toDenoFFI(ret: Boolean): dynamic

fun KType.toDenoFFI(ret: Boolean): dynamic

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

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