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

use std::{
    fmt::{Debug, Display},
    rc::Rc,
    time::Instant,
};

use crate::{
    production::{Concat, Node, Nullable, TokenField},
    LexerlessParser, NodeImpl, TokenImpl,
};

#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, PartialOrd, Ord)]
enum Token {
    A,
    B,
    C,
    Eof,
}
impl TokenImpl for Token {
    fn eof() -> Self {
        Token::Eof
    }

    fn is_structural(&self) -> bool {
        true
    }
}

#[derive(Debug, Clone, Copy)]
enum NodeValue {
    P,
    Q,
    R,
    NULL,
}

impl NodeImpl for NodeValue {
    fn null() -> Self {
        Self::NULL
    }
}
impl Display for Token {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}", self)
    }
}

#[test]
fn circular_dependency_test() {
    let p1 = Rc::new(TokenField::new(Token::A, Some(NodeValue::P)));
    let p2 = Rc::new(TokenField::new(Token::B, Some(NodeValue::Q)));

    let p3 = Rc::new(Concat::<NodeValue, Token>::init("ID1"));

    let p4 = Rc::new(Concat::<NodeValue, Token>::new(
        "ID2",
        vec![p3.clone(), p2.clone(), p1.clone()],
    ));

    p3.set_symbols(vec![p4.clone(), p2.clone(), p3.clone()])
        .unwrap();

    let p5 = Rc::new(Node::new(&p4, NodeValue::R));
    let now = Instant::now();
    match LexerlessParser::new(p5) {
        Ok(_) => panic!("Validation should fail."),
        Err(err) => println!("{:?}", err),
    }
    println!("Time elapsed: {:?}", now.elapsed());
}

#[test]
fn circular_dependency_test2() {
    let p1 = Rc::new(TokenField::new(Token::A, Some(NodeValue::P)));
    let p2 = Rc::new(TokenField::new(Token::B, Some(NodeValue::Q)));
    let np1 = Rc::new(Nullable::new(&p1));
    let np2 = Rc::new(Nullable::new(&p2));

    let np3 = Rc::new(Concat::<NodeValue, Token>::new("N_ID1", vec![np1, np2]));
    let p3 = Rc::new(Concat::<NodeValue, Token>::init("ID1"));

    let p4 = Rc::new(Concat::<NodeValue, Token>::new(
        "ID2",
        vec![p3.clone(), p2.clone(), p1.clone()],
    ));

    p3.set_symbols(vec![np3.clone(), p3.clone()]).unwrap();

    let p5 = Rc::new(Node::new(&p4, NodeValue::R));
    let now = Instant::now();
    match LexerlessParser::new(p5) {
        Ok(_) => panic!("Validation should fail."),
        Err(err) => println!("{:?}", err),
    }
    println!("Time elapsed: {:?}", now.elapsed());
}
#[test]
fn print_grammar_test() {
    let p1 = Rc::new(TokenField::new(Token::A, Some(NodeValue::P)));
    let p2 = Rc::new(TokenField::new(Token::B, Some(NodeValue::Q)));
    let p3 = Rc::new(TokenField::new(Token::C, Some(NodeValue::R)));

    let p4 = Rc::new(Concat::<NodeValue, Token>::new(
        "PROD4",
        vec![p3.clone(), p1.clone()],
    ));
    let p5 = Rc::new(Concat::<NodeValue, Token>::init("MAIN"));
    p5.set_symbols(vec![p4.clone(), p2.clone(), p1.clone()])
        .unwrap();
    let now = Instant::now();
    LexerlessParser::new(p5).unwrap();

    // println!(
    //     "Grammar:[
    //         {}
    //         ]",
    //     gu.print_grammar().unwrap()
    // );
    println!("Time elapsed: {:.4?}", now.elapsed());
}