sleigh2rust 0.1.6

Transpile Ghidra Sleigh parser into 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
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use std::collections::HashSet;

use proc_macro2::{Ident, TokenStream};
use quote::{format_ident, quote};

use super::{formater::*, Disassembler};

#[derive(Clone, Debug)]
pub struct RegistersEnum {
    pub name: Ident,
    pub registers: Vec<Ident>,
}

impl RegistersEnum {
    pub fn from_all(name: Ident, sleigh: &sleigh_rs::Sleigh) -> Self {
        Self::from_iterator(name, sleigh.varnodes().iter())
    }

    //enum from only the Registers that can be printed
    #[allow(dead_code)]
    pub fn from_printable(name: Ident, sleigh: &sleigh_rs::Sleigh) -> Self {
        use sleigh_rs::display::DisplayElement::*;
        use sleigh_rs::token::TokenFieldAttach;
        use sleigh_rs::varnode::ContextAttach;
        let mut vars = HashSet::new();
        let add_varnodes = |vars: &mut HashSet<_>, id| {
            for (_i, var) in sleigh.attach_varnode(id).0.iter() {
                vars.insert(*var);
            }
        };
        for table in sleigh.tables().iter() {
            for constructor in table.constructors().iter() {
                for element in constructor.display.elements() {
                    match element {
                        Varnode(var) => {
                            vars.insert(*var);
                        }
                        Context(context) => {
                            match sleigh.context(*context).attach {
                                ContextAttach::NoAttach(_)
                                | ContextAttach::Literal(_) => {}
                                ContextAttach::Varnode(id) => {
                                    add_varnodes(&mut vars, id)
                                }
                            }
                        }
                        TokenField(token_field) => {
                            match sleigh.token_field(*token_field).attach {
                                TokenFieldAttach::NoAttach(_)
                                | TokenFieldAttach::Literal(_)
                                | TokenFieldAttach::Number(_, _) => {}
                                TokenFieldAttach::Varnode(id) => {
                                    add_varnodes(&mut vars, id)
                                }
                            }
                        }
                        InstStart(_) | InstNext(_) | Disassembly(_)
                        | Table(_) | Literal(_) | Space => {}
                    }
                }
            }
        }
        //TODO: from meaning, with could use the meaning to display
        Self::from_iterator(name, vars.into_iter().map(|id| sleigh.varnode(id)))
    }

    pub fn from_iterator<'a>(
        name: Ident,
        registers: impl Iterator<Item = &'a sleigh_rs::varnode::Varnode>,
    ) -> Self {
        let registers = registers
            .map(|varnode| format_ident!("{}", from_sleigh(varnode.name())))
            .collect();
        Self { name, registers }
    }
    pub fn name(&self) -> &Ident {
        &self.name
    }
    pub fn registers(
        &self,
    ) -> impl Iterator<Item = (&Ident, sleigh_rs::VarnodeId)> {
        self.registers
            .iter()
            .enumerate()
            .map(|(i, name)| (name, sleigh_rs::VarnodeId(i)))
    }
    pub fn register(&self, id: sleigh_rs::VarnodeId) -> &Ident {
        &self.registers[id.0]
    }
    pub fn to_tokens(
        &self,
        tokens: &mut TokenStream,
        disassembler: &Disassembler,
    ) {
        let name = self.name();
        let elements_names = self.registers.iter();
        let elements_names2 = self.registers.iter();
        let elements_display = self
            .registers()
            .map(|(_name, id)| disassembler.sleigh.varnode(id).name());
        tokens.extend(quote! {
            #[derive(Clone, Copy, Debug)]
            pub enum #name {
                #(#elements_names),*
            }
            impl #name {
                fn as_str(&self) -> &'static str {
                    match self {
                        #(Self::#elements_names2 => #elements_display,)*
                    }
                }
            }
            impl core::fmt::Display for #name {
                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> std::fmt::Result {
                    write!(f, "{}", self.as_str())
                }
            }
        })
    }
}