text_parsing/
state.rs

1use std::collections::VecDeque;
2
3use crate::{
4    Error,
5    Local, ParserEvent,
6    Parser, 
7    ParserResult,
8    Source, SourceEvent,
9};
10
11use opt_struct::OptVec;
12
13pub trait StateMachine: Default {
14    type Context;
15    type Data;
16    
17    fn eof(self, context: &Self::Context) -> NextResult<Self,Self::Data>;
18    fn next_state(self, local_char: Local<SourceEvent>, context: &Self::Context) -> NextResult<Self,Self::Data>;
19}
20
21#[derive(Debug)]
22enum State<S> {
23    SourceDone,
24    SourceInvalid,
25    Inner(S),
26}
27
28pub type NextResult<S, D> = Result<Next<S,D>,Error>;
29
30pub struct Next<S: Default, D> {
31    next_state: S,
32    events: OptVec<Local<ParserEvent<D>>>,
33}
34impl<S: Default, D> Next<S,D> {
35    pub fn empty() -> Next<S,D> {
36        Next {
37            next_state: S::default(),
38            events: OptVec::None,
39        }
40    }
41    pub fn with_state(mut self, st: S) -> Next<S,D> {
42        self.next_state = st;
43        self
44    }
45    pub fn with_event(mut self, ev: Local<ParserEvent<D>>) -> Next<S,D> {
46        self.events.push(ev);
47        self
48    }
49    pub fn push_event(&mut self, ev: Local<ParserEvent<D>>) {
50        self.events.push(ev);
51    }
52}
53
54
55pub struct Runtime<S,D,C> // State, Data, Context
56where S: StateMachine<Data = D, Context = C>
57{ 
58    state: State<S>,
59    buffer: VecDeque<Local<ParserEvent<D>>>,
60    context: C,
61}
62
63impl<S,D,C> Runtime<S,D,C>
64where S: StateMachine<Data = D, Context = C>
65{
66    pub fn new(context: C) -> Runtime<S,D,C> {
67        Runtime {
68            state: State::Inner(S::default()),
69            buffer: VecDeque::new(),
70            context,
71        }
72    }
73    
74    fn process_eof(&mut self, next: NextResult<S,D>) -> ParserResult<D> {
75        let r = self.process(next)?;
76        self.state = State::SourceDone;
77        Ok(r)
78    }
79    fn process_err(&mut self, e: Error) -> ParserResult<D> {
80        self.state = State::SourceInvalid;
81        Err(e)
82    }
83    fn process(&mut self, next: NextResult<S,D>) -> ParserResult<D> {
84        match next {
85            Ok(Next { next_state, events }) => {
86                self.state = State::Inner(next_state);
87                let mut iter = events.into_iter();
88                Ok(match iter.next() {
89                    None => None,
90                    Some(ev) => {
91                        self.buffer.extend(iter);
92                        Some(ev)
93                    }
94                })
95            },
96            Err(e) => self.process_err(e),
97        }
98    }
99}
100
101impl<S,D,C> Parser for Runtime<S,D,C>
102where S: StateMachine<Data = D, Context = C>
103{
104    type Data = D;
105    
106    fn next_event<SRC: Source>(&mut self, src: &mut SRC) -> ParserResult<D> {
107        match self.buffer.pop_front() {
108            Some(le) => Ok(Some(le)),
109            None => loop {
110                match &mut self.state {                    
111                    State::SourceDone => break Ok(self.buffer.pop_front()),
112                    State::SourceInvalid => break Ok(None),
113                    State::Inner(ts) => {
114                        let inner_state = std::mem::take(ts);                        
115                        if let Some(local) = match src.next_char() {
116                            Ok(None) => self.process_eof(inner_state.eof(&self.context)),                            
117                            Ok(Some(local_char)) => self.process(inner_state.next_state(local_char,&self.context)),
118                            Err(e) => self.process_err(e),
119                        }? {
120                            break Ok(Some(local))
121                        }
122                    },
123                }
124            }
125        }
126    }
127}
text_parsing/state.rs

text_parsing/
state.rs
