rsleigh 0.4.0

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

mod alignment;
mod bitrange;
mod context;
mod space;
mod token;
mod user_function;
mod varnode;

use nom::branch::alt;
use nom::combinator::{cut, eof, map, value};
use nom::sequence::{pair, preceded, terminated};
use nom::IResult;

use crate::{Endian, SleighError};

use crate::preprocessor::token::Token as ParserToken;

pub use self::alignment::Alignment;
pub use self::bitrange::BitRangeDef;
pub use self::context::{Context, ContextFieldAttribute};
pub use self::space::{Attribute, Space};
pub use self::token::{Token, TokenFieldAttribute};
pub use self::user_function::UserFunction;
pub use self::varnode::Varnode;

use super::parser::this_ident;

#[derive(Clone, Debug)]
pub enum Define {
    Endian(Endian),
    Alignment(Alignment),
    Varnode(Varnode),
    Bitrange(BitRangeDef),
    Token(Token),
    UserFunction(UserFunction),
    Context(Context),
    Space(Space),
}

pub fn parse_endian(input: &[ParserToken]) -> IResult<&[ParserToken], Endian, Box<SleighError>> {
    preceded(
        pair(this_ident("endian"), tag!("=")),
        cut(alt((
            value(Endian::Little, this_ident("little")),
            value(Endian::Big, this_ident("big")),
        ))),
    )(input)
}

impl Define {
    pub fn parse(input: &[ParserToken]) -> Result<Define, Box<SleighError>> {
        let (_eof, define) = preceded(
            this_ident("define"),
            cut(terminated(
                alt((
                    map(parse_endian, Define::Endian),
                    map(Alignment::parse, Define::Alignment),
                    map(UserFunction::parse, Define::UserFunction),
                    map(Space::parse, Define::Space),
                    map(Token::parse, Define::Token),
                    map(BitRangeDef::parse, Define::Bitrange),
                    map(Context::parse, Define::Context),
                    //NOTE Varnode need to be the last
                    map(Varnode::parse, Define::Varnode),
                )),
                pair(tag!(";"), eof),
            )),
        )(input)?;
        Ok(define)
    }
}