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
use range::Range;
use read_token::ReadToken;
use super::{
ret_err,
err_update,
ParseResult,
};
use {
DebugId,
MetaData,
ParseError,
Rule,
};
use tokenizer::TokenizerState;
#[derive(Clone)]
pub struct FastSelect {
pub table: [u8; 256],
pub args: Vec<Rule>,
pub tail: bool,
pub debug_id: DebugId,
}
impl PartialEq for FastSelect {
fn eq(&self, _: &Self) -> bool {false}
}
impl std::fmt::Debug for FastSelect {
fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
Ok(())
}
}
impl FastSelect {
pub fn parse(
&self,
tokens: &mut Vec<Range<MetaData>>,
state: &TokenizerState,
read_token: &ReadToken,
refs: &[Rule]
) -> ParseResult<TokenizerState> {
if self.tail {
if let Some(ch) = read_token.src.chars().next() {
let mut opt_error: Option<Range<ParseError>> = None;
let mut buf = [0; 4];
ch.encode_utf8(&mut buf);
let ind = self.table[buf[0] as usize];
if ind != 255 {
let sub_rule = &self.args[ind as usize];
match sub_rule.parse(tokens, state, read_token, refs) {
Ok((range, state, err)) => {
err_update(err, &mut opt_error);
return Ok((read_token.peek(range.length),
state, opt_error));
}
Err(err) => {
err_update(Some(err), &mut opt_error);
}
}
}
let sub_rule = &self.args[self.args.len()-1];
match sub_rule.parse(tokens, state, read_token, refs) {
Ok((range, state, err)) => {
err_update(err, &mut opt_error);
Ok((read_token.peek(range.length),
state, opt_error))
}
Err(err) => {
Err(ret_err(err, opt_error))
}
}
} else {
Err(read_token.start().wrap(
ParseError::ExpectedSomething(self.debug_id)))
}
} else {
if let Some(ch) = read_token.src.chars().next() {
let mut buf = [0; 4];
ch.encode_utf8(&mut buf);
let ind = self.table[buf[0] as usize];
if ind != 255 {
let sub_rule = &self.args[ind as usize];
match sub_rule.parse(tokens, state, read_token, refs) {
Ok((range, state, err)) => {
Ok((read_token.peek(range.length),
state, err))
}
Err(err) => {
Err(err)
}
}
} else {
Err(read_token.start().wrap(
ParseError::ExpectedSomething(self.debug_id)))
}
} else {
Err(read_token.start().wrap(
ParseError::ExpectedSomething(self.debug_id)))
}
}
}
}