Struct Disassembler 

pub struct Disassembler { /* private fields */ }

Parses Java class files into a structured reverse-engineering model.

The default instance uses RecoveryMode::BestEffort. It preserves a readable class-file header and records a Diagnostic when complete decoding cannot continue.

Implementations

impl Disassembler

pub fn builder() -> DisassemblerBuilder

Creates a builder for configuring a disassembler.

The builder starts with RecoveryMode::BestEffort.

pub fn new(options: DisassemblerOptions) -> Self

Creates a disassembler with the supplied options.

pub fn options(&self) -> &DisassemblerOptions

Returns the options used by this disassembler.

pub fn parse(&self, bytes: &[u8]) -> Result<Disassembly, FerroBabeError>

Parses one complete Java class-file byte sequence.

In best-effort mode, an error after the class-file header is read returns a partial Disassembly with diagnostics. In strict mode, the same decoding failure is returned as FerroBabeError. Invalid, incomplete, or unsupported headers always return an error.

Errors

Returns an error when the input has no readable supported class-file header, or when strict recovery is selected and decoding fails.

pub fn parse_reader<R: Read>( &self, reader: R, ) -> Result<Disassembly, FerroBabeError>

Reads and parses one Java class file from reader.

The complete reader is buffered before parsing, so the returned Disassembly does not borrow from reader.

Errors

Returns FerroBabeError::InputRead when reading fails, or any error documented by Self::parse after the bytes have been read.

Examples found in repository

examples/disassemble.rs (line 22)

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)
}

pub fn disassemble(&self, bytes: &[u8]) -> Result<String, FerroBabeError>

Parses bytes and renders a complete class with FerroFormatter.

Errors

Returns parse errors, FerroBabeError::IncompleteDisassembly for a recovered partial result, or a formatting error from the default formatter.

pub fn disassemble_with<F: Formatter>( &self, bytes: &[u8], formatter: &F, ) -> Result<String, FerroBabeError>

Parses bytes and renders the resulting complete class with formatter.

formatter receives the same Class view available through Disassembly::class.

Errors

Returns parse errors, FerroBabeError::IncompleteDisassembly for a partial result, or FerroBabeError::Format when formatter cannot write its output.

Trait Implementations

impl Clone for Disassembler

fn clone(&self) -> Disassembler

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Disassembler

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Disassembler

fn default() -> Disassembler

Returns the “default value” for a type.