cfg 0.10.1

Library for manipulating context-free grammars.
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

#![cfg(feature = "cfg-predict-sets")]

use cfg::Cfg;
use cfg_predict_sets::{FirstSets, PredictSets, sets::PerSymbolSetVal};

use std::collections::BTreeMap;

#[test]
fn test_simple_first_sets() {
    let mut cfg: Cfg = Cfg::new();
    let [start, a, x, b, c, y] = cfg.sym();

    cfg.rule(start)
        .rhs([a, x, b])
        .rhs([c])
        .rule(b)
        .rhs([a, a])
        .rhs([a, c])
        .rule(c)
        .rhs([x])
        .rhs([y])
        .rule(a)
        .rhs([]);

    cfg.set_roots([start]);

    let collector = FirstSets::new(&cfg);
    let sets = collector.predict_sets();

    let mut map = BTreeMap::new();
    let start_set = PerSymbolSetVal {
        has_none: false,
        list: vec![x, y],
    };
    let a_set = PerSymbolSetVal {
        has_none: true,
        list: vec![],
    };
    let b_set = PerSymbolSetVal {
        has_none: true,
        list: vec![x, y],
    };
    let c_set = PerSymbolSetVal {
        has_none: false,
        list: vec![x, y],
    };

    map.insert(start, start_set);
    map.insert(a, a_set);
    map.insert(b, b_set);
    map.insert(c, c_set);

    assert_eq!(sets, &map);
}

#[test]
fn test_simple_first_sets_altered() {
    let mut cfg: Cfg = Cfg::new();
    let [start, a, x, b, c, y] = cfg.sym();

    cfg.rule(start)
        .rhs([a, x, b])
        .rule(b)
        .rhs([a, a])
        .rhs([a, c])
        .rule(c)
        .rhs([x])
        .rhs([y])
        .rule(a)
        .rhs([]);
    let collector = FirstSets::new(&cfg);
    let sets = collector.predict_sets();

    let mut map = BTreeMap::new();
    let start_set = PerSymbolSetVal {
        has_none: false,
        list: vec![x],
    };
    let a_set = PerSymbolSetVal {
        has_none: true,
        list: vec![],
    };
    let b_set = PerSymbolSetVal {
        has_none: true,
        list: vec![x, y],
    };
    let c_set = PerSymbolSetVal {
        has_none: false,
        list: vec![x, y],
    };

    map.insert(start, start_set);
    map.insert(a, a_set);
    map.insert(b, b_set);
    map.insert(c, c_set);

    assert_eq!(sets, &map);
}