rsleigh 0.4.1

SLEIGH (.slaspec) parser and Rust decoder/P-code emitter codegen — Ghidra-compatible disassembly in pure Rust
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

use crate::meaning::Meaning;
use crate::semantic::{
    AttachLiteralId, AttachNumberId, AttachVarnodeId, PrintBase, TokenId, ValueFmt,
};
use crate::{Endian, FieldBits, NumberNonZeroUnsigned, Sleigh, Span};

#[derive(Clone, Debug)]
pub struct Token {
    pub(crate) name: Box<str>,
    pub location: Span,
    pub len_bytes: NumberNonZeroUnsigned,
    pub endian: Endian,
}

#[derive(Clone, Debug)]
pub struct TokenField {
    pub(crate) name: Box<str>,
    pub location: Span,
    pub bits: FieldBits,
    pub token: TokenId,
    pub attach: TokenFieldAttach,
}

impl Token {
    pub fn name(&self) -> &str {
        &self.name
    }
    pub fn endian(&self) -> Endian {
        self.endian
    }
    pub fn len_bytes(&self) -> NumberNonZeroUnsigned {
        self.len_bytes
    }
}

impl TokenField {
    pub fn name(&self) -> &str {
        &self.name
    }
    pub fn raw_value_is_signed(&self) -> bool {
        match self.attach {
            TokenFieldAttach::NoAttach(fmt) => fmt.signed,
            TokenFieldAttach::Varnode(_)
            | TokenFieldAttach::Literal(_)
            | TokenFieldAttach::Number(_, _) => false,
        }
    }
    pub fn execution_value_is_signed(&self, sleigh: &Sleigh) -> bool {
        match self.attach {
            TokenFieldAttach::NoAttach(fmt) => fmt.signed,
            TokenFieldAttach::Varnode(_) | TokenFieldAttach::Literal(_) => false,
            TokenFieldAttach::Number(_, value) => sleigh.attach_number(value).is_signed(),
        }
    }

    pub fn meaning(&self) -> Meaning {
        match self.attach {
            TokenFieldAttach::NoAttach(fmt) => Meaning::NoAttach(fmt),
            TokenFieldAttach::Varnode(id) => Meaning::Varnode(id),
            TokenFieldAttach::Literal(id) => Meaning::Literal(id),
            TokenFieldAttach::Number(base, id) => Meaning::Number(base, id),
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum TokenFieldAttach {
    /// No attach, just use the raw value
    NoAttach(ValueFmt),
    Varnode(AttachVarnodeId),
    Literal(AttachLiteralId),
    Number(PrintBase, AttachNumberId),
}