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

use crate::preprocessor::token::Token;
use crate::syntax::parser::{ident, this_ident};
use crate::{SleighError, Span};
use nom::branch::alt;
use nom::combinator::map;
use nom::sequence::{delimited, pair, preceded, tuple};
use nom::IResult;

use super::op::ByteRangeLsb;
use super::{expr, op};

#[derive(Clone, Debug)]
pub enum Export {
    Value(expr::Expr),
    Reference {
        space: op::AddrDereference,
        addr: expr::Expr,
    },
    Const {
        size: ByteRangeLsb,
        src: Span,
        value: String,
    },
    //TODO Unique
    //Unique{
    //  value: &[Token],
    //}
}

impl Export {
    fn parse_value(input: &[Token]) -> IResult<&[Token], Self, Box<SleighError>> {
        map(expr::Expr::parse, Self::Value)(input)
    }
    fn parse_reference(input: &[Token]) -> IResult<&[Token], Self, Box<SleighError>> {
        map(
            pair(op::AddrDereference::parse, expr::Expr::parse),
            |(space, addr)| Self::Reference { space, addr },
        )(input)
    }
    fn parse_const(input: &[Token]) -> IResult<&[Token], Self, Box<SleighError>> {
        map(
            preceded(
                tuple((tag!("*"), tag!("["), tag!("const"), tag!("]"))),
                pair(ByteRangeLsb::parse, ident),
            ),
            |(size, (value, value_src))| Self::Const {
                size,
                value,
                src: value_src.clone(),
            },
        )(input)
    }
    fn parse_unique(input: &[Token]) -> IResult<&[Token], Self, Box<SleighError>> {
        map(
            preceded(
                tuple((tag!("*"), tag!("["), tag!("unique"), tag!("]"))),
                pair(ByteRangeLsb::parse, ident),
            ),
            |_| todo!(),
        )(input)
    }
    pub fn parse(input: &[Token]) -> IResult<&[Token], Self, Box<SleighError>> {
        delimited(
            this_ident("export"),
            //NOTE order is important
            alt((
                Self::parse_unique,
                Self::parse_const,
                Self::parse_reference,
                Self::parse_value,
            )),
            tag!(";"),
        )(input)
    }
}