use std::borrow::Cow;
use std::io::{IsTerminal, Read};
use reedline::{
DefaultHinter, Prompt, PromptEditMode, PromptHistorySearch, Reedline, Signal, ValidationResult,
Validator,
};
use slew::{Execution, Lua, Step, Value};
const DEFAULT_FUEL: u64 = 1_000_000;
fn main() {
if let Some(path) = std::env::args().nth(1) {
let src = std::fs::read(&path).unwrap_or_else(|e| {
eprintln!("slew: cannot read {path}: {e}");
std::process::exit(1);
});
run_script(&path, &src);
return;
}
if !std::io::stdin().is_terminal() {
let mut src = Vec::new();
std::io::stdin().read_to_end(&mut src).expect("read stdin");
run_script("stdin", &src);
return;
}
repl();
}
fn run_script(name: &str, src: &[u8]) {
let mut lua = Lua::new();
let chunk = match lua.load_named(name, src) {
Ok(c) => c,
Err(e) => {
eprintln!("slew: {e}");
std::process::exit(1);
}
};
let mut exec = lua.execute(&chunk);
loop {
match exec.step(&mut lua, 10_000_000) {
Ok(Step::Done(_)) => return,
Ok(Step::Pending) => {}
Ok(Step::Waiting(wait)) => {
eprintln!("slew: waiting for native operation {wait:?}");
std::process::exit(1);
}
Err(e) => {
eprintln!("slew: {e}");
std::process::exit(1);
}
}
}
}
fn repl() {
let mut lua = Lua::new();
let mut editor = Reedline::create()
.with_validator(Box::new(LuaValidator))
.with_hinter(Box::new(DefaultHinter::default()));
let mut fuel = DEFAULT_FUEL;
let mut suspended: Option<Execution> = None;
println!("slew {} — a suspendable Lua 5.4", env!("CARGO_PKG_VERSION"));
println!("fuel budget per input: {fuel} (:help for commands)");
loop {
match editor.read_line(&LuaPrompt) {
Ok(Signal::Success(line)) => {
let line = line.trim();
if line.is_empty() {
continue;
}
if let Some(cmd) = line.strip_prefix(':') {
handle_command(cmd, &mut lua, &mut fuel, &mut suspended);
continue;
}
if let Some(old) = suspended.take() {
old.abort(&mut lua);
println!("(abandoned suspended execution)");
}
let chunk = match lua.load_named("repl", format!("return {line}")) {
Ok(c) => c,
Err(_) => match lua.load_named("repl", line) {
Ok(c) => c,
Err(e) => {
eprintln!("{e}");
continue;
}
},
};
let exec = lua.execute(&chunk);
suspended = drive(&mut lua, exec, fuel);
}
Ok(Signal::CtrlD) => break,
Ok(_) => {} Err(e) => {
eprintln!("input error: {e}");
break;
}
}
}
}
fn drive(lua: &mut Lua, mut exec: Execution, fuel: u64) -> Option<Execution> {
match exec.step(lua, fuel) {
Ok(Step::Done(vals)) => {
if !vals.is_empty() {
let line = vals
.iter()
.map(|v| repr(lua, *v))
.collect::<Vec<_>>()
.join("\t");
println!("{line}");
}
None
}
Ok(Step::Pending) => {
println!("~ suspended after {fuel} fuel (:more to continue, new input to abandon)");
Some(exec)
}
Ok(Step::Waiting(wait)) => {
println!("~ waiting for native operation {wait:?}");
Some(exec)
}
Err(e) => {
eprintln!("{e}");
None
}
}
}
fn repr(lua: &Lua, v: Value) -> String {
match v {
Value::Str(_) => format!("{:?}", lua.display_value(v)),
_ => lua.display_value(v),
}
}
fn handle_command(cmd: &str, lua: &mut Lua, fuel: &mut u64, suspended: &mut Option<Execution>) {
let mut parts = cmd.split_whitespace();
match parts.next().unwrap_or("") {
"more" | "m" => match suspended.take() {
Some(exec) => *suspended = drive(lua, exec, *fuel),
None => println!("nothing is suspended"),
},
"fuel" => match parts.next().and_then(|s| s.parse::<u64>().ok()) {
Some(n) => {
*fuel = n;
println!("fuel budget per input: {n}");
}
None => println!("fuel budget per input: {fuel} (usage: :fuel N)"),
},
"mem" => println!("~{} bytes in use", lua.memory_used()),
"gc" => {
let after = lua.gc();
println!("collected; ~{after} bytes in use");
}
"help" | "h" => {
println!(":fuel N set the per-input fuel budget (currently {fuel})");
println!(":more resume a suspended execution with another budget");
println!(":mem approximate memory in use");
println!(":gc run a garbage collection");
println!(":quit exit (also Ctrl-D)");
}
"quit" | "q" | "exit" => std::process::exit(0),
other => println!("unknown command ':{other}' (:help)"),
}
}
struct LuaPrompt;
impl Prompt for LuaPrompt {
fn render_prompt_left(&self) -> Cow<'_, str> {
Cow::Borrowed("slew")
}
fn render_prompt_right(&self) -> Cow<'_, str> {
Cow::Borrowed("")
}
fn render_prompt_indicator(&self, _edit_mode: PromptEditMode) -> Cow<'_, str> {
Cow::Borrowed("> ")
}
fn render_prompt_multiline_indicator(&self) -> Cow<'_, str> {
Cow::Borrowed("..> ")
}
fn render_prompt_history_search_indicator(
&self,
_history_search: PromptHistorySearch,
) -> Cow<'_, str> {
Cow::Borrowed("search: ")
}
}
struct LuaValidator;
impl Validator for LuaValidator {
fn validate(&self, line: &str) -> ValidationResult {
if is_incomplete(line) {
ValidationResult::Incomplete
} else {
ValidationResult::Complete
}
}
}
fn is_incomplete(src: &str) -> bool {
use slew::parser::parse;
if parse(format!("return {src}").as_bytes()).is_ok() {
return false;
}
match parse(src.as_bytes()) {
Ok(_) => false,
Err(e) => e.to_string().contains("<eof>"),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn incomplete_detection() {
assert!(!is_incomplete("1 + 2"));
assert!(!is_incomplete("x = 1"));
assert!(!is_incomplete("function f() return 1 end"));
assert!(!is_incomplete("for i = 1, 3 do print(i) end"));
assert!(is_incomplete("function f()"));
assert!(is_incomplete("if x then"));
assert!(is_incomplete("local t = {"));
assert!(is_incomplete("while true do"));
assert!(is_incomplete("print('unterminated call'"));
assert!(!is_incomplete("x = = 1"));
assert!(!is_incomplete(")("));
}
#[test]
fn expression_vs_statement_and_suspension() {
let mut lua = Lua::new();
let chunk = lua.load_named("repl", "return 6 * 7").unwrap();
let exec = lua.execute(&chunk);
assert!(drive(&mut lua, exec, 1_000).is_none());
let chunk = lua.load_named("repl", "answer = 42").unwrap();
let exec = lua.execute(&chunk);
assert!(drive(&mut lua, exec, 1_000).is_none());
assert_eq!(lua.get_global("answer"), Value::Int(42));
let chunk = lua
.load_named("repl", "n = 0 while true do n = n + 1 end")
.unwrap();
let exec = lua.execute(&chunk);
let suspended = drive(&mut lua, exec, 5_000);
assert!(suspended.is_some());
let Value::Int(n1) = lua.get_global("n") else {
panic!()
};
let still = drive(&mut lua, suspended.unwrap(), 5_000);
assert!(still.is_some());
let Value::Int(n2) = lua.get_global("n") else {
panic!()
};
assert!(n2 > n1, "resume must make progress");
still.unwrap().abort(&mut lua);
}
#[test]
fn repr_quotes_strings() {
let mut lua = Lua::new();
let s = lua.new_string(b"hi");
assert_eq!(repr(&lua, s), "\"hi\"");
assert_eq!(repr(&lua, Value::Int(1)), "1");
}
}