peg 0.8.6

A simple Parsing Expression Grammar (PEG) parser generator.
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

peg::parser!( grammar arithmetic() for str {
    rule ident() -> &'input str = $(['a'..='z']+)

    pub rule expression() -> Node = precedence!{
        start:position!() node:@ end:position!() { Node { start, node, end} }
        --
        x:(@) "+" y:@ { Op::Add(Box::new(x), Box::new(y)) }
        --
        x:(@) "*" y:@ { Op::Mul(Box::new(x), Box::new(y)) }
        --
        i:ident() [' '|'\n']* { Op::Ident(i.to_owned()) }
    }
});

#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Node {
    node: Op,
    start: usize,
    end: usize,
}

#[derive(Debug, PartialEq, Eq, Clone)]
pub enum Op {
    Ident(String),
    Add(Box<Node>, Box<Node>),
    Mul(Box<Node>, Box<Node>),
}

#[test]
fn main() {
    assert_eq!(
        arithmetic::expression("a+b*c").unwrap(),
        Node {
            start: 0,
            end: 5,
            node: Op::Add(
                Box::new(Node {
                    start: 0,
                    end: 1,
                    node: Op::Ident("a".into())
                }),
                Box::new(Node {
                    start: 2,
                    end: 5,
                    node: Op::Mul(
                        Box::new(Node {
                            start: 2,
                            end: 3,
                            node: Op::Ident("b".into())
                        }),
                        Box::new(Node {
                            start: 4,
                            end: 5,
                            node: Op::Ident("c".into())
                        })
                    )
                })
            )
        }
    );
}