From 609eebff176777f7539ff6d3c9f4d9c229099d37 Mon Sep 17 00:00:00 2001 From: Taehwan Kim Date: Mon, 6 Oct 2025 12:12:07 +0900 Subject: [PATCH 1/8] let Term in builder::Grammar to TerminalSymbol --- rusty_lr_core/src/builder/grammar.rs | 63 +++++++++++++++------------- 1 file changed, 35 insertions(+), 28 deletions(-) diff --git a/rusty_lr_core/src/builder/grammar.rs b/rusty_lr_core/src/builder/grammar.rs index 405c962..a74d6ba 100644 --- a/rusty_lr_core/src/builder/grammar.rs +++ b/rusty_lr_core/src/builder/grammar.rs @@ -12,6 +12,7 @@ use super::States; use crate::hash::HashMap; use crate::rule::*; use crate::token::Token; +use crate::TerminalSymbol; /// struct that holding pre-calculated information for `expand()` function. #[derive(Debug, Clone)] @@ -51,7 +52,7 @@ pub struct Grammar { pub precedence_types: Vec>, } -impl Grammar { +impl Grammar, NonTerm> { pub fn new() -> Self { Grammar { rules: Vec::new(), @@ -68,8 +69,8 @@ impl Grammar { pub fn add_rule( &mut self, name: NonTerm, - rule: Vec>, - lookaheads: Option>, + rule: Vec, NonTerm>>, + lookaheads: Option>>, precedence: Option, priority: usize, ) -> usize @@ -92,7 +93,7 @@ impl Grammar { } /// false if precedence already exists and different - pub fn add_precedence(&mut self, term: Term, level: usize) -> bool + pub fn add_precedence(&mut self, term: TerminalSymbol, level: usize) -> bool where Term: Hash + Eq, { @@ -110,7 +111,10 @@ impl Grammar { } /// search for every production rules with name 'name' - fn search_rules(&self, name: NonTerm) -> Result<&[usize], BuildError> + fn search_rules( + &self, + name: NonTerm, + ) -> Result<&[usize], BuildError, NonTerm>> where NonTerm: Hash + Eq, { @@ -187,14 +191,14 @@ impl Grammar { } /// pre calculate the information for `expand()` function. - fn calculate_expand_cache(&mut self) -> Result<(), BuildError> + fn calculate_expand_cache(&mut self) -> Result<(), BuildError, NonTerm>> where Term: Ord + Copy, NonTerm: Hash + Eq + Copy, { - let mut pong: Vec> = Vec::new(); + let mut pong: Vec>> = Vec::new(); for (nonterm, nonterm_rules) in self.rules_map.iter() { - let mut rules: BTreeMap> = nonterm_rules + let mut rules: BTreeMap>> = nonterm_rules .iter() .map(|rule| { ( @@ -265,9 +269,9 @@ impl Grammar { /// 1st `bool` of returned tuple is true if follow_tokens can be empty. fn lookahead( &self, - follow_tokens: &[Token], - lookaheads: &BTreeSet, - ) -> Result<(BTreeSet, bool), BuildError> + follow_tokens: &[Token, NonTerm>], + lookaheads: &BTreeSet>, + ) -> Result<(BTreeSet>, bool), BuildError, NonTerm>> where Term: Ord + Copy, NonTerm: Copy + Hash + Eq, @@ -298,7 +302,10 @@ impl Grammar { /// for given set of production rules, /// if the first token of each rule is nonterminal, attach its production rules - fn expand(&self, rules: &mut LookaheadRuleRefSet) -> Result<(), BuildError> + fn expand( + &self, + rules: &mut LookaheadRuleRefSet>, + ) -> Result<(), BuildError, NonTerm>> where Term: Copy + Ord, NonTerm: Copy + Hash + Eq, @@ -390,8 +397,8 @@ impl Grammar { /// check for any shift/reduce or reduce/reduce conflicts and report them to `diags`. fn check_conflicts( &self, - states: &[State], - diags: &mut DiagnosticCollector, + states: &[State, NonTerm>], + diags: &mut DiagnosticCollector>, ) where Term: Ord + Copy + Hash, NonTerm: Copy + PartialEq + Ord, @@ -487,8 +494,8 @@ impl Grammar { fn build_full( &mut self, augmented_name: NonTerm, - diags: &mut DiagnosticCollector, - ) -> Result, BuildError> + diags: &mut DiagnosticCollector>, + ) -> Result, NonTerm>, BuildError, NonTerm>> where Term: Copy + Ord + Hash, NonTerm: Copy + Hash + Ord, @@ -532,8 +539,8 @@ impl Grammar { pub fn build( &mut self, augmented_name: NonTerm, - diags: &mut DiagnosticCollector, - ) -> Result, BuildError> + diags: &mut DiagnosticCollector>, + ) -> Result, NonTerm>, BuildError, NonTerm>> where Term: Copy + Ord + Hash, NonTerm: Copy + Hash + Ord, @@ -716,8 +723,8 @@ impl Grammar { pub fn build_lalr( &mut self, augmented_name: NonTerm, - diags: &mut DiagnosticCollector, - ) -> Result, BuildError> + diags: &mut DiagnosticCollector>, + ) -> Result, NonTerm>, BuildError, NonTerm>> where Term: Copy + Ord + Hash, NonTerm: Copy + Hash + Ord, @@ -927,11 +934,11 @@ impl Grammar { /// build new state with given production rules fn build_recursive( &self, - mut rules: LookaheadRuleRefSet, - states: &mut Vec>, - state_map: &mut BTreeMap, usize>, - diags: &mut DiagnosticCollector, - ) -> Result> + mut rules: LookaheadRuleRefSet>, + states: &mut Vec, NonTerm>>, + state_map: &mut BTreeMap>, usize>, + diags: &mut DiagnosticCollector>, + ) -> Result, NonTerm>> where Term: Hash + Ord + Copy, NonTerm: Hash + Ord + Copy, @@ -954,7 +961,7 @@ impl Grammar { // we don't care about the conflicts here let mut next_rules_term = BTreeMap::new(); let mut next_rules_nonterm = BTreeMap::new(); - let mut reduce_map: BTreeMap> = BTreeMap::new(); + let mut reduce_map: BTreeMap, BTreeSet> = BTreeMap::new(); for (mut rule_ref, lookaheads) in rules.rules.into_iter() { let rule = &self.rules[rule_ref.rule].rule; match rule.rule.get(rule_ref.shifted) { @@ -1118,7 +1125,7 @@ impl Grammar { // process rules that no more tokens left to shift // if next token is one of lookahead, add reduce action - // if there are multiple recude rules for same lookahead, it is a reduce/reduce conflict + // if there are multiple reduce rules for same lookahead, it is a reduce/reduce conflict // reduce_type conflict resolving for (lookahead, reduce_rules) in reduce_map.into_iter() { let state = &mut states[state_id]; @@ -1160,7 +1167,7 @@ impl Grammar { // } // } -impl Default for Grammar { +impl Default for Grammar, NonTerm> { fn default() -> Self { Self::new() } From 735299ddf110598381bb74b60d3a3f10caaf4fac Mon Sep 17 00:00:00 2001 From: Taehwan Kim Date: Mon, 6 Oct 2025 12:22:26 +0900 Subject: [PATCH 2/8] add can_accept_error field --- rusty_lr_core/src/builder/grammar.rs | 12 ++++++++++++ rusty_lr_core/src/builder/state.rs | 2 ++ 2 files changed, 14 insertions(+) diff --git a/rusty_lr_core/src/builder/grammar.rs b/rusty_lr_core/src/builder/grammar.rs index a74d6ba..67cdfb9 100644 --- a/rusty_lr_core/src/builder/grammar.rs +++ b/rusty_lr_core/src/builder/grammar.rs @@ -532,6 +532,16 @@ impl Grammar, NonTerm> { panic!("main state is not 0"); } + for state in &mut states { + if state + .shift_goto_map_term + .contains_key(&TerminalSymbol::Error) + || state.reduce_map.contains_key(&TerminalSymbol::Error) + { + state.can_accept_error = true; + } + } + Ok(States { states }) } @@ -669,6 +679,7 @@ impl Grammar, NonTerm> { .shift_goto_map_nonterm .append(&mut state_b.shift_goto_map_nonterm); state_a.reduce_map.append(&mut state_b.reduce_map); + state_a.can_accept_error |= state_b.can_accept_error; merged = true; } } @@ -764,6 +775,7 @@ impl Grammar, NonTerm> { .or_default() .append(&mut reduce_rules); } + states[state_a].can_accept_error |= state_b.can_accept_error; } } let mut new_states = Vec::with_capacity(states.len() - merge_into.len()); diff --git a/rusty_lr_core/src/builder/state.rs b/rusty_lr_core/src/builder/state.rs index 108a63e..050bc29 100644 --- a/rusty_lr_core/src/builder/state.rs +++ b/rusty_lr_core/src/builder/state.rs @@ -8,6 +8,7 @@ pub struct State { pub shift_goto_map_nonterm: BTreeMap, pub reduce_map: BTreeMap>, pub ruleset: BTreeSet, + pub can_accept_error: bool, } impl State { pub fn new() -> Self { @@ -16,6 +17,7 @@ impl State { shift_goto_map_nonterm: Default::default(), reduce_map: Default::default(), ruleset: Default::default(), + can_accept_error: false, } } From 23656c734b067f736292df60028fcfa72e39de4c Mon Sep 17 00:00:00 2001 From: Taehwan Kim Date: Mon, 6 Oct 2025 13:24:11 +0900 Subject: [PATCH 3/8] add can_accept_error --- rusty_lr_core/src/builder/state.rs | 1 + rusty_lr_core/src/parser/state.rs | 17 +- rusty_lr_parser/src/emit.rs | 5 +- rusty_lr_parser/src/parser/parser_expanded.rs | 437 +++++----- scripts/diff/calculator.rs | 113 +-- scripts/diff/calculator_u8.rs | 186 ++-- scripts/diff/json.rs | 816 ++++++++++-------- 7 files changed, 836 insertions(+), 739 deletions(-) diff --git a/rusty_lr_core/src/builder/state.rs b/rusty_lr_core/src/builder/state.rs index 050bc29..57b34b8 100644 --- a/rusty_lr_core/src/builder/state.rs +++ b/rusty_lr_core/src/builder/state.rs @@ -81,6 +81,7 @@ where .map(|(term, rules)| (term, rules.into_iter().collect())) .collect(), ruleset: state.ruleset.into_iter().collect(), + can_accept_error: state.can_accept_error, } } } diff --git a/rusty_lr_core/src/parser/state.rs b/rusty_lr_core/src/parser/state.rs index b86ed76..27b9b71 100644 --- a/rusty_lr_core/src/parser/state.rs +++ b/rusty_lr_core/src/parser/state.rs @@ -23,6 +23,7 @@ pub struct IntermediateState { pub shift_goto_map_nonterm: Vec<(NonTerm, ShiftTarget)>, // must be sorted pub reduce_map: Vec<(TermClass, Vec)>, // must be sorted pub ruleset: Vec, + pub can_accept_error: bool, } /// For state, terminal and class indices, we use the most compact integer type that can hold the maximum value. @@ -133,6 +134,8 @@ pub trait State { /// Get the set of rules that this state is trying to parse fn get_rules(&self) -> &[crate::rule::ShiftedRuleRef]; + + fn can_accept_error(&self) -> bool; } /// `State` implementation for a sparse state representation using HashMap @@ -149,6 +152,8 @@ pub struct SparseState { /// set of rules that this state is trying to parse pub(crate) ruleset: Vec, + + pub(crate) can_accept_error: bool, } impl< @@ -189,6 +194,9 @@ impl< fn get_rules(&self) -> &[crate::rule::ShiftedRuleRef] { &self.ruleset } + fn can_accept_error(&self) -> bool { + self.can_accept_error + } } /// `State` implementation for a dense state representation using Vec @@ -215,7 +223,7 @@ pub struct DenseState { /// set of rules that this state is trying to parse pub(crate) ruleset: Vec, - _phantom: std::marker::PhantomData, + pub(crate) can_accept_error: bool, } impl< TermClass: TerminalClass, @@ -267,6 +275,10 @@ impl< fn get_rules(&self) -> &[crate::rule::ShiftedRuleRef] { &self.ruleset } + + fn can_accept_error(&self) -> bool { + self.can_accept_error + } } impl @@ -313,6 +325,7 @@ where }) .collect(), ruleset: builder_state.ruleset.into_iter().collect(), + can_accept_error: builder_state.can_accept_error, } } } @@ -421,7 +434,7 @@ where reduce_map, reduce_offset: reduce_min, ruleset: builder_state.ruleset.into_iter().collect(), - _phantom: std::marker::PhantomData, + can_accept_error: builder_state.can_accept_error, } } } diff --git a/rusty_lr_parser/src/emit.rs b/rusty_lr_parser/src/emit.rs index 52ff0a7..3a972cc 100644 --- a/rusty_lr_parser/src/emit.rs +++ b/rusty_lr_parser/src/emit.rs @@ -781,6 +781,8 @@ impl Grammar { } }; + let can_accept_error = state.can_accept_error; + states_body_stream.extend(quote! { #module_prefix::parser::state::IntermediateState { shift_goto_map_term: vec![#shift_term_body_stream], @@ -801,7 +803,8 @@ impl Grammar { } } ).collect() - } + }, + can_accept_error: #can_accept_error, }, }); } diff --git a/rusty_lr_parser/src/parser/parser_expanded.rs b/rusty_lr_parser/src/parser/parser_expanded.rs index e9f1072..b8b37c0 100644 --- a/rusty_lr_parser/src/parser/parser_expanded.rs +++ b/rusty_lr_parser/src/parser/parser_expanded.rs @@ -7540,7 +7540,7 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::parengroup, ::rusty_lr_core::parser::state::ShiftTarget::new(2, true)),], @@ -7553,7 +7553,7 @@ impl GrammarParser { 2,]; static __SHIFTED : [u8; 3usize] = [1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7562,7 +7562,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [1,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::colon, ::rusty_lr_core::parser::state::ShiftTarget::new(4, true)),], @@ -7570,7 +7570,7 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [0,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(5, true)), @@ -7607,7 +7607,7 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::equal, ::rusty_lr_core::parser::state::ShiftTarget::new(6, true)),], @@ -7618,7 +7618,7 @@ impl GrammarParser { { static __RULES : [u8; 2usize] = [12, 21,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), @@ -7641,7 +7641,7 @@ impl GrammarParser { __SHIFTED : [u8; 19usize] = [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7650,7 +7650,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [21,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7659,7 +7659,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [20,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(10, true)),], @@ -7667,17 +7667,17 @@ impl GrammarParser { static __RULES : [u8; 5usize] = [32, 33, 34, 35, 36,]; static __SHIFTED : [u8; 5usize] = [1, 1, 1, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(GrammarTerminalClasses::lparen, + as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : + false, }, ::rusty_lr_core::parser::state::IntermediateState { + shift_goto_map_term : vec![(GrammarTerminalClasses::lparen, ::rusty_lr_core::parser::state::ShiftTarget::new(11, true)),], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 5usize] = [32, 33, 34, 35, 36,]; static __SHIFTED : [u8; 5usize] = [2, 2, 2, 2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(GrammarTerminalClasses::ident, + as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : + false, }, ::rusty_lr_core::parser::state::IntermediateState { + shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), (GrammarTerminalClasses::dot, ::rusty_lr_core::parser::state::ShiftTarget::new(8, true)), @@ -7698,18 +7698,18 @@ impl GrammarParser { 36,]; static __SHIFTED : [u8; 23usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map - = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = - [30]; __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, - __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : - { static __RULES : [u8; 1usize] = [30,]; static __SHIFTED : [u8; 1usize] = - [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(GrammarTerminalClasses::ident, + as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : + false, }, ::rusty_lr_core::parser::state::IntermediateState { + shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); { static + __REDUCE_RULES : [u8; 1usize] = [30]; __reduce_map.extend(__RUSTYLR_TSET3 + .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map + .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [30,]; + static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : + rule as usize, shifted : shifted as usize, } }).collect() }, can_accept_error + : true, }, ::rusty_lr_core::parser::state::IntermediateState { + shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), (GrammarTerminalClasses::dot, ::rusty_lr_core::parser::state::ShiftTarget::new(8, true)), @@ -7742,7 +7742,7 @@ impl GrammarParser { 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::caret, ::rusty_lr_core::parser::state::ShiftTarget::new(15, true)),], @@ -7755,7 +7755,7 @@ impl GrammarParser { 86, 87,]; static __SHIFTED : [u8; 3usize] = [1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7764,7 +7764,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [86,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(17, true)), @@ -7783,9 +7783,9 @@ impl GrammarParser { 14, 15, 16, 17, 18, 19, 88, 89, 90, 91,]; static __SHIFTED : [u8; 11usize] = [0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()) .map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : - rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(GrammarTerminalClasses::minus, + rule as usize, shifted : shifted as usize, } }).collect() }, can_accept_error + : false, }, ::rusty_lr_core::parser::state::IntermediateState { + shift_goto_map_term : vec![(GrammarTerminalClasses::minus, ::rusty_lr_core::parser::state::ShiftTarget::new(18, true)),], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7794,7 +7794,7 @@ impl GrammarParser { { static __RULES : [u8; 3usize] = [13, 14, 15,]; static __SHIFTED : [u8; 3usize] = [1, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(19, true)), @@ -7804,7 +7804,7 @@ impl GrammarParser { static __RULES : [u8; 2usize] = [14, 15,]; static __SHIFTED : [u8; 2usize] = [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7813,7 +7813,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [14,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7822,7 +7822,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [15,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::minus, ::rusty_lr_core::parser::state::ShiftTarget::new(22, true)),], @@ -7833,7 +7833,7 @@ impl GrammarParser { { static __RULES : [u8; 3usize] = [16, 17, 18,]; static __SHIFTED : [u8; 3usize] = [1, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::literal, ::rusty_lr_core::parser::state::ShiftTarget::new(23, true)), @@ -7843,7 +7843,7 @@ impl GrammarParser { static __RULES : [u8; 2usize] = [17, 18,]; static __SHIFTED : [u8; 2usize] = [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7852,7 +7852,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [17,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7861,7 +7861,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [18,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7870,7 +7870,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [88,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(17, true)), @@ -7885,7 +7885,7 @@ impl GrammarParser { 14, 15, 16, 17, 18, 89, 90,]; static __SHIFTED : [u8; 8usize] = [0, 0, 0, 0, 0, 0, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7894,7 +7894,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [89,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::rbracket, ::rusty_lr_core::parser::state::ShiftTarget::new(29, true)),], @@ -7902,7 +7902,7 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [19,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7911,7 +7911,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [19,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7920,7 +7920,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [26,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::plus, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), @@ -7941,7 +7941,7 @@ impl GrammarParser { 36,]; static __SHIFTED : [u8; 11usize] = [1, 1, 1, 1, 1, 1, 4, 4, 4, 4, 4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7950,7 +7950,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [22,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7959,7 +7959,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [23,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7968,7 +7968,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [24,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), @@ -7991,7 +7991,7 @@ impl GrammarParser { __SHIFTED : [u8; 19usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::plus, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), @@ -8010,18 +8010,18 @@ impl GrammarParser { { static __RULES : [u8; 6usize] = [22, 23, 24, 25, 27, 31,]; static __SHIFTED : [u8; 6usize] = [1, 1, 1, 1, 1, 3,]; __RULES.iter().zip(__SHIFTED.iter()) .map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : - rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map - = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = - [25]; __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, - __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : - { static __RULES : [u8; 1usize] = [25,]; static __SHIFTED : [u8; 1usize] = - [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(GrammarTerminalClasses::ident, + rule as usize, shifted : shifted as usize, } }).collect() }, can_accept_error + : true, }, ::rusty_lr_core::parser::state::IntermediateState { + shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); { static + __REDUCE_RULES : [u8; 1usize] = [25]; __reduce_map.extend(__RUSTYLR_TSET3 + .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map + .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [25,]; + static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : + rule as usize, shifted : shifted as usize, } }).collect() }, can_accept_error + : true, }, ::rusty_lr_core::parser::state::IntermediateState { + shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), (GrammarTerminalClasses::dot, ::rusty_lr_core::parser::state::ShiftTarget::new(8, true)), @@ -8042,7 +8042,7 @@ impl GrammarParser { __SHIFTED : [u8; 19usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::plus, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), @@ -8059,9 +8059,9 @@ impl GrammarParser { { static __RULES : [u8; 5usize] = [22, 23, 24, 25, 27,]; static __SHIFTED : [u8; 5usize] = [1, 1, 1, 1, 3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(GrammarTerminalClasses::ident, + as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : + true, }, ::rusty_lr_core::parser::state::IntermediateState { + shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), (GrammarTerminalClasses::dot, ::rusty_lr_core::parser::state::ShiftTarget::new(8, true)), @@ -8082,15 +8082,15 @@ impl GrammarParser { 36,]; static __SHIFTED : [u8; 23usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 5, 0, 5, 0, 5, 0, 5,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(GrammarTerminalClasses::rparen, + as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : + false, }, ::rusty_lr_core::parser::state::IntermediateState { + shift_goto_map_term : vec![(GrammarTerminalClasses::rparen, ::rusty_lr_core::parser::state::ShiftTarget::new(42, true)),], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 1usize] = [29,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8099,7 +8099,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [29,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::plus, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), @@ -8121,7 +8121,7 @@ impl GrammarParser { __SHIFTED : [u8; 7usize] = [1, 1, 1, 1, 1, 1, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), @@ -8147,7 +8147,7 @@ impl GrammarParser { static __SHIFTED : [u8; 20usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::plus, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), @@ -8169,7 +8169,7 @@ impl GrammarParser { __SHIFTED : [u8; 7usize] = [1, 1, 1, 1, 1, 1, 2,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8178,7 +8178,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [96,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::pipe, ::rusty_lr_core::parser::state::ShiftTarget::new(48, true)), @@ -8188,7 +8188,7 @@ impl GrammarParser { static __RULES : [u8; 2usize] = [28, 97,]; static __SHIFTED : [u8; 2usize] = [2, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), @@ -8218,7 +8218,8 @@ impl GrammarParser { 94, 95, 97,]; static __SHIFTED : [u8; 23usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef - { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, + { rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8227,7 +8228,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [97,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8236,7 +8237,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [28,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::plus, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), @@ -8264,7 +8265,7 @@ impl GrammarParser { 13usize] = [1, 1, 1, 1, 1, 1, 6, 6, 6, 6, 6, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::plus, ::rusty_lr_core::parser::state::ShiftTarget::new(53, true)), @@ -8279,7 +8280,7 @@ impl GrammarParser { { static __RULES : [u8; 4usize] = [33, 34, 36, 98,]; static __SHIFTED : [u8; 4usize] = [7, 7, 7, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + shifted : shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::rparen, ::rusty_lr_core::parser::state::ShiftTarget::new(54, true)),], @@ -8287,7 +8288,7 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [33,]; static __SHIFTED : [u8; 1usize] = [8,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8296,7 +8297,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [33,]; static __SHIFTED : [u8; 1usize] = [9,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::rparen, ::rusty_lr_core::parser::state::ShiftTarget::new(56, true)),], @@ -8304,7 +8305,7 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [34,]; static __SHIFTED : [u8; 1usize] = [8,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8313,7 +8314,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [34,]; static __SHIFTED : [u8; 1usize] = [9,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::rparen, ::rusty_lr_core::parser::state::ShiftTarget::new(58, true)),], @@ -8321,7 +8322,7 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [36,]; static __SHIFTED : [u8; 1usize] = [8,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8330,7 +8331,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [36,]; static __SHIFTED : [u8; 1usize] = [9,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::rparen, ::rusty_lr_core::parser::state::ShiftTarget::new(60, true)),], @@ -8338,7 +8339,7 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [35,]; static __SHIFTED : [u8; 1usize] = [7,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8347,7 +8348,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [35,]; static __SHIFTED : [u8; 1usize] = [8,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::rparen, ::rusty_lr_core::parser::state::ShiftTarget::new(62, true)),], @@ -8355,7 +8356,7 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [32,]; static __SHIFTED : [u8; 1usize] = [7,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8364,7 +8365,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [32,]; static __SHIFTED : [u8; 1usize] = [8,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::plus, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), @@ -8386,7 +8387,7 @@ impl GrammarParser { __SHIFTED : [u8; 7usize] = [3, 1, 1, 1, 1, 1, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(65, false)), @@ -8396,7 +8397,7 @@ impl GrammarParser { static __RULES : [u8; 2usize] = [0, 3,]; static __SHIFTED : [u8; 2usize] = [4, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8405,7 +8406,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [0,]; static __SHIFTED : [u8; 1usize] = [5,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(5, true)), @@ -8440,7 +8441,7 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8449,7 +8450,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [3,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8458,7 +8459,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [78,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::plus, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), @@ -8480,7 +8481,7 @@ impl GrammarParser { __SHIFTED : [u8; 7usize] = [1, 1, 1, 1, 1, 1, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(5, true)), @@ -8508,18 +8509,18 @@ impl GrammarParser { 79, 80,]; static __SHIFTED : [u8; 22usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()) .map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : - rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map - = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = - [79]; __reduce_map.extend(__RUSTYLR_TSET11.iter().map(| term | (* term, - __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : - { static __RULES : [u8; 1usize] = [79,]; static __SHIFTED : [u8; 1usize] = - [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(GrammarTerminalClasses::percent, + rule as usize, shifted : shifted as usize, } }).collect() }, can_accept_error + : false, }, ::rusty_lr_core::parser::state::IntermediateState { + shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); { static + __REDUCE_RULES : [u8; 1usize] = [79]; __reduce_map.extend(__RUSTYLR_TSET11 + .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map + .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [79,]; + static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : + rule as usize, shifted : shifted as usize, } }).collect() }, can_accept_error + : false, }, ::rusty_lr_core::parser::state::IntermediateState { + shift_goto_map_term : vec![(GrammarTerminalClasses::percent, ::rusty_lr_core::parser::state::ShiftTarget::new(73, true)),], shift_goto_map_nonterm : vec![(GrammarNonTerminals::PrecDef, ::rusty_lr_core::parser::state::ShiftTarget::new(83, true)), @@ -8534,7 +8535,7 @@ impl GrammarParser { 7, 8, 9, 10, 82, 83, 84, 85,]; static __SHIFTED : [u8; 10usize] = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::prec, ::rusty_lr_core::parser::state::ShiftTarget::new(74, true)), @@ -8546,8 +8547,8 @@ impl GrammarParser { static __RULES : [u8; 5usize] = [6, 7, 8, 9, 10,]; static __SHIFTED : [u8; 5usize] = [1, 1, 1, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + usize, shifted : shifted as usize, } }).collect() }, can_accept_error : true, + }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)), (GrammarTerminalClasses::literal, @@ -8560,7 +8561,7 @@ impl GrammarParser { 40,]; static __SHIFTED : [u8; 4usize] = [2, 2, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8569,7 +8570,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [39,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8578,7 +8579,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [40,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8587,7 +8588,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [7,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8596,7 +8597,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [6,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::literal, ::rusty_lr_core::parser::state::ShiftTarget::new(80, true)), @@ -8606,7 +8607,7 @@ impl GrammarParser { static __RULES : [u8; 2usize] = [8, 9,]; static __SHIFTED : [u8; 2usize] = [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8615,7 +8616,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [8,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8624,7 +8625,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [9,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8633,7 +8634,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [10,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8642,7 +8643,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [82,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::percent, ::rusty_lr_core::parser::state::ShiftTarget::new(73, true)),], @@ -8655,7 +8656,7 @@ impl GrammarParser { 8, 9, 10, 83, 84,]; static __SHIFTED : [u8; 7usize] = [0, 0, 0, 0, 0, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8664,7 +8665,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [83,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::bracegroup, ::rusty_lr_core::parser::state::ShiftTarget::new(87, true)),], @@ -8677,7 +8678,7 @@ impl GrammarParser { 38,]; static __SHIFTED : [u8; 3usize] = [2, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8686,7 +8687,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [37,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8695,7 +8696,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [5,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8704,7 +8705,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [4,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::left, ::rusty_lr_core::parser::state::ShiftTarget::new(91, true)), @@ -8747,7 +8748,7 @@ impl GrammarParser { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)), @@ -8763,7 +8764,7 @@ impl GrammarParser { 51, 143, 144,]; static __SHIFTED : [u8; 6usize] = [0, 0, 2, 2, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(93, false)),], @@ -8771,7 +8772,7 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [51,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8780,7 +8781,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [51,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8789,7 +8790,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [143,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)), @@ -8803,7 +8804,7 @@ impl GrammarParser { 144,]; static __SHIFTED : [u8; 4usize] = [0, 0, 3, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8812,7 +8813,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [50,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8821,7 +8822,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [144,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)), @@ -8837,7 +8838,7 @@ impl GrammarParser { 53, 143, 144,]; static __SHIFTED : [u8; 6usize] = [0, 0, 2, 2, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(100, false)),], @@ -8845,7 +8846,7 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [53,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8854,7 +8855,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [53,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)), @@ -8868,7 +8869,7 @@ impl GrammarParser { 144,]; static __SHIFTED : [u8; 4usize] = [0, 0, 3, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8877,7 +8878,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [52,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(104, true)), @@ -8887,7 +8888,7 @@ impl GrammarParser { static __RULES : [u8; 3usize] = [41, 42, 43,]; static __SHIFTED : [u8; 3usize] = [2, 2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + shifted : shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), @@ -8985,7 +8986,7 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8994,7 +8995,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [42,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9003,7 +9004,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [141,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)), @@ -9099,7 +9100,7 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9108,7 +9109,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [41,]; static __SHIFTED : [u8; 1usize] = [5,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9117,7 +9118,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [142,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(111, false)),], @@ -9125,7 +9126,7 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [43,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9134,7 +9135,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [43,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(113, true)), @@ -9144,7 +9145,7 @@ impl GrammarParser { static __RULES : [u8; 2usize] = [44, 45,]; static __SHIFTED : [u8; 2usize] = [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(114, false)),], @@ -9152,7 +9153,7 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [44,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9161,7 +9162,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [44,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(116, false)),], @@ -9169,7 +9170,7 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9178,7 +9179,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), @@ -9276,7 +9277,7 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9285,7 +9286,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [47,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)), @@ -9381,7 +9382,7 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9390,7 +9391,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), @@ -9488,7 +9489,7 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9497,7 +9498,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [49,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)), @@ -9593,7 +9594,7 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9602,7 +9603,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [48,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), @@ -9700,7 +9701,7 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9709,7 +9710,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [57,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)), @@ -9805,7 +9806,7 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9814,7 +9815,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [56,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), @@ -9912,7 +9913,7 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9921,7 +9922,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [59,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)), @@ -10017,7 +10018,7 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10026,7 +10027,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [58,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(134, false)), @@ -10036,7 +10037,7 @@ impl GrammarParser { static __RULES : [u8; 2usize] = [62, 63,]; static __SHIFTED : [u8; 2usize] = [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10045,7 +10046,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [62,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(136, false)),], @@ -10053,7 +10054,7 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [63,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10062,7 +10063,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [63,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(138, false)), @@ -10072,7 +10073,7 @@ impl GrammarParser { static __RULES : [u8; 2usize] = [60, 61,]; static __SHIFTED : [u8; 2usize] = [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10081,7 +10082,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [60,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(140, false)),], @@ -10089,7 +10090,7 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [61,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10098,7 +10099,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [61,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)), @@ -10114,7 +10115,7 @@ impl GrammarParser { 55, 143, 144,]; static __SHIFTED : [u8; 6usize] = [0, 0, 2, 2, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(143, false)),], @@ -10122,7 +10123,7 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [55,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10131,7 +10132,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [55,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)), @@ -10145,7 +10146,7 @@ impl GrammarParser { 144,]; static __SHIFTED : [u8; 4usize] = [0, 0, 3, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10154,7 +10155,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [54,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(147, false)), @@ -10164,7 +10165,7 @@ impl GrammarParser { static __RULES : [u8; 2usize] = [64, 65,]; static __SHIFTED : [u8; 2usize] = [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10173,7 +10174,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [64,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(149, false)),], @@ -10181,7 +10182,7 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [65,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10190,7 +10191,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [65,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(151, false)), @@ -10200,7 +10201,7 @@ impl GrammarParser { static __RULES : [u8; 2usize] = [66, 67,]; static __SHIFTED : [u8; 2usize] = [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10209,7 +10210,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [66,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(153, false)),], @@ -10217,7 +10218,7 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [67,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10226,7 +10227,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [67,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(155, true)), @@ -10243,7 +10244,7 @@ impl GrammarParser { 69, 145, 146, 147, 148,]; static __SHIFTED : [u8; 6usize] = [2, 2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : true, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10252,7 +10253,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [145,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(157, false)),], @@ -10260,7 +10261,7 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [69,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10269,7 +10270,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [69,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(159, true)),], @@ -10280,7 +10281,7 @@ impl GrammarParser { { static __RULES : [u8; 2usize] = [146, 147,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10289,7 +10290,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [146,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(161, false)),], @@ -10297,7 +10298,7 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [68,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10306,7 +10307,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [68,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), @@ -10404,7 +10405,7 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10413,7 +10414,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [71,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)), @@ -10509,7 +10510,7 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10518,7 +10519,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [70,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), @@ -10616,7 +10617,7 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10625,7 +10626,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [73,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)), @@ -10721,7 +10722,7 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10730,7 +10731,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [72,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(171, false)),], @@ -10738,7 +10739,7 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [74,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10747,7 +10748,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [74,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10756,7 +10757,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [75,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(1, true)), @@ -10780,7 +10781,7 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10789,7 +10790,7 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [150,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::eof, ::rusty_lr_core::parser::state::ShiftTarget::new(176, true)),], @@ -10797,13 +10798,13 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [151,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 1usize] = [151,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, ]; let states: Vec = states .into_iter() diff --git a/scripts/diff/calculator.rs b/scripts/diff/calculator.rs index 8a40b1d..69a1289 100644 --- a/scripts/diff/calculator.rs +++ b/scripts/diff/calculator.rs @@ -721,15 +721,16 @@ impl EParser { 4, 5, 6, 7,]; static __SHIFTED : [u8; 8usize] = [0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [4]; __reduce_map.extend(__RUSTYLR_TSET0 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [4,]; - static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [4]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [4,]; static __SHIFTED : [u8; 1usize] = + [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::num, ::rusty_lr::parser::state::ShiftTarget::new(1, true)), (ETerminalClasses::lparen, @@ -743,21 +744,22 @@ impl EParser { 4, 5, 5, 6,]; static __SHIFTED : [u8; 8usize] = [0, 0, 0, 0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(ETerminalClasses::plus, - ::rusty_lr::parser::state::ShiftTarget::new(4, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = - [6]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term, - __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : - { static __RULES : [u8; 2usize] = [0, 6,]; static __SHIFTED : [u8; 2usize] = - [1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { - ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(ETerminalClasses::num, - ::rusty_lr::parser::state::ShiftTarget::new(1, true)), - (ETerminalClasses::lparen, ::rusty_lr::parser::state::ShiftTarget::new(2, - false)),], shift_goto_map_nonterm : vec![(ENonTerminals::A, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(ETerminalClasses::plus, ::rusty_lr::parser::state::ShiftTarget::new(4, + true)),], shift_goto_map_nonterm : vec![], reduce_map : { let mut + __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : + [u8; 1usize] = [6]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | + (* term, __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, + ruleset : { static __RULES : [u8; 2usize] = [0, 6,]; static __SHIFTED : [u8; + 2usize] = [1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & + shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted + : shifted as usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(ETerminalClasses::num, ::rusty_lr::parser::state::ShiftTarget::new(1, + true)), (ETerminalClasses::lparen, + ::rusty_lr::parser::state::ShiftTarget::new(2, false)),], + shift_goto_map_nonterm : vec![(ENonTerminals::A, ::rusty_lr::parser::state::ShiftTarget::new(5, true)), (ENonTerminals::M, ::rusty_lr::parser::state::ShiftTarget::new(6, true)), (ENonTerminals::P, ::rusty_lr::parser::state::ShiftTarget::new(6, true)),], reduce_map : @@ -765,15 +767,16 @@ impl EParser { 3, 4, 5,]; static __SHIFTED : [u8; 7usize] = [0, 2, 0, 0, 0, 0, 0,]; __RULES .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [0]; __reduce_map.extend(__RUSTYLR_TSET2 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [0,]; - static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [0]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [0,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::star, ::rusty_lr::parser::state::ShiftTarget::new(7, false)),], shift_goto_map_nonterm : vec![], reduce_map : { let mut @@ -783,7 +786,7 @@ impl EParser { ruleset : { static __RULES : [u8; 2usize] = [1, 2,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + : shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::num, ::rusty_lr::parser::state::ShiftTarget::new(1, true)), (ETerminalClasses::lparen, @@ -795,15 +798,16 @@ impl EParser { 5,]; static __SHIFTED : [u8; 5usize] = [0, 2, 0, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [2]; __reduce_map.extend(__RUSTYLR_TSET0 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [2,]; - static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [2]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [2,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::rparen, ::rusty_lr::parser::state::ShiftTarget::new(10, false)),], @@ -811,28 +815,29 @@ impl EParser { static __RULES : [u8; 1usize] = [5,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [5]; __reduce_map.extend(__RUSTYLR_TSET0 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [5,]; - static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [5]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [5,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::eof, ::rusty_lr::parser::state::ShiftTarget::new(12, true)),], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 1usize] = [7,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + : shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 1usize] = [7,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, ]; let states: Vec = states.into_iter().map(|state| state.into()).collect(); Self { rules, states } diff --git a/scripts/diff/calculator_u8.rs b/scripts/diff/calculator_u8.rs index ac03033..7cfe402 100644 --- a/scripts/diff/calculator_u8.rs +++ b/scripts/diff/calculator_u8.rs @@ -1028,15 +1028,16 @@ impl EParser { 12, 13, 16,]; static __SHIFTED : [u8; 11usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [3]; __reduce_map.extend(__RUSTYLR_TSET1 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [3,]; - static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [3]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [3,]; static __SHIFTED : [u8; 1usize] = + [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass7, ::rusty_lr::parser::state::ShiftTarget::new(4, true)), @@ -1049,12 +1050,13 @@ impl EParser { 16,]; static __SHIFTED : [u8; 4usize] = [1, 0, 0, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : - Default::default(), ruleset : { static __RULES : [u8; 1usize] = [16,]; static - __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| - (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [16,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(6, false)),], @@ -1073,8 +1075,9 @@ impl EParser { 12, 13,]; static __SHIFTED : [u8; 11usize] = [0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(ETerminalClasses::TermClass7, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(ETerminalClasses::TermClass7, ::rusty_lr::parser::state::ShiftTarget::new(4, true)), (ETerminalClasses::TermClass8, ::rusty_lr::parser::state::ShiftTarget::new(4, true)),], shift_goto_map_nonterm : vec![(ENonTerminals::Op, @@ -1085,7 +1088,7 @@ impl EParser { ruleset : { static __RULES : [u8; 4usize] = [5, 5, 8, 9,]; static __SHIFTED : [u8; 4usize] = [1, 3, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(7, false)),], @@ -1096,15 +1099,16 @@ impl EParser { { static __RULES : [u8; 2usize] = [11, 12,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [11]; __reduce_map.extend(__RUSTYLR_TSET4 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [11,]; - static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [11]; __reduce_map.extend(__RUSTYLR_TSET4.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [11,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass2, ::rusty_lr::parser::state::ShiftTarget::new(9, false)), @@ -1121,7 +1125,7 @@ impl EParser { 7usize] = [0, 1, 2, 4, 6, 14, 15,]; static __SHIFTED : [u8; 7usize] = [0, 0, 1, 1, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + : shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(6, false)),], @@ -1140,8 +1144,9 @@ impl EParser { 12, 13,]; static __SHIFTED : [u8; 11usize] = [0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(ETerminalClasses::TermClass3, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(ETerminalClasses::TermClass3, ::rusty_lr::parser::state::ShiftTarget::new(11, false)), (ETerminalClasses::TermClass7, ::rusty_lr::parser::state::ShiftTarget::new(13, true)), @@ -1153,8 +1158,9 @@ impl EParser { 9,]; static __SHIFTED : [u8; 4usize] = [3, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(ETerminalClasses::TermClass0, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(ETerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(6, false)),], shift_goto_map_nonterm : vec![(ENonTerminals::__Terminal32Plus6, ::rusty_lr::parser::state::ShiftTarget::new(6, true)), @@ -1166,17 +1172,18 @@ impl EParser { }, ruleset : { static __RULES : [u8; 5usize] = [4, 10, 11, 12, 13,]; static __SHIFTED : [u8; 5usize] = [4, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = - [4]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term, - __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : - { static __RULES : [u8; 1usize] = [4,]; static __SHIFTED : [u8; 1usize] = - [5,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { - ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(ETerminalClasses::TermClass0, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); { static + __REDUCE_RULES : [u8; 1usize] = [4]; __reduce_map.extend(__RUSTYLR_TSET1 + .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map + .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [4,]; + static __SHIFTED : [u8; 1usize] = [5,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : + false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term + : vec![(ETerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(6, false)),], shift_goto_map_nonterm : vec![(ENonTerminals::Number, ::rusty_lr::parser::state::ShiftTarget::new(1, true)), (ENonTerminals::P, @@ -1193,8 +1200,9 @@ impl EParser { 12, 13,]; static __SHIFTED : [u8; 11usize] = [0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(ETerminalClasses::TermClass7, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(ETerminalClasses::TermClass7, ::rusty_lr::parser::state::ShiftTarget::new(13, true)), (ETerminalClasses::TermClass8, ::rusty_lr::parser::state::ShiftTarget::new(13, true)),], @@ -1206,7 +1214,7 @@ impl EParser { ruleset : { static __RULES : [u8; 4usize] = [5, 5, 8, 9,]; static __SHIFTED : [u8; 4usize] = [1, 3, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass2, ::rusty_lr::parser::state::ShiftTarget::new(9, false)), @@ -1223,7 +1231,7 @@ impl EParser { 7usize] = [0, 1, 2, 4, 6, 14, 15,]; static __SHIFTED : [u8; 7usize] = [0, 0, 1, 1, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + : shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(6, false)),], @@ -1242,25 +1250,26 @@ impl EParser { 12, 13,]; static __SHIFTED : [u8; 11usize] = [0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : - vec![(ENonTerminals::Op, ::rusty_lr::parser::state::ShiftTarget::new(13, - true)),], reduce_map : { let mut __reduce_map = + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![(ENonTerminals::Op, + ::rusty_lr::parser::state::ShiftTarget::new(13, true)),], reduce_map : { let + mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES + : [u8; 1usize] = [6]; __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | + (* term, __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, + ruleset : { static __RULES : [u8; 2usize] = [5, 6,]; static __SHIFTED : [u8; + 2usize] = [1, 3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & + shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted + : shifted as usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = - [6]; __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term, + [0]; __reduce_map.extend(__RUSTYLR_TSET6.iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : - { static __RULES : [u8; 2usize] = [5, 6,]; static __SHIFTED : [u8; 2usize] = - [1, 3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + { static __RULES : [u8; 1usize] = [0,]; static __SHIFTED : [u8; 1usize] = + [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [0]; __reduce_map.extend(__RUSTYLR_TSET6 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [0,]; - static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -1269,8 +1278,9 @@ impl EParser { { static __RULES : [u8; 1usize] = [14,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(ETerminalClasses::TermClass0, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(ETerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(6, false)), (ETerminalClasses::TermClass5, ::rusty_lr::parser::state::ShiftTarget::new(18, false)), @@ -1289,15 +1299,16 @@ impl EParser { 15,]; static __SHIFTED : [u8; 8usize] = [0, 0, 2, 0, 0, 0, 0, 1,]; __RULES .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [15]; __reduce_map.extend(__RUSTYLR_TSET6 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [15,]; - static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [15]; __reduce_map.extend(__RUSTYLR_TSET6.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [15,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -1306,8 +1317,9 @@ impl EParser { { static __RULES : [u8; 1usize] = [2,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(ETerminalClasses::TermClass0, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(ETerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(6, false)),], shift_goto_map_nonterm : vec![(ENonTerminals::Number, ::rusty_lr::parser::state::ShiftTarget::new(1, true)), (ENonTerminals::P, @@ -1324,17 +1336,17 @@ impl EParser { 12, 13,]; static __SHIFTED : [u8; 11usize] = [0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : - vec![(ENonTerminals::Op, ::rusty_lr::parser::state::ShiftTarget::new(4, - true)),], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = - [6]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term, - __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : - { static __RULES : [u8; 2usize] = [5, 6,]; static __SHIFTED : [u8; 2usize] = - [1, 3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { - ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![(ENonTerminals::Op, + ::rusty_lr::parser::state::ShiftTarget::new(4, true)),], reduce_map : { let + mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES + : [u8; 1usize] = [6]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | + (* term, __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, + ruleset : { static __RULES : [u8; 2usize] = [5, 6,]; static __SHIFTED : [u8; + 2usize] = [1, 3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & + shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted + : shifted as usize, } }).collect() }, can_accept_error : false, }, ]; let states: Vec = states.into_iter().map(|state| state.into()).collect(); Self { rules, states } diff --git a/scripts/diff/json.rs b/scripts/diff/json.rs index 4844108..01bfa36 100644 --- a/scripts/diff/json.rs +++ b/scripts/diff/json.rs @@ -2025,8 +2025,9 @@ impl JsonParser { static __SHIFTED : [u8; 7usize] = [0, 0, 0, 0, 0, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(1, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(2, false)),], @@ -2040,9 +2041,9 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 5usize] = [42, 43, 44, 44, 97,]; static __SHIFTED : [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass0, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(1, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(2, false)),], @@ -2056,24 +2057,25 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 5usize] = [42, 43, 43, 44, 97,]; static __SHIFTED : [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = - [43]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term, - __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : - { static __RULES : [u8; 1usize] = [43,]; static __SHIFTED : [u8; 1usize] = - [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { - ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [44]; __reduce_map.extend(__RUSTYLR_TSET1 + __REDUCE_RULES : [u8; 1usize] = [43]; __reduce_map.extend(__RUSTYLR_TSET1 .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [44,]; + .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [43,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()) .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : + false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term + : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut + __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : + [u8; 1usize] = [44]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | + (* term, __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, + ruleset : { static __RULES : [u8; 1usize] = [44,]; static __SHIFTED : [u8; + 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & + shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted + : shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::eof, ::rusty_lr::parser::state::ShiftTarget::new(6, true)),], @@ -2081,12 +2083,13 @@ impl JsonParser { static __RULES : [u8; 1usize] = [98,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : - Default::default(), ruleset : { static __RULES : [u8; 1usize] = [98,]; static - __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| - (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [98,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(8, false)), @@ -2128,7 +2131,7 @@ impl JsonParser { static __SHIFTED : [u8; 23usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass22, ::rusty_lr::parser::state::ShiftTarget::new(9, false)),], @@ -2136,36 +2139,40 @@ impl JsonParser { static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass24, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass24, ::rusty_lr::parser::state::ShiftTarget::new(10, false)),], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass25, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass25, ::rusty_lr::parser::state::ShiftTarget::new(11, false)),], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass19, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass19, ::rusty_lr::parser::state::ShiftTarget::new(12, false)),], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [46]; __reduce_map.extend(__RUSTYLR_TSET2 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [46,]; - static __SHIFTED : [u8; 1usize] = [5,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [46]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] = + [5,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass26, ::rusty_lr::parser::state::ShiftTarget::new(14, false)),], @@ -2173,29 +2180,32 @@ impl JsonParser { static __RULES : [u8; 1usize] = [47,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass24, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass24, ::rusty_lr::parser::state::ShiftTarget::new(15, false)),], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 1usize] = [47,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass24, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass24, ::rusty_lr::parser::state::ShiftTarget::new(16, false)),], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 1usize] = [47,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [47]; __reduce_map.extend(__RUSTYLR_TSET2 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [47,]; - static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [47]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [47,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass8, ::rusty_lr::parser::state::ShiftTarget::new(18, false)),], @@ -2203,29 +2213,32 @@ impl JsonParser { static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass26, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass26, ::rusty_lr::parser::state::ShiftTarget::new(19, false)),], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass19, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass19, ::rusty_lr::parser::state::ShiftTarget::new(20, false)),], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [45]; __reduce_map.extend(__RUSTYLR_TSET2 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [45,]; - static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [45]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(26, false)), @@ -2237,8 +2250,9 @@ impl JsonParser { 93,]; static __SHIFTED : [u8; 4usize] = [1, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(24, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(24, false)),], @@ -2253,15 +2267,16 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [2, 0, 0, 0, 0, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [35]; __reduce_map.extend(__RUSTYLR_TSET4 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [35,]; - static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [35]; __reduce_map.extend(__RUSTYLR_TSET4.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [35,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(24, false)), @@ -2278,15 +2293,16 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [91]; __reduce_map.extend(__RUSTYLR_TSET4 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [91,]; - static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [91]; __reduce_map.extend(__RUSTYLR_TSET4.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [91,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -2295,8 +2311,9 @@ impl JsonParser { { static __RULES : [u8; 1usize] = [34,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(24, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(24, false)),], @@ -2311,15 +2328,16 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [1, 0, 0, 0, 0, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [33]; __reduce_map.extend(__RUSTYLR_TSET4 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [33,]; - static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [33]; __reduce_map.extend(__RUSTYLR_TSET4.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [33,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(1, false)), @@ -2343,8 +2361,9 @@ impl JsonParser { 51, 97,]; static __SHIFTED : [u8; 10usize] = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass12, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass12, ::rusty_lr::parser::state::ShiftTarget::new(31, false)),], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -2353,8 +2372,9 @@ impl JsonParser { { static __RULES : [u8; 2usize] = [48, 49,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(1, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(2, false)),], @@ -2372,8 +2392,9 @@ impl JsonParser { 97,]; static __SHIFTED : [u8; 8usize] = [0, 0, 0, 0, 0, 0, 2, 0,]; __RULES .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass6, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(8, false)), (JsonTerminalClasses::TermClass7, ::rusty_lr::parser::state::ShiftTarget::new(13, false)), @@ -2413,7 +2434,7 @@ impl JsonParser { static __SHIFTED : [u8; 23usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(26, false)), @@ -2425,8 +2446,9 @@ impl JsonParser { 93,]; static __SHIFTED : [u8; 4usize] = [1, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(35, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(35, false)),], @@ -2441,8 +2463,9 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [2, 0, 0, 0, 0, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(35, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(35, false)),], @@ -2457,8 +2480,9 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(35, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(35, false)),], @@ -2473,22 +2497,24 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [1, 0, 0, 0, 0, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass21, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass21, ::rusty_lr::parser::state::ShiftTarget::new(38, false)),], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 1usize] = [14,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [14]; __reduce_map.extend(__RUSTYLR_TSET2 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [14,]; - static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [14]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [14,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(40, false)), @@ -2509,8 +2535,9 @@ impl JsonParser { 43, 44, 97,]; static __SHIFTED : [u8; 10usize] = [1, 1, 1, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, + usize, } }).collect() }, can_accept_error : true, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(40, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(41, false)),], @@ -2524,9 +2551,9 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 5usize] = [42, 43, 44, 44, 97,]; static __SHIFTED : [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass0, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(40, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(41, false)),], @@ -2540,23 +2567,24 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 5usize] = [42, 43, 43, 44, 97,]; static __SHIFTED : [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass28, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass28, ::rusty_lr::parser::state::ShiftTarget::new(43, false)),], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 1usize] = [10,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [10]; __reduce_map.extend(__RUSTYLR_TSET2 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [10,]; - static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [10]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [10,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass28, ::rusty_lr::parser::state::ShiftTarget::new(45, false)),], @@ -2564,15 +2592,16 @@ impl JsonParser { static __RULES : [u8; 1usize] = [9,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [9]; __reduce_map.extend(__RUSTYLR_TSET2 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [9,]; - static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [9]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [9,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass12, ::rusty_lr::parser::state::ShiftTarget::new(47, false)),], @@ -2583,8 +2612,9 @@ impl JsonParser { { static __RULES : [u8; 2usize] = [11, 12,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(48, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(49, false)),], @@ -2602,8 +2632,9 @@ impl JsonParser { 97,]; static __SHIFTED : [u8; 8usize] = [0, 0, 2, 0, 0, 0, 0, 0,]; __RULES .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(48, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(49, false)),], @@ -2617,9 +2648,9 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 5usize] = [42, 43, 44, 44, 97,]; static __SHIFTED : [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass0, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(48, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(49, false)),], @@ -2633,26 +2664,27 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 5usize] = [42, 43, 43, 44, 97,]; static __SHIFTED : [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = - [12]; __reduce_map.extend(__RUSTYLR_TSET8.iter().map(| term | (* term, - __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : - { static __RULES : [u8; 1usize] = [12,]; static __SHIFTED : [u8; 1usize] = - [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { - ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass29, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); { static + __REDUCE_RULES : [u8; 1usize] = [12]; __reduce_map.extend(__RUSTYLR_TSET8 + .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map + .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [12,]; + static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : + false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term + : vec![(JsonTerminalClasses::TermClass29, ::rusty_lr::parser::state::ShiftTarget::new(52, false)),], shift_goto_map_nonterm : vec![(JsonNonTerminals::String, ::rusty_lr::parser::state::ShiftTarget::new(64, true)),], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 2usize] = [13, 16,]; static __SHIFTED : [u8; 2usize] = [1, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass1, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(60, false)), (JsonTerminalClasses::TermClass3, ::rusty_lr::parser::state::ShiftTarget::new(60, false)), @@ -2725,7 +2757,7 @@ impl JsonParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + : shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass4, ::rusty_lr::parser::state::ShiftTarget::new(59, false)), @@ -2751,7 +2783,7 @@ impl JsonParser { 21, 22, 23, 24, 25, 26, 27,]; static __SHIFTED : [u8; 10usize] = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + : shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass5, ::rusty_lr::parser::state::ShiftTarget::new(55, false)), @@ -2783,9 +2815,9 @@ impl JsonParser { 30, 83, 84, 85, 86, 87, 88, 89, 92, 93,]; static __SHIFTED : [u8; 13usize] = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass5, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass5, ::rusty_lr::parser::state::ShiftTarget::new(56, false)), (JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(56, false)), @@ -2815,9 +2847,9 @@ impl JsonParser { 30, 83, 84, 85, 86, 87, 88, 89, 92, 93,]; static __SHIFTED : [u8; 13usize] = [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass5, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass5, ::rusty_lr::parser::state::ShiftTarget::new(57, false)), (JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(57, false)), @@ -2847,9 +2879,9 @@ impl JsonParser { 30, 83, 84, 85, 86, 87, 88, 89, 92, 93,]; static __SHIFTED : [u8; 13usize] = [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass5, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass5, ::rusty_lr::parser::state::ShiftTarget::new(58, false)), (JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(58, false)), @@ -2879,24 +2911,25 @@ impl JsonParser { 30, 83, 84, 85, 86, 87, 88, 89, 92, 93,]; static __SHIFTED : [u8; 13usize] = [4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = - [27]; __reduce_map.extend(__RUSTYLR_TSET10.iter().map(| term | (* term, - __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : - { static __RULES : [u8; 1usize] = [27,]; static __SHIFTED : [u8; 1usize] = - [5,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { - ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [17]; __reduce_map.extend(__RUSTYLR_TSET10 + __REDUCE_RULES : [u8; 1usize] = [27]; __reduce_map.extend(__RUSTYLR_TSET10 .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [17,]; - static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()) + .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [27,]; + static __SHIFTED : [u8; 1usize] = [5,]; __RULES.iter().zip(__SHIFTED.iter()) .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : + false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term + : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut + __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : + [u8; 1usize] = [17]; __reduce_map.extend(__RUSTYLR_TSET10.iter().map(| term | + (* term, __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, + ruleset : { static __RULES : [u8; 1usize] = [17,]; static __SHIFTED : [u8; + 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & + shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted + : shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(60, false)), @@ -2969,15 +3002,16 @@ impl JsonParser { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [53]; __reduce_map.extend(__RUSTYLR_TSET9 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [53,]; - static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [53]; __reduce_map.extend(__RUSTYLR_TSET9.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [53,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass29, ::rusty_lr::parser::state::ShiftTarget::new(63, false)),], @@ -2985,15 +3019,16 @@ impl JsonParser { static __RULES : [u8; 1usize] = [16,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [16]; __reduce_map.extend(__RUSTYLR_TSET11 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [16,]; - static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [16]; __reduce_map.extend(__RUSTYLR_TSET11.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [16,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(65, false)), @@ -3009,9 +3044,9 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 5usize] = [13, 42, 43, 44, 97,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass0, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(65, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(66, false)),], @@ -3025,9 +3060,9 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 5usize] = [42, 43, 44, 44, 97,]; static __SHIFTED : [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass0, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(65, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(66, false)),], @@ -3041,16 +3076,17 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 5usize] = [42, 43, 43, 44, 97,]; static __SHIFTED : [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass16, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass16, ::rusty_lr::parser::state::ShiftTarget::new(68, false)),], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 1usize] = [13,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(1, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(2, false)),], @@ -3066,15 +3102,16 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [4, 0, 0, 0, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [13]; __reduce_map.extend(__RUSTYLR_TSET13 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [13,]; - static __SHIFTED : [u8; 1usize] = [5,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [13]; __reduce_map.extend(__RUSTYLR_TSET13.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [13,]; static __SHIFTED : [u8; 1usize] = + [5,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(8, false)), @@ -3116,7 +3153,7 @@ impl JsonParser { static __SHIFTED : [u8; 23usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(26, false)), @@ -3128,8 +3165,9 @@ impl JsonParser { 93,]; static __SHIFTED : [u8; 4usize] = [1, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(73, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(73, false)),], @@ -3144,8 +3182,9 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [2, 0, 0, 0, 0, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(73, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(73, false)),], @@ -3160,8 +3199,9 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(73, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(73, false)),], @@ -3176,8 +3216,9 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [1, 0, 0, 0, 0, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass28, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass28, ::rusty_lr::parser::state::ShiftTarget::new(76, false)), (JsonTerminalClasses::TermClass29, ::rusty_lr::parser::state::ShiftTarget::new(52, false)),], @@ -3186,17 +3227,18 @@ impl JsonParser { Default::default(), ruleset : { static __RULES : [u8; 3usize] = [8, 13, 16,]; static __SHIFTED : [u8; 3usize] = [2, 1, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = - [8]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term, - __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : - { static __RULES : [u8; 1usize] = [8,]; static __SHIFTED : [u8; 1usize] = - [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { - ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); { static + __REDUCE_RULES : [u8; 1usize] = [8]; __reduce_map.extend(__RUSTYLR_TSET2 + .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map + .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [8,]; + static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : + false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term + : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(78, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(79, false)),], @@ -3210,9 +3252,9 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 5usize] = [15, 42, 43, 44, 97,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass0, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(78, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(79, false)),], @@ -3226,9 +3268,9 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 5usize] = [42, 43, 44, 44, 97,]; static __SHIFTED : [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass0, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(78, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(79, false)),], @@ -3242,17 +3284,18 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 5usize] = [42, 43, 43, 44, 97,]; static __SHIFTED : [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = - [15]; __reduce_map.extend(__RUSTYLR_TSET15.iter().map(| term | (* term, - __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : - { static __RULES : [u8; 1usize] = [15,]; static __SHIFTED : [u8; 1usize] = - [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { - ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass13, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); { static + __REDUCE_RULES : [u8; 1usize] = [15]; __reduce_map.extend(__RUSTYLR_TSET15 + .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map + .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [15,]; + static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : + false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term + : vec![(JsonTerminalClasses::TermClass13, ::rusty_lr::parser::state::ShiftTarget::new(82, false)),], shift_goto_map_nonterm : vec![(JsonNonTerminals::_Group34, ::rusty_lr::parser::state::ShiftTarget::new(85, false)), @@ -3264,9 +3307,9 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 4usize] = [31, 94, 95, 96,]; static __SHIFTED : [u8; 4usize] = [1, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass14, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(84, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(84, false)),], @@ -3278,15 +3321,16 @@ impl JsonParser { 93, 94,]; static __SHIFTED : [u8; 5usize] = [0, 0, 0, 0, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [94]; __reduce_map.extend(__RUSTYLR_TSET17 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [94,]; - static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [94]; __reduce_map.extend(__RUSTYLR_TSET17.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [94,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(84, false)), @@ -3303,8 +3347,9 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass18, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass18, ::rusty_lr::parser::state::ShiftTarget::new(86, false)), (JsonTerminalClasses::TermClass19, ::rusty_lr::parser::state::ShiftTarget::new(90, false)),], @@ -3318,9 +3363,9 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 5usize] = [31, 36, 37, 38, 97,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass10, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass10, ::rusty_lr::parser::state::ShiftTarget::new(87, false)), (JsonTerminalClasses::TermClass11, ::rusty_lr::parser::state::ShiftTarget::new(87, false)),], @@ -3334,9 +3379,9 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 5usize] = [37, 39, 40, 41, 97,]; static __SHIFTED : [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass14, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(89, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(89, false)),], @@ -3348,15 +3393,16 @@ impl JsonParser { 92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [37]; __reduce_map.extend(__RUSTYLR_TSET2 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [37,]; - static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [37]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [37,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(89, false)), @@ -3373,8 +3419,9 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass10, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass10, ::rusty_lr::parser::state::ShiftTarget::new(91, false)), (JsonTerminalClasses::TermClass11, ::rusty_lr::parser::state::ShiftTarget::new(91, false)),], @@ -3388,9 +3435,9 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 5usize] = [38, 39, 40, 41, 97,]; static __SHIFTED : [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass14, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(89, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(89, false)),], @@ -3402,15 +3449,16 @@ impl JsonParser { 92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [38]; __reduce_map.extend(__RUSTYLR_TSET2 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [38,]; - static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [38]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [38,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -3419,8 +3467,9 @@ impl JsonParser { { static __RULES : [u8; 1usize] = [31,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(95, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(96, false)),], @@ -3434,9 +3483,9 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 5usize] = [15, 42, 43, 44, 97,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass0, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(95, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(96, false)),], @@ -3450,9 +3499,9 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 5usize] = [42, 43, 44, 44, 97,]; static __SHIFTED : [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass0, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(95, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(96, false)),], @@ -3466,9 +3515,9 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 5usize] = [42, 43, 43, 44, 97,]; static __SHIFTED : [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass13, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass13, ::rusty_lr::parser::state::ShiftTarget::new(98, false)),], shift_goto_map_nonterm : vec![(JsonNonTerminals::_Group34, ::rusty_lr::parser::state::ShiftTarget::new(100, false)), @@ -3480,9 +3529,9 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 4usize] = [31, 94, 95, 96,]; static __SHIFTED : [u8; 4usize] = [1, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass14, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(99, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(99, false)),], @@ -3494,8 +3543,9 @@ impl JsonParser { 93, 94,]; static __SHIFTED : [u8; 5usize] = [0, 0, 0, 0, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(99, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(99, false)),], @@ -3510,8 +3560,9 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass18, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass18, ::rusty_lr::parser::state::ShiftTarget::new(101, false)), (JsonTerminalClasses::TermClass19, ::rusty_lr::parser::state::ShiftTarget::new(104, false)),], @@ -3525,9 +3576,9 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 5usize] = [31, 36, 37, 38, 97,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass10, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass10, ::rusty_lr::parser::state::ShiftTarget::new(102, false)), (JsonTerminalClasses::TermClass11, ::rusty_lr::parser::state::ShiftTarget::new(102, false)),], @@ -3542,8 +3593,9 @@ impl JsonParser { 39, 40, 41, 97,]; static __SHIFTED : [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(103, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(103, false)),], @@ -3555,8 +3607,9 @@ impl JsonParser { 92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(103, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(103, false)),], @@ -3571,8 +3624,9 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass10, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass10, ::rusty_lr::parser::state::ShiftTarget::new(105, false)), (JsonTerminalClasses::TermClass11, ::rusty_lr::parser::state::ShiftTarget::new(105, false)),], @@ -3587,8 +3641,9 @@ impl JsonParser { 39, 40, 41, 97,]; static __SHIFTED : [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(103, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(103, false)),], @@ -3600,15 +3655,16 @@ impl JsonParser { 92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [49]; __reduce_map.extend(__RUSTYLR_TSET5 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [49,]; - static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [49]; __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [49,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(108, false)), @@ -3624,9 +3680,9 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 5usize] = [15, 42, 43, 44, 97,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass0, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(108, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(109, false)),], @@ -3640,9 +3696,9 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 5usize] = [42, 43, 44, 44, 97,]; static __SHIFTED : [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass0, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(108, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(109, false)),], @@ -3656,9 +3712,9 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 5usize] = [42, 43, 43, 44, 97,]; static __SHIFTED : [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass13, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass13, ::rusty_lr::parser::state::ShiftTarget::new(111, false)),], shift_goto_map_nonterm : vec![(JsonNonTerminals::_Group34, ::rusty_lr::parser::state::ShiftTarget::new(113, false)), @@ -3670,9 +3726,9 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 4usize] = [31, 94, 95, 96,]; static __SHIFTED : [u8; 4usize] = [1, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass14, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(112, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(112, false)),], @@ -3684,8 +3740,9 @@ impl JsonParser { 93, 94,]; static __SHIFTED : [u8; 5usize] = [0, 0, 0, 0, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(112, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(112, false)),], @@ -3700,8 +3757,9 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass18, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass18, ::rusty_lr::parser::state::ShiftTarget::new(114, false)), (JsonTerminalClasses::TermClass19, ::rusty_lr::parser::state::ShiftTarget::new(117, false)),], @@ -3715,9 +3773,9 @@ impl JsonParser { }, ruleset : { static __RULES : [u8; 5usize] = [31, 36, 37, 38, 97,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass10, + rule : rule as usize, shifted : shifted as usize, } }).collect() }, + can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass10, ::rusty_lr::parser::state::ShiftTarget::new(115, false)), (JsonTerminalClasses::TermClass11, ::rusty_lr::parser::state::ShiftTarget::new(115, false)),], @@ -3732,8 +3790,9 @@ impl JsonParser { 39, 40, 41, 97,]; static __SHIFTED : [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(116, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(116, false)),], @@ -3745,8 +3804,9 @@ impl JsonParser { 92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(116, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(116, false)),], @@ -3761,8 +3821,9 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass10, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass10, ::rusty_lr::parser::state::ShiftTarget::new(118, false)), (JsonTerminalClasses::TermClass11, ::rusty_lr::parser::state::ShiftTarget::new(118, false)),], @@ -3777,8 +3838,9 @@ impl JsonParser { 39, 40, 41, 97,]; static __SHIFTED : [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, + usize, } }).collect() }, can_accept_error : false, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(116, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(116, false)),], @@ -3790,7 +3852,7 @@ impl JsonParser { 92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() } }, + usize, } }).collect() }, can_accept_error : false, }, ]; let states: Vec = states .into_iter() From 567ef1b2d3dbcabd0a76beaf28fa7001c86dd1a3 Mon Sep 17 00:00:00 2001 From: Taehwan Kim Date: Mon, 6 Oct 2025 22:15:39 +0900 Subject: [PATCH 4/8] use can_accept_error for deterministic error --- .../src/parser/deterministic/context.rs | 64 +++++++++---------- 1 file changed, 32 insertions(+), 32 deletions(-) diff --git a/rusty_lr_core/src/parser/deterministic/context.rs b/rusty_lr_core/src/parser/deterministic/context.rs index f4f6309..08dd977 100644 --- a/rusty_lr_core/src/parser/deterministic/context.rs +++ b/rusty_lr_core/src/parser/deterministic/context.rs @@ -269,41 +269,41 @@ impl Context { return Err(ParseError::NoAction(err)); } - let mut error_location = Location::new(self.location_stack.iter().rev(), 0); - let error = P::TermClass::ERROR; - let error_prec = error.precedence(); - + let error_prec = P::TermClass::ERROR.precedence(); + let mut error_location = Data::Location::new(self.location_stack.iter().rev(), 0); loop { - match self.feed_location_impl( - parser, - TerminalSymbol::Error, - error, - error_prec, - userdata, - Some(error_location), - ) { - Err(ParseError::NoAction(err1)) => { - if self.state_stack.len() == 1 { - return Err(ParseError::NoAction(err)); - } else { - // no action for `error` token, continue to panic mode - // merge location with previous - error_location = Data::Location::new( - std::iter::once(&err1.location.unwrap()) - .chain(self.location_stack.iter().rev()), - 2, // error node - ); - self.data_stack.pop(); - self.precedence_stack.pop(); - self.location_stack.pop(); - self.state_stack.pop(); - - #[cfg(feature = "tree")] - self.tree_stack.pop(); // pop tree node for `error` + if let Some(s) = self.state_stack.last() { + if parser.get_states()[s.into_usize()].can_accept_error() { + match self.feed_location_impl( + parser, + TerminalSymbol::Error, + P::TermClass::ERROR, + error_prec, + userdata, + Some(error_location), + ) { + Ok(()) => break, // successfully shifted `error` + Err(ParseError::NoAction(err1)) => { + error_location = err1.location.unwrap(); + } + Err(_) => return Err(ParseError::NoAction(err)), // other errors } } - Ok(()) => break, // successfully shifted `error` - Err(_) => return Err(ParseError::NoAction(err)), // other errors + + error_location = Data::Location::new( + std::iter::once(&error_location) + .chain(self.location_stack.iter().rev()), + 2, + ); + + self.location_stack.pop(); + self.state_stack.pop(); + self.precedence_stack.pop(); + self.data_stack.pop(); + #[cfg(feature = "tree")] + self.tree_stack.pop(); + } else { + return Err(ParseError::NoAction(err)); } } From 49d923b19aa2315b313cc63eeb753810922b48aa Mon Sep 17 00:00:00 2001 From: Taehwan Kim Date: Tue, 7 Oct 2025 00:29:48 +0900 Subject: [PATCH 5/8] use can_accept_error for non-deterministic error --- .../src/parser/nondeterministic/context.rs | 69 +++++++++++-------- 1 file changed, 41 insertions(+), 28 deletions(-) diff --git a/rusty_lr_core/src/parser/nondeterministic/context.rs b/rusty_lr_core/src/parser/nondeterministic/context.rs index 09bc0ec..5437135 100644 --- a/rusty_lr_core/src/parser/nondeterministic/context.rs +++ b/rusty_lr_core/src/parser/nondeterministic/context.rs @@ -1234,8 +1234,7 @@ impl mut node: usize, error_prec: Precedence, userdata: &mut Data::UserData, - ) -> bool - where + ) where Data: Clone, P::Term: Clone, P::NonTerm: std::fmt::Debug, @@ -1244,34 +1243,47 @@ impl use crate::Location; let mut error_location = Data::Location::new(self.location_iter(node), 0); - loop { - match self.feed_location_impl( - parser, - node, - TerminalSymbol::Error, - P::TermClass::ERROR, - error_prec, - Some(error_location), - userdata, - ) { - Ok(_) => { - return true; - } - Err((err_node, _, err_loc)) => { - if self.node(err_node).len() == 0 { - return false; // root node; no more nodes to process - } - error_location = Data::Location::new( - std::iter::once(&err_loc.unwrap()).chain(self.location_iter(err_node)), - 2, - ); - if let Some(next_node) = self.pop(err_node) { - node = next_node; - } else { - return false; + let node_ = self.node(node); + if !node_.is_leaf() { + self.try_remove_node(node); + return; + } + if let Some(&s) = node_.state_stack.last() { + if parser.get_states()[s.into_usize()].can_accept_error() { + match self.feed_location_impl( + parser, + node, + TerminalSymbol::Error, + P::TermClass::ERROR, + error_prec, + Some(error_location), + userdata, + ) { + Ok(()) => break, // successfully shifted `error` + Err((err_node, _, err_loc)) => { + // if this `error` feed causes reduce error, do not try panic mode anymore + if !self.reduce_errors.is_empty() { + return; + } + error_location = err_loc.unwrap(); + node = err_node; + } // other errors } } + + error_location = Data::Location::new( + std::iter::once(&error_location).chain(self.location_iter(node)), + 2, + ); + let next_node = self.pop(node); + if let Some(next_node) = next_node { + node = next_node; + } else { + return; // reached root node; no more nodes to process + } + } else { + unreachable!("state stack is empty but node is not root"); } } } @@ -1337,6 +1349,7 @@ impl let error_prec = P::TermClass::ERROR.precedence(); + let reduce_action_errors = std::mem::take(&mut self.reduce_errors); let mut fallback_nodes = std::mem::take(&mut self.fallback_nodes); // try enter panic mode and store error nodes to next_nodes for node in fallback_nodes.drain(..) { @@ -1349,7 +1362,7 @@ impl Err(ParseError { term: TerminalSymbol::Term(term), location: Some(location), - reduce_action_errors: std::mem::take(&mut self.reduce_errors), + reduce_action_errors, no_precedences: std::mem::take(&mut self.no_precedences), states: self.states().collect(), }) From ab65a8c677388fa99b079763dd4c7fe0b350e5b2 Mon Sep 17 00:00:00 2001 From: Taehwan Kim Date: Tue, 7 Oct 2025 09:53:38 +0900 Subject: [PATCH 6/8] add TriState --- rusty_lr_core/src/builder/grammar.rs | 9 +- rusty_lr_core/src/builder/state.rs | 6 +- rusty_lr_core/src/lib.rs | 19 + rusty_lr_core/src/parser/state.rs | 9 +- rusty_lr_parser/src/emit.rs | 6 +- rusty_lr_parser/src/parser/parser_expanded.rs | 596 ++++++++++++------ scripts/diff/calculator.rs | 57 +- scripts/diff/calculator_u8.rs | 122 ++-- scripts/diff/json.rs | 458 +++++++------- 9 files changed, 762 insertions(+), 520 deletions(-) diff --git a/rusty_lr_core/src/builder/grammar.rs b/rusty_lr_core/src/builder/grammar.rs index 67cdfb9..615b9e8 100644 --- a/rusty_lr_core/src/builder/grammar.rs +++ b/rusty_lr_core/src/builder/grammar.rs @@ -13,6 +13,7 @@ use crate::hash::HashMap; use crate::rule::*; use crate::token::Token; use crate::TerminalSymbol; +use crate::TriState; /// struct that holding pre-calculated information for `expand()` function. #[derive(Debug, Clone)] @@ -538,7 +539,7 @@ impl Grammar, NonTerm> { .contains_key(&TerminalSymbol::Error) || state.reduce_map.contains_key(&TerminalSymbol::Error) { - state.can_accept_error = true; + state.can_accept_error = TriState::True; } } @@ -679,7 +680,8 @@ impl Grammar, NonTerm> { .shift_goto_map_nonterm .append(&mut state_b.shift_goto_map_nonterm); state_a.reduce_map.append(&mut state_b.reduce_map); - state_a.can_accept_error |= state_b.can_accept_error; + state_a.can_accept_error = + state_a.can_accept_error | state_b.can_accept_error; merged = true; } } @@ -775,7 +777,8 @@ impl Grammar, NonTerm> { .or_default() .append(&mut reduce_rules); } - states[state_a].can_accept_error |= state_b.can_accept_error; + states[state_a].can_accept_error = + states[state_a].can_accept_error | state_b.can_accept_error; } } let mut new_states = Vec::with_capacity(states.len() - merge_into.len()); diff --git a/rusty_lr_core/src/builder/state.rs b/rusty_lr_core/src/builder/state.rs index 57b34b8..88b1e6a 100644 --- a/rusty_lr_core/src/builder/state.rs +++ b/rusty_lr_core/src/builder/state.rs @@ -1,6 +1,8 @@ use std::collections::BTreeMap; use std::collections::BTreeSet; +use crate::TriState; + /// state for internal usage during grammar building stage #[derive(Debug, Clone)] pub struct State { @@ -8,7 +10,7 @@ pub struct State { pub shift_goto_map_nonterm: BTreeMap, pub reduce_map: BTreeMap>, pub ruleset: BTreeSet, - pub can_accept_error: bool, + pub can_accept_error: TriState, } impl State { pub fn new() -> Self { @@ -17,7 +19,7 @@ impl State { shift_goto_map_nonterm: Default::default(), reduce_map: Default::default(), ruleset: Default::default(), - can_accept_error: false, + can_accept_error: TriState::False, } } diff --git a/rusty_lr_core/src/lib.rs b/rusty_lr_core/src/lib.rs index 218bad0..3b6d39e 100644 --- a/rusty_lr_core/src/lib.rs +++ b/rusty_lr_core/src/lib.rs @@ -50,3 +50,22 @@ impl std::error::Error for DefaultReduceActionError { "Default reduce action error" } } + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum TriState { + False, + Maybe, + True, +} +impl std::ops::BitOr for TriState { + type Output = Self; + fn bitor(self, rhs: Self) -> Self::Output { + match (self, rhs) { + (TriState::False, TriState::False) => TriState::False, + (TriState::False, _) => TriState::Maybe, + (_, TriState::False) => TriState::Maybe, + (TriState::True, TriState::True) => TriState::True, + _ => TriState::Maybe, + } + } +} diff --git a/rusty_lr_core/src/parser/state.rs b/rusty_lr_core/src/parser/state.rs index 27b9b71..0b8bcb7 100644 --- a/rusty_lr_core/src/parser/state.rs +++ b/rusty_lr_core/src/parser/state.rs @@ -3,6 +3,7 @@ use std::hash::Hash; use crate::hash::HashMap; use crate::parser::nonterminal::NonTerminal; use crate::parser::terminalclass::TerminalClass; +use crate::TriState; #[derive(Debug, Clone, Copy)] pub struct ShiftTarget { @@ -23,7 +24,7 @@ pub struct IntermediateState { pub shift_goto_map_nonterm: Vec<(NonTerm, ShiftTarget)>, // must be sorted pub reduce_map: Vec<(TermClass, Vec)>, // must be sorted pub ruleset: Vec, - pub can_accept_error: bool, + pub can_accept_error: TriState, } /// For state, terminal and class indices, we use the most compact integer type that can hold the maximum value. @@ -325,7 +326,8 @@ where }) .collect(), ruleset: builder_state.ruleset.into_iter().collect(), - can_accept_error: builder_state.can_accept_error, + can_accept_error: false, + // builder_state.can_accept_error, } } } @@ -434,7 +436,8 @@ where reduce_map, reduce_offset: reduce_min, ruleset: builder_state.ruleset.into_iter().collect(), - can_accept_error: builder_state.can_accept_error, + can_accept_error: false, + // builder_state.can_accept_error, } } } diff --git a/rusty_lr_parser/src/emit.rs b/rusty_lr_parser/src/emit.rs index 3a972cc..8e3fd45 100644 --- a/rusty_lr_parser/src/emit.rs +++ b/rusty_lr_parser/src/emit.rs @@ -781,7 +781,11 @@ impl Grammar { } }; - let can_accept_error = state.can_accept_error; + let can_accept_error = match state.can_accept_error { + rusty_lr_core::TriState::False => quote! { #module_prefix::TriState::False }, + rusty_lr_core::TriState::True => quote! { #module_prefix::TriState::True }, + rusty_lr_core::TriState::Maybe => quote! { #module_prefix::TriState::Maybe }, + }; states_body_stream.extend(quote! { #module_prefix::parser::state::IntermediateState { diff --git a/rusty_lr_parser/src/parser/parser_expanded.rs b/rusty_lr_parser/src/parser/parser_expanded.rs index b8b37c0..1651d20 100644 --- a/rusty_lr_parser/src/parser/parser_expanded.rs +++ b/rusty_lr_parser/src/parser/parser_expanded.rs @@ -7540,7 +7540,8 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::parengroup, ::rusty_lr_core::parser::state::ShiftTarget::new(2, true)),], @@ -7553,7 +7554,8 @@ impl GrammarParser { 2,]; static __SHIFTED : [u8; 3usize] = [1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7562,7 +7564,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [1,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::colon, ::rusty_lr_core::parser::state::ShiftTarget::new(4, true)),], @@ -7570,7 +7573,8 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [0,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(5, true)), @@ -7607,7 +7611,8 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::equal, ::rusty_lr_core::parser::state::ShiftTarget::new(6, true)),], @@ -7618,7 +7623,8 @@ impl GrammarParser { { static __RULES : [u8; 2usize] = [12, 21,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), @@ -7641,7 +7647,8 @@ impl GrammarParser { __SHIFTED : [u8; 19usize] = [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7650,7 +7657,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [21,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::Maybe, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7659,7 +7667,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [20,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::Maybe, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(10, true)),], @@ -7668,16 +7677,18 @@ impl GrammarParser { [u8; 5usize] = [1, 1, 1, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : - false, }, ::rusty_lr_core::parser::state::IntermediateState { - shift_goto_map_term : vec![(GrammarTerminalClasses::lparen, + ::rusty_lr_core::TriState::False, }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(GrammarTerminalClasses::lparen, ::rusty_lr_core::parser::state::ShiftTarget::new(11, true)),], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 5usize] = [32, 33, 34, 35, 36,]; static __SHIFTED : [u8; 5usize] = [2, 2, 2, 2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : - false, }, ::rusty_lr_core::parser::state::IntermediateState { - shift_goto_map_term : vec![(GrammarTerminalClasses::ident, + ::rusty_lr_core::TriState::False, }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), (GrammarTerminalClasses::dot, ::rusty_lr_core::parser::state::ShiftTarget::new(8, true)), @@ -7699,17 +7710,19 @@ impl GrammarParser { 0, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : - false, }, ::rusty_lr_core::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [30]; __reduce_map.extend(__RUSTYLR_TSET3 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [30,]; - static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : - rule as usize, shifted : shifted as usize, } }).collect() }, can_accept_error - : true, }, ::rusty_lr_core::parser::state::IntermediateState { - shift_goto_map_term : vec![(GrammarTerminalClasses::ident, + ::rusty_lr_core::TriState::False, }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map + = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [30]; __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [30,]; static __SHIFTED : [u8; 1usize] = + [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::Maybe, }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), (GrammarTerminalClasses::dot, ::rusty_lr_core::parser::state::ShiftTarget::new(8, true)), @@ -7742,7 +7755,8 @@ impl GrammarParser { 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::True, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::caret, ::rusty_lr_core::parser::state::ShiftTarget::new(15, true)),], @@ -7755,7 +7769,8 @@ impl GrammarParser { 86, 87,]; static __SHIFTED : [u8; 3usize] = [1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7764,7 +7779,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [86,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(17, true)), @@ -7784,8 +7800,9 @@ impl GrammarParser { [0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()) .map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, can_accept_error - : false, }, ::rusty_lr_core::parser::state::IntermediateState { - shift_goto_map_term : vec![(GrammarTerminalClasses::minus, + : ::rusty_lr_core::TriState::False, }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(GrammarTerminalClasses::minus, ::rusty_lr_core::parser::state::ShiftTarget::new(18, true)),], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7794,7 +7811,8 @@ impl GrammarParser { { static __RULES : [u8; 3usize] = [13, 14, 15,]; static __SHIFTED : [u8; 3usize] = [1, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(19, true)), @@ -7804,7 +7822,8 @@ impl GrammarParser { static __RULES : [u8; 2usize] = [14, 15,]; static __SHIFTED : [u8; 2usize] = [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::True, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7813,7 +7832,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [14,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7822,7 +7842,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [15,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::minus, ::rusty_lr_core::parser::state::ShiftTarget::new(22, true)),], @@ -7833,7 +7854,8 @@ impl GrammarParser { { static __RULES : [u8; 3usize] = [16, 17, 18,]; static __SHIFTED : [u8; 3usize] = [1, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::literal, ::rusty_lr_core::parser::state::ShiftTarget::new(23, true)), @@ -7843,7 +7865,8 @@ impl GrammarParser { static __RULES : [u8; 2usize] = [17, 18,]; static __SHIFTED : [u8; 2usize] = [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::True, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7852,7 +7875,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [17,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7861,7 +7885,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [18,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7870,7 +7895,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [88,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(17, true)), @@ -7885,7 +7911,8 @@ impl GrammarParser { 14, 15, 16, 17, 18, 89, 90,]; static __SHIFTED : [u8; 8usize] = [0, 0, 0, 0, 0, 0, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7894,7 +7921,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [89,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::rbracket, ::rusty_lr_core::parser::state::ShiftTarget::new(29, true)),], @@ -7902,7 +7930,8 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [19,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7911,7 +7940,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [19,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::Maybe, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7920,7 +7950,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [26,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::Maybe, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::plus, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), @@ -7941,7 +7972,8 @@ impl GrammarParser { 36,]; static __SHIFTED : [u8; 11usize] = [1, 1, 1, 1, 1, 1, 4, 4, 4, 4, 4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7950,7 +7982,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [22,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::Maybe, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7959,7 +7992,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [23,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::Maybe, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7968,7 +8002,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [24,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::Maybe, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), @@ -7991,7 +8026,8 @@ impl GrammarParser { __SHIFTED : [u8; 19usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::plus, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), @@ -8011,17 +8047,19 @@ impl GrammarParser { : [u8; 6usize] = [1, 1, 1, 1, 1, 3,]; __RULES.iter().zip(__SHIFTED.iter()) .map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, can_accept_error - : true, }, ::rusty_lr_core::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [25]; __reduce_map.extend(__RUSTYLR_TSET3 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [25,]; - static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : - rule as usize, shifted : shifted as usize, } }).collect() }, can_accept_error - : true, }, ::rusty_lr_core::parser::state::IntermediateState { - shift_goto_map_term : vec![(GrammarTerminalClasses::ident, + : ::rusty_lr_core::TriState::Maybe, }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map + = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [25]; __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [25,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::Maybe, }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), (GrammarTerminalClasses::dot, ::rusty_lr_core::parser::state::ShiftTarget::new(8, true)), @@ -8042,7 +8080,8 @@ impl GrammarParser { __SHIFTED : [u8; 19usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::plus, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), @@ -8060,8 +8099,9 @@ impl GrammarParser { [u8; 5usize] = [1, 1, 1, 1, 3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : - true, }, ::rusty_lr_core::parser::state::IntermediateState { - shift_goto_map_term : vec![(GrammarTerminalClasses::ident, + ::rusty_lr_core::TriState::Maybe, }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), (GrammarTerminalClasses::dot, ::rusty_lr_core::parser::state::ShiftTarget::new(8, true)), @@ -8083,14 +8123,16 @@ impl GrammarParser { 0, 0, 5, 0, 5, 0, 5, 0, 5, 0, 5,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : - false, }, ::rusty_lr_core::parser::state::IntermediateState { - shift_goto_map_term : vec![(GrammarTerminalClasses::rparen, + ::rusty_lr_core::TriState::False, }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(GrammarTerminalClasses::rparen, ::rusty_lr_core::parser::state::ShiftTarget::new(42, true)),], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 1usize] = [29,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8099,7 +8141,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [29,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::Maybe, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::plus, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), @@ -8121,7 +8164,8 @@ impl GrammarParser { __SHIFTED : [u8; 7usize] = [1, 1, 1, 1, 1, 1, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), @@ -8147,7 +8191,8 @@ impl GrammarParser { static __SHIFTED : [u8; 20usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::plus, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), @@ -8169,7 +8214,8 @@ impl GrammarParser { __SHIFTED : [u8; 7usize] = [1, 1, 1, 1, 1, 1, 2,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8178,7 +8224,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [96,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::pipe, ::rusty_lr_core::parser::state::ShiftTarget::new(48, true)), @@ -8188,7 +8235,8 @@ impl GrammarParser { static __RULES : [u8; 2usize] = [28, 97,]; static __SHIFTED : [u8; 2usize] = [2, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), @@ -8219,7 +8267,7 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, + can_accept_error : ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8228,7 +8276,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [97,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8237,7 +8286,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [28,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::Maybe, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::plus, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), @@ -8265,7 +8315,8 @@ impl GrammarParser { 13usize] = [1, 1, 1, 1, 1, 1, 6, 6, 6, 6, 6, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::True, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::plus, ::rusty_lr_core::parser::state::ShiftTarget::new(53, true)), @@ -8280,7 +8331,8 @@ impl GrammarParser { { static __RULES : [u8; 4usize] = [33, 34, 36, 98,]; static __SHIFTED : [u8; 4usize] = [7, 7, 7, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::True, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::rparen, ::rusty_lr_core::parser::state::ShiftTarget::new(54, true)),], @@ -8288,7 +8340,8 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [33,]; static __SHIFTED : [u8; 1usize] = [8,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8297,7 +8350,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [33,]; static __SHIFTED : [u8; 1usize] = [9,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::Maybe, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::rparen, ::rusty_lr_core::parser::state::ShiftTarget::new(56, true)),], @@ -8305,7 +8359,8 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [34,]; static __SHIFTED : [u8; 1usize] = [8,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8314,7 +8369,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [34,]; static __SHIFTED : [u8; 1usize] = [9,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::Maybe, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::rparen, ::rusty_lr_core::parser::state::ShiftTarget::new(58, true)),], @@ -8322,7 +8378,8 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [36,]; static __SHIFTED : [u8; 1usize] = [8,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8331,7 +8388,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [36,]; static __SHIFTED : [u8; 1usize] = [9,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::Maybe, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::rparen, ::rusty_lr_core::parser::state::ShiftTarget::new(60, true)),], @@ -8339,7 +8397,8 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [35,]; static __SHIFTED : [u8; 1usize] = [7,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8348,7 +8407,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [35,]; static __SHIFTED : [u8; 1usize] = [8,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::Maybe, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::rparen, ::rusty_lr_core::parser::state::ShiftTarget::new(62, true)),], @@ -8356,7 +8416,8 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [32,]; static __SHIFTED : [u8; 1usize] = [7,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8365,7 +8426,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [32,]; static __SHIFTED : [u8; 1usize] = [8,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::Maybe, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::plus, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), @@ -8387,7 +8449,8 @@ impl GrammarParser { __SHIFTED : [u8; 7usize] = [3, 1, 1, 1, 1, 1, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(65, false)), @@ -8397,7 +8460,8 @@ impl GrammarParser { static __RULES : [u8; 2usize] = [0, 3,]; static __SHIFTED : [u8; 2usize] = [4, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8406,7 +8470,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [0,]; static __SHIFTED : [u8; 1usize] = [5,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(5, true)), @@ -8441,7 +8506,8 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8450,7 +8516,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [3,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8459,7 +8526,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [78,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::plus, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), @@ -8481,7 +8549,8 @@ impl GrammarParser { __SHIFTED : [u8; 7usize] = [1, 1, 1, 1, 1, 1, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(5, true)), @@ -8510,17 +8579,19 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()) .map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, can_accept_error - : false, }, ::rusty_lr_core::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [79]; __reduce_map.extend(__RUSTYLR_TSET11 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [79,]; - static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : - rule as usize, shifted : shifted as usize, } }).collect() }, can_accept_error - : false, }, ::rusty_lr_core::parser::state::IntermediateState { - shift_goto_map_term : vec![(GrammarTerminalClasses::percent, + : ::rusty_lr_core::TriState::False, }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map + = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [79]; __reduce_map.extend(__RUSTYLR_TSET11.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [79,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(GrammarTerminalClasses::percent, ::rusty_lr_core::parser::state::ShiftTarget::new(73, true)),], shift_goto_map_nonterm : vec![(GrammarNonTerminals::PrecDef, ::rusty_lr_core::parser::state::ShiftTarget::new(83, true)), @@ -8535,7 +8606,8 @@ impl GrammarParser { 7, 8, 9, 10, 82, 83, 84, 85,]; static __SHIFTED : [u8; 10usize] = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::prec, ::rusty_lr_core::parser::state::ShiftTarget::new(74, true)), @@ -8547,8 +8619,9 @@ impl GrammarParser { static __RULES : [u8; 5usize] = [6, 7, 8, 9, 10,]; static __SHIFTED : [u8; 5usize] = [1, 1, 1, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() }, can_accept_error : true, - }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + usize, shifted : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::True, }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)), (GrammarTerminalClasses::literal, @@ -8561,7 +8634,8 @@ impl GrammarParser { 40,]; static __SHIFTED : [u8; 4usize] = [2, 2, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::True, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8570,7 +8644,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [39,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8579,7 +8654,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [40,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8588,7 +8664,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [7,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8597,7 +8674,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [6,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::literal, ::rusty_lr_core::parser::state::ShiftTarget::new(80, true)), @@ -8607,7 +8685,8 @@ impl GrammarParser { static __RULES : [u8; 2usize] = [8, 9,]; static __SHIFTED : [u8; 2usize] = [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::True, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8616,7 +8695,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [8,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8625,7 +8705,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [9,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8634,7 +8715,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [10,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8643,7 +8725,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [82,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::percent, ::rusty_lr_core::parser::state::ShiftTarget::new(73, true)),], @@ -8656,7 +8739,8 @@ impl GrammarParser { 8, 9, 10, 83, 84,]; static __SHIFTED : [u8; 7usize] = [0, 0, 0, 0, 0, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8665,7 +8749,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [83,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::bracegroup, ::rusty_lr_core::parser::state::ShiftTarget::new(87, true)),], @@ -8678,7 +8763,8 @@ impl GrammarParser { 38,]; static __SHIFTED : [u8; 3usize] = [2, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8687,7 +8773,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [37,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8696,7 +8783,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [5,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8705,7 +8793,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [4,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::left, ::rusty_lr_core::parser::state::ShiftTarget::new(91, true)), @@ -8748,7 +8837,8 @@ impl GrammarParser { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::True, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)), @@ -8764,7 +8854,8 @@ impl GrammarParser { 51, 143, 144,]; static __SHIFTED : [u8; 6usize] = [0, 0, 2, 2, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::True, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(93, false)),], @@ -8772,7 +8863,8 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [51,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8781,7 +8873,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [51,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8790,7 +8883,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [143,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)), @@ -8804,7 +8898,8 @@ impl GrammarParser { 144,]; static __SHIFTED : [u8; 4usize] = [0, 0, 3, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8813,7 +8908,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [50,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8822,7 +8918,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [144,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)), @@ -8838,7 +8935,8 @@ impl GrammarParser { 53, 143, 144,]; static __SHIFTED : [u8; 6usize] = [0, 0, 2, 2, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::True, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(100, false)),], @@ -8846,7 +8944,8 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [53,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8855,7 +8954,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [53,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)), @@ -8869,7 +8969,8 @@ impl GrammarParser { 144,]; static __SHIFTED : [u8; 4usize] = [0, 0, 3, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8878,7 +8979,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [52,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(104, true)), @@ -8888,7 +8990,8 @@ impl GrammarParser { static __RULES : [u8; 3usize] = [41, 42, 43,]; static __SHIFTED : [u8; 3usize] = [2, 2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::True, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), @@ -8986,7 +9089,8 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8995,7 +9099,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [42,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9004,7 +9109,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [141,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)), @@ -9100,7 +9206,8 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9109,7 +9216,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [41,]; static __SHIFTED : [u8; 1usize] = [5,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9118,7 +9226,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [142,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(111, false)),], @@ -9126,7 +9235,8 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [43,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9135,7 +9245,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [43,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(113, true)), @@ -9145,7 +9256,8 @@ impl GrammarParser { static __RULES : [u8; 2usize] = [44, 45,]; static __SHIFTED : [u8; 2usize] = [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::True, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(114, false)),], @@ -9153,7 +9265,8 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [44,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9162,7 +9275,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [44,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(116, false)),], @@ -9170,7 +9284,8 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9179,7 +9294,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), @@ -9277,7 +9393,8 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9286,7 +9403,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [47,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)), @@ -9382,7 +9500,8 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9391,7 +9510,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), @@ -9489,7 +9609,8 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9498,7 +9619,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [49,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)), @@ -9594,7 +9716,8 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9603,7 +9726,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [48,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), @@ -9701,7 +9825,8 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9710,7 +9835,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [57,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)), @@ -9806,7 +9932,8 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9815,7 +9942,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [56,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), @@ -9913,7 +10041,8 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -9922,7 +10051,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [59,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)), @@ -10018,7 +10148,8 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10027,7 +10158,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [58,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(134, false)), @@ -10037,7 +10169,8 @@ impl GrammarParser { static __RULES : [u8; 2usize] = [62, 63,]; static __SHIFTED : [u8; 2usize] = [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::True, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10046,7 +10179,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [62,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(136, false)),], @@ -10054,7 +10188,8 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [63,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10063,7 +10198,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [63,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(138, false)), @@ -10073,7 +10209,8 @@ impl GrammarParser { static __RULES : [u8; 2usize] = [60, 61,]; static __SHIFTED : [u8; 2usize] = [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::True, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10082,7 +10219,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [60,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(140, false)),], @@ -10090,7 +10228,8 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [61,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10099,7 +10238,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [61,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)), @@ -10115,7 +10255,8 @@ impl GrammarParser { 55, 143, 144,]; static __SHIFTED : [u8; 6usize] = [0, 0, 2, 2, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::True, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(143, false)),], @@ -10123,7 +10264,8 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [55,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10132,7 +10274,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [55,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)), @@ -10146,7 +10289,8 @@ impl GrammarParser { 144,]; static __SHIFTED : [u8; 4usize] = [0, 0, 3, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10155,7 +10299,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [54,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(147, false)), @@ -10165,7 +10310,8 @@ impl GrammarParser { static __RULES : [u8; 2usize] = [64, 65,]; static __SHIFTED : [u8; 2usize] = [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::True, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10174,7 +10320,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [64,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(149, false)),], @@ -10182,7 +10329,8 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [65,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10191,7 +10339,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [65,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(151, false)), @@ -10201,7 +10350,8 @@ impl GrammarParser { static __RULES : [u8; 2usize] = [66, 67,]; static __SHIFTED : [u8; 2usize] = [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::True, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10210,7 +10360,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [66,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(153, false)),], @@ -10218,7 +10369,8 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [67,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10227,7 +10379,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [67,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(155, true)), @@ -10244,7 +10397,8 @@ impl GrammarParser { 69, 145, 146, 147, 148,]; static __SHIFTED : [u8; 6usize] = [2, 2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : true, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::True, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10253,7 +10407,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [145,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(157, false)),], @@ -10261,7 +10416,8 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [69,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10270,7 +10426,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [69,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(159, true)),], @@ -10281,7 +10438,8 @@ impl GrammarParser { { static __RULES : [u8; 2usize] = [146, 147,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10290,7 +10448,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [146,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(161, false)),], @@ -10298,7 +10457,8 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [68,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10307,7 +10467,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [68,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), @@ -10405,7 +10566,8 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10414,7 +10576,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [71,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)), @@ -10510,7 +10673,8 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10519,7 +10683,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [70,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), @@ -10617,7 +10782,8 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10626,7 +10792,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [73,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)), @@ -10722,7 +10889,8 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10731,7 +10899,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [72,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(171, false)),], @@ -10739,7 +10908,8 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [74,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10748,7 +10918,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [74,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10757,7 +10928,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [75,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(1, true)), @@ -10781,7 +10953,8 @@ impl GrammarParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -10790,7 +10963,8 @@ impl GrammarParser { { static __RULES : [u8; 1usize] = [150,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::eof, ::rusty_lr_core::parser::state::ShiftTarget::new(176, true)),], @@ -10798,13 +10972,15 @@ impl GrammarParser { static __RULES : [u8; 1usize] = [151,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 1usize] = [151,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, + shifted : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr_core::TriState::False, }, ]; let states: Vec = states .into_iter() diff --git a/scripts/diff/calculator.rs b/scripts/diff/calculator.rs index 69a1289..e8f8398 100644 --- a/scripts/diff/calculator.rs +++ b/scripts/diff/calculator.rs @@ -721,7 +721,7 @@ impl EParser { 4, 5, 6, 7,]; static __SHIFTED : [u8; 8usize] = [0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -730,7 +730,7 @@ impl EParser { { static __RULES : [u8; 1usize] = [4,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::num, ::rusty_lr::parser::state::ShiftTarget::new(1, true)), (ETerminalClasses::lparen, @@ -744,7 +744,7 @@ impl EParser { 4, 5, 5, 6,]; static __SHIFTED : [u8; 8usize] = [0, 0, 0, 0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::plus, ::rusty_lr::parser::state::ShiftTarget::new(4, true)),], shift_goto_map_nonterm : vec![], reduce_map : { let mut @@ -754,12 +754,12 @@ impl EParser { ruleset : { static __RULES : [u8; 2usize] = [0, 6,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() }, can_accept_error : false, }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(ETerminalClasses::num, ::rusty_lr::parser::state::ShiftTarget::new(1, - true)), (ETerminalClasses::lparen, - ::rusty_lr::parser::state::ShiftTarget::new(2, false)),], - shift_goto_map_nonterm : vec![(ENonTerminals::A, + : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState + { shift_goto_map_term : vec![(ETerminalClasses::num, + ::rusty_lr::parser::state::ShiftTarget::new(1, true)), + (ETerminalClasses::lparen, ::rusty_lr::parser::state::ShiftTarget::new(2, + false)),], shift_goto_map_nonterm : vec![(ENonTerminals::A, ::rusty_lr::parser::state::ShiftTarget::new(5, true)), (ENonTerminals::M, ::rusty_lr::parser::state::ShiftTarget::new(6, true)), (ENonTerminals::P, ::rusty_lr::parser::state::ShiftTarget::new(6, true)),], reduce_map : @@ -767,7 +767,7 @@ impl EParser { 3, 4, 5,]; static __SHIFTED : [u8; 7usize] = [0, 2, 0, 0, 0, 0, 0,]; __RULES .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -776,7 +776,7 @@ impl EParser { { static __RULES : [u8; 1usize] = [0,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::star, ::rusty_lr::parser::state::ShiftTarget::new(7, false)),], shift_goto_map_nonterm : vec![], reduce_map : { let mut @@ -786,19 +786,19 @@ impl EParser { ruleset : { static __RULES : [u8; 2usize] = [1, 2,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() }, can_accept_error : false, }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(ETerminalClasses::num, ::rusty_lr::parser::state::ShiftTarget::new(1, - true)), (ETerminalClasses::lparen, - ::rusty_lr::parser::state::ShiftTarget::new(2, false)),], - shift_goto_map_nonterm : vec![(ENonTerminals::M, + : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState + { shift_goto_map_term : vec![(ETerminalClasses::num, + ::rusty_lr::parser::state::ShiftTarget::new(1, true)), + (ETerminalClasses::lparen, ::rusty_lr::parser::state::ShiftTarget::new(2, + false)),], shift_goto_map_nonterm : vec![(ENonTerminals::M, ::rusty_lr::parser::state::ShiftTarget::new(8, true)), (ENonTerminals::P, ::rusty_lr::parser::state::ShiftTarget::new(8, true)),], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 5usize] = [2, 2, 3, 4, 5,]; static __SHIFTED : [u8; 5usize] = [0, 2, 0, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -807,7 +807,7 @@ impl EParser { { static __RULES : [u8; 1usize] = [2,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::rparen, ::rusty_lr::parser::state::ShiftTarget::new(10, false)),], @@ -815,7 +815,7 @@ impl EParser { static __RULES : [u8; 1usize] = [5,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -824,20 +824,21 @@ impl EParser { { static __RULES : [u8; 1usize] = [5,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::eof, ::rusty_lr::parser::state::ShiftTarget::new(12, true)),], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 1usize] = [7,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() }, can_accept_error : false, }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], - shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { - static __RULES : [u8; 1usize] = [7,]; static __SHIFTED : [u8; 1usize] = [2,]; - __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { - ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState + { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 1usize] = [7,]; static + __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr::TriState::False, }, ]; let states: Vec = states.into_iter().map(|state| state.into()).collect(); Self { rules, states } diff --git a/scripts/diff/calculator_u8.rs b/scripts/diff/calculator_u8.rs index 7cfe402..dc47719 100644 --- a/scripts/diff/calculator_u8.rs +++ b/scripts/diff/calculator_u8.rs @@ -1028,7 +1028,7 @@ impl EParser { 12, 13, 16,]; static __SHIFTED : [u8; 11usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -1037,7 +1037,7 @@ impl EParser { { static __RULES : [u8; 1usize] = [3,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass7, ::rusty_lr::parser::state::ShiftTarget::new(4, true)), @@ -1050,13 +1050,13 @@ impl EParser { 16,]; static __SHIFTED : [u8; 4usize] = [1, 0, 0, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 1usize] = [16,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(6, false)),], @@ -1075,7 +1075,7 @@ impl EParser { 12, 13,]; static __SHIFTED : [u8; 11usize] = [0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass7, ::rusty_lr::parser::state::ShiftTarget::new(4, true)), @@ -1088,9 +1088,9 @@ impl EParser { ruleset : { static __RULES : [u8; 4usize] = [5, 5, 8, 9,]; static __SHIFTED : [u8; 4usize] = [1, 3, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(ETerminalClasses::TermClass0, + shifted : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState + { shift_goto_map_term : vec![(ETerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(7, false)),], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -1099,7 +1099,7 @@ impl EParser { { static __RULES : [u8; 2usize] = [11, 12,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -1108,7 +1108,7 @@ impl EParser { { static __RULES : [u8; 1usize] = [11,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass2, ::rusty_lr::parser::state::ShiftTarget::new(9, false)), @@ -1125,9 +1125,9 @@ impl EParser { 7usize] = [0, 1, 2, 4, 6, 14, 15,]; static __SHIFTED : [u8; 7usize] = [0, 0, 1, 1, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() }, can_accept_error : false, }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(ETerminalClasses::TermClass0, + : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState + { shift_goto_map_term : vec![(ETerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(6, false)),], shift_goto_map_nonterm : vec![(ENonTerminals::Number, ::rusty_lr::parser::state::ShiftTarget::new(1, true)), (ENonTerminals::P, @@ -1144,7 +1144,7 @@ impl EParser { 12, 13,]; static __SHIFTED : [u8; 11usize] = [0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass3, ::rusty_lr::parser::state::ShiftTarget::new(11, false)), @@ -1158,7 +1158,7 @@ impl EParser { 9,]; static __SHIFTED : [u8; 4usize] = [3, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(6, false)),], @@ -1173,17 +1173,18 @@ impl EParser { __SHIFTED : [u8; 5usize] = [4, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [4]; __reduce_map.extend(__RUSTYLR_TSET1 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [4,]; - static __SHIFTED : [u8; 1usize] = [5,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : - false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term - : vec![(ETerminalClasses::TermClass0, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [4]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [4,]; static __SHIFTED : [u8; 1usize] = + [5,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(ETerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(6, false)),], shift_goto_map_nonterm : vec![(ENonTerminals::Number, ::rusty_lr::parser::state::ShiftTarget::new(1, true)), (ENonTerminals::P, @@ -1200,7 +1201,7 @@ impl EParser { 12, 13,]; static __SHIFTED : [u8; 11usize] = [0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass7, ::rusty_lr::parser::state::ShiftTarget::new(13, true)), @@ -1214,9 +1215,9 @@ impl EParser { ruleset : { static __RULES : [u8; 4usize] = [5, 5, 8, 9,]; static __SHIFTED : [u8; 4usize] = [1, 3, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(ETerminalClasses::TermClass2, + shifted : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState + { shift_goto_map_term : vec![(ETerminalClasses::TermClass2, ::rusty_lr::parser::state::ShiftTarget::new(9, false)), (ETerminalClasses::TermClass4, ::rusty_lr::parser::state::ShiftTarget::new(16, false)), @@ -1231,9 +1232,9 @@ impl EParser { 7usize] = [0, 1, 2, 4, 6, 14, 15,]; static __SHIFTED : [u8; 7usize] = [0, 0, 1, 1, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() }, can_accept_error : false, }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(ETerminalClasses::TermClass0, + : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState + { shift_goto_map_term : vec![(ETerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(6, false)),], shift_goto_map_nonterm : vec![(ENonTerminals::Number, ::rusty_lr::parser::state::ShiftTarget::new(1, true)), (ENonTerminals::P, @@ -1250,7 +1251,7 @@ impl EParser { 12, 13,]; static __SHIFTED : [u8; 11usize] = [0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![(ENonTerminals::Op, ::rusty_lr::parser::state::ShiftTarget::new(13, true)),], reduce_map : { let @@ -1260,27 +1261,27 @@ impl EParser { ruleset : { static __RULES : [u8; 2usize] = [5, 6,]; static __SHIFTED : [u8; 2usize] = [1, 3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() }, can_accept_error : false, }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = - [0]; __reduce_map.extend(__RUSTYLR_TSET6.iter().map(| term | (* term, - __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : - { static __RULES : [u8; 1usize] = [0,]; static __SHIFTED : [u8; 1usize] = - [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { - ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = - [14]; __reduce_map.extend(__RUSTYLR_TSET6.iter().map(| term | (* term, - __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : - { static __RULES : [u8; 1usize] = [14,]; static __SHIFTED : [u8; 1usize] = - [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { - ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(ETerminalClasses::TermClass0, + : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState + { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : + { let mut __reduce_map = std::collections::BTreeMap::new(); { static + __REDUCE_RULES : [u8; 1usize] = [0]; __reduce_map.extend(__RUSTYLR_TSET6 + .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map + .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [0,]; + static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState + { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : + { let mut __reduce_map = std::collections::BTreeMap::new(); { static + __REDUCE_RULES : [u8; 1usize] = [14]; __reduce_map.extend(__RUSTYLR_TSET6 + .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map + .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [14,]; + static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState + { shift_goto_map_term : vec![(ETerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(6, false)), (ETerminalClasses::TermClass5, ::rusty_lr::parser::state::ShiftTarget::new(18, false)), @@ -1299,7 +1300,7 @@ impl EParser { 15,]; static __SHIFTED : [u8; 8usize] = [0, 0, 2, 0, 0, 0, 0, 1,]; __RULES .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -1308,7 +1309,7 @@ impl EParser { { static __RULES : [u8; 1usize] = [15,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -1317,7 +1318,7 @@ impl EParser { { static __RULES : [u8; 1usize] = [2,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(6, false)),], @@ -1336,7 +1337,7 @@ impl EParser { 12, 13,]; static __SHIFTED : [u8; 11usize] = [0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![(ENonTerminals::Op, ::rusty_lr::parser::state::ShiftTarget::new(4, true)),], reduce_map : { let @@ -1346,7 +1347,8 @@ impl EParser { ruleset : { static __RULES : [u8; 2usize] = [5, 6,]; static __SHIFTED : [u8; 2usize] = [1, 3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() }, can_accept_error : false, }, + : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr::TriState::False, }, ]; let states: Vec = states.into_iter().map(|state| state.into()).collect(); Self { rules, states } diff --git a/scripts/diff/json.rs b/scripts/diff/json.rs index 01bfa36..37b5038 100644 --- a/scripts/diff/json.rs +++ b/scripts/diff/json.rs @@ -2025,7 +2025,7 @@ impl JsonParser { static __SHIFTED : [u8; 7usize] = [0, 0, 0, 0, 0, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(1, false)), @@ -2042,8 +2042,9 @@ impl JsonParser { __SHIFTED : [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(1, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(2, false)),], @@ -2058,24 +2059,25 @@ impl JsonParser { __SHIFTED : [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [43]; __reduce_map.extend(__RUSTYLR_TSET1 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [43,]; - static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : - false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term - : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : - [u8; 1usize] = [44]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | - (* term, __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, - ruleset : { static __RULES : [u8; 1usize] = [44,]; static __SHIFTED : [u8; - 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() }, can_accept_error : false, }, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [43]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [43,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [44]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [44,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::eof, ::rusty_lr::parser::state::ShiftTarget::new(6, true)),], @@ -2083,13 +2085,13 @@ impl JsonParser { static __RULES : [u8; 1usize] = [98,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 1usize] = [98,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(8, false)), @@ -2131,15 +2133,15 @@ impl JsonParser { static __SHIFTED : [u8; 23usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass22, + shifted : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState + { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass22, ::rusty_lr::parser::state::ShiftTarget::new(9, false)),], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass24, ::rusty_lr::parser::state::ShiftTarget::new(10, false)),], @@ -2147,7 +2149,7 @@ impl JsonParser { static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass25, ::rusty_lr::parser::state::ShiftTarget::new(11, false)),], @@ -2155,7 +2157,7 @@ impl JsonParser { static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass19, ::rusty_lr::parser::state::ShiftTarget::new(12, false)),], @@ -2163,7 +2165,7 @@ impl JsonParser { static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -2172,7 +2174,7 @@ impl JsonParser { { static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] = [5,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass26, ::rusty_lr::parser::state::ShiftTarget::new(14, false)),], @@ -2180,7 +2182,7 @@ impl JsonParser { static __RULES : [u8; 1usize] = [47,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass24, ::rusty_lr::parser::state::ShiftTarget::new(15, false)),], @@ -2188,7 +2190,7 @@ impl JsonParser { static __RULES : [u8; 1usize] = [47,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass24, ::rusty_lr::parser::state::ShiftTarget::new(16, false)),], @@ -2196,7 +2198,7 @@ impl JsonParser { static __RULES : [u8; 1usize] = [47,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -2205,7 +2207,7 @@ impl JsonParser { { static __RULES : [u8; 1usize] = [47,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass8, ::rusty_lr::parser::state::ShiftTarget::new(18, false)),], @@ -2213,7 +2215,7 @@ impl JsonParser { static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass26, ::rusty_lr::parser::state::ShiftTarget::new(19, false)),], @@ -2221,7 +2223,7 @@ impl JsonParser { static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass19, ::rusty_lr::parser::state::ShiftTarget::new(20, false)),], @@ -2229,7 +2231,7 @@ impl JsonParser { static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -2238,7 +2240,7 @@ impl JsonParser { { static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(26, false)), @@ -2250,7 +2252,7 @@ impl JsonParser { 93,]; static __SHIFTED : [u8; 4usize] = [1, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(24, false)), @@ -2267,7 +2269,7 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [2, 0, 0, 0, 0, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -2276,7 +2278,7 @@ impl JsonParser { { static __RULES : [u8; 1usize] = [35,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(24, false)), @@ -2293,7 +2295,7 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -2302,7 +2304,7 @@ impl JsonParser { { static __RULES : [u8; 1usize] = [91,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -2311,7 +2313,7 @@ impl JsonParser { { static __RULES : [u8; 1usize] = [34,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(24, false)), @@ -2328,7 +2330,7 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [1, 0, 0, 0, 0, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -2337,7 +2339,7 @@ impl JsonParser { { static __RULES : [u8; 1usize] = [33,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(1, false)), @@ -2361,7 +2363,7 @@ impl JsonParser { 51, 97,]; static __SHIFTED : [u8; 10usize] = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass12, ::rusty_lr::parser::state::ShiftTarget::new(31, false)),], @@ -2372,7 +2374,7 @@ impl JsonParser { { static __RULES : [u8; 2usize] = [48, 49,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(1, false)), @@ -2392,7 +2394,7 @@ impl JsonParser { 97,]; static __SHIFTED : [u8; 8usize] = [0, 0, 0, 0, 0, 0, 2, 0,]; __RULES .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(8, false)), @@ -2434,9 +2436,9 @@ impl JsonParser { static __SHIFTED : [u8; 23usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass14, + shifted : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState + { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(26, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(34, false)),], @@ -2446,7 +2448,7 @@ impl JsonParser { 93,]; static __SHIFTED : [u8; 4usize] = [1, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(35, false)), @@ -2463,7 +2465,7 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [2, 0, 0, 0, 0, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(35, false)), @@ -2480,7 +2482,7 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(35, false)), @@ -2497,7 +2499,7 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [1, 0, 0, 0, 0, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass21, ::rusty_lr::parser::state::ShiftTarget::new(38, false)),], @@ -2505,7 +2507,7 @@ impl JsonParser { static __RULES : [u8; 1usize] = [14,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -2514,7 +2516,7 @@ impl JsonParser { { static __RULES : [u8; 1usize] = [14,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(40, false)), @@ -2535,7 +2537,7 @@ impl JsonParser { 43, 44, 97,]; static __SHIFTED : [u8; 10usize] = [1, 1, 1, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : true, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::True, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(40, false)), @@ -2552,8 +2554,9 @@ impl JsonParser { __SHIFTED : [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(40, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(41, false)),], @@ -2568,14 +2571,15 @@ impl JsonParser { __SHIFTED : [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass28, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass28, ::rusty_lr::parser::state::ShiftTarget::new(43, false)),], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 1usize] = [10,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -2584,7 +2588,7 @@ impl JsonParser { { static __RULES : [u8; 1usize] = [10,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass28, ::rusty_lr::parser::state::ShiftTarget::new(45, false)),], @@ -2592,7 +2596,7 @@ impl JsonParser { static __RULES : [u8; 1usize] = [9,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -2601,7 +2605,7 @@ impl JsonParser { { static __RULES : [u8; 1usize] = [9,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass12, ::rusty_lr::parser::state::ShiftTarget::new(47, false)),], @@ -2612,7 +2616,7 @@ impl JsonParser { { static __RULES : [u8; 2usize] = [11, 12,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(48, false)), @@ -2632,7 +2636,7 @@ impl JsonParser { 97,]; static __SHIFTED : [u8; 8usize] = [0, 0, 2, 0, 0, 0, 0, 0,]; __RULES .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(48, false)), @@ -2649,8 +2653,9 @@ impl JsonParser { __SHIFTED : [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(48, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(49, false)),], @@ -2665,17 +2670,18 @@ impl JsonParser { __SHIFTED : [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [12]; __reduce_map.extend(__RUSTYLR_TSET8 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [12,]; - static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : - false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term - : vec![(JsonTerminalClasses::TermClass29, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [12]; __reduce_map.extend(__RUSTYLR_TSET8.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [12,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass29, ::rusty_lr::parser::state::ShiftTarget::new(52, false)),], shift_goto_map_nonterm : vec![(JsonNonTerminals::String, ::rusty_lr::parser::state::ShiftTarget::new(64, true)),], reduce_map : @@ -2683,8 +2689,9 @@ impl JsonParser { static __SHIFTED : [u8; 2usize] = [1, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass1, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(60, false)), (JsonTerminalClasses::TermClass3, ::rusty_lr::parser::state::ShiftTarget::new(60, false)), @@ -2757,9 +2764,9 @@ impl JsonParser { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() }, can_accept_error : false, }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass4, + : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState + { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass4, ::rusty_lr::parser::state::ShiftTarget::new(59, false)), (JsonTerminalClasses::TermClass5, ::rusty_lr::parser::state::ShiftTarget::new(59, false)), @@ -2783,9 +2790,9 @@ impl JsonParser { 21, 22, 23, 24, 25, 26, 27,]; static __SHIFTED : [u8; 10usize] = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() }, can_accept_error : false, }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass5, + : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState + { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass5, ::rusty_lr::parser::state::ShiftTarget::new(55, false)), (JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(55, false)), @@ -2816,8 +2823,9 @@ impl JsonParser { [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass5, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass5, ::rusty_lr::parser::state::ShiftTarget::new(56, false)), (JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(56, false)), @@ -2848,8 +2856,9 @@ impl JsonParser { [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass5, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass5, ::rusty_lr::parser::state::ShiftTarget::new(57, false)), (JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(57, false)), @@ -2880,8 +2889,9 @@ impl JsonParser { [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass5, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass5, ::rusty_lr::parser::state::ShiftTarget::new(58, false)), (JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(58, false)), @@ -2912,24 +2922,25 @@ impl JsonParser { [4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [27]; __reduce_map.extend(__RUSTYLR_TSET10 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [27,]; - static __SHIFTED : [u8; 1usize] = [5,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : - false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term - : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : - [u8; 1usize] = [17]; __reduce_map.extend(__RUSTYLR_TSET10.iter().map(| term | - (* term, __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, - ruleset : { static __RULES : [u8; 1usize] = [17,]; static __SHIFTED : [u8; - 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() }, can_accept_error : false, }, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [27]; __reduce_map.extend(__RUSTYLR_TSET10.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [27,]; static __SHIFTED : [u8; 1usize] = + [5,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [17]; __reduce_map.extend(__RUSTYLR_TSET10.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [17,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(60, false)), @@ -3002,7 +3013,7 @@ impl JsonParser { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -3011,7 +3022,7 @@ impl JsonParser { { static __RULES : [u8; 1usize] = [53,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass29, ::rusty_lr::parser::state::ShiftTarget::new(63, false)),], @@ -3019,7 +3030,7 @@ impl JsonParser { static __RULES : [u8; 1usize] = [16,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -3028,7 +3039,7 @@ impl JsonParser { { static __RULES : [u8; 1usize] = [16,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(65, false)), @@ -3045,8 +3056,9 @@ impl JsonParser { __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(65, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(66, false)),], @@ -3061,8 +3073,9 @@ impl JsonParser { __SHIFTED : [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(65, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(66, false)),], @@ -3077,14 +3090,15 @@ impl JsonParser { __SHIFTED : [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass16, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass16, ::rusty_lr::parser::state::ShiftTarget::new(68, false)),], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { static __RULES : [u8; 1usize] = [13,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(1, false)), @@ -3102,7 +3116,7 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [4, 0, 0, 0, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -3111,7 +3125,7 @@ impl JsonParser { { static __RULES : [u8; 1usize] = [13,]; static __SHIFTED : [u8; 1usize] = [5,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(8, false)), @@ -3153,9 +3167,9 @@ impl JsonParser { static __SHIFTED : [u8; 23usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() }, can_accept_error : false, }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass14, + shifted : shifted as usize, } }).collect() }, can_accept_error : + ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState + { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(26, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(72, false)),], @@ -3165,7 +3179,7 @@ impl JsonParser { 93,]; static __SHIFTED : [u8; 4usize] = [1, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(73, false)), @@ -3182,7 +3196,7 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [2, 0, 0, 0, 0, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(73, false)), @@ -3199,7 +3213,7 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(73, false)), @@ -3216,7 +3230,7 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [1, 0, 0, 0, 0, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass28, ::rusty_lr::parser::state::ShiftTarget::new(76, false)), @@ -3228,17 +3242,18 @@ impl JsonParser { static __SHIFTED : [u8; 3usize] = [2, 1, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [8]; __reduce_map.extend(__RUSTYLR_TSET2 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [8,]; - static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : - false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term - : vec![(JsonTerminalClasses::TermClass0, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [8]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [8,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(78, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(79, false)),], @@ -3253,8 +3268,9 @@ impl JsonParser { __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(78, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(79, false)),], @@ -3269,8 +3285,9 @@ impl JsonParser { __SHIFTED : [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(78, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(79, false)),], @@ -3285,17 +3302,18 @@ impl JsonParser { __SHIFTED : [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); { static - __REDUCE_RULES : [u8; 1usize] = [15]; __reduce_map.extend(__RUSTYLR_TSET15 - .iter().map(| term | (* term, __REDUCE_RULES.to_vec()))); } __reduce_map - .into_iter().collect() }, ruleset : { static __RULES : [u8; 1usize] = [15,]; - static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() }, can_accept_error : - false, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term - : vec![(JsonTerminalClasses::TermClass13, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], + shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = + [15]; __reduce_map.extend(__RUSTYLR_TSET15.iter().map(| term | (* term, + __REDUCE_RULES.to_vec()))); } __reduce_map.into_iter().collect() }, ruleset : + { static __RULES : [u8; 1usize] = [15,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass13, ::rusty_lr::parser::state::ShiftTarget::new(82, false)),], shift_goto_map_nonterm : vec![(JsonNonTerminals::_Group34, ::rusty_lr::parser::state::ShiftTarget::new(85, false)), @@ -3308,8 +3326,9 @@ impl JsonParser { __SHIFTED : [u8; 4usize] = [1, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(84, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(84, false)),], @@ -3321,7 +3340,7 @@ impl JsonParser { 93, 94,]; static __SHIFTED : [u8; 5usize] = [0, 0, 0, 0, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -3330,7 +3349,7 @@ impl JsonParser { { static __RULES : [u8; 1usize] = [94,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(84, false)), @@ -3347,7 +3366,7 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass18, ::rusty_lr::parser::state::ShiftTarget::new(86, false)), @@ -3364,8 +3383,9 @@ impl JsonParser { __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass10, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass10, ::rusty_lr::parser::state::ShiftTarget::new(87, false)), (JsonTerminalClasses::TermClass11, ::rusty_lr::parser::state::ShiftTarget::new(87, false)),], @@ -3380,8 +3400,9 @@ impl JsonParser { __SHIFTED : [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(89, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(89, false)),], @@ -3393,7 +3414,7 @@ impl JsonParser { 92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -3402,7 +3423,7 @@ impl JsonParser { { static __RULES : [u8; 1usize] = [37,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(89, false)), @@ -3419,7 +3440,7 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass10, ::rusty_lr::parser::state::ShiftTarget::new(91, false)), @@ -3436,8 +3457,9 @@ impl JsonParser { __SHIFTED : [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(89, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(89, false)),], @@ -3449,7 +3471,7 @@ impl JsonParser { 92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -3458,7 +3480,7 @@ impl JsonParser { { static __RULES : [u8; 1usize] = [38,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -3467,7 +3489,7 @@ impl JsonParser { { static __RULES : [u8; 1usize] = [31,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(95, false)), @@ -3484,8 +3506,9 @@ impl JsonParser { __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(95, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(96, false)),], @@ -3500,8 +3523,9 @@ impl JsonParser { __SHIFTED : [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(95, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(96, false)),], @@ -3516,8 +3540,9 @@ impl JsonParser { __SHIFTED : [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass13, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass13, ::rusty_lr::parser::state::ShiftTarget::new(98, false)),], shift_goto_map_nonterm : vec![(JsonNonTerminals::_Group34, ::rusty_lr::parser::state::ShiftTarget::new(100, false)), @@ -3530,8 +3555,9 @@ impl JsonParser { __SHIFTED : [u8; 4usize] = [1, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(99, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(99, false)),], @@ -3543,7 +3569,7 @@ impl JsonParser { 93, 94,]; static __SHIFTED : [u8; 5usize] = [0, 0, 0, 0, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(99, false)), @@ -3560,7 +3586,7 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass18, ::rusty_lr::parser::state::ShiftTarget::new(101, false)), @@ -3577,8 +3603,9 @@ impl JsonParser { __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass10, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass10, ::rusty_lr::parser::state::ShiftTarget::new(102, false)), (JsonTerminalClasses::TermClass11, ::rusty_lr::parser::state::ShiftTarget::new(102, false)),], @@ -3593,7 +3620,7 @@ impl JsonParser { 39, 40, 41, 97,]; static __SHIFTED : [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(103, false)), @@ -3607,7 +3634,7 @@ impl JsonParser { 92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(103, false)), @@ -3624,7 +3651,7 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass10, ::rusty_lr::parser::state::ShiftTarget::new(105, false)), @@ -3641,7 +3668,7 @@ impl JsonParser { 39, 40, 41, 97,]; static __SHIFTED : [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(103, false)), @@ -3655,7 +3682,7 @@ impl JsonParser { 92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -3664,7 +3691,7 @@ impl JsonParser { { static __RULES : [u8; 1usize] = [49,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(108, false)), @@ -3681,8 +3708,9 @@ impl JsonParser { __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(108, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(109, false)),], @@ -3697,8 +3725,9 @@ impl JsonParser { __SHIFTED : [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(108, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(109, false)),], @@ -3713,8 +3742,9 @@ impl JsonParser { __SHIFTED : [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass13, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass13, ::rusty_lr::parser::state::ShiftTarget::new(111, false)),], shift_goto_map_nonterm : vec![(JsonNonTerminals::_Group34, ::rusty_lr::parser::state::ShiftTarget::new(113, false)), @@ -3727,8 +3757,9 @@ impl JsonParser { __SHIFTED : [u8; 4usize] = [1, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(112, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(112, false)),], @@ -3740,7 +3771,7 @@ impl JsonParser { 93, 94,]; static __SHIFTED : [u8; 5usize] = [0, 0, 0, 0, 1,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(112, false)), @@ -3757,7 +3788,7 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass18, ::rusty_lr::parser::state::ShiftTarget::new(114, false)), @@ -3774,8 +3805,9 @@ impl JsonParser { __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() }, - can_accept_error : false, }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass10, + can_accept_error : ::rusty_lr::TriState::False, }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(JsonTerminalClasses::TermClass10, ::rusty_lr::parser::state::ShiftTarget::new(115, false)), (JsonTerminalClasses::TermClass11, ::rusty_lr::parser::state::ShiftTarget::new(115, false)),], @@ -3790,7 +3822,7 @@ impl JsonParser { 39, 40, 41, 97,]; static __SHIFTED : [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(116, false)), @@ -3804,7 +3836,7 @@ impl JsonParser { 92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(116, false)), @@ -3821,7 +3853,7 @@ impl JsonParser { static __SHIFTED : [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass10, ::rusty_lr::parser::state::ShiftTarget::new(118, false)), @@ -3838,7 +3870,7 @@ impl JsonParser { 39, 40, 41, 97,]; static __SHIFTED : [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(116, false)), @@ -3852,7 +3884,7 @@ impl JsonParser { 92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter() .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as - usize, } }).collect() }, can_accept_error : false, }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ]; let states: Vec = states .into_iter() From 831fccf83b6b46e6218d8090db078ecc0bc31ab1 Mon Sep 17 00:00:00 2001 From: Taehwan Kim Date: Tue, 7 Oct 2025 10:27:57 +0900 Subject: [PATCH 7/8] fixed deterministic logics --- .../src/parser/deterministic/context.rs | 150 +++++++++++------- .../src/parser/nondeterministic/context.rs | 2 + rusty_lr_core/src/parser/state.rs | 16 +- 3 files changed, 99 insertions(+), 69 deletions(-) diff --git a/rusty_lr_core/src/parser/deterministic/context.rs b/rusty_lr_core/src/parser/deterministic/context.rs index 08dd977..5b1fa71 100644 --- a/rusty_lr_core/src/parser/deterministic/context.rs +++ b/rusty_lr_core/src/parser/deterministic/context.rs @@ -270,79 +270,109 @@ impl Context { } let error_prec = P::TermClass::ERROR.precedence(); - let mut error_location = Data::Location::new(self.location_stack.iter().rev(), 0); - loop { - if let Some(s) = self.state_stack.last() { - if parser.get_states()[s.into_usize()].can_accept_error() { - match self.feed_location_impl( + + let mut extra_state_stack = Vec::new(); + let mut extra_precedence_stack = Vec::new(); + + use crate::TriState; + let mut pop_count = 0; + let mut found = false; + for &s in self.state_stack.iter().rev() { + match parser.get_states()[s.into_usize()].can_accept_error() { + TriState::False => {} + TriState::Maybe => { + extra_precedence_stack.clear(); + extra_state_stack.clear(); + + if self.can_feed_impl( + self.precedence_stack.len() - pop_count, + &mut extra_state_stack, + &mut extra_precedence_stack, parser, - TerminalSymbol::Error, P::TermClass::ERROR, error_prec, - userdata, - Some(error_location), - ) { - Ok(()) => break, // successfully shifted `error` - Err(ParseError::NoAction(err1)) => { - error_location = err1.location.unwrap(); - } - Err(_) => return Err(ParseError::NoAction(err)), // other errors + ) == Some(true) + { + found = true; + break; } } - - error_location = Data::Location::new( - std::iter::once(&error_location) - .chain(self.location_stack.iter().rev()), - 2, - ); - - self.location_stack.pop(); - self.state_stack.pop(); - self.precedence_stack.pop(); - self.data_stack.pop(); - #[cfg(feature = "tree")] - self.tree_stack.pop(); - } else { - return Err(ParseError::NoAction(err)); + TriState::True => { + found = true; + break; + } } + + self.data_stack.pop(); + pop_count += 1; } - // try shift given term again - // to check if the given terminal should be merged with `error` token - // or it can be shift right after the error token - if let Some(next_state) = parser.get_states() - [self.state_stack.last().unwrap().into_usize()] - .shift_goto_class(class) - { - #[cfg(feature = "tree")] - self.tree_stack - .push(crate::tree::Tree::new_terminal(err.term.clone())); + if !found { + return Err(ParseError::NoAction(err)); + } - // shift after `error` token - if next_state.push { - self.data_stack.push_terminal(err.term.into_term().unwrap()); - } else { - self.data_stack.push_empty(); - } + let error_location = + Data::Location::new(self.location_stack.iter().rev(), pop_count); + self.location_stack + .truncate(self.location_stack.len() - pop_count); + self.state_stack + .truncate(self.state_stack.len() - pop_count); + self.precedence_stack + .truncate(self.precedence_stack.len() - pop_count); + #[cfg(feature = "tree")] + { + let l = self.tree_stack.len() - pop_count; + self.tree_stack.truncate(l); + } - self.location_stack.push(err.location.unwrap()); - self.precedence_stack.push(shift_prec); - self.state_stack.push(next_state.state); - } else { - // merge term with previous error + match self.feed_location_impl( + parser, + TerminalSymbol::Error, + P::TermClass::ERROR, + error_prec, + userdata, + Some(error_location), + ) { + Ok(()) => { + // try shift given term again + // to check if the given terminal should be merged with `error` token + // or it can be shift right after the error token + if let Some(next_state) = parser.get_states() + [self.state_stack.last().unwrap().into_usize()] + .shift_goto_class(class) + { + #[cfg(feature = "tree")] + self.tree_stack + .push(crate::tree::Tree::new_terminal(err.term.clone())); + + // shift after `error` token + if next_state.push { + self.data_stack.push_terminal(err.term.into_term().unwrap()); + } else { + self.data_stack.push_empty(); + } - let error_location = Data::Location::new( - std::iter::once(&err.location.unwrap()) - .chain(self.location_stack.iter().rev()), - 2, // error node - ); - if let Some(err_loc) = self.location_stack.last_mut() { - *err_loc = error_location; - } else { - unreachable!("location stack must have at least one element"); + self.location_stack.push(err.location.unwrap()); + self.precedence_stack.push(shift_prec); + self.state_stack.push(next_state.state); + } else { + // merge term with previous error + + let error_location = Data::Location::new( + std::iter::once(&err.location.unwrap()) + .chain(self.location_stack.iter().rev()), + 2, // error node + ); + if let Some(err_loc) = self.location_stack.last_mut() { + *err_loc = error_location; + } else { + unreachable!("location stack must have at least one element"); + } + } + Ok(()) } + Err(_) => Err(ParseError::NoAction(err)), // other errors } - Ok(()) } Err(err) => Err(err), } diff --git a/rusty_lr_core/src/parser/nondeterministic/context.rs b/rusty_lr_core/src/parser/nondeterministic/context.rs index 5437135..41ba94c 100644 --- a/rusty_lr_core/src/parser/nondeterministic/context.rs +++ b/rusty_lr_core/src/parser/nondeterministic/context.rs @@ -1240,6 +1240,7 @@ impl P::NonTerm: std::fmt::Debug, P::State: State, { + /* use crate::Location; let mut error_location = Data::Location::new(self.location_iter(node), 0); @@ -1286,6 +1287,7 @@ impl unreachable!("state stack is empty but node is not root"); } } + */ } /// Feed one terminal with location to parser, and update state stack. diff --git a/rusty_lr_core/src/parser/state.rs b/rusty_lr_core/src/parser/state.rs index 0b8bcb7..f684169 100644 --- a/rusty_lr_core/src/parser/state.rs +++ b/rusty_lr_core/src/parser/state.rs @@ -136,7 +136,7 @@ pub trait State { /// Get the set of rules that this state is trying to parse fn get_rules(&self) -> &[crate::rule::ShiftedRuleRef]; - fn can_accept_error(&self) -> bool; + fn can_accept_error(&self) -> TriState; } /// `State` implementation for a sparse state representation using HashMap @@ -154,7 +154,7 @@ pub struct SparseState { /// set of rules that this state is trying to parse pub(crate) ruleset: Vec, - pub(crate) can_accept_error: bool, + pub(crate) can_accept_error: TriState, } impl< @@ -195,7 +195,7 @@ impl< fn get_rules(&self) -> &[crate::rule::ShiftedRuleRef] { &self.ruleset } - fn can_accept_error(&self) -> bool { + fn can_accept_error(&self) -> TriState { self.can_accept_error } } @@ -224,7 +224,7 @@ pub struct DenseState { /// set of rules that this state is trying to parse pub(crate) ruleset: Vec, - pub(crate) can_accept_error: bool, + pub(crate) can_accept_error: TriState, } impl< TermClass: TerminalClass, @@ -277,7 +277,7 @@ impl< &self.ruleset } - fn can_accept_error(&self) -> bool { + fn can_accept_error(&self) -> TriState { self.can_accept_error } } @@ -326,8 +326,7 @@ where }) .collect(), ruleset: builder_state.ruleset.into_iter().collect(), - can_accept_error: false, - // builder_state.can_accept_error, + can_accept_error: builder_state.can_accept_error, } } } @@ -436,8 +435,7 @@ where reduce_map, reduce_offset: reduce_min, ruleset: builder_state.ruleset.into_iter().collect(), - can_accept_error: false, - // builder_state.can_accept_error, + can_accept_error: builder_state.can_accept_error, } } } From 3a62c780cdfe5978223f8de7b5c6d2149c3c619b Mon Sep 17 00:00:00 2001 From: Taehwan Kim Date: Tue, 7 Oct 2025 11:19:12 +0900 Subject: [PATCH 8/8] fix logics for non-deterministic --- .../src/parser/nondeterministic/context.rs | 197 +++++++++++++----- 1 file changed, 141 insertions(+), 56 deletions(-) diff --git a/rusty_lr_core/src/parser/nondeterministic/context.rs b/rusty_lr_core/src/parser/nondeterministic/context.rs index 41ba94c..7343085 100644 --- a/rusty_lr_core/src/parser/nondeterministic/context.rs +++ b/rusty_lr_core/src/parser/nondeterministic/context.rs @@ -232,24 +232,6 @@ impl .map(move |&node| self.state_iter(node).chain(std::iter::once(0))) } - /// pop one stack from the node. - fn pop(&mut self, node: usize) -> Option { - match self.node(node).len() { - 0 => unreachable!("cannot pop from empty node"), - 1 => self.try_remove_node(node), - _ => { - let node_ = self.node_mut(node); - node_.data_stack.pop(); - node_.location_stack.pop(); - #[cfg(feature = "tree")] - node_.tree_stack.pop(); - node_.state_stack.pop(); - node_.precedence_stack.pop(); - Some(node) - } - } - } - /// From `node`, collect `reduce_token_count` number of tokens for reduce_action. /// Returns the index of node that it's data_stack, location_stack and tree_stack have more elements than reduce_token_count, /// and other stack containing the (data_stack.len() - reduce_token_count) number of elements. @@ -1234,60 +1216,121 @@ impl mut node: usize, error_prec: Precedence, userdata: &mut Data::UserData, - ) where + extra_state_stack: &mut Vec, + extra_precedence_stack: &mut Vec, + ) -> Option + where Data: Clone, P::Term: Clone, P::NonTerm: std::fmt::Debug, P::State: State, { - /* use crate::Location; + use crate::TriState; - let mut error_location = Data::Location::new(self.location_iter(node), 0); - loop { + let mut error_location_preserved = None; + + let pop_count = loop { let node_ = self.node(node); if !node_.is_leaf() { self.try_remove_node(node); - return; + return error_location_preserved; } - if let Some(&s) = node_.state_stack.last() { - if parser.get_states()[s.into_usize()].can_accept_error() { - match self.feed_location_impl( - parser, - node, - TerminalSymbol::Error, - P::TermClass::ERROR, - error_prec, - Some(error_location), - userdata, - ) { - Ok(()) => break, // successfully shifted `error` - Err((err_node, _, err_loc)) => { - // if this `error` feed causes reduce error, do not try panic mode anymore - if !self.reduce_errors.is_empty() { - return; - } - error_location = err_loc.unwrap(); - node = err_node; - } // other errors + + let mut pop_count = 0; + let mut found = false; + + for &s in node_.state_stack.iter().rev() { + match parser.get_states()[s.into_usize()].can_accept_error() { + TriState::False => {} + TriState::Maybe => { + extra_precedence_stack.clear(); + extra_state_stack.clear(); + + if self.can_feed_impl( + extra_state_stack, + extra_precedence_stack, + parser, + Some((node, NonZeroUsize::new(node_.len() - pop_count).unwrap())), + P::TermClass::ERROR, + error_prec, + ) == Some(true) + { + found = true; + break; + } + } + TriState::True => { + found = true; + break; } } - error_location = Data::Location::new( - std::iter::once(&error_location).chain(self.location_iter(node)), - 2, - ); - let next_node = self.pop(node); - if let Some(next_node) = next_node { - node = next_node; + pop_count += 1; + } + + if !found { + error_location_preserved = Some(if let Some(prev) = error_location_preserved { + Data::Location::new( + std::iter::once(&prev).chain(self.location_iter(node)), + pop_count + 1, + ) + } else { + Data::Location::new(self.location_iter(node), pop_count) + }); + + if let Some(parent) = self.try_remove_node(node) { + node = parent; + continue; } else { - return; // reached root node; no more nodes to process + return error_location_preserved; } } else { - unreachable!("state stack is empty but node is not root"); + break pop_count; } + }; + + let error_location = if let Some(prev) = error_location_preserved { + Data::Location::new( + std::iter::once(&prev).chain(self.location_iter(node)), + pop_count + 1, + ) + } else { + Data::Location::new(self.location_iter(node), pop_count) + }; + let node_ = self.node_mut(node); + node_ + .location_stack + .truncate(node_.location_stack.len() - pop_count); + node_ + .state_stack + .truncate(node_.state_stack.len() - pop_count); + node_ + .precedence_stack + .truncate(node_.precedence_stack.len() - pop_count); + for _ in 0..pop_count { + node_.data_stack.pop(); } - */ + #[cfg(feature = "tree")] + { + let l = node_.tree_stack.len() - pop_count; + node_.tree_stack.truncate(l); + } + match self.feed_location_impl( + parser, + node, + TerminalSymbol::Error, + P::TermClass::ERROR, + error_prec, + Some(error_location), + userdata, + ) { + Ok(()) => {} + Err((err_node, _, _)) => { + self.try_remove_node(err_node); + } // other errors + } + None } /// Feed one terminal with location to parser, and update state stack. @@ -1330,6 +1373,7 @@ impl self.fallback_nodes.push(node); } } + // put back for reused allocated memory self.current_nodes = current_nodes; // next_nodes is empty; invalid terminal was given @@ -1351,20 +1395,61 @@ impl let error_prec = P::TermClass::ERROR.precedence(); - let reduce_action_errors = std::mem::take(&mut self.reduce_errors); let mut fallback_nodes = std::mem::take(&mut self.fallback_nodes); + let mut extra_state_stack = Vec::new(); + let mut extra_precedence_stack = Vec::new(); + let mut error_location = None; // try enter panic mode and store error nodes to next_nodes for node in fallback_nodes.drain(..) { - self.panic_mode(parser, node, error_prec, userdata); + error_location = self.panic_mode( + parser, + node, + error_prec, + userdata, + &mut extra_state_stack, + &mut extra_precedence_stack, + ); } + // put back for reuse allocated memory self.fallback_nodes = fallback_nodes; + + if self.next_nodes.is_empty() { + // for-loop above doesn't check for root state (0). + // check for 0 state here + if parser.get_states()[0].can_accept_error() == crate::TriState::True { + if error_location.is_none() { + error_location = Some(Data::Location::new(std::iter::empty(), 0)); + } + + // all nodes were deleted, so create new + let node = self.new_node(); + if let Err(_) = self.feed_location_impl( + parser, + node, + TerminalSymbol::Error, + P::TermClass::ERROR, + error_prec, + error_location, + userdata, + ) { + return Err(ParseError { + term: TerminalSymbol::Term(term), + location: Some(location), + reduce_action_errors: std::mem::take(&mut self.reduce_errors), + no_precedences: std::mem::take(&mut self.no_precedences), + states: self.states().collect(), + }); + } + } + } + // if next_node is still empty, then no panic mode was entered, this is an error // restore current_nodes to fallback_nodes if self.next_nodes.is_empty() { Err(ParseError { term: TerminalSymbol::Term(term), location: Some(location), - reduce_action_errors, + reduce_action_errors: std::mem::take(&mut self.reduce_errors), no_precedences: std::mem::take(&mut self.no_precedences), states: self.states().collect(), })