use crate::host::{self, StdinSource};
const INTERPRETER_STACK: usize = 1024 * 1024 * 1024;
pub(crate) struct ExitNow(pub i32);
pub fn run_program(src: &str, input: &str) -> Result<String, String> {
let src = src.to_owned();
let stdin = StdinSource::Fed(std::io::Cursor::new(input.as_bytes().to_vec()));
std::thread::Builder::new()
.name("rubylang-embed".into())
.stack_size(INTERPRETER_STACK)
.spawn(move || run_captured(&src, stdin))
.map_err(|e| format!("spawn interpreter thread: {e}"))?
.join()
.unwrap_or_else(|panic| Err(panic_message(panic.as_ref())))
}
fn run_captured(src: &str, stdin: StdinSource) -> Result<String, String> {
let run = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
crate::eval_captured(src, &[], stdin)
}));
let (result, output) = match run {
Ok(done) => done,
Err(panic) => match panic.downcast::<ExitNow>() {
Ok(exit) => {
let output = host::with_host(|h| h.end_capture());
return exit_outcome(exit.0, "exit", output);
}
Err(panic) => return Err(panic_message(panic.as_ref())),
},
};
match (result, host::with_host(|h| h.exit_status)) {
(Ok(_), _) => Ok(output),
(Err(msg), Some(code)) => exit_outcome(code, &msg, output),
(Err(msg), None) => Err(msg),
}
}
fn exit_outcome(code: i32, msg: &str, output: String) -> Result<String, String> {
match (code, msg) {
(0, _) => Ok(output),
(_, "exit") => Err(format!("exit status {code}")),
_ => Err(msg.to_string()),
}
}
fn panic_message(panic: &(dyn std::any::Any + Send)) -> String {
let msg = panic
.downcast_ref::<&str>()
.copied()
.or_else(|| panic.downcast_ref::<String>().map(String::as_str))
.unwrap_or("unknown panic");
format!("interpreter panicked: {msg}")
}