pub mod ast;
pub mod banner;
pub mod cli;
pub mod compiler;
pub mod dap;
pub mod embed;
pub mod fdlibm;
pub mod flow;
pub mod host;
pub mod hotspot_trig;
pub mod jbig;
pub mod jbigdec;
pub mod jbitset;
pub mod jdk_generic_statics;
pub mod jdk_supertypes;
pub mod jio;
pub mod jrandom;
pub mod jstr;
pub mod lexer;
pub mod lsp;
pub mod parser;
pub mod prelude;
pub mod reference;
pub mod regex;
pub mod regex_names;
pub mod regex_syntax;
pub mod rust_ffi;
pub mod tiers;
pub mod unicode_tables;
pub mod uninames;
pub use banner::version_banner;
pub use embed::run_program;
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)?;
compiler::check_member_rules(&prog)?;
flow::check(&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 functional_sam_map(prog: &ast::Program) -> std::collections::HashMap<String, String> {
let mut map: std::collections::HashMap<String, String> = prelude::FUNCTIONAL
.iter()
.filter_map(|(name, sam, _)| {
let head = sam.split('(').next()?;
Some((
name.to_string(),
head.split_whitespace().last()?.to_string(),
))
})
.collect();
for c in prog.classes.iter().filter(|c| c.is_interface) {
let mut abstracts = c.methods.iter().filter(|m| m.is_abstract);
if let (Some(m), None) = (abstracts.next(), abstracts.next()) {
map.insert(c.name.clone(), m.name.clone());
}
}
map
}
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)?;
host::set_functional_sams(functional_sam_map(&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())
}