use alloc::string::{String, ToString};
use alloc::vec::Vec;
use std::cell::Cell;
use std::sync::Mutex;
use crate::runtime::{Runtime, Value};
const THE_SLOTS: usize = 64;
struct Entry {
name: String,
params: usize,
func: Option<Value>,
}
static REGISTRY: Mutex<Vec<Option<Entry>>> = Mutex::new(Vec::new());
thread_local! {
static CURRENT: Cell<*mut ()> = const { Cell::new(std::ptr::null_mut()) };
}
pub fn set_current(rt: &mut Runtime<'_>) -> usize {
CURRENT.with(|cell| {
let previous = cell.get();
cell.set(rt as *mut Runtime<'_> as *mut ());
previous as usize
})
}
pub fn clear_current(previous: usize) {
CURRENT.with(|cell| cell.set(previous as *mut ()));
}
pub fn the_message_runs(msg: i64, wparam: i64, lparam: i64, hwnd: i64) -> Option<i64> {
let ptr = CURRENT.with(|cell| cell.get());
if ptr.is_null() {
return None;
}
let rt = unsafe { &mut *(ptr as *mut Runtime<'static>) };
rt.the_message_runs(msg, wparam, lparam, hwnd)
}
pub fn register(name: &str, params: usize) -> usize {
let mut registry = match REGISTRY.lock() {
Ok(registry) => registry,
Err(_) => return 0,
};
let slot = match registry.iter().position(|entry| entry.is_none()) {
Some(slot) => slot,
None => {
if registry.len() >= THE_SLOTS {
return 0;
}
registry.push(None);
registry.len() - 1
}
};
registry[slot] = Some(Entry {
name: name.to_string(),
params,
func: None,
});
THE_TRAMPOLINES[slot] as usize
}
pub fn register_value(func: Value, params: usize) -> usize {
let mut registry = match REGISTRY.lock() {
Ok(registry) => registry,
Err(_) => return 0,
};
let slot = match registry.iter().position(|entry| entry.is_none()) {
Some(slot) => slot,
None => {
if registry.len() >= THE_SLOTS {
return 0;
}
registry.push(None);
registry.len() - 1
}
};
registry[slot] = Some(Entry {
name: String::new(),
params,
func: Some(func),
});
THE_TRAMPOLINES[slot] as usize
}
pub fn free(address: usize) {
if let Some(slot) = THE_TRAMPOLINES.iter().position(|&t| t as usize == address) {
if let Ok(mut registry) = REGISTRY.lock() {
if let Some(entry) = registry.get_mut(slot) {
*entry = None;
}
}
}
}
fn invoke(slot: usize, args: [usize; 4]) -> usize {
let ptr = CURRENT.with(|cell| cell.get());
if ptr.is_null() {
return 0;
}
let entry = {
let registry = match REGISTRY.lock() {
Ok(registry) => registry,
Err(_) => return 0,
};
match registry.get(slot).and_then(|entry| entry.as_ref()) {
Some(entry) => Entry {
name: entry.name.clone(),
params: entry.params,
func: entry.func.clone(),
},
None => return 0,
}
};
let rt = unsafe { &mut *(ptr as *mut Runtime<'static>) };
let values: Vec<Value> = args
.iter()
.take(entry.params)
.map(|&arg| Value::Int(arg as i64))
.collect();
let answer = if let Some(func) = &entry.func {
rt.the_callback_runs(func, &values)
} else {
rt.call_named(&entry.name, &values, 0, crate::runtime::Route::Written)
.map_err(|failure| crate::runtime::as_error(failure, 0))
};
match answer {
Ok(value) => value.to_number().unwrap_or(0.0) as usize,
Err(_) => 0,
}
}
extern "C" fn trampoline<const SLOT: usize>(
a0: usize,
a1: usize,
a2: usize,
a3: usize,
) -> usize {
invoke(SLOT, [a0, a1, a2, a3])
}
macro_rules! trampoline_array {
($($index:literal),* $(,)?) => {
static THE_TRAMPOLINES: [extern "C" fn(usize, usize, usize, usize) -> usize; THE_SLOTS] = [
$(trampoline::<$index>,)*
];
};
}
trampoline_array!(
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
);