rsleigh 0.4.2

SLEIGH (.slaspec) parser and Rust decoder/P-code emitter codegen — Ghidra-compatible disassembly in pure Rust
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use crate::semantic::display::{Display, DisplayElement};
use crate::syntax::block;
use crate::{DisplayError, Span};

use super::{Pattern, Sleigh};

impl Sleigh {
    fn get_display_ref(
        &self,
        pattern: &mut Pattern,
        name: &str,
        src: &Span,
    ) -> Result<DisplayElement, Box<DisplayError>> {
        use crate::semantic::inner::GlobalScope::*;
        if let Some(disassembly_var) = pattern.disassembly_variable_names.get(name) {
            return Ok(DisplayElement::Disassembly(*disassembly_var));
        }
        match self
            .get_global(name)
            .ok_or_else(|| Box::new(DisplayError::MissingRef(src.clone())))?
        {
            TokenField(x) => {
                if pattern
                    .produce_token_field(self, x)
                    .map(|block_num| block_num.is_none())
                    .unwrap()
                {
                    //TODO error here
                    todo!()
                }
                Ok(DisplayElement::TokenField(x))
            }
            Varnode(x) => Ok(DisplayElement::Varnode(x)),
            Table(x) => Ok(DisplayElement::Table(x)),
            Context(x) => Ok(DisplayElement::Context(x)),
            _ => Err(Box::new(DisplayError::InvalidRef(src.clone()))),
        }
    }

    pub fn new_display(
        &self,
        display: block::display::Display,
        pattern: &mut Pattern,
        is_root: bool,
    ) -> Result<Display, Box<DisplayError>> {
        use block::display::DisplayElement::*;
        //solve the idents
        let mut elements = vec![];
        let mut iter = display.0.into_iter();
        //in root table first element is the mneumonic
        let mneumonic = if !is_root {
            None
        } else {
            let Some(ele) = iter.next() else {
                return Ok(Display::default());
            };
            match ele {
                Concat => None,
                Ident(_src, mneumonic) => Some(mneumonic),
                //TODO: a single char can be a mneumonic?
                Other(c) => Some(c.to_string()),
                Literal(x) => {
                    elements.push(DisplayElement::Literal(x));
                    None
                }
            }
        };

        for ele in iter {
            match ele {
                Concat => (),
                Ident(src, name) => elements.push(self.get_display_ref(pattern, &name, &src)?),
                // Multiple spaces should be combined into a single one
                // NOTE: a literal with a space in the end, followed by
                // Other(' ') should NOT be condensated.
                Other(x) if x.is_whitespace() => match elements.last() {
                    // spaces should be trimmed at the start
                    None if mneumonic.is_none() => {}
                    // if last was space, don't add other one
                    Some(DisplayElement::Space) => {}
                    Some(_) | None => elements.push(DisplayElement::Space),
                },
                // if the previous entry was a literal, just add to it.
                Literal(value) => match elements.last_mut() {
                    Some(DisplayElement::Literal(lit)) => lit.push_str(&value),
                    _ => elements.push(DisplayElement::Literal(value)),
                },
                Other(c) => match elements.last_mut() {
                    Some(DisplayElement::Literal(lit)) => lit.push(c),
                    _ => elements.push(DisplayElement::Literal(c.into())),
                },
            }
        }

        //remove the space at the end
        if matches!(elements.last().map(DisplayElement::is_space), Some(true)) {
            elements.pop();
        }
        Ok(Display {
            mneumonic,
            elements: elements.into(),
        })
    }
}