diff --git a/rusty_lr_core/src/builder/state.rs b/rusty_lr_core/src/builder/state.rs index 356a4f9..e72b46f 100644 --- a/rusty_lr_core/src/builder/state.rs +++ b/rusty_lr_core/src/builder/state.rs @@ -44,6 +44,8 @@ where Term: Ord, { fn from(mut state: crate::builder::State, NonTerm>) -> Self { + use crate::parser::state::ShiftTarget; + let error_shift = state .shift_goto_map_term .remove(&crate::TerminalSymbol::Error); @@ -62,11 +64,31 @@ where shift_goto_map_term: state .shift_goto_map_term .into_iter() - .map(|(term, state_index)| (term.into_term().unwrap(), state_index)) + .map(|(term, state_index)| { + ( + term.into_term().unwrap(), + ShiftTarget { + state: state_index.into(), + push: true, + }, + ) + }) .collect(), error_shift, eof_shift, - shift_goto_map_nonterm: state.shift_goto_map_nonterm.into_iter().collect(), + shift_goto_map_nonterm: state + .shift_goto_map_nonterm + .into_iter() + .map(|(nonterm, state_index)| { + ( + nonterm, + ShiftTarget { + state: state_index.into(), + push: true, + }, + ) + }) + .collect(), reduce_map: state .reduce_map .into_iter() diff --git a/rusty_lr_core/src/parser/data_stack.rs b/rusty_lr_core/src/parser/data_stack.rs index 96e5529..14b41b1 100644 --- a/rusty_lr_core/src/parser/data_stack.rs +++ b/rusty_lr_core/src/parser/data_stack.rs @@ -35,7 +35,8 @@ pub trait DataStack: Sized + Default { fn split_off(&mut self, at: usize) -> Self; fn append(&mut self, other: &mut Self); - /// performs a reduce action with the given rule index + /// Performs a reduce action with the given rule index. + /// Returns false if the empty tag was pushed by this reduce action, true otherwise. fn reduce_action( // the child tokens for the reduction // the caller (usually from generated code) must pops all of the tokens used for this reduce_action @@ -54,5 +55,5 @@ pub trait DataStack: Sized + Default { userdata: &mut Self::UserData, // location of this non-terminal, e.g. `@$` location0: &mut Self::Location, - ) -> Result<(), Self::ReduceActionError>; + ) -> Result; } diff --git a/rusty_lr_core/src/parser/deterministic/context.rs b/rusty_lr_core/src/parser/deterministic/context.rs index d6b77fc..ddae287 100644 --- a/rusty_lr_core/src/parser/deterministic/context.rs +++ b/rusty_lr_core/src/parser/deterministic/context.rs @@ -180,7 +180,7 @@ impl Context { let mut popped_states = states.drain(states.len() - len..).collect::>(); let last_state = states.last().unwrap().into_usize(); if let Some(next_state) = parser.get_states()[last_state].shift_goto_nonterm(&nonterm) { - states.push(StateIndex::from_usize_unchecked(next_state)); + states.push(StateIndex::from_usize_unchecked(next_state.state)); self.expected_token_impl(parser, states, terms, nonterms); states.pop(); } @@ -275,6 +275,8 @@ impl Context { } // 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) @@ -283,12 +285,17 @@ impl Context { self.tree_stack .push(crate::tree::Tree::new_terminal(term.clone())); - // shift with `error` token - self.data_stack.push_terminal(term.into_term().unwrap()); + // shift after `error` token + if next_state.push { + self.data_stack.push_terminal(term.into_term().unwrap()); + } else { + self.data_stack.push_empty(); + } + self.location_stack.push(location.unwrap()); self.precedence_stack.push(shift_prec); self.state_stack - .push(StateIndex::from_usize_unchecked(next_state)); + .push(StateIndex::from_usize_unchecked(next_state.state)); } else { // merge term with previous error @@ -400,7 +407,7 @@ impl Context { Data::Location::new(self.location_stack.iter().rev(), tokens_len); // call reduce action - match Data::reduce_action( + let non_empty_pushed = match Data::reduce_action( &mut self.data_stack, &mut self.location_stack, reduce_rule, @@ -409,7 +416,7 @@ impl Context { userdata, &mut new_location, ) { - Ok(_) => {} + Ok(ret) => ret, Err(err) => { return Err(ParseError::ReduceAction(term, location, err)); } @@ -438,7 +445,11 @@ impl Context { .shift_goto_nonterm(&rule.name) { self.state_stack - .push(StateIndex::from_usize_unchecked(next_state_id)); + .push(StateIndex::from_usize_unchecked(next_state_id.state)); + if !next_state_id.push && non_empty_pushed { + self.data_stack.pop(); + self.data_stack.push_empty(); + } } else { unreachable!("shift nonterm failed"); } @@ -450,20 +461,25 @@ impl Context { // shift with terminal if let Some(next_state_id) = shift_to { self.state_stack - .push(StateIndex::from_usize_unchecked(next_state_id)); + .push(StateIndex::from_usize_unchecked(next_state_id.state)); #[cfg(feature = "tree")] self.tree_stack .push(crate::tree::Tree::new_terminal(term.clone())); - match term { - TerminalSymbol::Term(term) => { - self.data_stack.push_terminal(term); - } - TerminalSymbol::Error | TerminalSymbol::Eof => { - self.data_stack.push_empty(); + if next_state_id.push { + match term { + TerminalSymbol::Term(term) => { + self.data_stack.push_terminal(term); + } + TerminalSymbol::Error | TerminalSymbol::Eof => { + self.data_stack.push_empty(); + } } + } else { + self.data_stack.push_empty(); } + // location is `Some` if it is not `Eof` if let Some(location) = location { self.location_stack.push(location); @@ -618,7 +634,7 @@ impl Context { [state_stack.last().unwrap().into_usize()] .shift_goto_nonterm(&rule.name) { - state_stack.push(StateIndex::from_usize_unchecked(next_state_id)); + state_stack.push(StateIndex::from_usize_unchecked(next_state_id.state)); } else { unreachable!("shift nonterm failed"); } diff --git a/rusty_lr_core/src/parser/nondeterministic/context.rs b/rusty_lr_core/src/parser/nondeterministic/context.rs index 45b9723..b148aa8 100644 --- a/rusty_lr_core/src/parser/nondeterministic/context.rs +++ b/rusty_lr_core/src/parser/nondeterministic/context.rs @@ -453,12 +453,16 @@ impl Context { userdata, &mut new_location, ) { - Ok(_) => { + Ok(non_empty_pushed) => { if let Some(nonterm_shift_state) = parser.get_states()[state].shift_goto_nonterm(&rule.name) { node.state_stack - .push(StateIndex::from_usize_unchecked(nonterm_shift_state)); + .push(StateIndex::from_usize_unchecked(nonterm_shift_state.state)); + if !nonterm_shift_state.push && non_empty_pushed { + node.data_stack.pop(); + node.data_stack.push_empty(); + } node.location_stack.push(new_location); node.precedence_stack.push(precedence); #[cfg(feature = "tree")] @@ -1051,7 +1055,7 @@ impl Context { let node_ = self.node_mut(node); node_ .state_stack - .push(StateIndex::from_usize_unchecked(shift)); + .push(StateIndex::from_usize_unchecked(shift.state)); node_.precedence_stack.push(shift_prec); if let Some(location) = &location { node_.location_stack.push(location.clone()); @@ -1061,13 +1065,17 @@ impl Context { .tree_stack .push(crate::tree::Tree::new_terminal(term.clone())); - match term { - TerminalSymbol::Term(term) => { - node_.data_stack.push_terminal(term); - } - TerminalSymbol::Eof | TerminalSymbol::Error => { - node_.data_stack.push_empty(); + if shift.push { + match term { + TerminalSymbol::Term(term) => { + node_.data_stack.push_terminal(term); + } + TerminalSymbol::Eof | TerminalSymbol::Error => { + node_.data_stack.push_empty(); + } } + } else { + node_.data_stack.push_empty(); } self.next_nodes.push(node); @@ -1083,7 +1091,7 @@ impl Context { let node_ = self.node_mut(node); node_ .state_stack - .push(StateIndex::from_usize_unchecked(shift)); + .push(StateIndex::from_usize_unchecked(shift.state)); node_.precedence_stack.push(shift_prec); if let Some(location) = location { node_.location_stack.push(location); @@ -1093,13 +1101,17 @@ impl Context { .tree_stack .push(crate::tree::Tree::new_terminal(term.clone())); - match term { - TerminalSymbol::Term(term) => { - node_.data_stack.push_terminal(term); - } - TerminalSymbol::Eof | TerminalSymbol::Error => { - node_.data_stack.push_empty(); + if shift.push { + match term { + TerminalSymbol::Term(term) => { + node_.data_stack.push_terminal(term); + } + TerminalSymbol::Eof | TerminalSymbol::Error => { + node_.data_stack.push_empty(); + } } + } else { + node_.data_stack.push_empty(); } self.next_nodes.push(node); @@ -1243,14 +1255,19 @@ impl Context { // and b is fed, shift error and b let node = self.node_mut(error_node); node.state_stack - .push(StateIndex::from_usize_unchecked(next_state)); + .push(StateIndex::from_usize_unchecked(next_state.state)); node.precedence_stack.push(shift_prec); node.location_stack.push(location.clone()); #[cfg(feature = "tree")] node.tree_stack.push(crate::tree::Tree::new_terminal( TerminalSymbol::Term(term.clone()), )); - node.data_stack.push_terminal(term.clone()); + + if next_state.push { + node.data_stack.push_terminal(term.clone()); + } else { + node.data_stack.push_empty(); + } self.current_nodes.push(error_node); } else { diff --git a/rusty_lr_core/src/parser/state.rs b/rusty_lr_core/src/parser/state.rs index f3426bc..5c7c1b3 100644 --- a/rusty_lr_core/src/parser/state.rs +++ b/rusty_lr_core/src/parser/state.rs @@ -4,14 +4,26 @@ use crate::hash::HashMap; use crate::nonterminal::NonTerminal; use crate::TerminalSymbol; +#[derive(Debug, Clone, Copy)] +pub struct ShiftTarget { + pub state: StateIndex, + /// true if the data should be pushed, false if data should not be pushed + pub push: bool, +} +impl ShiftTarget { + pub fn new(state: StateIndex, push: bool) -> Self { + ShiftTarget { state, push } + } +} + /// This intermediate state is a common structure to convert from generated code and grammar builder /// into various types of parser states (SparseState, DenseState, ...). pub struct IntermediateState { - pub shift_goto_map_term: Vec<(Term, StateIndex)>, // must be sorted + pub shift_goto_map_term: Vec<(Term, ShiftTarget)>, // must be sorted pub eof_shift: Option, pub error_shift: Option, - pub shift_goto_map_nonterm: Vec<(NonTerm, StateIndex)>, // must be sorted - pub reduce_map: Vec<(Term, Vec)>, // must be sorted + pub shift_goto_map_nonterm: Vec<(NonTerm, ShiftTarget)>, // must be sorted + pub reduce_map: Vec<(Term, Vec)>, // must be sorted pub eof_reduce: Option>, pub error_reduce: Option>, pub ruleset: Vec, @@ -102,10 +114,10 @@ pub type SmallVecUsize = smallvec::SmallVec<[usize; 2]>; /// A trait representing a parser state. pub trait State { /// Get the next state for a given terminal symbol. - fn shift_goto_class(&self, class: TerminalSymbol) -> Option; + fn shift_goto_class(&self, class: TerminalSymbol) -> Option>; /// Get the next state for a given non-terminal symbol. - fn shift_goto_nonterm(&self, nonterm: &NonTerm) -> Option + fn shift_goto_nonterm(&self, nonterm: &NonTerm) -> Option> where NonTerm: Hash + Eq + NonTerminal; @@ -138,12 +150,12 @@ pub trait State { #[derive(Debug, Clone)] pub struct SparseState { /// terminal symbol -> next state - pub(crate) shift_goto_map_class: HashMap, + pub(crate) shift_goto_map_class: HashMap>, pub(crate) error_shift: Option, pub(crate) eof_shift: Option, /// non-terminal symbol -> next state - pub(crate) shift_goto_map_nonterm: HashMap, + pub(crate) shift_goto_map_nonterm: HashMap>, /// terminal symbol -> reduce rule index pub(crate) reduce_map: HashMap, @@ -161,25 +173,37 @@ impl< StateIndex: Into + Copy, > State for SparseState { - fn shift_goto_class(&self, class: TerminalSymbol) -> Option { + fn shift_goto_class(&self, class: TerminalSymbol) -> Option> { match class { TerminalSymbol::Term(class) => self .shift_goto_map_class .get(&Term::from_usize_unchecked(class)) - .copied(), - TerminalSymbol::Error => self.error_shift, - TerminalSymbol::Eof => self.eof_shift, + .copied() + .map(|s| ShiftTarget { + state: s.state.into(), + push: s.push, + }), + TerminalSymbol::Error => self.error_shift.map(|s| ShiftTarget { + state: s.into(), + push: false, + }), + TerminalSymbol::Eof => self.eof_shift.map(|s| ShiftTarget { + state: s.into(), + push: false, + }), } - .map(Into::into) } - fn shift_goto_nonterm(&self, nonterm: &NonTerm) -> Option + fn shift_goto_nonterm(&self, nonterm: &NonTerm) -> Option> where NonTerm: Hash + Eq, { self.shift_goto_map_nonterm .get(nonterm) .copied() - .map(Into::into) + .map(|s| ShiftTarget { + state: s.state.into(), + push: s.push, + }) } fn reduce( &self, @@ -218,14 +242,14 @@ impl< #[derive(Debug, Clone)] pub struct DenseState { /// terminal symbol -> next state - pub(crate) shift_goto_map_class: Vec>, + pub(crate) shift_goto_map_class: Vec>>, /// shift_goto_map_class[i] will contain i+offset 'th class's next state. pub(crate) shift_class_offset: usize, pub(crate) error_shift: Option, pub(crate) eof_shift: Option, /// non-terminal symbol -> next state - pub(crate) shift_goto_map_nonterm: Vec>, + pub(crate) shift_goto_map_nonterm: Vec>>, pub(crate) shift_nonterm_offset: usize, /// set of non-terminal symbols that is keys of `shift_goto_map_nonterm` pub(crate) shift_goto_map_nonterm_keys: Vec, @@ -245,19 +269,28 @@ pub struct DenseState { impl + Copy> State for DenseState { - fn shift_goto_class(&self, class: TerminalSymbol) -> Option { + fn shift_goto_class(&self, class: TerminalSymbol) -> Option> { match class { TerminalSymbol::Term(class) => self .shift_goto_map_class .get(class.wrapping_sub(self.shift_class_offset)) .copied() - .flatten(), - TerminalSymbol::Error => self.error_shift, - TerminalSymbol::Eof => self.eof_shift, + .flatten() + .map(|s| ShiftTarget { + state: s.state.into(), + push: s.push, + }), + TerminalSymbol::Error => self.error_shift.map(|s| ShiftTarget { + state: s.into(), + push: false, + }), + TerminalSymbol::Eof => self.eof_shift.map(|s| ShiftTarget { + state: s.into(), + push: false, + }), } - .map(Into::into) } - fn shift_goto_nonterm(&self, nonterm: &NonTerm) -> Option + fn shift_goto_nonterm(&self, nonterm: &NonTerm) -> Option> where NonTerm: Hash + Eq + NonTerminal, { @@ -266,7 +299,10 @@ impl + .get(nonterm.wrapping_sub(self.shift_nonterm_offset)) .copied() .flatten() - .map(Into::into) + .map(|s| ShiftTarget { + state: s.state.into(), + push: s.push, + }) } fn reduce( &self, @@ -312,16 +348,12 @@ impl + } } -impl +impl From> - for SparseState + for SparseState where - Term: Ord + TryInto, - Term::Error: std::fmt::Debug, - TermTo: Hash + Eq, + Term: Ord + std::hash::Hash, NonTerm: Hash + Eq, - StateIndex: TryInto, - StateIndex::Error: std::fmt::Debug, RuleContainer: ReduceRules, RuleContainer::RuleIndex: TryFrom, { @@ -353,30 +385,10 @@ where let error_reduce = builder_state.error_reduce.map(RuleContainer::from_set); SparseState { - shift_goto_map_class: builder_state - .shift_goto_map_term - .into_iter() - .map(|(term, state)| { - ( - term.try_into().expect("term conversion failed"), - state.try_into().expect("state conversion failed"), - ) - }) - .collect(), - error_shift: error_shift.map(|s| s.try_into().expect("error shift conversion failed")), - eof_shift: eof_shift.map(|s| s.try_into().expect("eof shift conversion failed")), - shift_goto_map_nonterm: builder_state - .shift_goto_map_nonterm - .into_iter() - .map(|(nonterm, state)| { - ( - nonterm, - state - .try_into() - .expect("non-terminal state conversion failed"), - ) - }) - .collect(), + shift_goto_map_class: builder_state.shift_goto_map_term.into_iter().collect(), + error_shift, + eof_shift, + shift_goto_map_nonterm: builder_state.shift_goto_map_nonterm.into_iter().collect(), reduce_map: builder_state .reduce_map .into_iter() @@ -393,14 +405,13 @@ where } } } -impl +impl From> - for DenseState + for DenseState where Term: Ord + Into + Copy, NonTerm: Hash + Eq + Copy + NonTerminal, - StateIndex: TryInto, - StateIndex::Error: std::fmt::Debug, + StateIndex: Copy, RuleContainer: Clone + ReduceRules, RuleContainer::RuleIndex: TryFrom, { @@ -472,8 +483,7 @@ where let mut shift_goto_map_class = vec![None; shift_len]; for (term, state) in builder_state.shift_goto_map_term { - shift_goto_map_class[term.into() - shift_min] = - Some(state.try_into().expect("state conversion failed")); + shift_goto_map_class[term.into() - shift_min] = Some(state); } let mut reduce_map = vec![None; reduce_len]; @@ -488,18 +498,14 @@ where .collect(); let mut shift_goto_map_nonterm = vec![None; nonterm_len]; for (nonterm, state) in builder_state.shift_goto_map_nonterm { - shift_goto_map_nonterm[nonterm.to_usize() - nonterm_min] = Some( - state - .try_into() - .expect("non-terminal state conversion failed"), - ); + shift_goto_map_nonterm[nonterm.to_usize() - nonterm_min] = Some(state); } DenseState { shift_goto_map_class, shift_class_offset: shift_min, - error_shift: error_shift.map(|s| s.try_into().expect("error shift conversion failed")), - eof_shift: eof_shift.map(|s| s.try_into().expect("EOF shift conversion failed")), + error_shift, + eof_shift, shift_goto_map_nonterm, shift_goto_map_nonterm_keys: nonterm_keys, shift_nonterm_offset: nonterm_min, diff --git a/rusty_lr_parser/src/emit.rs b/rusty_lr_parser/src/emit.rs index c1c8e20..5002028 100644 --- a/rusty_lr_parser/src/emit.rs +++ b/rusty_lr_parser/src/emit.rs @@ -434,64 +434,66 @@ impl Grammar { }; for state in &self.states { let mut shift_term_body_stream = TokenStream::new(); - let mut error_shift_stream = quote! {None}; - let mut eof_shift_stream = quote! {None}; - for (&term, &next_state) in &state.shift_goto_map_term { - let next_state = proc_macro2::Literal::usize_unsuffixed(next_state); - match term { - TerminalSymbol::Error => { - error_shift_stream = quote! {Some(#next_state)}; - continue; - } - TerminalSymbol::Eof => { - eof_shift_stream = quote! {Some(#next_state)}; - continue; - } - TerminalSymbol::Term(term) => { - let term = proc_macro2::Literal::usize_unsuffixed(term); - shift_term_body_stream.extend(quote! { - (#term, #next_state), - }); - } - } + let error_shift_stream = state + .error_shift + .map(|next_state| { + let next_state = proc_macro2::Literal::usize_unsuffixed(next_state); + quote! {Some(#next_state)} + }) + .unwrap_or(quote! {None}); + let eof_shift_stream = state + .eof_shift + .map(|next_state| { + let next_state = proc_macro2::Literal::usize_unsuffixed(next_state); + quote! {Some(#next_state)} + }) + .unwrap_or(quote! {None}); + for &(term, next_state) in &state.shift_goto_map_term { + let push = next_state.push; + let next_state = proc_macro2::Literal::usize_unsuffixed(next_state.state); + let term = proc_macro2::Literal::usize_unsuffixed(term); + shift_term_body_stream.extend(quote! { + (#term, #module_prefix::parser::state::ShiftTarget::new(#next_state,#push)), + }); } let mut shift_nonterm_body_stream = TokenStream::new(); - for (&nonterm, &next_state) in &state.shift_goto_map_nonterm { + for &(nonterm, next_state) in &state.shift_goto_map_nonterm { let nonterm_stream = &nonterminals_token[nonterm]; - let next_state = proc_macro2::Literal::usize_unsuffixed(next_state); + let push = next_state.push; + let next_state = proc_macro2::Literal::usize_unsuffixed(next_state.state); shift_nonterm_body_stream.extend(quote! { - (#nonterm_stream, #next_state), + (#nonterm_stream, #module_prefix::parser::state::ShiftTarget::new(#next_state,#push)), }); } let mut reduce_body_stream = TokenStream::new(); + let error_reduce_stream = state + .error_reduce + .as_ref() + .map(|rules| { + let rules_it = rules + .iter() + .map(|&rule| proc_macro2::Literal::usize_unsuffixed(rule)); + quote! {Some(vec![#(#rules_it),*])} + }) + .unwrap_or(quote! {None}); + let eof_reduce_stream = state + .eof_reduce + .as_ref() + .map(|rules| { + let rules_it = rules + .iter() + .map(|&rule| proc_macro2::Literal::usize_unsuffixed(rule)); + quote! {Some(vec![#(#rules_it),*])} + }) + .unwrap_or(quote! {None}); let mut reduce_rules_terms_map = std::collections::BTreeMap::new(); - let mut error_reduce_stream = quote! {None}; - let mut eof_reduce_stream = quote! {None}; - for (&term, rules) in &state.reduce_map { - match term { - TerminalSymbol::Error => { - let rules_it = rules - .iter() - .map(|&rule| proc_macro2::Literal::usize_unsuffixed(rule)); - error_reduce_stream = quote! {Some(vec![#(#rules_it),*])}; - continue; - } - TerminalSymbol::Eof => { - let rules_it = rules - .iter() - .map(|&rule| proc_macro2::Literal::usize_unsuffixed(rule)); - eof_reduce_stream = quote! {Some(vec![#(#rules_it),*])}; - continue; - } - TerminalSymbol::Term(term) => { - reduce_rules_terms_map - .entry(rules) - .or_insert_with(std::collections::BTreeSet::new) - .insert(term); - } - } + for (term, rules) in &state.reduce_map { + reduce_rules_terms_map + .entry(rules) + .or_insert_with(std::collections::BTreeSet::new) + .insert(*term); } for (rules, terms) in reduce_rules_terms_map { let terms_set_name = get_or_insert_terminal_set(terms); @@ -1124,52 +1126,81 @@ impl Grammar { match &rule.reduce_action { Some(ReduceAction::Custom(reduce_action)) => { - let mut debug_tag_check_stream = TokenStream::new(); - let mut stack_mapto_map = std::collections::BTreeMap::new(); - for (token_index_from_end, token) in rule.tokens.iter().rev().enumerate() { - let stack_name = token_to_stack_name(token.token); - let tag_name = stack_name.unwrap_or(&empty_tag_name); - - #[derive(PartialEq, Eq, PartialOrd, Ord)] - enum StackName { - DataStack(Ident), - LocationStack, - } - impl StackName { - pub fn to_token_stream(&self) -> TokenStream { - match self { - StackName::DataStack(name) => quote! {__data_stack.#name}, - StackName::LocationStack => quote! {__location_stack}, - } + if rule.is_used { + let mut debug_tag_check_stream = TokenStream::new(); + let mut stack_mapto_map = std::collections::BTreeMap::new(); + for (token_index_from_end, token) in + rule.tokens.iter().rev().enumerate() + { + let stack_name = token_to_stack_name(token.token); + let tag_name = stack_name.unwrap_or(&empty_tag_name); + + #[derive(PartialEq, Eq, PartialOrd, Ord)] + enum StackName { + DataStack(Ident), + LocationStack, } - } - fn tokenstream_contains_ident( - stream: TokenStream, - ident: &Ident, - ) -> bool { - for t in stream { - match t { - proc_macro2::TokenTree::Ident(i) if &i == ident => { - return true + impl StackName { + pub fn to_token_stream(&self) -> TokenStream { + match self { + StackName::DataStack(name) => { + quote! {__data_stack.#name} + } + StackName::LocationStack => quote! {__location_stack}, } - proc_macro2::TokenTree::Group(g) => { - if tokenstream_contains_ident(g.stream(), ident) { - return true; + } + } + fn tokenstream_contains_ident( + stream: TokenStream, + ident: &Ident, + ) -> bool { + for t in stream { + match t { + proc_macro2::TokenTree::Ident(i) if &i == ident => { + return true + } + proc_macro2::TokenTree::Group(g) => { + if tokenstream_contains_ident(g.stream(), ident) { + return true; + } } + _ => {} } - _ => {} } + false } - false - } - if let Some(stack_name) = stack_name { - // if variable was not used at this reduce action, - // we can use `truncate` instead of `pop` for optimization - // so check it here - let mapto = if let Some(mapto) = &token.mapto { - if tokenstream_contains_ident(reduce_action.clone(), mapto) { - Some(mapto.clone()) + if let Some(stack_name) = stack_name { + // if variable was not used at this reduce action, + // we can use `truncate` instead of `pop` for optimization + // so check it here + let mapto = if let Some(mapto) = &token.mapto { + if tokenstream_contains_ident(reduce_action.clone(), mapto) + { + Some(mapto.clone()) + } else { + None + } + } else { + None + }; + stack_mapto_map + .entry(StackName::DataStack(stack_name.clone())) + .or_insert_with(Vec::new) + .push(mapto); + } + let location_mapto = if let Some(mapto) = &token.mapto { + let location_varname = + format_ident!("__rustylr_location_{}", mapto); + + // if variable was not used at this reduce action, + // we can use `truncate` instead of `pop` for optimization + // so check it here + if tokenstream_contains_ident( + reduce_action.clone(), + &location_varname, + ) { + Some(location_varname) } else { None } @@ -1177,177 +1208,161 @@ impl Grammar { None }; stack_mapto_map - .entry(StackName::DataStack(stack_name.clone())) + .entry(StackName::LocationStack) .or_insert_with(Vec::new) - .push(mapto); - } - let location_mapto = if let Some(mapto) = &token.mapto { - let location_varname = - format_ident!("__rustylr_location_{}", mapto); - - // if variable was not used at this reduce action, - // we can use `truncate` instead of `pop` for optimization - // so check it here - if tokenstream_contains_ident( - reduce_action.clone(), - &location_varname, - ) { - Some(location_varname) - } else { - None - } - } else { - None - }; - stack_mapto_map - .entry(StackName::LocationStack) - .or_insert_with(Vec::new) - .push(location_mapto); + .push(location_mapto); - debug_tag_check_stream.extend(quote! { + debug_tag_check_stream.extend(quote! { debug_assert!( __data_stack.#tag_stack_name.get( __data_stack.#tag_stack_name.len()-1-#token_index_from_end ) == Some( &#tag_enum_name::#tag_name ) ); }); - } + } - // if there are variable with same name, the last one will be used (by shadowing) - // so set the front one to `None` - // this will also help optimizing performance by using `truncate` instead of `pop` - for maptos in &mut stack_mapto_map.values_mut() { - for var_right in (0..maptos.len()).rev() { - if let Some(var_name) = maptos[var_right].as_ref().cloned() { - for var_left in 0..var_right { - if maptos[var_left].as_ref() == Some(&var_name) { - maptos[var_left] = None; + // if there are variable with same name, the last one will be used (by shadowing) + // so set the front one to `None` + // this will also help optimizing performance by using `truncate` instead of `pop` + for maptos in &mut stack_mapto_map.values_mut() { + for var_right in (0..maptos.len()).rev() { + if let Some(var_name) = maptos[var_right].as_ref().cloned() { + for var_left in 0..var_right { + if maptos[var_left].as_ref() == Some(&var_name) { + maptos[var_left] = None; + } } } } } - } - // new tag that will be inserted by this reduce action - let new_tag_name = stack_names_for_nonterm[nonterm_idx] - .as_ref() - .unwrap_or(&empty_tag_name); - // pop n tokens from tag_stack and push new reduced tag - let modify_tag_stream = if rule.tokens.len() > 0 { - // if first token's tag is equal to new_tag, no need to (pop n tokens -> push new token). - // just pop n-1 tokens - let first_tag_name = token_to_stack_name(rule.tokens[0].token) + // new tag that will be inserted by this reduce action + let new_tag_name = stack_names_for_nonterm[nonterm_idx] + .as_ref() .unwrap_or(&empty_tag_name); - - if first_tag_name == new_tag_name { - // pop n-1 tokens, no new insertion - let len = rule.tokens.len() - 1; - let truncate_stream = if len > 0 { - quote! {__data_stack.#tag_stack_name.truncate(__data_stack.#tag_stack_name.len() - #len);} + // pop n tokens from tag_stack and push new reduced tag + let modify_tag_stream = if rule.tokens.len() > 0 { + // if first token's tag is equal to new_tag, no need to (pop n tokens -> push new token). + // just pop n-1 tokens + let first_tag_name = token_to_stack_name(rule.tokens[0].token) + .unwrap_or(&empty_tag_name); + + if first_tag_name == new_tag_name { + // pop n-1 tokens, no new insertion + let len = rule.tokens.len() - 1; + let truncate_stream = if len > 0 { + quote! {__data_stack.#tag_stack_name.truncate(__data_stack.#tag_stack_name.len() - #len);} + } else { + TokenStream::new() + }; + truncate_stream } else { - TokenStream::new() - }; - truncate_stream + let len = rule.tokens.len(); + // len > 0 here + quote! { + __data_stack.#tag_stack_name.truncate(__data_stack.#tag_stack_name.len() - #len); + __data_stack.#tag_stack_name.push(#tag_enum_name::#new_tag_name); + } + } } else { - let len = rule.tokens.len(); - // len > 0 here quote! { - __data_stack.#tag_stack_name.truncate(__data_stack.#tag_stack_name.len() - #len); __data_stack.#tag_stack_name.push(#tag_enum_name::#new_tag_name); } - } - } else { - quote! { - __data_stack.#tag_stack_name.push(#tag_enum_name::#new_tag_name); - } - }; - - let mut extract_data_stream = TokenStream::new(); - for (stack_name, maptos) in stack_mapto_map.iter() { - let stack_stream = stack_name.to_token_stream(); - - // if there are consecutive `None` mapto, truncate instead of pop - let mut last_none_count: usize = 0; - for mapto in maptos { - match mapto { - Some(mapto) => { - if last_none_count > 0 { - extract_data_stream.extend(quote! { + }; + + let mut extract_data_stream = TokenStream::new(); + for (stack_name, maptos) in stack_mapto_map.iter() { + let stack_stream = stack_name.to_token_stream(); + + // if there are consecutive `None` mapto, truncate instead of pop + let mut last_none_count: usize = 0; + for mapto in maptos { + match mapto { + Some(mapto) => { + if last_none_count > 0 { + extract_data_stream.extend(quote! { #stack_stream.truncate(#stack_stream.len() - #last_none_count); }); - last_none_count = 0; + last_none_count = 0; + } + extract_data_stream.extend(quote! { + let mut #mapto = #stack_stream.pop().unwrap(); + }); + } + None => { + last_none_count += 1; } - extract_data_stream.extend(quote! { - let mut #mapto = #stack_stream.pop().unwrap(); - }); - } - None => { - last_none_count += 1; } } - } - if last_none_count > 0 { - extract_data_stream.extend(quote! { + if last_none_count > 0 { + extract_data_stream.extend(quote! { #stack_stream.truncate(#stack_stream.len() - #last_none_count); }); + } } - } - reduce_action_case_streams.extend(quote! { - #rule_index => Self::#reduce_fn_ident( data_stack, location_stack, shift, lookahead, user_data, location0 ), - }); + reduce_action_case_streams.extend(quote! { + #rule_index => Self::#reduce_fn_ident( data_stack, location_stack, shift, lookahead, user_data, location0 ), + }); - // typename is defined, reduce action must be defined - if let Some(stack_name) = &stack_names_for_nonterm[nonterm_idx] { - fn_reduce_for_each_rule_stream.extend(quote! { - #[doc = #rule_debug_str] - #[inline] - fn #reduce_fn_ident( - __data_stack: &mut Self, - __location_stack: &mut Vec<#location_typename>, - shift: &mut bool, - lookahead: &#module_prefix::TerminalSymbol<#token_typename>, - #user_data_parameter_name: &mut #user_data_typename, - __rustylr_location0: &mut #location_typename, - ) -> Result<(), #reduce_error_typename> { - #[cfg(debug_assertions)] - { - #debug_tag_check_stream - } - #modify_tag_stream + let returns_non_empty = stack_names_for_nonterm[nonterm_idx].is_some(); + + // typename is defined, reduce action must be defined + if let Some(stack_name) = &stack_names_for_nonterm[nonterm_idx] { + fn_reduce_for_each_rule_stream.extend(quote! { + #[doc = #rule_debug_str] + #[inline] + fn #reduce_fn_ident( + __data_stack: &mut Self, + __location_stack: &mut Vec<#location_typename>, + shift: &mut bool, + lookahead: &#module_prefix::TerminalSymbol<#token_typename>, + #user_data_parameter_name: &mut #user_data_typename, + __rustylr_location0: &mut #location_typename, + ) -> Result { + #[cfg(debug_assertions)] + { + #debug_tag_check_stream + } + #modify_tag_stream - #extract_data_stream + #extract_data_stream - let __res = #reduce_action ; - __data_stack.#stack_name.push(__res); + let __res = #reduce_action ; + __data_stack.#stack_name.push(__res); - Ok(()) - } - }); - } else { - fn_reduce_for_each_rule_stream.extend(quote! { - #[doc = #rule_debug_str] - #[inline] - fn #reduce_fn_ident( - __data_stack: &mut Self, - __location_stack: &mut Vec<#location_typename>, - shift: &mut bool, - lookahead: &#module_prefix::TerminalSymbol<#token_typename>, - #user_data_parameter_name: &mut #user_data_typename, - __rustylr_location0: &mut #location_typename, - ) -> Result<(), #reduce_error_typename> { - #[cfg(debug_assertions)] - { - #debug_tag_check_stream + Ok(#returns_non_empty) } - #modify_tag_stream + }); + } else { + fn_reduce_for_each_rule_stream.extend(quote! { + #[doc = #rule_debug_str] + #[inline] + fn #reduce_fn_ident( + __data_stack: &mut Self, + __location_stack: &mut Vec<#location_typename>, + shift: &mut bool, + lookahead: &#module_prefix::TerminalSymbol<#token_typename>, + #user_data_parameter_name: &mut #user_data_typename, + __rustylr_location0: &mut #location_typename, + ) -> Result { + #[cfg(debug_assertions)] + { + #debug_tag_check_stream + } + #modify_tag_stream - #extract_data_stream + #extract_data_stream - #reduce_action + #reduce_action - Ok(()) - } + Ok(#returns_non_empty) + } + }); + } + } else { + reduce_action_case_streams.extend(quote! { + #rule_index => unreachable!("{rule_index}: this production rule was optimized out"), }); } } @@ -1355,179 +1370,194 @@ impl Grammar { // E(i32): a b c(i32) d e ; // 'c' will be automatically chosen, even if there is no reduce action &Some(ReduceAction::Identity(identity_token_idx)) => { - reduce_action_case_streams.extend(quote! { - #rule_index => { Self::#reduce_fn_ident( data_stack, location_stack ); Ok(()) } - }); + if rule.is_used { + reduce_action_case_streams.extend(quote! { + #rule_index => { Ok(Self::#reduce_fn_ident( data_stack, location_stack )) } + }); - let mut stack_count_map = std::collections::BTreeMap::new(); - let mut pop_stack_idx_pair = None; - for (token_idx, token) in rule.tokens.iter().enumerate().rev() { - let stack_name = token_to_stack_name(token.token); + let mut stack_count_map = std::collections::BTreeMap::new(); + let mut pop_stack_idx_pair = None; + for (token_idx, token) in rule.tokens.iter().enumerate().rev() { + let stack_name = token_to_stack_name(token.token); - if token_idx == identity_token_idx { - if let Some(stack_name) = stack_name { - let idx_from_back = - stack_count_map.get(stack_name).copied().unwrap_or(0); - pop_stack_idx_pair = Some((stack_name, idx_from_back)); - } - } else { - if let Some(stack_name) = stack_name { - *stack_count_map.entry(stack_name).or_insert(0usize) += 1; + if token_idx == identity_token_idx { + if let Some(stack_name) = stack_name { + let idx_from_back = + stack_count_map.get(stack_name).copied().unwrap_or(0); + pop_stack_idx_pair = Some((stack_name, idx_from_back)); + } + } else { + if let Some(stack_name) = stack_name { + *stack_count_map.entry(stack_name).or_insert(0usize) += 1; + } } } - } - let len = rule.tokens.len(); - debug_assert!(len > 0); - - // let temp = stack.swap_remove( i ); <-- pop_stream - // stack.truncate( len-1 ); <-- truncate_stream - // stack.push( temp ); <-- push_stream - - let (stack_pop_stream, stack_push_stream) = if let Some(( - pop_stack, - pop_index_from_back, - )) = pop_stack_idx_pair - { - // if i is the first inserted element on the stack, no need to pop and push - if pop_index_from_back - == stack_count_map.get(pop_stack).copied().unwrap_or(0) - { - (quote! {}, quote! {}) - } else { - ( - quote! { let __ret = __data_stack.#pop_stack.swap_remove( __data_stack.#pop_stack.len() - 1 - #pop_index_from_back ); }, - quote! { __data_stack.#pop_stack.push(__ret); }, - ) - } - } else { - (quote! {}, quote! {}) - }; - let mut stack_truncate_stream = TokenStream::new(); - for (stack_name, count) in stack_count_map { - debug_assert!(count > 0); - stack_truncate_stream.extend(quote! { - __data_stack.#stack_name.truncate(__data_stack.#stack_name.len() - #count); - }); - } + let len = rule.tokens.len(); + debug_assert!(len > 0); - let is_0th_token_same_tag_ith_token = - token_to_stack_name(rule.tokens[0].token) - == token_to_stack_name(rule.tokens[identity_token_idx].token); + // let temp = stack.swap_remove( i ); <-- pop_stream + // stack.truncate( len-1 ); <-- truncate_stream + // stack.push( temp ); <-- push_stream - let (tags_truncate_stream, tag_push_stream) = - if is_0th_token_same_tag_ith_token { - let truncate_len = len - 1; - if truncate_len > 0 { + let (stack_pop_stream, stack_push_stream) = if let Some(( + pop_stack, + pop_index_from_back, + )) = pop_stack_idx_pair + { + // if i is the first inserted element on the stack, no need to pop and push + if pop_index_from_back + == stack_count_map.get(pop_stack).copied().unwrap_or(0) + { + (quote! {}, quote! {}) + } else { ( - quote! { __data_stack.#tag_stack_name.truncate(__data_stack.#tag_stack_name.len() - #truncate_len); }, - quote! {}, + quote! { let __ret = __data_stack.#pop_stack.swap_remove( __data_stack.#pop_stack.len() - 1 - #pop_index_from_back ); }, + quote! { __data_stack.#pop_stack.push(__ret); }, ) - } else { - (quote! {}, quote! {}) } } else { - let tag_push_stream = if let Some((pop_stack, _)) = - pop_stack_idx_pair - { - quote! { __data_stack.#tag_stack_name.push(#tag_enum_name::#pop_stack); } + (quote! {}, quote! {}) + }; + let mut stack_truncate_stream = TokenStream::new(); + for (stack_name, count) in stack_count_map { + debug_assert!(count > 0); + stack_truncate_stream.extend(quote! { + __data_stack.#stack_name.truncate(__data_stack.#stack_name.len() - #count); + }); + } + + let is_0th_token_same_tag_ith_token = + token_to_stack_name(rule.tokens[0].token) + == token_to_stack_name(rule.tokens[identity_token_idx].token); + + let (tags_truncate_stream, tag_push_stream) = + if is_0th_token_same_tag_ith_token { + let truncate_len = len - 1; + if truncate_len > 0 { + ( + quote! { __data_stack.#tag_stack_name.truncate(__data_stack.#tag_stack_name.len() - #truncate_len); }, + quote! {}, + ) + } else { + (quote! {}, quote! {}) + } } else { - quote! {__data_stack.#tag_stack_name.push(#tag_enum_name::#empty_tag_name); } + let tag_push_stream = if let Some((pop_stack, _)) = + pop_stack_idx_pair + { + quote! { __data_stack.#tag_stack_name.push(#tag_enum_name::#pop_stack); } + } else { + quote! {__data_stack.#tag_stack_name.push(#tag_enum_name::#empty_tag_name); } + }; + + let tags_truncate_stream = quote! { __data_stack.#tag_stack_name.truncate(__data_stack.#tag_stack_name.len() - #len); }; + + (tags_truncate_stream, tag_push_stream) }; - let tags_truncate_stream = quote! { __data_stack.#tag_stack_name.truncate(__data_stack.#tag_stack_name.len() - #len); }; + let location_truncate_stream = quote! { __location_stack.truncate(__location_stack.len() - #len); }; - (tags_truncate_stream, tag_push_stream) - }; + let returns_non_empty = pop_stack_idx_pair.is_some(); - let location_truncate_stream = - quote! { __location_stack.truncate(__location_stack.len() - #len); }; - - fn_reduce_for_each_rule_stream.extend(quote! { - #[doc = #rule_debug_str] - #[inline(always)] - fn #reduce_fn_ident( - __data_stack: &mut Self, - __location_stack: &mut Vec<#location_typename>, - ) { - #stack_pop_stream // __ret = stack.swap_remove(i); - #stack_truncate_stream // stack.truncate( ... ); - #stack_push_stream // stack.push( __ret ); - #location_truncate_stream // location.truncate( ... ); - #tags_truncate_stream // tags.truncate( ... ); - #tag_push_stream // tag.push( ... ); - } - }); + fn_reduce_for_each_rule_stream.extend(quote! { + #[doc = #rule_debug_str] + #[inline(always)] + fn #reduce_fn_ident( + __data_stack: &mut Self, + __location_stack: &mut Vec<#location_typename>, + ) -> bool { + #stack_pop_stream // __ret = stack.swap_remove(i); + #stack_truncate_stream // stack.truncate( ... ); + #stack_push_stream // stack.push( __ret ); + #location_truncate_stream // location.truncate( ... ); + #tags_truncate_stream // tags.truncate( ... ); + #tag_push_stream // tag.push( ... ); + + #returns_non_empty + } + }); + } else { + reduce_action_case_streams.extend(quote! { + #rule_index => unreachable!("{rule_index}: this production rule was optimized out"), + }); + } } // E: a b c d ... // 'E' does not have rule type, so no need for a reduce action None => { - reduce_action_case_streams.extend(quote! { - #rule_index => { Self::#reduce_fn_ident( data_stack, location_stack ); Ok(()) } - }); - - let mut stack_count_map = std::collections::BTreeMap::new(); - for token in rule.tokens.iter() { - let stack_name = token_to_stack_name(token.token); - if let Some(stack_name) = stack_name { - *stack_count_map.entry(stack_name).or_insert(0usize) += 1; + if rule.is_used { + reduce_action_case_streams.extend(quote! { + #rule_index => { Self::#reduce_fn_ident( data_stack, location_stack ); Ok(false) } + }); + + let mut stack_count_map = std::collections::BTreeMap::new(); + for token in rule.tokens.iter() { + let stack_name = token_to_stack_name(token.token); + if let Some(stack_name) = stack_name { + *stack_count_map.entry(stack_name).or_insert(0usize) += 1; + } } - } - let mut stack_truncate_stream = TokenStream::new(); - for (stack_name, count) in stack_count_map { - debug_assert!(count > 0); - stack_truncate_stream.extend(quote! { + let mut stack_truncate_stream = TokenStream::new(); + for (stack_name, count) in stack_count_map { + debug_assert!(count > 0); + stack_truncate_stream.extend(quote! { __data_stack.#stack_name.truncate(__data_stack.#stack_name.len() - #count); }); - } - let location_truncate_stream = if rule.tokens.len() > 0 { - let len = rule.tokens.len(); - quote! { __location_stack.truncate(__location_stack.len() - #len); } - } else { - quote! {} - }; - let (tags_truncate_stream, tag_push_stream) = if rule.tokens.len() > 0 { - let is_first_token_empty_tag = - token_to_stack_name(rule.tokens[0].token).is_none(); - if is_first_token_empty_tag { - // pop n-1 tags and use n-1'th tag as-is - let len = rule.tokens.len() - 1; - if len > 0 { + } + let location_truncate_stream = if rule.tokens.len() > 0 { + let len = rule.tokens.len(); + quote! { __location_stack.truncate(__location_stack.len() - #len); } + } else { + quote! {} + }; + let (tags_truncate_stream, tag_push_stream) = if rule.tokens.len() > 0 { + let is_first_token_empty_tag = + token_to_stack_name(rule.tokens[0].token).is_none(); + if is_first_token_empty_tag { + // pop n-1 tags and use n-1'th tag as-is + let len = rule.tokens.len() - 1; + if len > 0 { + ( + quote! { __data_stack.#tag_stack_name.truncate(__data_stack.#tag_stack_name.len() - #len); }, + quote! {}, + ) + } else { + (quote! {}, quote! {}) + } + } else { + // pop all n tags and push empty tag + let len = rule.tokens.len(); ( quote! { __data_stack.#tag_stack_name.truncate(__data_stack.#tag_stack_name.len() - #len); }, - quote! {}, + quote! { __data_stack.#tag_stack_name.push(#tag_enum_name::#empty_tag_name); }, ) - } else { - (quote! {}, quote! {}) } } else { - // pop all n tags and push empty tag - let len = rule.tokens.len(); ( - quote! { __data_stack.#tag_stack_name.truncate(__data_stack.#tag_stack_name.len() - #len); }, + quote! {}, quote! { __data_stack.#tag_stack_name.push(#tag_enum_name::#empty_tag_name); }, ) - } + }; + fn_reduce_for_each_rule_stream.extend(quote! { + #[doc = #rule_debug_str] + #[inline(always)] + fn #reduce_fn_ident( + __data_stack: &mut Self, + __location_stack: &mut Vec<#location_typename>, + ) { + #stack_truncate_stream + #location_truncate_stream + #tags_truncate_stream + #tag_push_stream + } + }); } else { - ( - quote! {}, - quote! { __data_stack.#tag_stack_name.push(#tag_enum_name::#empty_tag_name); }, - ) - }; - fn_reduce_for_each_rule_stream.extend(quote! { - #[doc = #rule_debug_str] - #[inline(always)] - fn #reduce_fn_ident( - __data_stack: &mut Self, - __location_stack: &mut Vec<#location_typename>, - ) { - #stack_truncate_stream - #location_truncate_stream - #tags_truncate_stream - #tag_push_stream - } - }); + reduce_action_case_streams.extend(quote! { + #rule_index => unreachable!("{rule_index}: this production rule was optimized out"), + }); + } } } rule_index += 1; @@ -1704,7 +1734,7 @@ impl Grammar { lookahead: &#module_prefix::TerminalSymbol, user_data: &mut Self::UserData, location0: &mut Self::Location, - ) -> Result<(), Self::ReduceActionError> { + ) -> Result { match rule_index { #reduce_action_case_streams _ => { diff --git a/rusty_lr_parser/src/grammar.rs b/rusty_lr_parser/src/grammar.rs index b21967e..06d3a13 100644 --- a/rusty_lr_parser/src/grammar.rs +++ b/rusty_lr_parser/src/grammar.rs @@ -100,7 +100,7 @@ pub struct Grammar { /// do terminal classificate optimization pub optimize: bool, pub builder: rusty_lr_core::builder::Grammar, usize>, - pub states: Vec, usize>>, + pub states: Vec>, /// set of terminals for each terminal class pub terminal_classes: Vec, @@ -770,6 +770,7 @@ impl Grammar { lookaheads: None, prec, dprec, + is_used: true, }); } @@ -869,6 +870,7 @@ impl Grammar { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let nonterminal_info = NonTerminalInfo { name: augmented_ident.clone(), @@ -1552,12 +1554,213 @@ impl Grammar { self.builder.build(augmented_idx, &mut collector) }; let states = match states { - Ok(states) => states, + Ok(states) => states.states, Err(err) => { unreachable!("Error building grammar: {:?}", err); } }; - self.states = states.states; + let mut states: Vec< + rusty_lr_core::parser::state::IntermediateState, + > = states.into_iter().map(Into::into).collect(); + + // Identify states that only perform a single reduction of a single-token rule. + // These are candidates for optimization. + let mut reduce_states: Vec<_> = Vec::with_capacity(states.len()); + for state in states.iter() { + if state.eof_shift.is_some() + || state.error_shift.is_some() + || !state.shift_goto_map_term.is_empty() + || !state.shift_goto_map_nonterm.is_empty() + { + // this state is not a reduce state + reduce_states.push(None); + continue; + } + + let rules = state + .reduce_map + .iter() + .map(|(_, r)| r) + .chain(state.eof_reduce.iter()) + .chain(state.error_reduce.iter()) + .collect::>(); + + if rules.len() != 1 { + reduce_states.push(None); + continue; + } + let rule_set = rules.into_iter().next().unwrap(); + if rule_set.len() != 1 { + reduce_states.push(None); + continue; + } + let rule = rule_set[0]; + let (nonterm, local_rule_id) = self.get_rule_by_id(rule).unwrap(); + if nonterm.rules[local_rule_id].tokens.len() != 1 { + reduce_states.push(None); + continue; + } + + let nonterm_idx = self.nonterminals_index[&nonterm.name]; + reduce_states.push(Some((nonterm_idx, local_rule_id))); + } + + // Iteratively optimize the state machine by bypassing the reduce-only states identified above. + // This continues until no more optimizations can be made. + loop { + let mut changed = false; + + for state in &mut states { + // Optimize shift-on-terminal transitions. + for (_, next_state) in &mut state.shift_goto_map_term { + if let Some((nonterm_idx, rule_local_id)) = reduce_states[next_state.state] { + let rule = &self.nonterminals[nonterm_idx].rules[rule_local_id]; + match rule.reduce_action { + None => { + let idx = state + .shift_goto_map_nonterm + .iter() + .position(|(nt, _)| *nt == nonterm_idx) + .unwrap(); + let ns = state.shift_goto_map_nonterm[idx].1; + next_state.state = ns.state; + next_state.push = false; + changed = true; + } + Some(ReduceAction::Identity(_)) => { + let idx = state + .shift_goto_map_nonterm + .iter() + .position(|(nt, _)| *nt == nonterm_idx) + .unwrap(); + let ns = state.shift_goto_map_nonterm[idx].1; + next_state.state = ns.state; + next_state.push = true; + changed = true; + } + _ => {} + } + } + } + + // Optimize shift-on-nonterminal transitions. + for i in 0..state.shift_goto_map_nonterm.len() { + let next_state = state.shift_goto_map_nonterm[i].1; + if let Some((nonterm_idx, rule_local_id)) = reduce_states[next_state.state] { + let rule = &self.nonterminals[nonterm_idx].rules[rule_local_id]; + match rule.reduce_action { + None => { + let idx = state + .shift_goto_map_nonterm + .iter() + .position(|(nt, _)| *nt == nonterm_idx) + .unwrap(); + let ns = state.shift_goto_map_nonterm[idx].1; + state.shift_goto_map_nonterm[i].1.state = ns.state; + state.shift_goto_map_nonterm[i].1.push = false; + changed = true; + } + Some(ReduceAction::Identity(_)) => { + let idx = state + .shift_goto_map_nonterm + .iter() + .position(|(nt, _)| *nt == nonterm_idx) + .unwrap(); + let ns = state.shift_goto_map_nonterm[idx].1; + state.shift_goto_map_nonterm[i].1.state = ns.state; + state.shift_goto_map_nonterm[i].1.push = true; + changed = true; + } + _ => {} + } + } + } + } + + if !changed { + break; + } + } + + // Identify all reachable states starting from the initial state (state 0). + let mut states_used = vec![false; states.len()]; + let mut ping = vec![0]; + states_used[0] = true; + let mut pong = Vec::new(); + while !ping.is_empty() { + pong.clear(); + for &p in &ping { + let s = &states[p]; + + for next_state in s + .shift_goto_map_term + .iter() + .map(|(_, v)| v.state) + .chain(s.shift_goto_map_nonterm.iter().map(|(_, v)| v.state)) + .chain(s.eof_shift.iter().copied()) + .chain(s.error_shift.iter().copied()) + { + if !states_used[next_state] { + states_used[next_state] = true; + pong.push(next_state); + } + } + } + std::mem::swap(&mut ping, &mut pong); + } + + // Remove unreachable states and remap state indices. + let mut state_remap = Vec::with_capacity(states.len()); + let mut new_states = Vec::with_capacity(states.len()); + for (i, state) in states.into_iter().enumerate() { + state_remap.push(new_states.len()); + if states_used[i] { + new_states.push(state); + } + } + for state in &mut new_states { + for (_, next_state) in &mut state.shift_goto_map_term { + debug_assert!(states_used[next_state.state]); + next_state.state = state_remap[next_state.state]; + } + for (_, next_state) in &mut state.shift_goto_map_nonterm { + debug_assert!(states_used[next_state.state]); + next_state.state = state_remap[next_state.state]; + } + if let Some(next_state) = &mut state.eof_shift { + debug_assert!(states_used[*next_state]); + *next_state = state_remap[*next_state]; + } + if let Some(next_state) = &mut state.error_shift { + debug_assert!(states_used[*next_state]); + *next_state = state_remap[*next_state]; + } + } + + // check for unused production rules + let mut rules_used = vec![false; self.builder.rules.len()]; + for state in &new_states { + for rules in state + .reduce_map + .iter() + .map(|(_, r)| r) + .chain(state.eof_reduce.iter()) + .chain(state.error_reduce.iter()) + { + for &rule in rules { + rules_used[rule] = true; + } + } + } + let mut i = 0; + for nonterm in &mut self.nonterminals { + for rule in &mut nonterm.rules { + rule.is_used = rules_used[i]; + i += 1; + } + } + + self.states = new_states; collector } diff --git a/rusty_lr_parser/src/nonterminal_info.rs b/rusty_lr_parser/src/nonterminal_info.rs index 8fa4e1a..a24936e 100644 --- a/rusty_lr_parser/src/nonterminal_info.rs +++ b/rusty_lr_parser/src/nonterminal_info.rs @@ -33,6 +33,9 @@ pub struct Rule { pub prec: Option<(rusty_lr_core::rule::Precedence, Span)>, /// %dprec definition pub dprec: Option<(usize, Span)>, + + /// in `Grammar::build_grammar()`, some production rules will be optimized out and deleted + pub(crate) is_used: bool, } impl Rule { diff --git a/rusty_lr_parser/src/parser/parser_expanded.rs b/rusty_lr_parser/src/parser/parser_expanded.rs index 26da0ca..f1624e5 100644 --- a/rusty_lr_parser/src/parser/parser_expanded.rs +++ b/rusty_lr_parser/src/parser/parser_expanded.rs @@ -29,161 +29,161 @@ use rusty_lr_core::builder::ReduceType; ====================================Grammar===================================== # of terminal classes: 42 -# of states: 221 +# of states: 178 -Rule -> ident RuleType colon RuleLines semicolon -RuleType -> parengroup -RuleType -> -RuleLines -> RuleLines pipe RuleLine -RuleLines -> RuleLine -RuleLine -> TokenMapped* PrecDef* Action -PrecDef -> percent prec IdentOrLiteral -PrecDef -> percent prec error -PrecDef -> percent dprec literal -PrecDef -> percent dprec error -PrecDef -> percent error -TokenMapped -> Pattern -TokenMapped -> ident equal Pattern -TerminalSetItem -> ident -TerminalSetItem -> ident minus ident -TerminalSetItem -> ident minus error -TerminalSetItem -> literal -TerminalSetItem -> literal minus literal -TerminalSetItem -> literal minus error -TerminalSet -> lbracket caret? TerminalSetItem* rbracket -TerminalSet -> dot -Pattern -> ident -Pattern -> Pattern plus -Pattern -> Pattern star -Pattern -> Pattern question -Pattern -> Pattern exclamation -Pattern -> TerminalSet -Pattern -> Pattern slash Pattern -Pattern -> lparen $sep(Pattern*, pipe, +) rparen -Pattern -> lparen error rparen -Pattern -> literal -Pattern -> Pattern minus Pattern -Pattern -> dollar ident lparen Pattern comma Pattern comma? rparen -Pattern -> dollar ident lparen Pattern comma Pattern comma plus rparen -Pattern -> dollar ident lparen Pattern comma Pattern comma star rparen -Pattern -> dollar ident lparen Pattern comma Pattern error rparen -Pattern -> dollar ident lparen Pattern comma Pattern comma error rparen -Action -> bracegroup -Action -> -IdentOrLiteral -> ident -IdentOrLiteral -> literal -RustCode -> [^semicolon]+ -Directive -> percent token ident RustCode semicolon -Directive -> percent token ident semicolon -Directive -> percent token error semicolon -Directive -> percent start ident semicolon -Directive -> percent start error semicolon -Directive -> percent tokentype RustCode semicolon -Directive -> percent tokentype semicolon -Directive -> percent userdata RustCode semicolon -Directive -> percent userdata semicolon -Directive -> percent left IdentOrLiteral+ semicolon -Directive -> percent left error semicolon -Directive -> percent right IdentOrLiteral+ semicolon -Directive -> percent right error semicolon -Directive -> percent precedence IdentOrLiteral+ semicolon -Directive -> percent precedence error semicolon -Directive -> percent errortype RustCode semicolon -Directive -> percent errortype semicolon -Directive -> percent moduleprefix RustCode semicolon -Directive -> percent moduleprefix semicolon -Directive -> percent glr semicolon -Directive -> percent glr error semicolon -Directive -> percent lalr semicolon -Directive -> percent lalr error semicolon -Directive -> percent nooptim semicolon -Directive -> percent nooptim error semicolon -Directive -> percent dense semicolon -Directive -> percent dense error semicolon -Directive -> percent trace ident* semicolon -Directive -> percent trace error semicolon -Directive -> percent filter RustCode semicolon -Directive -> percent filter semicolon -Directive -> percent location RustCode semicolon -Directive -> percent location semicolon -Directive -> percent error semicolon -GrammarLine -> Rule -GrammarLine -> Directive -Grammar -> GrammarLine+ -TokenMapped+ -> TokenMapped -TokenMapped+ -> TokenMapped+ TokenMapped -TokenMapped* -> TokenMapped+ -TokenMapped* -> -PrecDef+ -> PrecDef -PrecDef+ -> PrecDef+ PrecDef -PrecDef* -> PrecDef+ -PrecDef* -> -caret? -> caret -caret? -> -TerminalSetItem+ -> TerminalSetItem -TerminalSetItem+ -> TerminalSetItem+ TerminalSetItem -TerminalSetItem* -> TerminalSetItem+ -TerminalSetItem* -> -Pattern+ -> Pattern -Pattern+ -> Pattern+ Pattern -Pattern* -> Pattern+ -Pattern* -> -$sep(Pattern*, pipe, +) -> Pattern* -$sep(Pattern*, pipe, +) -> $sep(Pattern*, pipe, +) pipe Pattern* -comma? -> comma -comma? -> -[^semicolon] -> ident -[^semicolon] -> colon -[^semicolon] -> pipe -[^semicolon] -> percent -[^semicolon] -> equal -[^semicolon] -> plus -[^semicolon] -> star -[^semicolon] -> question -[^semicolon] -> caret -[^semicolon] -> minus -[^semicolon] -> exclamation -[^semicolon] -> slash -[^semicolon] -> dot -[^semicolon] -> dollar -[^semicolon] -> comma -[^semicolon] -> literal -[^semicolon] -> parengroup -[^semicolon] -> bracegroup -[^semicolon] -> lparen -[^semicolon] -> rparen -[^semicolon] -> lbracket -[^semicolon] -> rbracket -[^semicolon] -> left -[^semicolon] -> right -[^semicolon] -> token -[^semicolon] -> start -[^semicolon] -> tokentype -[^semicolon] -> userdata -[^semicolon] -> errortype -[^semicolon] -> moduleprefix -[^semicolon] -> lalr -[^semicolon] -> glr -[^semicolon] -> prec -[^semicolon] -> precedence -[^semicolon] -> nooptim -[^semicolon] -> dense -[^semicolon] -> trace -[^semicolon] -> dprec -[^semicolon] -> filter -[^semicolon] -> location -[^semicolon] -> -[^semicolon]+ -> [^semicolon] -[^semicolon]+ -> [^semicolon]+ [^semicolon] -IdentOrLiteral+ -> IdentOrLiteral -IdentOrLiteral+ -> IdentOrLiteral+ IdentOrLiteral -ident+ -> ident -ident+ -> ident+ ident -ident* -> ident+ -ident* -> -GrammarLine+ -> GrammarLine -GrammarLine+ -> GrammarLine GrammarLine+ -Augmented -> Grammar eof +0: Rule -> ident RuleType colon RuleLines semicolon +1: RuleType -> parengroup +2: RuleType -> +3: RuleLines -> RuleLines pipe RuleLine +4: RuleLines -> RuleLine +5: RuleLine -> TokenMapped* PrecDef* Action +6: PrecDef -> percent prec IdentOrLiteral +7: PrecDef -> percent prec error +8: PrecDef -> percent dprec literal +9: PrecDef -> percent dprec error +10: PrecDef -> percent error +11: TokenMapped -> Pattern +12: TokenMapped -> ident equal Pattern +13: TerminalSetItem -> ident +14: TerminalSetItem -> ident minus ident +15: TerminalSetItem -> ident minus error +16: TerminalSetItem -> literal +17: TerminalSetItem -> literal minus literal +18: TerminalSetItem -> literal minus error +19: TerminalSet -> lbracket caret? TerminalSetItem* rbracket +20: TerminalSet -> dot +21: Pattern -> ident +22: Pattern -> Pattern plus +23: Pattern -> Pattern star +24: Pattern -> Pattern question +25: Pattern -> Pattern exclamation +26: Pattern -> TerminalSet +27: Pattern -> Pattern slash Pattern +28: Pattern -> lparen $sep(Pattern*, pipe, +) rparen +29: Pattern -> lparen error rparen +30: Pattern -> literal +31: Pattern -> Pattern minus Pattern +32: Pattern -> dollar ident lparen Pattern comma Pattern comma? rparen +33: Pattern -> dollar ident lparen Pattern comma Pattern comma plus rparen +34: Pattern -> dollar ident lparen Pattern comma Pattern comma star rparen +35: Pattern -> dollar ident lparen Pattern comma Pattern error rparen +36: Pattern -> dollar ident lparen Pattern comma Pattern comma error rparen +37: Action -> bracegroup +38: Action -> +39: IdentOrLiteral -> ident +40: IdentOrLiteral -> literal +41: RustCode -> [^semicolon]+ +42: Directive -> percent token ident RustCode semicolon +43: Directive -> percent token ident semicolon +44: Directive -> percent token error semicolon +45: Directive -> percent start ident semicolon +46: Directive -> percent start error semicolon +47: Directive -> percent tokentype RustCode semicolon +48: Directive -> percent tokentype semicolon +49: Directive -> percent userdata RustCode semicolon +50: Directive -> percent userdata semicolon +51: Directive -> percent left IdentOrLiteral+ semicolon +52: Directive -> percent left error semicolon +53: Directive -> percent right IdentOrLiteral+ semicolon +54: Directive -> percent right error semicolon +55: Directive -> percent precedence IdentOrLiteral+ semicolon +56: Directive -> percent precedence error semicolon +57: Directive -> percent errortype RustCode semicolon +58: Directive -> percent errortype semicolon +59: Directive -> percent moduleprefix RustCode semicolon +60: Directive -> percent moduleprefix semicolon +61: Directive -> percent glr semicolon +62: Directive -> percent glr error semicolon +63: Directive -> percent lalr semicolon +64: Directive -> percent lalr error semicolon +65: Directive -> percent nooptim semicolon +66: Directive -> percent nooptim error semicolon +67: Directive -> percent dense semicolon +68: Directive -> percent dense error semicolon +69: Directive -> percent trace ident* semicolon +70: Directive -> percent trace error semicolon +71: Directive -> percent filter RustCode semicolon +72: Directive -> percent filter semicolon +73: Directive -> percent location RustCode semicolon +74: Directive -> percent location semicolon +75: Directive -> percent error semicolon +76: GrammarLine -> Rule +77: GrammarLine -> Directive +78: Grammar -> GrammarLine+ +79: TokenMapped+ -> TokenMapped +80: TokenMapped+ -> TokenMapped+ TokenMapped +81: TokenMapped* -> TokenMapped+ +82: TokenMapped* -> +83: PrecDef+ -> PrecDef +84: PrecDef+ -> PrecDef+ PrecDef +85: PrecDef* -> PrecDef+ +86: PrecDef* -> +87: caret? -> caret +88: caret? -> +89: TerminalSetItem+ -> TerminalSetItem +90: TerminalSetItem+ -> TerminalSetItem+ TerminalSetItem +91: TerminalSetItem* -> TerminalSetItem+ +92: TerminalSetItem* -> +93: Pattern+ -> Pattern +94: Pattern+ -> Pattern+ Pattern +95: Pattern* -> Pattern+ +96: Pattern* -> +97: $sep(Pattern*, pipe, +) -> Pattern* +98: $sep(Pattern*, pipe, +) -> $sep(Pattern*, pipe, +) pipe Pattern* +99: comma? -> comma +100: comma? -> +101: [^semicolon] -> ident +102: [^semicolon] -> colon +103: [^semicolon] -> pipe +104: [^semicolon] -> percent +105: [^semicolon] -> equal +106: [^semicolon] -> plus +107: [^semicolon] -> star +108: [^semicolon] -> question +109: [^semicolon] -> caret +110: [^semicolon] -> minus +111: [^semicolon] -> exclamation +112: [^semicolon] -> slash +113: [^semicolon] -> dot +114: [^semicolon] -> dollar +115: [^semicolon] -> comma +116: [^semicolon] -> literal +117: [^semicolon] -> parengroup +118: [^semicolon] -> bracegroup +119: [^semicolon] -> lparen +120: [^semicolon] -> rparen +121: [^semicolon] -> lbracket +122: [^semicolon] -> rbracket +123: [^semicolon] -> left +124: [^semicolon] -> right +125: [^semicolon] -> token +126: [^semicolon] -> start +127: [^semicolon] -> tokentype +128: [^semicolon] -> userdata +129: [^semicolon] -> errortype +130: [^semicolon] -> moduleprefix +131: [^semicolon] -> lalr +132: [^semicolon] -> glr +133: [^semicolon] -> prec +134: [^semicolon] -> precedence +135: [^semicolon] -> nooptim +136: [^semicolon] -> dense +137: [^semicolon] -> trace +138: [^semicolon] -> dprec +139: [^semicolon] -> filter +140: [^semicolon] -> location +141: [^semicolon] -> +142: [^semicolon]+ -> [^semicolon] +143: [^semicolon]+ -> [^semicolon]+ [^semicolon] +144: IdentOrLiteral+ -> IdentOrLiteral +145: IdentOrLiteral+ -> IdentOrLiteral+ IdentOrLiteral +146: ident+ -> ident +147: ident+ -> ident+ ident +148: ident* -> ident+ +149: ident* -> +150: GrammarLine+ -> GrammarLine +151: GrammarLine+ -> GrammarLine GrammarLine+ +152: Augmented -> Grammar eof */ // =============================Generated Codes Begin============================== @@ -518,7 +518,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -566,7 +566,7 @@ impl GrammarDataStack { } }; __data_stack.__stack2.push(__res); - Ok(()) + Ok(true) } ///RuleType -> parengroup #[inline] @@ -577,7 +577,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -596,7 +596,7 @@ impl GrammarDataStack { Some(group) }; __data_stack.__stack3.push(__res); - Ok(()) + Ok(true) } ///RuleType -> #[inline] @@ -607,12 +607,12 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] {} __data_stack.__tags.push(GrammarTags::__stack3); let __res = { None }; __data_stack.__stack3.push(__res); - Ok(()) + Ok(true) } ///RuleLines -> RuleLines pipe RuleLine #[inline] @@ -623,7 +623,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -652,7 +652,7 @@ impl GrammarDataStack { RuleLines }; __data_stack.__stack4.push(__res); - Ok(()) + Ok(true) } ///RuleLines -> RuleLine #[inline] @@ -663,7 +663,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -677,7 +677,7 @@ impl GrammarDataStack { __location_stack.truncate(__location_stack.len() - 1usize); let __res = { vec![RuleLine] }; __data_stack.__stack4.push(__res); - Ok(()) + Ok(true) } ///RuleLine -> TokenMapped* PrecDef* Action #[inline] @@ -688,7 +688,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -721,7 +721,7 @@ impl GrammarDataStack { } }; __data_stack.__stack5.push(__res); - Ok(()) + Ok(true) } ///PrecDef -> percent prec IdentOrLiteral #[inline] @@ -732,7 +732,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -755,7 +755,7 @@ impl GrammarDataStack { __location_stack.truncate(__location_stack.len() - 3usize); let __res = { PrecDPrecArgs::Prec(IdentOrLiteral) }; __data_stack.__stack6.push(__res); - Ok(()) + Ok(true) } ///PrecDef -> percent prec error #[inline] @@ -766,7 +766,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -798,7 +798,7 @@ impl GrammarDataStack { PrecDPrecArgs::None }; __data_stack.__stack6.push(__res); - Ok(()) + Ok(true) } ///PrecDef -> percent dprec literal #[inline] @@ -809,7 +809,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -837,7 +837,7 @@ impl GrammarDataStack { PrecDPrecArgs::DPrec(literal) }; __data_stack.__stack6.push(__res); - Ok(()) + Ok(true) } ///PrecDef -> percent dprec error #[inline] @@ -848,7 +848,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -880,7 +880,7 @@ impl GrammarDataStack { PrecDPrecArgs::None }; __data_stack.__stack6.push(__res); - Ok(()) + Ok(true) } ///PrecDef -> percent error #[inline] @@ -891,7 +891,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -919,7 +919,7 @@ impl GrammarDataStack { PrecDPrecArgs::None }; __data_stack.__stack6.push(__res); - Ok(()) + Ok(true) } ///TokenMapped -> Pattern #[inline] @@ -930,7 +930,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -944,7 +944,7 @@ impl GrammarDataStack { __location_stack.truncate(__location_stack.len() - 1usize); let __res = { (None, Pattern) }; __data_stack.__stack7.push(__res); - Ok(()) + Ok(true) } ///TokenMapped -> ident equal Pattern #[inline] @@ -955,7 +955,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -984,7 +984,7 @@ impl GrammarDataStack { (Some(ident), Pattern) }; __data_stack.__stack7.push(__res); - Ok(()) + Ok(true) } ///TerminalSetItem -> ident #[inline] @@ -995,7 +995,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -1014,7 +1014,7 @@ impl GrammarDataStack { TerminalSetItem::Terminal(ident) }; __data_stack.__stack8.push(__res); - Ok(()) + Ok(true) } ///TerminalSetItem -> ident minus ident #[inline] @@ -1025,7 +1025,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -1057,7 +1057,7 @@ impl GrammarDataStack { TerminalSetItem::Range(first, last) }; __data_stack.__stack8.push(__res); - Ok(()) + Ok(true) } ///TerminalSetItem -> ident minus error #[inline] @@ -1068,7 +1068,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -1100,7 +1100,7 @@ impl GrammarDataStack { TerminalSetItem::Terminal(format_ident!("dummy")) }; __data_stack.__stack8.push(__res); - Ok(()) + Ok(true) } ///TerminalSetItem -> literal #[inline] @@ -1111,7 +1111,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -1130,7 +1130,7 @@ impl GrammarDataStack { TerminalSetItem::Literal(literal) }; __data_stack.__stack8.push(__res); - Ok(()) + Ok(true) } ///TerminalSetItem -> literal minus literal #[inline] @@ -1141,7 +1141,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -1173,7 +1173,7 @@ impl GrammarDataStack { TerminalSetItem::LiteralRange(first, last) }; __data_stack.__stack8.push(__res); - Ok(()) + Ok(true) } ///TerminalSetItem -> literal minus error #[inline] @@ -1184,7 +1184,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -1216,7 +1216,7 @@ impl GrammarDataStack { TerminalSetItem::Terminal(format_ident!("dummy")) }; __data_stack.__stack8.push(__res); - Ok(()) + Ok(true) } ///TerminalSet -> lbracket caret? TerminalSetItem* rbracket #[inline] @@ -1227,7 +1227,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -1264,7 +1264,7 @@ impl GrammarDataStack { } }; __data_stack.__stack9.push(__res); - Ok(()) + Ok(true) } ///TerminalSet -> dot #[inline] @@ -1275,7 +1275,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -1297,7 +1297,7 @@ impl GrammarDataStack { } }; __data_stack.__stack9.push(__res); - Ok(()) + Ok(true) } ///Pattern -> ident #[inline] @@ -1308,7 +1308,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -1327,7 +1327,7 @@ impl GrammarDataStack { PatternArgs::Ident(ident) }; __data_stack.__stack10.push(__res); - Ok(()) + Ok(true) } ///Pattern -> Pattern plus #[inline] @@ -1338,7 +1338,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -1362,7 +1362,7 @@ impl GrammarDataStack { PatternArgs::Plus(Box::new(Pattern), __rustylr_location_plus.span()) }; __data_stack.__stack10.push(__res); - Ok(()) + Ok(true) } ///Pattern -> Pattern star #[inline] @@ -1373,7 +1373,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -1394,7 +1394,7 @@ impl GrammarDataStack { PatternArgs::Star(Box::new(Pattern), __rustylr_location_star.span()) }; __data_stack.__stack10.push(__res); - Ok(()) + Ok(true) } ///Pattern -> Pattern question #[inline] @@ -1405,7 +1405,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -1426,7 +1426,7 @@ impl GrammarDataStack { PatternArgs::Question(Box::new(Pattern), __rustylr_location_question.span()) }; __data_stack.__stack10.push(__res); - Ok(()) + Ok(true) } ///Pattern -> Pattern exclamation #[inline] @@ -1437,7 +1437,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -1461,7 +1461,7 @@ impl GrammarDataStack { ) }; __data_stack.__stack10.push(__res); - Ok(()) + Ok(true) } ///Pattern -> TerminalSet #[inline] @@ -1472,7 +1472,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -1486,7 +1486,7 @@ impl GrammarDataStack { __location_stack.truncate(__location_stack.len() - 1usize); let __res = { PatternArgs::TerminalSet(TerminalSet) }; __data_stack.__stack10.push(__res); - Ok(()) + Ok(true) } ///Pattern -> Pattern slash Pattern #[inline] @@ -1497,7 +1497,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -1520,7 +1520,7 @@ impl GrammarDataStack { __location_stack.truncate(__location_stack.len() - 3usize); let __res = { PatternArgs::Lookaheads(Box::new(p1), Box::new(lh)) }; __data_stack.__stack10.push(__res); - Ok(()) + Ok(true) } ///Pattern -> lparen $sep(Pattern*, pipe, +) rparen #[inline] @@ -1531,7 +1531,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -1562,7 +1562,7 @@ impl GrammarDataStack { ) }; __data_stack.__stack10.push(__res); - Ok(()) + Ok(true) } ///Pattern -> lparen error rparen #[inline] @@ -1573,7 +1573,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -1606,7 +1606,7 @@ impl GrammarDataStack { PatternArgs::Ident(format_ident!("dummy")) }; __data_stack.__stack10.push(__res); - Ok(()) + Ok(true) } ///Pattern -> literal #[inline] @@ -1617,7 +1617,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -1636,7 +1636,7 @@ impl GrammarDataStack { PatternArgs::Literal(literal) }; __data_stack.__stack10.push(__res); - Ok(()) + Ok(true) } ///Pattern -> Pattern minus Pattern #[inline] @@ -1647,7 +1647,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -1670,7 +1670,7 @@ impl GrammarDataStack { __location_stack.truncate(__location_stack.len() - 3usize); let __res = { PatternArgs::Minus(Box::new(p1), Box::new(p2)) }; __data_stack.__stack10.push(__res); - Ok(()) + Ok(true) } ///Pattern -> dollar ident lparen Pattern comma Pattern comma? rparen #[inline] @@ -1681,7 +1681,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -1744,7 +1744,7 @@ impl GrammarDataStack { PatternArgs::Sep(Box::new(base), Box::new(del), false, *__rustylr_location0) }; __data_stack.__stack10.push(__res); - Ok(()) + Ok(true) } ///Pattern -> dollar ident lparen Pattern comma Pattern comma plus rparen #[inline] @@ -1755,7 +1755,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -1821,7 +1821,7 @@ impl GrammarDataStack { PatternArgs::Sep(Box::new(base), Box::new(del), true, *__rustylr_location0) }; __data_stack.__stack10.push(__res); - Ok(()) + Ok(true) } ///Pattern -> dollar ident lparen Pattern comma Pattern comma star rparen #[inline] @@ -1832,7 +1832,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -1898,7 +1898,7 @@ impl GrammarDataStack { PatternArgs::Sep(Box::new(base), Box::new(del), false, *__rustylr_location0) }; __data_stack.__stack10.push(__res); - Ok(()) + Ok(true) } ///Pattern -> dollar ident lparen Pattern comma Pattern error rparen #[inline] @@ -1909,7 +1909,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -1980,7 +1980,7 @@ impl GrammarDataStack { PatternArgs::Sep(Box::new(base), Box::new(del), false, *__rustylr_location0) }; __data_stack.__stack10.push(__res); - Ok(()) + Ok(true) } ///Pattern -> dollar ident lparen Pattern comma Pattern comma error rparen #[inline] @@ -1991,7 +1991,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -2066,7 +2066,7 @@ impl GrammarDataStack { PatternArgs::Sep(Box::new(base), Box::new(del), false, *__rustylr_location0) }; __data_stack.__stack10.push(__res); - Ok(()) + Ok(true) } ///Action -> bracegroup #[inline] @@ -2077,7 +2077,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -2096,7 +2096,7 @@ impl GrammarDataStack { Some(group) }; __data_stack.__stack3.push(__res); - Ok(()) + Ok(true) } ///Action -> #[inline] @@ -2107,12 +2107,12 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] {} __data_stack.__tags.push(GrammarTags::__stack3); let __res = { None }; __data_stack.__stack3.push(__res); - Ok(()) + Ok(true) } ///IdentOrLiteral -> ident #[inline] @@ -2123,7 +2123,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -2142,7 +2142,7 @@ impl GrammarDataStack { IdentOrLiteral::Ident(ident) }; __data_stack.__stack11.push(__res); - Ok(()) + Ok(true) } ///IdentOrLiteral -> literal #[inline] @@ -2153,7 +2153,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -2172,7 +2172,7 @@ impl GrammarDataStack { IdentOrLiteral::Literal(literal) }; __data_stack.__stack11.push(__res); - Ok(()) + Ok(true) } ///RustCode -> [^semicolon]+ #[inline] @@ -2183,7 +2183,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -2203,7 +2203,7 @@ impl GrammarDataStack { tokens }; __data_stack.__stack12.push(__res); - Ok(()) + Ok(true) } ///Directive -> percent token ident RustCode semicolon #[inline] @@ -2214,7 +2214,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -2251,7 +2251,7 @@ impl GrammarDataStack { }; data.terminals.push((ident, RustCode)); } - Ok(()) + Ok(false) } ///Directive -> percent token ident semicolon #[inline] @@ -2262,7 +2262,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -2297,7 +2297,7 @@ impl GrammarDataStack { span: __rustylr_location_ident, }); } - Ok(()) + Ok(false) } ///Directive -> percent token error semicolon #[inline] @@ -2308,7 +2308,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -2343,7 +2343,7 @@ impl GrammarDataStack { span: __rustylr_location_error, }); } - Ok(()) + Ok(false) } ///Directive -> percent start ident semicolon #[inline] @@ -2354,7 +2354,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -2386,7 +2386,7 @@ impl GrammarDataStack { }; data.start_rule_name.push(ident); } - Ok(()) + Ok(false) } ///Directive -> percent start error semicolon #[inline] @@ -2397,7 +2397,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -2432,7 +2432,7 @@ impl GrammarDataStack { span: __rustylr_location_error, }); } - Ok(()) + Ok(false) } ///Directive -> percent tokentype RustCode semicolon #[inline] @@ -2443,7 +2443,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -2473,7 +2473,7 @@ impl GrammarDataStack { { data.token_typename.push((__rustylr_location_tokentype.span(), RustCode)); } - Ok(()) + Ok(false) } ///Directive -> percent tokentype semicolon #[inline] @@ -2484,7 +2484,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -2515,7 +2515,7 @@ impl GrammarDataStack { span: __rustylr_location_tokentype, }); } - Ok(()) + Ok(false) } ///Directive -> percent userdata RustCode semicolon #[inline] @@ -2526,7 +2526,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -2556,7 +2556,7 @@ impl GrammarDataStack { { data.userdata_typename.push((__rustylr_location_userdata.span(), RustCode)); } - Ok(()) + Ok(false) } ///Directive -> percent userdata semicolon #[inline] @@ -2567,7 +2567,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -2598,7 +2598,7 @@ impl GrammarDataStack { span: __rustylr_location_userdata, }); } - Ok(()) + Ok(false) } ///Directive -> percent left IdentOrLiteral+ semicolon #[inline] @@ -2609,7 +2609,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -2644,7 +2644,7 @@ impl GrammarDataStack { IdentOrLiteral, )); } - Ok(()) + Ok(false) } ///Directive -> percent left error semicolon #[inline] @@ -2655,7 +2655,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -2690,7 +2690,7 @@ impl GrammarDataStack { span: __rustylr_location_error, }); } - Ok(()) + Ok(false) } ///Directive -> percent right IdentOrLiteral+ semicolon #[inline] @@ -2701,7 +2701,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -2736,7 +2736,7 @@ impl GrammarDataStack { IdentOrLiteral, )); } - Ok(()) + Ok(false) } ///Directive -> percent right error semicolon #[inline] @@ -2747,7 +2747,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -2782,7 +2782,7 @@ impl GrammarDataStack { span: __rustylr_location_error, }); } - Ok(()) + Ok(false) } ///Directive -> percent precedence IdentOrLiteral+ semicolon #[inline] @@ -2793,7 +2793,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -2824,7 +2824,7 @@ impl GrammarDataStack { data.precedences .push((__rustylr_location_precedence.span(), None, IdentOrLiteral)); } - Ok(()) + Ok(false) } ///Directive -> percent precedence error semicolon #[inline] @@ -2835,7 +2835,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -2870,7 +2870,7 @@ impl GrammarDataStack { span: __rustylr_location_error, }); } - Ok(()) + Ok(false) } ///Directive -> percent errortype RustCode semicolon #[inline] @@ -2881,7 +2881,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -2911,7 +2911,7 @@ impl GrammarDataStack { { data.error_typename.push((__rustylr_location_errortype.span(), RustCode)); } - Ok(()) + Ok(false) } ///Directive -> percent errortype semicolon #[inline] @@ -2922,7 +2922,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -2953,7 +2953,7 @@ impl GrammarDataStack { span: __rustylr_location_errortype, }); } - Ok(()) + Ok(false) } ///Directive -> percent moduleprefix RustCode semicolon #[inline] @@ -2964,7 +2964,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -2994,7 +2994,7 @@ impl GrammarDataStack { { data.module_prefix.push((__rustylr_location_moduleprefix.span(), RustCode)); } - Ok(()) + Ok(false) } ///Directive -> percent moduleprefix semicolon #[inline] @@ -3005,7 +3005,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3036,7 +3036,7 @@ impl GrammarDataStack { span: __rustylr_location_moduleprefix, }); } - Ok(()) + Ok(false) } ///Directive -> percent glr semicolon #[inline] @@ -3047,7 +3047,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3072,7 +3072,7 @@ impl GrammarDataStack { { data.glr = true; } - Ok(()) + Ok(false) } ///Directive -> percent glr error semicolon #[inline] @@ -3083,7 +3083,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3118,7 +3118,7 @@ impl GrammarDataStack { span: __rustylr_location_error, }); } - Ok(()) + Ok(false) } ///Directive -> percent lalr semicolon #[inline] @@ -3129,7 +3129,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3154,7 +3154,7 @@ impl GrammarDataStack { { data.lalr = true; } - Ok(()) + Ok(false) } ///Directive -> percent lalr error semicolon #[inline] @@ -3165,7 +3165,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3200,7 +3200,7 @@ impl GrammarDataStack { span: __rustylr_location_error, }); } - Ok(()) + Ok(false) } ///Directive -> percent nooptim semicolon #[inline] @@ -3211,7 +3211,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3234,7 +3234,7 @@ impl GrammarDataStack { { data.no_optim = true; } - Ok(()) + Ok(false) } ///Directive -> percent nooptim error semicolon #[inline] @@ -3245,7 +3245,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3280,7 +3280,7 @@ impl GrammarDataStack { span: __rustylr_location_error, }); } - Ok(()) + Ok(false) } ///Directive -> percent dense semicolon #[inline] @@ -3291,7 +3291,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3316,7 +3316,7 @@ impl GrammarDataStack { { data.dense = true; } - Ok(()) + Ok(false) } ///Directive -> percent dense error semicolon #[inline] @@ -3327,7 +3327,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3362,7 +3362,7 @@ impl GrammarDataStack { span: __rustylr_location_error, }); } - Ok(()) + Ok(false) } ///Directive -> percent trace ident* semicolon #[inline] @@ -3373,7 +3373,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3409,7 +3409,7 @@ impl GrammarDataStack { }); data.traces.extend(idents); } - Ok(()) + Ok(false) } ///Directive -> percent trace error semicolon #[inline] @@ -3420,7 +3420,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3455,7 +3455,7 @@ impl GrammarDataStack { span: __rustylr_location_error, }); } - Ok(()) + Ok(false) } ///Directive -> percent filter RustCode semicolon #[inline] @@ -3466,7 +3466,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3496,7 +3496,7 @@ impl GrammarDataStack { { data.filter = Some(RustCode); } - Ok(()) + Ok(false) } ///Directive -> percent filter semicolon #[inline] @@ -3507,7 +3507,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3538,7 +3538,7 @@ impl GrammarDataStack { span: __rustylr_location_filter, }); } - Ok(()) + Ok(false) } ///Directive -> percent location RustCode semicolon #[inline] @@ -3549,7 +3549,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3577,7 +3577,7 @@ impl GrammarDataStack { { data.location_typename = Some(RustCode); } - Ok(()) + Ok(false) } ///Directive -> percent location semicolon #[inline] @@ -3588,7 +3588,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3619,7 +3619,7 @@ impl GrammarDataStack { span: __rustylr_location_location, }); } - Ok(()) + Ok(false) } ///Directive -> percent error semicolon #[inline] @@ -3630,7 +3630,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3661,7 +3661,7 @@ impl GrammarDataStack { span: __rustylr_location_error, }); } - Ok(()) + Ok(false) } ///GrammarLine -> Rule #[inline] @@ -3672,7 +3672,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3687,20 +3687,7 @@ impl GrammarDataStack { { data.rules.push(Rule); } - Ok(()) - } - ///GrammarLine -> Directive - #[inline(always)] - fn reduce_GrammarLine_1( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///Grammar -> GrammarLine+ - #[inline(always)] - fn reduce_Grammar_0(__data_stack: &mut Self, __location_stack: &mut Vec) { - __location_stack.truncate(__location_stack.len() - 1usize); + Ok(false) } ///TokenMapped+ -> TokenMapped #[inline] @@ -3711,7 +3698,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3725,7 +3712,7 @@ impl GrammarDataStack { __location_stack.truncate(__location_stack.len() - 1usize); let __res = { vec![A] }; __data_stack.__stack13.push(__res); - Ok(()) + Ok(true) } ///TokenMapped+ -> TokenMapped+ TokenMapped #[inline] @@ -3736,7 +3723,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3757,15 +3744,16 @@ impl GrammarDataStack { Ap }; __data_stack.__stack13.push(__res); - Ok(()) + Ok(true) } ///TokenMapped* -> TokenMapped+ #[inline(always)] fn reduce__TokenMappedStar16_0( __data_stack: &mut Self, __location_stack: &mut Vec, - ) { + ) -> bool { __location_stack.truncate(__location_stack.len() - 1usize); + true } ///TokenMapped* -> #[inline] @@ -3776,12 +3764,12 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] {} __data_stack.__tags.push(GrammarTags::__stack13); let __res = { vec![] }; __data_stack.__stack13.push(__res); - Ok(()) + Ok(true) } ///PrecDef+ -> PrecDef #[inline] @@ -3792,7 +3780,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3806,7 +3794,7 @@ impl GrammarDataStack { __location_stack.truncate(__location_stack.len() - 1usize); let __res = { vec![A] }; __data_stack.__stack14.push(__res); - Ok(()) + Ok(true) } ///PrecDef+ -> PrecDef+ PrecDef #[inline] @@ -3817,7 +3805,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3838,15 +3826,16 @@ impl GrammarDataStack { Ap }; __data_stack.__stack14.push(__res); - Ok(()) + Ok(true) } ///PrecDef* -> PrecDef+ #[inline(always)] fn reduce__PrecDefStar18_0( __data_stack: &mut Self, __location_stack: &mut Vec, - ) { + ) -> bool { __location_stack.truncate(__location_stack.len() - 1usize); + true } ///PrecDef* -> #[inline] @@ -3857,12 +3846,12 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] {} __data_stack.__tags.push(GrammarTags::__stack14); let __res = { vec![] }; __data_stack.__stack14.push(__res); - Ok(()) + Ok(true) } ///caret? -> caret #[inline] @@ -3873,7 +3862,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3887,7 +3876,7 @@ impl GrammarDataStack { __location_stack.truncate(__location_stack.len() - 1usize); let __res = Some(A); __data_stack.__stack15.push(__res); - Ok(()) + Ok(true) } ///caret? -> #[inline] @@ -3898,12 +3887,12 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] {} __data_stack.__tags.push(GrammarTags::__stack15); let __res = { None }; __data_stack.__stack15.push(__res); - Ok(()) + Ok(true) } ///TerminalSetItem+ -> TerminalSetItem #[inline] @@ -3914,7 +3903,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3928,7 +3917,7 @@ impl GrammarDataStack { __location_stack.truncate(__location_stack.len() - 1usize); let __res = { vec![A] }; __data_stack.__stack16.push(__res); - Ok(()) + Ok(true) } ///TerminalSetItem+ -> TerminalSetItem+ TerminalSetItem #[inline] @@ -3939,7 +3928,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -3960,15 +3949,16 @@ impl GrammarDataStack { Ap }; __data_stack.__stack16.push(__res); - Ok(()) + Ok(true) } ///TerminalSetItem* -> TerminalSetItem+ #[inline(always)] fn reduce__TerminalSetItemStar21_0( __data_stack: &mut Self, __location_stack: &mut Vec, - ) { + ) -> bool { __location_stack.truncate(__location_stack.len() - 1usize); + true } ///TerminalSetItem* -> #[inline] @@ -3979,12 +3969,12 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] {} __data_stack.__tags.push(GrammarTags::__stack16); let __res = { vec![] }; __data_stack.__stack16.push(__res); - Ok(()) + Ok(true) } ///Pattern+ -> Pattern #[inline] @@ -3995,7 +3985,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -4009,7 +3999,7 @@ impl GrammarDataStack { __location_stack.truncate(__location_stack.len() - 1usize); let __res = { vec![A] }; __data_stack.__stack17.push(__res); - Ok(()) + Ok(true) } ///Pattern+ -> Pattern+ Pattern #[inline] @@ -4020,7 +4010,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -4041,15 +4031,16 @@ impl GrammarDataStack { Ap }; __data_stack.__stack17.push(__res); - Ok(()) + Ok(true) } ///Pattern* -> Pattern+ #[inline(always)] fn reduce__PatternStar23_0( __data_stack: &mut Self, __location_stack: &mut Vec, - ) { + ) -> bool { __location_stack.truncate(__location_stack.len() - 1usize); + true } ///Pattern* -> #[inline] @@ -4060,12 +4051,12 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] {} __data_stack.__tags.push(GrammarTags::__stack17); let __res = { vec![] }; __data_stack.__stack17.push(__res); - Ok(()) + Ok(true) } ///$sep(Pattern*, pipe, +) -> Pattern* #[inline] @@ -4076,7 +4067,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -4090,7 +4081,7 @@ impl GrammarDataStack { __location_stack.truncate(__location_stack.len() - 1usize); let __res = { vec![__token0] }; __data_stack.__stack18.push(__res); - Ok(()) + Ok(true) } ///$sep(Pattern*, pipe, +) -> $sep(Pattern*, pipe, +) pipe Pattern* #[inline] @@ -4101,7 +4092,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -4127,7 +4118,7 @@ impl GrammarDataStack { __token0 }; __data_stack.__stack18.push(__res); - Ok(()) + Ok(true) } ///comma? -> comma #[inline] @@ -4138,7 +4129,7 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] { debug_assert!( @@ -4152,7 +4143,7 @@ impl GrammarDataStack { __location_stack.truncate(__location_stack.len() - 1usize); let __res = Some(A); __data_stack.__stack15.push(__res); - Ok(()) + Ok(true) } ///comma? -> #[inline] @@ -4163,805 +4154,649 @@ impl GrammarDataStack { lookahead: &::rusty_lr_core::TerminalSymbol, data: &mut GrammarArgs, __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { + ) -> Result { #[cfg(debug_assertions)] {} __data_stack.__tags.push(GrammarTags::__stack15); let __res = { None }; __data_stack.__stack15.push(__res); - Ok(()) - } - ///[^semicolon] -> ident - #[inline(always)] - fn reduce__TermSet26_0( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///[^semicolon] -> colon - #[inline(always)] - fn reduce__TermSet26_1( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///[^semicolon] -> pipe - #[inline(always)] - fn reduce__TermSet26_2( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///[^semicolon] -> percent - #[inline(always)] - fn reduce__TermSet26_3( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///[^semicolon] -> equal - #[inline(always)] - fn reduce__TermSet26_4( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///[^semicolon] -> plus - #[inline(always)] - fn reduce__TermSet26_5( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///[^semicolon] -> star - #[inline(always)] - fn reduce__TermSet26_6( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); + Ok(true) } - ///[^semicolon] -> question - #[inline(always)] - fn reduce__TermSet26_7( + ///[^semicolon]+ -> [^semicolon] + #[inline] + fn reduce___TermSet26Plus27_0( __data_stack: &mut Self, __location_stack: &mut Vec, - ) { + shift: &mut bool, + lookahead: &::rusty_lr_core::TerminalSymbol, + data: &mut GrammarArgs, + __rustylr_location0: &mut SpanPair, + ) -> Result { + #[cfg(debug_assertions)] + { + debug_assert!( + __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(& + GrammarTags::__terminals) + ); + } + __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize); + __data_stack.__tags.push(GrammarTags::__stack19); + let mut A = __data_stack.__terminals.pop().unwrap(); __location_stack.truncate(__location_stack.len() - 1usize); + let __res = { vec![A] }; + __data_stack.__stack19.push(__res); + Ok(true) } - ///[^semicolon] -> caret - #[inline(always)] - fn reduce__TermSet26_8( + ///[^semicolon]+ -> [^semicolon]+ [^semicolon] + #[inline] + fn reduce___TermSet26Plus27_1( __data_stack: &mut Self, __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); + shift: &mut bool, + lookahead: &::rusty_lr_core::TerminalSymbol, + data: &mut GrammarArgs, + __rustylr_location0: &mut SpanPair, + ) -> Result { + #[cfg(debug_assertions)] + { + debug_assert!( + __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(& + GrammarTags::__terminals) + ); + debug_assert!( + __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(& + GrammarTags::__stack19) + ); + } + __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize); + let mut Ap = __data_stack.__stack19.pop().unwrap(); + let mut A = __data_stack.__terminals.pop().unwrap(); + __location_stack.truncate(__location_stack.len() - 2usize); + let __res = { + Ap.push(A); + Ap + }; + __data_stack.__stack19.push(__res); + Ok(true) } - ///[^semicolon] -> minus - #[inline(always)] - fn reduce__TermSet26_9( + ///IdentOrLiteral+ -> IdentOrLiteral + #[inline] + fn reduce__IdentOrLiteralPlus28_0( __data_stack: &mut Self, __location_stack: &mut Vec, - ) { + shift: &mut bool, + lookahead: &::rusty_lr_core::TerminalSymbol, + data: &mut GrammarArgs, + __rustylr_location0: &mut SpanPair, + ) -> Result { + #[cfg(debug_assertions)] + { + debug_assert!( + __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(& + GrammarTags::__stack11) + ); + } + __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize); + __data_stack.__tags.push(GrammarTags::__stack20); + let mut A = __data_stack.__stack11.pop().unwrap(); __location_stack.truncate(__location_stack.len() - 1usize); + let __res = { vec![A] }; + __data_stack.__stack20.push(__res); + Ok(true) } - ///[^semicolon] -> exclamation - #[inline(always)] - fn reduce__TermSet26_10( + ///IdentOrLiteral+ -> IdentOrLiteral+ IdentOrLiteral + #[inline] + fn reduce__IdentOrLiteralPlus28_1( __data_stack: &mut Self, __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); + shift: &mut bool, + lookahead: &::rusty_lr_core::TerminalSymbol, + data: &mut GrammarArgs, + __rustylr_location0: &mut SpanPair, + ) -> Result { + #[cfg(debug_assertions)] + { + debug_assert!( + __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(& + GrammarTags::__stack11) + ); + debug_assert!( + __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(& + GrammarTags::__stack20) + ); + } + __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize); + let mut A = __data_stack.__stack11.pop().unwrap(); + let mut Ap = __data_stack.__stack20.pop().unwrap(); + __location_stack.truncate(__location_stack.len() - 2usize); + let __res = { + Ap.push(A); + Ap + }; + __data_stack.__stack20.push(__res); + Ok(true) } - ///[^semicolon] -> slash - #[inline(always)] - fn reduce__TermSet26_11( + ///ident+ -> ident + #[inline] + fn reduce__identPlus29_0( __data_stack: &mut Self, __location_stack: &mut Vec, - ) { + shift: &mut bool, + lookahead: &::rusty_lr_core::TerminalSymbol, + data: &mut GrammarArgs, + __rustylr_location0: &mut SpanPair, + ) -> Result { + #[cfg(debug_assertions)] + { + debug_assert!( + __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(& + GrammarTags::__terminals) + ); + } + __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize); + __data_stack.__tags.push(GrammarTags::__stack19); + let mut A = __data_stack.__terminals.pop().unwrap(); __location_stack.truncate(__location_stack.len() - 1usize); + let __res = { vec![A] }; + __data_stack.__stack19.push(__res); + Ok(true) } - ///[^semicolon] -> dot - #[inline(always)] - fn reduce__TermSet26_12( + ///ident+ -> ident+ ident + #[inline] + fn reduce__identPlus29_1( __data_stack: &mut Self, __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); + shift: &mut bool, + lookahead: &::rusty_lr_core::TerminalSymbol, + data: &mut GrammarArgs, + __rustylr_location0: &mut SpanPair, + ) -> Result { + #[cfg(debug_assertions)] + { + debug_assert!( + __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(& + GrammarTags::__terminals) + ); + debug_assert!( + __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(& + GrammarTags::__stack19) + ); + } + __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize); + let mut Ap = __data_stack.__stack19.pop().unwrap(); + let mut A = __data_stack.__terminals.pop().unwrap(); + __location_stack.truncate(__location_stack.len() - 2usize); + let __res = { + Ap.push(A); + Ap + }; + __data_stack.__stack19.push(__res); + Ok(true) } - ///[^semicolon] -> dollar + ///ident* -> ident+ #[inline(always)] - fn reduce__TermSet26_13( + fn reduce__identStar30_0( __data_stack: &mut Self, __location_stack: &mut Vec, - ) { + ) -> bool { __location_stack.truncate(__location_stack.len() - 1usize); + true } - ///[^semicolon] -> comma - #[inline(always)] - fn reduce__TermSet26_14( + ///ident* -> + #[inline] + fn reduce__identStar30_1( __data_stack: &mut Self, __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); + shift: &mut bool, + lookahead: &::rusty_lr_core::TerminalSymbol, + data: &mut GrammarArgs, + __rustylr_location0: &mut SpanPair, + ) -> Result { + #[cfg(debug_assertions)] {} + __data_stack.__tags.push(GrammarTags::__stack19); + let __res = { vec![] }; + __data_stack.__stack19.push(__res); + Ok(true) } - ///[^semicolon] -> literal + ///GrammarLine+ -> GrammarLine #[inline(always)] - fn reduce__TermSet26_15( + fn reduce__GrammarLinePlus31_0( __data_stack: &mut Self, __location_stack: &mut Vec, ) { __location_stack.truncate(__location_stack.len() - 1usize); } - ///[^semicolon] -> parengroup + ///GrammarLine+ -> GrammarLine GrammarLine+ #[inline(always)] - fn reduce__TermSet26_16( + fn reduce__GrammarLinePlus31_1( __data_stack: &mut Self, __location_stack: &mut Vec, ) { - __location_stack.truncate(__location_stack.len() - 1usize); + __location_stack.truncate(__location_stack.len() - 2usize); + __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize); } - ///[^semicolon] -> bracegroup - #[inline(always)] - fn reduce__TermSet26_17( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); +} +#[allow( + unused_braces, + unused_parens, + non_snake_case, + non_camel_case_types, + unused_variables +)] +impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { + type Term = Lexed; + type NonTerm = GrammarNonTerminals; + type ReduceActionError = ::rusty_lr_core::DefaultReduceActionError; + type UserData = GrammarArgs; + type StartType = (); + type Location = SpanPair; + fn pop_start(&mut self) -> Option { + let tag = self.__tags.pop(); + debug_assert!(tag == Some(GrammarTags::Empty)); + Some(()) } - ///[^semicolon] -> lparen - #[inline(always)] - fn reduce__TermSet26_18( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///[^semicolon] -> rparen - #[inline(always)] - fn reduce__TermSet26_19( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///[^semicolon] -> lbracket - #[inline(always)] - fn reduce__TermSet26_20( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); + fn pop(&mut self) { + match self.__tags.pop().unwrap() { + GrammarTags::__terminals => { + self.__terminals.pop(); + } + GrammarTags::__stack2 => { + self.__stack2.pop(); + } + GrammarTags::__stack3 => { + self.__stack3.pop(); + } + GrammarTags::__stack4 => { + self.__stack4.pop(); + } + GrammarTags::__stack5 => { + self.__stack5.pop(); + } + GrammarTags::__stack6 => { + self.__stack6.pop(); + } + GrammarTags::__stack7 => { + self.__stack7.pop(); + } + GrammarTags::__stack8 => { + self.__stack8.pop(); + } + GrammarTags::__stack9 => { + self.__stack9.pop(); + } + GrammarTags::__stack10 => { + self.__stack10.pop(); + } + GrammarTags::__stack11 => { + self.__stack11.pop(); + } + GrammarTags::__stack12 => { + self.__stack12.pop(); + } + GrammarTags::__stack13 => { + self.__stack13.pop(); + } + GrammarTags::__stack14 => { + self.__stack14.pop(); + } + GrammarTags::__stack15 => { + self.__stack15.pop(); + } + GrammarTags::__stack16 => { + self.__stack16.pop(); + } + GrammarTags::__stack17 => { + self.__stack17.pop(); + } + GrammarTags::__stack18 => { + self.__stack18.pop(); + } + GrammarTags::__stack19 => { + self.__stack19.pop(); + } + GrammarTags::__stack20 => { + self.__stack20.pop(); + } + _ => {} + } } - ///[^semicolon] -> rbracket - #[inline(always)] - fn reduce__TermSet26_21( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); + fn push_terminal(&mut self, term: Self::Term) { + self.__tags.push(GrammarTags::__terminals); + self.__terminals.push(term); } - ///[^semicolon] -> left - #[inline(always)] - fn reduce__TermSet26_22( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); + fn push_empty(&mut self) { + self.__tags.push(GrammarTags::Empty); } - ///[^semicolon] -> right - #[inline(always)] - fn reduce__TermSet26_23( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); + fn clear(&mut self) { + self.__tags.clear(); + self.__terminals.clear(); + self.__stack2.clear(); + self.__stack3.clear(); + self.__stack4.clear(); + self.__stack5.clear(); + self.__stack6.clear(); + self.__stack7.clear(); + self.__stack8.clear(); + self.__stack9.clear(); + self.__stack10.clear(); + self.__stack11.clear(); + self.__stack12.clear(); + self.__stack13.clear(); + self.__stack14.clear(); + self.__stack15.clear(); + self.__stack16.clear(); + self.__stack17.clear(); + self.__stack18.clear(); + self.__stack19.clear(); + self.__stack20.clear(); } - ///[^semicolon] -> token - #[inline(always)] - fn reduce__TermSet26_24( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); + fn reserve(&mut self, additional: usize) { + self.__tags.reserve(additional); } - ///[^semicolon] -> start - #[inline(always)] - fn reduce__TermSet26_25( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); + fn split_off(&mut self, at: usize) -> Self { + let __other_tag_stack = self.__tags.split_off(at); + let mut __counts: [u8; 20usize + 1] = [0; 20usize + 1]; + for &tag in &__other_tag_stack { + __counts[tag as usize] += 1; + } + let __other___terminals = self + .__terminals + .split_off(self.__terminals.len() - (__counts[0usize] as usize)); + let __other___stack2 = self + .__stack2 + .split_off(self.__stack2.len() - (__counts[1usize] as usize)); + let __other___stack3 = self + .__stack3 + .split_off(self.__stack3.len() - (__counts[2usize] as usize)); + let __other___stack4 = self + .__stack4 + .split_off(self.__stack4.len() - (__counts[3usize] as usize)); + let __other___stack5 = self + .__stack5 + .split_off(self.__stack5.len() - (__counts[4usize] as usize)); + let __other___stack6 = self + .__stack6 + .split_off(self.__stack6.len() - (__counts[5usize] as usize)); + let __other___stack7 = self + .__stack7 + .split_off(self.__stack7.len() - (__counts[6usize] as usize)); + let __other___stack8 = self + .__stack8 + .split_off(self.__stack8.len() - (__counts[7usize] as usize)); + let __other___stack9 = self + .__stack9 + .split_off(self.__stack9.len() - (__counts[8usize] as usize)); + let __other___stack10 = self + .__stack10 + .split_off(self.__stack10.len() - (__counts[9usize] as usize)); + let __other___stack11 = self + .__stack11 + .split_off(self.__stack11.len() - (__counts[10usize] as usize)); + let __other___stack12 = self + .__stack12 + .split_off(self.__stack12.len() - (__counts[11usize] as usize)); + let __other___stack13 = self + .__stack13 + .split_off(self.__stack13.len() - (__counts[12usize] as usize)); + let __other___stack14 = self + .__stack14 + .split_off(self.__stack14.len() - (__counts[13usize] as usize)); + let __other___stack15 = self + .__stack15 + .split_off(self.__stack15.len() - (__counts[14usize] as usize)); + let __other___stack16 = self + .__stack16 + .split_off(self.__stack16.len() - (__counts[15usize] as usize)); + let __other___stack17 = self + .__stack17 + .split_off(self.__stack17.len() - (__counts[16usize] as usize)); + let __other___stack18 = self + .__stack18 + .split_off(self.__stack18.len() - (__counts[17usize] as usize)); + let __other___stack19 = self + .__stack19 + .split_off(self.__stack19.len() - (__counts[18usize] as usize)); + let __other___stack20 = self + .__stack20 + .split_off(self.__stack20.len() - (__counts[19usize] as usize)); + Self { + __tags: __other_tag_stack, + __terminals: __other___terminals, + __stack2: __other___stack2, + __stack3: __other___stack3, + __stack4: __other___stack4, + __stack5: __other___stack5, + __stack6: __other___stack6, + __stack7: __other___stack7, + __stack8: __other___stack8, + __stack9: __other___stack9, + __stack10: __other___stack10, + __stack11: __other___stack11, + __stack12: __other___stack12, + __stack13: __other___stack13, + __stack14: __other___stack14, + __stack15: __other___stack15, + __stack16: __other___stack16, + __stack17: __other___stack17, + __stack18: __other___stack18, + __stack19: __other___stack19, + __stack20: __other___stack20, + } } - ///[^semicolon] -> tokentype - #[inline(always)] - fn reduce__TermSet26_26( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); + fn append(&mut self, other: &mut Self) { + self.__tags.append(&mut other.__tags); + self.__terminals.append(&mut other.__terminals); + self.__stack2.append(&mut other.__stack2); + self.__stack3.append(&mut other.__stack3); + self.__stack4.append(&mut other.__stack4); + self.__stack5.append(&mut other.__stack5); + self.__stack6.append(&mut other.__stack6); + self.__stack7.append(&mut other.__stack7); + self.__stack8.append(&mut other.__stack8); + self.__stack9.append(&mut other.__stack9); + self.__stack10.append(&mut other.__stack10); + self.__stack11.append(&mut other.__stack11); + self.__stack12.append(&mut other.__stack12); + self.__stack13.append(&mut other.__stack13); + self.__stack14.append(&mut other.__stack14); + self.__stack15.append(&mut other.__stack15); + self.__stack16.append(&mut other.__stack16); + self.__stack17.append(&mut other.__stack17); + self.__stack18.append(&mut other.__stack18); + self.__stack19.append(&mut other.__stack19); + self.__stack20.append(&mut other.__stack20); } - ///[^semicolon] -> userdata - #[inline(always)] - fn reduce__TermSet26_27( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///[^semicolon] -> errortype - #[inline(always)] - fn reduce__TermSet26_28( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///[^semicolon] -> moduleprefix - #[inline(always)] - fn reduce__TermSet26_29( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///[^semicolon] -> lalr - #[inline(always)] - fn reduce__TermSet26_30( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///[^semicolon] -> glr - #[inline(always)] - fn reduce__TermSet26_31( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///[^semicolon] -> prec - #[inline(always)] - fn reduce__TermSet26_32( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///[^semicolon] -> precedence - #[inline(always)] - fn reduce__TermSet26_33( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///[^semicolon] -> nooptim - #[inline(always)] - fn reduce__TermSet26_34( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///[^semicolon] -> dense - #[inline(always)] - fn reduce__TermSet26_35( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///[^semicolon] -> trace - #[inline(always)] - fn reduce__TermSet26_36( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///[^semicolon] -> dprec - #[inline(always)] - fn reduce__TermSet26_37( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///[^semicolon] -> filter - #[inline(always)] - fn reduce__TermSet26_38( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///[^semicolon] -> location - #[inline(always)] - fn reduce__TermSet26_39( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///[^semicolon] -> - #[inline(always)] - fn reduce__TermSet26_40( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///[^semicolon]+ -> [^semicolon] - #[inline] - fn reduce___TermSet26Plus27_0( - __data_stack: &mut Self, - __location_stack: &mut Vec, - shift: &mut bool, - lookahead: &::rusty_lr_core::TerminalSymbol, - data: &mut GrammarArgs, - __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { - #[cfg(debug_assertions)] - { - debug_assert!( - __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(& - GrammarTags::__terminals) - ); - } - __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize); - __data_stack.__tags.push(GrammarTags::__stack19); - let mut A = __data_stack.__terminals.pop().unwrap(); - __location_stack.truncate(__location_stack.len() - 1usize); - let __res = { vec![A] }; - __data_stack.__stack19.push(__res); - Ok(()) - } - ///[^semicolon]+ -> [^semicolon]+ [^semicolon] - #[inline] - fn reduce___TermSet26Plus27_1( - __data_stack: &mut Self, - __location_stack: &mut Vec, - shift: &mut bool, - lookahead: &::rusty_lr_core::TerminalSymbol, - data: &mut GrammarArgs, - __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { - #[cfg(debug_assertions)] - { - debug_assert!( - __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(& - GrammarTags::__terminals) - ); - debug_assert!( - __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(& - GrammarTags::__stack19) - ); - } - __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize); - let mut Ap = __data_stack.__stack19.pop().unwrap(); - let mut A = __data_stack.__terminals.pop().unwrap(); - __location_stack.truncate(__location_stack.len() - 2usize); - let __res = { - Ap.push(A); - Ap - }; - __data_stack.__stack19.push(__res); - Ok(()) - } - ///IdentOrLiteral+ -> IdentOrLiteral - #[inline] - fn reduce__IdentOrLiteralPlus28_0( - __data_stack: &mut Self, - __location_stack: &mut Vec, - shift: &mut bool, - lookahead: &::rusty_lr_core::TerminalSymbol, - data: &mut GrammarArgs, - __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { - #[cfg(debug_assertions)] - { - debug_assert!( - __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(& - GrammarTags::__stack11) - ); - } - __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize); - __data_stack.__tags.push(GrammarTags::__stack20); - let mut A = __data_stack.__stack11.pop().unwrap(); - __location_stack.truncate(__location_stack.len() - 1usize); - let __res = { vec![A] }; - __data_stack.__stack20.push(__res); - Ok(()) - } - ///IdentOrLiteral+ -> IdentOrLiteral+ IdentOrLiteral - #[inline] - fn reduce__IdentOrLiteralPlus28_1( - __data_stack: &mut Self, - __location_stack: &mut Vec, - shift: &mut bool, - lookahead: &::rusty_lr_core::TerminalSymbol, - data: &mut GrammarArgs, - __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { - #[cfg(debug_assertions)] - { - debug_assert!( - __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(& - GrammarTags::__stack11) - ); - debug_assert!( - __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(& - GrammarTags::__stack20) - ); - } - __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize); - let mut A = __data_stack.__stack11.pop().unwrap(); - let mut Ap = __data_stack.__stack20.pop().unwrap(); - __location_stack.truncate(__location_stack.len() - 2usize); - let __res = { - Ap.push(A); - Ap - }; - __data_stack.__stack20.push(__res); - Ok(()) - } - ///ident+ -> ident - #[inline] - fn reduce__identPlus29_0( - __data_stack: &mut Self, - __location_stack: &mut Vec, - shift: &mut bool, - lookahead: &::rusty_lr_core::TerminalSymbol, - data: &mut GrammarArgs, - __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { - #[cfg(debug_assertions)] - { - debug_assert!( - __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(& - GrammarTags::__terminals) - ); - } - __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize); - __data_stack.__tags.push(GrammarTags::__stack19); - let mut A = __data_stack.__terminals.pop().unwrap(); - __location_stack.truncate(__location_stack.len() - 1usize); - let __res = { vec![A] }; - __data_stack.__stack19.push(__res); - Ok(()) - } - ///ident+ -> ident+ ident - #[inline] - fn reduce__identPlus29_1( - __data_stack: &mut Self, - __location_stack: &mut Vec, - shift: &mut bool, - lookahead: &::rusty_lr_core::TerminalSymbol, - data: &mut GrammarArgs, - __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { - #[cfg(debug_assertions)] - { - debug_assert!( - __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(& - GrammarTags::__terminals) - ); - debug_assert!( - __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(& - GrammarTags::__stack19) - ); - } - __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize); - let mut Ap = __data_stack.__stack19.pop().unwrap(); - let mut A = __data_stack.__terminals.pop().unwrap(); - __location_stack.truncate(__location_stack.len() - 2usize); - let __res = { - Ap.push(A); - Ap - }; - __data_stack.__stack19.push(__res); - Ok(()) - } - ///ident* -> ident+ - #[inline(always)] - fn reduce__identStar30_0( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///ident* -> - #[inline] - fn reduce__identStar30_1( - __data_stack: &mut Self, - __location_stack: &mut Vec, + fn reduce_action( + data_stack: &mut Self, + location_stack: &mut Vec, + rule_index: usize, shift: &mut bool, - lookahead: &::rusty_lr_core::TerminalSymbol, - data: &mut GrammarArgs, - __rustylr_location0: &mut SpanPair, - ) -> Result<(), ::rusty_lr_core::DefaultReduceActionError> { - #[cfg(debug_assertions)] {} - __data_stack.__tags.push(GrammarTags::__stack19); - let __res = { vec![] }; - __data_stack.__stack19.push(__res); - Ok(()) - } - ///GrammarLine+ -> GrammarLine - #[inline(always)] - fn reduce__GrammarLinePlus31_0( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 1usize); - } - ///GrammarLine+ -> GrammarLine GrammarLine+ - #[inline(always)] - fn reduce__GrammarLinePlus31_1( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 2usize); - __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize); - } - ///Augmented -> Grammar eof - #[inline(always)] - fn reduce_Augmented_0( - __data_stack: &mut Self, - __location_stack: &mut Vec, - ) { - __location_stack.truncate(__location_stack.len() - 2usize); - __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize); - } -} -#[allow( - unused_braces, - unused_parens, - non_snake_case, - non_camel_case_types, - unused_variables -)] -impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { - type Term = Lexed; - type NonTerm = GrammarNonTerminals; - type ReduceActionError = ::rusty_lr_core::DefaultReduceActionError; - type UserData = GrammarArgs; - type StartType = (); - type Location = SpanPair; - fn pop_start(&mut self) -> Option { - let tag = self.__tags.pop(); - debug_assert!(tag == Some(GrammarTags::Empty)); - Some(()) - } - fn pop(&mut self) { - match self.__tags.pop().unwrap() { - GrammarTags::__terminals => { - self.__terminals.pop(); + lookahead: &::rusty_lr_core::TerminalSymbol, + user_data: &mut Self::UserData, + location0: &mut Self::Location, + ) -> Result { + match rule_index { + 0usize => { + Self::reduce_Rule_0( + data_stack, + location_stack, + shift, + lookahead, + user_data, + location0, + ) } - GrammarTags::__stack2 => { - self.__stack2.pop(); + 1usize => { + Self::reduce_RuleType_0( + data_stack, + location_stack, + shift, + lookahead, + user_data, + location0, + ) } - GrammarTags::__stack3 => { - self.__stack3.pop(); + 2usize => { + Self::reduce_RuleType_1( + data_stack, + location_stack, + shift, + lookahead, + user_data, + location0, + ) } - GrammarTags::__stack4 => { - self.__stack4.pop(); + 3usize => { + Self::reduce_RuleLines_0( + data_stack, + location_stack, + shift, + lookahead, + user_data, + location0, + ) } - GrammarTags::__stack5 => { - self.__stack5.pop(); + 4usize => { + Self::reduce_RuleLines_1( + data_stack, + location_stack, + shift, + lookahead, + user_data, + location0, + ) } - GrammarTags::__stack6 => { - self.__stack6.pop(); + 5usize => { + Self::reduce_RuleLine_0( + data_stack, + location_stack, + shift, + lookahead, + user_data, + location0, + ) } - GrammarTags::__stack7 => { - self.__stack7.pop(); + 6usize => { + Self::reduce_PrecDef_0( + data_stack, + location_stack, + shift, + lookahead, + user_data, + location0, + ) } - GrammarTags::__stack8 => { - self.__stack8.pop(); + 7usize => { + Self::reduce_PrecDef_1( + data_stack, + location_stack, + shift, + lookahead, + user_data, + location0, + ) } - GrammarTags::__stack9 => { - self.__stack9.pop(); + 8usize => { + Self::reduce_PrecDef_2( + data_stack, + location_stack, + shift, + lookahead, + user_data, + location0, + ) } - GrammarTags::__stack10 => { - self.__stack10.pop(); + 9usize => { + Self::reduce_PrecDef_3( + data_stack, + location_stack, + shift, + lookahead, + user_data, + location0, + ) } - GrammarTags::__stack11 => { - self.__stack11.pop(); + 10usize => { + Self::reduce_PrecDef_4( + data_stack, + location_stack, + shift, + lookahead, + user_data, + location0, + ) } - GrammarTags::__stack12 => { - self.__stack12.pop(); + 11usize => { + Self::reduce_TokenMapped_0( + data_stack, + location_stack, + shift, + lookahead, + user_data, + location0, + ) } - GrammarTags::__stack13 => { - self.__stack13.pop(); + 12usize => { + Self::reduce_TokenMapped_1( + data_stack, + location_stack, + shift, + lookahead, + user_data, + location0, + ) } - GrammarTags::__stack14 => { - self.__stack14.pop(); + 13usize => { + Self::reduce_TerminalSetItem_0( + data_stack, + location_stack, + shift, + lookahead, + user_data, + location0, + ) } - GrammarTags::__stack15 => { - self.__stack15.pop(); + 14usize => { + Self::reduce_TerminalSetItem_1( + data_stack, + location_stack, + shift, + lookahead, + user_data, + location0, + ) } - GrammarTags::__stack16 => { - self.__stack16.pop(); + 15usize => { + Self::reduce_TerminalSetItem_2( + data_stack, + location_stack, + shift, + lookahead, + user_data, + location0, + ) } - GrammarTags::__stack17 => { - self.__stack17.pop(); + 16usize => { + Self::reduce_TerminalSetItem_3( + data_stack, + location_stack, + shift, + lookahead, + user_data, + location0, + ) } - GrammarTags::__stack18 => { - self.__stack18.pop(); + 17usize => { + Self::reduce_TerminalSetItem_4( + data_stack, + location_stack, + shift, + lookahead, + user_data, + location0, + ) } - GrammarTags::__stack19 => { - self.__stack19.pop(); - } - GrammarTags::__stack20 => { - self.__stack20.pop(); - } - _ => {} - } - } - fn push_terminal(&mut self, term: Self::Term) { - self.__tags.push(GrammarTags::__terminals); - self.__terminals.push(term); - } - fn push_empty(&mut self) { - self.__tags.push(GrammarTags::Empty); - } - fn clear(&mut self) { - self.__tags.clear(); - self.__terminals.clear(); - self.__stack2.clear(); - self.__stack3.clear(); - self.__stack4.clear(); - self.__stack5.clear(); - self.__stack6.clear(); - self.__stack7.clear(); - self.__stack8.clear(); - self.__stack9.clear(); - self.__stack10.clear(); - self.__stack11.clear(); - self.__stack12.clear(); - self.__stack13.clear(); - self.__stack14.clear(); - self.__stack15.clear(); - self.__stack16.clear(); - self.__stack17.clear(); - self.__stack18.clear(); - self.__stack19.clear(); - self.__stack20.clear(); - } - fn reserve(&mut self, additional: usize) { - self.__tags.reserve(additional); - } - fn split_off(&mut self, at: usize) -> Self { - let __other_tag_stack = self.__tags.split_off(at); - let mut __counts: [u8; 20usize + 1] = [0; 20usize + 1]; - for &tag in &__other_tag_stack { - __counts[tag as usize] += 1; - } - let __other___terminals = self - .__terminals - .split_off(self.__terminals.len() - (__counts[0usize] as usize)); - let __other___stack2 = self - .__stack2 - .split_off(self.__stack2.len() - (__counts[1usize] as usize)); - let __other___stack3 = self - .__stack3 - .split_off(self.__stack3.len() - (__counts[2usize] as usize)); - let __other___stack4 = self - .__stack4 - .split_off(self.__stack4.len() - (__counts[3usize] as usize)); - let __other___stack5 = self - .__stack5 - .split_off(self.__stack5.len() - (__counts[4usize] as usize)); - let __other___stack6 = self - .__stack6 - .split_off(self.__stack6.len() - (__counts[5usize] as usize)); - let __other___stack7 = self - .__stack7 - .split_off(self.__stack7.len() - (__counts[6usize] as usize)); - let __other___stack8 = self - .__stack8 - .split_off(self.__stack8.len() - (__counts[7usize] as usize)); - let __other___stack9 = self - .__stack9 - .split_off(self.__stack9.len() - (__counts[8usize] as usize)); - let __other___stack10 = self - .__stack10 - .split_off(self.__stack10.len() - (__counts[9usize] as usize)); - let __other___stack11 = self - .__stack11 - .split_off(self.__stack11.len() - (__counts[10usize] as usize)); - let __other___stack12 = self - .__stack12 - .split_off(self.__stack12.len() - (__counts[11usize] as usize)); - let __other___stack13 = self - .__stack13 - .split_off(self.__stack13.len() - (__counts[12usize] as usize)); - let __other___stack14 = self - .__stack14 - .split_off(self.__stack14.len() - (__counts[13usize] as usize)); - let __other___stack15 = self - .__stack15 - .split_off(self.__stack15.len() - (__counts[14usize] as usize)); - let __other___stack16 = self - .__stack16 - .split_off(self.__stack16.len() - (__counts[15usize] as usize)); - let __other___stack17 = self - .__stack17 - .split_off(self.__stack17.len() - (__counts[16usize] as usize)); - let __other___stack18 = self - .__stack18 - .split_off(self.__stack18.len() - (__counts[17usize] as usize)); - let __other___stack19 = self - .__stack19 - .split_off(self.__stack19.len() - (__counts[18usize] as usize)); - let __other___stack20 = self - .__stack20 - .split_off(self.__stack20.len() - (__counts[19usize] as usize)); - Self { - __tags: __other_tag_stack, - __terminals: __other___terminals, - __stack2: __other___stack2, - __stack3: __other___stack3, - __stack4: __other___stack4, - __stack5: __other___stack5, - __stack6: __other___stack6, - __stack7: __other___stack7, - __stack8: __other___stack8, - __stack9: __other___stack9, - __stack10: __other___stack10, - __stack11: __other___stack11, - __stack12: __other___stack12, - __stack13: __other___stack13, - __stack14: __other___stack14, - __stack15: __other___stack15, - __stack16: __other___stack16, - __stack17: __other___stack17, - __stack18: __other___stack18, - __stack19: __other___stack19, - __stack20: __other___stack20, - } - } - fn append(&mut self, other: &mut Self) { - self.__tags.append(&mut other.__tags); - self.__terminals.append(&mut other.__terminals); - self.__stack2.append(&mut other.__stack2); - self.__stack3.append(&mut other.__stack3); - self.__stack4.append(&mut other.__stack4); - self.__stack5.append(&mut other.__stack5); - self.__stack6.append(&mut other.__stack6); - self.__stack7.append(&mut other.__stack7); - self.__stack8.append(&mut other.__stack8); - self.__stack9.append(&mut other.__stack9); - self.__stack10.append(&mut other.__stack10); - self.__stack11.append(&mut other.__stack11); - self.__stack12.append(&mut other.__stack12); - self.__stack13.append(&mut other.__stack13); - self.__stack14.append(&mut other.__stack14); - self.__stack15.append(&mut other.__stack15); - self.__stack16.append(&mut other.__stack16); - self.__stack17.append(&mut other.__stack17); - self.__stack18.append(&mut other.__stack18); - self.__stack19.append(&mut other.__stack19); - self.__stack20.append(&mut other.__stack20); - } - fn reduce_action( - data_stack: &mut Self, - location_stack: &mut Vec, - rule_index: usize, - shift: &mut bool, - lookahead: &::rusty_lr_core::TerminalSymbol, - user_data: &mut Self::UserData, - location0: &mut Self::Location, - ) -> Result<(), Self::ReduceActionError> { - match rule_index { - 0usize => { - Self::reduce_Rule_0( + 18usize => { + Self::reduce_TerminalSetItem_5( data_stack, location_stack, shift, @@ -4970,8 +4805,8 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 1usize => { - Self::reduce_RuleType_0( + 19usize => { + Self::reduce_TerminalSet_0( data_stack, location_stack, shift, @@ -4980,8 +4815,8 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 2usize => { - Self::reduce_RuleType_1( + 20usize => { + Self::reduce_TerminalSet_1( data_stack, location_stack, shift, @@ -4990,8 +4825,8 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 3usize => { - Self::reduce_RuleLines_0( + 21usize => { + Self::reduce_Pattern_0( data_stack, location_stack, shift, @@ -5000,8 +4835,8 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 4usize => { - Self::reduce_RuleLines_1( + 22usize => { + Self::reduce_Pattern_1( data_stack, location_stack, shift, @@ -5010,8 +4845,8 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 5usize => { - Self::reduce_RuleLine_0( + 23usize => { + Self::reduce_Pattern_2( data_stack, location_stack, shift, @@ -5020,8 +4855,8 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 6usize => { - Self::reduce_PrecDef_0( + 24usize => { + Self::reduce_Pattern_3( data_stack, location_stack, shift, @@ -5030,8 +4865,8 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 7usize => { - Self::reduce_PrecDef_1( + 25usize => { + Self::reduce_Pattern_4( data_stack, location_stack, shift, @@ -5040,8 +4875,8 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 8usize => { - Self::reduce_PrecDef_2( + 26usize => { + Self::reduce_Pattern_5( data_stack, location_stack, shift, @@ -5050,8 +4885,8 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 9usize => { - Self::reduce_PrecDef_3( + 27usize => { + Self::reduce_Pattern_6( data_stack, location_stack, shift, @@ -5060,8 +4895,8 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 10usize => { - Self::reduce_PrecDef_4( + 28usize => { + Self::reduce_Pattern_7( data_stack, location_stack, shift, @@ -5070,8 +4905,8 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 11usize => { - Self::reduce_TokenMapped_0( + 29usize => { + Self::reduce_Pattern_8( data_stack, location_stack, shift, @@ -5080,8 +4915,8 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 12usize => { - Self::reduce_TokenMapped_1( + 30usize => { + Self::reduce_Pattern_9( data_stack, location_stack, shift, @@ -5090,8 +4925,8 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 13usize => { - Self::reduce_TerminalSetItem_0( + 31usize => { + Self::reduce_Pattern_10( data_stack, location_stack, shift, @@ -5100,8 +4935,8 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 14usize => { - Self::reduce_TerminalSetItem_1( + 32usize => { + Self::reduce_Pattern_11( data_stack, location_stack, shift, @@ -5110,8 +4945,8 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 15usize => { - Self::reduce_TerminalSetItem_2( + 33usize => { + Self::reduce_Pattern_12( data_stack, location_stack, shift, @@ -5120,8 +4955,8 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 16usize => { - Self::reduce_TerminalSetItem_3( + 34usize => { + Self::reduce_Pattern_13( data_stack, location_stack, shift, @@ -5130,8 +4965,8 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 17usize => { - Self::reduce_TerminalSetItem_4( + 35usize => { + Self::reduce_Pattern_14( data_stack, location_stack, shift, @@ -5140,8 +4975,8 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 18usize => { - Self::reduce_TerminalSetItem_5( + 36usize => { + Self::reduce_Pattern_15( data_stack, location_stack, shift, @@ -5150,8 +4985,8 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 19usize => { - Self::reduce_TerminalSet_0( + 37usize => { + Self::reduce_Action_0( data_stack, location_stack, shift, @@ -5160,8 +4995,8 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 20usize => { - Self::reduce_TerminalSet_1( + 38usize => { + Self::reduce_Action_1( data_stack, location_stack, shift, @@ -5170,8 +5005,8 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 21usize => { - Self::reduce_Pattern_0( + 39usize => { + Self::reduce_IdentOrLiteral_0( data_stack, location_stack, shift, @@ -5180,188 +5015,8 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 22usize => { - Self::reduce_Pattern_1( - data_stack, - location_stack, - shift, - lookahead, - user_data, - location0, - ) - } - 23usize => { - Self::reduce_Pattern_2( - data_stack, - location_stack, - shift, - lookahead, - user_data, - location0, - ) - } - 24usize => { - Self::reduce_Pattern_3( - data_stack, - location_stack, - shift, - lookahead, - user_data, - location0, - ) - } - 25usize => { - Self::reduce_Pattern_4( - data_stack, - location_stack, - shift, - lookahead, - user_data, - location0, - ) - } - 26usize => { - Self::reduce_Pattern_5( - data_stack, - location_stack, - shift, - lookahead, - user_data, - location0, - ) - } - 27usize => { - Self::reduce_Pattern_6( - data_stack, - location_stack, - shift, - lookahead, - user_data, - location0, - ) - } - 28usize => { - Self::reduce_Pattern_7( - data_stack, - location_stack, - shift, - lookahead, - user_data, - location0, - ) - } - 29usize => { - Self::reduce_Pattern_8( - data_stack, - location_stack, - shift, - lookahead, - user_data, - location0, - ) - } - 30usize => { - Self::reduce_Pattern_9( - data_stack, - location_stack, - shift, - lookahead, - user_data, - location0, - ) - } - 31usize => { - Self::reduce_Pattern_10( - data_stack, - location_stack, - shift, - lookahead, - user_data, - location0, - ) - } - 32usize => { - Self::reduce_Pattern_11( - data_stack, - location_stack, - shift, - lookahead, - user_data, - location0, - ) - } - 33usize => { - Self::reduce_Pattern_12( - data_stack, - location_stack, - shift, - lookahead, - user_data, - location0, - ) - } - 34usize => { - Self::reduce_Pattern_13( - data_stack, - location_stack, - shift, - lookahead, - user_data, - location0, - ) - } - 35usize => { - Self::reduce_Pattern_14( - data_stack, - location_stack, - shift, - lookahead, - user_data, - location0, - ) - } - 36usize => { - Self::reduce_Pattern_15( - data_stack, - location_stack, - shift, - lookahead, - user_data, - location0, - ) - } - 37usize => { - Self::reduce_Action_0( - data_stack, - location_stack, - shift, - lookahead, - user_data, - location0, - ) - } - 38usize => { - Self::reduce_Action_1( - data_stack, - location_stack, - shift, - lookahead, - user_data, - location0, - ) - } - 39usize => { - Self::reduce_IdentOrLiteral_0( - data_stack, - location_stack, - shift, - lookahead, - user_data, - location0, - ) - } - 40usize => { - Self::reduce_IdentOrLiteral_1( + 40usize => { + Self::reduce_IdentOrLiteral_1( data_stack, location_stack, shift, @@ -5731,12 +5386,10 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { ) } 77usize => { - Self::reduce_GrammarLine_1(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 78usize => { - Self::reduce_Grammar_0(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 79usize => { Self::reduce__TokenMappedPlus15_0( @@ -5758,10 +5411,7 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 81usize => { - Self::reduce__TokenMappedStar16_0(data_stack, location_stack); - Ok(()) - } + 81usize => Ok(Self::reduce__TokenMappedStar16_0(data_stack, location_stack)), 82usize => { Self::reduce__TokenMappedStar16_1( data_stack, @@ -5792,10 +5442,7 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 85usize => { - Self::reduce__PrecDefStar18_0(data_stack, location_stack); - Ok(()) - } + 85usize => Ok(Self::reduce__PrecDefStar18_0(data_stack, location_stack)), 86usize => { Self::reduce__PrecDefStar18_1( data_stack, @@ -5847,8 +5494,7 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { ) } 91usize => { - Self::reduce__TerminalSetItemStar21_0(data_stack, location_stack); - Ok(()) + Ok(Self::reduce__TerminalSetItemStar21_0(data_stack, location_stack)) } 92usize => { Self::reduce__TerminalSetItemStar21_1( @@ -5880,10 +5526,7 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 95usize => { - Self::reduce__PatternStar23_0(data_stack, location_stack); - Ok(()) - } + 95usize => Ok(Self::reduce__PatternStar23_0(data_stack, location_stack)), 96usize => { Self::reduce__PatternStar23_1( data_stack, @@ -5935,168 +5578,127 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { ) } 101usize => { - Self::reduce__TermSet26_0(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 102usize => { - Self::reduce__TermSet26_1(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 103usize => { - Self::reduce__TermSet26_2(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 104usize => { - Self::reduce__TermSet26_3(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 105usize => { - Self::reduce__TermSet26_4(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 106usize => { - Self::reduce__TermSet26_5(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 107usize => { - Self::reduce__TermSet26_6(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 108usize => { - Self::reduce__TermSet26_7(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 109usize => { - Self::reduce__TermSet26_8(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 110usize => { - Self::reduce__TermSet26_9(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 111usize => { - Self::reduce__TermSet26_10(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 112usize => { - Self::reduce__TermSet26_11(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 113usize => { - Self::reduce__TermSet26_12(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 114usize => { - Self::reduce__TermSet26_13(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 115usize => { - Self::reduce__TermSet26_14(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 116usize => { - Self::reduce__TermSet26_15(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 117usize => { - Self::reduce__TermSet26_16(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 118usize => { - Self::reduce__TermSet26_17(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 119usize => { - Self::reduce__TermSet26_18(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 120usize => { - Self::reduce__TermSet26_19(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 121usize => { - Self::reduce__TermSet26_20(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 122usize => { - Self::reduce__TermSet26_21(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 123usize => { - Self::reduce__TermSet26_22(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 124usize => { - Self::reduce__TermSet26_23(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 125usize => { - Self::reduce__TermSet26_24(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 126usize => { - Self::reduce__TermSet26_25(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 127usize => { - Self::reduce__TermSet26_26(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 128usize => { - Self::reduce__TermSet26_27(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 129usize => { - Self::reduce__TermSet26_28(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 130usize => { - Self::reduce__TermSet26_29(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 131usize => { - Self::reduce__TermSet26_30(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 132usize => { - Self::reduce__TermSet26_31(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 133usize => { - Self::reduce__TermSet26_32(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 134usize => { - Self::reduce__TermSet26_33(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 135usize => { - Self::reduce__TermSet26_34(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 136usize => { - Self::reduce__TermSet26_35(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 137usize => { - Self::reduce__TermSet26_36(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 138usize => { - Self::reduce__TermSet26_37(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 139usize => { - Self::reduce__TermSet26_38(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 140usize => { - Self::reduce__TermSet26_39(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 141usize => { - Self::reduce__TermSet26_40(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } 142usize => { Self::reduce___TermSet26Plus27_0( @@ -6158,10 +5760,7 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { location0, ) } - 148usize => { - Self::reduce__identStar30_0(data_stack, location_stack); - Ok(()) - } + 148usize => Ok(Self::reduce__identStar30_0(data_stack, location_stack)), 149usize => { Self::reduce__identStar30_1( data_stack, @@ -6174,15 +5773,14 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack { } 150usize => { Self::reduce__GrammarLinePlus31_0(data_stack, location_stack); - Ok(()) + Ok(false) } 151usize => { Self::reduce__GrammarLinePlus31_1(data_stack, location_stack); - Ok(()) + Ok(false) } 152usize => { - Self::reduce_Augmented_0(data_stack, location_stack); - Ok(()) + unreachable!("{rule_index}: this production rule was optimized out") } _ => { unreachable!("Invalid Rule: {}", rule_index); @@ -6793,1758 +6391,1597 @@ impl GrammarParser { GrammarNonTerminals::_TermSet26, rule : vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(0)),], precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(1)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(3)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(4)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(5)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(6)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(7)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(8)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(9)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(10)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(11)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(12)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(13)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(14)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(15)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(16)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(17)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(18)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(19)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(20)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(21)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(22)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(23)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(24)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(25)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(26)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(27)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(28)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(29)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(30)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(31)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(32)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(33)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(34)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(35)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(36)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(37)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(38)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(39)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(40)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_TermSet26, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(41)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::__TermSet26Plus27, rule : - vec![::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::_TermSet26),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::__TermSet26Plus27, rule : - vec![::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::__TermSet26Plus27), - ::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::_TermSet26),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_IdentOrLiteralPlus28, rule : - vec![::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::IdentOrLiteral),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_IdentOrLiteralPlus28, rule : - vec![::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::_IdentOrLiteralPlus28), - ::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::IdentOrLiteral),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_identPlus29, rule : - vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(0)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_identPlus29, rule : - vec![::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::_identPlus29), - ::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(0)),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_identStar30, rule : - vec![::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::_identPlus29),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_identStar30, rule : vec![], precedence : None, }, - ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_GrammarLinePlus31, rule : - vec![::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::GrammarLine),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::_GrammarLinePlus31, rule : - vec![::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::GrammarLine), - ::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::_GrammarLinePlus31),], - precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : - GrammarNonTerminals::Augmented, rule : - vec![::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::Grammar), - ::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Eof),], - precedence : None, }, - ]; - let terminal_class_names = vec![ - "ident", "colon", "semicolon", "pipe", "percent", "equal", "plus", "star", - "question", "caret", "minus", "exclamation", "slash", "dot", "dollar", - "comma", "literal", "parengroup", "bracegroup", "lparen", "rparen", - "lbracket", "rbracket", "left", "right", "token", "start", "tokentype", - "userdata", "errortype", "moduleprefix", "lalr", "glr", "prec", "precedence", - "nooptim", "dense", "trace", "dprec", "filter", "location", "", - ]; - let rules = rules - .into_iter() - .map(move |rule| { - rule.map( - |term| match term { - ::rusty_lr_core::TerminalSymbol::Term(term) => { - terminal_class_names[term as usize] - } - ::rusty_lr_core::TerminalSymbol::Error => "error", - ::rusty_lr_core::TerminalSymbol::Eof => "eof", - }, - |nonterm| nonterm, - ) - }) - .collect(); - let __rustylr_tset17: Vec = vec![ - 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, - 41 - ]; - let __rustylr_tset19: Vec = vec![0, 2]; - let __rustylr_tset3: Vec = vec![ - 0, 2, 3, 4, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 18, 19, 20, 21 - ]; - let __rustylr_tset2: Vec = vec![ - 0, 2, 3, 4, 6, 7, 8, 10, 11, 12, 13, 14, 16, 18, 19, 21 - ]; - let __rustylr_tset8: Vec = vec![ - 0, 2, 3, 4, 10, 12, 13, 14, 15, 16, 18, 19, 20, 21 - ]; - let __rustylr_tset7: Vec = vec![ - 0, 2, 3, 4, 10, 13, 14, 15, 16, 18, 19, 20, 21 - ]; - let __rustylr_tset11: Vec = vec![0, 2, 3, 4, 13, 14, 16, 18, 19, 21]; - let __rustylr_tset15: Vec = vec![0, 2, 3, 4, 16, 18]; - let __rustylr_tset16: Vec = vec![0, 2, 16]; - let __rustylr_tset9: Vec = vec![0, 3, 13, 14, 16, 19, 20, 21]; - let __rustylr_tset12: Vec = vec![0, 4]; - let __rustylr_tset5: Vec = vec![0, 16, 22]; - let __rustylr_tset0: Vec = vec![1]; - let __rustylr_tset18: Vec = vec![2]; - let __rustylr_tset13: Vec = vec![2, 3]; - let __rustylr_tset1: Vec = vec![2, 3, 4, 18]; - let __rustylr_tset14: Vec = vec![2, 3, 18]; - let __rustylr_tset4: Vec = vec![3, 20]; - let __rustylr_tset10: Vec = vec![20]; - let __rustylr_tset6: Vec = vec![22]; - let states: Vec< - ::rusty_lr_core::parser::state::IntermediateState, - > = vec![ - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 1), (4, 90),], error_shift : None, eof_shift : None, - shift_goto_map_nonterm : vec![(GrammarNonTerminals::Rule, 214), - (GrammarNonTerminals::Directive, 215), (GrammarNonTerminals::GrammarLine, - 216), (GrammarNonTerminals::Grammar, 218), - (GrammarNonTerminals::_GrammarLinePlus31, 220),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); __reduce_map.into_iter() - .collect() }, error_reduce : None, eof_reduce : None, ruleset : { let rules : - & 'static [u8] = & [0, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 77, 78, 150, 151, 152,]; let shifted : & 'static [u8] = & [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, 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() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(17, 2),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![(GrammarNonTerminals::RuleType, 3),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![2]; - __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [0, 1, 2,]; let - shifted : & 'static [u8] = & [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() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![1]; __reduce_map - .extend(__rustylr_tset0.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [1,]; let shifted : & 'static [u8] - = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(1, 4),], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [0,]; let shifted : & 'static [u8] = & [2,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 5), (13, 8), (14, 9), (16, 12), (19, 13), (21, 14),], error_shift : - None, eof_shift : None, shift_goto_map_nonterm : - vec![(GrammarNonTerminals::RuleLines, 64), (GrammarNonTerminals::RuleLine, - 89), (GrammarNonTerminals::TokenMapped, 68), - (GrammarNonTerminals::TerminalSet, 30), (GrammarNonTerminals::Pattern, 69), - (GrammarNonTerminals::_TokenMappedPlus15, 70), - (GrammarNonTerminals::_TokenMappedStar16, 72),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![82]; __reduce_map.extend(__rustylr_tset1.iter().map(| term | (* term, - reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : - None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [0, 3, 4, - 5, 11, 12, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 79, 80, 81, 82,]; let shifted : & 'static [u8] = & [3, 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() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(5, 6),], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![21]; __reduce_map - .extend(__rustylr_tset2.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [12, 21,]; let shifted : & 'static - [u8] = & [1, 1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) - | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 7), (13, 8), (14, 9), (16, 12), (19, 13), (21, 14),], error_shift : - None, eof_shift : None, shift_goto_map_nonterm : - vec![(GrammarNonTerminals::TerminalSet, 30), (GrammarNonTerminals::Pattern, - 63),], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [12, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36,]; let shifted : & 'static [u8] = & [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() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![21]; __reduce_map - .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : Some(vec![21]), - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [21,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![20]; __reduce_map - .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : Some(vec![20]), - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [20,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 10),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [32, 33, 34, 35, 36,]; let shifted : & 'static [u8] = & [1, 1, 1, 1, - 1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(19, 11),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [32, 33, 34, 35, 36,]; let shifted : & 'static [u8] = & [2, 2, 2, 2, - 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 7), (13, 8), (14, 9), (16, 12), (19, 13), (21, 14),], error_shift : - None, eof_shift : None, shift_goto_map_nonterm : - vec![(GrammarNonTerminals::TerminalSet, 30), (GrammarNonTerminals::Pattern, - 31),], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 32, 33, 33, - 34, 34, 35, 35, 36, 36,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3,]; rules.iter().zip(shifted - .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef - { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![30]; __reduce_map - .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : Some(vec![30]), - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [30,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 7), (13, 8), (14, 9), (16, 12), (19, 13), (21, 14),], error_shift : - Some(41), eof_shift : None, shift_goto_map_nonterm : - vec![(GrammarNonTerminals::TerminalSet, 30), (GrammarNonTerminals::Pattern, - 43), (GrammarNonTerminals::_PatternPlus22, 44), - (GrammarNonTerminals::_PatternStar23, 46), - (GrammarNonTerminals::__PatternStar23SepPlus24, 47),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![96]; __reduce_map.extend(__rustylr_tset4.iter().map(| term | (* term, - reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : - None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [19, 20, - 21, 22, 23, 24, 25, 26, 27, 28, 28, 29, 29, 30, 31, 32, 33, 34, 35, 36, 93, - 94, 95, 96, 97, 98,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 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() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(9, 15),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![(GrammarNonTerminals::_caretQuestion19, 16),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![88]; __reduce_map.extend(__rustylr_tset5.iter().map(| term | (* term, - reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : - None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [19, 87, - 88,]; let shifted : & 'static [u8] = & [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() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![87]; __reduce_map - .extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [87,]; let shifted : & 'static - [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 17), (16, 21),], error_shift : None, eof_shift : None, - shift_goto_map_nonterm : vec![(GrammarNonTerminals::TerminalSetItem, 25), - (GrammarNonTerminals::_TerminalSetItemPlus20, 26), - (GrammarNonTerminals::_TerminalSetItemStar21, 28),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![92]; __reduce_map.extend(__rustylr_tset6.iter().map(| term | (* term, - reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : - None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [13, 14, - 15, 16, 17, 18, 19, 89, 90, 91, 92,]; let shifted : & 'static [u8] = & [0, 0, - 0, 0, 0, 0, 2, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, - & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(10, 18),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![13]; __reduce_map - .extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [13, 14, 15,]; let shifted : & - 'static [u8] = & [1, 1, 1,]; rules.iter().zip(shifted.iter()).map(| (& rule, - & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 19),], error_shift : Some(20), eof_shift : None, - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [14, 15,]; let shifted : & 'static [u8] = & [2, 2,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![14]; __reduce_map - .extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [14,]; let shifted : & 'static - [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![15]; __reduce_map - .extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [15,]; let shifted : & 'static - [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(10, 22),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![16]; __reduce_map - .extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [16, 17, 18,]; let shifted : & - 'static [u8] = & [1, 1, 1,]; rules.iter().zip(shifted.iter()).map(| (& rule, - & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(16, 23),], error_shift : Some(24), eof_shift : None, - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [17, 18,]; let shifted : & 'static [u8] = & [2, 2,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![17]; __reduce_map - .extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [17,]; let shifted : & 'static - [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![18]; __reduce_map - .extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [18,]; let shifted : & 'static - [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![89]; __reduce_map - .extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [89,]; let shifted : & 'static - [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 17), (16, 21),], error_shift : None, eof_shift : None, - shift_goto_map_nonterm : vec![(GrammarNonTerminals::TerminalSetItem, 27),], - reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let - reduce_rules = vec![91]; __reduce_map.extend(__rustylr_tset6.iter().map(| - term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() - }, error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [13, 14, 15, 16, 17, 18, 90, 91,]; let shifted : & 'static [u8] = & - [0, 0, 0, 0, 0, 0, 1, 1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![90]; __reduce_map - .extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [90,]; let shifted : & 'static - [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(22, 29),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [19,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![19]; __reduce_map - .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : Some(vec![19]), - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [19,]; let - shifted : & 'static [u8] = & [4,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![26]; __reduce_map - .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : Some(vec![26]), - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [26,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(6, 32), (7, 33), (8, 34), (10, 35), (11, 37), (12, 38), (15, 40),], - error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], - reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); - __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [22, 23, 24, 25, 27, 31, 32, 33, - 34, 35, 36,]; let shifted : & 'static [u8] = & [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() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![22]; __reduce_map - .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : Some(vec![22]), - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [22,]; let - shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![23]; __reduce_map - .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : Some(vec![23]), - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [23,]; let - shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![24]; __reduce_map - .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : Some(vec![24]), - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [24,]; let - shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 7), (13, 8), (14, 9), (16, 12), (19, 13), (21, 14),], error_shift : - None, eof_shift : None, shift_goto_map_nonterm : - vec![(GrammarNonTerminals::TerminalSet, 30), (GrammarNonTerminals::Pattern, - 36),], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 31, 32, 33, 34, - 35, 36,]; let shifted : & 'static [u8] = & [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() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(6, 32), (7, 33), (8, 34), (11, 37), (12, 38),], error_shift : None, - eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![31]; __reduce_map.extend(__rustylr_tset7.iter().map(| term | (* term, - reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : - Some(vec![31]), eof_reduce : None, ruleset : { let rules : & 'static [u8] = & - [22, 23, 24, 25, 27, 31,]; let shifted : & 'static [u8] = & [1, 1, 1, 1, 1, - 3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![25]; __reduce_map - .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : Some(vec![25]), - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [25,]; let - shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 7), (13, 8), (14, 9), (16, 12), (19, 13), (21, 14),], error_shift : - None, eof_shift : None, shift_goto_map_nonterm : - vec![(GrammarNonTerminals::TerminalSet, 30), (GrammarNonTerminals::Pattern, - 39),], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [19, 20, 21, 22, 23, 24, 25, 26, 27, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36,]; let shifted : & 'static [u8] = & [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() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(6, 32), (7, 33), (8, 34), (11, 37),], error_shift : None, eof_shift : - None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![27]; __reduce_map - .extend(__rustylr_tset8.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : Some(vec![27]), - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [22, 23, 24, - 25, 27,]; let shifted : & 'static [u8] = & [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() } }, + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(1)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(3)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(4)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(5)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(6)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(7)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(8)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(9)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(10)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(11)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(12)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(13)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(14)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(15)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(16)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(17)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(18)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(19)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(20)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(21)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(22)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(23)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(24)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(25)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(26)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(27)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(28)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(29)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(30)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(31)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(32)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(33)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(34)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(35)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(36)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(37)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(38)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(39)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(40)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_TermSet26, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(41)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::__TermSet26Plus27, rule : + vec![::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::_TermSet26),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::__TermSet26Plus27, rule : + vec![::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::__TermSet26Plus27), + ::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::_TermSet26),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_IdentOrLiteralPlus28, rule : + vec![::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::IdentOrLiteral),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_IdentOrLiteralPlus28, rule : + vec![::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::_IdentOrLiteralPlus28), + ::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::IdentOrLiteral),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_identPlus29, rule : + vec![::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(0)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_identPlus29, rule : + vec![::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::_identPlus29), + ::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Term(0)),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_identStar30, rule : + vec![::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::_identPlus29),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_identStar30, rule : vec![], precedence : None, }, + ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_GrammarLinePlus31, rule : + vec![::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::GrammarLine),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::_GrammarLinePlus31, rule : + vec![::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::GrammarLine), + ::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::_GrammarLinePlus31),], + precedence : None, }, ::rusty_lr_core::rule::ProductionRule { name : + GrammarNonTerminals::Augmented, rule : + vec![::rusty_lr_core::Token::NonTerm(GrammarNonTerminals::Grammar), + ::rusty_lr_core::Token::Term(::rusty_lr_core::TerminalSymbol::Eof),], + precedence : None, }, + ]; + let terminal_class_names = vec![ + "ident", "colon", "semicolon", "pipe", "percent", "equal", "plus", "star", + "question", "caret", "minus", "exclamation", "slash", "dot", "dollar", + "comma", "literal", "parengroup", "bracegroup", "lparen", "rparen", + "lbracket", "rbracket", "left", "right", "token", "start", "tokentype", + "userdata", "errortype", "moduleprefix", "lalr", "glr", "prec", "precedence", + "nooptim", "dense", "trace", "dprec", "filter", "location", "", + ]; + let rules = rules + .into_iter() + .map(move |rule| { + rule.map( + |term| match term { + ::rusty_lr_core::TerminalSymbol::Term(term) => { + terminal_class_names[term as usize] + } + ::rusty_lr_core::TerminalSymbol::Error => "error", + ::rusty_lr_core::TerminalSymbol::Eof => "eof", + }, + |nonterm| nonterm, + ) + }) + .collect(); + let __rustylr_tset17: Vec = vec![ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41 + ]; + let __rustylr_tset19: Vec = vec![0, 2]; + let __rustylr_tset3: Vec = vec![ + 0, 2, 3, 4, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 18, 19, 20, 21 + ]; + let __rustylr_tset2: Vec = vec![ + 0, 2, 3, 4, 6, 7, 8, 10, 11, 12, 13, 14, 16, 18, 19, 21 + ]; + let __rustylr_tset8: Vec = vec![ + 0, 2, 3, 4, 10, 12, 13, 14, 15, 16, 18, 19, 20, 21 + ]; + let __rustylr_tset7: Vec = vec![ + 0, 2, 3, 4, 10, 13, 14, 15, 16, 18, 19, 20, 21 + ]; + let __rustylr_tset11: Vec = vec![0, 2, 3, 4, 13, 14, 16, 18, 19, 21]; + let __rustylr_tset15: Vec = vec![0, 2, 3, 4, 16, 18]; + let __rustylr_tset16: Vec = vec![0, 2, 16]; + let __rustylr_tset9: Vec = vec![0, 3, 13, 14, 16, 19, 20, 21]; + let __rustylr_tset12: Vec = vec![0, 4]; + let __rustylr_tset5: Vec = vec![0, 16, 22]; + let __rustylr_tset0: Vec = vec![1]; + let __rustylr_tset18: Vec = vec![2]; + let __rustylr_tset13: Vec = vec![2, 3]; + let __rustylr_tset1: Vec = vec![2, 3, 4, 18]; + let __rustylr_tset14: Vec = vec![2, 3, 18]; + let __rustylr_tset4: Vec = vec![3, 20]; + let __rustylr_tset10: Vec = vec![20]; + let __rustylr_tset6: Vec = vec![22]; + let states: Vec< + ::rusty_lr_core::parser::state::IntermediateState, + > = vec![ ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 7), (13, 8), (14, 9), (16, 12), (19, 13), (21, 14),], error_shift : + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(1, true)), (4, + ::rusty_lr_core::parser::state::ShiftTarget::new(90, true)),], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![(GrammarNonTerminals::TerminalSet, 30), (GrammarNonTerminals::Pattern, - 51),], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 32, 33, 33, - 34, 34, 35, 35, 36, 36,]; let shifted : & 'static [u8] = & [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 + vec![(GrammarNonTerminals::Rule, + ::rusty_lr_core::parser::state::ShiftTarget::new(173, true)), + (GrammarNonTerminals::Directive, + ::rusty_lr_core::parser::state::ShiftTarget::new(174, false)), + (GrammarNonTerminals::GrammarLine, + ::rusty_lr_core::parser::state::ShiftTarget::new(174, true)), + (GrammarNonTerminals::Grammar, + ::rusty_lr_core::parser::state::ShiftTarget::new(176, true)), + (GrammarNonTerminals::_GrammarLinePlus31, + ::rusty_lr_core::parser::state::ShiftTarget::new(176, false)),], reduce_map : + { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [0, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 150, 151, 152,]; let shifted : & 'static [u8] + = & [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, 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() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(20, 42),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [29,]; let shifted : & 'static [u8] = & [2,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![29]; __reduce_map - .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : Some(vec![29]), - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [29,]; let - shifted : & 'static [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(6, 32), (7, 33), (8, 34), (10, 35), (11, 37), (12, 38),], error_shift : - None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![93]; __reduce_map.extend(__rustylr_tset9.iter().map(| term | (* term, - reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : - None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [22, 23, - 24, 25, 27, 31, 93,]; let shifted : & 'static [u8] = & [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() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 7), (13, 8), (14, 9), (16, 12), (19, 13), (21, 14),], error_shift : - None, eof_shift : None, shift_goto_map_nonterm : - vec![(GrammarNonTerminals::TerminalSet, 30), (GrammarNonTerminals::Pattern, - 45),], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![95]; __reduce_map - .extend(__rustylr_tset4.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [19, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 94, 95,]; let shifted : & 'static - [u8] = & [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,]; rules - .iter().zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(6, 32), (7, 33), (8, 34), (10, 35), (11, 37), (12, 38),], error_shift : - None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![94]; __reduce_map.extend(__rustylr_tset9.iter().map(| term | (* term, + { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(17, ::rusty_lr_core::parser::state::ShiftTarget::new(2, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::RuleType, + ::rusty_lr_core::parser::state::ShiftTarget::new(3, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![2]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : - None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [22, 23, - 24, 25, 27, 31, 94,]; let shifted : & 'static [u8] = & [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() } }, + None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [0, 1, + 2,]; let shifted : & 'static [u8] = & [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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![97]; __reduce_map - .extend(__rustylr_tset4.iter().map(| term | (* term, reduce_rules.clone()))); + std::collections::BTreeMap::new(); let reduce_rules = vec![1]; __reduce_map + .extend(__rustylr_tset0.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [97,]; let shifted : & 'static - [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(3, 48), (20, 50),], error_shift : None, eof_shift : None, - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [28, 98,]; let shifted : & 'static [u8] = & [2, 1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + ruleset : { let rules : & 'static [u8] = & [1,]; let shifted : & 'static [u8] + = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 7), (13, 8), (14, 9), (16, 12), (19, 13), (21, 14),], error_shift : - None, eof_shift : None, shift_goto_map_nonterm : - vec![(GrammarNonTerminals::TerminalSet, 30), (GrammarNonTerminals::Pattern, - 43), (GrammarNonTerminals::_PatternPlus22, 44), - (GrammarNonTerminals::_PatternStar23, 49),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![96]; __reduce_map.extend(__rustylr_tset4.iter().map(| term | (* term, - reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : - None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [19, 20, - 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 93, 94, 95, - 96, 98,]; let shifted : & 'static [u8] = & [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() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![98]; __reduce_map - .extend(__rustylr_tset4.iter().map(| term | (* term, reduce_rules.clone()))); + vec![(1, ::rusty_lr_core::parser::state::ShiftTarget::new(4, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [98,]; let shifted : & 'static - [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ruleset : { let rules : & 'static [u8] = & [0,]; let shifted : & 'static [u8] + = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![28]; __reduce_map - .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : Some(vec![28]), - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [28,]; let - shifted : & 'static [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(6, 32), (7, 33), (8, 34), (10, 35), (11, 37), (12, 38), (15, 52),], - error_shift : Some(59), eof_shift : None, shift_goto_map_nonterm : - vec![(GrammarNonTerminals::_commaQuestion25, 61),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![100]; __reduce_map.extend(__rustylr_tset10.iter().map(| term | (* term, + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(5, true)), (13, + ::rusty_lr_core::parser::state::ShiftTarget::new(8, true)), (14, + ::rusty_lr_core::parser::state::ShiftTarget::new(9, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(12, true)), (19, + ::rusty_lr_core::parser::state::ShiftTarget::new(13, true)), (21, + ::rusty_lr_core::parser::state::ShiftTarget::new(14, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::RuleLines, + ::rusty_lr_core::parser::state::ShiftTarget::new(64, true)), + (GrammarNonTerminals::RuleLine, + ::rusty_lr_core::parser::state::ShiftTarget::new(89, true)), + (GrammarNonTerminals::TokenMapped, + ::rusty_lr_core::parser::state::ShiftTarget::new(68, true)), + (GrammarNonTerminals::TerminalSet, + ::rusty_lr_core::parser::state::ShiftTarget::new(30, true)), + (GrammarNonTerminals::Pattern, + ::rusty_lr_core::parser::state::ShiftTarget::new(69, true)), + (GrammarNonTerminals::_TokenMappedPlus15, + ::rusty_lr_core::parser::state::ShiftTarget::new(70, true)), + (GrammarNonTerminals::_TokenMappedStar16, + ::rusty_lr_core::parser::state::ShiftTarget::new(72, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![82]; __reduce_map.extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : - None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [22, 23, - 24, 25, 27, 31, 32, 33, 34, 35, 36, 99, 100,]; let shifted : & 'static [u8] = - & [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() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(6, 53), (7, 55),], error_shift : Some(57), eof_shift : None, - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![99]; __reduce_map - .extend(__rustylr_tset10.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [33, 34, 36, - 99,]; let shifted : & 'static [u8] = & [7, 7, 7, 1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [0, 3, 4, + 5, 11, 12, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 79, 80, 81, 82,]; let shifted : & 'static [u8] = & [3, 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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(20, 54),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [33,]; let shifted : & 'static [u8] = & [8,]; rules.iter() + vec![(5, ::rusty_lr_core::parser::state::ShiftTarget::new(6, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let + reduce_rules = vec![21]; __reduce_map.extend(__rustylr_tset2.iter().map(| + term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() + }, error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static + [u8] = & [12, 21,]; let shifted : & 'static [u8] = & [1, 1,]; rules.iter() .zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![33]; __reduce_map - .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : Some(vec![33]), - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [33,]; let - shifted : & 'static [u8] = & [9,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(20, 56),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [34,]; let shifted : & 'static [u8] = & [8,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), (13, + ::rusty_lr_core::parser::state::ShiftTarget::new(8, true)), (14, + ::rusty_lr_core::parser::state::ShiftTarget::new(9, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(12, true)), (19, + ::rusty_lr_core::parser::state::ShiftTarget::new(13, true)), (21, + ::rusty_lr_core::parser::state::ShiftTarget::new(14, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::TerminalSet, + ::rusty_lr_core::parser::state::ShiftTarget::new(30, true)), + (GrammarNonTerminals::Pattern, + ::rusty_lr_core::parser::state::ShiftTarget::new(63, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [12, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36,]; let shifted : & 'static [u8] = & [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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![34]; __reduce_map + std::collections::BTreeMap::new(); let reduce_rules = vec![21]; __reduce_map .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : Some(vec![34]), - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [34,]; let - shifted : & 'static [u8] = & [9,]; rules.iter().zip(shifted.iter()).map(| (& + __reduce_map.into_iter().collect() }, error_reduce : Some(vec![21]), + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [21,]; let + shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(20, 58),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [36,]; let shifted : & 'static [u8] = & [8,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![36]; __reduce_map + std::collections::BTreeMap::new(); let reduce_rules = vec![20]; __reduce_map .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : Some(vec![36]), - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [36,]; let - shifted : & 'static [u8] = & [9,]; rules.iter().zip(shifted.iter()).map(| (& + __reduce_map.into_iter().collect() }, error_reduce : Some(vec![20]), + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [20,]; let + shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(20, 60),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [35,]; let shifted : & 'static [u8] = & [7,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(10, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [32, 33, 34, 35, 36,]; let shifted + : & 'static [u8] = & [1, 1, 1, 1, 1,]; rules.iter().zip(shifted.iter()).map(| + (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![35]; __reduce_map - .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : Some(vec![35]), - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [35,]; let - shifted : & 'static [u8] = & [8,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + vec![(19, ::rusty_lr_core::parser::state::ShiftTarget::new(11, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [32, 33, 34, 35, 36,]; let shifted + : & 'static [u8] = & [2, 2, 2, 2, 2,]; rules.iter().zip(shifted.iter()).map(| + (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(20, 62),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [32,]; let shifted : & 'static [u8] = & [7,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), (13, + ::rusty_lr_core::parser::state::ShiftTarget::new(8, true)), (14, + ::rusty_lr_core::parser::state::ShiftTarget::new(9, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(12, true)), (19, + ::rusty_lr_core::parser::state::ShiftTarget::new(13, true)), (21, + ::rusty_lr_core::parser::state::ShiftTarget::new(14, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::TerminalSet, + ::rusty_lr_core::parser::state::ShiftTarget::new(30, true)), + (GrammarNonTerminals::Pattern, + ::rusty_lr_core::parser::state::ShiftTarget::new(31, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 32, 33, 33, 34, 34, 35, 35, 36, 36,]; let shifted : & 'static + [u8] = & [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0, 3, 0, 3, 0, + 3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![32]; __reduce_map + std::collections::BTreeMap::new(); let reduce_rules = vec![30]; __reduce_map .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, error_reduce : Some(vec![32]), - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [32,]; let - shifted : & 'static [u8] = & [8,]; rules.iter().zip(shifted.iter()).map(| (& + __reduce_map.into_iter().collect() }, error_reduce : Some(vec![30]), + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [30,]; let + shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(6, 32), (7, 33), (8, 34), (10, 35), (11, 37), (12, 38),], error_shift : - None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![12]; __reduce_map.extend(__rustylr_tset11.iter().map(| term | (* term, + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), (13, + ::rusty_lr_core::parser::state::ShiftTarget::new(8, true)), (14, + ::rusty_lr_core::parser::state::ShiftTarget::new(9, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(12, true)), (19, + ::rusty_lr_core::parser::state::ShiftTarget::new(13, true)), (21, + ::rusty_lr_core::parser::state::ShiftTarget::new(14, true)),], error_shift : + Some(41), eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::TerminalSet, + ::rusty_lr_core::parser::state::ShiftTarget::new(30, true)), + (GrammarNonTerminals::Pattern, + ::rusty_lr_core::parser::state::ShiftTarget::new(43, true)), + (GrammarNonTerminals::_PatternPlus22, + ::rusty_lr_core::parser::state::ShiftTarget::new(44, true)), + (GrammarNonTerminals::_PatternStar23, + ::rusty_lr_core::parser::state::ShiftTarget::new(46, true)), + (GrammarNonTerminals::__PatternStar23SepPlus24, + ::rusty_lr_core::parser::state::ShiftTarget::new(47, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![96]; __reduce_map.extend(__rustylr_tset4.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : - None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [12, 22, - 23, 24, 25, 27, 31,]; let shifted : & 'static [u8] = & [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() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 65), (3, 66),], error_shift : None, eof_shift : None, - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [0, 3,]; let shifted : & 'static [u8] = & [4, 1,]; rules.iter() + None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 28, 29, 29, 30, 31, 32, 33, 34, 35, 36, 93, + 94, 95, 96, 97, 98,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![0]; __reduce_map - .extend(__rustylr_tset12.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : Some(vec![0]), ruleset : { let rules : & 'static [u8] = & [0,]; - let shifted : & 'static [u8] = & [5,]; rules.iter().zip(shifted.iter()).map(| - (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 5), (13, 8), (14, 9), (16, 12), (19, 13), (21, 14),], error_shift : - None, eof_shift : None, shift_goto_map_nonterm : - vec![(GrammarNonTerminals::RuleLine, 67), (GrammarNonTerminals::TokenMapped, - 68), (GrammarNonTerminals::TerminalSet, 30), (GrammarNonTerminals::Pattern, - 69), (GrammarNonTerminals::_TokenMappedPlus15, 70), - (GrammarNonTerminals::_TokenMappedStar16, 72),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![82]; __reduce_map.extend(__rustylr_tset1.iter().map(| term | (* term, + vec![(9, ::rusty_lr_core::parser::state::ShiftTarget::new(15, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::_caretQuestion19, + ::rusty_lr_core::parser::state::ShiftTarget::new(16, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![88]; __reduce_map.extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : - None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [3, 5, - 11, 12, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 79, 80, 81, 82,]; let shifted : & 'static [u8] = & [2, 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() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![3]; __reduce_map - .extend(__rustylr_tset13.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [3,]; let - shifted : & 'static [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [19, 87, + 88,]; let shifted : & 'static [u8] = & [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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![79]; __reduce_map - .extend(__rustylr_tset11.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [79,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(6, 32), (7, 33), (8, 34), (10, 35), (11, 37), (12, 38),], error_shift : - None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![11]; __reduce_map.extend(__rustylr_tset11.iter().map(| term | (* term, - reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : - None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [11, 22, - 23, 24, 25, 27, 31,]; let shifted : & 'static [u8] = & [1, 1, 1, 1, 1, 1, - 1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + std::collections::BTreeMap::new(); let reduce_rules = vec![87]; __reduce_map + .extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [87,]; let shifted : & 'static + [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 5), (13, 8), (14, 9), (16, 12), (19, 13), (21, 14),], error_shift : + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(17, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(21, true)),], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![(GrammarNonTerminals::TokenMapped, 71), - (GrammarNonTerminals::TerminalSet, 30), (GrammarNonTerminals::Pattern, 69),], + vec![(GrammarNonTerminals::TerminalSetItem, + ::rusty_lr_core::parser::state::ShiftTarget::new(25, true)), + (GrammarNonTerminals::_TerminalSetItemPlus20, + ::rusty_lr_core::parser::state::ShiftTarget::new(26, true)), + (GrammarNonTerminals::_TerminalSetItemStar21, + ::rusty_lr_core::parser::state::ShiftTarget::new(28, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![92]; __reduce_map.extend(__rustylr_tset6.iter().map(| term | (* term, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : + None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [13, 14, + 15, 16, 17, 18, 19, 89, 90, 91, 92,]; let shifted : & 'static [u8] = & [0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, + & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, + shifted : shifted as usize, } }).collect() } }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(10, ::rusty_lr_core::parser::state::ShiftTarget::new(18, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let - reduce_rules = vec![81]; __reduce_map.extend(__rustylr_tset1.iter().map(| + reduce_rules = vec![13]; __reduce_map.extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [11, 12, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 80, 81,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,]; rules.iter().zip(shifted - .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef - { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![80]; __reduce_map - .extend(__rustylr_tset11.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [80,]; let - shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(4, 73),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![(GrammarNonTerminals::PrecDef, 83), - (GrammarNonTerminals::_PrecDefPlus17, 84), - (GrammarNonTerminals::_PrecDefStar18, 86),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![86]; __reduce_map.extend(__rustylr_tset14.iter().map(| term | (* term, - reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : - None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [5, 6, 7, - 8, 9, 10, 83, 84, 85, 86,]; let shifted : & 'static [u8] = & [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() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(33, 74), (38, 79),], error_shift : Some(82), eof_shift : None, - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [6, 7, 8, 9, 10,]; let shifted : & 'static [u8] = & [1, 1, 1, 1, - 1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + [u8] = & [13, 14, 15,]; let shifted : & 'static [u8] = & [1, 1, 1,]; rules + .iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 75), (16, 76),], error_shift : Some(77), eof_shift : None, - shift_goto_map_nonterm : vec![(GrammarNonTerminals::IdentOrLiteral, 78),], + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(19, true)),], + error_shift : Some(20), eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [6, 7, 39, 40,]; let shifted : & - 'static [u8] = & [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() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![39]; __reduce_map - .extend(__rustylr_tset15.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [39,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![40]; __reduce_map - .extend(__rustylr_tset15.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [40,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + ruleset : { let rules : & 'static [u8] = & [14, 15,]; let shifted : & 'static + [u8] = & [2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) + | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![7]; __reduce_map - .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone()))); + std::collections::BTreeMap::new(); let reduce_rules = vec![14]; __reduce_map + .extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [7,]; let shifted : & 'static [u8] - = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ruleset : { let rules : & 'static [u8] = & [14,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![6]; __reduce_map - .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone()))); + std::collections::BTreeMap::new(); let reduce_rules = vec![15]; __reduce_map + .extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [6,]; let shifted : & 'static [u8] - = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ruleset : { let rules : & 'static [u8] = & [15,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(16, 80),], error_shift : Some(81), eof_shift : None, - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [8, 9,]; let shifted : & 'static [u8] = & [2, 2,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + vec![(10, ::rusty_lr_core::parser::state::ShiftTarget::new(22, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let + reduce_rules = vec![16]; __reduce_map.extend(__rustylr_tset5.iter().map(| + term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() + }, error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static + [u8] = & [16, 17, 18,]; let shifted : & 'static [u8] = & [1, 1, 1,]; rules + .iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![8]; __reduce_map - .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone()))); + vec![(16, ::rusty_lr_core::parser::state::ShiftTarget::new(23, true)),], + error_shift : Some(24), eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [8,]; let shifted : & 'static [u8] - = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + ruleset : { let rules : & 'static [u8] = & [17, 18,]; let shifted : & 'static + [u8] = & [2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) + | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![9]; __reduce_map - .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone()))); + std::collections::BTreeMap::new(); let reduce_rules = vec![17]; __reduce_map + .extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [9,]; let shifted : & 'static [u8] - = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ruleset : { let rules : & 'static [u8] = & [17,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![10]; __reduce_map - .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone()))); + std::collections::BTreeMap::new(); let reduce_rules = vec![18]; __reduce_map + .extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [10,]; let shifted : & 'static - [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ruleset : { let rules : & 'static [u8] = & [18,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![83]; __reduce_map - .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone()))); + std::collections::BTreeMap::new(); let reduce_rules = vec![89]; __reduce_map + .extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [83,]; let shifted : & 'static + ruleset : { let rules : & 'static [u8] = & [89,]; let shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(4, 73),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![(GrammarNonTerminals::PrecDef, 85),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![85]; __reduce_map.extend(__rustylr_tset14.iter().map(| term | (* term, + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(17, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(21, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::TerminalSetItem, + ::rusty_lr_core::parser::state::ShiftTarget::new(27, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![91]; __reduce_map.extend(__rustylr_tset6.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : - None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [6, 7, 8, - 9, 10, 84, 85,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 1, 1,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [13, 14, + 15, 16, 17, 18, 90, 91,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, + 1, 1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![84]; __reduce_map - .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone()))); + std::collections::BTreeMap::new(); let reduce_rules = vec![90]; __reduce_map + .extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [84,]; let shifted : & 'static + ruleset : { let rules : & 'static [u8] = & [90,]; let shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(18, 87),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![(GrammarNonTerminals::Action, 88),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![38]; __reduce_map.extend(__rustylr_tset13.iter().map(| term | (* term, - reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : - None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [5, 37, - 38,]; let shifted : & 'static [u8] = & [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() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![37]; __reduce_map - .extend(__rustylr_tset13.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [37,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + vec![(22, ::rusty_lr_core::parser::state::ShiftTarget::new(29, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [19,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![5]; __reduce_map - .extend(__rustylr_tset13.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [5,]; let - shifted : & 'static [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& + std::collections::BTreeMap::new(); let reduce_rules = vec![19]; __reduce_map + .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, error_reduce : Some(vec![19]), + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [19,]; let + shifted : & 'static [u8] = & [4,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![4]; __reduce_map - .extend(__rustylr_tset13.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [4,]; let + std::collections::BTreeMap::new(); let reduce_rules = vec![26]; __reduce_map + .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, error_reduce : Some(vec![26]), + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [26,]; let shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(23, 91), (24, 98), (25, 103), (26, 154), (27, 159), (28, 163), (29, - 167), (30, 171), (31, 175), (32, 179), (34, 183), (35, 188), (36, 192), (37, - 196), (39, 204), (40, 208),], error_shift : Some(212), eof_shift : None, - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, - 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,]; let - shifted : & 'static [u8] = & [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, 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() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 75), (16, 76),], error_shift : Some(92), eof_shift : None, - shift_goto_map_nonterm : vec![(GrammarNonTerminals::IdentOrLiteral, 94), - (GrammarNonTerminals::_IdentOrLiteralPlus28, 95),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); __reduce_map.into_iter() - .collect() }, error_reduce : None, eof_reduce : None, ruleset : { let rules : - & 'static [u8] = & [39, 40, 51, 52, 144, 145,]; let shifted : & 'static [u8] - = & [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() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 93),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [52,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + vec![(6, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), (7, + ::rusty_lr_core::parser::state::ShiftTarget::new(33, true)), (8, + ::rusty_lr_core::parser::state::ShiftTarget::new(34, true)), (10, + ::rusty_lr_core::parser::state::ShiftTarget::new(35, true)), (11, + ::rusty_lr_core::parser::state::ShiftTarget::new(37, true)), (12, + ::rusty_lr_core::parser::state::ShiftTarget::new(38, true)), (15, + ::rusty_lr_core::parser::state::ShiftTarget::new(40, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let + mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [22, 23, 24, 25, 27, 31, 32, 33, 34, 35, 36,]; + let shifted : & 'static [u8] = & [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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![52]; __reduce_map - .extend(__rustylr_tset12.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : Some(vec![52]), ruleset : { let rules : & 'static [u8] = & - [52,]; let shifted : & 'static [u8] = & [4,]; rules.iter().zip(shifted - .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef - { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, + std::collections::BTreeMap::new(); let reduce_rules = vec![22]; __reduce_map + .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, error_reduce : Some(vec![22]), + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [22,]; let + shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& + rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![144]; __reduce_map - .extend(__rustylr_tset16.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [144,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& + std::collections::BTreeMap::new(); let reduce_rules = vec![23]; __reduce_map + .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, error_reduce : Some(vec![23]), + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [23,]; let + shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 75), (2, 96), (16, 76),], error_shift : None, eof_shift : None, - shift_goto_map_nonterm : vec![(GrammarNonTerminals::IdentOrLiteral, 97),], - reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); - __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [39, 40, 51, 145,]; let shifted : - & 'static [u8] = & [0, 0, 3, 1,]; rules.iter().zip(shifted.iter()).map(| (& + vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : + vec![], reduce_map : { let mut __reduce_map = + std::collections::BTreeMap::new(); let reduce_rules = vec![24]; __reduce_map + .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, error_reduce : Some(vec![24]), + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [24,]; let + shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![51]; __reduce_map - .extend(__rustylr_tset12.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : Some(vec![51]), ruleset : { let rules : & 'static [u8] = & - [51,]; let shifted : & 'static [u8] = & [4,]; rules.iter().zip(shifted + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), (13, + ::rusty_lr_core::parser::state::ShiftTarget::new(8, true)), (14, + ::rusty_lr_core::parser::state::ShiftTarget::new(9, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(12, true)), (19, + ::rusty_lr_core::parser::state::ShiftTarget::new(13, true)), (21, + ::rusty_lr_core::parser::state::ShiftTarget::new(14, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::TerminalSet, + ::rusty_lr_core::parser::state::ShiftTarget::new(30, true)), + (GrammarNonTerminals::Pattern, + ::rusty_lr_core::parser::state::ShiftTarget::new(36, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 31, 32, 33, 34, 35, 36,]; let shifted : & 'static [u8] = & [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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(6, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), (7, + ::rusty_lr_core::parser::state::ShiftTarget::new(33, true)), (8, + ::rusty_lr_core::parser::state::ShiftTarget::new(34, true)), (11, + ::rusty_lr_core::parser::state::ShiftTarget::new(37, true)), (12, + ::rusty_lr_core::parser::state::ShiftTarget::new(38, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let + mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![31]; __reduce_map.extend(__rustylr_tset7.iter().map(| term | (* term, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : + Some(vec![31]), eof_reduce : None, ruleset : { let rules : & 'static [u8] = & + [22, 23, 24, 25, 27, 31,]; let shifted : & 'static [u8] = & [1, 1, 1, 1, 1, + 3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![145]; __reduce_map - .extend(__rustylr_tset16.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [145,]; let + std::collections::BTreeMap::new(); let reduce_rules = vec![25]; __reduce_map + .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, error_reduce : Some(vec![25]), + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [25,]; let shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 75), (16, 76),], error_shift : Some(99), eof_shift : None, - shift_goto_map_nonterm : vec![(GrammarNonTerminals::IdentOrLiteral, 94), - (GrammarNonTerminals::_IdentOrLiteralPlus28, 101),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); __reduce_map.into_iter() - .collect() }, error_reduce : None, eof_reduce : None, ruleset : { let rules : - & 'static [u8] = & [39, 40, 53, 54, 144, 145,]; let shifted : & 'static [u8] - = & [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() } }, + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), (13, + ::rusty_lr_core::parser::state::ShiftTarget::new(8, true)), (14, + ::rusty_lr_core::parser::state::ShiftTarget::new(9, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(12, true)), (19, + ::rusty_lr_core::parser::state::ShiftTarget::new(13, true)), (21, + ::rusty_lr_core::parser::state::ShiftTarget::new(14, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::TerminalSet, + ::rusty_lr_core::parser::state::ShiftTarget::new(30, true)), + (GrammarNonTerminals::Pattern, + ::rusty_lr_core::parser::state::ShiftTarget::new(39, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [19, 20, 21, 22, 23, 24, 25, 26, 27, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36,]; let shifted : & 'static [u8] = & [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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 100),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [54,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + vec![(6, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), (7, + ::rusty_lr_core::parser::state::ShiftTarget::new(33, true)), (8, + ::rusty_lr_core::parser::state::ShiftTarget::new(34, true)), (11, + ::rusty_lr_core::parser::state::ShiftTarget::new(37, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let + mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![27]; __reduce_map.extend(__rustylr_tset8.iter().map(| term | (* term, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : + Some(vec![27]), eof_reduce : None, ruleset : { let rules : & 'static [u8] = & + [22, 23, 24, 25, 27,]; let shifted : & 'static [u8] = & [1, 1, 1, 1, 3,]; + rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![54]; __reduce_map - .extend(__rustylr_tset12.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : Some(vec![54]), ruleset : { let rules : & 'static [u8] = & - [54,]; let shifted : & 'static [u8] = & [4,]; rules.iter().zip(shifted - .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef - { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), (13, + ::rusty_lr_core::parser::state::ShiftTarget::new(8, true)), (14, + ::rusty_lr_core::parser::state::ShiftTarget::new(9, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(12, true)), (19, + ::rusty_lr_core::parser::state::ShiftTarget::new(13, true)), (21, + ::rusty_lr_core::parser::state::ShiftTarget::new(14, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::TerminalSet, + ::rusty_lr_core::parser::state::ShiftTarget::new(30, true)), + (GrammarNonTerminals::Pattern, + ::rusty_lr_core::parser::state::ShiftTarget::new(51, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 32, 33, 33, 34, 34, 35, 35, 36, 36,]; let shifted : & 'static + [u8] = & [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 5, 0, 5, 0, 5, 0, + 5,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 75), (2, 102), (16, 76),], error_shift : None, eof_shift : None, - shift_goto_map_nonterm : vec![(GrammarNonTerminals::IdentOrLiteral, 97),], + vec![(20, ::rusty_lr_core::parser::state::ShiftTarget::new(42, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [39, 40, 53, 145,]; let shifted : - & 'static [u8] = & [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() } }, + ruleset : { let rules : & 'static [u8] = & [29,]; let shifted : & 'static + [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![53]; __reduce_map - .extend(__rustylr_tset12.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : Some(vec![53]), ruleset : { let rules : & 'static [u8] = & - [53,]; let shifted : & 'static [u8] = & [4,]; rules.iter().zip(shifted - .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef - { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, + std::collections::BTreeMap::new(); let reduce_rules = vec![29]; __reduce_map + .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, error_reduce : Some(vec![29]), + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [29,]; let + shifted : & 'static [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& + rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(6, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), (7, + ::rusty_lr_core::parser::state::ShiftTarget::new(33, true)), (8, + ::rusty_lr_core::parser::state::ShiftTarget::new(34, true)), (10, + ::rusty_lr_core::parser::state::ShiftTarget::new(35, true)), (11, + ::rusty_lr_core::parser::state::ShiftTarget::new(37, true)), (12, + ::rusty_lr_core::parser::state::ShiftTarget::new(38, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let + mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![93]; __reduce_map.extend(__rustylr_tset9.iter().map(| term | (* term, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : + None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [22, 23, + 24, 25, 27, 31, 93,]; let shifted : & 'static [u8] = & [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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 104),], error_shift : Some(152), eof_shift : None, - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [42, 43, 44,]; let shifted : & 'static [u8] = & [2, 2, 2,]; rules - .iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), (13, + ::rusty_lr_core::parser::state::ShiftTarget::new(8, true)), (14, + ::rusty_lr_core::parser::state::ShiftTarget::new(9, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(12, true)), (19, + ::rusty_lr_core::parser::state::ShiftTarget::new(13, true)), (21, + ::rusty_lr_core::parser::state::ShiftTarget::new(14, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::TerminalSet, + ::rusty_lr_core::parser::state::ShiftTarget::new(30, true)), + (GrammarNonTerminals::Pattern, + ::rusty_lr_core::parser::state::ShiftTarget::new(45, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![95]; __reduce_map.extend(__rustylr_tset4.iter().map(| term | (* term, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : + None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 94, 95,]; let + shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 105), (1, 106), (2, 107), (3, 108), (4, 109), (5, 110), (6, 111), - (7, 112), (8, 113), (9, 114), (10, 115), (11, 116), (12, 117), (13, 118), - (14, 119), (15, 120), (16, 121), (17, 122), (18, 123), (19, 124), (20, 125), - (21, 126), (22, 127), (23, 128), (24, 129), (25, 130), (26, 131), (27, 132), - (28, 133), (29, 134), (30, 135), (31, 136), (32, 137), (33, 138), (34, 139), - (35, 140), (36, 141), (37, 142), (38, 143), (39, 144), (40, 145), (41, - 146),], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![(GrammarNonTerminals::RustCode, 147), (GrammarNonTerminals::_TermSet26, - 149), (GrammarNonTerminals::__TermSet26Plus27, 150),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); __reduce_map.into_iter() - .collect() }, error_reduce : None, eof_reduce : None, ruleset : { let rules : - & 'static [u8] = & [41, 42, 43, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143,]; let shifted : & 'static [u8] = & [0, 3, 3, 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, 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() } }, + vec![(6, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), (7, + ::rusty_lr_core::parser::state::ShiftTarget::new(33, true)), (8, + ::rusty_lr_core::parser::state::ShiftTarget::new(34, true)), (10, + ::rusty_lr_core::parser::state::ShiftTarget::new(35, true)), (11, + ::rusty_lr_core::parser::state::ShiftTarget::new(37, true)), (12, + ::rusty_lr_core::parser::state::ShiftTarget::new(38, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let + mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![94]; __reduce_map.extend(__rustylr_tset9.iter().map(| term | (* term, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : + None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [22, 23, + 24, 25, 27, 31, 94,]; let shifted : & 'static [u8] = & [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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![101]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [101,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + std::collections::BTreeMap::new(); let reduce_rules = vec![97]; __reduce_map + .extend(__rustylr_tset4.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [97,]; let shifted : & 'static + [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![102]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [102,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + vec![(3, ::rusty_lr_core::parser::state::ShiftTarget::new(48, true)), (20, + ::rusty_lr_core::parser::state::ShiftTarget::new(50, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let + mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [28, 98,]; let shifted : & 'static [u8] = & + [2, 1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![43]; __reduce_map - .extend(__rustylr_tset12.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : Some(vec![43]), ruleset : { let rules : & 'static [u8] = & - [43,]; let shifted : & 'static [u8] = & [4,]; rules.iter().zip(shifted - .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef - { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), (13, + ::rusty_lr_core::parser::state::ShiftTarget::new(8, true)), (14, + ::rusty_lr_core::parser::state::ShiftTarget::new(9, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(12, true)), (19, + ::rusty_lr_core::parser::state::ShiftTarget::new(13, true)), (21, + ::rusty_lr_core::parser::state::ShiftTarget::new(14, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::TerminalSet, + ::rusty_lr_core::parser::state::ShiftTarget::new(30, true)), + (GrammarNonTerminals::Pattern, + ::rusty_lr_core::parser::state::ShiftTarget::new(43, true)), + (GrammarNonTerminals::_PatternPlus22, + ::rusty_lr_core::parser::state::ShiftTarget::new(44, true)), + (GrammarNonTerminals::_PatternStar23, + ::rusty_lr_core::parser::state::ShiftTarget::new(49, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![96]; __reduce_map.extend(__rustylr_tset4.iter().map(| term | (* term, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : + None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 93, 94, 95, + 96, 98,]; let shifted : & 'static [u8] = & [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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![103]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [103,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + std::collections::BTreeMap::new(); let reduce_rules = vec![98]; __reduce_map + .extend(__rustylr_tset4.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [98,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![104]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [104,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& + std::collections::BTreeMap::new(); let reduce_rules = vec![28]; __reduce_map + .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, error_reduce : Some(vec![28]), + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [28,]; let + shifted : & 'static [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![105]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [105,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + vec![(6, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), (7, + ::rusty_lr_core::parser::state::ShiftTarget::new(33, true)), (8, + ::rusty_lr_core::parser::state::ShiftTarget::new(34, true)), (10, + ::rusty_lr_core::parser::state::ShiftTarget::new(35, true)), (11, + ::rusty_lr_core::parser::state::ShiftTarget::new(37, true)), (12, + ::rusty_lr_core::parser::state::ShiftTarget::new(38, true)), (15, + ::rusty_lr_core::parser::state::ShiftTarget::new(52, true)),], error_shift : + Some(59), eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::_commaQuestion25, + ::rusty_lr_core::parser::state::ShiftTarget::new(61, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![100]; __reduce_map.extend(__rustylr_tset10.iter().map(| term | (* term, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : + None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [22, 23, + 24, 25, 27, 31, 32, 33, 34, 35, 36, 99, 100,]; let shifted : & 'static [u8] = + & [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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![106]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [106,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + vec![(6, ::rusty_lr_core::parser::state::ShiftTarget::new(53, true)), (7, + ::rusty_lr_core::parser::state::ShiftTarget::new(55, true)),], error_shift : + Some(57), eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![99]; __reduce_map.extend(__rustylr_tset10.iter().map(| term | (* term, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : + None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [33, 34, + 36, 99,]; let shifted : & 'static [u8] = & [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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![107]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [107,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + vec![(20, ::rusty_lr_core::parser::state::ShiftTarget::new(54, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [33,]; let shifted : & 'static + [u8] = & [8,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![108]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [108,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& + std::collections::BTreeMap::new(); let reduce_rules = vec![33]; __reduce_map + .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, error_reduce : Some(vec![33]), + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [33,]; let + shifted : & 'static [u8] = & [9,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![109]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [109,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + vec![(20, ::rusty_lr_core::parser::state::ShiftTarget::new(56, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [34,]; let shifted : & 'static + [u8] = & [8,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![110]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [110,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& + std::collections::BTreeMap::new(); let reduce_rules = vec![34]; __reduce_map + .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, error_reduce : Some(vec![34]), + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [34,]; let + shifted : & 'static [u8] = & [9,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![111]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [111,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + vec![(20, ::rusty_lr_core::parser::state::ShiftTarget::new(58, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [36,]; let shifted : & 'static + [u8] = & [8,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![112]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [112,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& + std::collections::BTreeMap::new(); let reduce_rules = vec![36]; __reduce_map + .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, error_reduce : Some(vec![36]), + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [36,]; let + shifted : & 'static [u8] = & [9,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![113]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [113,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + vec![(20, ::rusty_lr_core::parser::state::ShiftTarget::new(60, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [35,]; let shifted : & 'static + [u8] = & [7,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![114]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [114,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& + std::collections::BTreeMap::new(); let reduce_rules = vec![35]; __reduce_map + .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, error_reduce : Some(vec![35]), + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [35,]; let + shifted : & 'static [u8] = & [8,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![115]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [115,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + vec![(20, ::rusty_lr_core::parser::state::ShiftTarget::new(62, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [32,]; let shifted : & 'static + [u8] = & [7,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![116]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [116,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& + std::collections::BTreeMap::new(); let reduce_rules = vec![32]; __reduce_map + .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, error_reduce : Some(vec![32]), + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [32,]; let + shifted : & 'static [u8] = & [8,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![117]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [117,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + vec![(6, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), (7, + ::rusty_lr_core::parser::state::ShiftTarget::new(33, true)), (8, + ::rusty_lr_core::parser::state::ShiftTarget::new(34, true)), (10, + ::rusty_lr_core::parser::state::ShiftTarget::new(35, true)), (11, + ::rusty_lr_core::parser::state::ShiftTarget::new(37, true)), (12, + ::rusty_lr_core::parser::state::ShiftTarget::new(38, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let + mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![12]; __reduce_map.extend(__rustylr_tset11.iter().map(| term | (* term, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : + None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [12, 22, + 23, 24, 25, 27, 31,]; let shifted : & 'static [u8] = & [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() } }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(65, true)), (3, + ::rusty_lr_core::parser::state::ShiftTarget::new(66, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let + mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [0, 3,]; let shifted : & 'static [u8] = & [4, + 1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![118]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules + std::collections::BTreeMap::new(); let reduce_rules = vec![0]; __reduce_map + .extend(__rustylr_tset12.iter().map(| term | (* term, reduce_rules .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [118,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + eof_reduce : Some(vec![0]), ruleset : { let rules : & 'static [u8] = & [0,]; + let shifted : & 'static [u8] = & [5,]; rules.iter().zip(shifted.iter()).map(| + (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() } }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(5, true)), (13, + ::rusty_lr_core::parser::state::ShiftTarget::new(8, true)), (14, + ::rusty_lr_core::parser::state::ShiftTarget::new(9, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(12, true)), (19, + ::rusty_lr_core::parser::state::ShiftTarget::new(13, true)), (21, + ::rusty_lr_core::parser::state::ShiftTarget::new(14, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::RuleLine, + ::rusty_lr_core::parser::state::ShiftTarget::new(67, true)), + (GrammarNonTerminals::TokenMapped, + ::rusty_lr_core::parser::state::ShiftTarget::new(68, true)), + (GrammarNonTerminals::TerminalSet, + ::rusty_lr_core::parser::state::ShiftTarget::new(30, true)), + (GrammarNonTerminals::Pattern, + ::rusty_lr_core::parser::state::ShiftTarget::new(69, true)), + (GrammarNonTerminals::_TokenMappedPlus15, + ::rusty_lr_core::parser::state::ShiftTarget::new(70, true)), + (GrammarNonTerminals::_TokenMappedStar16, + ::rusty_lr_core::parser::state::ShiftTarget::new(72, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![82]; __reduce_map.extend(__rustylr_tset1.iter().map(| term | (* term, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : + None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [3, 5, + 11, 12, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 79, 80, 81, 82,]; let shifted : & 'static [u8] = & [2, 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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![119]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules + std::collections::BTreeMap::new(); let reduce_rules = vec![3]; __reduce_map + .extend(__rustylr_tset13.iter().map(| term | (* term, reduce_rules .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [119,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [3,]; let + shifted : & 'static [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![120]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules + std::collections::BTreeMap::new(); let reduce_rules = vec![79]; __reduce_map + .extend(__rustylr_tset11.iter().map(| term | (* term, reduce_rules .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [120,]; let + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [79,]; let shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![121]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [121,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& + vec![(6, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), (7, + ::rusty_lr_core::parser::state::ShiftTarget::new(33, true)), (8, + ::rusty_lr_core::parser::state::ShiftTarget::new(34, true)), (10, + ::rusty_lr_core::parser::state::ShiftTarget::new(35, true)), (11, + ::rusty_lr_core::parser::state::ShiftTarget::new(37, true)), (12, + ::rusty_lr_core::parser::state::ShiftTarget::new(38, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let + mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![11]; __reduce_map.extend(__rustylr_tset11.iter().map(| term | (* term, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : + None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [11, 22, + 23, 24, 25, 27, 31,]; let shifted : & 'static [u8] = & [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() } }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(5, true)), (13, + ::rusty_lr_core::parser::state::ShiftTarget::new(8, true)), (14, + ::rusty_lr_core::parser::state::ShiftTarget::new(9, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(12, true)), (19, + ::rusty_lr_core::parser::state::ShiftTarget::new(13, true)), (21, + ::rusty_lr_core::parser::state::ShiftTarget::new(14, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::TokenMapped, + ::rusty_lr_core::parser::state::ShiftTarget::new(71, true)), + (GrammarNonTerminals::TerminalSet, + ::rusty_lr_core::parser::state::ShiftTarget::new(30, true)), + (GrammarNonTerminals::Pattern, + ::rusty_lr_core::parser::state::ShiftTarget::new(69, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![81]; __reduce_map.extend(__rustylr_tset1.iter().map(| term | (* term, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : + None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [11, 12, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 80, + 81,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![122]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules + std::collections::BTreeMap::new(); let reduce_rules = vec![80]; __reduce_map + .extend(__rustylr_tset11.iter().map(| term | (* term, reduce_rules .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [122,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [80,]; let + shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(4, ::rusty_lr_core::parser::state::ShiftTarget::new(73, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::PrecDef, + ::rusty_lr_core::parser::state::ShiftTarget::new(83, true)), + (GrammarNonTerminals::_PrecDefPlus17, + ::rusty_lr_core::parser::state::ShiftTarget::new(84, true)), + (GrammarNonTerminals::_PrecDefStar18, + ::rusty_lr_core::parser::state::ShiftTarget::new(86, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![86]; __reduce_map.extend(__rustylr_tset14.iter().map(| term | (* term, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : + None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [5, 6, 7, + 8, 9, 10, 83, 84, 85, 86,]; let shifted : & 'static [u8] = & [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() } }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(33, ::rusty_lr_core::parser::state::ShiftTarget::new(74, true)), (38, + ::rusty_lr_core::parser::state::ShiftTarget::new(79, true)),], error_shift : + Some(82), eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [6, 7, 8, 9, 10,]; let shifted : & 'static + [u8] = & [1, 1, 1, 1, 1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & + shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, + shifted : shifted as usize, } }).collect() } }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(76, true)),], error_shift : + Some(77), eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::IdentOrLiteral, + ::rusty_lr_core::parser::state::ShiftTarget::new(78, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [6, 7, 39, 40,]; let shifted : & 'static [u8] + = & [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() } }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![123]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules + std::collections::BTreeMap::new(); let reduce_rules = vec![39]; __reduce_map + .extend(__rustylr_tset15.iter().map(| term | (* term, reduce_rules .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [123,]; let + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [39,]; let shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![124]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules + std::collections::BTreeMap::new(); let reduce_rules = vec![40]; __reduce_map + .extend(__rustylr_tset15.iter().map(| term | (* term, reduce_rules .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [124,]; let + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [40,]; let shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![125]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [125,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + std::collections::BTreeMap::new(); let reduce_rules = vec![7]; __reduce_map + .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [7,]; let shifted : & 'static [u8] + = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![126]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [126,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + std::collections::BTreeMap::new(); let reduce_rules = vec![6]; __reduce_map + .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [6,]; let shifted : & 'static [u8] + = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(16, ::rusty_lr_core::parser::state::ShiftTarget::new(80, true)),], + error_shift : Some(81), eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [8, 9,]; let shifted : & 'static + [u8] = & [2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) + | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![127]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [127,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + std::collections::BTreeMap::new(); let reduce_rules = vec![8]; __reduce_map + .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [8,]; let shifted : & 'static [u8] + = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![128]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [128,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + std::collections::BTreeMap::new(); let reduce_rules = vec![9]; __reduce_map + .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [9,]; let shifted : & 'static [u8] + = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![129]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [129,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + std::collections::BTreeMap::new(); let reduce_rules = vec![10]; __reduce_map + .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [10,]; let shifted : & 'static + [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![130]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [130,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + std::collections::BTreeMap::new(); let reduce_rules = vec![83]; __reduce_map + .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [83,]; let shifted : & 'static + [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(4, ::rusty_lr_core::parser::state::ShiftTarget::new(73, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::PrecDef, + ::rusty_lr_core::parser::state::ShiftTarget::new(85, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![85]; __reduce_map.extend(__rustylr_tset14.iter().map(| term | (* term, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : + None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [6, 7, 8, + 9, 10, 84, 85,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 1, 1,]; + rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![131]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [131,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + std::collections::BTreeMap::new(); let reduce_rules = vec![84]; __reduce_map + .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [84,]; let shifted : & 'static + [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(18, ::rusty_lr_core::parser::state::ShiftTarget::new(87, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::Action, + ::rusty_lr_core::parser::state::ShiftTarget::new(88, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![38]; __reduce_map.extend(__rustylr_tset13.iter().map(| term | (* term, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : + None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [5, 37, + 38,]; let shifted : & 'static [u8] = & [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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![132]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules + std::collections::BTreeMap::new(); let reduce_rules = vec![37]; __reduce_map + .extend(__rustylr_tset13.iter().map(| term | (* term, reduce_rules .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [132,]; let + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [37,]; let shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![133]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules + std::collections::BTreeMap::new(); let reduce_rules = vec![5]; __reduce_map + .extend(__rustylr_tset13.iter().map(| term | (* term, reduce_rules .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [133,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [5,]; let + shifted : & 'static [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![134]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules + std::collections::BTreeMap::new(); let reduce_rules = vec![4]; __reduce_map + .extend(__rustylr_tset13.iter().map(| term | (* term, reduce_rules .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [134,]; let + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [4,]; let shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(23, ::rusty_lr_core::parser::state::ShiftTarget::new(91, true)), (24, + ::rusty_lr_core::parser::state::ShiftTarget::new(98, true)), (25, + ::rusty_lr_core::parser::state::ShiftTarget::new(103, true)), (26, + ::rusty_lr_core::parser::state::ShiftTarget::new(113, true)), (27, + ::rusty_lr_core::parser::state::ShiftTarget::new(118, true)), (28, + ::rusty_lr_core::parser::state::ShiftTarget::new(122, true)), (29, + ::rusty_lr_core::parser::state::ShiftTarget::new(126, true)), (30, + ::rusty_lr_core::parser::state::ShiftTarget::new(130, true)), (31, + ::rusty_lr_core::parser::state::ShiftTarget::new(134, true)), (32, + ::rusty_lr_core::parser::state::ShiftTarget::new(138, true)), (34, + ::rusty_lr_core::parser::state::ShiftTarget::new(142, true)), (35, + ::rusty_lr_core::parser::state::ShiftTarget::new(147, true)), (36, + ::rusty_lr_core::parser::state::ShiftTarget::new(151, true)), (37, + ::rusty_lr_core::parser::state::ShiftTarget::new(155, true)), (39, + ::rusty_lr_core::parser::state::ShiftTarget::new(163, true)), (40, + ::rusty_lr_core::parser::state::ShiftTarget::new(167, true)),], error_shift : + Some(171), eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75,]; let shifted : & 'static [u8] = & [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, 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() } }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(76, true)),], error_shift : + Some(92), eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::IdentOrLiteral, + ::rusty_lr_core::parser::state::ShiftTarget::new(94, true)), + (GrammarNonTerminals::_IdentOrLiteralPlus28, + ::rusty_lr_core::parser::state::ShiftTarget::new(95, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [39, 40, 51, 52, 144, 145,]; let shifted : & + 'static [u8] = & [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() } }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(93, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [52,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![135]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules + std::collections::BTreeMap::new(); let reduce_rules = vec![52]; __reduce_map + .extend(__rustylr_tset12.iter().map(| term | (* term, reduce_rules .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [135,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + eof_reduce : Some(vec![52]), ruleset : { let rules : & 'static [u8] = & + [52,]; let shifted : & 'static [u8] = & [4,]; rules.iter().zip(shifted + .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef + { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![136]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules + std::collections::BTreeMap::new(); let reduce_rules = vec![144]; __reduce_map + .extend(__rustylr_tset16.iter().map(| term | (* term, reduce_rules .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [136,]; let + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [144,]; let shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)), (2, + ::rusty_lr_core::parser::state::ShiftTarget::new(96, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(76, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::IdentOrLiteral, + ::rusty_lr_core::parser::state::ShiftTarget::new(97, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [39, 40, 51, 145,]; let shifted : & 'static + [u8] = & [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() } }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![137]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules + std::collections::BTreeMap::new(); let reduce_rules = vec![51]; __reduce_map + .extend(__rustylr_tset12.iter().map(| term | (* term, reduce_rules .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [137,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + eof_reduce : Some(vec![51]), ruleset : { let rules : & 'static [u8] = & + [51,]; let shifted : & 'static [u8] = & [4,]; rules.iter().zip(shifted + .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef + { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![138]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules + std::collections::BTreeMap::new(); let reduce_rules = vec![145]; __reduce_map + .extend(__rustylr_tset16.iter().map(| term | (* term, reduce_rules .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [138,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& + eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [145,]; let + shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(76, true)),], error_shift : + Some(99), eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::IdentOrLiteral, + ::rusty_lr_core::parser::state::ShiftTarget::new(94, true)), + (GrammarNonTerminals::_IdentOrLiteralPlus28, + ::rusty_lr_core::parser::state::ShiftTarget::new(101, true)),], reduce_map : + { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [39, 40, 53, 54, 144, 145,]; let shifted : & + 'static [u8] = & [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() } }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(100, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [54,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![139]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules + std::collections::BTreeMap::new(); let reduce_rules = vec![54]; __reduce_map + .extend(__rustylr_tset12.iter().map(| term | (* term, reduce_rules .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [139,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + eof_reduce : Some(vec![54]), ruleset : { let rules : & 'static [u8] = & + [54,]; let shifted : & 'static [u8] = & [4,]; rules.iter().zip(shifted + .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef + { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)), (2, + ::rusty_lr_core::parser::state::ShiftTarget::new(102, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(76, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::IdentOrLiteral, + ::rusty_lr_core::parser::state::ShiftTarget::new(97, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [39, 40, 53, 145,]; let shifted : & 'static + [u8] = & [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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![140]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules + std::collections::BTreeMap::new(); let reduce_rules = vec![53]; __reduce_map + .extend(__rustylr_tset12.iter().map(| term | (* term, reduce_rules .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [140,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + eof_reduce : Some(vec![53]), ruleset : { let rules : & 'static [u8] = & + [53,]; let shifted : & 'static [u8] = & [4,]; rules.iter().zip(shifted + .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef + { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(104, true)),], + error_shift : Some(111), eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [42, 43, 44,]; let shifted : & + 'static [u8] = & [2, 2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, + & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, + shifted : shifted as usize, } }).collect() } }, + ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (1, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (2, + ::rusty_lr_core::parser::state::ShiftTarget::new(105, true)), (3, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (4, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (5, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (6, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (7, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (8, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (9, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (10, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (11, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (12, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (13, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (14, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (15, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (17, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (18, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (19, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (20, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (21, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (22, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (23, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (24, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (25, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (26, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (27, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (28, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (29, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (30, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (31, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (32, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (33, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (34, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (35, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (36, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (37, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (38, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (39, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (40, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (41, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::RustCode, + ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), + (GrammarNonTerminals::_TermSet26, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), + (GrammarNonTerminals::__TermSet26Plus27, + ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], reduce_map : + { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [41, 42, 43, 101, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, + 137, 138, 139, 140, 141, 142, 143,]; let shifted : & 'static [u8] = & [0, 3, + 3, 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, 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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![141]; __reduce_map - .extend(__rustylr_tset17.iter().map(| term | (* term, reduce_rules + std::collections::BTreeMap::new(); let reduce_rules = vec![43]; __reduce_map + .extend(__rustylr_tset12.iter().map(| term | (* term, reduce_rules .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [141,]; let - shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + eof_reduce : Some(vec![43]), ruleset : { let rules : & 'static [u8] = & + [43,]; let shifted : & 'static [u8] = & [4,]; rules.iter().zip(shifted + .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef + { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 148),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [42,]; let shifted : & 'static [u8] = & [4,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(107, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [42,]; let shifted : & 'static + [u8] = & [4,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8568,16 +8005,52 @@ impl GrammarParser { rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 105), (1, 106), (3, 108), (4, 109), (5, 110), (6, 111), (7, 112), - (8, 113), (9, 114), (10, 115), (11, 116), (12, 117), (13, 118), (14, 119), - (15, 120), (16, 121), (17, 122), (18, 123), (19, 124), (20, 125), (21, 126), - (22, 127), (23, 128), (24, 129), (25, 130), (26, 131), (27, 132), (28, 133), - (29, 134), (30, 135), (31, 136), (32, 137), (33, 138), (34, 139), (35, 140), - (36, 141), (37, 142), (38, 143), (39, 144), (40, 145), (41, 146),], - error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![(GrammarNonTerminals::_TermSet26, 151),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![41]; __reduce_map.extend(__rustylr_tset18.iter().map(| term | (* term, + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (1, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (3, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (4, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (5, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (6, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (7, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (8, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (9, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (10, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (11, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (12, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (13, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (14, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (15, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (17, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (18, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (19, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (20, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (21, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (22, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (23, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (24, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (25, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (26, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (27, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (28, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (29, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (30, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (31, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (32, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (33, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (34, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (35, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (36, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (37, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (38, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (39, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (40, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)), (41, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::_TermSet26, + ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)),], reduce_map : + { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules + = vec![41]; __reduce_map.extend(__rustylr_tset18.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [41, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, @@ -8599,12 +8072,12 @@ impl GrammarParser { rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 153),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [44,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(112, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [44,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8618,21 +8091,21 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 155),], error_shift : Some(157), eof_shift : None, - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [45, 46,]; let shifted : & 'static [u8] = & [2, 2,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(114, true)),], + error_shift : Some(116), eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [45, 46,]; let shifted : & 'static + [u8] = & [2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) + | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 156),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [45,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(115, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [45,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8646,12 +8119,12 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 158),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [46,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(117, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [46,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8665,25 +8138,66 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 105), (1, 106), (2, 160), (3, 108), (4, 109), (5, 110), (6, 111), - (7, 112), (8, 113), (9, 114), (10, 115), (11, 116), (12, 117), (13, 118), - (14, 119), (15, 120), (16, 121), (17, 122), (18, 123), (19, 124), (20, 125), - (21, 126), (22, 127), (23, 128), (24, 129), (25, 130), (26, 131), (27, 132), - (28, 133), (29, 134), (30, 135), (31, 136), (32, 137), (33, 138), (34, 139), - (35, 140), (36, 141), (37, 142), (38, 143), (39, 144), (40, 145), (41, - 146),], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![(GrammarNonTerminals::RustCode, 161), (GrammarNonTerminals::_TermSet26, - 149), (GrammarNonTerminals::__TermSet26Plus27, 150),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); __reduce_map.into_iter() - .collect() }, error_reduce : None, eof_reduce : None, ruleset : { let rules : - & 'static [u8] = & [41, 47, 48, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143,]; let shifted : & 'static [u8] = & [0, 2, 2, 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, 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() } }, + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (1, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (2, + ::rusty_lr_core::parser::state::ShiftTarget::new(119, true)), (3, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (4, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (5, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (6, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (7, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (8, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (9, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (10, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (11, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (12, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (13, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (14, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (15, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (17, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (18, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (19, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (20, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (21, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (22, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (23, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (24, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (25, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (26, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (27, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (28, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (29, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (30, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (31, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (32, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (33, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (34, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (35, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (36, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (37, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (38, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (39, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (40, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (41, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::RustCode, + ::rusty_lr_core::parser::state::ShiftTarget::new(120, true)), + (GrammarNonTerminals::_TermSet26, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), + (GrammarNonTerminals::__TermSet26Plus27, + ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], reduce_map : + { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [41, 47, 48, 101, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, + 137, 138, 139, 140, 141, 142, 143,]; let shifted : & 'static [u8] = & [0, 2, + 2, 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, 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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = @@ -8695,12 +8209,12 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 162),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [47,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(121, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [47,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8714,25 +8228,66 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 105), (1, 106), (2, 164), (3, 108), (4, 109), (5, 110), (6, 111), - (7, 112), (8, 113), (9, 114), (10, 115), (11, 116), (12, 117), (13, 118), - (14, 119), (15, 120), (16, 121), (17, 122), (18, 123), (19, 124), (20, 125), - (21, 126), (22, 127), (23, 128), (24, 129), (25, 130), (26, 131), (27, 132), - (28, 133), (29, 134), (30, 135), (31, 136), (32, 137), (33, 138), (34, 139), - (35, 140), (36, 141), (37, 142), (38, 143), (39, 144), (40, 145), (41, - 146),], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![(GrammarNonTerminals::RustCode, 165), (GrammarNonTerminals::_TermSet26, - 149), (GrammarNonTerminals::__TermSet26Plus27, 150),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); __reduce_map.into_iter() - .collect() }, error_reduce : None, eof_reduce : None, ruleset : { let rules : - & 'static [u8] = & [41, 49, 50, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143,]; let shifted : & 'static [u8] = & [0, 2, 2, 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, 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() } }, + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (1, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (2, + ::rusty_lr_core::parser::state::ShiftTarget::new(123, true)), (3, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (4, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (5, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (6, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (7, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (8, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (9, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (10, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (11, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (12, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (13, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (14, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (15, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (17, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (18, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (19, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (20, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (21, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (22, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (23, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (24, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (25, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (26, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (27, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (28, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (29, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (30, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (31, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (32, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (33, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (34, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (35, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (36, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (37, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (38, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (39, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (40, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (41, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::RustCode, + ::rusty_lr_core::parser::state::ShiftTarget::new(124, true)), + (GrammarNonTerminals::_TermSet26, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), + (GrammarNonTerminals::__TermSet26Plus27, + ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], reduce_map : + { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [41, 49, 50, 101, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, + 137, 138, 139, 140, 141, 142, 143,]; let shifted : & 'static [u8] = & [0, 2, + 2, 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, 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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = @@ -8744,12 +8299,12 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 166),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [49,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(125, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [49,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8763,25 +8318,66 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 105), (1, 106), (2, 168), (3, 108), (4, 109), (5, 110), (6, 111), - (7, 112), (8, 113), (9, 114), (10, 115), (11, 116), (12, 117), (13, 118), - (14, 119), (15, 120), (16, 121), (17, 122), (18, 123), (19, 124), (20, 125), - (21, 126), (22, 127), (23, 128), (24, 129), (25, 130), (26, 131), (27, 132), - (28, 133), (29, 134), (30, 135), (31, 136), (32, 137), (33, 138), (34, 139), - (35, 140), (36, 141), (37, 142), (38, 143), (39, 144), (40, 145), (41, - 146),], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![(GrammarNonTerminals::RustCode, 169), (GrammarNonTerminals::_TermSet26, - 149), (GrammarNonTerminals::__TermSet26Plus27, 150),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); __reduce_map.into_iter() - .collect() }, error_reduce : None, eof_reduce : None, ruleset : { let rules : - & 'static [u8] = & [41, 57, 58, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143,]; let shifted : & 'static [u8] = & [0, 2, 2, 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, 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() } }, + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (1, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (2, + ::rusty_lr_core::parser::state::ShiftTarget::new(127, true)), (3, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (4, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (5, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (6, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (7, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (8, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (9, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (10, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (11, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (12, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (13, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (14, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (15, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (17, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (18, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (19, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (20, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (21, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (22, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (23, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (24, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (25, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (26, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (27, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (28, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (29, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (30, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (31, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (32, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (33, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (34, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (35, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (36, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (37, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (38, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (39, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (40, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (41, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::RustCode, + ::rusty_lr_core::parser::state::ShiftTarget::new(128, true)), + (GrammarNonTerminals::_TermSet26, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), + (GrammarNonTerminals::__TermSet26Plus27, + ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], reduce_map : + { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [41, 57, 58, 101, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, + 137, 138, 139, 140, 141, 142, 143,]; let shifted : & 'static [u8] = & [0, 2, + 2, 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, 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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = @@ -8793,12 +8389,12 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 170),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [57,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(129, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [57,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8812,25 +8408,66 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 105), (1, 106), (2, 172), (3, 108), (4, 109), (5, 110), (6, 111), - (7, 112), (8, 113), (9, 114), (10, 115), (11, 116), (12, 117), (13, 118), - (14, 119), (15, 120), (16, 121), (17, 122), (18, 123), (19, 124), (20, 125), - (21, 126), (22, 127), (23, 128), (24, 129), (25, 130), (26, 131), (27, 132), - (28, 133), (29, 134), (30, 135), (31, 136), (32, 137), (33, 138), (34, 139), - (35, 140), (36, 141), (37, 142), (38, 143), (39, 144), (40, 145), (41, - 146),], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![(GrammarNonTerminals::RustCode, 173), (GrammarNonTerminals::_TermSet26, - 149), (GrammarNonTerminals::__TermSet26Plus27, 150),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); __reduce_map.into_iter() - .collect() }, error_reduce : None, eof_reduce : None, ruleset : { let rules : - & 'static [u8] = & [41, 59, 60, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143,]; let shifted : & 'static [u8] = & [0, 2, 2, 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, 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() } }, + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (1, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (2, + ::rusty_lr_core::parser::state::ShiftTarget::new(131, true)), (3, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (4, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (5, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (6, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (7, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (8, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (9, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (10, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (11, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (12, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (13, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (14, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (15, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (17, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (18, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (19, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (20, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (21, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (22, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (23, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (24, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (25, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (26, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (27, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (28, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (29, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (30, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (31, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (32, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (33, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (34, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (35, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (36, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (37, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (38, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (39, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (40, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (41, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::RustCode, + ::rusty_lr_core::parser::state::ShiftTarget::new(132, true)), + (GrammarNonTerminals::_TermSet26, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), + (GrammarNonTerminals::__TermSet26Plus27, + ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], reduce_map : + { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [41, 59, 60, 101, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, + 137, 138, 139, 140, 141, 142, 143,]; let shifted : & 'static [u8] = & [0, 2, + 2, 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, 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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = @@ -8842,12 +8479,12 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 174),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [59,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(133, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [59,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8861,13 +8498,13 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 176),], error_shift : Some(177), eof_shift : None, - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [63, 64,]; let shifted : & 'static [u8] = & [2, 2,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(135, true)),], + error_shift : Some(136), eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [63, 64,]; let shifted : & 'static + [u8] = & [2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) + | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : @@ -8880,12 +8517,12 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 178),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [64,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(137, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [64,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8899,13 +8536,13 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 180),], error_shift : Some(181), eof_shift : None, - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [61, 62,]; let shifted : & 'static [u8] = & [2, 2,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(139, true)),], + error_shift : Some(140), eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [61, 62,]; let shifted : & 'static + [u8] = & [2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) + | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : @@ -8918,12 +8555,12 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 182),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [62,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(141, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [62,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8937,22 +8574,26 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 75), (16, 76),], error_shift : Some(184), eof_shift : None, - shift_goto_map_nonterm : vec![(GrammarNonTerminals::IdentOrLiteral, 94), - (GrammarNonTerminals::_IdentOrLiteralPlus28, 186),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); __reduce_map.into_iter() - .collect() }, error_reduce : None, eof_reduce : None, ruleset : { let rules : - & 'static [u8] = & [39, 40, 55, 56, 144, 145,]; let shifted : & 'static [u8] - = & [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() } }, + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(76, true)),], error_shift : + Some(143), eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::IdentOrLiteral, + ::rusty_lr_core::parser::state::ShiftTarget::new(94, true)), + (GrammarNonTerminals::_IdentOrLiteralPlus28, + ::rusty_lr_core::parser::state::ShiftTarget::new(145, true)),], reduce_map : + { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [39, 40, 55, 56, 144, 145,]; let shifted : & + 'static [u8] = & [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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 185),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [56,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(144, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [56,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8966,14 +8607,18 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 75), (2, 187), (16, 76),], error_shift : None, eof_shift : None, - shift_goto_map_nonterm : vec![(GrammarNonTerminals::IdentOrLiteral, 97),], - reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); - __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, - ruleset : { let rules : & 'static [u8] = & [39, 40, 55, 145,]; let shifted : - & 'static [u8] = & [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() } }, + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)), (2, + ::rusty_lr_core::parser::state::ShiftTarget::new(146, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(76, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::IdentOrLiteral, + ::rusty_lr_core::parser::state::ShiftTarget::new(97, true)),], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [39, 40, 55, 145,]; let shifted : & 'static + [u8] = & [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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = @@ -8985,13 +8630,13 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 189),], error_shift : Some(190), eof_shift : None, - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [65, 66,]; let shifted : & 'static [u8] = & [2, 2,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(148, true)),], + error_shift : Some(149), eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [65, 66,]; let shifted : & 'static + [u8] = & [2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) + | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : @@ -9004,12 +8649,12 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 191),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [66,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(150, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [66,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -9023,13 +8668,13 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 193),], error_shift : Some(194), eof_shift : None, - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [67, 68,]; let shifted : & 'static [u8] = & [2, 2,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(152, true)),], + error_shift : Some(153), eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [67, 68,]; let shifted : & 'static + [u8] = & [2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) + | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : @@ -9042,12 +8687,12 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 195),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [68,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(154, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [68,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -9061,16 +8706,19 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 197),], error_shift : Some(198), eof_shift : None, - shift_goto_map_nonterm : vec![(GrammarNonTerminals::_identPlus29, 200), - (GrammarNonTerminals::_identStar30, 202),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![149]; __reduce_map.extend(__rustylr_tset18.iter().map(| term | (* term, - reduce_rules.clone()))); __reduce_map.into_iter().collect() }, error_reduce : - None, eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [69, 70, - 146, 147, 148, 149,]; let shifted : & 'static [u8] = & [2, 2, 0, 0, 0, 0,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(156, true)),], + error_shift : Some(157), eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::_identPlus29, + ::rusty_lr_core::parser::state::ShiftTarget::new(159, true)), + (GrammarNonTerminals::_identStar30, + ::rusty_lr_core::parser::state::ShiftTarget::new(161, true)),], reduce_map : + { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules + = vec![149]; __reduce_map.extend(__rustylr_tset18.iter().map(| term | (* + term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, + error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static + [u8] = & [69, 70, 146, 147, 148, 149,]; let shifted : & 'static [u8] = & [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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : @@ -9083,12 +8731,12 @@ impl GrammarParser { rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 199),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [70,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(158, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [70,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -9102,15 +8750,16 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 201),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![148]; __reduce_map - .extend(__rustylr_tset18.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : None, ruleset : { let rules : & 'static [u8] = & [147, 148,]; - let shifted : & 'static [u8] = & [1, 1,]; rules.iter().zip(shifted.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : - rule as usize, shifted : shifted as usize, } }).collect() } }, + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(160, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let + reduce_rules = vec![148]; __reduce_map.extend(__rustylr_tset18.iter().map(| + term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() + }, error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static + [u8] = & [147, 148,]; let shifted : & 'static [u8] = & [1, 1,]; rules.iter() + .zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = @@ -9122,12 +8771,12 @@ impl GrammarParser { rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 203),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [69,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(162, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [69,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -9141,25 +8790,66 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 105), (1, 106), (2, 205), (3, 108), (4, 109), (5, 110), (6, 111), - (7, 112), (8, 113), (9, 114), (10, 115), (11, 116), (12, 117), (13, 118), - (14, 119), (15, 120), (16, 121), (17, 122), (18, 123), (19, 124), (20, 125), - (21, 126), (22, 127), (23, 128), (24, 129), (25, 130), (26, 131), (27, 132), - (28, 133), (29, 134), (30, 135), (31, 136), (32, 137), (33, 138), (34, 139), - (35, 140), (36, 141), (37, 142), (38, 143), (39, 144), (40, 145), (41, - 146),], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![(GrammarNonTerminals::RustCode, 206), (GrammarNonTerminals::_TermSet26, - 149), (GrammarNonTerminals::__TermSet26Plus27, 150),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); __reduce_map.into_iter() - .collect() }, error_reduce : None, eof_reduce : None, ruleset : { let rules : - & 'static [u8] = & [41, 71, 72, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143,]; let shifted : & 'static [u8] = & [0, 2, 2, 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, 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() } }, + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (1, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (2, + ::rusty_lr_core::parser::state::ShiftTarget::new(164, true)), (3, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (4, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (5, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (6, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (7, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (8, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (9, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (10, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (11, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (12, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (13, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (14, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (15, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (17, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (18, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (19, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (20, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (21, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (22, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (23, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (24, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (25, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (26, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (27, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (28, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (29, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (30, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (31, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (32, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (33, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (34, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (35, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (36, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (37, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (38, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (39, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (40, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (41, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::RustCode, + ::rusty_lr_core::parser::state::ShiftTarget::new(165, true)), + (GrammarNonTerminals::_TermSet26, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), + (GrammarNonTerminals::__TermSet26Plus27, + ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], reduce_map : + { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [41, 71, 72, 101, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, + 137, 138, 139, 140, 141, 142, 143,]; let shifted : & 'static [u8] = & [0, 2, + 2, 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, 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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = @@ -9171,12 +8861,12 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 207),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [71,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(166, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [71,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -9190,25 +8880,66 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 105), (1, 106), (2, 209), (3, 108), (4, 109), (5, 110), (6, 111), - (7, 112), (8, 113), (9, 114), (10, 115), (11, 116), (12, 117), (13, 118), - (14, 119), (15, 120), (16, 121), (17, 122), (18, 123), (19, 124), (20, 125), - (21, 126), (22, 127), (23, 128), (24, 129), (25, 130), (26, 131), (27, 132), - (28, 133), (29, 134), (30, 135), (31, 136), (32, 137), (33, 138), (34, 139), - (35, 140), (36, 141), (37, 142), (38, 143), (39, 144), (40, 145), (41, - 146),], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![(GrammarNonTerminals::RustCode, 210), (GrammarNonTerminals::_TermSet26, - 149), (GrammarNonTerminals::__TermSet26Plus27, 150),], reduce_map : { let mut - __reduce_map = std::collections::BTreeMap::new(); __reduce_map.into_iter() - .collect() }, error_reduce : None, eof_reduce : None, ruleset : { let rules : - & 'static [u8] = & [41, 73, 74, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143,]; let shifted : & 'static [u8] = & [0, 2, 2, 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, 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() } }, + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (1, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (2, + ::rusty_lr_core::parser::state::ShiftTarget::new(168, true)), (3, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (4, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (5, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (6, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (7, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (8, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (9, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (10, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (11, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (12, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (13, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (14, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (15, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (16, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (17, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (18, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (19, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (20, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (21, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (22, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (23, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (24, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (25, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (26, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (27, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (28, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (29, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (30, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (31, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (32, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (33, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (34, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (35, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (36, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (37, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (38, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (39, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (40, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), (41, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::RustCode, + ::rusty_lr_core::parser::state::ShiftTarget::new(169, true)), + (GrammarNonTerminals::_TermSet26, + ::rusty_lr_core::parser::state::ShiftTarget::new(108, true)), + (GrammarNonTerminals::__TermSet26Plus27, + ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], reduce_map : + { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + .into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { + let rules : & 'static [u8] = & [41, 73, 74, 101, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, + 137, 138, 139, 140, 141, 142, 143,]; let shifted : & 'static [u8] = & [0, 2, + 2, 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, 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() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = @@ -9220,12 +8951,12 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 211),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [73,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(170, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [73,]; let shifted : & 'static + [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -9239,12 +8970,12 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(2, 213),], error_shift : None, eof_shift : None, shift_goto_map_nonterm - : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static - [u8] = & [75,]; let shifted : & 'static [u8] = & [2,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + vec![(2, ::rusty_lr_core::parser::state::ShiftTarget::new(172, true)),], + error_shift : None, eof_shift : None, shift_goto_map_nonterm : vec![], + reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); + __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, + ruleset : { let rules : & 'static [u8] = & [75,]; let shifted : & 'static + [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -9268,21 +8999,18 @@ impl GrammarParser { .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![77]; __reduce_map - .extend(__rustylr_tset12.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, error_reduce : None, - eof_reduce : Some(vec![77]), ruleset : { let rules : & 'static [u8] = & - [77,]; let shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted - .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef - { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![(0, 1), (4, 90),], error_shift : None, eof_shift : None, - shift_goto_map_nonterm : vec![(GrammarNonTerminals::Rule, 214), - (GrammarNonTerminals::Directive, 215), (GrammarNonTerminals::GrammarLine, - 216), (GrammarNonTerminals::_GrammarLinePlus31, 217),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map + vec![(0, ::rusty_lr_core::parser::state::ShiftTarget::new(1, true)), (4, + ::rusty_lr_core::parser::state::ShiftTarget::new(90, true)),], error_shift : + None, eof_shift : None, shift_goto_map_nonterm : + vec![(GrammarNonTerminals::Rule, + ::rusty_lr_core::parser::state::ShiftTarget::new(173, true)), + (GrammarNonTerminals::Directive, + ::rusty_lr_core::parser::state::ShiftTarget::new(174, false)), + (GrammarNonTerminals::GrammarLine, + ::rusty_lr_core::parser::state::ShiftTarget::new(174, true)), + (GrammarNonTerminals::_GrammarLinePlus31, + ::rusty_lr_core::parser::state::ShiftTarget::new(175, true)),], reduce_map : + { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map .into_iter().collect() }, error_reduce : None, eof_reduce : Some(vec![150]), ruleset : { let rules : & 'static [u8] = & [0, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, @@ -9302,7 +9030,7 @@ impl GrammarParser { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : Some(219), shift_goto_map_nonterm : + vec![], error_shift : None, eof_shift : Some(177), shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, error_reduce : None, eof_reduce : None, ruleset : { let rules : & 'static @@ -9319,15 +9047,6 @@ impl GrammarParser { .zip(shifted.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], error_shift : None, eof_shift : None, shift_goto_map_nonterm : - vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - error_reduce : None, eof_reduce : Some(vec![78]), ruleset : { let rules : & - 'static [u8] = & [78,]; let shifted : & 'static [u8] = & [1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, ]; let states: Vec = states .into_iter() diff --git a/rusty_lr_parser/src/pattern.rs b/rusty_lr_parser/src/pattern.rs index b0b518d..c1d4b73 100644 --- a/rusty_lr_parser/src/pattern.rs +++ b/rusty_lr_parser/src/pattern.rs @@ -162,6 +162,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let line2 = Rule { tokens: vec![ @@ -185,6 +186,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let nonterm_info = NonTerminalInfo { @@ -224,6 +226,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let line2 = Rule { tokens: vec![ @@ -245,6 +248,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let nonterm_info = NonTerminalInfo { @@ -301,6 +305,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let line2 = Rule { tokens: vec![], @@ -311,6 +316,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let nonterm_info = NonTerminalInfo { @@ -350,6 +356,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let line2 = Rule { tokens: vec![], @@ -358,6 +365,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let nonterm_info = NonTerminalInfo { name: newrule_name.clone(), @@ -406,6 +414,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let line2 = Rule { tokens: vec![], @@ -416,6 +425,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let nonterm_info = NonTerminalInfo { @@ -455,6 +465,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let line2 = Rule { tokens: vec![], @@ -463,6 +474,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let nonterm_info = NonTerminalInfo { @@ -528,6 +540,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; rules.push(rule); } @@ -580,6 +593,7 @@ impl Pattern { lookaheads: Some(lookaheads), prec: None, dprec: None, + is_used: true, }; let nonterm_info = NonTerminalInfo { @@ -616,6 +630,7 @@ impl Pattern { lookaheads: Some(lookaheads), prec: None, dprec: None, + is_used: true, }; let nonterm_info = NonTerminalInfo { @@ -683,6 +698,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; (rule, None) } @@ -698,6 +714,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let ruletype = elements[unique_child_idx].ruletype.clone(); (rule, ruletype) @@ -722,6 +739,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; (rule, Some(typename)) } @@ -817,6 +835,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let nonterm_info = NonTerminalInfo { @@ -866,6 +885,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let nonterm_info = NonTerminalInfo { @@ -917,6 +937,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let rule2 = Rule { tokens: vec![ @@ -949,6 +970,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let nonterm_info = NonTerminalInfo { @@ -985,6 +1007,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let rule2 = Rule { tokens: vec![ @@ -1012,6 +1035,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let nonterm_info = NonTerminalInfo { @@ -1069,6 +1093,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let line2 = Rule { tokens: vec![], @@ -1079,6 +1104,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let nonterm_info = NonTerminalInfo { @@ -1118,6 +1144,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let line2 = Rule { tokens: vec![], @@ -1126,6 +1153,7 @@ impl Pattern { lookaheads: None, prec: None, dprec: None, + is_used: true, }; let nonterm_info = NonTerminalInfo { name: newrule_name.clone(),