lalrpop 0.19.2

convenient LR(1) 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

use super::FirstSets;
use crate::grammar::repr::*;
use crate::lr1::lookahead::Token::EOF;
use crate::lr1::lookahead::{Token, TokenSet};
use crate::lr1::tls::Lr1Tls;
use string_cache::DefaultAtom as Atom;
use crate::test_util::normalized_grammar;

pub fn nt(t: &str) -> Symbol {
    Symbol::Nonterminal(NonterminalString(Atom::from(t)))
}

pub fn term(t: &str) -> Symbol {
    Symbol::Terminal(TerminalString::quoted(Atom::from(t)))
}

fn la(t: &str) -> Token {
    Token::Terminal(TerminalString::quoted(Atom::from(t)))
}

fn first0(first: &FirstSets, symbols: &[Symbol]) -> Vec<Token> {
    let v = first.first0(symbols);
    v.iter().collect()
}

fn first1(first: &FirstSets, symbols: &[Symbol], lookahead: Token) -> Vec<Token> {
    let v = first.first1(symbols, &TokenSet::from(lookahead));
    v.iter().collect()
}

#[test]
fn basic_first1() {
    let grammar = normalized_grammar(
        r#"
    grammar;
    A = B "C";
    B: Option<u32> = {
        "D" => Some(1),
        => None
    };
    X = "E"; // intentionally unreachable
"#,
    );
    let _lr1_tls = Lr1Tls::install(grammar.terminals.clone());
    let first_sets = FirstSets::new(&grammar);

    assert_eq!(first1(&first_sets, &[nt("A")], EOF), vec![la("C"), la("D")]);

    assert_eq!(first1(&first_sets, &[nt("B")], EOF), vec![la("D"), EOF]);

    assert_eq!(
        first1(&first_sets, &[nt("B"), term("E")], EOF),
        vec![la("D"), la("E")]
    );

    assert_eq!(
        first1(&first_sets, &[nt("B"), nt("X")], EOF),
        vec![la("D"), la("E")]
    );
}

#[test]
fn basic_first0() {
    let grammar = normalized_grammar(
        r#"
    grammar;
    A = B "C";
    B: Option<u32> = {
        "D" => Some(1),
        => None
    };
    X = "E"; // intentionally unreachable
"#,
    );
    let _lr1_tls = Lr1Tls::install(grammar.terminals.clone());
    let first_sets = FirstSets::new(&grammar);

    assert_eq!(first0(&first_sets, &[nt("A")]), vec![la("C"), la("D")]);

    assert_eq!(first0(&first_sets, &[nt("B")]), vec![la("D"), EOF]);

    assert_eq!(
        first0(&first_sets, &[nt("B"), term("E")]),
        vec![la("D"), la("E")]
    );

    assert_eq!(
        first0(&first_sets, &[nt("B"), nt("X")]),
        vec![la("D"), la("E")]
    );

    assert_eq!(first0(&first_sets, &[nt("X")]), vec![la("E")]);
}