lang_pt 0.1.2

A parser tool to generate recursive descent top down parser.
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

use crate::production::{EOFProd, Node};
use crate::NodeImpl;
use crate::{
    production::{Concat, ConstantField, RegexField, Union},
    LexerlessParser,
};
use std::rc::Rc;

#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, PartialOrd, Ord)]
enum NodeValue {
    ID,
    Add,
    Sub,
    Mul,
    Div,
    NULL,
    Root,
}

impl NodeImpl for NodeValue {
    fn null() -> Self {
        Self::NULL
    }
}

#[test]
fn union_test() {
    let eof = Rc::new(EOFProd::new(None));
    let id = Rc::new(RegexField::new(r#"^[_$a-zA-Z][_$\w]*"#, Some(NodeValue::ID)).unwrap());
    let add = Rc::new(ConstantField::new("+", Some(NodeValue::Add)));
    let sub = Rc::new(ConstantField::new("-", Some(NodeValue::Sub)));
    let mul = Rc::new(ConstantField::new("*", Some(NodeValue::Mul)));
    let div = Rc::new(ConstantField::new("/", Some(NodeValue::Div)));
    let addition = Rc::new(Concat::new(
        "addition",
        vec![id.clone(), add.clone(), id.clone()],
    ));
    let subtraction = Rc::new(Concat::new(
        "subtraction",
        vec![id.clone(), sub.clone(), id.clone()],
    ));
    let multiplication = Rc::new(Concat::new(
        "multiplication",
        vec![id.clone(), mul.clone(), id.clone()],
    ));
    let division = Rc::new(Concat::new(
        "division",
        vec![id.clone(), div.clone(), id.clone()],
    ));
    let expression = Rc::new(Union::new(
        "expression",
        vec![addition, subtraction, multiplication, division],
    ));

    let main = Rc::new(Concat::new("main", vec![expression, eof]));
    let main_node = Rc::new(Node::new(&main, NodeValue::Root));

    let parser = LexerlessParser::new(main_node).unwrap();
    let tree_list = parser.parse(b"ax+by").unwrap();
    tree_list.last().unwrap().print().unwrap();
}