/rust/registry/src/index.crates.io-1949cf8c6b5b557f/antlr4rust-0.6.0/src/atn_deserializer.rs
Line | Count | Source |
1 | | use std::slice::Iter; |
2 | | use std::str::FromStr; |
3 | | |
4 | | use uuid::Uuid; |
5 | | |
6 | | use crate::atn::ATN; |
7 | | use crate::atn_deserialization_options::ATNDeserializationOptions; |
8 | | use crate::atn_state::ATNBlockStart; |
9 | | use crate::atn_state::ATNDecisionState; |
10 | | use crate::atn_state::ATNState; |
11 | | use crate::atn_state::ATNStateType; |
12 | | use crate::atn_state::BaseATNState; |
13 | | use crate::atn_state::*; |
14 | | use crate::atn_type::ATNType; |
15 | | use crate::int_stream::EOF; |
16 | | use crate::interval_set::IntervalSet; |
17 | | use crate::lexer_action::LexerAction::*; |
18 | | use crate::lexer_action::*; |
19 | | use crate::transition::Transition; |
20 | | use crate::transition::*; |
21 | | |
22 | | lazy_static! { |
23 | | static ref BASE_SERIALIZED_UUID: Uuid = |
24 | | Uuid::from_str("33761B2D-78BB-4A43-8B0B-4F5BEE8AACF3").unwrap(); |
25 | | static ref ADDED_PRECEDENCE_TRANSITIONS: Uuid = |
26 | | Uuid::from_str("1DA0C57D-6C06-438A-9B27-10BCB3CE0F61").unwrap(); |
27 | | static ref ADDED_LEXER_ACTIONS: Uuid = |
28 | | Uuid::from_str("AADB8D7E-AEEF-4415-AD2B-8204D6CF042E").unwrap(); |
29 | | static ref ADDED_UNICODE_SMP: Uuid = |
30 | | Uuid::from_str("59627784-3BE5-417A-B9EB-8131A7286089").unwrap(); |
31 | | static ref SUPPORTED_UUIDS: Vec<Uuid> = vec![ |
32 | | *BASE_SERIALIZED_UUID, |
33 | | *ADDED_PRECEDENCE_TRANSITIONS, |
34 | | *ADDED_LEXER_ACTIONS, |
35 | | *ADDED_UNICODE_SMP, |
36 | | ]; |
37 | | } |
38 | | |
39 | | const SERIALIZED_VERSION: i32 = 4; |
40 | | |
41 | | #[derive(Debug)] |
42 | | pub struct ATNDeserializer { |
43 | | deserialization_options: ATNDeserializationOptions, |
44 | | } |
45 | | |
46 | | impl ATNDeserializer { |
47 | 4 | pub fn new(options: Option<ATNDeserializationOptions>) -> ATNDeserializer { |
48 | 4 | ATNDeserializer { |
49 | 4 | deserialization_options: options.unwrap_or_default(), |
50 | 4 | } |
51 | 4 | } |
52 | | |
53 | 4 | pub fn deserialize(&self, data: &mut Iter<i32>) -> ATN { |
54 | 4 | self.check_version(*data.next().unwrap()); |
55 | | |
56 | 4 | let mut atn = self.read_atn(data); |
57 | | |
58 | 4 | self.read_states(&mut atn, data); |
59 | 4 | self.read_rules(&mut atn, data); |
60 | 4 | self.read_modes(&mut atn, data); |
61 | | |
62 | 4 | let sets = self.read_sets(&mut atn, data); |
63 | | |
64 | 4 | self.read_edges(&mut atn, data, &sets); |
65 | 4 | self.read_decisions(&mut atn, data); |
66 | 4 | if atn.grammar_type == ATNType::LEXER { |
67 | 2 | self.read_lexer_actions(&mut atn, data); |
68 | 2 | } |
69 | 4 | self.mark_precedence_decisions(&mut atn, data); |
70 | 4 | if self.deserialization_options.is_verify() { |
71 | 4 | self.verify_atn(&mut atn, data); |
72 | 4 | } |
73 | | // TODO parser |
74 | | // if a.deserializationOptions.generateRuleBypassTransitions && atn.grammarType == ATNTypeParser { |
75 | | // a.generateRuleBypassTransitions(atn) |
76 | | // a.verifyATN(atn) |
77 | | // } |
78 | | |
79 | 4 | atn |
80 | 4 | } |
81 | | |
82 | | // fn reset(&self, _data: Vec<u8>) { unimplemented!() } |
83 | | |
84 | 4 | fn check_version(&self, version: i32) { |
85 | 4 | if version != self::SERIALIZED_VERSION { |
86 | 0 | panic!( |
87 | 0 | "Could not deserialize ATN with version {} (expected {})", |
88 | | version, SERIALIZED_VERSION |
89 | | ); |
90 | 4 | } |
91 | 4 | } |
92 | | |
93 | 4 | fn read_atn(&self, data: &mut Iter<i32>) -> ATN { |
94 | 4 | ATN::new_atn( |
95 | 4 | match data.next() { |
96 | 2 | Some(0) => ATNType::LEXER, |
97 | 2 | Some(1) => ATNType::PARSER, |
98 | 0 | _ => panic!("invalid ATN type"), |
99 | | }, |
100 | 4 | *data.next().unwrap(), |
101 | | ) |
102 | 4 | } |
103 | | |
104 | 4 | fn read_states(&self, atn: &mut ATN, data: &mut Iter<i32>) { |
105 | | // let loop_back_states = Vec::<(BaseATNState,i32)>::new(); |
106 | | // let end_states = Vec::<(BaseATNState,i32)>::new(); |
107 | 4 | let states_count = *data.next().unwrap(); |
108 | 1.38k | for i in 0..states_count { |
109 | 1.38k | let state_type = *data.next().unwrap(); |
110 | 1.38k | if state_type == ATNSTATE_INVALID_STATE_NUMBER { |
111 | 0 | atn.add_state(self.state_factory(ATNSTATE_INVALID_TYPE, -1, i)); |
112 | 0 | panic!("why invalid state serialized?"); |
113 | 1.38k | } |
114 | | |
115 | 1.38k | let mut rule_index = *data.next().unwrap(); |
116 | 1.38k | if rule_index == 0xFFFF { |
117 | 0 | rule_index = -1; |
118 | 1.38k | } |
119 | 1.38k | let mut state = self.state_factory(state_type, rule_index, i); |
120 | | |
121 | 1.38k | match state.get_state_type_mut() { |
122 | | ATNStateType::DecisionState { |
123 | 130 | state: ATNDecisionState::BlockStartState { end_state, .. }, |
124 | | .. |
125 | 130 | } => *end_state = *data.next().unwrap(), |
126 | 66 | ATNStateType::LoopEndState(loop_back) => *loop_back = *data.next().unwrap(), |
127 | 1.19k | _ => (), |
128 | | } |
129 | 1.38k | atn.add_state(state); |
130 | | } |
131 | | |
132 | 4 | let num_non_greedy = *data.next().unwrap(); |
133 | | //println!("num_non_greedy {}", num_non_greedy); |
134 | 4 | for _ in 0..num_non_greedy { |
135 | 8 | let st = *data.next().unwrap(); |
136 | 8 | if let ATNStateType::DecisionState { nongreedy: ng, .. } = |
137 | 8 | atn.states[st as usize].get_state_type_mut() |
138 | | { |
139 | 8 | *ng = true |
140 | 0 | } |
141 | | } |
142 | | |
143 | | //if (supportsPrecedencePredicates) |
144 | 4 | if true { |
145 | 4 | let num_precedence_states = *data.next().unwrap(); |
146 | 4 | for _ in 0..num_precedence_states { |
147 | 6 | let st = *data.next().unwrap() as usize; |
148 | | if let ATNStateType::RuleStartState { |
149 | 6 | is_left_recursive: left_rec, |
150 | | .. |
151 | 6 | } = atn.states[st].get_state_type_mut() |
152 | | { |
153 | 6 | *left_rec = true |
154 | 0 | } |
155 | | } |
156 | 0 | } |
157 | 4 | } |
158 | | |
159 | 4 | fn read_rules(&self, atn: &mut ATN, data: &mut Iter<i32>) { |
160 | 4 | let nrules = *data.next().unwrap() as usize; |
161 | | // if atn.grammar_type == ATNType::LEXER { |
162 | | // atn.rule_to_token_type.resize(nrules, 0) |
163 | | // } |
164 | | |
165 | 4 | atn.rule_to_start_state.resize(nrules, 0); |
166 | 130 | for i in 0..nrules { |
167 | 130 | let s = *data.next().unwrap(); |
168 | 130 | atn.rule_to_start_state[i] = s; |
169 | 130 | if atn.grammar_type == ATNType::LEXER { |
170 | 96 | let token_type = *data.next().unwrap(); |
171 | 96 | |
172 | 96 | atn.rule_to_token_type.push(token_type); |
173 | 96 | } |
174 | | } |
175 | | //println!("rule_to_token_type {:?}", atn.rule_to_token_type); |
176 | | //println!("rule_to_start_state {:?}", atn.rule_to_start_state); |
177 | | |
178 | 4 | atn.rule_to_stop_state.resize(nrules, 0); |
179 | 1.38k | for i in 0..atn.states.len() { |
180 | 1.38k | let state = atn.states.get(i).unwrap(); |
181 | 1.38k | if let ATNStateType::RuleStopState = state.get_state_type() { |
182 | 130 | let rule_index = state.get_rule_index() as usize; |
183 | 130 | atn.rule_to_stop_state[rule_index] = i as i32; |
184 | 130 | let start_state = atn |
185 | 130 | .states |
186 | 130 | .get_mut(atn.rule_to_start_state[rule_index] as usize) |
187 | 130 | .unwrap(); |
188 | | if let ATNStateType::RuleStartState { |
189 | 130 | stop_state: stop, .. |
190 | 130 | } = start_state.get_state_type_mut() |
191 | | { |
192 | 130 | *stop = i as i32 |
193 | 0 | } |
194 | 1.25k | } |
195 | | } |
196 | 4 | } |
197 | | |
198 | 4 | fn read_modes(&self, atn: &mut ATN, data: &mut Iter<i32>) { |
199 | 4 | let nmodes = *data.next().unwrap(); |
200 | 4 | for _i in 0..nmodes { |
201 | 2 | atn.mode_to_start_state.push(*data.next().unwrap()); |
202 | 2 | } |
203 | 4 | } |
204 | | |
205 | 4 | fn read_sets(&self, _atn: &mut ATN, data: &mut Iter<i32>) -> Vec<IntervalSet> { |
206 | 4 | let nsets = *data.next().unwrap(); |
207 | 4 | let mut sets = Vec::new(); |
208 | 40 | for _i in 0..nsets { |
209 | 40 | let intervals = *data.next().unwrap(); |
210 | | |
211 | 40 | let mut set = IntervalSet::new(); |
212 | | |
213 | | // check if contains eof |
214 | 40 | if *data.next().unwrap() != 0 { |
215 | 0 | set.add_one(-1) |
216 | 40 | } |
217 | | |
218 | 106 | for _ in 0..intervals { |
219 | 106 | set.add_range(*data.next().unwrap(), *data.next().unwrap()); |
220 | 106 | } |
221 | 40 | sets.push(set); |
222 | | } |
223 | | |
224 | 4 | sets |
225 | 4 | } |
226 | | |
227 | 4 | fn read_edges(&self, atn: &mut ATN, data: &mut Iter<i32>, sets: &Vec<IntervalSet>) { |
228 | 4 | let nedges = *data.next().unwrap(); |
229 | | |
230 | 1.52k | for _i in 0..nedges { |
231 | 1.52k | let src = *data.next().unwrap(); |
232 | 1.52k | let trg = *data.next().unwrap(); |
233 | 1.52k | let ttype = *data.next().unwrap(); |
234 | 1.52k | let arg1 = *data.next().unwrap(); |
235 | 1.52k | let arg2 = *data.next().unwrap(); |
236 | 1.52k | let arg3 = *data.next().unwrap(); |
237 | 1.52k | |
238 | 1.52k | let transition = self.edge_factory(atn, ttype, src, trg, arg1, arg2, arg3, sets); |
239 | 1.52k | |
240 | 1.52k | atn.states |
241 | 1.52k | .get_mut(src as usize) |
242 | 1.52k | .unwrap() |
243 | 1.52k | .add_transition(transition); |
244 | 1.52k | } |
245 | | |
246 | 4 | let mut new_tr = Vec::new(); |
247 | 1.39k | for i in &atn.states { |
248 | 1.52k | for tr in i.get_transitions() { |
249 | 1.52k | match tr.get_serialization_type() { |
250 | | TransitionType::TRANSITION_RULE => { |
251 | | // println!("TRANSITION_RULE"); |
252 | 178 | let tr = tr.as_ref().cast::<RuleTransition>(); |
253 | 178 | let target = atn.states.get(tr.get_target() as usize).unwrap(); |
254 | | |
255 | 178 | let outermost_prec_return = if let ATNStateType::RuleStartState { |
256 | | is_left_recursive: true, |
257 | | .. |
258 | 178 | } = atn |
259 | 178 | .states |
260 | 178 | .get(atn.rule_to_start_state[target.get_rule_index() as usize] as usize) |
261 | 178 | .unwrap() |
262 | 178 | .get_state_type() |
263 | | { |
264 | 18 | if tr.precedence == 0 { |
265 | 12 | target.get_rule_index() as i32 |
266 | | } else { |
267 | 6 | -1 |
268 | | } |
269 | | } else { |
270 | 160 | -1 |
271 | | }; |
272 | | |
273 | 178 | let return_tr = EpsilonTransition { |
274 | 178 | target: tr.follow_state, |
275 | 178 | outermost_precedence_return: outermost_prec_return, |
276 | 178 | }; |
277 | 178 | new_tr.push(( |
278 | 178 | atn.rule_to_stop_state[target.get_rule_index() as usize], |
279 | 178 | Box::new(return_tr), |
280 | 178 | )); |
281 | | } |
282 | 1.34k | _ => continue, |
283 | | } |
284 | | } |
285 | | } |
286 | 4 | new_tr |
287 | 4 | .drain(..) |
288 | 178 | .for_each(|(state, tr)| atn.states[state as usize].add_transition(tr)); |
289 | | |
290 | 1.38k | for i in 0..atn.states.len() { |
291 | 1.38k | let atn_state = atn.states.get(i).unwrap(); |
292 | 1.38k | match atn_state.get_state_type() { |
293 | | ATNStateType::DecisionState { |
294 | | state: |
295 | | ATNDecisionState::BlockStartState { |
296 | | end_state: _, |
297 | | en: _, |
298 | | }, |
299 | | .. |
300 | 130 | } => { |
301 | 130 | |
302 | 130 | // if *end_state == 0 { panic!("invalid state")} |
303 | 130 | // looks like it is never used during recognition |
304 | 130 | // todo missed part |
305 | 130 | } |
306 | | // ATNStateType::DecisionState {state:ATNDecisionState::PlusLoopBack,..} =>{ |
307 | | // for tr in atn_state.get_transitions(){ |
308 | | // if let ATNStateType::DecisionState { |
309 | | // state:ATNDecisionState::BlockStartState { |
310 | | // en:ATNBlockStart::PlusBlockStart(loopBack),..},..} |
311 | | // = atn.states.get_mut(tr.get_target()).unwrap().get_state_type_mut(){ |
312 | | // *loopBack = i; |
313 | | // |
314 | | // } |
315 | | // } |
316 | | // } |
317 | 1.25k | _x => { /*println!("{:?}",x);*/ } |
318 | | } |
319 | | } |
320 | 4 | } |
321 | | |
322 | 4 | fn read_decisions(&self, atn: &mut ATN, _data: &mut Iter<i32>) { |
323 | 4 | let ndecisions = *_data.next().unwrap(); |
324 | 148 | for i in 0..ndecisions { |
325 | 148 | let s = *_data.next().unwrap(); |
326 | 148 | let dec_state: &mut Box<dyn ATNState> = atn.states.get_mut(s as usize).unwrap(); |
327 | 148 | atn.decision_to_state.push(s); |
328 | 148 | if let ATNStateType::DecisionState { decision, .. } = dec_state.get_state_type_mut() { |
329 | 148 | *decision = i |
330 | 0 | } |
331 | | } |
332 | 4 | } |
333 | | |
334 | 2 | fn read_lexer_actions(&self, atn: &mut ATN, _data: &mut Iter<i32>) { |
335 | | //lexer actions are always supported here |
336 | 2 | let nactions = *_data.next().unwrap(); |
337 | | |
338 | 2 | for _i in 0..nactions { |
339 | 2 | let action_type = *_data.next().unwrap(); |
340 | 2 | |
341 | 2 | let data1 = *_data.next().unwrap(); |
342 | 2 | let data2 = *_data.next().unwrap(); |
343 | 2 | |
344 | 2 | let lexer_action = self.lexer_action_factory(action_type, data1, data2); |
345 | 2 | |
346 | 2 | atn.lexer_actions.push(lexer_action); |
347 | 2 | } |
348 | 2 | } |
349 | | |
350 | 4 | fn mark_precedence_decisions(&self, _atn: &mut ATN, _data: &mut Iter<i32>) { |
351 | 4 | let mut precedence_states = Vec::new(); |
352 | 1.38k | for state in _atn.states.iter() { |
353 | | if let ATNStateType::DecisionState { |
354 | | state: ATNDecisionState::StarLoopEntry { .. }, |
355 | | .. |
356 | 1.38k | } = state.get_state_type() |
357 | | { |
358 | | if let ATNStateType::RuleStartState { |
359 | | is_left_recursive: true, |
360 | | .. |
361 | 40 | } = _atn.states |
362 | 40 | [_atn.rule_to_start_state[state.get_rule_index() as usize] as usize] |
363 | 40 | .get_state_type() |
364 | | { |
365 | 6 | let maybe_loop_end = |
366 | 6 | state.get_transitions().iter().last().unwrap().get_target(); |
367 | 6 | let maybe_loop_end = _atn.states[maybe_loop_end as usize].as_ref(); |
368 | 6 | if let ATNStateType::LoopEndState(_) = maybe_loop_end.get_state_type() { |
369 | 6 | if maybe_loop_end.has_epsilon_only_transitions() { |
370 | 6 | if let ATNStateType::RuleStopState = _atn.states |
371 | 6 | [maybe_loop_end.get_transitions()[0].get_target() as usize] |
372 | 6 | .get_state_type() |
373 | | { |
374 | 6 | precedence_states.push(state.get_state_number()) |
375 | 0 | } |
376 | 0 | } |
377 | 0 | } |
378 | 34 | } |
379 | 1.34k | } |
380 | | } |
381 | 10 | for st in precedence_states { |
382 | | if let ATNStateType::DecisionState { |
383 | | state: |
384 | | ATNDecisionState::StarLoopEntry { |
385 | | loop_back_state: _, |
386 | 6 | is_precedence, |
387 | | }, |
388 | | .. |
389 | 6 | } = _atn.states[st as usize].get_state_type_mut() |
390 | | { |
391 | 6 | *is_precedence = true |
392 | 0 | } |
393 | | } |
394 | 4 | } |
395 | | |
396 | 4 | fn verify_atn(&self, _atn: &mut ATN, _data: &mut Iter<i32>) { |
397 | | //TODO |
398 | 4 | } |
399 | | |
400 | | // fn check_condition(&self, _condition: bool, _message: String) { unimplemented!() } |
401 | | |
402 | 1.52k | fn edge_factory( |
403 | 1.52k | &self, |
404 | 1.52k | _atn: &ATN, |
405 | 1.52k | type_index: i32, |
406 | 1.52k | _src: ATNStateRef, |
407 | 1.52k | target: ATNStateRef, |
408 | 1.52k | arg1: i32, |
409 | 1.52k | arg2: i32, |
410 | 1.52k | arg3: i32, |
411 | 1.52k | sets: &Vec<IntervalSet>, |
412 | 1.52k | ) -> Box<dyn Transition> { |
413 | | // // let target = atn.states.get |
414 | | // let mut base = BaseTransition { |
415 | | // target: trg, |
416 | | // // is_epsilon: false, |
417 | | // // label: 0, |
418 | | // interval_set: IntervalSet::new_interval_set(), |
419 | | // }; |
420 | | |
421 | 1.52k | match type_index { |
422 | 964 | TRANSITION_EPSILON => Box::new(EpsilonTransition { |
423 | 964 | target, |
424 | 964 | outermost_precedence_return: 0, |
425 | 964 | }), |
426 | 8 | TRANSITION_RANGE => Box::new(RangeTransition { |
427 | 8 | target, |
428 | 8 | start: if arg3 != 0 { |
429 | 0 | super::token::TOKEN_EOF |
430 | | } else { |
431 | 8 | arg1 |
432 | | }, |
433 | 8 | stop: arg2, |
434 | | }), |
435 | | TRANSITION_RULE => { |
436 | | // base.set_target(arg1 as usize); |
437 | 178 | Box::new(RuleTransition { |
438 | 178 | target: arg1, |
439 | 178 | follow_state: target, |
440 | 178 | rule_index: arg2, |
441 | 178 | precedence: arg3, |
442 | 178 | }) |
443 | | } |
444 | 0 | TRANSITION_PREDICATE => Box::new(PredicateTransition { |
445 | 0 | target, |
446 | 0 | is_ctx_dependent: arg3 != 0, |
447 | 0 | rule_index: arg1, |
448 | 0 | pred_index: arg2, |
449 | 0 | }), |
450 | 302 | TRANSITION_ATOM => Box::new(AtomTransition { |
451 | 302 | target, |
452 | 302 | label: if arg3 != 0 { EOF } else { arg1 }, |
453 | | }), |
454 | 10 | TRANSITION_ACTION => Box::new(ActionTransition { |
455 | 10 | target, |
456 | 10 | is_ctx_dependent: arg3 != 0, |
457 | 10 | rule_index: arg1, |
458 | 10 | action_index: arg2, |
459 | 10 | pred_index: 0, |
460 | 10 | }), |
461 | 30 | TRANSITION_SET => Box::new(SetTransition { |
462 | 30 | target, |
463 | 30 | set: sets[arg1 as usize].clone(), |
464 | 30 | }), |
465 | 14 | TRANSITION_NOTSET => Box::new(NotSetTransition { |
466 | 14 | target, |
467 | 14 | set: sets[arg1 as usize].clone(), |
468 | 14 | }), |
469 | 4 | TRANSITION_WILDCARD => Box::new(WildcardTransition { target }), |
470 | 12 | TRANSITION_PRECEDENCE => Box::new(PrecedencePredicateTransition { |
471 | 12 | target, |
472 | 12 | precedence: arg1, |
473 | 12 | }), |
474 | 0 | _ => panic!("invalid transition type"), |
475 | | } |
476 | 1.52k | } |
477 | | |
478 | 1.38k | fn state_factory( |
479 | 1.38k | &self, |
480 | 1.38k | type_index: i32, |
481 | 1.38k | rule_index: i32, |
482 | 1.38k | state_number: i32, |
483 | 1.38k | ) -> Box<dyn ATNState> { |
484 | 1.38k | let mut state = BaseATNState::new_base_atnstate(); |
485 | 1.38k | state.state_number = state_number; |
486 | 1.38k | state.rule_index = rule_index; |
487 | 1.38k | state.state_type_id = type_index; |
488 | 1.38k | state.state_type = match type_index { |
489 | 0 | ATNSTATE_INVALID_TYPE => ATNStateType::InvalidState, |
490 | 694 | ATNSTATE_BASIC => ATNStateType::BasicState, |
491 | 130 | ATNSTATE_RULE_START => ATNStateType::RuleStartState { |
492 | 130 | stop_state: 0, |
493 | 130 | is_left_recursive: false, |
494 | 130 | }, |
495 | 64 | ATNSTATE_BLOCK_START => ATNStateType::DecisionState { |
496 | 64 | decision: -1, |
497 | 64 | nongreedy: false, |
498 | 64 | state: ATNDecisionState::BlockStartState { |
499 | 64 | end_state: 0, |
500 | 64 | en: ATNBlockStart::BasicBlockStart, |
501 | 64 | }, |
502 | 64 | }, |
503 | 26 | ATNSTATE_PLUS_BLOCK_START => ATNStateType::DecisionState { |
504 | 26 | decision: -1, |
505 | 26 | nongreedy: false, |
506 | 26 | state: ATNDecisionState::BlockStartState { |
507 | 26 | end_state: 0, |
508 | 26 | en: ATNBlockStart::PlusBlockStart(0), |
509 | 26 | }, |
510 | 26 | }, |
511 | 40 | ATNSTATE_STAR_BLOCK_START => ATNStateType::DecisionState { |
512 | 40 | decision: -1, |
513 | 40 | nongreedy: false, |
514 | 40 | state: ATNDecisionState::BlockStartState { |
515 | 40 | end_state: 0, |
516 | 40 | en: ATNBlockStart::StarBlockStart, |
517 | 40 | }, |
518 | 40 | }, |
519 | 2 | ATNSTATE_TOKEN_START => ATNStateType::DecisionState { |
520 | 2 | decision: -1, |
521 | 2 | nongreedy: false, |
522 | 2 | state: ATNDecisionState::TokenStartState, |
523 | 2 | }, |
524 | 130 | ATNSTATE_RULE_STOP => ATNStateType::RuleStopState, |
525 | 130 | ATNSTATE_BLOCK_END => ATNStateType::BlockEndState(0), |
526 | 40 | ATNSTATE_STAR_LOOP_BACK => ATNStateType::StarLoopbackState, |
527 | 40 | ATNSTATE_STAR_LOOP_ENTRY => ATNStateType::DecisionState { |
528 | 40 | decision: -1, |
529 | 40 | nongreedy: false, |
530 | 40 | state: ATNDecisionState::StarLoopEntry { |
531 | 40 | loop_back_state: 0, |
532 | 40 | is_precedence: false, |
533 | 40 | }, |
534 | 40 | }, |
535 | 26 | ATNSTATE_PLUS_LOOP_BACK => ATNStateType::DecisionState { |
536 | 26 | decision: -1, |
537 | 26 | nongreedy: false, |
538 | 26 | state: ATNDecisionState::PlusLoopBack, |
539 | 26 | }, |
540 | 66 | ATNSTATE_LOOP_END => ATNStateType::LoopEndState(0), |
541 | | |
542 | 0 | _ => panic!("invalid ATN state type"), |
543 | | }; |
544 | | // println!("created state {} {:?}", state_number, state.state_type); |
545 | 1.38k | Box::new(state) |
546 | 1.38k | } |
547 | | |
548 | 2 | fn lexer_action_factory(&self, action_type: i32, data1: i32, data2: i32) -> LexerAction { |
549 | 2 | match action_type { |
550 | 2 | LEXER_ACTION_TYPE_CHANNEL => LexerChannelAction(data1), |
551 | 0 | LEXER_ACTION_TYPE_CUSTOM => LexerCustomAction { |
552 | 0 | rule_index: data1, |
553 | 0 | action_index: data2, |
554 | 0 | }, |
555 | 0 | LEXER_ACTION_TYPE_MODE => LexerModeAction(data1), |
556 | 0 | LEXER_ACTION_TYPE_MORE => LexerMoreAction, |
557 | 0 | LEXER_ACTION_TYPE_POP_MODE => LexerPopModeAction, |
558 | 0 | LEXER_ACTION_TYPE_PUSH_MODE => LexerPushModeAction(data1), |
559 | 0 | LEXER_ACTION_TYPE_SKIP => LexerSkipAction, |
560 | 0 | LEXER_ACTION_TYPE_TYPE => LexerTypeAction(data1), |
561 | 0 | _ => panic!("invalid action type {}", action_type), |
562 | | } |
563 | 2 | } |
564 | | } |