pub mod ast;
pub mod banner;
pub mod cli;
pub mod compiler;
pub mod dap;
pub mod host;
pub mod lexer;
pub mod lsp;
pub mod parser;
pub mod prelude;
pub mod reference;
pub mod regex;
pub mod rust_ffi;
pub mod tiers;
pub use banner::version_banner;
use fusevm::{VMResult, Value, VM};
pub fn parse(src: &str) -> Result<ast::Program, String> {
let src = rust_ffi::desugar(src);
let mut prog = parser::parse(&src)?;
compiler::check_duplicate_declarations(&prog)?;
prelude::inject(&mut prog)?;
Ok(prog)
}
pub(crate) fn supertype_map(prog: &ast::Program) -> std::collections::HashMap<String, Vec<String>> {
prog.classes
.iter()
.map(|c| {
let mut sups: Vec<String> = c.superclass.clone().into_iter().collect();
sups.extend(c.interfaces.iter().cloned());
if c.is_enum {
sups.push("Enum".to_string());
}
if c.is_record {
sups.push("Record".to_string());
}
(c.name.clone(), sups)
})
.collect()
}
pub(crate) fn binary_name_map(prog: &ast::Program) -> std::collections::HashMap<String, String> {
prog.classes
.iter()
.map(|c| (c.name.clone(), c.binary.clone()))
.collect()
}
pub fn compile(src: &str) -> Result<fusevm::Chunk, String> {
let prog = parse(src)?;
compiler::compile(&prog)
}
fn run_chunk(
chunk: fusevm::Chunk,
supers: std::collections::HashMap<String, Vec<String>>,
binaries: std::collections::HashMap<String, String>,
exceptions: bool,
argv: &[String],
) -> Result<Value, String> {
host::heap_reset();
host::set_supertypes(supers);
host::set_binary_names(binaries);
host::set_exceptions_enabled(exceptions);
host::set_argv(argv.to_vec());
host::intern_literals(&chunk);
let mut vm = VM::new(chunk);
host::install(&mut vm);
vm.set_numeric_hook(std::sync::Arc::new(host::numeric_hook));
vm.enable_tracing_jit();
let result = vm.run();
if let Some(e) = host::take_ffi_error() {
return Err(e);
}
match result {
VMResult::Ok(v) => Ok(v),
VMResult::Halted => Ok(vm.stack.last().cloned().unwrap_or(Value::Undef)),
VMResult::Error(e) => Err(e),
}
}
pub fn run_str(src: &str) -> Result<Value, String> {
run_str_args(src, &[])
}
pub fn run_str_args(src: &str, argv: &[String]) -> Result<Value, String> {
let prog = parse(src)?;
let supers = supertype_map(&prog);
let binaries = binary_name_map(&prog);
let chunk = compiler::compile(&prog)?;
run_chunk(chunk, supers, binaries, prog.uses_exceptions, argv)
}
pub fn run_file(path: &str) -> Result<Value, String> {
let src =
std::fs::read_to_string(path).map_err(|e| format!("javars: cannot read {path}: {e}"))?;
run_str(&src)
}
pub fn disassemble(src: &str) -> Result<String, String> {
Ok(compile(src)?.disassemble())
}