mpl-macro 0.2.0

Derive parsers from MPL's one-rule grammar files. Includes the FastParse static-codegen backend (cascade detection, first-byte dispatch, Squirrel left recursion).
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

use crate::mplg::{MplgAST, MplgRules, MplgVariable};
use mpl::output::Output;
use mpl::parser::Parser;
use mpl::span::{Len, Start, StartAndLenSpan};
use mpl::symbols::U8SliceTerminal;

pub struct MplgParser;

impl<'i, P, L, O>
    Parser<'i, [u8], U8SliceTerminal<'i>, MplgVariable, StartAndLenSpan<P, L>, P, MplgRules, O>
    for MplgParser
where
    P: Start<[u8], L>,
    L: Len<[u8], P>,
    O: Output<'i, [u8], MplgVariable, StartAndLenSpan<P, L>>,
{
}

pub fn parse_mplg(input: &[u8]) -> Result<MplgAST<'_>, MplgAST<'_>> {
    let parser = MplgParser;
    let all_of_the_span = StartAndLenSpan::<u32, u32>::from_start_len(0, input.len() as u32);
    let rules = &MplgRules;
    parser.parse(input, rules, &MplgVariable::Mplg, &all_of_the_span)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn mplg() {
        enum ParseResult {
            Ok,
            Err,
        }
        let inputs = [
            // Ok
            ("", ParseResult::Ok),
            ("\n", ParseResult::Ok),
            ("\r\n", ParseResult::Ok),
            ("\r\n\n\r\n", ParseResult::Ok),
            // Rule
            ("A = B C / D\n", ParseResult::Ok),
            ("Abc1 = B1 CC / D0d\n", ParseResult::Ok),
            // Rules
            (
                "A = B C / D\r\nE = F G / H\nI = J K / L\r\nM = N O / P\n",
                ParseResult::Ok,
            ),
            // LineComment
            ("//\n", ParseResult::Ok),
            ("//\r\n", ParseResult::Ok),
            ("// \n", ParseResult::Ok),
            ("// Hello\n", ParseResult::Ok),
            ("//A = B C / D\n", ParseResult::Ok),
            ("// \"こんにちは!\"\n", ParseResult::Ok),
            // LineComments
            ("//\r\n// a\r\n//b\n", ParseResult::Ok),
            // Metasymbols
            ("A = () () / ()\n", ParseResult::Ok),
            ("A = f f / f\n", ParseResult::Ok),
            ("A = ? ?? / ???\n", ParseResult::Ok),
            ("A = * * / *\n", ParseResult::Ok),
            // Chars
            ("A = { 'b' } { 'c' } / { 'd' }\n", ParseResult::Ok),
            // ("A = { '\'' } { '\'' } / { '\'' }\n", ParseResult::Ok),
            // Strings
            (
                "A = { \"string\" } { \"''\r\n\n\\\"\\\"\n\" } / { \"\" }\n",
                ParseResult::Ok,
            ),
            // Integers
            (
                "A = { 1234567890 } { 1_2__3 } / { 1_____ }\n",
                ParseResult::Ok,
            ),
            // Struct
            (
                "A = { Str(\"b\") } { Null(1) } / { A(2) }\n",
                ParseResult::Ok,
            ),
            // Mplg
            (
                "// Mplg = Line Mplg / ()\nMplg = Line Mplg / ()\r\n\n",
                ParseResult::Ok,
            ),
            // Err
            ("A = B\n", ParseResult::Err),
            ("A = B C / D", ParseResult::Err),
            ("A = B / C / D\n", ParseResult::Err),
            ("a = B C / D\n", ParseResult::Err),
            ("A = b c / d\n", ParseResult::Err),
            ("() = B C / D\n", ParseResult::Err),
            ("A = { 'bb' } { 'c' } / { 'd' }\n", ParseResult::Err),
        ];
        for input in inputs {
            let result = parse_mplg(input.0.as_bytes());
            match input.1 {
                ParseResult::Ok => assert!(result.is_ok()),
                ParseResult::Err => assert!(result.is_err()),
            }
        }
    }
}