FerroBabe 0.1.3

A lightweight Rust library for disassembling Java class files.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use std::{
    env,
    fs::File,
    path::{Path, PathBuf},
    process::ExitCode,
};

use ferro_babe::{Diagnostic, Disassembler, FerroFormatter, Formatter};

fn main() -> ExitCode {
    run().unwrap_or_else(|message| {
        eprintln!("ferro-disassemble: {message}");
        ExitCode::FAILURE
    })
}

fn run() -> Result<ExitCode, String> {
    let path = class_path()?;
    let file =
        File::open(&path).map_err(|error| format!("could not open {}: {error}", path.display()))?;
    let disassembly = Disassembler::default()
        .parse_reader(file)
        .map_err(|error| format!("could not parse {}: {error}", path.display()))?;

    let version = disassembly.version();
    let Some(class) = disassembly.class() else {
        println!(
            "partial class file v{}.{}",
            version.major(),
            version.minor()
        );
        for diagnostic in disassembly.diagnostics() {
            print_diagnostic(diagnostic);
        }
        return Ok(ExitCode::from(2));
    };

    let output = FerroFormatter
        .format(class)
        .map_err(|error| format!("could not format {}: {error}", path.display()))?;
    print!("{output}");

    Ok(ExitCode::SUCCESS)
}

fn class_path() -> Result<PathBuf, String> {
    let mut arguments = env::args_os();
    let executable = arguments.next().unwrap_or_default();
    let Some(path) = arguments.next() else {
        return Err(usage(&executable));
    };

    if arguments.next().is_some() {
        return Err(usage(&executable));
    }

    Ok(PathBuf::from(path))
}

fn usage(executable: &std::ffi::OsStr) -> String {
    format!("usage: {} <class-file>", Path::new(executable).display())
}

fn print_diagnostic(diagnostic: &Diagnostic) {
    let offset = diagnostic
        .offset()
        .map(|offset| format!(" at code offset 0x{offset:04x}"))
        .unwrap_or_default();

    eprintln!(
        "diagnostic: {:?} in {:?}{offset}: {}",
        diagnostic.severity(),
        diagnostic.stage(),
        diagnostic.message()
    );
}