diff --git a/rusty_lr_core/src/builder/grammar.rs b/rusty_lr_core/src/builder/grammar.rs index 405c962..615b9e8 100644 --- a/rusty_lr_core/src/builder/grammar.rs +++ b/rusty_lr_core/src/builder/grammar.rs @@ -12,6 +12,8 @@ use super::States; 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)] @@ -51,7 +53,7 @@ pub struct Grammar { pub precedence_types: Vec>, } -impl Grammar { +impl Grammar, NonTerm> { pub fn new() -> Self { Grammar { rules: Vec::new(), @@ -68,8 +70,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 +94,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 +112,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 +192,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 +270,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 +303,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 +398,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 +495,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, @@ -525,6 +533,16 @@ impl Grammar { 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 = TriState::True; + } + } + Ok(States { states }) } @@ -532,8 +550,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, @@ -662,6 +680,8 @@ impl Grammar { .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_a.can_accept_error | state_b.can_accept_error; merged = true; } } @@ -716,8 +736,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, @@ -757,6 +777,8 @@ impl Grammar { .or_default() .append(&mut reduce_rules); } + 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()); @@ -927,11 +949,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 +976,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 +1140,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 +1182,7 @@ impl Grammar { // } // } -impl Default for Grammar { +impl Default for Grammar, NonTerm> { fn default() -> Self { Self::new() } diff --git a/rusty_lr_core/src/builder/state.rs b/rusty_lr_core/src/builder/state.rs index 108a63e..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,6 +10,7 @@ pub struct State { pub shift_goto_map_nonterm: BTreeMap, pub reduce_map: BTreeMap>, pub ruleset: BTreeSet, + pub can_accept_error: TriState, } impl State { pub fn new() -> Self { @@ -16,6 +19,7 @@ impl State { shift_goto_map_nonterm: Default::default(), reduce_map: Default::default(), ruleset: Default::default(), + can_accept_error: TriState::False, } } @@ -79,6 +83,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/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/deterministic/context.rs b/rusty_lr_core/src/parser/deterministic/context.rs index f4f6309..5b1fa71 100644 --- a/rusty_lr_core/src/parser/deterministic/context.rs +++ b/rusty_lr_core/src/parser/deterministic/context.rs @@ -269,80 +269,110 @@ 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(); - - 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` + let error_prec = P::TermClass::ERROR.precedence(); + + 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, + P::TermClass::ERROR, + error_prec, + ) == Some(true) + { + found = true; + break; } } - Ok(()) => break, // successfully shifted `error` - Err(_) => return Err(ParseError::NoAction(err)), // other errors + 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 09bc0ec..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,7 +1216,9 @@ impl mut node: usize, error_prec: Precedence, userdata: &mut Data::UserData, - ) -> bool + extra_state_stack: &mut Vec, + extra_precedence_stack: &mut Vec, + ) -> Option where Data: Clone, P::Term: Clone, @@ -1242,38 +1226,111 @@ impl P::State: State, { use crate::Location; + use crate::TriState; - let mut error_location = Data::Location::new(self.location_iter(node), 0); + let mut error_location_preserved = None; - 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 + let pop_count = loop { + let node_ = self.node(node); + if !node_.is_leaf() { + self.try_remove_node(node); + return error_location_preserved; + } + + 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; + } } - 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; + TriState::True => { + found = true; + break; } } + + 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 error_location_preserved; + } + } else { + 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. @@ -1316,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 @@ -1338,11 +1396,53 @@ impl let error_prec = P::TermClass::ERROR.precedence(); 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() { diff --git a/rusty_lr_core/src/parser/state.rs b/rusty_lr_core/src/parser/state.rs index b86ed76..f684169 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,6 +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: TriState, } /// For state, terminal and class indices, we use the most compact integer type that can hold the maximum value. @@ -133,6 +135,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) -> TriState; } /// `State` implementation for a sparse state representation using HashMap @@ -149,6 +153,8 @@ pub struct SparseState { /// set of rules that this state is trying to parse pub(crate) ruleset: Vec, + + pub(crate) can_accept_error: TriState, } impl< @@ -189,6 +195,9 @@ impl< fn get_rules(&self) -> &[crate::rule::ShiftedRuleRef] { &self.ruleset } + fn can_accept_error(&self) -> TriState { + self.can_accept_error + } } /// `State` implementation for a dense state representation using Vec @@ -215,7 +224,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: TriState, } impl< TermClass: TerminalClass, @@ -267,6 +276,10 @@ impl< fn get_rules(&self) -> &[crate::rule::ShiftedRuleRef] { &self.ruleset } + + fn can_accept_error(&self) -> TriState { + self.can_accept_error + } } impl @@ -313,6 +326,7 @@ where }) .collect(), ruleset: builder_state.ruleset.into_iter().collect(), + can_accept_error: builder_state.can_accept_error, } } } @@ -421,7 +435,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..8e3fd45 100644 --- a/rusty_lr_parser/src/emit.rs +++ b/rusty_lr_parser/src/emit.rs @@ -781,6 +781,12 @@ impl Grammar { } }; + 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 { shift_goto_map_term: vec![#shift_term_body_stream], @@ -801,7 +807,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..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() } }, + 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() } }, + 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() } }, + 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() } }, + 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() } }, + 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() } }, + 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() } }, + 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() } }, + 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() } }, + 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)),], @@ -7667,7 +7676,8 @@ 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() } }, + 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::lparen, ::rusty_lr_core::parser::state::ShiftTarget::new(11, true)),], @@ -7675,7 +7685,8 @@ impl GrammarParser { 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() } }, + 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::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), @@ -7698,7 +7709,8 @@ 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() } }, + 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![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -7707,7 +7719,8 @@ impl GrammarParser { { 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() } }, + 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)), @@ -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() } }, + 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() } }, + 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() } }, + 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)), @@ -7783,7 +7799,8 @@ 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() } }, + 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::minus, ::rusty_lr_core::parser::state::ShiftTarget::new(18, true)),], @@ -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() } }, + 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() } }, + 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() } }, + 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() } }, + 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() } }, + 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() } }, + 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() } }, + 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() } }, + 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() } }, + 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() } }, + 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() } }, + 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() } }, + 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() } }, + 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() } }, + 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() } }, + 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() } }, + 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() } }, + 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() } }, + 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() } }, + 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)), @@ -8010,7 +8046,8 @@ 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() } }, + 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![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8019,7 +8056,8 @@ impl GrammarParser { { 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() } }, + 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)), @@ -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() } }, + 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)), @@ -8059,7 +8098,8 @@ 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() } }, + 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)), @@ -8082,7 +8122,8 @@ 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() } }, + 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::rparen, ::rusty_lr_core::parser::state::ShiftTarget::new(42, true)),], @@ -8090,7 +8131,8 @@ impl GrammarParser { 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 : + ::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() } }, + 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() } }, + 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() } }, + 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() } }, + 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() } }, + 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() } }, + 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)), @@ -8218,7 +8266,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 : ::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] = @@ -8227,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() } }, + 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] = @@ -8236,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() } }, + 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)), @@ -8264,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() } }, + 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)), @@ -8279,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() } }, + 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)),], @@ -8287,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() } }, + 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] = @@ -8296,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() } }, + 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)),], @@ -8304,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() } }, + 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] = @@ -8313,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() } }, + 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)),], @@ -8321,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() } }, + 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] = @@ -8330,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() } }, + 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)),], @@ -8338,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() } }, + 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] = @@ -8347,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() } }, + 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)),], @@ -8355,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() } }, + 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] = @@ -8364,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() } }, + 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)), @@ -8386,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() } }, + 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)), @@ -8396,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() } }, + 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] = @@ -8405,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() } }, + 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)), @@ -8440,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() } }, + 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] = @@ -8449,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() } }, + 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] = @@ -8458,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() } }, + 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)), @@ -8480,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() } }, + 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)), @@ -8508,7 +8578,8 @@ 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() } }, + 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![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); { static __REDUCE_RULES : [u8; 1usize] = @@ -8517,7 +8588,8 @@ impl GrammarParser { { 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() } }, + 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)),], @@ -8534,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() } }, + 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)), @@ -8546,7 +8619,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() } }, + 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)), @@ -8560,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() } }, + 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] = @@ -8569,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() } }, + 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] = @@ -8578,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() } }, + 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] = @@ -8587,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() } }, + 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] = @@ -8596,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() } }, + 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)), @@ -8606,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() } }, + 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] = @@ -8615,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() } }, + 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] = @@ -8624,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() } }, + 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] = @@ -8633,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() } }, + 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] = @@ -8642,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() } }, + 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)),], @@ -8655,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() } }, + 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] = @@ -8664,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() } }, + 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)),], @@ -8677,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() } }, + 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] = @@ -8686,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() } }, + 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] = @@ -8695,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() } }, + 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] = @@ -8704,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() } }, + 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)), @@ -8747,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() } }, + 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)), @@ -8763,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() } }, + 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)),], @@ -8771,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() } }, + 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] = @@ -8780,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() } }, + 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] = @@ -8789,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() } }, + 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)), @@ -8803,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() } }, + 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] = @@ -8812,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() } }, + 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] = @@ -8821,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() } }, + 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)), @@ -8837,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() } }, + 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)),], @@ -8845,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() } }, + 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] = @@ -8854,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() } }, + 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)), @@ -8868,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() } }, + 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] = @@ -8877,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() } }, + 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)), @@ -8887,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() } }, + 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)), @@ -8985,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() } }, + 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] = @@ -8994,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() } }, + 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] = @@ -9003,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() } }, + 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)), @@ -9099,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() } }, + 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] = @@ -9108,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() } }, + 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] = @@ -9117,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() } }, + 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)),], @@ -9125,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() } }, + 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] = @@ -9134,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() } }, + 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)), @@ -9144,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() } }, + 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)),], @@ -9152,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() } }, + 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] = @@ -9161,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() } }, + 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)),], @@ -9169,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() } }, + 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] = @@ -9178,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() } }, + 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)), @@ -9276,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() } }, + 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] = @@ -9285,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() } }, + 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)), @@ -9381,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() } }, + 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] = @@ -9390,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() } }, + 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)), @@ -9488,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() } }, + 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] = @@ -9497,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() } }, + 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)), @@ -9593,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() } }, + 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] = @@ -9602,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() } }, + 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)), @@ -9700,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() } }, + 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] = @@ -9709,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() } }, + 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)), @@ -9805,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() } }, + 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] = @@ -9814,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() } }, + 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)), @@ -9912,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() } }, + 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] = @@ -9921,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() } }, + 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)), @@ -10017,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() } }, + 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] = @@ -10026,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() } }, + 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)), @@ -10036,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() } }, + 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] = @@ -10045,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() } }, + 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)),], @@ -10053,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() } }, + 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] = @@ -10062,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() } }, + 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)), @@ -10072,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() } }, + 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] = @@ -10081,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() } }, + 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)),], @@ -10089,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() } }, + 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] = @@ -10098,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() } }, + 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)), @@ -10114,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() } }, + 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)),], @@ -10122,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() } }, + 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] = @@ -10131,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() } }, + 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)), @@ -10145,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() } }, + 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] = @@ -10154,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() } }, + 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)), @@ -10164,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() } }, + 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] = @@ -10173,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() } }, + 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)),], @@ -10181,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() } }, + 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] = @@ -10190,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() } }, + 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)), @@ -10200,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() } }, + 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] = @@ -10209,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() } }, + 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)),], @@ -10217,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() } }, + 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] = @@ -10226,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() } }, + 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)), @@ -10243,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() } }, + 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] = @@ -10252,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() } }, + 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)),], @@ -10260,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() } }, + 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] = @@ -10269,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() } }, + 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)),], @@ -10280,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() } }, + 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] = @@ -10289,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() } }, + 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)),], @@ -10297,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() } }, + 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] = @@ -10306,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() } }, + 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)), @@ -10404,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() } }, + 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] = @@ -10413,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() } }, + 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)), @@ -10509,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() } }, + 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] = @@ -10518,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() } }, + 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)), @@ -10616,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() } }, + 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] = @@ -10625,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() } }, + 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)), @@ -10721,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() } }, + 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] = @@ -10730,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() } }, + 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)),], @@ -10738,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() } }, + 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] = @@ -10747,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() } }, + 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] = @@ -10756,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() } }, + 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)), @@ -10780,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() } }, + 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] = @@ -10789,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() } }, + 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)),], @@ -10797,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() } }, + 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() } }, + 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 8a40b1d..e8f8398 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 : ::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_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 : ::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, @@ -743,18 +744,19 @@ 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, + 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 + __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 : + ::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, @@ -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 : ::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_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 : ::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 @@ -783,27 +786,28 @@ 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() } }, - ::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() } }, ::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 : ::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] = + [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 : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::rparen, ::rusty_lr::parser::state::ShiftTarget::new(10, false)),], @@ -811,28 +815,30 @@ 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 : ::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] = + [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 : ::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() } }, - ::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() } }, + : 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 ac03033..dc47719 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 : ::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] = + [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 : ::rusty_lr::TriState::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 : ::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 : ::rusty_lr::TriState::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 : ::rusty_lr::TriState::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,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() } }, - ::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] = @@ -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 : ::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] = + [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 : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass2, ::rusty_lr::parser::state::ShiftTarget::new(9, false)), @@ -1121,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() } }, - ::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, @@ -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 : ::rusty_lr::TriState::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 : ::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::__Terminal32Plus6, ::rusty_lr::parser::state::ShiftTarget::new(6, true)), @@ -1166,7 +1172,8 @@ 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() } }, + 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] = @@ -1175,8 +1182,9 @@ impl EParser { { 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, + 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, @@ -1193,8 +1201,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 : ::rusty_lr::TriState::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,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() } }, - ::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)), @@ -1223,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() } }, - ::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, @@ -1242,35 +1251,37 @@ 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 = - 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() } }, ::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 + 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 + 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 : + ::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() } }, - ::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() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(ETerminalClasses::TermClass0, + 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)), @@ -1289,15 +1300,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 : ::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_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 : ::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] = @@ -1306,8 +1318,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 : ::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, @@ -1324,17 +1337,18 @@ 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 : ::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 + 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 : + ::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 4844108..37b5038 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 : ::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)),], @@ -2040,7 +2041,8 @@ 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() } }, + 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(1, false)), @@ -2056,7 +2058,8 @@ 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() } }, + 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] = @@ -2065,15 +2068,16 @@ impl JsonParser { { 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 { - shift_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() } }, + 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)),], @@ -2081,12 +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() } }, ::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 : ::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 : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(8, false)), @@ -2128,44 +2133,48 @@ 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() } }, - ::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() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(JsonTerminalClasses::TermClass24, + 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)),], 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 : ::rusty_lr::TriState::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 : ::rusty_lr::TriState::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 : ::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] = + [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 : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass26, ::rusty_lr::parser::state::ShiftTarget::new(14, false)),], @@ -2173,29 +2182,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 : ::rusty_lr::TriState::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 : ::rusty_lr::TriState::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 : ::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] = + [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 : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass8, ::rusty_lr::parser::state::ShiftTarget::new(18, false)),], @@ -2203,29 +2215,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 : ::rusty_lr::TriState::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 : ::rusty_lr::TriState::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 : ::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] = + [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 : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(26, false)), @@ -2237,8 +2252,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 : ::rusty_lr::TriState::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 +2269,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 : ::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] = + [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 : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(24, false)), @@ -2278,15 +2295,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 : ::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] = + [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 : ::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] = @@ -2295,8 +2313,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 : ::rusty_lr::TriState::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 +2330,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 : ::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] = + [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 : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(1, false)), @@ -2343,8 +2363,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 : ::rusty_lr::TriState::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 +2374,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 : ::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)),], @@ -2372,8 +2394,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 : ::rusty_lr::TriState::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,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() } }, - ::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)),], @@ -2425,8 +2448,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 : ::rusty_lr::TriState::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 +2465,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 : ::rusty_lr::TriState::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 +2482,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 : ::rusty_lr::TriState::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 +2499,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 : ::rusty_lr::TriState::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 : ::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_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 : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(40, false)), @@ -2509,8 +2537,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 : ::rusty_lr::TriState::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,7 +2553,8 @@ 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() } }, + 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(40, false)), @@ -2540,7 +2570,8 @@ 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() } }, + 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::TermClass28, ::rusty_lr::parser::state::ShiftTarget::new(43, false)),], @@ -2548,15 +2579,16 @@ impl JsonParser { 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 : ::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] = + [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 : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass28, ::rusty_lr::parser::state::ShiftTarget::new(45, false)),], @@ -2564,15 +2596,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 : ::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] = + [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 : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass12, ::rusty_lr::parser::state::ShiftTarget::new(47, false)),], @@ -2583,8 +2616,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 : ::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)),], @@ -2602,8 +2636,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 : ::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)),], @@ -2617,7 +2652,8 @@ 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() } }, + 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(48, false)), @@ -2633,7 +2669,8 @@ 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() } }, + 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] = @@ -2642,15 +2679,17 @@ impl JsonParser { { 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, + 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 : 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() } }, + 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)), @@ -2725,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() } }, - ::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)), @@ -2751,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() } }, - ::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)), @@ -2783,7 +2822,8 @@ 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() } }, + 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::TermClass5, ::rusty_lr::parser::state::ShiftTarget::new(56, false)), @@ -2815,7 +2855,8 @@ 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() } }, + 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::TermClass5, ::rusty_lr::parser::state::ShiftTarget::new(57, false)), @@ -2847,7 +2888,8 @@ 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() } }, + 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::TermClass5, ::rusty_lr::parser::state::ShiftTarget::new(58, false)), @@ -2879,7 +2921,8 @@ 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() } }, + 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] = @@ -2888,15 +2931,16 @@ impl JsonParser { { 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 { - shift_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() } }, + 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)), @@ -2969,15 +3013,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 : ::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] = + [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 : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass29, ::rusty_lr::parser::state::ShiftTarget::new(63, false)),], @@ -2985,15 +3030,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 : ::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] = + [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 : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(65, false)), @@ -3009,7 +3055,8 @@ 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() } }, + 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(65, false)), @@ -3025,7 +3072,8 @@ 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() } }, + 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(65, false)), @@ -3041,7 +3089,8 @@ 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() } }, + 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::TermClass16, ::rusty_lr::parser::state::ShiftTarget::new(68, false)),], @@ -3049,8 +3098,9 @@ impl JsonParser { 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 : ::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)),], @@ -3066,15 +3116,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 : ::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] = + [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 : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(8, false)), @@ -3116,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() } }, - ::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)),], @@ -3128,8 +3179,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 : ::rusty_lr::TriState::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 +3196,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 : ::rusty_lr::TriState::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 +3213,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 : ::rusty_lr::TriState::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 +3230,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 : ::rusty_lr::TriState::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,7 +3241,8 @@ 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() } }, + 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] = @@ -3195,8 +3251,9 @@ impl JsonParser { { 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, + 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)),], @@ -3210,7 +3267,8 @@ 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() } }, + 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)), @@ -3226,7 +3284,8 @@ 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() } }, + 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)), @@ -3242,7 +3301,8 @@ 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() } }, + 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] = @@ -3251,8 +3311,9 @@ impl JsonParser { { 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, + 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)), @@ -3264,7 +3325,8 @@ 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() } }, + 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::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(84, false)), @@ -3278,15 +3340,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 : ::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] = + [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 : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(84, false)), @@ -3303,8 +3366,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 : ::rusty_lr::TriState::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,7 +3382,8 @@ 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() } }, + 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::TermClass10, ::rusty_lr::parser::state::ShiftTarget::new(87, false)), @@ -3334,7 +3399,8 @@ 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() } }, + 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::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(89, false)), @@ -3348,15 +3414,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 : ::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] = + [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 : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(89, false)), @@ -3373,8 +3440,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 : ::rusty_lr::TriState::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,7 +3456,8 @@ 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() } }, + 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::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(89, false)), @@ -3402,15 +3471,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 : ::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] = + [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 : ::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] = @@ -3419,8 +3489,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 : ::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)),], @@ -3434,7 +3505,8 @@ 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() } }, + 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(95, false)), @@ -3450,7 +3522,8 @@ 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() } }, + 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(95, false)), @@ -3466,7 +3539,8 @@ 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() } }, + 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(98, false)),], @@ -3480,7 +3554,8 @@ 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() } }, + 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::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(99, false)), @@ -3494,8 +3569,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 : ::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)),], @@ -3510,8 +3586,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 : ::rusty_lr::TriState::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,7 +3602,8 @@ 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() } }, + 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::TermClass10, ::rusty_lr::parser::state::ShiftTarget::new(102, false)), @@ -3542,8 +3620,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 : ::rusty_lr::TriState::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 +3634,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 : ::rusty_lr::TriState::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 +3651,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 : ::rusty_lr::TriState::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 +3668,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 : ::rusty_lr::TriState::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 +3682,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 : ::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] = + [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 : ::rusty_lr::TriState::False, }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(108, false)), @@ -3624,7 +3707,8 @@ 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() } }, + 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(108, false)), @@ -3640,7 +3724,8 @@ 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() } }, + 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(108, false)), @@ -3656,7 +3741,8 @@ 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() } }, + 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(111, false)),], @@ -3670,7 +3756,8 @@ 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() } }, + 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::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(112, false)), @@ -3684,8 +3771,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 : ::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)),], @@ -3700,8 +3788,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 : ::rusty_lr::TriState::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,7 +3804,8 @@ 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() } }, + 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::TermClass10, ::rusty_lr::parser::state::ShiftTarget::new(115, false)), @@ -3732,8 +3822,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 : ::rusty_lr::TriState::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 +3836,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 : ::rusty_lr::TriState::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 +3853,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 : ::rusty_lr::TriState::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 +3870,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 : ::rusty_lr::TriState::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 +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() } }, + usize, } }).collect() }, can_accept_error : ::rusty_lr::TriState::False, }, ]; let states: Vec = states .into_iter()