Enum Data 

#[non_exhaustive]
pub enum Data {
    Byte(u8),
    Word(u16),
    Long(u32),
}

Raw parser data, kept separate from valid instructions and unknown words.

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.

Byte(u8)

One byte.

Word(u16)

One 16-bit word.

Long(u32)

One 32-bit longword.

Implementations

impl Data

pub const fn display(&self) -> DisplayData<'_>

Render a raw parser data item.

Examples found in repository

examples/disasm_text.rs (line 27)

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()),
            _ => {}
        }
    }
}

Trait Implementations

impl Clone for Data

fn clone(&self) -> Data

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Data

impl Debug for Data

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

Formats the value using the given formatter.

impl Eq for Data

impl PartialEq for Data

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Data