earley-omnitool 0.0.6

An Earley parser engine.
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

#[macro_use]
extern crate log;
extern crate env_logger;
extern crate cfg;
extern crate earley_omnitool;

mod helpers;

use cfg::Symbol;
use cfg::sequence::Separator::Trailing;
use cfg::earley::Grammar;

use earley_omnitool::forest::Bocage;
use earley_omnitool::grammar::InternalGrammar;
use earley_omnitool::recognizer::Recognizer;

use helpers::{SimpleEvaluator, Parse};

#[test]
fn test_sequence() {
    let _ = env_logger::try_init();
    let (plus, minus) = (1, 2);
    let tokens = &[plus, minus, plus, minus, plus, minus];
    let mut external = Grammar::new();
    let (start, plus, minus) = external.sym();
    external.sequence(start).separator(Trailing(minus)).inclusive(3, Some(3)).rhs(plus);
    external.set_start(start);

    let cfg = InternalGrammar::from_grammar(&external);
    let mut evaluator = SimpleEvaluator::new(
        |sym: Symbol| {
            match sym.usize() {
                1 => 1,
                2 => -1,
                _ => unreachable!()
            }
        },
        |rule: u32, args: &[&i32]| {
            if rule == 0 {
                args.len() as i32
            } else {
                unreachable!()
            }
        },
        |_, _: &mut Vec<i32>| unreachable!()
    );
    let bocage = Bocage::new(&cfg);
    let mut recognizer = Recognizer::new(&cfg, bocage);
    assert!(recognizer.parse(tokens));

    let mut traversal = recognizer.forest.traverse();

    let results = evaluator.traverse(&mut traversal, recognizer.finished_node().unwrap());

    assert_eq!(results, vec![6]);
}