#![deny(unsafe_code)]
#[derive(Clone, Copy)]
pub(crate) struct Entry(seam::Raw, Option<seam::RawCall>);
pub(crate) fn open(path: &std::path::Path) -> Option<Entry> {
use std::os::unix::ffi::OsStrExt;
let path = std::ffi::CString::new(path.as_os_str().as_bytes()).ok()?;
let (words, tokens) = seam::open(&path)?;
Some(Entry(words, tokens))
}
pub(crate) fn call_tokens(entry: Entry, input: &str) -> Option<String> {
let call = entry.1?;
let mut cap = 64usize;
loop {
let mut out = vec![0u8; cap];
let mut len = 0usize;
match seam::call_tokens(call, input.as_bytes(), &mut out, &mut len) {
0 => {
out.truncate(len);
return String::from_utf8(out).ok();
}
3 if len > cap => cap = len,
_ => return None,
}
}
}
pub(crate) fn call(entry: Entry, args: &[i64]) -> Option<i64> {
let mut out = 0i64;
(seam::call(entry.0, args, &mut out) == 0).then_some(out)
}
#[allow(unsafe_code)]
mod seam {
use std::ffi::{c_char, c_int, c_void, CStr};
pub(super) type Raw = extern "C" fn(*const i64, usize, *mut i64) -> i32;
pub(super) type RawCall = extern "C" fn(*const u8, usize, *mut u8, usize, *mut usize) -> i32;
const RTLD_NOW: c_int = 2;
#[cfg(target_os = "macos")]
const RTLD_LOCAL: c_int = 4;
#[cfg(not(target_os = "macos"))]
const RTLD_LOCAL: c_int = 0;
extern "C" {
fn dlopen(path: *const c_char, mode: c_int) -> *mut c_void;
fn dlsym(handle: *mut c_void, name: *const c_char) -> *mut c_void;
}
pub(super) fn open(path: &CStr) -> Option<(Raw, Option<RawCall>)> {
let handle = unsafe { dlopen(path.as_ptr(), RTLD_NOW | RTLD_LOCAL) };
if handle.is_null() {
return None;
}
let symbol = unsafe { dlsym(handle, c"blue_def_entry".as_ptr()) };
if symbol.is_null() {
return None;
}
let words = unsafe { std::mem::transmute::<*mut c_void, Raw>(symbol) };
let symbol = unsafe { dlsym(handle, c"blue_def_call".as_ptr()) };
let tokens = (!symbol.is_null())
.then(|| unsafe { std::mem::transmute::<*mut c_void, RawCall>(symbol) });
Some((words, tokens))
}
pub(super) fn call_tokens(call: RawCall, input: &[u8], out: &mut [u8], len: &mut usize) -> i32 {
call(
input.as_ptr(),
input.len(),
out.as_mut_ptr(),
out.len(),
len,
)
}
pub(super) fn call(entry: Raw, args: &[i64], out: &mut i64) -> i32 {
entry(args.as_ptr(), args.len(), out)
}
}