gramma 0.2.24

Generate a scannerless parser by declaring types.
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

#![cfg(feature = "regex")]
use gramma::ast::{CompoundToken, DelimitedList, Discard, DualParse, Ignore, InfixChain};

type Blank = Ignore<Space>;

gramma::define_rule!(
    #[transform(ignore_before<Space>)]
    pub struct Braces {
        l_brace: Discard<LBrace>,
        inner: DelimitedList<Expr, (Blank, Comma)>,
        #[transform(ignore_before<Space>)]
        r_brace: Discard<RBrace>,
    }
    pub struct Expr {
        value: InfixChain<BaseExpr, InfixOp>,
    }
    pub enum BaseExpr {
        Ident {
            ident: Ident,
        },
        Braces {
            braces: Braces,
        },
        #[transform(ignore_before<Space>)]
        BracketedIdent {
            bracketed: CompoundToken<BracketedIdent>,
        },
        #[transform(ignore_before<Space>)]
        BracketedNumber {
            bracketed: CompoundToken<BracketedNumber>,
        },
    }

    #[transform(ignore_before<Space>)]
    pub enum InfixOp {
        Plus { value: Plus },
        Minus { value: Minus },
    }

    pub struct IdentParts {
        parts: DelimitedList<IdentPart, Underscore>,
    }
    #[transform(ignore_before<Space>)]
    pub struct Ident {
        inner: DualParse<IdentString, IdentParts>,
    }
    #[transform(
        ignore_after<Space>,
        discard_before<LBracket>,
        discard_after<RBracket>,
    )]
    pub struct BracketedIdent {
        ident: Ident,
    }
    pub struct BracketedNumber {
        l_bracket: Discard<LBracket>,
        #[transform(ignore_around<Space>)]
        ident: Digits,
        r_bracket: Discard<RBracket>,
    }
    pub enum Empty {}
);

gramma::define_token!(
    #[pattern(exact = "[")]
    pub struct LBracket;
    #[pattern(exact = "]")]
    pub struct RBracket;
    #[pattern(exact = "{")]
    pub struct LBrace;
    #[pattern(exact = "}")]
    pub struct RBrace;
    #[pattern(exact = ",")]
    pub struct Comma;
    #[pattern(exact = "+")]
    pub struct Plus;
    #[pattern(exact = "-")]
    pub struct Minus;
    #[pattern(exact = "_")]
    pub struct Underscore;
    #[pattern(regex = r"[a-zA-Z][a-zA-Z0-9_]*")]
    pub struct IdentString;
    #[pattern(regex = r"[a-zA-Z0-9]+")]
    pub struct IdentPart;
    #[pattern(regex = r"[0-9]+")]
    pub struct Digits;
    #[pattern(regex = r"\s+")]
    pub struct Space;
);

#[test]
pub fn parse_test1() {
    let src = "{a,{a, {{{ a +foo_bar+ {{{a,b} }}}-{}}},b,}, b +b }";
    let ast = gramma::parse_tree::<Braces, 2>(src).unwrap();
    println!("{:#}", gramma::display_tree(src, &ast));
}

#[test]
pub fn parse_test2() {
    let src = "abc_def";
    let ast = gramma::parse_tree::<Ident, 1>(src).unwrap();
    println!("{:#}", gramma::display_tree(src, &ast));
}

#[test]
pub fn parse_test3() {
    let src = r#"
    {
        a,
        {
            a,
            {
                {
                    {
                        a + foo_bar + {
                            {{a,[b] + [1]}},
                        }
                    }-{}
                }
            },
            b,
        },
        b
    }"#;
    let ast = gramma::parse_tree::<Expr, 1>(src).unwrap();
    println!("{:#}", gramma::display_tree(src, &ast));
}