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
121
122
123
124
125
126
127

use std::collections::VecDeque;

use crate::{
    Error,
    Local, ParserEvent,
    Parser, 
    ParserResult,
    Source, SourceEvent,
};

use opt_struct::OptVec;

pub trait StateMachine: Default {
    type Context;
    type Data;
    
    fn eof(self, context: &Self::Context) -> NextResult<Self,Self::Data>;
    fn next_state(self, local_char: Local<SourceEvent>, context: &Self::Context) -> NextResult<Self,Self::Data>;
}

#[derive(Debug)]
enum State<S> {
    SourceDone,
    SourceInvalid,
    Inner(S),
}

pub type NextResult<S, D> = Result<Next<S,D>,Error>;

pub struct Next<S: Default, D> {
    next_state: S,
    events: OptVec<Local<ParserEvent<D>>>,
}
impl<S: Default, D> Next<S,D> {
    pub fn empty() -> Next<S,D> {
        Next {
            next_state: S::default(),
            events: OptVec::None,
        }
    }
    pub fn with_state(mut self, st: S) -> Next<S,D> {
        self.next_state = st;
        self
    }
    pub fn with_event(mut self, ev: Local<ParserEvent<D>>) -> Next<S,D> {
        self.events.push(ev);
        self
    }
    pub fn push_event(&mut self, ev: Local<ParserEvent<D>>) {
        self.events.push(ev);
    }
}


pub struct Runtime<S,D,C> // State, Data, Context
where S: StateMachine<Data = D, Context = C>
{ 
    state: State<S>,
    buffer: VecDeque<Local<ParserEvent<D>>>,
    context: C,
}

impl<S,D,C> Runtime<S,D,C>
where S: StateMachine<Data = D, Context = C>
{
    pub fn new(context: C) -> Runtime<S,D,C> {
        Runtime {
            state: State::Inner(S::default()),
            buffer: VecDeque::new(),
            context,
        }
    }
    
    fn process_eof(&mut self, next: NextResult<S,D>) -> ParserResult<D> {
        let r = self.process(next)?;
        self.state = State::SourceDone;
        Ok(r)
    }
    fn process_err(&mut self, e: Error) -> ParserResult<D> {
        self.state = State::SourceInvalid;
        Err(e)
    }
    fn process(&mut self, next: NextResult<S,D>) -> ParserResult<D> {
        match next {
            Ok(Next { next_state, events }) => {
                self.state = State::Inner(next_state);
                let mut iter = events.into_iter();
                Ok(match iter.next() {
                    None => None,
                    Some(ev) => {
                        self.buffer.extend(iter);
                        Some(ev)
                    }
                })
            },
            Err(e) => self.process_err(e),
        }
    }
}

impl<S,D,C> Parser for Runtime<S,D,C>
where S: StateMachine<Data = D, Context = C>
{
    type Data = D;
    
    fn next_event<SRC: Source>(&mut self, src: &mut SRC) -> ParserResult<D> {
        match self.buffer.pop_front() {
            Some(le) => Ok(Some(le)),
            None => loop {
                match &mut self.state {                    
                    State::SourceDone => break Ok(self.buffer.pop_front()),
                    State::SourceInvalid => break Ok(None),
                    State::Inner(ts) => {
                        let inner_state = std::mem::take(ts);                        
                        if let Some(local) = match src.next_char() {
                            Ok(None) => self.process_eof(inner_state.eof(&self.context)),                            
                            Ok(Some(local_char)) => self.process(inner_state.next_state(local_char,&self.context)),
                            Err(e) => self.process_err(e),
                        }? {
                            break Ok(Some(local))
                        }
                    },
                }
            }
        }
    }
}