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

use crate::data::parser::verify_le_u32;
use crate::data::{ParserResult, Span};
use nom::bytes::complete::tag;
use nom::combinator::map;
use nom::sequence::tuple;
use nom_tracable::tracable_parser;

#[derive(Debug)]
pub struct Chunky {
    pub name: String,
    pub signature: u32,
    pub major_version: u32,
    pub minor_version: u32, // maybe?
}

impl Chunky {
    #[tracable_parser]
    pub fn parse(input: Span) -> ParserResult<Chunky> {
        map(
            tuple((
                Self::parse_name,
                Self::parse_signature,
                Self::parse_major_version,
                Self::parse_minor_version,
            )),
            |(name, signature, major_version, minor_version)| Chunky {
                name,
                signature,
                major_version,
                minor_version,
            },
        )(input)
    }

    #[tracable_parser]
    fn parse_name(input: Span) -> ParserResult<String> {
        map(tag("Relic Chunky"), |s: Span| {
            String::from_utf8_lossy(s.fragment()).into_owned()
        })(input)
    }

    #[tracable_parser]
    fn parse_signature(input: Span) -> ParserResult<u32> {
        verify_le_u32(0x1A0A0D)(input)
    }

    #[tracable_parser]
    fn parse_major_version(input: Span) -> ParserResult<u32> {
        verify_le_u32(0x4)(input)
    }

    #[tracable_parser]
    fn parse_minor_version(input: Span) -> ParserResult<u32> {
        verify_le_u32(0x1)(input)
    }
}