Enum DecodeResult 

#[non_exhaustive]
pub enum DecodeResult {
    Instruction(Ins),
    Unknown(u16),
}

Result of decoding one 16-bit word.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Instruction(Ins)

A valid instruction for the selected architecture.

Unknown(u16)

The original word when no valid encoding matched.

Implementations

impl DecodeResult

pub const fn display_at<'a>( &'a self, address: u32, options: &'a FormatOptions, ) -> DisplayDecode<'a>

Render a decode result at address.

Examples found in repository

examples/disasm_text.rs (line 25)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let base_address = args.get(1).map_or(0, |value| {
        let value = value.strip_prefix("0x").unwrap_or(value);
        u32::from_str_radix(value, 16).expect("base address must be hexadecimal")
    });

    let mut bytes = Vec::new();
    std::io::stdin().read_to_end(&mut bytes).expect("read stdin");

    let format = FormatOptions::default();
    let mut parser =
        Parser::new(&bytes, ParseMode::Instruction, ParseEndian::Little, DecodeOptions::default());
    parser.set_address(base_address);

    for item in parser {
        match item.value {
            ParsedValue::Instruction { result, .. } => {
                println!("{:08x}: {}", item.address, result.display_at(item.address, &format));
            }
            ParsedValue::Data(data) => println!("{:08x}: {}", item.address, data.display()),
            _ => {}
        }
    }
}

pub fn write_at<W: FormatIns + ?Sized>( &self, out: &mut W, address: u32, ) -> Result

Write this decode result at address into a structured formatter.

impl DecodeResult

pub const fn instruction(&self) -> Option<&Ins>

Borrow the valid instruction, if the word decoded.

pub const fn unknown_word(&self) -> Option<u16>

Return the original unknown word, if decoding failed.

Trait Implementations

impl Clone for DecodeResult

fn clone(&self) -> DecodeResult

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for DecodeResult

impl Debug for DecodeResult

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

Formats the value using the given formatter.

impl Eq for DecodeResult

impl PartialEq for DecodeResult

fn eq(&self, other: &DecodeResult) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for DecodeResult