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
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

use std::ops::Range;

#[derive(Debug, PartialEq)]
struct Node {
    span: Range<usize>,
    kind: NodeKind,
}

#[derive(Debug, PartialEq)]
enum NodeKind {
    Number(i64),
    Add(Box<Node>, Box<Node>),
    Sub(Box<Node>, Box<Node>),
    Mul(Box<Node>, Box<Node>),
    Div(Box<Node>, Box<Node>),
    Factorial(Box<Node>),
    Neg(Box<Node>),
    Group(Box<Node>),
    Var(String),
}

peg::parser!( grammar lang() for str {
    inject span(_input, lpos, rpos) -> Range<usize> { lpos..rpos }

    rule number() -> Node
        = n:$(['0'..='9']+) {? match n.parse() {
            Ok(n) => Ok(Node { span, kind: NodeKind::Number(n) }),
            Err(_) => Err("number too large"),
        }}

    rule var() -> Node
        = v:$(['a'..='z']+) { Node { span, kind: NodeKind::Var(v.to_string()) } }

    pub rule expr() -> Node = precedence!{
        x:(@) "+" y:@ { Node { span, kind: NodeKind::Add(Box::new(x), Box::new(y)) } }
        x:(@) "-" y:@ { Node { span, kind: NodeKind::Sub(Box::new(x), Box::new(y)) } }
              "-" v:@ { Node { span, kind: NodeKind::Neg(Box::new(v)) } }
        --
        x:(@) "*" y:@ { Node { span, kind: NodeKind::Mul(Box::new(x), Box::new(y)) } }
        x:(@) "/" y:@ { Node { span, kind: NodeKind::Div(Box::new(x), Box::new(y)) } }
        --
        v:@   "!"     { Node { span, kind: NodeKind::Factorial(Box::new(v)) } }
        --
        "(" v:expr() ")" { Node { span, kind: NodeKind::Group(Box::new(v)) } }
        v:var() { v }
        n:number() { n }
    }
});

#[test]
fn main() {
    assert_eq!(
        lang::expr("3+3*(-33+v!)"),
        Ok(Node {
            span: 0..12,
            kind: NodeKind::Add(
                Box::new(Node {
                    span: 0..1,
                    kind: NodeKind::Number(3),
                }),
                Box::new(Node {
                    span: 2..12,
                    kind: NodeKind::Mul(
                        Box::new(Node {
                            span: 2..3,
                            kind: NodeKind::Number(3),
                        }),
                        Box::new(Node {
                            span: 4..12,
                            kind: NodeKind::Group(Box::new(Node {
                                span: 5..11,
                                kind: NodeKind::Add(
                                    Box::new(Node {
                                        span: 5..8,
                                        kind: NodeKind::Neg(Box::new(Node {
                                            span: 6..8,
                                            kind: NodeKind::Number(33),
                                        })),
                                    }),
                                    Box::new(Node {
                                        span: 9..11,
                                        kind: NodeKind::Factorial(Box::new(Node {
                                            span: 9..10,
                                            kind: NodeKind::Var("v".to_string()),
                                        })),
                                    }),
                                ),
                            })),
                        }),
                    )
                }),
            ),
        })
    );
}

peg::parser!( grammar inject2(offset: usize) for str {
    inject span(_input, lpos, rpos) -> Range<usize> { (offset + lpos)..(offset + rpos) }
    inject text(input, lpos, rpos) -> &'input str { &input[lpos..rpos] }

    pub rule test() -> (Range<usize>, String)
        = "abc" { (span, text.to_string()) }
});

#[test]
fn inject2() {
    assert_eq!(inject2::test("abc", 10), Ok((10..13, "abc".into())));
}