use crate::host::ClosureDef;
use fusevm::{Chunk, VM};
thread_local! {
static AOT_SOURCE: std::cell::RefCell<Option<String>> = const { std::cell::RefCell::new(None) };
}
fn embedded_closures(chunk: &Chunk) -> Vec<ClosureDef> {
use base64::Engine as _;
for name in &chunk.names {
let Some(b64) = name.strip_prefix(crate::aot::AOT_CLOSURES_TAG) else {
continue;
};
let Ok(blob) = base64::engine::general_purpose::STANDARD.decode(b64) else {
continue;
};
let Ok(closures) = bincode::deserialize::<Vec<(Vec<String>, Chunk, Vec<String>)>>(&blob)
else {
continue;
};
return closures
.into_iter()
.map(|(params, chunk, src)| ClosureDef { params, chunk, src })
.collect();
}
Vec::new()
}
fn embedded_source(chunk: &Chunk) -> Option<String> {
use base64::Engine as _;
for name in &chunk.names {
if let Some(b64) = name.strip_prefix(crate::aot::AOT_SOURCE_TAG) {
if let Ok(bytes) = base64::engine::general_purpose::STANDARD.decode(b64) {
if let Ok(s) = String::from_utf8(bytes) {
return Some(s);
}
}
}
}
None
}
#[no_mangle]
pub unsafe extern "C" fn fusevm_aot_register_builtins(vm: *mut VM) {
let vm = unsafe { &mut *vm };
let closures = embedded_closures(&vm.chunk);
let source = embedded_source(&vm.chunk);
AOT_SOURCE.with(|s| *s.borrow_mut() = source);
crate::host::with_host(|h| h.load_closures(closures));
crate::builtins::install(vm);
}
#[cfg(not(target_arch = "wasm32"))]
fn capture_stdout<R>(f: impl FnOnce() -> R) -> (R, Vec<u8>) {
use std::io::{Read, Seek, Write};
use std::os::unix::io::AsRawFd;
let path = std::env::temp_dir().join(format!("rlang-aot-cap-{}.out", std::process::id()));
let Ok(file) = std::fs::OpenOptions::new()
.read(true)
.write(true)
.create(true)
.truncate(true)
.open(&path)
else {
return (f(), Vec::new());
};
let (r, mut file) = unsafe {
let saved = libc::dup(1);
libc::dup2(file.as_raw_fd(), 1);
let r = f();
let _ = std::io::stdout().flush();
libc::dup2(saved, 1);
libc::close(saved);
(r, file)
};
let mut buf = Vec::new();
let _ = file.seek(std::io::SeekFrom::Start(0));
let _ = file.read_to_end(&mut buf);
let _ = std::fs::remove_file(&path);
(r, buf)
}
#[no_mangle]
pub unsafe extern "C" fn rlang_aot_main() -> i64 {
let (code, captured) = capture_stdout(|| fusevm::aot::fusevm_aot_run_embedded());
let err = crate::host::with_host(|h| h.take_error());
match err {
None => {
use std::io::Write as _;
let _ = std::io::stdout().write_all(&captured);
code
}
Some(e) => {
#[cfg(not(target_arch = "wasm32"))]
if crate::rembed::available() {
if let Some(src) = AOT_SOURCE.with(|s| s.borrow().clone()) {
use crate::rembed::ScriptFailure;
return match crate::rembed::run_script(&src) {
Ok(()) => 0,
Err(ScriptFailure::RError(msg)) => {
eprint!("{msg}");
eprintln!("Execution halted");
1
}
Err(ScriptFailure::Unavailable(msg)) => {
eprintln!("Rscript: {msg}");
1
}
};
}
}
use std::io::Write as _;
let _ = std::io::stdout().write_all(&captured);
eprintln!("Rscript: {e}");
1
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn embedded_closures_round_trip() {
let prog = crate::compile("f <- function(x) x + 1\ng <- function(a, b) a * b\nf(1)")
.expect("compile");
assert_eq!(prog.closures.len(), 2, "expected two user closures");
let tag = crate::aot::AOT_CLOSURES_TAG;
let mut chunk = prog.main.clone();
chunk.names.push(format!(
"{tag}{}",
crate::aot::encode_closures(&prog).unwrap()
));
let recovered = embedded_closures(&chunk);
assert_eq!(recovered.len(), prog.closures.len());
for (a, b) in recovered.iter().zip(prog.closures.iter()) {
assert_eq!(a.params, b.params, "formals must survive the round trip");
assert_eq!(a.chunk.ops.len(), b.chunk.ops.len(), "body must survive");
}
}
#[test]
fn no_image_yields_no_closures() {
let chunk = crate::compile("cat(1 + 1)").unwrap().main;
assert!(embedded_closures(&chunk).is_empty());
}
#[test]
fn embedded_source_round_trips() {
use base64::Engine as _;
let src = "suppressMessages(library(dplyr))\nfilter(mtcars, cyl == 4)\n";
let mut chunk = crate::compile("1 + 1").unwrap().main;
assert_eq!(embedded_source(&chunk), None);
let b64 = base64::engine::general_purpose::STANDARD.encode(src.as_bytes());
chunk
.names
.push(format!("{}{b64}", crate::aot::AOT_SOURCE_TAG));
assert_eq!(embedded_source(&chunk).as_deref(), Some(src));
}
}