aob_common 1.0.2

String searching with wildcards
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

use crate::error::SimpleError;
use chumsky::{
    primitive::{
        choice,
        filter,
        filter_map,
        just,
    },
    Parser,
};

#[must_use]
pub(crate) fn ida_pattern() -> impl Parser<char, Vec<Option<u8>>, Error = SimpleError> {
    let whitespace = filter(|c: &char| c.is_whitespace()).repeated();
    let wildcard = just("?").repeated().at_least(1).at_most(2).to(None);
    let byte = filter_map(|span, c: char| {
        if c.is_ascii_hexdigit() {
            Ok(c as u8)
        } else {
            Err(SimpleError::invalid_hexdigit(span, c))
        }
    })
    .repeated()
    .exactly(2)
    .map(|digits| {
        let digits = String::from_utf8(digits).unwrap();
        Some(u8::from_str_radix(&digits, 16).unwrap())
    });

    choice((wildcard, byte))
        .separated_by(whitespace.at_least(1))
        .collect()
        .padded_by(whitespace)
}

#[cfg(test)]
mod tests {
    use chumsky::{
        primitive::end,
        Parser as _,
    };

    #[test]
    fn test_success() {
        let parser = super::ida_pattern().then_ignore(end());
        assert_eq!(
            parser.parse("AA ? BB").unwrap(),
            [Some(0xAA), None, Some(0xBB)]
        );
        assert_eq!(
            parser.parse("AA ?? BB").unwrap(),
            [Some(0xAA), None, Some(0xBB)]
        );
        assert_eq!(
            parser.parse("AA    ? BB").unwrap(),
            [Some(0xAA), None, Some(0xBB)]
        );
        assert_eq!(
            parser.parse(" AA ? BB").unwrap(),
            [Some(0xAA), None, Some(0xBB)]
        );
        assert_eq!(
            parser.parse("AA ? BB ").unwrap(),
            [Some(0xAA), None, Some(0xBB)]
        );
    }

    #[test]
    fn test_error() {
        let parser = super::ida_pattern().then_ignore(end());
        assert!(parser.parse("A ? BB").is_err());
        assert!(parser.parse("AAA ? BB").is_err());
        assert!(parser.parse("AA ??? BB").is_err());
        assert!(parser.parse("Ax ? BB").is_err());
        assert!(parser.parse("\"AA ? BB\"").is_err());
    }
}