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
62
63
64
65

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

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

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

#[test]
pub fn concat_test() {
    let eof = Rc::new(EOFProd::new(None));
    let id = Rc::new(RegexField::new(r#"^[_$a-zA-Z][_$\w]*"#, Some(NodeValue::ID)).unwrap());
    let operators = Rc::new(
        PunctuationsField::new(vec![
            ("+", Some(NodeValue::Add)),
            ("-", Some(NodeValue::Sub)),
            ("*", Some(NodeValue::Mul)),
            ("/", Some(NodeValue::Div)),
        ])
        .unwrap(),
    );
    let open_paren = Rc::new(ConstantField::new("(", None));
    let close_paren = Rc::new(ConstantField::new(")", None));

    let expression = Rc::new(Concat::new(
        "Expression",
        vec![id.clone(), operators.clone(), id.clone()],
    ));

    let expression_node = Rc::new(Node::new(&expression, NodeValue::Expr));

    let parenthesis_expression = Rc::new(Concat::new(
        "Parenthesis_Expression",
        vec![
            open_paren.clone(),
            expression_node.clone(),
            close_paren.clone(),
        ],
    ));

    let root = Rc::new(Concat::new("main", vec![parenthesis_expression, eof]));

    let root_node = Rc::new(Node::new(&root, NodeValue::Root));

    let parser = LexerlessParser::new(root_node).unwrap();

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