ffi.c
No OneTemporary
Actions

Size

46 KB

Referenced Files

None

Subscribers

None

ffi.c
View Options

	#ifdef _WIN32
	#define WIN32_LEAN_AND_MEAN
	#include <windows.h>
	#define dlopen(name, flags) ((void *)LoadLibraryA(name))
	#define dlsym(handle, name) ((void *)GetProcAddress((HMODULE)(handle), (name)))
	#define dlclose(handle) FreeLibrary((HMODULE)(handle))
	#define dlerror() "LoadLibrary failed"
	#define RTLD_LAZY 0
	#else
	#include <dlfcn.h>
	#endif

	#include <ffi.h>
	#include <pthread.h>
	#include <stdbool.h>
	#include <stdint.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>

	#include "ant.h"
	#include "ptr.h"
	#include "errors.h"
	#include "internal.h"
	#include "silver/engine.h"

	#include "modules/buffer.h"
	#include "modules/ffi.h"
	#include "modules/symbol.h"

	enum {
	FFI_LIBRARY_NATIVE_TAG = 0x4646494cu, // FFIL
	FFI_FUNCTION_NATIVE_TAG = 0x46464946u, // FFIF
	FFI_POINTER_NATIVE_TAG = 0x46464950u, // FFIP
	FFI_CALLBACK_NATIVE_TAG = 0x46464943u, // FFIC
	};

	typedef enum {
	FFI_VALUE_VOID = 0,
	FFI_VALUE_INT8,
	FFI_VALUE_INT16,
	FFI_VALUE_INT,
	FFI_VALUE_INT64,
	FFI_VALUE_UINT8,
	FFI_VALUE_UINT16,
	FFI_VALUE_UINT64,
	FFI_VALUE_FLOAT,
	FFI_VALUE_DOUBLE,
	FFI_VALUE_POINTER,
	FFI_VALUE_STRING,
	FFI_VALUE_SPREAD,
	FFI_VALUE_UNKNOWN,
	} ffi_value_type_id_t;

	typedef struct {
	ffi_value_type_id_t id;
	ffi_type *ffi_type;
	const char *name;
	} ffi_marshaled_type_t;

	typedef struct {
	ffi_marshaled_type_t returns;
	ffi_marshaled_type_t *args;
	ffi_type **ffi_arg_types;
	size_t arg_count;
	size_t fixed_arg_count;
	bool variadic;
	} ffi_signature_t;

	typedef struct {
	ant_value_t obj;
	void *handle;
	char *path;
	bool closed;
	} ffi_library_handle_t;

	typedef struct {
	ffi_library_handle_t *library;
	ffi_signature_t signature;
	ffi_cif cif;
	void *func_ptr;
	char *symbol_name;
	} ffi_function_handle_t;

	typedef struct ffi_pointer_region_s {
	uint8_t *ptr;
	size_t size;
	size_t ref_count;
	bool size_known;
	bool owned;
	bool freed;
	} ffi_pointer_region_t;

	typedef struct {
	ffi_pointer_region_t *region;
	size_t byte_offset;
	} ffi_pointer_handle_t;

	typedef struct {
	ant_t *js;
	ant_value_t owner_obj;
	ffi_signature_t signature;
	ffi_cif cif;
	ffi_closure *closure;
	void *code_ptr;
	pthread_t owner_thread;
	bool closed;
	} ffi_callback_handle_t;

	typedef union {
	int8_t i8;
	int16_t i16;
	int32_t i32;
	int64_t i64;
	uint8_t u8;
	uint16_t u16;
	uint32_t u32;
	uint64_t u64;
	float f32;
	double f64;
	void *ptr;
	ffi_arg raw;
	} ffi_value_box_t;

	static ant_value_t g_ffi_library_proto = 0;
	static ant_value_t g_ffi_function_proto = 0;
	static ant_value_t g_ffi_pointer_proto = 0;
	static ant_value_t g_ffi_callback_proto = 0;

	static inline bool ffi_is_nullish(ant_value_t value) {
	return is_null(value) \|\| is_undefined(value);
	}

	static ffi_marshaled_type_t ffi_marshaled_type_unknown(void) {
	ffi_marshaled_type_t type = {0};
	type.id = FFI_VALUE_UNKNOWN;
	type.ffi_type = NULL;
	type.name = NULL;
	return type;
	}

	static ffi_marshaled_type_t ffi_marshaled_type_make(ffi_value_type_id_t id, const char *name) {
	ffi_marshaled_type_t type = ffi_marshaled_type_unknown();
	type.id = id;
	type.name = name;

	switch (id) {
	case FFI_VALUE_VOID: type.ffi_type = &ffi_type_void; break;
	case FFI_VALUE_INT8: type.ffi_type = &ffi_type_sint8; break;
	case FFI_VALUE_INT16: type.ffi_type = &ffi_type_sint16; break;
	case FFI_VALUE_INT: type.ffi_type = &ffi_type_sint32; break;
	case FFI_VALUE_INT64: type.ffi_type = &ffi_type_sint64; break;
	case FFI_VALUE_UINT8: type.ffi_type = &ffi_type_uint8; break;
	case FFI_VALUE_UINT16: type.ffi_type = &ffi_type_uint16; break;
	case FFI_VALUE_UINT64: type.ffi_type = &ffi_type_uint64; break;
	case FFI_VALUE_FLOAT: type.ffi_type = &ffi_type_float; break;
	case FFI_VALUE_DOUBLE: type.ffi_type = &ffi_type_double; break;
	case FFI_VALUE_POINTER: type.ffi_type = &ffi_type_pointer; break;
	case FFI_VALUE_STRING: type.ffi_type = &ffi_type_pointer; break;
	case FFI_VALUE_SPREAD:
	case FFI_VALUE_UNKNOWN:
	type.ffi_type = NULL;
	break;
	}

	return type;
	}

	static ffi_value_type_id_t ffi_type_id_from_name(const char *name) {
	if (!name) return FFI_VALUE_UNKNOWN;
	if (strcmp(name, "void") == 0) return FFI_VALUE_VOID;
	if (strcmp(name, "int8") == 0) return FFI_VALUE_INT8;
	if (strcmp(name, "int16") == 0) return FFI_VALUE_INT16;
	if (strcmp(name, "int") == 0) return FFI_VALUE_INT;
	if (strcmp(name, "int64") == 0) return FFI_VALUE_INT64;
	if (strcmp(name, "uint8") == 0) return FFI_VALUE_UINT8;
	if (strcmp(name, "uint16") == 0) return FFI_VALUE_UINT16;
	if (strcmp(name, "uint64") == 0) return FFI_VALUE_UINT64;
	if (strcmp(name, "float") == 0) return FFI_VALUE_FLOAT;
	if (strcmp(name, "double") == 0) return FFI_VALUE_DOUBLE;
	if (strcmp(name, "pointer") == 0) return FFI_VALUE_POINTER;
	if (strcmp(name, "string") == 0) return FFI_VALUE_STRING;
	if (strcmp(name, "...") == 0) return FFI_VALUE_SPREAD;
	return FFI_VALUE_UNKNOWN;
	}

	static ffi_marshaled_type_t ffi_marshaled_type_from_value(ant_t *js, ant_value_t value) {
	if (vtype(value) != T_STR) return ffi_marshaled_type_unknown();
	return ffi_marshaled_type_make(
	ffi_type_id_from_name(js_getstr(js, value, NULL)),
	js_getstr(js, value, NULL)
	);
	}

	static void ffi_signature_cleanup(ffi_signature_t *signature) {
	if (!signature) return;
	free(signature->args);
	free(signature->ffi_arg_types);
	signature->args = NULL;
	signature->ffi_arg_types = NULL;
	signature->arg_count = 0;
	signature->fixed_arg_count = 0;
	signature->variadic = false;
	signature->returns = ffi_marshaled_type_unknown();
	}

	static bool ffi_parse_signature(
	ant_t *js,
	ant_value_t value,
	bool allow_variadic,
	bool allow_string_return,
	ffi_signature_t *out,
	ant_value_t *error_out
	) {
	ant_value_t returns_val = js_mkundef();
	ant_value_t args_val = js_mkundef();
	size_t arg_count = 0;

	memset(out, 0, sizeof(*out));
	out->returns = ffi_marshaled_type_unknown();
	if (error_out) *error_out = js_mkundef();

	if (!is_object_type(value)) {
	if (error_out) *error_out = js_mkerr_typed(
	js, JS_ERR_TYPE,
	"FFI signature must be [returnType, argTypes] or { returns, args }"
	);
	return false;
	}

	returns_val = js_get(js, value, "returns");
	args_val = js_get(js, value, "args");

	if (vtype(returns_val) == T_UNDEF \|\| vtype(args_val) == T_UNDEF) {
	returns_val = js_get(js, value, "0");
	args_val = js_get(js, value, "1");
	}

	if (vtype(returns_val) != T_STR) {
	if (error_out) *error_out = js_mkerr_typed(js, JS_ERR_TYPE, "FFI return type must be a string");
	return false;
	}

	if (!is_object_type(args_val)) {
	if (error_out) *error_out = js_mkerr_typed(js, JS_ERR_TYPE, "FFI argument list must be an array-like object");
	return false;
	}

	out->returns = ffi_marshaled_type_from_value(js, returns_val);
	if (out->returns.id == FFI_VALUE_UNKNOWN \|\| out->returns.id == FFI_VALUE_SPREAD) {
	if (error_out) *error_out = js_mkerr_typed(js, JS_ERR_TYPE, "Unsupported FFI return type");
	return false;
	}

	if (!allow_string_return && out->returns.id == FFI_VALUE_STRING) {
	if (error_out) *error_out = js_mkerr_typed(
	js, JS_ERR_TYPE,
	"FFICallback does not support string return values"
	);
	return false;
	}

	ant_value_t len_val = js_get(js, args_val, "length");
	arg_count = vtype(len_val) == T_NUM ? (size_t)js_getnum(len_val) : 0;

	if (arg_count > 0) {
	out->args = calloc(arg_count, sizeof(*out->args));
	out->ffi_arg_types = calloc(arg_count, sizeof(*out->ffi_arg_types));
	if (!out->args \|\| !out->ffi_arg_types) {
	free(out->args);
	free(out->ffi_arg_types);
	out->args = NULL;
	out->ffi_arg_types = NULL;
	if (error_out) *error_out = js_mkerr(js, "Out of memory");
	return false;
	}
	}

	out->arg_count = arg_count;
	out->fixed_arg_count = arg_count;
	out->variadic = false;

	for (size_t i = 0; i < arg_count; i++) {
	char idx[32];
	ant_value_t arg_val;
	ffi_marshaled_type_t arg_type;

	snprintf(idx, sizeof(idx), "%zu", i);
	arg_val = js_get(js, args_val, idx);
	arg_type = ffi_marshaled_type_from_value(js, arg_val);

	if (arg_type.id == FFI_VALUE_UNKNOWN) {
	ffi_signature_cleanup(out);
	if (error_out) *error_out = js_mkerr_typed(js, JS_ERR_TYPE, "Unsupported FFI argument type");
	return false;
	}

	if (arg_type.id == FFI_VALUE_SPREAD) {
	if (!allow_variadic) {
	ffi_signature_cleanup(out);
	if (error_out) *error_out = js_mkerr_typed(js, JS_ERR_TYPE, "Variadic signatures are not supported here");
	return false;
	}

	if (i + 1 != arg_count) {
	ffi_signature_cleanup(out);
	if (error_out) *error_out = js_mkerr_typed(
	js, JS_ERR_TYPE,
	"FFI spread marker must be the last argument type"
	);
	return false;
	}

	out->variadic = true;
	out->fixed_arg_count = i;
	out->arg_count = i;
	break;
	}

	out->args[i] = arg_type;
	out->ffi_arg_types[i] = arg_type.ffi_type;
	}

	return true;
	}

	static ffi_marshaled_type_t ffi_infer_variadic_type(ant_value_t value) {
	if (vtype(value) == T_STR) return ffi_marshaled_type_make(FFI_VALUE_STRING, "string");
	if (ffi_is_nullish(value)) return ffi_marshaled_type_make(FFI_VALUE_POINTER, "pointer");

	if (is_object_type(value) && js_check_native_tag(value, FFI_POINTER_NATIVE_TAG))
	return ffi_marshaled_type_make(FFI_VALUE_POINTER, "pointer");

	if (is_object_type(value) && js_check_native_tag(value, FFI_CALLBACK_NATIVE_TAG))
	return ffi_marshaled_type_make(FFI_VALUE_POINTER, "pointer");

	if (vtype(value) == T_NUM) {
	double number = js_getnum(value);
	double truncated = js_to_int32(number);
	if (number == truncated) return ffi_marshaled_type_make(FFI_VALUE_INT, "int");
	return ffi_marshaled_type_make(FFI_VALUE_DOUBLE, "double");
	}

	if (vtype(value) == T_BOOL) return ffi_marshaled_type_make(FFI_VALUE_INT, "int");
	return ffi_marshaled_type_make(FFI_VALUE_POINTER, "pointer");
	}

	static ffi_library_handle_t *ffi_library_data(ant_value_t value) {
	if (!js_check_native_tag(value, FFI_LIBRARY_NATIVE_TAG)) return NULL;
	return (ffi_library_handle_t *)js_get_native_ptr(value);
	}

	static ffi_function_handle_t *ffi_function_data(ant_value_t value) {
	if (!js_check_native_tag(value, FFI_FUNCTION_NATIVE_TAG)) return NULL;
	return (ffi_function_handle_t *)js_get_native_ptr(value);
	}

	static ffi_pointer_handle_t *ffi_pointer_data(ant_value_t value) {
	if (!js_check_native_tag(value, FFI_POINTER_NATIVE_TAG)) return NULL;
	return (ffi_pointer_handle_t *)js_get_native_ptr(value);
	}

	static ffi_callback_handle_t *ffi_callback_data(ant_value_t value) {
	if (!js_check_native_tag(value, FFI_CALLBACK_NATIVE_TAG)) return NULL;
	return (ffi_callback_handle_t *)js_get_native_ptr(value);
	}

	static void ffi_library_close_handle(ffi_library_handle_t *library) {
	if (!library \|\| library->closed) return;
	library->closed = true;
	if (library->handle) dlclose(library->handle);
	library->handle = NULL;
	}

	static void ffi_pointer_region_release(ffi_pointer_region_t *region) {
	if (!region) return;
	if (region->ref_count > 0) region->ref_count--;
	if (region->ref_count != 0) return;
	if (region->owned && !region->freed && region->ptr) free(region->ptr);
	free(region);
	}

	static bool ffi_pointer_region_free(ffi_pointer_region_t *region) {
	if (!region \|\| !region->owned \|\| region->freed) return false;
	if (region->ptr) free(region->ptr);
	region->ptr = NULL;
	region->freed = true;
	region->size = 0;
	region->size_known = true;
	return true;
	}

	static void ffi_pointer_close_handle(ffi_pointer_handle_t *handle, bool free_region_memory) {
	if (!handle) return;
	if (handle->region && free_region_memory) (void)ffi_pointer_region_free(handle->region);
	ffi_pointer_region_release(handle->region);
	handle->region = NULL;
	}

	static void ffi_callback_close_handle(ffi_callback_handle_t *callback) {
	if (!callback \|\| callback->closed) return;
	callback->closed = true;
	if (callback->closure) ffi_closure_free(callback->closure);
	callback->closure = NULL;
	callback->code_ptr = NULL;
	ffi_signature_cleanup(&callback->signature);
	}

	static uint8_t ffi_pointer_address_raw(ffi_pointer_handle_t handle) {
	if (!handle \|\| !handle->region \|\| handle->region->freed \|\| !handle->region->ptr) return NULL;
	return handle->region->ptr + handle->byte_offset;
	}

	static bool ffi_pointer_ensure_readable(
	ant_t *js,
	ffi_pointer_handle_t *handle,
	size_t size,
	const char *op,
	ant_value_t *error_out
	) {
	size_t remaining = 0;

	if (error_out) *error_out = js_mkundef();
	if (!handle \|\| !handle->region) {
	if (error_out) *error_out = js_mkerr_typed(js, JS_ERR_TYPE, "Invalid FFIPointer");
	return false;
	}

	if (handle->region->freed) {
	if (error_out) *error_out = js_mkerr_typed(js, JS_ERR_TYPE, "FFIPointer has been freed");
	return false;
	}

	if (!handle->region->ptr) {
	if (error_out) *error_out = js_mkerr_typed(js, JS_ERR_TYPE, "Cannot %s through a null pointer", op);
	return false;
	}

	if (handle->region->size_known) {
	if (handle->byte_offset > handle->region->size) {
	if (error_out) *error_out = js_mkerr_typed(js, JS_ERR_RANGE, "Pointer offset is out of bounds");
	return false;
	}

	remaining = handle->region->size - handle->byte_offset;
	if (size > remaining) {
	if (error_out) *error_out = js_mkerr_typed(
	js, JS_ERR_RANGE,
	"FFIPointer %s would read past the tracked allocation",
	op
	);
	return false;
	}
	}

	return true;
	}

	static ant_value_t ffi_make_pointer(ant_t js, ffi_pointer_region_t region, size_t byte_offset) {
	ant_value_t obj = js_mkobj(js);
	ffi_pointer_handle_t handle = calloc(1, sizeof(handle));

	if (!handle) {
	ffi_pointer_region_release(region);
	return js_mkerr(js, "Out of memory");
	}

	handle->region = region;
	handle->byte_offset = byte_offset;
	if (region) region->ref_count++;

	if (g_ffi_pointer_proto) js_set_proto_init(obj, g_ffi_pointer_proto);
	js_set_native_ptr(obj, handle);
	js_set_native_tag(obj, FFI_POINTER_NATIVE_TAG);
	js_set_finalizer(obj, ffi_pointer_finalize);

	return obj;
	}

	static ant_value_t ffi_make_pointer_from_raw(ant_t js, void ptr) {
	ffi_pointer_region_t region = calloc(1, sizeof(region));
	if (!region) return js_mkerr(js, "Out of memory");
	region->ptr = (uint8_t *)ptr;
	region->owned = false;
	region->freed = false;
	region->size_known = false;
	return ffi_make_pointer(js, region, 0);
	}

	static ant_value_t ffi_make_pointer_or_null(ant_t js, void ptr) {
	if (!ptr) return js_mknull();
	return ffi_make_pointer_from_raw(js, ptr);
	}

	static bool ffi_pointer_from_js(
	ant_t *js,
	ant_value_t value,
	void **out,
	ant_value_t *error_out
	) {
	ffi_pointer_handle_t *ptr_handle = NULL;
	ffi_callback_handle_t *cb_handle = NULL;

	if (error_out) *error_out = js_mkundef();
	if (out) *out = NULL;

	if (ffi_is_nullish(value)) return true;

	ptr_handle = ffi_pointer_data(value);
	if (ptr_handle) {
	if (ptr_handle->region && ptr_handle->region->freed) {
	if (error_out) *error_out = js_mkerr_typed(js, JS_ERR_TYPE, "FFIPointer has been freed");
	return false;
	}
	if (out) out = (void )ffi_pointer_address_raw(ptr_handle);
	return true;
	}

	cb_handle = ffi_callback_data(value);
	if (cb_handle) {
	if (cb_handle->closed) {
	if (error_out) *error_out = js_mkerr_typed(js, JS_ERR_TYPE, "FFICallback has been closed");
	return false;
	}
	if (out) *out = cb_handle->code_ptr;
	return true;
	}

	if (error_out) *error_out = js_mkerr_typed(
	js, JS_ERR_TYPE,
	"Pointer arguments require FFIPointer, FFICallback, null, or undefined"
	);

	return false;
	}

	static bool ffi_copy_js_string(
	ant_t *js,
	ant_value_t value,
	char **out,
	size_t *len_out,
	ant_value_t *error_out
	) {
	ant_value_t str_val = js_tostring_val(js, value);
	const char *src = NULL;
	size_t len = 0;
	char *copy = NULL;

	if (error_out) *error_out = js_mkundef();
	if (out) *out = NULL;
	if (len_out) *len_out = 0;

	if (is_err(str_val)) {
	if (error_out) *error_out = str_val;
	return false;
	}

	src = js_getstr(js, str_val, &len);
	if (!src) {
	if (error_out) *error_out = js_mkerr_typed(js, JS_ERR_TYPE, "Invalid string value");
	return false;
	}

	copy = malloc(len + 1);
	if (!copy) {
	if (error_out) *error_out = js_mkerr(js, "Out of memory");
	return false;
	}

	memcpy(copy, src, len);
	copy[len] = '\0';

	if (out) *out = copy;
	if (len_out) *len_out = len;

	return true;
	}

	static bool ffi_value_to_c(
	ant_t *js,
	ant_value_t value,
	ffi_marshaled_type_t type,
	ffi_value_box_t *box,
	void **scratch_alloc,
	ant_value_t *error_out
	) {
	void *ptr = NULL;
	char *str_copy = NULL;

	if (error_out) *error_out = js_mkundef();
	if (scratch_alloc) *scratch_alloc = NULL;

	switch (type.id) {
	case FFI_VALUE_INT8: box->i8 = (int8_t)js_getnum(value); return true;
	case FFI_VALUE_INT16: box->i16 = (int16_t)js_getnum(value); return true;
	case FFI_VALUE_INT: box->i32 = (int32_t)js_getnum(value); return true;
	case FFI_VALUE_INT64: box->i64 = (int64_t)js_getnum(value); return true;
	case FFI_VALUE_UINT8: box->u8 = (uint8_t)js_getnum(value); return true;
	case FFI_VALUE_UINT16: box->u16 = (uint16_t)js_getnum(value); return true;
	case FFI_VALUE_UINT64: box->u64 = (uint64_t)js_getnum(value); return true;
	case FFI_VALUE_FLOAT: box->f32 = (float)js_getnum(value); return true;
	case FFI_VALUE_DOUBLE: box->f64 = js_getnum(value); return true;
	case FFI_VALUE_POINTER:
	if (!ffi_pointer_from_js(js, value, &ptr, error_out)) return false;
	box->ptr = ptr;
	return true;
	case FFI_VALUE_STRING:
	if (!ffi_is_nullish(value) && ffi_pointer_from_js(js, value, &ptr, NULL)) {
	box->ptr = ptr;
	return true;
	}
	if (!ffi_copy_js_string(js, value, &str_copy, NULL, error_out)) return false;
	if (scratch_alloc) *scratch_alloc = str_copy;
	box->ptr = str_copy;
	return true;
	case FFI_VALUE_VOID:
	case FFI_VALUE_SPREAD:
	case FFI_VALUE_UNKNOWN:
	if (error_out) *error_out = js_mkerr_typed(js, JS_ERR_TYPE, "Unsupported FFI argument conversion");
	return false;
	}

	return false;
	}

	static ant_value_t ffi_value_from_c(ant_t js, const void value, ffi_marshaled_type_t type) {
	switch (type.id) {
	case FFI_VALUE_VOID: return js_mkundef();
	case FFI_VALUE_INT8: return js_mknum((double)(const int8_t )value);
	case FFI_VALUE_INT16: return js_mknum((double)(const int16_t )value);
	case FFI_VALUE_INT: return js_mknum((double)(const int32_t )value);
	case FFI_VALUE_INT64: return js_mknum((double)(const int64_t )value);
	case FFI_VALUE_UINT8: return js_mknum((double)(const uint8_t )value);
	case FFI_VALUE_UINT16: return js_mknum((double)(const uint16_t )value);
	case FFI_VALUE_UINT64: return js_mknum((double)(const uint64_t )value);
	case FFI_VALUE_FLOAT: return js_mknum((double)(const float )value);
	case FFI_VALUE_DOUBLE: return js_mknum((const double )value);
	case FFI_VALUE_POINTER: return ffi_make_pointer_or_null(js, (void const *)value);
	case FFI_VALUE_STRING: {
	const char str = (const char const )value;
	return str ? js_mkstr(js, str, strlen(str)) : js_mknull();
	}
	case FFI_VALUE_SPREAD:
	case FFI_VALUE_UNKNOWN:
	return js_mkundef();
	}

	return js_mkundef();
	}

	static size_t ffi_marshaled_type_size(ffi_marshaled_type_t type) {
	switch (type.id) {
	case FFI_VALUE_STRING: return 1;
	case FFI_VALUE_VOID:
	case FFI_VALUE_SPREAD:
	case FFI_VALUE_UNKNOWN:
	return 0;
	default:
	return type.ffi_type ? type.ffi_type->size : 0;
	}
	}

	static void ffi_zero_return_value(void *ret, ffi_marshaled_type_t type) {
	size_t size = ffi_marshaled_type_size(type);
	if (size > 0) memset(ret, 0, size);
	}

	static ant_value_t ffi_read_from_pointer(ant_t js, ffi_pointer_handle_t handle, ffi_marshaled_type_t type) {
	ant_value_t err = js_mkundef();
	uint8_t *addr = ffi_pointer_address_raw(handle);

	if (type.id == FFI_VALUE_STRING) {
	size_t len = 0;
	if (!ffi_pointer_ensure_readable(js, handle, 1, "read", &err)) return err;
	if (handle->region && handle->region->size_known) {
	size_t remaining = handle->region->size - handle->byte_offset;
	const char *nul = memchr(addr, '\0', remaining);
	if (!nul) return js_mkerr_typed(js, JS_ERR_RANGE, "String read exceeded the tracked allocation");
	len = (size_t)(nul - (const char *)addr);
	} else len = strlen((const char *)addr);
	return js_mkstr(js, addr, len);
	}

	if (type.id == FFI_VALUE_POINTER) {
	if (!ffi_pointer_ensure_readable(js, handle, sizeof(void *), "read", &err)) return err;
	return ffi_make_pointer_or_null(js, (void *)addr);
	}

	if (!ffi_pointer_ensure_readable(js, handle, ffi_marshaled_type_size(type), "read", &err)) return err;
	return ffi_value_from_c(js, addr, type);
	}

	static ant_value_t ffi_write_to_pointer(
	ant_t *js,
	ffi_pointer_handle_t *handle,
	ffi_marshaled_type_t type,
	ant_value_t value
	) {
	ant_value_t err = js_mkundef();
	uint8_t *addr = ffi_pointer_address_raw(handle);
	ffi_value_box_t box;
	void *scratch = NULL;

	memset(&box, 0, sizeof(box));

	if (type.id == FFI_VALUE_STRING) {
	char *copy = NULL;
	size_t len = 0;
	if (!ffi_copy_js_string(js, value, &copy, &len, &err)) return err;
	if (!ffi_pointer_ensure_readable(js, handle, len + 1, "write", &err)) {
	free(copy);
	return err;
	}
	memcpy(addr, copy, len + 1);
	free(copy);
	return js_getthis(js);
	}

	if (!ffi_pointer_ensure_readable(js, handle, ffi_marshaled_type_size(type), "write", &err)) return err;
	if (!ffi_value_to_c(js, value, type, &box, &scratch, &err)) return err;

	switch (type.id) {
	case FFI_VALUE_INT8: memcpy(addr, &box.i8, sizeof(box.i8)); break;
	case FFI_VALUE_INT16: memcpy(addr, &box.i16, sizeof(box.i16)); break;
	case FFI_VALUE_INT: memcpy(addr, &box.i32, sizeof(box.i32)); break;
	case FFI_VALUE_INT64: memcpy(addr, &box.i64, sizeof(box.i64)); break;
	case FFI_VALUE_UINT8: memcpy(addr, &box.u8, sizeof(box.u8)); break;
	case FFI_VALUE_UINT16: memcpy(addr, &box.u16, sizeof(box.u16)); break;
	case FFI_VALUE_UINT64: memcpy(addr, &box.u64, sizeof(box.u64)); break;
	case FFI_VALUE_FLOAT: memcpy(addr, &box.f32, sizeof(box.f32)); break;
	case FFI_VALUE_DOUBLE: memcpy(addr, &box.f64, sizeof(box.f64)); break;
	case FFI_VALUE_POINTER: memcpy(addr, &box.ptr, sizeof(box.ptr)); break;
	default: break;
	}

	free(scratch);
	return js_getthis(js);
	}

	static ant_value_t ffi_make_function(ant_t js, ffi_library_handle_t library, const char symbol_name, ffi_signature_t signature, void *func_ptr) {
	ant_value_t obj = js_mkobj(js);
	ant_value_t fn = 0;
	ffi_function_handle_t handle = calloc(1, sizeof(handle));

	if (!handle) {
	ffi_signature_cleanup(signature);
	return js_mkerr(js, "Out of memory");
	}

	handle->library = library;
	handle->signature = *signature;
	handle->func_ptr = func_ptr;
	handle->symbol_name = strdup(symbol_name);
	if (!handle->symbol_name) {
	free(handle);
	ffi_signature_cleanup(signature);
	return js_mkerr(js, "Out of memory");
	}

	if (!handle->signature.variadic) if (
	ffi_prep_cif(
	&handle->cif,
	FFI_DEFAULT_ABI,
	(unsigned int)handle->signature.arg_count,
	handle->signature.returns.ffi_type,
	handle->signature.arg_count > 0 ? handle->signature.ffi_arg_types : NULL
	) != FFI_OK) {
	free(handle->symbol_name);
	ffi_signature_cleanup(&handle->signature);
	free(handle);
	return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to prepare FFI call interface");
	}

	if (g_ffi_function_proto) js_set_proto_init(obj, g_ffi_function_proto);
	js_set_slot(obj, SLOT_CFUNC, js_mkfun(ffi_function_call));
	js_set_native_ptr(obj, handle);
	js_set_native_tag(obj, FFI_FUNCTION_NATIVE_TAG);
	js_set_slot_wb(js, obj, SLOT_ENTRIES, library ? library->obj : js_mkundef());
	js_set_finalizer(obj, ffi_function_finalize);

	fn = js_obj_to_func(obj);
	return fn;
	}

	void ffi_library_finalize(ant_t js, ant_object_t obj) {
	ffi_library_handle_t *library;
	if (obj->native.tag != FFI_LIBRARY_NATIVE_TAG) return;

	library = (ffi_library_handle_t *)obj->native.ptr;
	if (!library) return;

	ffi_library_close_handle(library);
	free(library->path);
	free(library);
	obj->native.ptr = NULL;
	obj->native.tag = 0;
	}

	void ffi_function_finalize(ant_t js, ant_object_t obj) {
	ffi_function_handle_t *handle;
	if (obj->native.tag != FFI_FUNCTION_NATIVE_TAG) return;

	handle = (ffi_function_handle_t *)obj->native.ptr;
	if (!handle) return;

	free(handle->symbol_name);
	ffi_signature_cleanup(&handle->signature);
	free(handle);
	obj->native.ptr = NULL;
	obj->native.tag = 0;
	}

	void ffi_pointer_finalize(ant_t js, ant_object_t obj) {
	ffi_pointer_handle_t *handle;
	if (obj->native.tag != FFI_POINTER_NATIVE_TAG) return;

	handle = (ffi_pointer_handle_t *)obj->native.ptr;
	if (!handle) return;

	ffi_pointer_close_handle(handle, false);
	free(handle);
	obj->native.ptr = NULL;
	obj->native.tag = 0;
	}

	void ffi_callback_finalize(ant_t js, ant_object_t obj) {
	ffi_callback_handle_t *handle;
	if (obj->native.tag != FFI_CALLBACK_NATIVE_TAG) return;

	handle = (ffi_callback_handle_t *)obj->native.ptr;
	if (!handle) return;

	ffi_callback_close_handle(handle);
	free(handle);
	obj->native.ptr = NULL;
	obj->native.tag = 0;
	}

	static bool ffi_callback_result_to_c(
	ffi_callback_handle_t *callback,
	ant_value_t result,
	void *ret,
	ant_value_t *error_out
	) {
	ffi_value_box_t box;
	ant_value_t err = js_mkundef();
	void *scratch = NULL;

	memset(&box, 0, sizeof(box));
	if (error_out) *error_out = js_mkundef();
	if (callback->signature.returns.id == FFI_VALUE_VOID) return true;

	if (!ffi_value_to_c(callback->js, result, callback->signature.returns, &box, &scratch, &err)) {
	if (error_out) *error_out = err;
	free(scratch);
	return false;
	}

	switch (callback->signature.returns.id) {
	case FFI_VALUE_INT8: memcpy(ret, &box.i8, sizeof(box.i8)); break;
	case FFI_VALUE_INT16: memcpy(ret, &box.i16, sizeof(box.i16)); break;
	case FFI_VALUE_INT: memcpy(ret, &box.i32, sizeof(box.i32)); break;
	case FFI_VALUE_INT64: memcpy(ret, &box.i64, sizeof(box.i64)); break;
	case FFI_VALUE_UINT8: memcpy(ret, &box.u8, sizeof(box.u8)); break;
	case FFI_VALUE_UINT16: memcpy(ret, &box.u16, sizeof(box.u16)); break;
	case FFI_VALUE_UINT64: memcpy(ret, &box.u64, sizeof(box.u64)); break;
	case FFI_VALUE_FLOAT: memcpy(ret, &box.f32, sizeof(box.f32)); break;
	case FFI_VALUE_DOUBLE: memcpy(ret, &box.f64, sizeof(box.f64)); break;
	case FFI_VALUE_POINTER:
	memcpy(ret, &box.ptr, sizeof(box.ptr));
	break;
	default:
	free(scratch);
	return false;
	}

	free(scratch);
	return true;
	}

	static void ffi_callback_trampoline(ffi_cif cif, void ret, void *args, void user_data) {
	ffi_callback_handle_t callback = (ffi_callback_handle_t )user_data;
	ant_value_t js_args[32];
	ant_value_t fn = js_mkundef();
	ant_value_t result = js_mkundef();
	size_t argc = 0;

	(void)cif;
	if (!callback \|\| callback->closed \|\| !callback->js) return;
	ffi_zero_return_value(ret, callback->signature.returns);
	argc = callback->signature.arg_count;

	if (!pthread_equal(pthread_self(), callback->owner_thread)) {
	fprintf(stderr, "ant:ffi callback invoked off the JS thread; returning a zero value\n");
	return;
	}

	if (argc > 32) argc = 32;
	for (size_t i = 0; i < argc; i++) {
	js_args[i] = ffi_value_from_c(callback->js, args[i], callback->signature.args[i]);
	}

	fn = js_get_slot(callback->owner_obj, SLOT_DATA);
	if (!is_callable(fn)) {
	fprintf(stderr, "ant:ffi callback target is no longer callable; returning a zero value\n");
	return;
	}

	result = sv_vm_call(callback->js->vm, callback->js, fn, js_mkundef(), js_args, (int)argc, NULL, false);
	if (is_err(result)) {
	fprintf(stderr, "ant:ffi callback threw an exception; returning a zero value\n");
	callback->js->thrown_exists = 0;
	return;
	}

	if (!ffi_callback_result_to_c(callback, result, ret, NULL)) {
	fprintf(stderr, "ant:ffi callback returned an incompatible value; returning a zero value\n");
	}
	}

	static void ffi_init_prototypes(ant_t *js) {
	ant_value_t function_proto = 0;

	if (g_ffi_library_proto) return;

	function_proto = js_get_slot(js_glob(js), SLOT_FUNC_PROTO);
	if (vtype(function_proto) == T_UNDEF) function_proto = js_get_ctor_proto(js, "Function", 8);

	g_ffi_library_proto = js_mkobj(js);
	g_ffi_function_proto = js_mkobj(js);
	g_ffi_pointer_proto = js_mkobj(js);
	g_ffi_callback_proto = js_mkobj(js);

	if (is_object_type(js->sym.object_proto)) {
	js_set_proto_init(g_ffi_library_proto, js->sym.object_proto);
	js_set_proto_init(g_ffi_pointer_proto, js->sym.object_proto);
	js_set_proto_init(g_ffi_callback_proto, js->sym.object_proto);
	}

	if (is_object_type(function_proto)) js_set_proto_init(g_ffi_function_proto, function_proto);

	js_set_sym(js, g_ffi_library_proto, get_toStringTag_sym(), ANT_STRING("FFILibrary"));
	js_set_sym(js, g_ffi_function_proto, get_toStringTag_sym(), ANT_STRING("FFIFunction"));
	js_set_sym(js, g_ffi_pointer_proto, get_toStringTag_sym(), ANT_STRING("FFIPointer"));
	js_set_sym(js, g_ffi_callback_proto, get_toStringTag_sym(), ANT_STRING("FFICallback"));

	js_set(js, g_ffi_library_proto, "define", js_mkfun(ffi_library_define));
	js_set(js, g_ffi_library_proto, "call", js_mkfun(ffi_library_call));
	js_set(js, g_ffi_library_proto, "close", js_mkfun(ffi_library_close));

	js_set(js, g_ffi_pointer_proto, "address", js_mkfun(ffi_pointer_address));
	js_set(js, g_ffi_pointer_proto, "isNull", js_mkfun(ffi_pointer_is_null));
	js_set(js, g_ffi_pointer_proto, "read", js_mkfun(ffi_pointer_read));
	js_set(js, g_ffi_pointer_proto, "write", js_mkfun(ffi_pointer_write));
	js_set(js, g_ffi_pointer_proto, "offset", js_mkfun(ffi_pointer_offset));
	js_set(js, g_ffi_pointer_proto, "free", js_mkfun(ffi_pointer_free));

	js_set(js, g_ffi_callback_proto, "address", js_mkfun(ffi_callback_address));
	js_set(js, g_ffi_callback_proto, "close", js_mkfun(ffi_callback_close));

	js_set(js, g_ffi_function_proto, "address", js_mkfun(ffi_function_address));
	}

	static ant_value_t ffi_dlopen(ant_t js, ant_value_t args, int nargs) {
	ant_value_t path_val = js_mkundef();
	const char *path = NULL;

	size_t path_len = 0;
	void *dl = NULL;

	ffi_library_handle_t *library = NULL;
	ant_value_t obj = 0;

	if (nargs < 1) return js_mkerr_typed(js, JS_ERR_TYPE, "dlopen(path) requires a library path");
	ffi_init_prototypes(js);

	path_val = js_tostring_val(js, args[0]);
	if (is_err(path_val) \|\| vtype(path_val) != T_STR) return path_val;
	path = js_getstr(js, path_val, &path_len);
	if (!path) return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid library path");

	dl = dlopen(path, RTLD_LAZY);
	if (!dl) return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to load library: %s", dlerror());

	library = calloc(1, sizeof(*library));
	if (!library) {
	dlclose(dl);
	return js_mkerr(js, "Out of memory");
	}

	library->path = malloc(path_len + 1);
	if (!library->path) {
	dlclose(dl);
	free(library);
	return js_mkerr(js, "Out of memory");
	}

	memcpy(library->path, path, path_len);
	library->path[path_len] = '\0';
	library->handle = dl;
	library->closed = false;

	obj = js_mkobj(js);
	if (g_ffi_library_proto) js_set_proto_init(obj, g_ffi_library_proto);
	library->obj = obj;
	js_set_native_ptr(obj, library);
	js_set_native_tag(obj, FFI_LIBRARY_NATIVE_TAG);
	js_set_finalizer(obj, ffi_library_finalize);
	return obj;
	}

	ant_value_t ffi_library_close(ant_t js, ant_value_t args, int nargs) {
	ffi_library_handle_t *library = ffi_library_data(js_getthis(js));
	(void)args;
	(void)nargs;
	if (!library) return js_mkerr_typed(js, JS_ERR_TYPE, "Expected an FFILibrary");
	ffi_library_close_handle(library);
	return js_getthis(js);
	}

	ant_value_t ffi_library_define(ant_t js, ant_value_t args, int nargs) {
	ffi_library_handle_t *library = ffi_library_data(js_getthis(js));
	ffi_signature_t signature;

	ant_value_t error = js_mkundef();
	ant_value_t fn = js_mkundef();

	const char *symbol_name = NULL;
	void *sym = NULL;
	memset(&signature, 0, sizeof(signature));

	if (!library) return js_mkerr_typed(js, JS_ERR_TYPE, "Expected an FFILibrary");
	if (library->closed) return js_mkerr_typed(js, JS_ERR_TYPE, "FFILibrary is closed");

	if (nargs < 2 \|\| vtype(args[0]) != T_STR) {
	return js_mkerr_typed(js, JS_ERR_TYPE, "define(name, signature) requires a symbol name and signature");
	}

	if (!ffi_parse_signature(js, args[1], true, true, &signature, &error)) return error;

	symbol_name = js_getstr(js, args[0], NULL);
	sym = dlsym(library->handle, symbol_name);

	if (!sym) {
	ffi_signature_cleanup(&signature);
	return js_mkerr_typed(js, JS_ERR_TYPE, "Symbol '%s' was not found", symbol_name);
	}

	fn = ffi_make_function(js, library, symbol_name, &signature, sym);
	if (is_err(fn)) {
	ffi_signature_cleanup(&signature);
	return fn;
	}

	js_set(js, js_getthis(js), symbol_name, fn);
	return fn;
	}

	ant_value_t ffi_library_call(ant_t js, ant_value_t args, int nargs) {
	ant_value_t fn = js_mkundef();
	ffi_library_handle_t *library = ffi_library_data(js_getthis(js));

	if (!library) return js_mkerr_typed(js, JS_ERR_TYPE, "Expected an FFILibrary");
	if (library->closed) return js_mkerr_typed(js, JS_ERR_TYPE, "FFILibrary is closed");
	if (nargs < 1 \|\| vtype(args[0]) != T_STR) {
	return js_mkerr_typed(js, JS_ERR_TYPE, "call(name, ...args) requires a symbol name");
	}

	fn = js_get(js, js_getthis(js), js_getstr(js, args[0], NULL));
	if (!is_callable(fn)) {
	return js_mkerr_typed(js, JS_ERR_TYPE, "Symbol '%s' has not been defined", js_getstr(js, args[0], NULL));
	}

	return sv_vm_call(js->vm, js, fn, js_mkundef(), args + 1, nargs - 1, NULL, false);
	}

	ant_value_t ffi_function_call(ant_t js, ant_value_t args, int nargs) {
	ffi_function_handle_t *function = ffi_function_data(js->current_func);
	ffi_type **call_types = NULL;
	ffi_value_box_t *values = NULL;

	void **call_args = NULL;
	void **scratch = NULL;

	ffi_marshaled_type_t *dynamic_types = NULL;
	ffi_cif call_cif;
	ffi_value_box_t result;
	ant_value_t error = js_mkundef();

	int status = FFI_OK;
	size_t actual_argc = 0;

	memset(&result, 0, sizeof(result));

	if (!function) return js_mkerr_typed(js, JS_ERR_TYPE, "Expected an FFIFunction");
	if (!function->library \|\| function->library->closed) {
	return js_mkerr_typed(js, JS_ERR_TYPE, "FFIFunction '%s' belongs to a closed library", function->symbol_name);
	}

	if (!function->signature.variadic && nargs != (int)function->signature.arg_count) return js_mkerr_typed(
	js, JS_ERR_TYPE,
	"FFIFunction '%s' expects %zu arguments, got %d",
	function->symbol_name,
	function->signature.arg_count,
	nargs
	);

	if (function->signature.variadic && nargs < (int)function->signature.fixed_arg_count) return js_mkerr_typed(
	js, JS_ERR_TYPE,
	"FFIFunction '%s' expects at least %zu arguments, got %d",
	function->symbol_name,
	function->signature.fixed_arg_count,
	nargs
	);

	actual_argc = (size_t)nargs;
	if (actual_argc > 0) {
	call_types = calloc(actual_argc, sizeof(*call_types));
	values = calloc(actual_argc, sizeof(*values));
	call_args = calloc(actual_argc, sizeof(*call_args));
	scratch = calloc(actual_argc, sizeof(*scratch));
	dynamic_types = calloc(actual_argc, sizeof(*dynamic_types));
	if (!call_types \|\| !values \|\| !call_args \|\| !scratch \|\| !dynamic_types) {
	error = js_mkerr(js, "Out of memory");
	goto cleanup;
	}
	}

	for (size_t i = 0; i < actual_argc; i++) {
	ffi_marshaled_type_t type = i < function->signature.fixed_arg_count
	? function->signature.args[i]
	: ffi_infer_variadic_type(args[i]);

	dynamic_types[i] = type;
	call_types[i] = type.ffi_type;
	call_args[i] = &values[i];

	if (!ffi_value_to_c(js, args[i], type, &values[i], &scratch[i], &error)) goto cleanup;
	}

	if (function->signature.variadic) {
	status = ffi_prep_cif_var(
	&call_cif,
	FFI_DEFAULT_ABI,
	(unsigned int)function->signature.fixed_arg_count,
	(unsigned int)actual_argc,
	function->signature.returns.ffi_type,
	call_types
	);

	if (status != FFI_OK) {
	error = js_mkerr_typed(js, JS_ERR_TYPE, "Failed to prepare variadic FFI call");
	goto cleanup;
	}

	ffi_call(&call_cif, function->func_ptr, &result, call_args);
	} else ffi_call(&function->cif, function->func_ptr, &result, call_args);

	cleanup:
	if (vtype(error) != T_UNDEF) {
	size_t i;
	for (i = 0; i < actual_argc; i++) free(scratch ? scratch[i] : NULL);
	free(dynamic_types);
	free(scratch);
	free(call_args);
	free(values);
	free(call_types);
	return error;
	}

	{
	ant_value_t out = ffi_value_from_c(js, &result, function->signature.returns);
	size_t i;
	for (i = 0; i < actual_argc; i++) free(scratch ? scratch[i] : NULL);
	free(dynamic_types);
	free(scratch);
	free(call_args);
	free(values);
	free(call_types);
	return out;
	}
	}

	ant_value_t ffi_function_address(ant_t js, ant_value_t args, int nargs) {
	ffi_function_handle_t *function = ffi_function_data(js_getthis(js));
	(void)args;
	(void)nargs;
	if (!function) return js_mkerr_typed(js, JS_ERR_TYPE, "Expected an FFIFunction");
	return js_mknum((double)(uintptr_t)function->func_ptr);
	}

	static ant_value_t ffi_alloc_memory(ant_t js, ant_value_t args, int nargs) {
	ffi_pointer_region_t *region = NULL;
	size_t size = 0;

	if (nargs < 1 \|\| vtype(args[0]) != T_NUM) {
	return js_mkerr_typed(js, JS_ERR_TYPE, "alloc(size) requires a numeric size");
	}

	size = (size_t)js_getnum(args[0]);
	if (size == 0) return js_mkerr_typed(js, JS_ERR_RANGE, "alloc(size) requires a positive size");

	region = calloc(1, sizeof(*region));
	if (!region) return js_mkerr(js, "Out of memory");

	region->ptr = malloc(size);
	if (!region->ptr) {
	free(region);
	return js_mkerr(js, "Out of memory");
	}

	region->size = size;
	region->owned = true;
	region->freed = false;
	region->size_known = true;
	return ffi_make_pointer(js, region, 0);
	}

	static ant_value_t ffi_pointer_value(ant_t js, ant_value_t args, int nargs) {
	ffi_pointer_region_t *region = NULL;
	ant_value_t error = js_mkundef();
	char *str_copy = NULL;
	size_t str_len = 0;
	const uint8_t *buffer_bytes = NULL;
	size_t buffer_len = 0;

	if (nargs < 1 \|\| ffi_is_nullish(args[0])) return ffi_make_pointer_from_raw(js, NULL);
	if (ffi_pointer_data(args[0])) return args[0];

	if (ffi_callback_data(args[0])) {
	void *ptr = NULL;
	if (!ffi_pointer_from_js(js, args[0], &ptr, &error)) return error;
	return ffi_make_pointer_or_null(js, ptr);
	}

	region = calloc(1, sizeof(*region));
	if (!region) return js_mkerr(js, "Out of memory");

	if (buffer_source_get_bytes(js, args[0], &buffer_bytes, &buffer_len)) {
	region->ptr = (uint8_t *)buffer_bytes;
	region->size = buffer_len;
	region->size_known = true;
	region->owned = false;
	region->freed = false;
	return ffi_make_pointer(js, region, 0);
	}

	if (!ffi_copy_js_string(js, args[0], &str_copy, &str_len, &error)) {
	free(region);
	return error;
	}

	region->ptr = (uint8_t *)str_copy;
	region->size = str_len + 1;
	region->size_known = true;
	region->owned = true;
	region->freed = false;
	return ffi_make_pointer(js, region, 0);
	}

	ant_value_t ffi_pointer_address(ant_t js, ant_value_t args, int nargs) {
	ffi_pointer_handle_t *handle = ffi_pointer_data(js_getthis(js));
	(void)args;
	(void)nargs;
	if (!handle) return js_mkerr_typed(js, JS_ERR_TYPE, "Expected an FFIPointer");
	return js_mknum((double)(uintptr_t)ffi_pointer_address_raw(handle));
	}

	ant_value_t ffi_pointer_is_null(ant_t js, ant_value_t args, int nargs) {
	ffi_pointer_handle_t *handle = ffi_pointer_data(js_getthis(js));
	(void)args;
	(void)nargs;
	if (!handle) return js_mkerr_typed(js, JS_ERR_TYPE, "Expected an FFIPointer");
	return js_bool(ffi_pointer_address_raw(handle) == NULL);
	}

	ant_value_t ffi_pointer_read(ant_t js, ant_value_t args, int nargs) {
	ffi_pointer_handle_t *handle = ffi_pointer_data(js_getthis(js));
	ffi_marshaled_type_t type;

	if (!handle) return js_mkerr_typed(js, JS_ERR_TYPE, "Expected an FFIPointer");
	type = nargs > 0 ? ffi_marshaled_type_from_value(js, args[0]) : ffi_marshaled_type_make(FFI_VALUE_POINTER, "pointer");
	if (type.id == FFI_VALUE_UNKNOWN \|\| type.id == FFI_VALUE_SPREAD \|\| type.id == FFI_VALUE_VOID) {
	return js_mkerr_typed(js, JS_ERR_TYPE, "Unsupported FFIPointer.read() type");
	}
	return ffi_read_from_pointer(js, handle, type);
	}

	ant_value_t ffi_pointer_write(ant_t js, ant_value_t args, int nargs) {
	ffi_pointer_handle_t *handle = ffi_pointer_data(js_getthis(js));
	ffi_marshaled_type_t type;

	if (!handle) return js_mkerr_typed(js, JS_ERR_TYPE, "Expected an FFIPointer");
	if (nargs < 2) {
	return js_mkerr_typed(js, JS_ERR_TYPE, "FFIPointer.write(type, value) requires a type and value");
	}

	type = ffi_marshaled_type_from_value(js, args[0]);
	if (type.id == FFI_VALUE_UNKNOWN \|\| type.id == FFI_VALUE_SPREAD \|\| type.id == FFI_VALUE_VOID) {
	return js_mkerr_typed(js, JS_ERR_TYPE, "Unsupported FFIPointer.write() type");
	}

	return ffi_write_to_pointer(js, handle, type, args[1]);
	}

	ant_value_t ffi_pointer_offset(ant_t js, ant_value_t args, int nargs) {
	ffi_pointer_handle_t *handle = ffi_pointer_data(js_getthis(js));
	ffi_pointer_handle_t *next = NULL;
	ant_value_t out = 0;
	size_t offset = 0;

	if (!handle) return js_mkerr_typed(js, JS_ERR_TYPE, "Expected an FFIPointer");
	if (nargs < 1 \|\| vtype(args[0]) != T_NUM) {
	return js_mkerr_typed(js, JS_ERR_TYPE, "FFIPointer.offset(bytes) requires a numeric byte offset");
	}

	if (js_getnum(args[0]) < 0) return js_mkerr_typed(js, JS_ERR_RANGE, "FFIPointer.offset() requires a non-negative offset");
	offset = (size_t)js_getnum(args[0]);

	if (handle->region && handle->region->size_known && handle->byte_offset + offset > handle->region->size) {
	return js_mkerr_typed(js, JS_ERR_RANGE, "FFIPointer.offset() is out of bounds");
	}

	out = ffi_make_pointer(js, handle->region, handle->byte_offset + offset);
	next = ffi_pointer_data(out);
	if (!next) return out;
	return out;
	}

	ant_value_t ffi_pointer_free(ant_t js, ant_value_t args, int nargs) {
	ffi_pointer_handle_t *handle = ffi_pointer_data(js_getthis(js));
	(void)args;
	(void)nargs;
	if (!handle) return js_mkerr_typed(js, JS_ERR_TYPE, "Expected an FFIPointer");
	if (!handle->region \|\| !handle->region->owned) {
	return js_mkerr_typed(js, JS_ERR_TYPE, "Only owned FFIPointers can be freed");
	}
	if (!ffi_pointer_region_free(handle->region)) {
	return js_mkerr_typed(js, JS_ERR_TYPE, "FFIPointer has already been freed");
	}
	return js_getthis(js);
	}

	static ant_value_t ffi_create_callback(ant_t js, ant_value_t args, int nargs) {
	ant_value_t signature_val = js_mkundef();
	ant_value_t fn = js_mkundef();
	ant_value_t obj = 0;
	ffi_callback_handle_t *callback = NULL;
	ant_value_t error = js_mkundef();

	if (nargs < 2) {
	return js_mkerr_typed(js, JS_ERR_TYPE, "callback(signature, fn) requires a signature and function");
	}

	if (is_callable(args[0]) && is_object_type(args[1])) {
	fn = args[0];
	signature_val = args[1];
	} else if (is_object_type(args[0]) && is_callable(args[1])) {
	signature_val = args[0];
	fn = args[1];
	} else return js_mkerr_typed(js, JS_ERR_TYPE, "callback(signature, fn) requires a signature object and callable function");

	ffi_init_prototypes(js);

	callback = calloc(1, sizeof(*callback));
	if (!callback) return js_mkerr(js, "Out of memory");

	if (!ffi_parse_signature(js, signature_val, false, false, &callback->signature, &error)) {
	free(callback);
	return error;
	}

	if (ffi_prep_cif(
	&callback->cif,
	FFI_DEFAULT_ABI,
	(unsigned int)callback->signature.arg_count,
	callback->signature.returns.ffi_type,
	callback->signature.arg_count > 0 ? callback->signature.ffi_arg_types : NULL
	) != FFI_OK) {
	ffi_signature_cleanup(&callback->signature);
	free(callback);
	return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to prepare FFICallback signature");
	}

	callback->closure = ffi_closure_alloc(sizeof(*callback->closure), &callback->code_ptr);
	if (!callback->closure) {
	ffi_signature_cleanup(&callback->signature);
	free(callback);
	return js_mkerr(js, "Failed to allocate FFICallback closure");
	}

	if (ffi_prep_closure_loc(callback->closure, &callback->cif, ffi_callback_trampoline, callback, callback->code_ptr) != FFI_OK) {
	ffi_closure_free(callback->closure);
	ffi_signature_cleanup(&callback->signature);
	free(callback);
	return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to prepare FFICallback closure");
	}

	obj = js_mkobj(js);
	if (g_ffi_callback_proto) js_set_proto_init(obj, g_ffi_callback_proto);
	callback->js = js;
	callback->owner_obj = obj;
	callback->owner_thread = pthread_self();
	callback->closed = false;
	js_set_native_ptr(obj, callback);
	js_set_native_tag(obj, FFI_CALLBACK_NATIVE_TAG);
	js_set_slot_wb(js, obj, SLOT_DATA, fn);
	js_set_finalizer(obj, ffi_callback_finalize);
	return obj;
	}

	ant_value_t ffi_callback_address(ant_t js, ant_value_t args, int nargs) {
	ffi_callback_handle_t *callback = ffi_callback_data(js_getthis(js));
	(void)args;
	(void)nargs;
	if (!callback) return js_mkerr_typed(js, JS_ERR_TYPE, "Expected an FFICallback");
	return js_mknum((double)(uintptr_t)callback->code_ptr);
	}

	ant_value_t ffi_callback_close(ant_t js, ant_value_t args, int nargs) {
	ffi_callback_handle_t *callback = ffi_callback_data(js_getthis(js));
	(void)args;
	(void)nargs;
	if (!callback) return js_mkerr_typed(js, JS_ERR_TYPE, "Expected an FFICallback");
	ffi_callback_close_handle(callback);
	return js_getthis(js);
	}

	ant_value_t ffi_library(ant_t *js) {
	ant_value_t ffi_obj = js_mkobj(js);
	ant_value_t ffi_types = js_mkobj(js);
	const char *suffix = "so";

	ffi_init_prototypes(js);

	js_set(js, ffi_obj, "dlopen", js_mkfun(ffi_dlopen));
	js_set(js, ffi_obj, "alloc", js_mkfun(ffi_alloc_memory));
	js_set(js, ffi_obj, "pointer", js_mkfun(ffi_pointer_value));
	js_set(js, ffi_obj, "callback", js_mkfun(ffi_create_callback));

	#ifdef __APPLE__
	suffix = "dylib";
	#elif defined(_WIN32)
	suffix = "dll";
	#endif

	js_set(js, ffi_obj, "suffix", js_mkstr(js, suffix, strlen(suffix)));

	js_set(js, ffi_types, "void", ANT_STRING("void"));
	js_set(js, ffi_types, "int8", ANT_STRING("int8"));
	js_set(js, ffi_types, "int16", ANT_STRING("int16"));
	js_set(js, ffi_types, "int", ANT_STRING("int"));
	js_set(js, ffi_types, "int64", ANT_STRING("int64"));
	js_set(js, ffi_types, "uint8", ANT_STRING("uint8"));
	js_set(js, ffi_types, "uint16", ANT_STRING("uint16"));
	js_set(js, ffi_types, "uint64", ANT_STRING("uint64"));
	js_set(js, ffi_types, "float", ANT_STRING("float"));
	js_set(js, ffi_types, "double", ANT_STRING("double"));
	js_set(js, ffi_types, "pointer", ANT_STRING("pointer"));
	js_set(js, ffi_types, "string", ANT_STRING("string"));
	js_set(js, ffi_types, "spread", ANT_STRING("..."));

	js_set(js, ffi_obj, "FFIType", ffi_types);
	js_set_sym(js, ffi_obj, get_toStringTag_sym(), ANT_STRING("FFI"));

	return ffi_obj;
	}

File Metadata

Mime Type: text/x-c
Expires: Sat, May 2, 5:16 AM (1 d, 19 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 541588
Default Alt Text: ffi.c (46 KB)

ffi.cNo OneTemporaryActions

ffi.cView Options

File Metadata

Event Timeline

ffi.c
No OneTemporary
Actions

ffi.c
View Options