diff --git a/rusty_lr_parser/src/emit.rs b/rusty_lr_parser/src/emit.rs index 24346f1..d67dc77 100644 --- a/rusty_lr_parser/src/emit.rs +++ b/rusty_lr_parser/src/emit.rs @@ -679,7 +679,7 @@ impl Grammar { let new_index = terminal_sets_name_map.len(); terminal_sets_name_map .entry(set) - .or_insert_with(|| format_ident!("__rustylr_tset{new_index}")) + .or_insert_with(|| format_ident!("__RUSTYLR_TSET{new_index}")) .clone() }; for state in &self.states { @@ -743,6 +743,7 @@ impl Grammar { let mut ruleset_rules_body_stream = TokenStream::new(); let mut ruleset_shifted_body_stream = TokenStream::new(); + let ruleset_len = state.ruleset.len(); let mut max_shifted = 0; for &rule in &state.ruleset { max_shifted = max_shifted.max(rule.shifted); @@ -765,23 +766,31 @@ impl Grammar { quote! { usize } }; + let reduce_map_construct_stream = if reduce_body_stream.is_empty() { + quote! { Default::default() } + } else { + quote! { + { + let mut __reduce_map = std::collections::BTreeMap::new(); + #reduce_body_stream + __reduce_map.into_iter().collect() + } + } + }; + states_body_stream.extend(quote! { #module_prefix::parser::state::IntermediateState { shift_goto_map_term: vec![#shift_term_body_stream], shift_goto_map_nonterm: vec![#shift_nonterm_body_stream], - reduce_map: { - let mut __reduce_map = std::collections::BTreeMap::new(); - #reduce_body_stream - __reduce_map.into_iter().collect() - }, + reduce_map: #reduce_map_construct_stream, ruleset: { - let rules: &'static [#rule_index_typename] = &[ + static __RULES: [#rule_index_typename; #ruleset_len] = [ #ruleset_rules_body_stream ]; - let shifted: &'static [#shifted_typename] = &[ + static __SHIFTED: [#shifted_typename; #ruleset_len] = [ #ruleset_shifted_body_stream ]; - rules.iter().zip(shifted.iter()).map( + __RULES.iter().zip(__SHIFTED.iter()).map( |(&rule, &shifted)| { #module_prefix::rule::ShiftedRuleRef { rule: rule as usize, @@ -796,6 +805,7 @@ impl Grammar { let mut terminal_set_initialize_stream = TokenStream::new(); for (set, name) in terminal_sets_name_map { + let len = set.len(); let set_it = set.into_iter().map(|val| match val { TerminalSymbol::Term(term) => { let var = &class_variants[term]; @@ -811,7 +821,7 @@ impl Grammar { } }); terminal_set_initialize_stream.extend(quote! { - let #name: Vec<#termclass_typename> = vec![#(#set_it),*]; + static #name: [#termclass_typename; #len] = [#(#set_it),*]; }); } diff --git a/rusty_lr_parser/src/parser/parser_expanded.rs b/rusty_lr_parser/src/parser/parser_expanded.rs index 04151a5..e9763e6 100644 --- a/rusty_lr_parser/src/parser/parser_expanded.rs +++ b/rusty_lr_parser/src/parser/parser_expanded.rs @@ -7311,132 +7311,204 @@ impl GrammarParser { ::rusty_lr_core::Token::Term(GrammarTerminalClasses::eof),], precedence : None, }, ]; - let __rustylr_tset17: Vec = vec![ - GrammarTerminalClasses::ident, GrammarTerminalClasses::colon, - GrammarTerminalClasses::semicolon, GrammarTerminalClasses::pipe, - GrammarTerminalClasses::percent, GrammarTerminalClasses::equal, - GrammarTerminalClasses::plus, GrammarTerminalClasses::star, - GrammarTerminalClasses::question, GrammarTerminalClasses::caret, - GrammarTerminalClasses::minus, GrammarTerminalClasses::exclamation, - GrammarTerminalClasses::slash, GrammarTerminalClasses::dot, - GrammarTerminalClasses::dollar, GrammarTerminalClasses::comma, - GrammarTerminalClasses::literal, GrammarTerminalClasses::parengroup, - GrammarTerminalClasses::bracegroup, GrammarTerminalClasses::lparen, - GrammarTerminalClasses::rparen, GrammarTerminalClasses::lbracket, - GrammarTerminalClasses::rbracket, GrammarTerminalClasses::left, - GrammarTerminalClasses::right, GrammarTerminalClasses::token, - GrammarTerminalClasses::start, GrammarTerminalClasses::tokentype, - GrammarTerminalClasses::userdata, GrammarTerminalClasses::errortype, - GrammarTerminalClasses::moduleprefix, GrammarTerminalClasses::lalr, - GrammarTerminalClasses::glr, GrammarTerminalClasses::prec, - GrammarTerminalClasses::precedence, GrammarTerminalClasses::nooptim, - GrammarTerminalClasses::dense, GrammarTerminalClasses::trace, - GrammarTerminalClasses::dprec, GrammarTerminalClasses::filter, + static __RUSTYLR_TSET17: [GrammarTerminalClasses; 42usize] = [ + GrammarTerminalClasses::ident, + GrammarTerminalClasses::colon, + GrammarTerminalClasses::semicolon, + GrammarTerminalClasses::pipe, + GrammarTerminalClasses::percent, + GrammarTerminalClasses::equal, + GrammarTerminalClasses::plus, + GrammarTerminalClasses::star, + GrammarTerminalClasses::question, + GrammarTerminalClasses::caret, + GrammarTerminalClasses::minus, + GrammarTerminalClasses::exclamation, + GrammarTerminalClasses::slash, + GrammarTerminalClasses::dot, + GrammarTerminalClasses::dollar, + GrammarTerminalClasses::comma, + GrammarTerminalClasses::literal, + GrammarTerminalClasses::parengroup, + GrammarTerminalClasses::bracegroup, + GrammarTerminalClasses::lparen, + GrammarTerminalClasses::rparen, + GrammarTerminalClasses::lbracket, + GrammarTerminalClasses::rbracket, + GrammarTerminalClasses::left, + GrammarTerminalClasses::right, + GrammarTerminalClasses::token, + GrammarTerminalClasses::start, + GrammarTerminalClasses::tokentype, + GrammarTerminalClasses::userdata, + GrammarTerminalClasses::errortype, + GrammarTerminalClasses::moduleprefix, + GrammarTerminalClasses::lalr, + GrammarTerminalClasses::glr, + GrammarTerminalClasses::prec, + GrammarTerminalClasses::precedence, + GrammarTerminalClasses::nooptim, + GrammarTerminalClasses::dense, + GrammarTerminalClasses::trace, + GrammarTerminalClasses::dprec, + GrammarTerminalClasses::filter, GrammarTerminalClasses::location, - GrammarTerminalClasses::__rustylr_other_terminals + GrammarTerminalClasses::__rustylr_other_terminals, ]; - let __rustylr_tset19: Vec = vec![ - GrammarTerminalClasses::ident, GrammarTerminalClasses::semicolon + static __RUSTYLR_TSET19: [GrammarTerminalClasses; 2usize] = [ + GrammarTerminalClasses::ident, + GrammarTerminalClasses::semicolon, ]; - let __rustylr_tset3: Vec = vec![ - GrammarTerminalClasses::ident, GrammarTerminalClasses::semicolon, - GrammarTerminalClasses::pipe, GrammarTerminalClasses::percent, - GrammarTerminalClasses::plus, GrammarTerminalClasses::star, - GrammarTerminalClasses::question, GrammarTerminalClasses::minus, - GrammarTerminalClasses::exclamation, GrammarTerminalClasses::slash, - GrammarTerminalClasses::dot, GrammarTerminalClasses::dollar, - GrammarTerminalClasses::comma, GrammarTerminalClasses::literal, - GrammarTerminalClasses::bracegroup, GrammarTerminalClasses::lparen, - GrammarTerminalClasses::rparen, GrammarTerminalClasses::lbracket, - GrammarTerminalClasses::error + static __RUSTYLR_TSET3: [GrammarTerminalClasses; 19usize] = [ + GrammarTerminalClasses::ident, + GrammarTerminalClasses::semicolon, + GrammarTerminalClasses::pipe, + GrammarTerminalClasses::percent, + GrammarTerminalClasses::plus, + GrammarTerminalClasses::star, + GrammarTerminalClasses::question, + GrammarTerminalClasses::minus, + GrammarTerminalClasses::exclamation, + GrammarTerminalClasses::slash, + GrammarTerminalClasses::dot, + GrammarTerminalClasses::dollar, + GrammarTerminalClasses::comma, + GrammarTerminalClasses::literal, + GrammarTerminalClasses::bracegroup, + GrammarTerminalClasses::lparen, + GrammarTerminalClasses::rparen, + GrammarTerminalClasses::lbracket, + GrammarTerminalClasses::error, ]; - let __rustylr_tset2: Vec = vec![ - GrammarTerminalClasses::ident, GrammarTerminalClasses::semicolon, - GrammarTerminalClasses::pipe, GrammarTerminalClasses::percent, - GrammarTerminalClasses::plus, GrammarTerminalClasses::star, - GrammarTerminalClasses::question, GrammarTerminalClasses::minus, - GrammarTerminalClasses::exclamation, GrammarTerminalClasses::slash, - GrammarTerminalClasses::dot, GrammarTerminalClasses::dollar, - GrammarTerminalClasses::literal, GrammarTerminalClasses::bracegroup, - GrammarTerminalClasses::lparen, GrammarTerminalClasses::lbracket + static __RUSTYLR_TSET2: [GrammarTerminalClasses; 16usize] = [ + GrammarTerminalClasses::ident, + GrammarTerminalClasses::semicolon, + GrammarTerminalClasses::pipe, + GrammarTerminalClasses::percent, + GrammarTerminalClasses::plus, + GrammarTerminalClasses::star, + GrammarTerminalClasses::question, + GrammarTerminalClasses::minus, + GrammarTerminalClasses::exclamation, + GrammarTerminalClasses::slash, + GrammarTerminalClasses::dot, + GrammarTerminalClasses::dollar, + GrammarTerminalClasses::literal, + GrammarTerminalClasses::bracegroup, + GrammarTerminalClasses::lparen, + GrammarTerminalClasses::lbracket, ]; - let __rustylr_tset8: Vec = vec![ - GrammarTerminalClasses::ident, GrammarTerminalClasses::semicolon, - GrammarTerminalClasses::pipe, GrammarTerminalClasses::percent, - GrammarTerminalClasses::minus, GrammarTerminalClasses::slash, - GrammarTerminalClasses::dot, GrammarTerminalClasses::dollar, - GrammarTerminalClasses::comma, GrammarTerminalClasses::literal, - GrammarTerminalClasses::bracegroup, GrammarTerminalClasses::lparen, - GrammarTerminalClasses::rparen, GrammarTerminalClasses::lbracket, - GrammarTerminalClasses::error + static __RUSTYLR_TSET8: [GrammarTerminalClasses; 15usize] = [ + GrammarTerminalClasses::ident, + GrammarTerminalClasses::semicolon, + GrammarTerminalClasses::pipe, + GrammarTerminalClasses::percent, + GrammarTerminalClasses::minus, + GrammarTerminalClasses::slash, + GrammarTerminalClasses::dot, + GrammarTerminalClasses::dollar, + GrammarTerminalClasses::comma, + GrammarTerminalClasses::literal, + GrammarTerminalClasses::bracegroup, + GrammarTerminalClasses::lparen, + GrammarTerminalClasses::rparen, + GrammarTerminalClasses::lbracket, + GrammarTerminalClasses::error, ]; - let __rustylr_tset7: Vec = vec![ - GrammarTerminalClasses::ident, GrammarTerminalClasses::semicolon, - GrammarTerminalClasses::pipe, GrammarTerminalClasses::percent, - GrammarTerminalClasses::minus, GrammarTerminalClasses::dot, - GrammarTerminalClasses::dollar, GrammarTerminalClasses::comma, - GrammarTerminalClasses::literal, GrammarTerminalClasses::bracegroup, - GrammarTerminalClasses::lparen, GrammarTerminalClasses::rparen, - GrammarTerminalClasses::lbracket, GrammarTerminalClasses::error + static __RUSTYLR_TSET7: [GrammarTerminalClasses; 14usize] = [ + GrammarTerminalClasses::ident, + GrammarTerminalClasses::semicolon, + GrammarTerminalClasses::pipe, + GrammarTerminalClasses::percent, + GrammarTerminalClasses::minus, + GrammarTerminalClasses::dot, + GrammarTerminalClasses::dollar, + GrammarTerminalClasses::comma, + GrammarTerminalClasses::literal, + GrammarTerminalClasses::bracegroup, + GrammarTerminalClasses::lparen, + GrammarTerminalClasses::rparen, + GrammarTerminalClasses::lbracket, + GrammarTerminalClasses::error, ]; - let __rustylr_tset11: Vec = vec![ - GrammarTerminalClasses::ident, GrammarTerminalClasses::semicolon, - GrammarTerminalClasses::pipe, GrammarTerminalClasses::percent, - GrammarTerminalClasses::dot, GrammarTerminalClasses::dollar, - GrammarTerminalClasses::literal, GrammarTerminalClasses::bracegroup, - GrammarTerminalClasses::lparen, GrammarTerminalClasses::lbracket + static __RUSTYLR_TSET11: [GrammarTerminalClasses; 10usize] = [ + GrammarTerminalClasses::ident, + GrammarTerminalClasses::semicolon, + GrammarTerminalClasses::pipe, + GrammarTerminalClasses::percent, + GrammarTerminalClasses::dot, + GrammarTerminalClasses::dollar, + GrammarTerminalClasses::literal, + GrammarTerminalClasses::bracegroup, + GrammarTerminalClasses::lparen, + GrammarTerminalClasses::lbracket, ]; - let __rustylr_tset15: Vec = vec![ - GrammarTerminalClasses::ident, GrammarTerminalClasses::semicolon, - GrammarTerminalClasses::pipe, GrammarTerminalClasses::percent, - GrammarTerminalClasses::literal, GrammarTerminalClasses::bracegroup + static __RUSTYLR_TSET15: [GrammarTerminalClasses; 6usize] = [ + GrammarTerminalClasses::ident, + GrammarTerminalClasses::semicolon, + GrammarTerminalClasses::pipe, + GrammarTerminalClasses::percent, + GrammarTerminalClasses::literal, + GrammarTerminalClasses::bracegroup, ]; - let __rustylr_tset16: Vec = vec![ - GrammarTerminalClasses::ident, GrammarTerminalClasses::semicolon, - GrammarTerminalClasses::literal + static __RUSTYLR_TSET16: [GrammarTerminalClasses; 3usize] = [ + GrammarTerminalClasses::ident, + GrammarTerminalClasses::semicolon, + GrammarTerminalClasses::literal, ]; - let __rustylr_tset9: Vec = vec![ - GrammarTerminalClasses::ident, GrammarTerminalClasses::pipe, - GrammarTerminalClasses::dot, GrammarTerminalClasses::dollar, - GrammarTerminalClasses::literal, GrammarTerminalClasses::lparen, - GrammarTerminalClasses::rparen, GrammarTerminalClasses::lbracket + static __RUSTYLR_TSET9: [GrammarTerminalClasses; 8usize] = [ + GrammarTerminalClasses::ident, + GrammarTerminalClasses::pipe, + GrammarTerminalClasses::dot, + GrammarTerminalClasses::dollar, + GrammarTerminalClasses::literal, + GrammarTerminalClasses::lparen, + GrammarTerminalClasses::rparen, + GrammarTerminalClasses::lbracket, ]; - let __rustylr_tset12: Vec = vec![ - GrammarTerminalClasses::ident, GrammarTerminalClasses::percent, - GrammarTerminalClasses::eof + static __RUSTYLR_TSET12: [GrammarTerminalClasses; 3usize] = [ + GrammarTerminalClasses::ident, + GrammarTerminalClasses::percent, + GrammarTerminalClasses::eof, ]; - let __rustylr_tset5: Vec = vec![ - GrammarTerminalClasses::ident, GrammarTerminalClasses::literal, - GrammarTerminalClasses::rbracket + static __RUSTYLR_TSET5: [GrammarTerminalClasses; 3usize] = [ + GrammarTerminalClasses::ident, + GrammarTerminalClasses::literal, + GrammarTerminalClasses::rbracket, ]; - let __rustylr_tset0: Vec = vec![ - GrammarTerminalClasses::colon + static __RUSTYLR_TSET0: [GrammarTerminalClasses; 1usize] = [ + GrammarTerminalClasses::colon, ]; - let __rustylr_tset18: Vec = vec![ - GrammarTerminalClasses::semicolon + static __RUSTYLR_TSET18: [GrammarTerminalClasses; 1usize] = [ + GrammarTerminalClasses::semicolon, ]; - let __rustylr_tset13: Vec = vec![ - GrammarTerminalClasses::semicolon, GrammarTerminalClasses::pipe + static __RUSTYLR_TSET13: [GrammarTerminalClasses; 2usize] = [ + GrammarTerminalClasses::semicolon, + GrammarTerminalClasses::pipe, ]; - let __rustylr_tset1: Vec = vec![ - GrammarTerminalClasses::semicolon, GrammarTerminalClasses::pipe, - GrammarTerminalClasses::percent, GrammarTerminalClasses::bracegroup + static __RUSTYLR_TSET1: [GrammarTerminalClasses; 4usize] = [ + GrammarTerminalClasses::semicolon, + GrammarTerminalClasses::pipe, + GrammarTerminalClasses::percent, + GrammarTerminalClasses::bracegroup, ]; - let __rustylr_tset14: Vec = vec![ - GrammarTerminalClasses::semicolon, GrammarTerminalClasses::pipe, - GrammarTerminalClasses::bracegroup + static __RUSTYLR_TSET14: [GrammarTerminalClasses; 3usize] = [ + GrammarTerminalClasses::semicolon, + GrammarTerminalClasses::pipe, + GrammarTerminalClasses::bracegroup, ]; - let __rustylr_tset4: Vec = vec![ - GrammarTerminalClasses::pipe, GrammarTerminalClasses::rparen + static __RUSTYLR_TSET4: [GrammarTerminalClasses; 2usize] = [ + GrammarTerminalClasses::pipe, + GrammarTerminalClasses::rparen, ]; - let __rustylr_tset10: Vec = vec![ - GrammarTerminalClasses::rparen + static __RUSTYLR_TSET10: [GrammarTerminalClasses; 1usize] = [ + GrammarTerminalClasses::rparen, ]; - let __rustylr_tset6: Vec = vec![ - GrammarTerminalClasses::rbracket + static __RUSTYLR_TSET6: [GrammarTerminalClasses; 1usize] = [ + GrammarTerminalClasses::rbracket, ]; - let __rustylr_tset20: Vec = vec![ - GrammarTerminalClasses::eof + static __RUSTYLR_TSET20: [GrammarTerminalClasses; 1usize] = [ + GrammarTerminalClasses::eof, ]; let states: Vec< ::rusty_lr_core::parser::state::IntermediateState< @@ -7461,14 +7533,13 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(175, true)), (GrammarNonTerminals::_GrammarLinePlus31, ::rusty_lr_core::parser::state::ShiftTarget::new(175, false)),], reduce_map : - { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [0, 41, - 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 149, 150, - 151,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + Default::default(), ruleset : { static __RULES : [u8; 41usize] = [0, 41, 42, + 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 149, 150, + 151,]; static __SHIFTED : [u8; 41usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 : + 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) + | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::parengroup, @@ -7476,27 +7547,27 @@ impl GrammarParser { 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, + vec![2]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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 : + static __RULES : [u8; 3usize] = [0, 1, 2,]; static __SHIFTED : [u8; 3usize] = + [1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | + { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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() }, 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() } }, + .extend(__RUSTYLR_TSET0.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 1usize] = [1,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::colon, ::rusty_lr_core::parser::state::ShiftTarget::new(4, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [0,]; let shifted : & 'static [u8] - = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [0,]; static __SHIFTED : [u8; 1usize] = [2,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -7527,23 +7598,23 @@ impl GrammarParser { (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![81]; __reduce_map.extend(__rustylr_tset1.iter().map(| term | (* term, + vec![81]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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, 78, 79, 80, 81,]; 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() } }, + static __RULES : [u8; 28usize] = [0, 3, 4, 5, 11, 12, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 78, 79, 80, 81,]; static + __SHIFTED : [u8; 28usize] = [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![(GrammarTerminalClasses::equal, ::rusty_lr_core::parser::state::ShiftTarget::new(6, true)),], 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() }, ruleset : { let rules : & 'static [u8] - = & [12, 21,]; let shifted : & 'static [u8] = & [1, 1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + .extend(__RUSTYLR_TSET2.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 2usize] = [12, 21,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -7562,48 +7633,45 @@ impl GrammarParser { 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() }, 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::parser::state::ShiftTarget::new(63, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 19usize] = [12, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,]; static + __SHIFTED : [u8; 19usize] = [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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() }, ruleset : { let rules : & - 'static [u8] = & [21,]; let shifted : & 'static [u8] = & [1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [21,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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() }, ruleset : { let rules : & - 'static [u8] = & [20,]; let shifted : & 'static [u8] = & [1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [20,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(10, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - 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(| + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 5usize] = [32, 33, 34, 35, 36,]; static __SHIFTED : + [u8; 5usize] = [1, 1, 1, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::lparen, ::rusty_lr_core::parser::state::ShiftTarget::new(11, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - 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(| + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 5usize] = [32, 33, 34, 35, 36,]; static __SHIFTED : + [u8; 5usize] = [2, 2, 2, 2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -7622,21 +7690,20 @@ impl GrammarParser { 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() }, 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(| + ::rusty_lr_core::parser::state::ShiftTarget::new(31, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 23usize] = [19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 32, 33, 33, 34, 34, 35, 35, 36, + 36,]; static __SHIFTED : [u8; 23usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![30]; - __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : & - 'static [u8] = & [30,]; let shifted : & 'static [u8] = & [1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [30,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -7665,33 +7732,33 @@ impl GrammarParser { (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![95]; __reduce_map.extend(__rustylr_tset4.iter().map(| term | (* term, + vec![95]; __reduce_map.extend(__RUSTYLR_TSET4.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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, 92, 93, 94, 95, 96, 97,]; 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() } }, + static __RULES : [u8; 26usize] = [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 28, + 29, 29, 30, 31, 32, 33, 34, 35, 36, 92, 93, 94, 95, 96, 97,]; static + __SHIFTED : [u8; 26usize] = [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![(GrammarTerminalClasses::caret, ::rusty_lr_core::parser::state::ShiftTarget::new(15, true)),], 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![87]; __reduce_map.extend(__rustylr_tset5.iter().map(| term | (* term, + vec![87]; __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [19, 86, 87,]; 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() } }, + static __RULES : [u8; 3usize] = [19, 86, 87,]; static __SHIFTED : [u8; + 3usize] = [1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & + shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, + shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![86]; - __reduce_map.extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : & - 'static [u8] = & [86,]; let shifted : & 'static [u8] = & [1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [86,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -7706,11 +7773,11 @@ impl GrammarParser { (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![91]; __reduce_map.extend(__rustylr_tset6.iter().map(| term | (* term, + vec![91]; __reduce_map.extend(__RUSTYLR_TSET6.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [13, 14, 15, 16, 17, 18, 19, 88, 89, 90, 91,]; - let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0,]; rules - .iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 11usize] = [13, 14, 15, 16, 17, 18, 19, 88, 89, 90, + 91,]; static __SHIFTED : [u8; 11usize] = [0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -7718,10 +7785,10 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(18, true)),], 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() }, ruleset : { let rules : & 'static [u8] - = & [13, 14, 15,]; let shifted : & 'static [u8] = & [1, 1, 1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + .extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 3usize] = [13, 14, 15,]; static __SHIFTED : [u8; 3usize] = [1, 1, 1,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -7729,28 +7796,27 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(19, true)), (GrammarTerminalClasses::error, ::rusty_lr_core::parser::state::ShiftTarget::new(20, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().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 : + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 2usize] = [14, 15,]; static __SHIFTED : [u8; 2usize] = + [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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() }, ruleset : { let rules : & - 'static [u8] = & [14,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [14,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![15]; - __reduce_map.extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : & - 'static [u8] = & [15,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [15,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -7758,10 +7824,10 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(22, true)),], 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() }, ruleset : { let rules : & 'static [u8] - = & [16, 17, 18,]; let shifted : & 'static [u8] = & [1, 1, 1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + .extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 3usize] = [16, 17, 18,]; static __SHIFTED : [u8; 3usize] = [1, 1, 1,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -7769,37 +7835,36 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(23, true)), (GrammarTerminalClasses::error, ::rusty_lr_core::parser::state::ShiftTarget::new(24, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - 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 : + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 2usize] = [17, 18,]; static __SHIFTED : [u8; 2usize] = + [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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() }, ruleset : { let rules : & - 'static [u8] = & [17,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [17,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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() }, ruleset : { let rules : & - 'static [u8] = & [18,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [18,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], 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() }, ruleset : { let rules : & - 'static [u8] = & [88,]; let shifted : & 'static [u8] = & [1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [88,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -7810,46 +7875,46 @@ impl GrammarParser { 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![90]; __reduce_map.extend(__rustylr_tset6.iter().map(| term | (* term, + vec![90]; __reduce_map.extend(__RUSTYLR_TSET6.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [13, 14, 15, 16, 17, 18, 89, 90,]; 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() } }, + static __RULES : [u8; 8usize] = [13, 14, 15, 16, 17, 18, 89, 90,]; static + __SHIFTED : [u8; 8usize] = [0, 0, 0, 0, 0, 0, 1, 1,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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() }, ruleset : { let rules : & - 'static [u8] = & [89,]; let shifted : & 'static [u8] = & [2,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [89,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::rbracket, ::rusty_lr_core::parser::state::ShiftTarget::new(29, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [19,]; let shifted : & 'static - [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [19,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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() }, ruleset : { let rules : & - 'static [u8] = & [19,]; let shifted : & 'static [u8] = & [4,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [19,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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() }, ruleset : { let rules : & - 'static [u8] = & [26,]; let shifted : & 'static [u8] = & [1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [26,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -7867,38 +7932,37 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(38, true)), (GrammarTerminalClasses::comma, ::rusty_lr_core::parser::state::ShiftTarget::new(40, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - 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) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 11usize] = [22, 23, 24, 25, 27, 31, 32, 33, 34, 35, + 36,]; static __SHIFTED : [u8; 11usize] = [1, 1, 1, 1, 1, 1, 4, 4, 4, 4, 4,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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() }, ruleset : { let rules : & - 'static [u8] = & [22,]; let shifted : & 'static [u8] = & [2,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [22,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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() }, ruleset : { let rules : & - 'static [u8] = & [23,]; let shifted : & 'static [u8] = & [2,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [23,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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() }, ruleset : { let rules : & - 'static [u8] = & [24,]; let shifted : & 'static [u8] = & [2,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [24,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -7917,12 +7981,11 @@ impl GrammarParser { 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() }, 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::parser::state::ShiftTarget::new(36, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 19usize] = [19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 31, 32, 33, 34, 35, 36,]; static + __SHIFTED : [u8; 19usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -7938,19 +8001,19 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(38, true)),], 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() }, 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 : + .extend(__RUSTYLR_TSET7.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 6usize] = [22, 23, 24, 25, 27, 31,]; static __SHIFTED : [u8; 6usize] = [1, 1, + 1, 1, 1, 3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) + | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![25]; - __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : & - 'static [u8] = & [25,]; let shifted : & 'static [u8] = & [2,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [25,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -7969,12 +8032,11 @@ impl GrammarParser { 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() }, 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::parser::state::ShiftTarget::new(39, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 19usize] = [19, 20, 21, + 22, 23, 24, 25, 26, 27, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,]; static + __SHIFTED : [u8; 19usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, + 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -7988,10 +8050,10 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(37, true)),], 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() }, 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) | { + .extend(__RUSTYLR_TSET8.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 5usize] = [22, 23, 24, 25, 27,]; static __SHIFTED : [u8; 5usize] = [1, 1, 1, + 1, 3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8010,30 +8072,28 @@ impl GrammarParser { 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() }, 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(| + ::rusty_lr_core::parser::state::ShiftTarget::new(51, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 23usize] = [19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 32, 33, 33, 34, 34, 35, 35, 36, + 36,]; static __SHIFTED : [u8; 23usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 5, 0, 5, 0, 5, 0, 5, 0, 5,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::rparen, ::rusty_lr_core::parser::state::ShiftTarget::new(42, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [29,]; let shifted : & 'static - [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [29,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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() }, ruleset : { let rules : & - 'static [u8] = & [29,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [29,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8051,12 +8111,12 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(38, true)),], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![92]; __reduce_map - .extend(__rustylr_tset9.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8] - = & [22, 23, 24, 25, 27, 31, 92,]; 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() } }, + .extend(__RUSTYLR_TSET9.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 7usize] = [22, 23, 24, 25, 27, 31, 92,]; static __SHIFTED : [u8; 7usize] = + [1, 1, 1, 1, 1, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & + shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, + shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), @@ -8075,12 +8135,12 @@ impl GrammarParser { (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![94]; __reduce_map.extend(__rustylr_tset4.iter().map(| term | (* term, + vec![94]; __reduce_map.extend(__RUSTYLR_TSET4.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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,]; 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) | { + static __RULES : [u8; 20usize] = [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 93, 94,]; static __SHIFTED : [u8; 20usize] = [0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8098,19 +8158,19 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(38, true)),], 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() }, ruleset : { let rules : & 'static [u8] - = & [22, 23, 24, 25, 27, 31, 93,]; 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() } }, + .extend(__RUSTYLR_TSET9.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 7usize] = [22, 23, 24, 25, 27, 31, 93,]; static __SHIFTED : [u8; 7usize] = + [1, 1, 1, 1, 1, 1, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & + shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, + shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], 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() }, ruleset : { let rules : & - 'static [u8] = & [96,]; let shifted : & 'static [u8] = & [1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET4.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [96,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8118,11 +8178,10 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(48, true)), (GrammarTerminalClasses::rparen, ::rusty_lr_core::parser::state::ShiftTarget::new(50, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [28, 97,]; let shifted : & 'static - [u8] = & [2, 1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) - | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 2usize] = [28, 97,]; static __SHIFTED : [u8; 2usize] = + [2, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, @@ -8146,30 +8205,30 @@ impl GrammarParser { (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![95]; __reduce_map.extend(__rustylr_tset4.iter().map(| term | (* term, + vec![95]; __reduce_map.extend(__RUSTYLR_TSET4.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 92, 93, 94, 95, 97,]; 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) | { + static __RULES : [u8; 23usize] = [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 92, 93, 94, 95, 97,]; static __SHIFTED : [u8; + 23usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : & - 'static [u8] = & [97,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET4.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [97,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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() }, ruleset : { let rules : & - 'static [u8] = & [28,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [28,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8192,11 +8251,11 @@ impl GrammarParser { 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![99]; __reduce_map.extend(__rustylr_tset10.iter().map(| term | (* term, + vec![99]; __reduce_map.extend(__RUSTYLR_TSET10.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [22, 23, 24, 25, 27, 31, 32, 33, 34, 35, 36, - 98, 99,]; 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) | { + static __RULES : [u8; 13usize] = [22, 23, 24, 25, 27, 31, 32, 33, 34, 35, 36, + 98, 99,]; static __SHIFTED : [u8; 13usize] = [1, 1, 1, 1, 1, 1, 6, 6, 6, 6, + 6, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8208,100 +8267,95 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(57, true)),], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![98]; __reduce_map - .extend(__rustylr_tset10.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : & - 'static [u8] = & [33, 34, 36, 98,]; let shifted : & 'static [u8] = & [7, 7, - 7, 1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + .extend(__RUSTYLR_TSET10.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 4usize] = [33, 34, 36, 98,]; static __SHIFTED : [u8; 4usize] = [7, 7, + 7, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::rparen, ::rusty_lr_core::parser::state::ShiftTarget::new(54, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [33,]; let shifted : & 'static - [u8] = & [8,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [33,]; static __SHIFTED : [u8; 1usize] = + [8,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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() }, ruleset : { let rules : & - 'static [u8] = & [33,]; let shifted : & 'static [u8] = & [9,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [33,]; static __SHIFTED : [u8; 1usize] = [9,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::rparen, ::rusty_lr_core::parser::state::ShiftTarget::new(56, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [34,]; let shifted : & 'static - [u8] = & [8,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [34,]; static __SHIFTED : [u8; 1usize] = + [8,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_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() }, ruleset : { let rules : & - 'static [u8] = & [34,]; let shifted : & 'static [u8] = & [9,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [34,]; static __SHIFTED : [u8; 1usize] = [9,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::rparen, ::rusty_lr_core::parser::state::ShiftTarget::new(58, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [36,]; let shifted : & 'static - [u8] = & [8,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [36,]; static __SHIFTED : [u8; 1usize] = + [8,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_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() }, ruleset : { let rules : & - 'static [u8] = & [36,]; let shifted : & 'static [u8] = & [9,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [36,]; static __SHIFTED : [u8; 1usize] = [9,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::rparen, ::rusty_lr_core::parser::state::ShiftTarget::new(60, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [35,]; let shifted : & 'static - [u8] = & [7,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [35,]; static __SHIFTED : [u8; 1usize] = + [7,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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() }, ruleset : { let rules : & - 'static [u8] = & [35,]; let shifted : & 'static [u8] = & [8,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [35,]; static __SHIFTED : [u8; 1usize] = [8,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::rparen, ::rusty_lr_core::parser::state::ShiftTarget::new(62, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [32,]; let shifted : & 'static - [u8] = & [7,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [32,]; static __SHIFTED : [u8; 1usize] = + [7,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_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() }, ruleset : { let rules : & - 'static [u8] = & [32,]; let shifted : & 'static [u8] = & [8,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [32,]; static __SHIFTED : [u8; 1usize] = [8,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8319,30 +8373,29 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(38, true)),], 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() }, 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() } }, + .extend(__RUSTYLR_TSET11.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 7usize] = [12, 22, 23, 24, 25, 27, 31,]; static __SHIFTED : [u8; + 7usize] = [3, 1, 1, 1, 1, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(65, false)), (GrammarTerminalClasses::pipe, ::rusty_lr_core::parser::state::ShiftTarget::new(66, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - 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 : + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 2usize] = [0, 3,]; static __SHIFTED : [u8; 2usize] = + [4, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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() }, ruleset : { let rules : & - 'static [u8] = & [0,]; let shifted : & 'static [u8] = & [5,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + .extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [0,]; static __SHIFTED : [u8; 1usize] = [5,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8371,30 +8424,30 @@ impl GrammarParser { (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![81]; __reduce_map.extend(__rustylr_tset1.iter().map(| term | (* term, + vec![81]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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, 78, 79, 80, 81,]; 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() } }, + static __RULES : [u8; 26usize] = [3, 5, 11, 12, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 78, 79, 80, 81,]; static + __SHIFTED : [u8; 26usize] = [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![], 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() }, ruleset : { let rules : & - 'static [u8] = & [3,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + .extend(__RUSTYLR_TSET13.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [3,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![78]; - __reduce_map.extend(__rustylr_tset11.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET11.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [78,]; let shifted : & 'static [u8] = & [1,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [78,]; static __SHIFTED : [u8; 1usize] = + [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8412,12 +8465,12 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(38, true)),], 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() }, 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() } }, + .extend(__RUSTYLR_TSET11.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 7usize] = [11, 22, 23, 24, 25, 27, 31,]; static __SHIFTED : [u8; + 7usize] = [1, 1, 1, 1, 1, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(5, true)), @@ -8438,21 +8491,21 @@ impl GrammarParser { (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![80]; __reduce_map.extend(__rustylr_tset1.iter().map(| term | (* term, + vec![80]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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, 79, 80,]; 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) | { + static __RULES : [u8; 22usize] = [11, 12, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 79, 80,]; static __SHIFTED : [u8; + 22usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![79]; - __reduce_map.extend(__rustylr_tset11.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET11.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [79,]; let shifted : & 'static [u8] = & [2,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [79,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8465,11 +8518,11 @@ impl GrammarParser { (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![85]; __reduce_map.extend(__rustylr_tset14.iter().map(| term | (* term, + vec![85]; __reduce_map.extend(__RUSTYLR_TSET14.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [5, 6, 7, 8, 9, 10, 82, 83, 84, 85,]; let - shifted : & 'static [u8] = & [1, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 10usize] = [5, 6, 7, 8, 9, 10, 82, 83, 84, 85,]; static + __SHIFTED : [u8; 10usize] = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8479,10 +8532,9 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(79, true)), (GrammarTerminalClasses::error, ::rusty_lr_core::parser::state::ShiftTarget::new(82, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - 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(| (& + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 5usize] = [6, 7, 8, 9, 10,]; static __SHIFTED : [u8; + 5usize] = [1, 1, 1, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8493,90 +8545,92 @@ impl GrammarParser { (GrammarTerminalClasses::error, ::rusty_lr_core::parser::state::ShiftTarget::new(77, true)),], 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() }, 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::parser::state::ShiftTarget::new(78, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 4usize] = [6, 7, 39, + 40,]; static __SHIFTED : [u8; 4usize] = [2, 2, 0, 0,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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_map.extend(__RUSTYLR_TSET15.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [39,]; let shifted : & 'static [u8] = & [1,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [39,]; static __SHIFTED : [u8; 1usize] = + [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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_map.extend(__RUSTYLR_TSET15.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [40,]; let shifted : & 'static [u8] = & [1,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [40,]; static __SHIFTED : [u8; 1usize] = + [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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()))); - __reduce_map.into_iter().collect() }, 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() } }, + .extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 1usize] = [7,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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()))); - __reduce_map.into_iter().collect() }, 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() } }, + .extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 1usize] = [6,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::literal, ::rusty_lr_core::parser::state::ShiftTarget::new(80, true)), (GrammarTerminalClasses::error, ::rusty_lr_core::parser::state::ShiftTarget::new(81, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - 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 : + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 2usize] = [8, 9,]; static __SHIFTED : [u8; 2usize] = + [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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()))); - __reduce_map.into_iter().collect() }, 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() } }, + .extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 1usize] = [8,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![9]; __reduce_map - .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, 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() } }, + .extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 1usize] = [9,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![10]; - __reduce_map.extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : & - 'static [u8] = & [10,]; let shifted : & 'static [u8] = & [2,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [10,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], 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() }, ruleset : { let rules : & - 'static [u8] = & [82,]; let shifted : & 'static [u8] = & [1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [82,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8585,19 +8639,19 @@ impl GrammarParser { 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![84]; __reduce_map.extend(__rustylr_tset14.iter().map(| term | (* term, + vec![84]; __reduce_map.extend(__RUSTYLR_TSET14.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [6, 7, 8, 9, 10, 83, 84,]; let shifted : & - 'static [u8] = & [0, 0, 0, 0, 0, 1, 1,]; rules.iter().zip(shifted.iter()) + static __RULES : [u8; 7usize] = [6, 7, 8, 9, 10, 83, 84,]; static __SHIFTED : + [u8; 7usize] = [0, 0, 0, 0, 0, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()) .map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : & - 'static [u8] = & [83,]; let shifted : & 'static [u8] = & [2,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [83,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8606,37 +8660,37 @@ impl GrammarParser { 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, + vec![38]; __reduce_map.extend(__RUSTYLR_TSET13.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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 : + static __RULES : [u8; 3usize] = [5, 37, 38,]; static __SHIFTED : [u8; 3usize] + = [2, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) + | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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_map.extend(__RUSTYLR_TSET13.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [37,]; let shifted : & 'static [u8] = & [1,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [37,]; static __SHIFTED : [u8; 1usize] = + [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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() }, ruleset : { let rules : & - 'static [u8] = & [5,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + .extend(__RUSTYLR_TSET13.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [5,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![4]; __reduce_map - .extend(__rustylr_tset13.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : & - 'static [u8] = & [4,]; let shifted : & 'static [u8] = & [1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + .extend(__RUSTYLR_TSET13.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [4,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8674,13 +8728,12 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(166, true)), (GrammarTerminalClasses::error, ::rusty_lr_core::parser::state::ShiftTarget::new(170, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [41, 42, 43, 44, 45, 46, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, - 68, 69, 70, 71, 72, 73, 74,]; 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) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 34usize] = [41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74,]; static __SHIFTED : [u8; 34usize] = [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 : @@ -8693,38 +8746,36 @@ impl GrammarParser { 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() }, ruleset : { let rules : & 'static [u8] = & [39, 40, - 50, 51, 143, 144,]; let shifted : & 'static [u8] = & [0, 0, 2, 2, 0, 0,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::parser::state::ShiftTarget::new(95, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 6usize] = [39, 40, 50, + 51, 143, 144,]; static __SHIFTED : [u8; 6usize] = [0, 0, 2, 2, 0, 0,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(93, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [51,]; let shifted : & 'static - [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [51,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [51,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [51,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![143]; - __reduce_map.extend(__rustylr_tset16.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET16.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [143,]; let shifted : & 'static [u8] = & [1,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [143,]; static __SHIFTED : [u8; 1usize] = + [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8735,29 +8786,28 @@ impl GrammarParser { (GrammarTerminalClasses::literal, ::rusty_lr_core::parser::state::ShiftTarget::new(76, true)),], 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() }, ruleset : { let rules : & 'static [u8] = & [39, 40, - 50, 144,]; let shifted : & 'static [u8] = & [0, 0, 3, 1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::parser::state::ShiftTarget::new(97, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 4usize] = [39, 40, 50, + 144,]; static __SHIFTED : [u8; 4usize] = [0, 0, 3, 1,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![50]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [50,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [50,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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_map.extend(__RUSTYLR_TSET16.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [144,]; let shifted : & 'static [u8] = & [2,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [144,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8771,28 +8821,26 @@ impl GrammarParser { ::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() }, ruleset : { let rules : & 'static [u8] = & [39, 40, - 52, 53, 143, 144,]; let shifted : & 'static [u8] = & [0, 0, 2, 2, 0, 0,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + Default::default(), ruleset : { static __RULES : [u8; 6usize] = [39, 40, 52, + 53, 143, 144,]; static __SHIFTED : [u8; 6usize] = [0, 0, 2, 2, 0, 0,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(100, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [53,]; let shifted : & 'static - [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [53,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [53,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [53,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8803,20 +8851,19 @@ impl GrammarParser { (GrammarTerminalClasses::literal, ::rusty_lr_core::parser::state::ShiftTarget::new(76, true)),], 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() }, ruleset : { let rules : & 'static [u8] = & [39, 40, - 52, 144,]; let shifted : & 'static [u8] = & [0, 0, 3, 1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::parser::state::ShiftTarget::new(97, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 4usize] = [39, 40, 52, + 144,]; static __SHIFTED : [u8; 4usize] = [0, 0, 3, 1,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [52,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [52,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -8824,11 +8871,10 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(104, true)), (GrammarTerminalClasses::error, ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [41, 42, 43,]; let shifted : & - 'static [u8] = & [2, 2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, - & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 3usize] = [41, 42, 43,]; static __SHIFTED : [u8; + 3usize] = [2, 2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & + shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, @@ -8919,32 +8965,31 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), (GrammarNonTerminals::__TermSet26Plus27, ::rusty_lr_core::parser::state::ShiftTarget::new(107, true)),], reduce_map : - { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [41, 42, + Default::default(), ruleset : { static __RULES : [u8; 45usize] = [41, 42, 100, 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,]; let - shifted : & 'static [u8] = & [3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,]; static + __SHIFTED : [u8; 45usize] = [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) | { + 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![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![42]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [42,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [42,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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_map.extend(__RUSTYLR_TSET17.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [141,]; let shifted : & 'static [u8] = & [1,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [141,]; static __SHIFTED : [u8; 1usize] = + [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -9034,50 +9079,48 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], shift_goto_map_nonterm : vec![(GrammarNonTerminals::_TermSet26, ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], reduce_map : - { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [41, - 100, 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, 142,]; let shifted : & - 'static [u8] = & [4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; rules - .iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + Default::default(), ruleset : { static __RULES : [u8; 43usize] = [41, 100, + 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, 142,]; static __SHIFTED : + [u8; 43usize] = [4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![41]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [41,]; let shifted : & 'static [u8] = & [5,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [41,]; static __SHIFTED : [u8; 1usize] = + [5,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![142]; - __reduce_map.extend(__rustylr_tset17.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET17.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [142,]; let shifted : & 'static [u8] = & [2,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [142,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(111, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [43,]; let shifted : & 'static - [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [43,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [43,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [43,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -9085,46 +9128,43 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(113, true)), (GrammarTerminalClasses::error, ::rusty_lr_core::parser::state::ShiftTarget::new(115, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [44, 45,]; let shifted : & 'static - [u8] = & [2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) - | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 2usize] = [44, 45,]; static __SHIFTED : [u8; 2usize] = + [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(114, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [44,]; let shifted : & 'static - [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [44,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![44]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [44,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [44,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(116, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [45,]; let shifted : & 'static - [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![45]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [45,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -9216,23 +9256,22 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), (GrammarNonTerminals::__TermSet26Plus27, ::rusty_lr_core::parser::state::ShiftTarget::new(119, true)),], reduce_map : - { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [46, 47, + Default::default(), ruleset : { static __RULES : [u8; 45usize] = [46, 47, 100, 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,]; let - shifted : & 'static [u8] = & [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,]; static + __SHIFTED : [u8; 45usize] = [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) | { + 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![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![47]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [47,]; let shifted : & 'static [u8] = & [3,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [47,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -9322,23 +9361,22 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], shift_goto_map_nonterm : vec![(GrammarNonTerminals::_TermSet26, ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], reduce_map : - { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [46, - 100, 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, 142,]; 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; rules - .iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + Default::default(), ruleset : { static __RULES : [u8; 43usize] = [46, 100, + 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, 142,]; static __SHIFTED : + [u8; 43usize] = [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, 1,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![46]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [46,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -9430,23 +9468,22 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), (GrammarNonTerminals::__TermSet26Plus27, ::rusty_lr_core::parser::state::ShiftTarget::new(123, true)),], reduce_map : - { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [48, 49, + Default::default(), ruleset : { static __RULES : [u8; 45usize] = [48, 49, 100, 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,]; let - shifted : & 'static [u8] = & [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,]; static + __SHIFTED : [u8; 45usize] = [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) | { + 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![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![49]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [49,]; let shifted : & 'static [u8] = & [3,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [49,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -9536,23 +9573,22 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], shift_goto_map_nonterm : vec![(GrammarNonTerminals::_TermSet26, ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], reduce_map : - { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [48, - 100, 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, 142,]; 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; rules - .iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + Default::default(), ruleset : { static __RULES : [u8; 43usize] = [48, 100, + 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, 142,]; static __SHIFTED : + [u8; 43usize] = [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, 1,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![48]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [48,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [48,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -9644,23 +9680,22 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), (GrammarNonTerminals::__TermSet26Plus27, ::rusty_lr_core::parser::state::ShiftTarget::new(127, true)),], reduce_map : - { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [56, 57, + Default::default(), ruleset : { static __RULES : [u8; 45usize] = [56, 57, 100, 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,]; let - shifted : & 'static [u8] = & [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,]; static + __SHIFTED : [u8; 45usize] = [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) | { + 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![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![57]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [57,]; let shifted : & 'static [u8] = & [3,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [57,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -9750,23 +9785,22 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], shift_goto_map_nonterm : vec![(GrammarNonTerminals::_TermSet26, ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], reduce_map : - { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [56, - 100, 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, 142,]; 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; rules - .iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + Default::default(), ruleset : { static __RULES : [u8; 43usize] = [56, 100, + 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, 142,]; static __SHIFTED : + [u8; 43usize] = [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, 1,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![56]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [56,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [56,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -9858,23 +9892,22 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), (GrammarNonTerminals::__TermSet26Plus27, ::rusty_lr_core::parser::state::ShiftTarget::new(131, true)),], reduce_map : - { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [58, 59, + Default::default(), ruleset : { static __RULES : [u8; 45usize] = [58, 59, 100, 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,]; let - shifted : & 'static [u8] = & [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,]; static + __SHIFTED : [u8; 45usize] = [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) | { + 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![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![59]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [59,]; let shifted : & 'static [u8] = & [3,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [59,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -9964,23 +9997,22 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], shift_goto_map_nonterm : vec![(GrammarNonTerminals::_TermSet26, ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], reduce_map : - { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [58, - 100, 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, 142,]; 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; rules - .iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + Default::default(), ruleset : { static __RULES : [u8; 43usize] = [58, 100, + 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, 142,]; static __SHIFTED : + [u8; 43usize] = [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, 1,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![58]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [58,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [58,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -9988,37 +10020,35 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(134, false)), (GrammarTerminalClasses::error, ::rusty_lr_core::parser::state::ShiftTarget::new(135, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [62, 63,]; let shifted : & 'static - [u8] = & [2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) - | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 2usize] = [62, 63,]; static __SHIFTED : [u8; 2usize] = + [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![62]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [62,]; let shifted : & 'static [u8] = & [3,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [62,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(136, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [63,]; let shifted : & 'static - [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [63,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![63]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [63,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [63,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -10026,37 +10056,35 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(138, false)), (GrammarTerminalClasses::error, ::rusty_lr_core::parser::state::ShiftTarget::new(139, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [60, 61,]; let shifted : & 'static - [u8] = & [2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) - | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 2usize] = [60, 61,]; static __SHIFTED : [u8; 2usize] = + [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![60]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [60,]; let shifted : & 'static [u8] = & [3,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [60,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(140, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [61,]; let shifted : & 'static - [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [61,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![61]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [61,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [61,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -10070,28 +10098,26 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(94, true)), (GrammarNonTerminals::_IdentOrLiteralPlus28, ::rusty_lr_core::parser::state::ShiftTarget::new(144, true)),], reduce_map : - { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [39, 40, - 54, 55, 143, 144,]; let shifted : & 'static [u8] = & [0, 0, 2, 2, 0, 0,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + Default::default(), ruleset : { static __RULES : [u8; 6usize] = [39, 40, 54, + 55, 143, 144,]; static __SHIFTED : [u8; 6usize] = [0, 0, 2, 2, 0, 0,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(143, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [55,]; let shifted : & 'static - [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [55,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![55]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [55,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [55,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -10102,20 +10128,19 @@ impl GrammarParser { (GrammarTerminalClasses::literal, ::rusty_lr_core::parser::state::ShiftTarget::new(76, true)),], 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() }, ruleset : { let rules : & 'static [u8] = & [39, 40, - 54, 144,]; let shifted : & 'static [u8] = & [0, 0, 3, 1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::parser::state::ShiftTarget::new(97, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 4usize] = [39, 40, 54, + 144,]; static __SHIFTED : [u8; 4usize] = [0, 0, 3, 1,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], 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_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [54,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [54,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -10123,37 +10148,35 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(147, false)), (GrammarTerminalClasses::error, ::rusty_lr_core::parser::state::ShiftTarget::new(148, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [64, 65,]; let shifted : & 'static - [u8] = & [2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) - | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 2usize] = [64, 65,]; static __SHIFTED : [u8; 2usize] = + [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![64]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [64,]; let shifted : & 'static [u8] = & [3,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [64,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(149, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [65,]; let shifted : & 'static - [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [65,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![65]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [65,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [65,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -10161,37 +10184,35 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(151, false)), (GrammarTerminalClasses::error, ::rusty_lr_core::parser::state::ShiftTarget::new(152, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [66, 67,]; let shifted : & 'static - [u8] = & [2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) - | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 2usize] = [66, 67,]; static __SHIFTED : [u8; 2usize] = + [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![66]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [66,]; let shifted : & 'static [u8] = & [3,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [66,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(153, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [67,]; let shifted : & 'static - [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [67,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![67]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [67,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [67,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -10204,37 +10225,36 @@ impl GrammarParser { (GrammarNonTerminals::_identStar30, ::rusty_lr_core::parser::state::ShiftTarget::new(160, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules - = vec![148]; __reduce_map.extend(__rustylr_tset18.iter().map(| term | (* + = vec![148]; __reduce_map.extend(__RUSTYLR_TSET18.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset - : { let rules : & 'static [u8] = & [68, 69, 145, 146, 147, 148,]; 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() } }, + : { static __RULES : [u8; 6usize] = [68, 69, 145, 146, 147, 148,]; static + __SHIFTED : [u8; 6usize] = [2, 2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED + .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef + { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![145]; - __reduce_map.extend(__rustylr_tset19.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET19.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [145,]; let shifted : & 'static [u8] = & [1,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [145,]; static __SHIFTED : [u8; 1usize] = + [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(157, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [69,]; let shifted : & 'static - [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [69,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![69]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [69,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [69,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -10242,37 +10262,36 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(159, true)),], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![147]; __reduce_map - .extend(__rustylr_tset18.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : & - 'static [u8] = & [146, 147,]; let shifted : & 'static [u8] = & [1, 1,]; rules - .iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + .extend(__RUSTYLR_TSET18.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 2usize] = [146, 147,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![146]; - __reduce_map.extend(__rustylr_tset19.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET19.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [146,]; let shifted : & 'static [u8] = & [2,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [146,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(161, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [68,]; let shifted : & 'static - [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [68,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![68]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [68,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [68,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -10364,23 +10383,22 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), (GrammarNonTerminals::__TermSet26Plus27, ::rusty_lr_core::parser::state::ShiftTarget::new(164, true)),], reduce_map : - { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [70, 71, + Default::default(), ruleset : { static __RULES : [u8; 45usize] = [70, 71, 100, 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,]; let - shifted : & 'static [u8] = & [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,]; static + __SHIFTED : [u8; 45usize] = [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) | { + 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![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![71]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [71,]; let shifted : & 'static [u8] = & [3,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [71,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -10470,23 +10488,22 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], shift_goto_map_nonterm : vec![(GrammarNonTerminals::_TermSet26, ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], reduce_map : - { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [70, - 100, 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, 142,]; 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; rules - .iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + Default::default(), ruleset : { static __RULES : [u8; 43usize] = [70, 100, + 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, 142,]; static __SHIFTED : + [u8; 43usize] = [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, 1,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![70]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [70,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [70,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -10578,23 +10595,22 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), (GrammarNonTerminals::__TermSet26Plus27, ::rusty_lr_core::parser::state::ShiftTarget::new(168, true)),], reduce_map : - { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [72, 73, + Default::default(), ruleset : { static __RULES : [u8; 45usize] = [72, 73, 100, 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,]; let - shifted : & 'static [u8] = & [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,]; static + __SHIFTED : [u8; 45usize] = [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) | { + 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![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![73]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [73,]; let shifted : & 'static [u8] = & [3,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [73,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -10684,50 +10700,48 @@ impl GrammarParser { ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], shift_goto_map_nonterm : vec![(GrammarNonTerminals::_TermSet26, ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], reduce_map : - { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [72, - 100, 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, 142,]; 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; rules - .iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + Default::default(), ruleset : { static __RULES : [u8; 43usize] = [72, 100, + 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, 142,]; static __SHIFTED : + [u8; 43usize] = [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, 1,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![72]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [72,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [72,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::semicolon, ::rusty_lr_core::parser::state::ShiftTarget::new(171, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [74,]; let shifted : & 'static - [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [74,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![74]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [74,]; let shifted : & 'static [u8] = & [3,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [74,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![75]; - __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [75,]; let shifted : & 'static [u8] = & [1,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [75,]; static __SHIFTED : [u8; 1usize] = + [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : @@ -10744,41 +10758,39 @@ impl GrammarParser { (GrammarNonTerminals::_GrammarLinePlus31, ::rusty_lr_core::parser::state::ShiftTarget::new(174, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules - = vec![149]; __reduce_map.extend(__rustylr_tset20.iter().map(| term | (* + = vec![149]; __reduce_map.extend(__RUSTYLR_TSET20.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset - : { let rules : & 'static [u8] = & [0, 41, 42, 43, 44, 45, 46, 47, 48, 49, + : { static __RULES : [u8; 41usize] = [0, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, - 69, 70, 71, 72, 73, 74, 75, 76, 149, 149, 150, 150,]; 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, 1, 0, 1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + 69, 70, 71, 72, 73, 74, 75, 76, 149, 149, 150, 150,]; static __SHIFTED : [u8; + 41usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![150]; - __reduce_map.extend(__rustylr_tset20.iter().map(| term | (* term, + __reduce_map.extend(__RUSTYLR_TSET20.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [150,]; let shifted : & 'static [u8] = & [2,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [150,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::eof, ::rusty_lr_core::parser::state::ShiftTarget::new(176, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [151,]; let shifted : & 'static - [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [151,]; static __SHIFTED : [u8; 1usize] = + [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : - vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map - = std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [151,]; 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() } }, + vec![], shift_goto_map_nonterm : vec![], reduce_map : Default::default(), + ruleset : { static __RULES : [u8; 1usize] = [151,]; static __SHIFTED : [u8; + 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & + shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, + shifted : shifted as usize, } }).collect() } }, ]; let states: Vec = states .into_iter() diff --git a/scripts/diff/calculator.rs b/scripts/diff/calculator.rs index a2fd1f7..a50d2cd 100644 --- a/scripts/diff/calculator.rs +++ b/scripts/diff/calculator.rs @@ -685,15 +685,20 @@ impl EParser { vec![::rusty_lr::Token::NonTerm(ENonTerminals::E), ::rusty_lr::Token::Term(ETerminalClasses::eof),], precedence : None, }, ]; - let __rustylr_tset0: Vec = vec![ - ETerminalClasses::plus, ETerminalClasses::star, ETerminalClasses::rparen, - ETerminalClasses::eof + static __RUSTYLR_TSET0: [ETerminalClasses; 4usize] = [ + ETerminalClasses::plus, + ETerminalClasses::star, + ETerminalClasses::rparen, + ETerminalClasses::eof, ]; - let __rustylr_tset2: Vec = vec![ - ETerminalClasses::plus, ETerminalClasses::rparen, ETerminalClasses::eof + static __RUSTYLR_TSET2: [ETerminalClasses; 3usize] = [ + ETerminalClasses::plus, + ETerminalClasses::rparen, + ETerminalClasses::eof, ]; - let __rustylr_tset1: Vec = vec![ - ETerminalClasses::rparen, ETerminalClasses::eof + static __RUSTYLR_TSET1: [ETerminalClasses; 2usize] = [ + ETerminalClasses::rparen, + ETerminalClasses::eof, ]; let states: Vec< ::rusty_lr::parser::state::IntermediateState< @@ -711,19 +716,18 @@ impl EParser { ::rusty_lr::parser::state::ShiftTarget::new(3, true)), (ENonTerminals::M, ::rusty_lr::parser::state::ShiftTarget::new(6, true)), (ENonTerminals::P, ::rusty_lr::parser::state::ShiftTarget::new(6, true)), (ENonTerminals::E, - ::rusty_lr::parser::state::ShiftTarget::new(11, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [0, 1, - 2, 3, 4, 5, 6, 7,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 0, - 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::parser::state::ShiftTarget::new(11, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 8usize] = [0, 1, 2, 3, + 4, 5, 6, 7,]; static __SHIFTED : [u8; 8usize] = [0, 0, 0, 0, 0, 0, 0, 0,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![4]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term, + vec![4]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [4,]; let shifted : & 'static [u8] = & [1,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [4,]; static __SHIFTED : [u8; 1usize] = [1,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::num, @@ -733,21 +737,20 @@ impl EParser { ::rusty_lr::parser::state::ShiftTarget::new(3, true)), (ENonTerminals::M, ::rusty_lr::parser::state::ShiftTarget::new(6, true)), (ENonTerminals::P, ::rusty_lr::parser::state::ShiftTarget::new(6, true)), (ENonTerminals::E, - ::rusty_lr::parser::state::ShiftTarget::new(9, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [0, 1, - 2, 3, 4, 5, 5, 6,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 1, - 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::parser::state::ShiftTarget::new(9, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 8usize] = [0, 1, 2, 3, + 4, 5, 5, 6,]; static __SHIFTED : [u8; 8usize] = [0, 0, 0, 0, 0, 0, 1, 0,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::plus, ::rusty_lr::parser::state::ShiftTarget::new(4, true)),], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![6]; __reduce_map - .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8] - = & [0, 6,]; let shifted : & 'static [u8] = & [1, 1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + .extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 2usize] = [0, 6,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::num, @@ -756,29 +759,28 @@ impl EParser { false)),], shift_goto_map_nonterm : vec![(ENonTerminals::A, ::rusty_lr::parser::state::ShiftTarget::new(5, true)), (ENonTerminals::M, ::rusty_lr::parser::state::ShiftTarget::new(6, true)), (ENonTerminals::P, - ::rusty_lr::parser::state::ShiftTarget::new(6, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [0, 0, - 1, 2, 3, 4, 5,]; let shifted : & 'static [u8] = & [0, 2, 0, 0, 0, 0, 0,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::parser::state::ShiftTarget::new(6, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 7usize] = [0, 0, 1, 2, + 3, 4, 5,]; static __SHIFTED : [u8; 7usize] = [0, 2, 0, 0, 0, 0, 0,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![0]; __reduce_map.extend(__rustylr_tset2.iter().map(| term | (* term, + vec![0]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [0,]; let shifted : & 'static [u8] = & [3,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [0,]; static __SHIFTED : [u8; 1usize] = [3,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::star, ::rusty_lr::parser::state::ShiftTarget::new(7, false)),], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![1]; __reduce_map - .extend(__rustylr_tset2.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8] - = & [1, 2,]; let shifted : & 'static [u8] = & [1, 1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + .extend(__RUSTYLR_TSET2.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 2usize] = [1, 2,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::num, @@ -786,49 +788,45 @@ impl EParser { (ETerminalClasses::lparen, ::rusty_lr::parser::state::ShiftTarget::new(2, false)),], shift_goto_map_nonterm : vec![(ENonTerminals::M, ::rusty_lr::parser::state::ShiftTarget::new(8, true)), (ENonTerminals::P, - ::rusty_lr::parser::state::ShiftTarget::new(8, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [2, 2, - 3, 4, 5,]; let shifted : & 'static [u8] = & [0, 2, 0, 0, 0,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::parser::state::ShiftTarget::new(8, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 5usize] = [2, 2, 3, 4, + 5,]; static __SHIFTED : [u8; 5usize] = [0, 2, 0, 0, 0,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![2]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term, + vec![2]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [2,]; let shifted : & 'static [u8] = & [3,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [2,]; static __SHIFTED : [u8; 1usize] = [3,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::rparen, ::rusty_lr::parser::state::ShiftTarget::new(10, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [5,]; let shifted : & 'static [u8] - = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [5,]; static __SHIFTED : [u8; 1usize] = [2,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![5]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term, + vec![5]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [5,]; let shifted : & 'static [u8] = & [3,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [5,]; static __SHIFTED : [u8; 1usize] = [3,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::eof, ::rusty_lr::parser::state::ShiftTarget::new(12, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [7,]; let shifted : & 'static [u8] - = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [7,]; static __SHIFTED : [u8; 1usize] = [1,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [7,]; - let shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| + shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 1usize] = [7,]; static + __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ]; diff --git a/scripts/diff/calculator_u8.rs b/scripts/diff/calculator_u8.rs index c6d4715..36d6ae9 100644 --- a/scripts/diff/calculator_u8.rs +++ b/scripts/diff/calculator_u8.rs @@ -950,40 +950,57 @@ impl EParser { vec![::rusty_lr::Token::NonTerm(ENonTerminals::E), ::rusty_lr::Token::Term(ETerminalClasses::eof),], precedence : None, }, ]; - let __rustylr_tset4: Vec = vec![ - ETerminalClasses::TermClass0, ETerminalClasses::TermClass2, - ETerminalClasses::TermClass3, ETerminalClasses::TermClass4, - ETerminalClasses::TermClass5, ETerminalClasses::TermClass6, - ETerminalClasses::TermClass7, ETerminalClasses::TermClass8, - ETerminalClasses::eof + static __RUSTYLR_TSET4: [ETerminalClasses; 9usize] = [ + ETerminalClasses::TermClass0, + ETerminalClasses::TermClass2, + ETerminalClasses::TermClass3, + ETerminalClasses::TermClass4, + ETerminalClasses::TermClass5, + ETerminalClasses::TermClass6, + ETerminalClasses::TermClass7, + ETerminalClasses::TermClass8, + ETerminalClasses::eof, ]; - let __rustylr_tset6: Vec = vec![ - ETerminalClasses::TermClass0, ETerminalClasses::TermClass3, - ETerminalClasses::TermClass5, ETerminalClasses::TermClass6, - ETerminalClasses::TermClass7, ETerminalClasses::TermClass8, - ETerminalClasses::eof + static __RUSTYLR_TSET6: [ETerminalClasses; 7usize] = [ + ETerminalClasses::TermClass0, + ETerminalClasses::TermClass3, + ETerminalClasses::TermClass5, + ETerminalClasses::TermClass6, + ETerminalClasses::TermClass7, + ETerminalClasses::TermClass8, + ETerminalClasses::eof, ]; - let __rustylr_tset3: Vec = vec![ - ETerminalClasses::TermClass2, ETerminalClasses::TermClass3, - ETerminalClasses::TermClass4, ETerminalClasses::TermClass5, - ETerminalClasses::TermClass6, ETerminalClasses::TermClass7, - ETerminalClasses::TermClass8, ETerminalClasses::eof + static __RUSTYLR_TSET3: [ETerminalClasses; 8usize] = [ + ETerminalClasses::TermClass2, + ETerminalClasses::TermClass3, + ETerminalClasses::TermClass4, + ETerminalClasses::TermClass5, + ETerminalClasses::TermClass6, + ETerminalClasses::TermClass7, + ETerminalClasses::TermClass8, + ETerminalClasses::eof, ]; - let __rustylr_tset0: Vec = vec![ - ETerminalClasses::TermClass2, ETerminalClasses::TermClass4, - ETerminalClasses::TermClass5, ETerminalClasses::TermClass6 + static __RUSTYLR_TSET0: [ETerminalClasses; 4usize] = [ + ETerminalClasses::TermClass2, + ETerminalClasses::TermClass4, + ETerminalClasses::TermClass5, + ETerminalClasses::TermClass6, ]; - let __rustylr_tset5: Vec = vec![ - ETerminalClasses::TermClass3, ETerminalClasses::TermClass7, - ETerminalClasses::TermClass8 + static __RUSTYLR_TSET5: [ETerminalClasses; 3usize] = [ + ETerminalClasses::TermClass3, + ETerminalClasses::TermClass7, + ETerminalClasses::TermClass8, ]; - let __rustylr_tset1: Vec = vec![ - ETerminalClasses::TermClass3, ETerminalClasses::TermClass7, - ETerminalClasses::TermClass8, ETerminalClasses::eof + static __RUSTYLR_TSET1: [ETerminalClasses; 4usize] = [ + ETerminalClasses::TermClass3, + ETerminalClasses::TermClass7, + ETerminalClasses::TermClass8, + ETerminalClasses::eof, ]; - let __rustylr_tset2: Vec = vec![ - ETerminalClasses::TermClass7, ETerminalClasses::TermClass8, - ETerminalClasses::eof + static __RUSTYLR_TSET2: [ETerminalClasses; 3usize] = [ + ETerminalClasses::TermClass7, + ETerminalClasses::TermClass8, + ETerminalClasses::eof, ]; let states: Vec< ::rusty_lr::parser::state::IntermediateState< @@ -1005,19 +1022,19 @@ impl EParser { (ENonTerminals::__Terminal32Star7, ::rusty_lr::parser::state::ShiftTarget::new(8, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![13]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term, + vec![13]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [2, 3, 4, 5, 6, 7, 10, 11, 12, 13, 16,]; let - shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 11usize] = [2, 3, 4, 5, 6, 7, 10, 11, 12, 13, 16,]; + static __SHIFTED : [u8; 11usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![3]; __reduce_map.extend(__rustylr_tset1.iter().map(| term | (* term, + vec![3]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [3,]; let shifted : & 'static [u8] = & [1,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [3,]; static __SHIFTED : [u8; 1usize] = [1,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass7, @@ -1026,17 +1043,15 @@ impl EParser { true)), (ETerminalClasses::eof, ::rusty_lr::parser::state::ShiftTarget::new(3, true)),], shift_goto_map_nonterm : vec![(ENonTerminals::Op, - ::rusty_lr::parser::state::ShiftTarget::new(4, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [5, 8, - 9, 16,]; let shifted : & 'static [u8] = & [1, 0, 0, 1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::parser::state::ShiftTarget::new(4, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 4usize] = [5, 8, 9, + 16,]; static __SHIFTED : [u8; 4usize] = [1, 0, 0, 1,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [16,]; - let shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| + shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 1usize] = [16,]; static + __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : @@ -1051,11 +1066,11 @@ impl EParser { (ENonTerminals::__Terminal32Star7, ::rusty_lr::parser::state::ShiftTarget::new(8, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![13]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term, + vec![13]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [2, 3, 4, 5, 5, 6, 7, 10, 11, 12, 13,]; let - shifted : & 'static [u8] = & [0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 11usize] = [2, 3, 4, 5, 5, 6, 7, 10, 11, 12, 13,]; + static __SHIFTED : [u8; 11usize] = [0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass7, @@ -1064,28 +1079,29 @@ impl EParser { true)),], shift_goto_map_nonterm : vec![(ENonTerminals::Op, ::rusty_lr::parser::state::ShiftTarget::new(4, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![5]; __reduce_map.extend(__rustylr_tset2.iter().map(| term | (* term, + vec![5]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [5, 5, 8, 9,]; let shifted : & 'static [u8] = - & [1, 3, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | - { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted - as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(ETerminalClasses::TermClass0, + static __RULES : [u8; 4usize] = [5, 5, 8, 9,]; static __SHIFTED : [u8; + 4usize] = [1, 3, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, + & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, + shifted : shifted as usize, } }).collect() } }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(ETerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(7, false)),], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![12]; __reduce_map - .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8] - = & [11, 12,]; let shifted : & 'static [u8] = & [1, 1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + .extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 2usize] = [11, 12,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![11]; __reduce_map.extend(__rustylr_tset4.iter().map(| term | (* term, + vec![11]; __reduce_map.extend(__RUSTYLR_TSET4.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [11,]; let shifted : & 'static [u8] = & [2,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [11,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass2, @@ -1099,12 +1115,11 @@ impl EParser { shift_goto_map_nonterm : vec![(ENonTerminals::Digit, ::rusty_lr::parser::state::ShiftTarget::new(19, true)), (ENonTerminals::_DigitPlus9, ::rusty_lr::parser::state::ShiftTarget::new(20, - true)),], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [0, 1, 2, 4, 6, 14, 15,]; let - shifted : & 'static [u8] = & [0, 0, 1, 1, 1, 0, 0,]; rules.iter().zip(shifted - .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, + true)),], reduce_map : Default::default(), ruleset : { static __RULES : [u8; + 7usize] = [0, 1, 2, 4, 6, 14, 15,]; static __SHIFTED : [u8; 7usize] = [0, 0, + 1, 1, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & + shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted + : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(6, false)),], @@ -1117,11 +1132,11 @@ impl EParser { (ENonTerminals::__Terminal32Star7, ::rusty_lr::parser::state::ShiftTarget::new(15, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![13]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term, + vec![13]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [2, 3, 4, 4, 5, 6, 7, 10, 11, 12, 13,]; let - shifted : & 'static [u8] = & [0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 11usize] = [2, 3, 4, 4, 5, 6, 7, 10, 11, 12, 13,]; + static __SHIFTED : [u8; 11usize] = [0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass3, @@ -1131,11 +1146,10 @@ impl EParser { (ETerminalClasses::TermClass8, ::rusty_lr::parser::state::ShiftTarget::new(13, true)),], shift_goto_map_nonterm : vec![(ENonTerminals::Op, - ::rusty_lr::parser::state::ShiftTarget::new(13, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [4, 5, - 8, 9,]; let shifted : & 'static [u8] = & [3, 1, 0, 0,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::parser::state::ShiftTarget::new(13, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 4usize] = [4, 5, 8, + 9,]; static __SHIFTED : [u8; 4usize] = [3, 1, 0, 0,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass0, @@ -1145,22 +1159,22 @@ impl EParser { (ENonTerminals::__Terminal32Star7, ::rusty_lr::parser::state::ShiftTarget::new(12, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![13]; __reduce_map.extend(__rustylr_tset1.iter().map(| term | (* term, + vec![13]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [4, 10, 11, 12, 13,]; let shifted : & 'static - [u8] = & [4, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [4, 10, 11, 12, 13,]; static __SHIFTED : [u8; + 5usize] = [4, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& + rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, + shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![4]; __reduce_map - .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8] - = & [4,]; let shifted : & 'static [u8] = & [5,]; rules.iter().zip(shifted - .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(ETerminalClasses::TermClass0, + .extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 1usize] = [4,]; static __SHIFTED : [u8; 1usize] = [5,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(ETerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(6, false)),], shift_goto_map_nonterm : vec![(ENonTerminals::Number, ::rusty_lr::parser::state::ShiftTarget::new(1, true)), (ENonTerminals::P, @@ -1171,11 +1185,11 @@ impl EParser { (ENonTerminals::__Terminal32Star7, ::rusty_lr::parser::state::ShiftTarget::new(15, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![13]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term, + vec![13]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [2, 3, 4, 5, 5, 6, 7, 10, 11, 12, 13,]; let - shifted : & 'static [u8] = & [0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 11usize] = [2, 3, 4, 5, 5, 6, 7, 10, 11, 12, 13,]; + static __SHIFTED : [u8; 11usize] = [0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass7, @@ -1185,13 +1199,14 @@ impl EParser { shift_goto_map_nonterm : vec![(ENonTerminals::Op, ::rusty_lr::parser::state::ShiftTarget::new(13, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![5]; __reduce_map.extend(__rustylr_tset5.iter().map(| term | (* term, + vec![5]; __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [5, 5, 8, 9,]; let shifted : & 'static [u8] = - & [1, 3, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | - { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted - as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { - shift_goto_map_term : vec![(ETerminalClasses::TermClass2, + static __RULES : [u8; 4usize] = [5, 5, 8, 9,]; static __SHIFTED : [u8; + 4usize] = [1, 3, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, + & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, + shifted : shifted as usize, } }).collect() } }, + ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : + vec![(ETerminalClasses::TermClass2, ::rusty_lr::parser::state::ShiftTarget::new(9, false)), (ETerminalClasses::TermClass4, ::rusty_lr::parser::state::ShiftTarget::new(16, false)), @@ -1202,12 +1217,11 @@ impl EParser { shift_goto_map_nonterm : vec![(ENonTerminals::Digit, ::rusty_lr::parser::state::ShiftTarget::new(19, true)), (ENonTerminals::_DigitPlus9, ::rusty_lr::parser::state::ShiftTarget::new(20, - true)),], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [0, 1, 2, 4, 6, 14, 15,]; let - shifted : & 'static [u8] = & [0, 0, 1, 1, 1, 0, 0,]; rules.iter().zip(shifted - .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, + true)),], reduce_map : Default::default(), ruleset : { static __RULES : [u8; + 7usize] = [0, 1, 2, 4, 6, 14, 15,]; static __SHIFTED : [u8; 7usize] = [0, 0, + 1, 1, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & + shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted + : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(6, false)),], @@ -1220,37 +1234,37 @@ impl EParser { (ENonTerminals::__Terminal32Star7, ::rusty_lr::parser::state::ShiftTarget::new(15, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![13]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term, + vec![13]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [2, 3, 4, 5, 6, 6, 7, 10, 11, 12, 13,]; let - shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 11usize] = [2, 3, 4, 5, 6, 6, 7, 10, 11, 12, 13,]; + static __SHIFTED : [u8; 11usize] = [0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![(ENonTerminals::Op, ::rusty_lr::parser::state::ShiftTarget::new(13, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![6]; __reduce_map - .extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8] - = & [5, 6,]; let shifted : & 'static [u8] = & [1, 3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + .extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 2usize] = [5, 6,]; static __SHIFTED : [u8; 2usize] = [1, 3,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![0]; __reduce_map.extend(__rustylr_tset6.iter().map(| term | (* term, + vec![0]; __reduce_map.extend(__RUSTYLR_TSET6.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [0,]; let shifted : & 'static [u8] = & [1,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [0,]; static __SHIFTED : [u8; 1usize] = [1,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![14]; __reduce_map.extend(__rustylr_tset6.iter().map(| term | (* term, + vec![14]; __reduce_map.extend(__RUSTYLR_TSET6.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [14,]; let shifted : & 'static [u8] = & [1,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [14,]; static __SHIFTED : [u8; 1usize] = + [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(ETerminalClasses::TermClass0, @@ -1266,30 +1280,30 @@ impl EParser { (ENonTerminals::__Terminal32Star7, ::rusty_lr::parser::state::ShiftTarget::new(22, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![13]; __reduce_map.extend(__rustylr_tset1.iter().map(| term | (* term, + vec![13]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [0, 1, 2, 10, 11, 12, 13, 15,]; let shifted : - & 'static [u8] = & [0, 0, 2, 0, 0, 0, 0, 1,]; rules.iter().zip(shifted - .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![15]; __reduce_map - .extend(__rustylr_tset6.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8] - = & [15,]; let shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted - .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![2]; __reduce_map - .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8] - = & [2,]; let shifted : & 'static [u8] = & [3,]; rules.iter().zip(shifted - .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(ETerminalClasses::TermClass0, + static __RULES : [u8; 8usize] = [0, 1, 2, 10, 11, 12, 13, 15,]; static + __SHIFTED : [u8; 8usize] = [0, 0, 2, 0, 0, 0, 0, 1,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![15]; __reduce_map.extend(__RUSTYLR_TSET6.iter().map(| term | (* term, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { + static __RULES : [u8; 1usize] = [15,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![2]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { + static __RULES : [u8; 1usize] = [2,]; static __SHIFTED : [u8; 1usize] = [3,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(ETerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(6, false)),], shift_goto_map_nonterm : vec![(ENonTerminals::Number, ::rusty_lr::parser::state::ShiftTarget::new(1, true)), (ENonTerminals::P, @@ -1300,21 +1314,21 @@ impl EParser { (ENonTerminals::__Terminal32Star7, ::rusty_lr::parser::state::ShiftTarget::new(8, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![13]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term, + vec![13]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [2, 3, 4, 5, 6, 6, 7, 10, 11, 12, 13,]; let - shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 11usize] = [2, 3, 4, 5, 6, 6, 7, 10, 11, 12, 13,]; + static __SHIFTED : [u8; 11usize] = [0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![(ENonTerminals::Op, ::rusty_lr::parser::state::ShiftTarget::new(4, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![6]; __reduce_map - .extend(__rustylr_tset2.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8] - = & [5, 6,]; let shifted : & 'static [u8] = & [1, 3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + .extend(__RUSTYLR_TSET2.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 2usize] = [5, 6,]; static __SHIFTED : [u8; 2usize] = [1, 3,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ]; diff --git a/scripts/diff/json.rs b/scripts/diff/json.rs index d4c9028..d556b2c 100644 --- a/scripts/diff/json.rs +++ b/scripts/diff/json.rs @@ -1799,136 +1799,205 @@ impl JsonParser { vec![::rusty_lr::Token::NonTerm(JsonNonTerminals::Json), ::rusty_lr::Token::Term(JsonTerminalClasses::eof),], precedence : None, }, ]; - let __rustylr_tset6: Vec = vec![ - JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1, - JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass13, - JsonTerminalClasses::TermClass18, JsonTerminalClasses::TermClass19, - JsonTerminalClasses::TermClass21 + static __RUSTYLR_TSET6: [JsonTerminalClasses; 7usize] = [ + JsonTerminalClasses::TermClass0, + JsonTerminalClasses::TermClass1, + JsonTerminalClasses::TermClass12, + JsonTerminalClasses::TermClass13, + JsonTerminalClasses::TermClass18, + JsonTerminalClasses::TermClass19, + JsonTerminalClasses::TermClass21, ]; - let __rustylr_tset4: Vec = vec![ - JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1, - JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass13, - JsonTerminalClasses::TermClass18, JsonTerminalClasses::TermClass19, - JsonTerminalClasses::TermClass21, JsonTerminalClasses::TermClass28, - JsonTerminalClasses::eof + static __RUSTYLR_TSET4: [JsonTerminalClasses; 9usize] = [ + JsonTerminalClasses::TermClass0, + JsonTerminalClasses::TermClass1, + JsonTerminalClasses::TermClass12, + JsonTerminalClasses::TermClass13, + JsonTerminalClasses::TermClass18, + JsonTerminalClasses::TermClass19, + JsonTerminalClasses::TermClass21, + JsonTerminalClasses::TermClass28, + JsonTerminalClasses::eof, ]; - let __rustylr_tset14: Vec = vec![ - JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1, - JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass13, - JsonTerminalClasses::TermClass18, JsonTerminalClasses::TermClass19, - JsonTerminalClasses::TermClass28 + static __RUSTYLR_TSET14: [JsonTerminalClasses; 7usize] = [ + JsonTerminalClasses::TermClass0, + JsonTerminalClasses::TermClass1, + JsonTerminalClasses::TermClass12, + JsonTerminalClasses::TermClass13, + JsonTerminalClasses::TermClass18, + JsonTerminalClasses::TermClass19, + JsonTerminalClasses::TermClass28, ]; - let __rustylr_tset11: Vec = vec![ - JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1, - JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass16, - JsonTerminalClasses::TermClass21, JsonTerminalClasses::TermClass28, - JsonTerminalClasses::eof + static __RUSTYLR_TSET11: [JsonTerminalClasses; 7usize] = [ + JsonTerminalClasses::TermClass0, + JsonTerminalClasses::TermClass1, + JsonTerminalClasses::TermClass12, + JsonTerminalClasses::TermClass16, + JsonTerminalClasses::TermClass21, + JsonTerminalClasses::TermClass28, + JsonTerminalClasses::eof, ]; - let __rustylr_tset21: Vec = vec![ - JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1, - JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass18, - JsonTerminalClasses::TermClass19, JsonTerminalClasses::TermClass21 + static __RUSTYLR_TSET21: [JsonTerminalClasses; 6usize] = [ + JsonTerminalClasses::TermClass0, + JsonTerminalClasses::TermClass1, + JsonTerminalClasses::TermClass12, + JsonTerminalClasses::TermClass18, + JsonTerminalClasses::TermClass19, + JsonTerminalClasses::TermClass21, ]; - let __rustylr_tset17: Vec = vec![ - JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1, - JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass18, - JsonTerminalClasses::TermClass19, JsonTerminalClasses::TermClass21, - JsonTerminalClasses::TermClass28, JsonTerminalClasses::eof + static __RUSTYLR_TSET17: [JsonTerminalClasses; 8usize] = [ + JsonTerminalClasses::TermClass0, + JsonTerminalClasses::TermClass1, + JsonTerminalClasses::TermClass12, + JsonTerminalClasses::TermClass18, + JsonTerminalClasses::TermClass19, + JsonTerminalClasses::TermClass21, + JsonTerminalClasses::TermClass28, + JsonTerminalClasses::eof, ]; - let __rustylr_tset16: Vec = vec![ - JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1, - JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass18, - JsonTerminalClasses::TermClass19, JsonTerminalClasses::TermClass28 + static __RUSTYLR_TSET16: [JsonTerminalClasses; 6usize] = [ + JsonTerminalClasses::TermClass0, + JsonTerminalClasses::TermClass1, + JsonTerminalClasses::TermClass12, + JsonTerminalClasses::TermClass18, + JsonTerminalClasses::TermClass19, + JsonTerminalClasses::TermClass28, ]; - let __rustylr_tset22: Vec = vec![ - JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1, - JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass21 + static __RUSTYLR_TSET22: [JsonTerminalClasses; 4usize] = [ + JsonTerminalClasses::TermClass0, + JsonTerminalClasses::TermClass1, + JsonTerminalClasses::TermClass12, + JsonTerminalClasses::TermClass21, ]; - let __rustylr_tset2: Vec = vec![ - JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1, - JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass21, - JsonTerminalClasses::TermClass28, JsonTerminalClasses::eof + static __RUSTYLR_TSET2: [JsonTerminalClasses; 6usize] = [ + JsonTerminalClasses::TermClass0, + JsonTerminalClasses::TermClass1, + JsonTerminalClasses::TermClass12, + JsonTerminalClasses::TermClass21, + JsonTerminalClasses::TermClass28, + JsonTerminalClasses::eof, ]; - let __rustylr_tset18: Vec = vec![ - JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1, - JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass28 + static __RUSTYLR_TSET18: [JsonTerminalClasses; 4usize] = [ + JsonTerminalClasses::TermClass0, + JsonTerminalClasses::TermClass1, + JsonTerminalClasses::TermClass12, + JsonTerminalClasses::TermClass28, ]; - let __rustylr_tset3: Vec = vec![ - JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1, - JsonTerminalClasses::TermClass13, JsonTerminalClasses::TermClass18, - JsonTerminalClasses::TermClass19, JsonTerminalClasses::eof + static __RUSTYLR_TSET3: [JsonTerminalClasses; 6usize] = [ + JsonTerminalClasses::TermClass0, + JsonTerminalClasses::TermClass1, + JsonTerminalClasses::TermClass13, + JsonTerminalClasses::TermClass18, + JsonTerminalClasses::TermClass19, + JsonTerminalClasses::eof, ]; - let __rustylr_tset24: Vec = vec![ - JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1, - JsonTerminalClasses::TermClass18, JsonTerminalClasses::TermClass19, - JsonTerminalClasses::eof + static __RUSTYLR_TSET24: [JsonTerminalClasses; 5usize] = [ + JsonTerminalClasses::TermClass0, + JsonTerminalClasses::TermClass1, + JsonTerminalClasses::TermClass18, + JsonTerminalClasses::TermClass19, + JsonTerminalClasses::eof, ]; - let __rustylr_tset25: Vec = vec![ - JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1, - JsonTerminalClasses::eof + static __RUSTYLR_TSET25: [JsonTerminalClasses; 3usize] = [ + JsonTerminalClasses::TermClass0, + JsonTerminalClasses::TermClass1, + JsonTerminalClasses::eof, ]; - let __rustylr_tset10: Vec = vec![ - JsonTerminalClasses::TermClass1, JsonTerminalClasses::TermClass3, - JsonTerminalClasses::TermClass4, JsonTerminalClasses::TermClass5, - JsonTerminalClasses::TermClass6, JsonTerminalClasses::TermClass7, - JsonTerminalClasses::TermClass8, JsonTerminalClasses::TermClass9, - JsonTerminalClasses::TermClass10, JsonTerminalClasses::TermClass11, - JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass13, - JsonTerminalClasses::TermClass14, JsonTerminalClasses::TermClass15, - JsonTerminalClasses::TermClass16, JsonTerminalClasses::TermClass17, - JsonTerminalClasses::TermClass18, JsonTerminalClasses::TermClass19, - JsonTerminalClasses::TermClass20, JsonTerminalClasses::TermClass21, - JsonTerminalClasses::TermClass22, JsonTerminalClasses::TermClass23, - JsonTerminalClasses::TermClass24, JsonTerminalClasses::TermClass25, - JsonTerminalClasses::TermClass26, JsonTerminalClasses::TermClass27, - JsonTerminalClasses::TermClass28, JsonTerminalClasses::TermClass29, - JsonTerminalClasses::TermClass30 + static __RUSTYLR_TSET10: [JsonTerminalClasses; 29usize] = [ + JsonTerminalClasses::TermClass1, + JsonTerminalClasses::TermClass3, + JsonTerminalClasses::TermClass4, + JsonTerminalClasses::TermClass5, + JsonTerminalClasses::TermClass6, + JsonTerminalClasses::TermClass7, + JsonTerminalClasses::TermClass8, + JsonTerminalClasses::TermClass9, + JsonTerminalClasses::TermClass10, + JsonTerminalClasses::TermClass11, + JsonTerminalClasses::TermClass12, + JsonTerminalClasses::TermClass13, + JsonTerminalClasses::TermClass14, + JsonTerminalClasses::TermClass15, + JsonTerminalClasses::TermClass16, + JsonTerminalClasses::TermClass17, + JsonTerminalClasses::TermClass18, + JsonTerminalClasses::TermClass19, + JsonTerminalClasses::TermClass20, + JsonTerminalClasses::TermClass21, + JsonTerminalClasses::TermClass22, + JsonTerminalClasses::TermClass23, + JsonTerminalClasses::TermClass24, + JsonTerminalClasses::TermClass25, + JsonTerminalClasses::TermClass26, + JsonTerminalClasses::TermClass27, + JsonTerminalClasses::TermClass28, + JsonTerminalClasses::TermClass29, + JsonTerminalClasses::TermClass30, ]; - let __rustylr_tset1: Vec = vec![ - JsonTerminalClasses::TermClass6, JsonTerminalClasses::TermClass7, - JsonTerminalClasses::TermClass9, JsonTerminalClasses::TermClass11, - JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass14, - JsonTerminalClasses::TermClass15, JsonTerminalClasses::TermClass16, - JsonTerminalClasses::TermClass20, JsonTerminalClasses::TermClass21, - JsonTerminalClasses::TermClass27, JsonTerminalClasses::TermClass28, - JsonTerminalClasses::TermClass29, JsonTerminalClasses::eof + static __RUSTYLR_TSET1: [JsonTerminalClasses; 14usize] = [ + JsonTerminalClasses::TermClass6, + JsonTerminalClasses::TermClass7, + JsonTerminalClasses::TermClass9, + JsonTerminalClasses::TermClass11, + JsonTerminalClasses::TermClass12, + JsonTerminalClasses::TermClass14, + JsonTerminalClasses::TermClass15, + JsonTerminalClasses::TermClass16, + JsonTerminalClasses::TermClass20, + JsonTerminalClasses::TermClass21, + JsonTerminalClasses::TermClass27, + JsonTerminalClasses::TermClass28, + JsonTerminalClasses::TermClass29, + JsonTerminalClasses::eof, ]; - let __rustylr_tset0: Vec = vec![ - JsonTerminalClasses::TermClass6, JsonTerminalClasses::TermClass7, - JsonTerminalClasses::TermClass9, JsonTerminalClasses::TermClass11, - JsonTerminalClasses::TermClass14, JsonTerminalClasses::TermClass15, - JsonTerminalClasses::TermClass20, JsonTerminalClasses::TermClass27, - JsonTerminalClasses::TermClass29 + static __RUSTYLR_TSET0: [JsonTerminalClasses; 9usize] = [ + JsonTerminalClasses::TermClass6, + JsonTerminalClasses::TermClass7, + JsonTerminalClasses::TermClass9, + JsonTerminalClasses::TermClass11, + JsonTerminalClasses::TermClass14, + JsonTerminalClasses::TermClass15, + JsonTerminalClasses::TermClass20, + JsonTerminalClasses::TermClass27, + JsonTerminalClasses::TermClass29, ]; - let __rustylr_tset20: Vec = vec![ - JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass21 + static __RUSTYLR_TSET20: [JsonTerminalClasses; 2usize] = [ + JsonTerminalClasses::TermClass12, + JsonTerminalClasses::TermClass21, ]; - let __rustylr_tset15: Vec = vec![ - JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass21, - JsonTerminalClasses::TermClass28, JsonTerminalClasses::eof + static __RUSTYLR_TSET15: [JsonTerminalClasses; 4usize] = [ + JsonTerminalClasses::TermClass12, + JsonTerminalClasses::TermClass21, + JsonTerminalClasses::TermClass28, + JsonTerminalClasses::eof, ]; - let __rustylr_tset13: Vec = vec![ - JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass28 + static __RUSTYLR_TSET13: [JsonTerminalClasses; 2usize] = [ + JsonTerminalClasses::TermClass12, + JsonTerminalClasses::TermClass28, ]; - let __rustylr_tset19: Vec = vec![ - JsonTerminalClasses::TermClass14, JsonTerminalClasses::TermClass15 + static __RUSTYLR_TSET19: [JsonTerminalClasses; 2usize] = [ + JsonTerminalClasses::TermClass14, + JsonTerminalClasses::TermClass15, ]; - let __rustylr_tset12: Vec = vec![ - JsonTerminalClasses::TermClass16 + static __RUSTYLR_TSET12: [JsonTerminalClasses; 1usize] = [ + JsonTerminalClasses::TermClass16, ]; - let __rustylr_tset5: Vec = vec![ - JsonTerminalClasses::TermClass21 + static __RUSTYLR_TSET5: [JsonTerminalClasses; 1usize] = [ + JsonTerminalClasses::TermClass21, ]; - let __rustylr_tset8: Vec = vec![ - JsonTerminalClasses::TermClass28 + static __RUSTYLR_TSET8: [JsonTerminalClasses; 1usize] = [ + JsonTerminalClasses::TermClass28, ]; - let __rustylr_tset7: Vec = vec![ - JsonTerminalClasses::TermClass28, JsonTerminalClasses::TermClass29 + static __RUSTYLR_TSET7: [JsonTerminalClasses; 2usize] = [ + JsonTerminalClasses::TermClass28, + JsonTerminalClasses::TermClass29, ]; - let __rustylr_tset9: Vec = vec![ - JsonTerminalClasses::TermClass29 + static __RUSTYLR_TSET9: [JsonTerminalClasses; 1usize] = [ + JsonTerminalClasses::TermClass29, + ]; + static __RUSTYLR_TSET23: [JsonTerminalClasses; 1usize] = [ + JsonTerminalClasses::eof, ]; - let __rustylr_tset23: Vec = vec![JsonTerminalClasses::eof]; let states: Vec< ::rusty_lr::parser::state::IntermediateState< JsonTerminalClasses, @@ -1950,14 +2019,14 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(7, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [0, 15, 42, 43, 44, 97, 98,]; let shifted : & - 'static [u8] = & [0, 0, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass0, + static __RULES : [u8; 7usize] = [0, 15, 42, 43, 44, 97, 98,]; static + __SHIFTED : [u8; 7usize] = [0, 0, 0, 0, 0, 0, 0,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(1, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(2, false)),], @@ -1966,12 +2035,12 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(4, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [42, 43, 44, 44, 97,]; let shifted : & 'static - [u8] = & [0, 0, 0, 1, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [42, 43, 44, 44, 97,]; static __SHIFTED : + [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(1, false)), @@ -1982,41 +2051,39 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(3, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [42, 43, 43, 44, 97,]; let shifted : & 'static - [u8] = & [0, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [42, 43, 43, 44, 97,]; static __SHIFTED : + [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![43]; __reduce_map - .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8] - = & [43,]; let shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted - .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![44]; __reduce_map - .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8] - = & [44,]; let shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted - .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::eof, - ::rusty_lr::parser::state::ShiftTarget::new(6, true)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [98,]; let shifted : & 'static - [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + .extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 1usize] = [43,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [98,]; - let shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| + let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![44]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { + static __RULES : [u8; 1usize] = [44,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::eof, + ::rusty_lr::parser::state::ShiftTarget::new(6, true)),], + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [98,]; static __SHIFTED : [u8; 1usize] = + [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 1usize] = [98,]; static + __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : @@ -2054,117 +2121,106 @@ impl JsonParser { (JsonNonTerminals::_LiteralString24, ::rusty_lr::parser::state::ShiftTarget::new(107, false)), (JsonNonTerminals::_TermSet33, - ::rusty_lr::parser::state::ShiftTarget::new(110, false)),], reduce_map : { - let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [1, 2, - 3, 4, 5, 6, 7, 8, 9, 10, 14, 15, 16, 31, 32, 33, 34, 35, 45, 46, 47, 92, - 93,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& + ::rusty_lr::parser::state::ShiftTarget::new(110, false)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 23usize] = [1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 14, 15, 16, 31, 32, 33, 34, 35, 45, 46, 47, 92, 93,]; + static __SHIFTED : [u8; 23usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass22, ::rusty_lr::parser::state::ShiftTarget::new(9, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [46,]; let shifted : & 'static - [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] = + [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass24, ::rusty_lr::parser::state::ShiftTarget::new(10, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [46,]; let shifted : & 'static - [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass25, ::rusty_lr::parser::state::ShiftTarget::new(11, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [46,]; let shifted : & 'static - [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass19, ::rusty_lr::parser::state::ShiftTarget::new(12, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [46,]; let shifted : & 'static - [u8] = & [4,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![46]; __reduce_map.extend(__rustylr_tset2.iter().map(| term | (* term, + vec![46]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [46,]; let shifted : & 'static [u8] = & [5,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] = + [5,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass26, ::rusty_lr::parser::state::ShiftTarget::new(14, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [47,]; let shifted : & 'static - [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [47,]; static __SHIFTED : [u8; 1usize] = + [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass24, ::rusty_lr::parser::state::ShiftTarget::new(15, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [47,]; let shifted : & 'static - [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [47,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass24, ::rusty_lr::parser::state::ShiftTarget::new(16, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [47,]; let shifted : & 'static - [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [47,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![47]; __reduce_map.extend(__rustylr_tset2.iter().map(| term | (* term, + vec![47]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [47,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [47,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass8, ::rusty_lr::parser::state::ShiftTarget::new(18, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [45,]; let shifted : & 'static - [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] = + [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass26, ::rusty_lr::parser::state::ShiftTarget::new(19, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [45,]; let shifted : & 'static - [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass19, ::rusty_lr::parser::state::ShiftTarget::new(20, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [45,]; let shifted : & 'static - [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![45]; __reduce_map.extend(__rustylr_tset2.iter().map(| term | (* term, + vec![45]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [45,]; let shifted : & 'static [u8] = & [4,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, @@ -2172,11 +2228,10 @@ impl JsonParser { (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(22, false)),], shift_goto_map_nonterm : vec![(JsonNonTerminals::_TermSet33, - ::rusty_lr::parser::state::ShiftTarget::new(26, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [34, 35, - 92, 93,]; let shifted : & 'static [u8] = & [1, 1, 0, 0,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::parser::state::ShiftTarget::new(26, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 4usize] = [34, 35, 92, + 93,]; static __SHIFTED : [u8; 4usize] = [1, 1, 0, 0,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, @@ -2188,22 +2243,22 @@ impl JsonParser { (JsonNonTerminals::_TermSet33, ::rusty_lr::parser::state::ShiftTarget::new(24, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![93]; __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term, + vec![93]; __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [35, 90, 91, 92, 93, 93,]; let shifted : & - 'static [u8] = & [2, 0, 0, 0, 0, 1,]; rules.iter().zip(shifted.iter()).map(| - (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + static __RULES : [u8; 6usize] = [35, 90, 91, 92, 93, 93,]; static __SHIFTED : + [u8; 6usize] = [2, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![35]; __reduce_map - .extend(__rustylr_tset4.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8] - = & [35,]; let shifted : & 'static [u8] = & [3,]; rules.iter().zip(shifted - .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass14, + .extend(__RUSTYLR_TSET4.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 1usize] = [35,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(24, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(24, false)),], @@ -2212,30 +2267,30 @@ impl JsonParser { (JsonNonTerminals::_TermSet33, ::rusty_lr::parser::state::ShiftTarget::new(24, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![90]; __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term, + vec![90]; __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [90, 90, 91, 91, 92, 93,]; let shifted : & - 'static [u8] = & [0, 1, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| - (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + static __RULES : [u8; 6usize] = [90, 90, 91, 91, 92, 93,]; static __SHIFTED : + [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![91]; __reduce_map - .extend(__rustylr_tset4.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8] - = & [91,]; let shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted - .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); let reduce_rules = vec![34]; __reduce_map - .extend(__rustylr_tset4.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8] - = & [34,]; let shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted - .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass14, + .extend(__RUSTYLR_TSET4.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 1usize] = [91,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { + let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = + vec![34]; __reduce_map.extend(__RUSTYLR_TSET4.iter().map(| term | (* term, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { + static __RULES : [u8; 1usize] = [34,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(24, false)), (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(24, false)),], @@ -2244,22 +2299,22 @@ impl JsonParser { (JsonNonTerminals::_TermSet33, ::rusty_lr::parser::state::ShiftTarget::new(24, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![93]; __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term, + vec![93]; __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [33, 90, 91, 92, 93, 93,]; let shifted : & - 'static [u8] = & [1, 0, 0, 0, 0, 1,]; rules.iter().zip(shifted.iter()).map(| - (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + static __RULES : [u8; 6usize] = [33, 90, 91, 92, 93, 93,]; static __SHIFTED : + [u8; 6usize] = [1, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![33]; __reduce_map - .extend(__rustylr_tset4.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8] - = & [33,]; let shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted - .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass0, + .extend(__RUSTYLR_TSET4.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 1usize] = [33,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(1, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(2, false)),], @@ -2273,23 +2328,23 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(32, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![51]; __reduce_map.extend(__rustylr_tset5.iter().map(| term | (* term, + vec![51]; __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules.clone()))); let reduce_rules = vec![97]; __reduce_map - .extend(__rustylr_tset0.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8] - = & [14, 15, 42, 43, 44, 48, 49, 50, 51, 97,]; let shifted : & 'static [u8] = - & [1, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& - rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + .extend(__RUSTYLR_TSET0.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 10usize] = [14, 15, 42, 43, 44, 48, 49, 50, 51, 97,]; static __SHIFTED : [u8; + 10usize] = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED + .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { + rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass12, ::rusty_lr::parser::state::ShiftTarget::new(31, false)),], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![48]; __reduce_map - .extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8] - = & [48, 49,]; let shifted : & 'static [u8] = & [1, 1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + .extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 2usize] = [48, 49,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, @@ -2304,14 +2359,14 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(32, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [15, 42, 43, 44, 48, 49, 49, 97,]; let shifted - : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 2, 0,]; rules.iter().zip(shifted - .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass6, + static __RULES : [u8; 8usize] = [15, 42, 43, 44, 48, 49, 49, 97,]; static + __SHIFTED : [u8; 8usize] = [0, 0, 0, 0, 0, 0, 2, 0,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(8, false)), (JsonTerminalClasses::TermClass7, ::rusty_lr::parser::state::ShiftTarget::new(13, false)), @@ -2345,12 +2400,11 @@ impl JsonParser { (JsonNonTerminals::_LiteralString24, ::rusty_lr::parser::state::ShiftTarget::new(94, false)), (JsonNonTerminals::_TermSet33, - ::rusty_lr::parser::state::ShiftTarget::new(97, false)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [1, 2, - 3, 4, 5, 6, 7, 8, 9, 10, 14, 15, 16, 31, 32, 33, 34, 35, 45, 46, 47, 92, - 93,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& + ::rusty_lr::parser::state::ShiftTarget::new(97, false)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 23usize] = [1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 14, 15, 16, 31, 32, 33, 34, 35, 45, 46, 47, 92, 93,]; + static __SHIFTED : [u8; 23usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : @@ -2359,11 +2413,10 @@ impl JsonParser { (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(34, false)),], shift_goto_map_nonterm : vec![(JsonNonTerminals::_TermSet33, - ::rusty_lr::parser::state::ShiftTarget::new(26, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [34, 35, - 92, 93,]; let shifted : & 'static [u8] = & [1, 1, 0, 0,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::parser::state::ShiftTarget::new(26, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 4usize] = [34, 35, 92, + 93,]; static __SHIFTED : [u8; 4usize] = [1, 1, 0, 0,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, @@ -2375,12 +2428,12 @@ impl JsonParser { (JsonNonTerminals::_TermSet33, ::rusty_lr::parser::state::ShiftTarget::new(35, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![93]; __reduce_map.extend(__rustylr_tset6.iter().map(| term | (* term, + vec![93]; __reduce_map.extend(__RUSTYLR_TSET6.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [35, 90, 91, 92, 93, 93,]; let shifted : & - 'static [u8] = & [2, 0, 0, 0, 0, 1,]; rules.iter().zip(shifted.iter()).map(| - (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + static __RULES : [u8; 6usize] = [35, 90, 91, 92, 93, 93,]; static __SHIFTED : + [u8; 6usize] = [2, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(35, false)), @@ -2391,12 +2444,12 @@ impl JsonParser { (JsonNonTerminals::_TermSet33, ::rusty_lr::parser::state::ShiftTarget::new(35, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![90]; __reduce_map.extend(__rustylr_tset6.iter().map(| term | (* term, + vec![90]; __reduce_map.extend(__RUSTYLR_TSET6.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [90, 90, 91, 91, 92, 93,]; let shifted : & - 'static [u8] = & [0, 1, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| - (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + static __RULES : [u8; 6usize] = [90, 90, 91, 91, 92, 93,]; static __SHIFTED : + [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(35, false)), @@ -2407,27 +2460,26 @@ impl JsonParser { (JsonNonTerminals::_TermSet33, ::rusty_lr::parser::state::ShiftTarget::new(35, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![93]; __reduce_map.extend(__rustylr_tset6.iter().map(| term | (* term, + vec![93]; __reduce_map.extend(__RUSTYLR_TSET6.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [33, 90, 91, 92, 93, 93,]; let shifted : & - 'static [u8] = & [1, 0, 0, 0, 0, 1,]; rules.iter().zip(shifted.iter()).map(| - (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + static __RULES : [u8; 6usize] = [33, 90, 91, 92, 93, 93,]; static __SHIFTED : + [u8; 6usize] = [1, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass21, ::rusty_lr::parser::state::ShiftTarget::new(38, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [14,]; let shifted : & 'static - [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [14,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![14]; __reduce_map.extend(__rustylr_tset2.iter().map(| term | (* term, + vec![14]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [14,]; let shifted : & 'static [u8] = & [3,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [14,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, @@ -2443,11 +2495,11 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(75, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset7.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET7.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [8, 9, 10, 11, 12, 13, 42, 43, 44, 97,]; let - shifted : & 'static [u8] = & [1, 1, 1, 0, 0, 0, 0, 0, 0, 0,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 10usize] = [8, 9, 10, 11, 12, 13, 42, 43, 44, 97,]; + static __SHIFTED : [u8; 10usize] = [1, 1, 1, 0, 0, 0, 0, 0, 0, 0,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, @@ -2459,12 +2511,12 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(4, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset7.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET7.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [42, 43, 44, 44, 97,]; let shifted : & 'static - [u8] = & [0, 0, 0, 1, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [42, 43, 44, 44, 97,]; static __SHIFTED : + [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(40, false)), @@ -2475,53 +2527,51 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(3, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset7.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET7.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [42, 43, 43, 44, 97,]; let shifted : & 'static - [u8] = & [0, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [42, 43, 43, 44, 97,]; static __SHIFTED : + [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass28, ::rusty_lr::parser::state::ShiftTarget::new(43, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [10,]; let shifted : & 'static - [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [10,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![10]; __reduce_map.extend(__rustylr_tset2.iter().map(| term | (* term, + vec![10]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [10,]; let shifted : & 'static [u8] = & [3,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [10,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass28, ::rusty_lr::parser::state::ShiftTarget::new(45, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [9,]; let shifted : & 'static [u8] - = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [9,]; static __SHIFTED : [u8; 1usize] = [2,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![9]; __reduce_map.extend(__rustylr_tset2.iter().map(| term | (* term, + vec![9]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [9,]; let shifted : & 'static [u8] = & [3,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [9,]; static __SHIFTED : [u8; 1usize] = [3,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass12, ::rusty_lr::parser::state::ShiftTarget::new(47, false)),], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![11]; __reduce_map - .extend(__rustylr_tset8.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8] - = & [11, 12,]; let shifted : & 'static [u8] = & [1, 1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + .extend(__RUSTYLR_TSET8.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 2usize] = [11, 12,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, @@ -2536,14 +2586,14 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(51, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset9.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET9.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [11, 12, 12, 13, 42, 43, 44, 97,]; let shifted - : & 'static [u8] = & [0, 0, 2, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted - .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass0, + static __RULES : [u8; 8usize] = [11, 12, 12, 13, 42, 43, 44, 97,]; static + __SHIFTED : [u8; 8usize] = [0, 0, 2, 0, 0, 0, 0, 0,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(48, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(49, false)),], @@ -2552,12 +2602,12 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(4, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset9.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET9.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [42, 43, 44, 44, 97,]; let shifted : & 'static - [u8] = & [0, 0, 0, 1, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [42, 43, 44, 44, 97,]; static __SHIFTED : + [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(48, false)), @@ -2568,28 +2618,27 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(3, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset9.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET9.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [42, 43, 43, 44, 97,]; let shifted : & 'static - [u8] = & [0, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [42, 43, 43, 44, 97,]; static __SHIFTED : + [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![12]; __reduce_map - .extend(__rustylr_tset8.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8] - = & [12,]; let shifted : & 'static [u8] = & [3,]; rules.iter().zip(shifted - .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass29, + .extend(__RUSTYLR_TSET8.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 1usize] = [12,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass29, ::rusty_lr::parser::state::ShiftTarget::new(52, false)),], shift_goto_map_nonterm : vec![(JsonNonTerminals::String, - ::rusty_lr::parser::state::ShiftTarget::new(64, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [13, - 16,]; let shifted : & 'static [u8] = & [1, 0,]; rules.iter().zip(shifted + ::rusty_lr::parser::state::ShiftTarget::new(64, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 2usize] = [13, 16,]; + static __SHIFTED : [u8; 2usize] = [1, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : @@ -2658,13 +2707,13 @@ impl JsonParser { (JsonNonTerminals::_TermSet29, ::rusty_lr::parser::state::ShiftTarget::new(60, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![55]; __reduce_map.extend(__rustylr_tset9.iter().map(| term | (* term, + vec![55]; __reduce_map.extend(__RUSTYLR_TSET9.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [16, 17, 18, 52, 53, 54, 55, 56, 57, 58, 59, + static __RULES : [u8; 34usize] = [16, 17, 18, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, - 79, 80, 81, 82,]; let shifted : & 'static [u8] = & [1, 0, 0, 0, 0, 0, 0, 0, + 79, 80, 81, 82,]; static __SHIFTED : [u8; 34usize] = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass4, @@ -2686,11 +2735,10 @@ impl JsonParser { (JsonTerminalClasses::TermClass30, ::rusty_lr::parser::state::ShiftTarget::new(59, false)),], shift_goto_map_nonterm : vec![(JsonNonTerminals::Escape, - ::rusty_lr::parser::state::ShiftTarget::new(59, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [17, 19, - 20, 21, 22, 23, 24, 25, 26, 27,]; let shifted : & 'static [u8] = & [1, 0, 0, - 0, 0, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & + ::rusty_lr::parser::state::ShiftTarget::new(59, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 10usize] = [17, 19, 20, + 21, 22, 23, 24, 25, 26, 27,]; static __SHIFTED : [u8; 10usize] = [1, 0, 0, 0, + 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : @@ -2719,13 +2767,12 @@ impl JsonParser { (JsonNonTerminals::_TermSet31, ::rusty_lr::parser::state::ShiftTarget::new(55, false)), (JsonNonTerminals::_TermSet33, - ::rusty_lr::parser::state::ShiftTarget::new(55, false)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [27, 28, - 29, 30, 83, 84, 85, 86, 87, 88, 89, 92, 93,]; let shifted : & 'static [u8] = - & [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + ::rusty_lr::parser::state::ShiftTarget::new(55, false)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 13usize] = [27, 28, 29, + 30, 83, 84, 85, 86, 87, 88, 89, 92, 93,]; static __SHIFTED : [u8; 13usize] = + [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED + .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { + rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass5, ::rusty_lr::parser::state::ShiftTarget::new(56, false)), @@ -2752,13 +2799,12 @@ impl JsonParser { (JsonNonTerminals::_TermSet31, ::rusty_lr::parser::state::ShiftTarget::new(56, false)), (JsonNonTerminals::_TermSet33, - ::rusty_lr::parser::state::ShiftTarget::new(56, false)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [27, 28, - 29, 30, 83, 84, 85, 86, 87, 88, 89, 92, 93,]; let shifted : & 'static [u8] = - & [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + ::rusty_lr::parser::state::ShiftTarget::new(56, false)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 13usize] = [27, 28, 29, + 30, 83, 84, 85, 86, 87, 88, 89, 92, 93,]; static __SHIFTED : [u8; 13usize] = + [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED + .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { + rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass5, ::rusty_lr::parser::state::ShiftTarget::new(57, false)), @@ -2785,13 +2831,12 @@ impl JsonParser { (JsonNonTerminals::_TermSet31, ::rusty_lr::parser::state::ShiftTarget::new(57, false)), (JsonNonTerminals::_TermSet33, - ::rusty_lr::parser::state::ShiftTarget::new(57, false)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [27, 28, - 29, 30, 83, 84, 85, 86, 87, 88, 89, 92, 93,]; let shifted : & 'static [u8] = - & [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + ::rusty_lr::parser::state::ShiftTarget::new(57, false)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 13usize] = [27, 28, 29, + 30, 83, 84, 85, 86, 87, 88, 89, 92, 93,]; static __SHIFTED : [u8; 13usize] = + [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED + .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { + rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass5, ::rusty_lr::parser::state::ShiftTarget::new(58, false)), @@ -2818,28 +2863,27 @@ impl JsonParser { (JsonNonTerminals::_TermSet31, ::rusty_lr::parser::state::ShiftTarget::new(58, false)), (JsonNonTerminals::_TermSet33, - ::rusty_lr::parser::state::ShiftTarget::new(58, false)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [27, 28, - 29, 30, 83, 84, 85, 86, 87, 88, 89, 92, 93,]; let shifted : & 'static [u8] = - & [4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()) - .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + ::rusty_lr::parser::state::ShiftTarget::new(58, false)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 13usize] = [27, 28, 29, + 30, 83, 84, 85, 86, 87, 88, 89, 92, 93,]; static __SHIFTED : [u8; 13usize] = + [4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED + .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { + rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![27]; __reduce_map - .extend(__rustylr_tset10.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : & - 'static [u8] = & [27,]; let shifted : & 'static [u8] = & [5,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + .extend(__RUSTYLR_TSET10.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [27,]; static __SHIFTED : [u8; 1usize] = [5,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![17]; __reduce_map.extend(__rustylr_tset10.iter().map(| term | (* term, + vec![17]; __reduce_map.extend(__RUSTYLR_TSET10.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [17,]; let shifted : & 'static [u8] = & [2,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [17,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass1, @@ -2905,37 +2949,36 @@ impl JsonParser { (JsonNonTerminals::_TermSet29, ::rusty_lr::parser::state::ShiftTarget::new(60, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![52]; __reduce_map.extend(__rustylr_tset9.iter().map(| term | (* term, + vec![52]; __reduce_map.extend(__RUSTYLR_TSET9.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [17, 18, 52, 52, 53, 53, 56, 57, 58, 59, 60, + static __RULES : [u8; 33usize] = [17, 18, 52, 52, 53, 53, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82,]; let shifted : & 'static [u8] = & [0, 0, 0, 1, 0, 1, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; rules - .iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + 80, 81, 82,]; static __SHIFTED : [u8; 33usize] = [0, 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![53]; __reduce_map.extend(__rustylr_tset9.iter().map(| term | (* term, + vec![53]; __reduce_map.extend(__RUSTYLR_TSET9.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [53,]; let shifted : & 'static [u8] = & [2,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [53,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass29, ::rusty_lr::parser::state::ShiftTarget::new(63, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [16,]; let shifted : & 'static - [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [16,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![16]; __reduce_map.extend(__rustylr_tset11.iter().map(| term | (* term, + vec![16]; __reduce_map.extend(__RUSTYLR_TSET11.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [16,]; let shifted : & 'static [u8] = & [3,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [16,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, @@ -2947,12 +2990,12 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(67, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [13, 42, 43, 44, 97,]; let shifted : & 'static - [u8] = & [2, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [13, 42, 43, 44, 97,]; static __SHIFTED : + [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(65, false)), @@ -2963,12 +3006,12 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(4, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [42, 43, 44, 44, 97,]; let shifted : & 'static - [u8] = & [0, 0, 0, 1, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [42, 43, 44, 44, 97,]; static __SHIFTED : + [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(65, false)), @@ -2979,19 +3022,18 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(3, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [42, 43, 43, 44, 97,]; let shifted : & 'static - [u8] = & [0, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [42, 43, 43, 44, 97,]; static __SHIFTED : + [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass16, ::rusty_lr::parser::state::ShiftTarget::new(68, false)),], - shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - ruleset : { let rules : & 'static [u8] = & [13,]; let shifted : & 'static - [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [13,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, @@ -3004,19 +3046,19 @@ impl JsonParser { true)), (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(70, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [13, 15, 42, 43, 44, 97,]; let shifted : & - 'static [u8] = & [4, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| - (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + static __RULES : [u8; 6usize] = [13, 15, 42, 43, 44, 97,]; static __SHIFTED : + [u8; 6usize] = [4, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![13]; __reduce_map - .extend(__rustylr_tset13.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : & - 'static [u8] = & [13,]; let shifted : & 'static [u8] = & [5,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + .extend(__RUSTYLR_TSET13.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [13,]; static __SHIFTED : [u8; 1usize] = [5,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass6, @@ -3053,12 +3095,11 @@ impl JsonParser { (JsonNonTerminals::_LiteralString24, ::rusty_lr::parser::state::ShiftTarget::new(77, false)), (JsonNonTerminals::_TermSet33, - ::rusty_lr::parser::state::ShiftTarget::new(81, false)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [1, 2, - 3, 4, 5, 6, 7, 8, 9, 10, 14, 15, 16, 31, 32, 33, 34, 35, 45, 46, 47, 92, - 93,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& + ::rusty_lr::parser::state::ShiftTarget::new(81, false)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 23usize] = [1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 14, 15, 16, 31, 32, 33, 34, 35, 45, 46, 47, 92, 93,]; + static __SHIFTED : [u8; 23usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : @@ -3067,11 +3108,10 @@ impl JsonParser { (JsonTerminalClasses::TermClass15, ::rusty_lr::parser::state::ShiftTarget::new(72, false)),], shift_goto_map_nonterm : vec![(JsonNonTerminals::_TermSet33, - ::rusty_lr::parser::state::ShiftTarget::new(26, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [34, 35, - 92, 93,]; let shifted : & 'static [u8] = & [1, 1, 0, 0,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::parser::state::ShiftTarget::new(26, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 4usize] = [34, 35, 92, + 93,]; static __SHIFTED : [u8; 4usize] = [1, 1, 0, 0,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, @@ -3083,12 +3123,12 @@ impl JsonParser { (JsonNonTerminals::_TermSet33, ::rusty_lr::parser::state::ShiftTarget::new(73, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![93]; __reduce_map.extend(__rustylr_tset14.iter().map(| term | (* term, + vec![93]; __reduce_map.extend(__RUSTYLR_TSET14.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [35, 90, 91, 92, 93, 93,]; let shifted : & - 'static [u8] = & [2, 0, 0, 0, 0, 1,]; rules.iter().zip(shifted.iter()).map(| - (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + static __RULES : [u8; 6usize] = [35, 90, 91, 92, 93, 93,]; static __SHIFTED : + [u8; 6usize] = [2, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(73, false)), @@ -3099,12 +3139,12 @@ impl JsonParser { (JsonNonTerminals::_TermSet33, ::rusty_lr::parser::state::ShiftTarget::new(73, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![90]; __reduce_map.extend(__rustylr_tset14.iter().map(| term | (* term, + vec![90]; __reduce_map.extend(__RUSTYLR_TSET14.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [90, 90, 91, 91, 92, 93,]; let shifted : & - 'static [u8] = & [0, 1, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| - (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + static __RULES : [u8; 6usize] = [90, 90, 91, 91, 92, 93,]; static __SHIFTED : + [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(73, false)), @@ -3115,34 +3155,33 @@ impl JsonParser { (JsonNonTerminals::_TermSet33, ::rusty_lr::parser::state::ShiftTarget::new(73, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![93]; __reduce_map.extend(__rustylr_tset14.iter().map(| term | (* term, + vec![93]; __reduce_map.extend(__RUSTYLR_TSET14.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [33, 90, 91, 92, 93, 93,]; let shifted : & - 'static [u8] = & [1, 0, 0, 0, 0, 1,]; rules.iter().zip(shifted.iter()).map(| - (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + static __RULES : [u8; 6usize] = [33, 90, 91, 92, 93, 93,]; static __SHIFTED : + [u8; 6usize] = [1, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass28, ::rusty_lr::parser::state::ShiftTarget::new(76, false)), (JsonTerminalClasses::TermClass29, ::rusty_lr::parser::state::ShiftTarget::new(52, false)),], shift_goto_map_nonterm : vec![(JsonNonTerminals::String, - ::rusty_lr::parser::state::ShiftTarget::new(64, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [8, 13, - 16,]; let shifted : & 'static [u8] = & [2, 1, 0,]; rules.iter().zip(shifted + ::rusty_lr::parser::state::ShiftTarget::new(64, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 3usize] = [8, 13, 16,]; + static __SHIFTED : [u8; 3usize] = [2, 1, 0,]; __RULES.iter().zip(__SHIFTED .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![8]; __reduce_map - .extend(__rustylr_tset2.iter().map(| term | (* term, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8] - = & [8,]; let shifted : & 'static [u8] = & [3,]; rules.iter().zip(shifted - .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { - rule : rule as usize, shifted : shifted as usize, } }).collect() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass0, + .extend(__RUSTYLR_TSET2.iter().map(| term | (* term, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 1usize] = [8,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(78, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(79, false)),], @@ -3151,12 +3190,12 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(80, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset13.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET13.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [15, 42, 43, 44, 97,]; let shifted : & 'static - [u8] = & [2, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [15, 42, 43, 44, 97,]; static __SHIFTED : + [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(78, false)), @@ -3167,12 +3206,12 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(4, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset13.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET13.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [42, 43, 44, 44, 97,]; let shifted : & 'static - [u8] = & [0, 0, 0, 1, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [42, 43, 44, 44, 97,]; static __SHIFTED : + [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(78, false)), @@ -3183,19 +3222,19 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(3, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset13.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET13.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [42, 43, 43, 44, 97,]; let shifted : & 'static - [u8] = & [0, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [42, 43, 43, 44, 97,]; static __SHIFTED : + [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![15]; __reduce_map - .extend(__rustylr_tset15.iter().map(| term | (* term, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : & - 'static [u8] = & [15,]; let shifted : & 'static [u8] = & [3,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + .extend(__RUSTYLR_TSET15.iter().map(| term | (* term, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [15,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass13, @@ -3205,12 +3244,12 @@ impl JsonParser { (JsonNonTerminals::__Group34Question35, ::rusty_lr::parser::state::ShiftTarget::new(85, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![96]; __reduce_map.extend(__rustylr_tset16.iter().map(| term | (* term, + vec![96]; __reduce_map.extend(__RUSTYLR_TSET16.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [31, 94, 95, 96,]; let shifted : & 'static - [u8] = & [1, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 4usize] = [31, 94, 95, 96,]; static __SHIFTED : [u8; + 4usize] = [1, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, + & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, + shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(84, false)), @@ -3219,19 +3258,18 @@ impl JsonParser { shift_goto_map_nonterm : vec![(JsonNonTerminals::_DigitPlus32, ::rusty_lr::parser::state::ShiftTarget::new(83, true)), (JsonNonTerminals::_TermSet33, - ::rusty_lr::parser::state::ShiftTarget::new(84, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [90, 91, - 92, 93, 94,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::parser::state::ShiftTarget::new(84, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 5usize] = [90, 91, 92, + 93, 94,]; static __SHIFTED : [u8; 5usize] = [0, 0, 0, 0, 1,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![94]; __reduce_map.extend(__rustylr_tset17.iter().map(| term | (* term, + vec![94]; __reduce_map.extend(__RUSTYLR_TSET17.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [94,]; let shifted : & 'static [u8] = & [2,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [94,]; static __SHIFTED : [u8; 1usize] = + [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, @@ -3243,12 +3281,12 @@ impl JsonParser { (JsonNonTerminals::_TermSet33, ::rusty_lr::parser::state::ShiftTarget::new(84, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![90]; __reduce_map.extend(__rustylr_tset16.iter().map(| term | (* term, + vec![90]; __reduce_map.extend(__RUSTYLR_TSET16.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [90, 90, 91, 91, 92, 93,]; let shifted : & - 'static [u8] = & [0, 1, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| - (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + static __RULES : [u8; 6usize] = [90, 90, 91, 91, 92, 93,]; static __SHIFTED : + [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass18, ::rusty_lr::parser::state::ShiftTarget::new(86, false)), @@ -3259,12 +3297,12 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(93, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset18.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET18.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [31, 36, 37, 38, 97,]; let shifted : & 'static - [u8] = & [2, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [31, 36, 37, 38, 97,]; static __SHIFTED : + [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass10, ::rusty_lr::parser::state::ShiftTarget::new(87, false)), @@ -3275,12 +3313,12 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(87, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset19.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET19.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [37, 39, 40, 41, 97,]; let shifted : & 'static - [u8] = & [1, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [37, 39, 40, 41, 97,]; static __SHIFTED : + [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(89, false)), @@ -3289,19 +3327,18 @@ impl JsonParser { shift_goto_map_nonterm : vec![(JsonNonTerminals::_DigitPlus32, ::rusty_lr::parser::state::ShiftTarget::new(88, true)), (JsonNonTerminals::_TermSet33, - ::rusty_lr::parser::state::ShiftTarget::new(89, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [37, 90, - 91, 92, 93,]; let shifted : & 'static [u8] = & [2, 0, 0, 0, 0,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::parser::state::ShiftTarget::new(89, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 5usize] = [37, 90, 91, + 92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![37]; __reduce_map.extend(__rustylr_tset2.iter().map(| term | (* term, + vec![37]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [37,]; let shifted : & 'static [u8] = & [3,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [37,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, @@ -3313,12 +3350,12 @@ impl JsonParser { (JsonNonTerminals::_TermSet33, ::rusty_lr::parser::state::ShiftTarget::new(89, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![90]; __reduce_map.extend(__rustylr_tset18.iter().map(| term | (* term, + vec![90]; __reduce_map.extend(__RUSTYLR_TSET18.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [90, 90, 91, 91, 92, 93,]; let shifted : & - 'static [u8] = & [0, 1, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| - (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + static __RULES : [u8; 6usize] = [90, 90, 91, 91, 92, 93,]; static __SHIFTED : + [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass10, ::rusty_lr::parser::state::ShiftTarget::new(91, false)), @@ -3329,12 +3366,12 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(91, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset19.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET19.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [38, 39, 40, 41, 97,]; let shifted : & 'static - [u8] = & [1, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [38, 39, 40, 41, 97,]; static __SHIFTED : + [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(89, false)), @@ -3343,27 +3380,26 @@ impl JsonParser { shift_goto_map_nonterm : vec![(JsonNonTerminals::_DigitPlus32, ::rusty_lr::parser::state::ShiftTarget::new(92, true)), (JsonNonTerminals::_TermSet33, - ::rusty_lr::parser::state::ShiftTarget::new(89, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [38, 90, - 91, 92, 93,]; let shifted : & 'static [u8] = & [2, 0, 0, 0, 0,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::parser::state::ShiftTarget::new(89, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 5usize] = [38, 90, 91, + 92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![38]; __reduce_map.extend(__rustylr_tset2.iter().map(| term | (* term, + vec![38]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [38,]; let shifted : & 'static [u8] = & [3,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [38,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![31]; __reduce_map.extend(__rustylr_tset2.iter().map(| term | (* term, + vec![31]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [31,]; let shifted : & 'static [u8] = & [3,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [31,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, @@ -3375,12 +3411,12 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(80, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset20.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET20.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [15, 42, 43, 44, 97,]; let shifted : & 'static - [u8] = & [2, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [15, 42, 43, 44, 97,]; static __SHIFTED : + [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(95, false)), @@ -3391,12 +3427,12 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(4, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset20.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET20.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [42, 43, 44, 44, 97,]; let shifted : & 'static - [u8] = & [0, 0, 0, 1, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [42, 43, 44, 44, 97,]; static __SHIFTED : + [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(95, false)), @@ -3407,12 +3443,12 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(3, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset20.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET20.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [42, 43, 43, 44, 97,]; let shifted : & 'static - [u8] = & [0, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [42, 43, 43, 44, 97,]; static __SHIFTED : + [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass13, ::rusty_lr::parser::state::ShiftTarget::new(98, false)),], @@ -3421,12 +3457,12 @@ impl JsonParser { (JsonNonTerminals::__Group34Question35, ::rusty_lr::parser::state::ShiftTarget::new(100, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![96]; __reduce_map.extend(__rustylr_tset21.iter().map(| term | (* term, + vec![96]; __reduce_map.extend(__RUSTYLR_TSET21.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [31, 94, 95, 96,]; let shifted : & 'static - [u8] = & [1, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 4usize] = [31, 94, 95, 96,]; static __SHIFTED : [u8; + 4usize] = [1, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, + & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, + shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(99, false)), @@ -3435,11 +3471,10 @@ impl JsonParser { shift_goto_map_nonterm : vec![(JsonNonTerminals::_DigitPlus32, ::rusty_lr::parser::state::ShiftTarget::new(83, true)), (JsonNonTerminals::_TermSet33, - ::rusty_lr::parser::state::ShiftTarget::new(99, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [90, 91, - 92, 93, 94,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::parser::state::ShiftTarget::new(99, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 5usize] = [90, 91, 92, + 93, 94,]; static __SHIFTED : [u8; 5usize] = [0, 0, 0, 0, 1,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, @@ -3451,12 +3486,12 @@ impl JsonParser { (JsonNonTerminals::_TermSet33, ::rusty_lr::parser::state::ShiftTarget::new(99, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![90]; __reduce_map.extend(__rustylr_tset21.iter().map(| term | (* term, + vec![90]; __reduce_map.extend(__RUSTYLR_TSET21.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [90, 90, 91, 91, 92, 93,]; let shifted : & - 'static [u8] = & [0, 1, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| - (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + static __RULES : [u8; 6usize] = [90, 90, 91, 91, 92, 93,]; static __SHIFTED : + [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass18, ::rusty_lr::parser::state::ShiftTarget::new(101, false)), @@ -3467,12 +3502,12 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(93, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset22.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET22.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [31, 36, 37, 38, 97,]; let shifted : & 'static - [u8] = & [2, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [31, 36, 37, 38, 97,]; static __SHIFTED : + [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass10, ::rusty_lr::parser::state::ShiftTarget::new(102, false)), @@ -3483,12 +3518,12 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(102, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset19.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET19.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [37, 39, 40, 41, 97,]; let shifted : & 'static - [u8] = & [1, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [37, 39, 40, 41, 97,]; static __SHIFTED : + [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(103, false)), @@ -3497,11 +3532,10 @@ impl JsonParser { shift_goto_map_nonterm : vec![(JsonNonTerminals::_DigitPlus32, ::rusty_lr::parser::state::ShiftTarget::new(88, true)), (JsonNonTerminals::_TermSet33, - ::rusty_lr::parser::state::ShiftTarget::new(103, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [37, 90, - 91, 92, 93,]; let shifted : & 'static [u8] = & [2, 0, 0, 0, 0,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::parser::state::ShiftTarget::new(103, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 5usize] = [37, 90, 91, + 92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, @@ -3513,12 +3547,12 @@ impl JsonParser { (JsonNonTerminals::_TermSet33, ::rusty_lr::parser::state::ShiftTarget::new(103, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![90]; __reduce_map.extend(__rustylr_tset22.iter().map(| term | (* term, + vec![90]; __reduce_map.extend(__RUSTYLR_TSET22.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [90, 90, 91, 91, 92, 93,]; let shifted : & - 'static [u8] = & [0, 1, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| - (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + static __RULES : [u8; 6usize] = [90, 90, 91, 91, 92, 93,]; static __SHIFTED : + [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass10, ::rusty_lr::parser::state::ShiftTarget::new(105, false)), @@ -3529,12 +3563,12 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(105, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset19.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET19.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [38, 39, 40, 41, 97,]; let shifted : & 'static - [u8] = & [1, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [38, 39, 40, 41, 97,]; static __SHIFTED : + [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(103, false)), @@ -3543,19 +3577,18 @@ impl JsonParser { shift_goto_map_nonterm : vec![(JsonNonTerminals::_DigitPlus32, ::rusty_lr::parser::state::ShiftTarget::new(92, true)), (JsonNonTerminals::_TermSet33, - ::rusty_lr::parser::state::ShiftTarget::new(103, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [38, 90, - 91, 92, 93,]; let shifted : & 'static [u8] = & [2, 0, 0, 0, 0,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::parser::state::ShiftTarget::new(103, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 5usize] = [38, 90, 91, + 92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![49]; __reduce_map.extend(__rustylr_tset5.iter().map(| term | (* term, + vec![49]; __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [49,]; let shifted : & 'static [u8] = & [3,]; - rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { + static __RULES : [u8; 1usize] = [49,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, @@ -3567,12 +3600,12 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(80, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset23.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET23.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [15, 42, 43, 44, 97,]; let shifted : & 'static - [u8] = & [2, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [15, 42, 43, 44, 97,]; static __SHIFTED : + [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(108, false)), @@ -3583,12 +3616,12 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(4, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset23.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET23.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [42, 43, 44, 44, 97,]; let shifted : & 'static - [u8] = & [0, 0, 0, 1, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [42, 43, 44, 44, 97,]; static __SHIFTED : + [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(108, false)), @@ -3599,12 +3632,12 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(3, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset23.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET23.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [42, 43, 43, 44, 97,]; let shifted : & 'static - [u8] = & [0, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [42, 43, 43, 44, 97,]; static __SHIFTED : + [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass13, ::rusty_lr::parser::state::ShiftTarget::new(111, false)),], @@ -3613,12 +3646,12 @@ impl JsonParser { (JsonNonTerminals::__Group34Question35, ::rusty_lr::parser::state::ShiftTarget::new(113, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![96]; __reduce_map.extend(__rustylr_tset24.iter().map(| term | (* term, + vec![96]; __reduce_map.extend(__RUSTYLR_TSET24.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [31, 94, 95, 96,]; let shifted : & 'static - [u8] = & [1, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 4usize] = [31, 94, 95, 96,]; static __SHIFTED : [u8; + 4usize] = [1, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, + & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, + shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(112, false)), @@ -3627,11 +3660,10 @@ impl JsonParser { shift_goto_map_nonterm : vec![(JsonNonTerminals::_DigitPlus32, ::rusty_lr::parser::state::ShiftTarget::new(83, true)), (JsonNonTerminals::_TermSet33, - ::rusty_lr::parser::state::ShiftTarget::new(112, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [90, 91, - 92, 93, 94,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 1,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::parser::state::ShiftTarget::new(112, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 5usize] = [90, 91, 92, + 93, 94,]; static __SHIFTED : [u8; 5usize] = [0, 0, 0, 0, 1,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, @@ -3643,12 +3675,12 @@ impl JsonParser { (JsonNonTerminals::_TermSet33, ::rusty_lr::parser::state::ShiftTarget::new(112, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![90]; __reduce_map.extend(__rustylr_tset24.iter().map(| term | (* term, + vec![90]; __reduce_map.extend(__RUSTYLR_TSET24.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [90, 90, 91, 91, 92, 93,]; let shifted : & - 'static [u8] = & [0, 1, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| - (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + static __RULES : [u8; 6usize] = [90, 90, 91, 91, 92, 93,]; static __SHIFTED : + [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass18, ::rusty_lr::parser::state::ShiftTarget::new(114, false)), @@ -3659,12 +3691,12 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(93, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset25.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET25.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [31, 36, 37, 38, 97,]; let shifted : & 'static - [u8] = & [2, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [31, 36, 37, 38, 97,]; static __SHIFTED : + [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass10, ::rusty_lr::parser::state::ShiftTarget::new(115, false)), @@ -3675,12 +3707,12 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(115, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset19.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET19.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [37, 39, 40, 41, 97,]; let shifted : & 'static - [u8] = & [1, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [37, 39, 40, 41, 97,]; static __SHIFTED : + [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(116, false)), @@ -3689,11 +3721,10 @@ impl JsonParser { shift_goto_map_nonterm : vec![(JsonNonTerminals::_DigitPlus32, ::rusty_lr::parser::state::ShiftTarget::new(88, true)), (JsonNonTerminals::_TermSet33, - ::rusty_lr::parser::state::ShiftTarget::new(116, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [37, 90, - 91, 92, 93,]; let shifted : & 'static [u8] = & [2, 0, 0, 0, 0,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::parser::state::ShiftTarget::new(116, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 5usize] = [37, 90, 91, + 92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, @@ -3705,12 +3736,12 @@ impl JsonParser { (JsonNonTerminals::_TermSet33, ::rusty_lr::parser::state::ShiftTarget::new(116, true)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![90]; __reduce_map.extend(__rustylr_tset25.iter().map(| term | (* term, + vec![90]; __reduce_map.extend(__RUSTYLR_TSET25.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [90, 90, 91, 91, 92, 93,]; let shifted : & - 'static [u8] = & [0, 1, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| - (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + static __RULES : [u8; 6usize] = [90, 90, 91, 91, 92, 93,]; static __SHIFTED : + [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()) + .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass10, ::rusty_lr::parser::state::ShiftTarget::new(118, false)), @@ -3721,12 +3752,12 @@ impl JsonParser { (JsonNonTerminals::_LiteralString36, ::rusty_lr::parser::state::ShiftTarget::new(118, false)),], reduce_map : { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = - vec![97]; __reduce_map.extend(__rustylr_tset19.iter().map(| term | (* term, + vec![97]; __reduce_map.extend(__RUSTYLR_TSET19.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { - let rules : & 'static [u8] = & [38, 39, 40, 41, 97,]; let shifted : & 'static - [u8] = & [1, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + static __RULES : [u8; 5usize] = [38, 39, 40, 41, 97,]; static __SHIFTED : + [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(116, false)), @@ -3735,11 +3766,10 @@ impl JsonParser { shift_goto_map_nonterm : vec![(JsonNonTerminals::_DigitPlus32, ::rusty_lr::parser::state::ShiftTarget::new(92, true)), (JsonNonTerminals::_TermSet33, - ::rusty_lr::parser::state::ShiftTarget::new(116, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [38, 90, - 91, 92, 93,]; let shifted : & 'static [u8] = & [2, 0, 0, 0, 0,]; rules.iter() - .zip(shifted.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::parser::state::ShiftTarget::new(116, true)),], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 5usize] = [38, 90, 91, + 92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ];