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

use std::borrow::Borrow;
use std::fmt::Debug;

use cfg::Symbol;
use earley_omnitool::forest::bocage::order::NullOrder;
use earley_omnitool::forest::compact_bocage::order::NullOrder as CompactNullOrder;
use earley_omnitool::forest::{Bocage, CompactBocage, NullForest};
use earley_omnitool::grammar::InternalGrammar;
use earley_omnitool::recognizer::Recognizer;

pub trait Parse {
    fn parse(&mut self, tokens: &[u32]) -> bool;
}

impl<'g, G> Parse for Recognizer<'g, Bocage<G>>
where
    Self: Debug,
    G: Borrow<InternalGrammar>,
{
    #[inline]
    fn parse(&mut self, tokens: &[u32]) -> bool {
        let mut iter = tokens.iter().enumerate().peekable();
        while let Some((i, &token)) = iter.next() {
            self.begin_earleme();
            trace!("before pass 1 {:?}", &*self);
            self.scan(Symbol::from(token), i as u32);
            trace!("before pass 2 {:?}", &*self);
            self.lookahead_hint(iter.peek().map(|(_i, &t)| Symbol::from(t)));
            assert!(self.end_earleme(), "failed to parse after {}@{}", token, i);
        }
        trace!("finished {:?}", &*self);

        if self.is_finished() {
            self.forest
                .mark_alive(self.finished_node().unwrap(), NullOrder::new());
        }
        self.is_finished()
    }
}

impl<'g, G> Parse for Recognizer<'g, CompactBocage<G>>
where
    Self: Debug,
    G: Borrow<InternalGrammar>,
{
    #[inline]
    fn parse(&mut self, tokens: &[u32]) -> bool {
        let mut iter = tokens.iter().enumerate().peekable();
        while let Some((i, &token)) = iter.next() {
            self.begin_earleme();
            trace!("before pass 1 {:?}", &*self);
            self.scan(Symbol::from(token), i as u32);
            trace!("before pass 2 {:?}", &*self);
            self.lookahead_hint(iter.peek().map(|(_i, &t)| Symbol::from(t)));
            assert!(self.end_earleme(), "failed to parse after {}@{}", token, i);
        }
        trace!("finished {:?}", &*self);

        if self.is_finished() {
            self.forest
                .mark_alive(self.finished_node().unwrap(), CompactNullOrder::new());
        }
        self.is_finished()
    }
}

impl<'g> Parse for Recognizer<'g, NullForest>
where
    Self: Debug,
{
    #[inline]
    fn parse(&mut self, tokens: &[u32]) -> bool {
        for &token in tokens.iter() {
            self.begin_earleme();
            trace!("before pass 1 {:?}", &*self);
            self.scan(Symbol::from(token), ());
            trace!("before pass 2 {:?}", &*self);
            assert!(self.end_earleme());
        }
        trace!("finished {:?}", &*self);

        self.is_finished()
    }
}