javars 0.1.14

Java as a fusevm frontend: lexer, parser, and compiler to fusevm::Chunk, run on the shared three-tier Cranelift JIT — no bespoke VM or JVM
Documentation
//! The `java` binary entry point.
//!
//! Runs a `.java` file on fusevm, or serves an introspection flag
//! (`--version`, `--dump-tokens`/`--dump-ast`/`--disasm`). Errors go to stderr
//! in terse `javars: <reason>` form; nothing else is printed.

use std::process::ExitCode;

fn main() -> ExitCode {
    let cli = match javars::cli::parse(std::env::args().skip(1)) {
        Ok(c) => c,
        Err(e) => return fail(&e),
    };

    if cli.show_version {
        println!("{}", javars::version_banner());
        return ExitCode::SUCCESS;
    }
    if cli.show_help {
        print!("{}", javars::cli::USAGE);
        return ExitCode::SUCCESS;
    }

    if cli.lsp {
        return match javars::lsp::run() {
            Ok(()) => ExitCode::SUCCESS,
            Err(e) => fail(&e),
        };
    }
    if cli.dap {
        return match javars::dap::run() {
            Ok(()) => ExitCode::SUCCESS,
            Err(e) => fail(&e),
        };
    }

    let Some(file) = cli.file.clone() else {
        return fail("no input file (try `java --help`)");
    };

    let src = match std::fs::read_to_string(&file) {
        Ok(s) => s,
        Err(e) => return fail(&format!("cannot read {file}: {e}")),
    };

    if cli.dump_tokens {
        return finish(dump_tokens(&src));
    }
    if cli.dump_ast {
        return finish(dump_ast(&src));
    }
    if cli.disasm {
        return finish(javars::disassemble(&src));
    }
    if cli.tiers {
        return match javars::tiers::report(&src) {
            Ok(r) => {
                println!("{r}");
                ExitCode::SUCCESS
            }
            Err(e) => fail(&e),
        };
    }

    match javars::run_str_args(&src, &cli.argv) {
        // `System.exit(n)` reports `n` modulo 256, as a Unix process does.
        Ok(_) => match javars::host::exit_code() {
            Some(code) => ExitCode::from(code as u8),
            None => ExitCode::SUCCESS,
        },
        Err(e) => fail(&e),
    }
}

fn dump_tokens(src: &str) -> Result<String, String> {
    let toks = javars::lexer::lex(src)?;
    let mut out = String::new();
    for t in toks {
        out.push_str(&format!("{:>4}  {:?}\n", t.line, t.kind));
    }
    Ok(out)
}

fn dump_ast(src: &str) -> Result<String, String> {
    let prog = javars::parse(src)?;
    Ok(format!("{prog:#?}\n"))
}

fn finish(r: Result<String, String>) -> ExitCode {
    match r {
        Ok(s) => {
            print!("{s}");
            ExitCode::SUCCESS
        }
        Err(e) => fail(&e),
    }
}

fn fail(msg: &str) -> ExitCode {
    let msg = msg.strip_prefix("javars: ").unwrap_or(msg);
    eprintln!("javars: {msg}");
    ExitCode::FAILURE
}