From 08dd1079835d42429cb3341260cd1a9387450447 Mon Sep 17 00:00:00 2001 From: Taehwan Kim Date: Fri, 3 Oct 2025 23:53:11 +0900 Subject: [PATCH 1/3] emit terminal sets to static variables --- rusty_lr_parser/src/emit.rs | 5 +- rusty_lr_parser/src/parser/parser_expanded.rs | 504 ++++++++++-------- scripts/diff/calculator.rs | 31 +- scripts/diff/calculator_u8.rs | 113 ++-- scripts/diff/json.rs | 441 ++++++++------- 5 files changed, 629 insertions(+), 465 deletions(-) diff --git a/rusty_lr_parser/src/emit.rs b/rusty_lr_parser/src/emit.rs index 24346f1..12b9e5c 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 { @@ -796,6 +796,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 +812,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..a63d5d5 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< @@ -7476,7 +7548,7 @@ 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) | { @@ -7485,7 +7557,7 @@ impl GrammarParser { ::rusty_lr_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()))); + .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 @@ -7527,7 +7599,7 @@ 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 @@ -7540,7 +7612,7 @@ impl GrammarParser { ::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()))); + .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) | { @@ -7573,7 +7645,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -7582,7 +7654,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -7633,7 +7705,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -7665,7 +7737,7 @@ 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 : & @@ -7679,7 +7751,7 @@ impl GrammarParser { 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) | { @@ -7688,7 +7760,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -7706,7 +7778,7 @@ 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 @@ -7718,7 +7790,7 @@ 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()))); + .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) | { @@ -7738,7 +7810,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -7747,7 +7819,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -7758,7 +7830,7 @@ 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()))); + .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) | { @@ -7778,7 +7850,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -7787,7 +7859,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -7796,7 +7868,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -7810,7 +7882,7 @@ 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 @@ -7819,7 +7891,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -7837,7 +7909,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -7846,7 +7918,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -7877,7 +7949,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -7886,7 +7958,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -7895,7 +7967,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -7938,7 +8010,7 @@ 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()))); + .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) | { @@ -7947,7 +8019,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -7988,7 +8060,7 @@ 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()))); + .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) | { @@ -8030,7 +8102,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -8051,7 +8123,7 @@ 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()))); + .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) | { @@ -8075,7 +8147,7 @@ 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, @@ -8098,7 +8170,7 @@ 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()))); + .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) | { @@ -8107,7 +8179,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -8146,7 +8218,7 @@ 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 @@ -8157,7 +8229,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -8166,7 +8238,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -8192,7 +8264,7 @@ 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, @@ -8208,7 +8280,7 @@ 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 + .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) | { @@ -8226,7 +8298,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -8244,7 +8316,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -8262,7 +8334,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -8280,7 +8352,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -8298,7 +8370,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -8319,7 +8391,7 @@ 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 + .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, & @@ -8339,7 +8411,7 @@ impl GrammarParser { ::rusty_lr_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 + .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) | { @@ -8371,7 +8443,7 @@ 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 : & @@ -8382,7 +8454,7 @@ impl GrammarParser { ::rusty_lr_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 + .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) | { @@ -8391,7 +8463,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -8412,7 +8484,7 @@ 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 + .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, & @@ -8438,7 +8510,7 @@ 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] = @@ -8449,7 +8521,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -8465,7 +8537,7 @@ 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() @@ -8503,7 +8575,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -8512,7 +8584,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -8521,7 +8593,7 @@ impl GrammarParser { ::rusty_lr_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()))); + .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 @@ -8529,7 +8601,7 @@ impl GrammarParser { ::rusty_lr_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()))); + .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 @@ -8548,7 +8620,7 @@ impl GrammarParser { ::rusty_lr_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()))); + .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 @@ -8556,7 +8628,7 @@ impl GrammarParser { ::rusty_lr_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()))); + .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 @@ -8564,7 +8636,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -8573,7 +8645,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -8585,7 +8657,7 @@ 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()) @@ -8594,7 +8666,7 @@ impl GrammarParser { ::rusty_lr_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 + __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) | { @@ -8606,7 +8678,7 @@ 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) | { @@ -8615,7 +8687,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -8624,7 +8696,7 @@ impl GrammarParser { ::rusty_lr_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 + .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) | { @@ -8633,7 +8705,7 @@ impl GrammarParser { ::rusty_lr_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 + .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) | { @@ -8712,7 +8784,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -8721,7 +8793,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -8745,7 +8817,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -8754,7 +8826,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -8789,7 +8861,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -8813,7 +8885,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -8932,7 +9004,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -8941,7 +9013,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -9047,7 +9119,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -9056,7 +9128,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -9074,7 +9146,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -9103,7 +9175,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -9121,7 +9193,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -9229,7 +9301,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -9335,7 +9407,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -9443,7 +9515,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -9549,7 +9621,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -9657,7 +9729,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -9763,7 +9835,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -9871,7 +9943,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -9977,7 +10049,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -9997,7 +10069,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -10015,7 +10087,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -10035,7 +10107,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -10053,7 +10125,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -10088,7 +10160,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -10112,7 +10184,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -10132,7 +10204,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -10150,7 +10222,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -10170,7 +10242,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -10188,7 +10260,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -10204,7 +10276,7 @@ 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()) @@ -10213,7 +10285,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -10231,7 +10303,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -10242,7 +10314,7 @@ 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 + .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) | { @@ -10251,7 +10323,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -10269,7 +10341,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -10377,7 +10449,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -10483,7 +10555,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -10591,7 +10663,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -10697,7 +10769,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -10715,7 +10787,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -10724,7 +10796,7 @@ impl GrammarParser { ::rusty_lr_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) | { @@ -10744,7 +10816,7 @@ 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, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, @@ -10757,7 +10829,7 @@ impl GrammarParser { ::rusty_lr_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) | { diff --git a/scripts/diff/calculator.rs b/scripts/diff/calculator.rs index a2fd1f7..9365a24 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< @@ -720,7 +725,7 @@ impl EParser { 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) | { @@ -744,7 +749,7 @@ impl EParser { ::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()))); + .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) | { @@ -765,7 +770,7 @@ impl EParser { 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) | { @@ -775,7 +780,7 @@ impl EParser { ::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()))); + .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) | { @@ -795,7 +800,7 @@ impl EParser { 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) | { @@ -811,7 +816,7 @@ impl EParser { 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) | { diff --git a/scripts/diff/calculator_u8.rs b/scripts/diff/calculator_u8.rs index c6d4715..aa5cbf9 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,7 +1022,7 @@ 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() @@ -1014,7 +1031,7 @@ impl EParser { 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) | { @@ -1051,7 +1068,7 @@ 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() @@ -1064,7 +1081,7 @@ 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) | @@ -1074,7 +1091,7 @@ impl EParser { ::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()))); + .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) | { @@ -1082,7 +1099,7 @@ impl EParser { 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) | { @@ -1117,7 +1134,7 @@ 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() @@ -1145,7 +1162,7 @@ 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, & @@ -1154,7 +1171,7 @@ impl EParser { ::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()))); + .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 { @@ -1171,7 +1188,7 @@ 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() @@ -1185,7 +1202,7 @@ 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) | @@ -1220,7 +1237,7 @@ 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() @@ -1231,7 +1248,7 @@ impl EParser { 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()))); + .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) | { @@ -1239,7 +1256,7 @@ impl EParser { 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) | { @@ -1247,7 +1264,7 @@ impl EParser { 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) | { @@ -1266,7 +1283,7 @@ 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 @@ -1275,7 +1292,7 @@ impl EParser { ::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()))); + .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 { @@ -1283,7 +1300,7 @@ impl EParser { ::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()))); + .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 { @@ -1300,7 +1317,7 @@ 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() @@ -1311,7 +1328,7 @@ impl EParser { 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()))); + .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) | { diff --git a/scripts/diff/json.rs b/scripts/diff/json.rs index d4c9028..dfe4321 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,7 +2019,7 @@ 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()) @@ -1966,7 +2035,7 @@ 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, & @@ -1982,7 +2051,7 @@ 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, & @@ -1991,7 +2060,7 @@ impl JsonParser { ::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()))); + .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 { @@ -1999,7 +2068,7 @@ impl JsonParser { ::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()))); + .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 { @@ -2097,7 +2166,7 @@ impl JsonParser { 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) | { @@ -2129,7 +2198,7 @@ impl JsonParser { 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) | { @@ -2161,7 +2230,7 @@ impl JsonParser { 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) | { @@ -2188,7 +2257,7 @@ 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(| @@ -2197,7 +2266,7 @@ impl JsonParser { ::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()))); + .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 { @@ -2212,7 +2281,7 @@ 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(| @@ -2221,7 +2290,7 @@ impl JsonParser { ::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()))); + .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 { @@ -2229,7 +2298,7 @@ impl JsonParser { ::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()))); + .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 { @@ -2244,7 +2313,7 @@ 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(| @@ -2253,7 +2322,7 @@ impl JsonParser { ::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()))); + .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 { @@ -2273,9 +2342,9 @@ 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()))); + .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(| (& @@ -2286,7 +2355,7 @@ impl JsonParser { ::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()))); + .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) | { @@ -2304,7 +2373,7 @@ 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 @@ -2375,7 +2444,7 @@ 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(| @@ -2391,7 +2460,7 @@ 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(| @@ -2407,7 +2476,7 @@ 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(| @@ -2424,7 +2493,7 @@ impl JsonParser { 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) | { @@ -2443,7 +2512,7 @@ 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() @@ -2459,7 +2528,7 @@ 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, & @@ -2475,7 +2544,7 @@ 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, & @@ -2492,7 +2561,7 @@ impl JsonParser { 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) | { @@ -2508,7 +2577,7 @@ impl JsonParser { 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) | { @@ -2518,7 +2587,7 @@ impl JsonParser { ::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()))); + .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) | { @@ -2536,7 +2605,7 @@ 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 @@ -2552,7 +2621,7 @@ 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, & @@ -2568,7 +2637,7 @@ 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, & @@ -2577,7 +2646,7 @@ impl JsonParser { ::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()))); + .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 { @@ -2658,7 +2727,7 @@ 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, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, @@ -2828,7 +2897,7 @@ impl JsonParser { ::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 + .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) | { @@ -2836,7 +2905,7 @@ impl JsonParser { 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) | { @@ -2905,7 +2974,7 @@ 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, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, @@ -2916,7 +2985,7 @@ impl JsonParser { 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) | { @@ -2932,7 +3001,7 @@ impl JsonParser { 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) | { @@ -2947,7 +3016,7 @@ 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, & @@ -2963,7 +3032,7 @@ 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, & @@ -2979,7 +3048,7 @@ 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, & @@ -3004,7 +3073,7 @@ 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(| @@ -3013,7 +3082,7 @@ impl JsonParser { ::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 + .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) | { @@ -3083,7 +3152,7 @@ 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(| @@ -3099,7 +3168,7 @@ 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(| @@ -3115,7 +3184,7 @@ 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(| @@ -3136,7 +3205,7 @@ impl JsonParser { ::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()))); + .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 { @@ -3151,7 +3220,7 @@ 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, & @@ -3167,7 +3236,7 @@ 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, & @@ -3183,7 +3252,7 @@ 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, & @@ -3192,7 +3261,7 @@ impl JsonParser { ::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 + .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) | { @@ -3205,7 +3274,7 @@ 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, & @@ -3228,7 +3297,7 @@ impl JsonParser { 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) | { @@ -3243,7 +3312,7 @@ 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(| @@ -3259,7 +3328,7 @@ 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, & @@ -3275,7 +3344,7 @@ 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, & @@ -3298,7 +3367,7 @@ impl JsonParser { 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) | { @@ -3313,7 +3382,7 @@ 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(| @@ -3329,7 +3398,7 @@ 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, & @@ -3352,7 +3421,7 @@ impl JsonParser { 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) | { @@ -3360,7 +3429,7 @@ impl JsonParser { 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) | { @@ -3375,7 +3444,7 @@ 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, & @@ -3391,7 +3460,7 @@ 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, & @@ -3407,7 +3476,7 @@ 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, & @@ -3421,7 +3490,7 @@ 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, & @@ -3451,7 +3520,7 @@ 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(| @@ -3467,7 +3536,7 @@ 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, & @@ -3483,7 +3552,7 @@ 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, & @@ -3513,7 +3582,7 @@ 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(| @@ -3529,7 +3598,7 @@ 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, & @@ -3552,7 +3621,7 @@ impl JsonParser { 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) | { @@ -3567,7 +3636,7 @@ 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, & @@ -3583,7 +3652,7 @@ 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, & @@ -3599,7 +3668,7 @@ 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, & @@ -3613,7 +3682,7 @@ 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, & @@ -3643,7 +3712,7 @@ 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(| @@ -3659,7 +3728,7 @@ 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, & @@ -3675,7 +3744,7 @@ 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, & @@ -3705,7 +3774,7 @@ 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(| @@ -3721,7 +3790,7 @@ 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, & From c02b34f96fff3eaaa1495c2afe246b19e4b49bac Mon Sep 17 00:00:00 2001 From: Taehwan Kim Date: Fri, 3 Oct 2025 23:57:21 +0900 Subject: [PATCH 2/3] emit ruleset and shifted static --- rusty_lr_parser/src/emit.rs | 7 +- rusty_lr_parser/src/parser/parser_expanded.rs | 1246 +++++++++-------- scripts/diff/calculator.rs | 90 +- scripts/diff/calculator_u8.rs | 200 +-- scripts/diff/json.rs | 1044 +++++++------- 5 files changed, 1307 insertions(+), 1280 deletions(-) diff --git a/rusty_lr_parser/src/emit.rs b/rusty_lr_parser/src/emit.rs index 12b9e5c..dbece0e 100644 --- a/rusty_lr_parser/src/emit.rs +++ b/rusty_lr_parser/src/emit.rs @@ -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); @@ -775,13 +776,13 @@ impl Grammar { __reduce_map.into_iter().collect() }, 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, diff --git a/rusty_lr_parser/src/parser/parser_expanded.rs b/rusty_lr_parser/src/parser/parser_expanded.rs index a63d5d5..7d00895 100644 --- a/rusty_lr_parser/src/parser/parser_expanded.rs +++ b/rusty_lr_parser/src/parser/parser_expanded.rs @@ -7534,14 +7534,14 @@ impl GrammarParser { (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, + .into_iter().collect() }, 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,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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::parengroup, ::rusty_lr_core::parser::state::ShiftTarget::new(2, true)),], @@ -7550,27 +7550,28 @@ impl GrammarParser { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![2]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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() } }, + __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) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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 : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(5, true)), @@ -7601,21 +7602,21 @@ impl GrammarParser { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![81]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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) | { + __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 : @@ -7636,28 +7637,28 @@ impl GrammarParser { (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::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + .into_iter().collect() }, 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) | { + .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) | { + .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 : @@ -7665,19 +7666,19 @@ impl GrammarParser { ::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(| - (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + 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(| - (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + ruleset : { static __RULES : [u8; 5usize] = [32, 33, 34, 35, 36,]; static + __SHIFTED : [u8; 5usize] = [2, 2, 2, 2, 2,]; __RULES.iter().zip(__SHIFTED + .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef + { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), @@ -7696,19 +7697,19 @@ impl GrammarParser { (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(| - (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + .into_iter().collect() }, 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) | { + .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 : @@ -7739,12 +7740,12 @@ impl GrammarParser { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![95]; __reduce_map.extend(__RUSTYLR_TSET4.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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)),], @@ -7753,17 +7754,17 @@ impl GrammarParser { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![87]; __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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) | { + .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 : @@ -7780,9 +7781,9 @@ impl GrammarParser { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![91]; __reduce_map.extend(__RUSTYLR_TSET6.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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 : @@ -7791,9 +7792,9 @@ impl GrammarParser { 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) | { + __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 : @@ -7803,26 +7804,26 @@ impl GrammarParser { ::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 : - shifted as usize, } }).collect() } }, + 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) | { + .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) | { + .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 : @@ -7831,9 +7832,9 @@ impl GrammarParser { 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) | { + __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 : @@ -7843,35 +7844,35 @@ impl GrammarParser { ::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 : - shifted as usize, } }).collect() } }, + 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) | { + .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) | { + .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) | { + .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 : @@ -7884,17 +7885,18 @@ impl GrammarParser { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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) | { + .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 : @@ -7902,26 +7904,26 @@ impl GrammarParser { ::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) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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) | { + .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) | { + .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 : @@ -7941,36 +7943,36 @@ impl GrammarParser { ::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) | { + 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) | { + .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) | { + .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) | { + .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 : @@ -7991,12 +7993,12 @@ impl GrammarParser { (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::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + .into_iter().collect() }, 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 : vec![(GrammarTerminalClasses::plus, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), @@ -8011,18 +8013,18 @@ impl GrammarParser { 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 : + __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) | { + .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 : @@ -8043,12 +8045,12 @@ impl GrammarParser { (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::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + .into_iter().collect() }, 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 : vec![(GrammarTerminalClasses::plus, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), @@ -8061,9 +8063,9 @@ impl GrammarParser { 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) | { + __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 : @@ -8084,28 +8086,28 @@ impl GrammarParser { (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(| - (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule - as usize, shifted : shifted as usize, } }).collect() } }, + .into_iter().collect() }, 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) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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) | { + .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 : @@ -8124,11 +8126,11 @@ impl GrammarParser { 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() } }, + __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)), @@ -8149,10 +8151,10 @@ impl GrammarParser { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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 : @@ -8171,18 +8173,18 @@ impl GrammarParser { 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() } }, + __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) | { + .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 : @@ -8192,10 +8194,10 @@ impl GrammarParser { ::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 : - shifted as usize, } }).collect() } }, + 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, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), @@ -8220,28 +8222,28 @@ impl GrammarParser { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![95]; __reduce_map.extend(__RUSTYLR_TSET4.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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) | { + .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) | { + .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 : @@ -8266,9 +8268,9 @@ impl GrammarParser { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![99]; __reduce_map.extend(__RUSTYLR_TSET10.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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 : @@ -8281,9 +8283,9 @@ impl GrammarParser { 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) | { + .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 : @@ -8291,17 +8293,17 @@ impl GrammarParser { ::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) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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) | { + .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 : @@ -8309,17 +8311,17 @@ impl GrammarParser { ::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) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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) | { + .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 : @@ -8327,17 +8329,17 @@ impl GrammarParser { ::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) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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) | { + .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 : @@ -8345,17 +8347,17 @@ impl GrammarParser { ::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) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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) | { + .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 : @@ -8363,17 +8365,17 @@ impl GrammarParser { ::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) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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) | { + .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 : @@ -8392,11 +8394,11 @@ impl GrammarParser { 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() } }, + .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)), @@ -8404,17 +8406,17 @@ impl GrammarParser { ::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 : - shifted as usize, } }).collect() } }, + 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) | { + .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 : @@ -8445,19 +8447,19 @@ impl GrammarParser { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![81]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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) | { + .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 : @@ -8465,8 +8467,8 @@ impl GrammarParser { = std::collections::BTreeMap::new(); let reduce_rules = vec![78]; __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 : @@ -8485,11 +8487,11 @@ impl GrammarParser { 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() } }, + .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)), @@ -8512,10 +8514,10 @@ impl GrammarParser { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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 : @@ -8523,8 +8525,8 @@ impl GrammarParser { = std::collections::BTreeMap::new(); let reduce_rules = vec![79]; __reduce_map.extend(__RUSTYLR_TSET11.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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 : @@ -8539,9 +8541,9 @@ impl GrammarParser { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![85]; __reduce_map.extend(__RUSTYLR_TSET14.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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 : @@ -8553,10 +8555,10 @@ impl GrammarParser { ::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(| (& - rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + 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 : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)), @@ -8567,9 +8569,9 @@ impl GrammarParser { 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) | { + .into_iter().collect() }, 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 : @@ -8577,8 +8579,8 @@ impl GrammarParser { = std::collections::BTreeMap::new(); let reduce_rules = vec![39]; __reduce_map.extend(__RUSTYLR_TSET15.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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 : @@ -8586,26 +8588,28 @@ impl GrammarParser { = std::collections::BTreeMap::new(); let reduce_rules = vec![40]; __reduce_map.extend(__RUSTYLR_TSET15.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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() } }, + __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() } }, + __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)), @@ -8613,42 +8617,44 @@ impl GrammarParser { ::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 : - shifted as usize, } }).collect() } }, + 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() } }, + __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() } }, + __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) | { + .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) | { + .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 : @@ -8659,17 +8665,17 @@ impl GrammarParser { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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) | { + .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 : @@ -8680,35 +8686,35 @@ impl GrammarParser { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![38]; __reduce_map.extend(__RUSTYLR_TSET13.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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_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) | { + .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) | { + .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 : @@ -8748,12 +8754,12 @@ impl GrammarParser { ::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, + 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,]; let shifted : & 'static [u8] = & [1, 1, 1, 1, + 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 : + 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, @@ -8767,9 +8773,9 @@ impl GrammarParser { (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) | { + .into_iter().collect() }, 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 : @@ -8777,17 +8783,17 @@ impl GrammarParser { ::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) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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_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 : @@ -8795,8 +8801,8 @@ impl GrammarParser { = std::collections::BTreeMap::new(); let reduce_rules = vec![143]; __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 : @@ -8809,9 +8815,9 @@ impl GrammarParser { 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) | { + .into_iter().collect() }, 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 : @@ -8819,8 +8825,8 @@ impl GrammarParser { = std::collections::BTreeMap::new(); let reduce_rules = vec![50]; __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 : @@ -8828,8 +8834,8 @@ impl GrammarParser { = std::collections::BTreeMap::new(); let reduce_rules = vec![144]; __reduce_map.extend(__RUSTYLR_TSET16.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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 : @@ -8844,9 +8850,9 @@ impl GrammarParser { (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) | { + .into_iter().collect() }, 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 : @@ -8854,17 +8860,17 @@ impl GrammarParser { ::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) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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_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 : @@ -8877,9 +8883,9 @@ impl GrammarParser { 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) | { + .into_iter().collect() }, 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 : @@ -8887,8 +8893,8 @@ impl GrammarParser { = std::collections::BTreeMap::new(); let reduce_rules = vec![52]; __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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 : @@ -8898,10 +8904,10 @@ impl GrammarParser { ::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, - shifted : shifted as usize, } }).collect() } }, + 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, ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), @@ -8992,22 +8998,22 @@ impl GrammarParser { (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, - 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, + .into_iter().collect() }, 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,]; + 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,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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![42]; __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 : @@ -9015,8 +9021,8 @@ impl GrammarParser { = std::collections::BTreeMap::new(); let reduce_rules = vec![141]; __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 : @@ -9107,13 +9113,13 @@ impl GrammarParser { 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, + .into_iter().collect() }, 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,]; 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) | { + 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 : @@ -9121,8 +9127,8 @@ impl GrammarParser { = std::collections::BTreeMap::new(); let reduce_rules = vec![41]; __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 : @@ -9130,8 +9136,8 @@ impl GrammarParser { = std::collections::BTreeMap::new(); let reduce_rules = vec![142]; __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 : @@ -9139,17 +9145,17 @@ impl GrammarParser { ::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) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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_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 : @@ -9159,26 +9165,26 @@ impl GrammarParser { ::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 : - shifted as usize, } }).collect() } }, + 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) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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_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 : @@ -9186,17 +9192,17 @@ impl GrammarParser { ::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) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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_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 : @@ -9289,22 +9295,22 @@ impl GrammarParser { (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, - 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, + .into_iter().collect() }, 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,]; + 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,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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![47]; __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 : @@ -9395,13 +9401,13 @@ impl GrammarParser { 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, + .into_iter().collect() }, 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,]; 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) | { + 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 : @@ -9409,8 +9415,8 @@ impl GrammarParser { = std::collections::BTreeMap::new(); let reduce_rules = vec![46]; __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 : @@ -9503,22 +9509,22 @@ impl GrammarParser { (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, - 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, + .into_iter().collect() }, 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,]; + 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,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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![49]; __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 : @@ -9609,13 +9615,13 @@ impl GrammarParser { 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, + .into_iter().collect() }, 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,]; 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) | { + 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 : @@ -9623,8 +9629,8 @@ impl GrammarParser { = std::collections::BTreeMap::new(); let reduce_rules = vec![48]; __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 : @@ -9717,22 +9723,22 @@ impl GrammarParser { (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, - 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, + .into_iter().collect() }, 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,]; + 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,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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![57]; __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 : @@ -9823,13 +9829,13 @@ impl GrammarParser { 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, + .into_iter().collect() }, 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,]; 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) | { + 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 : @@ -9837,8 +9843,8 @@ impl GrammarParser { = std::collections::BTreeMap::new(); let reduce_rules = vec![56]; __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 : @@ -9931,22 +9937,22 @@ impl GrammarParser { (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, - 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, + .into_iter().collect() }, 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,]; + 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,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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![59]; __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 : @@ -10037,13 +10043,13 @@ impl GrammarParser { 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, + .into_iter().collect() }, 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,]; 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) | { + 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 : @@ -10051,8 +10057,8 @@ impl GrammarParser { = std::collections::BTreeMap::new(); let reduce_rules = vec![58]; __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 : @@ -10062,17 +10068,17 @@ impl GrammarParser { ::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 : - shifted as usize, } }).collect() } }, + 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_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 : @@ -10080,17 +10086,17 @@ impl GrammarParser { ::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) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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_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 : @@ -10100,17 +10106,17 @@ impl GrammarParser { ::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 : - shifted as usize, } }).collect() } }, + 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_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 : @@ -10118,17 +10124,17 @@ impl GrammarParser { ::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) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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_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 : @@ -10143,9 +10149,9 @@ impl GrammarParser { (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) | { + .into_iter().collect() }, 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 : @@ -10153,17 +10159,17 @@ impl GrammarParser { ::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) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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_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 : @@ -10176,9 +10182,9 @@ impl GrammarParser { 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) | { + .into_iter().collect() }, 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 : @@ -10186,8 +10192,8 @@ impl GrammarParser { = std::collections::BTreeMap::new(); let reduce_rules = vec![54]; __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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 : @@ -10197,17 +10203,17 @@ impl GrammarParser { ::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 : - shifted as usize, } }).collect() } }, + 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_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 : @@ -10215,17 +10221,17 @@ impl GrammarParser { ::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) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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_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 : @@ -10235,17 +10241,17 @@ impl GrammarParser { ::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 : - shifted as usize, } }).collect() } }, + 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_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 : @@ -10253,17 +10259,17 @@ impl GrammarParser { ::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) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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_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 : @@ -10278,17 +10284,17 @@ impl GrammarParser { { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = vec![148]; __reduce_map.extend(__RUSTYLR_TSET18.iter().map(| term | (* term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, 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_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 : @@ -10296,17 +10302,17 @@ impl GrammarParser { ::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) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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_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 : @@ -10315,9 +10321,9 @@ impl GrammarParser { 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) | { + .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 : @@ -10325,8 +10331,8 @@ impl GrammarParser { = std::collections::BTreeMap::new(); let reduce_rules = vec![146]; __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 : @@ -10334,17 +10340,17 @@ impl GrammarParser { ::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) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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_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 : @@ -10437,22 +10443,22 @@ impl GrammarParser { (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, - 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, + .into_iter().collect() }, 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,]; + 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,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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![71]; __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 : @@ -10543,13 +10549,13 @@ impl GrammarParser { 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, + .into_iter().collect() }, 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,]; 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) | { + 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 : @@ -10557,8 +10563,8 @@ impl GrammarParser { = std::collections::BTreeMap::new(); let reduce_rules = vec![70]; __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 : @@ -10651,22 +10657,22 @@ impl GrammarParser { (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, - 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, + .into_iter().collect() }, 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,]; + 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,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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![73]; __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 : @@ -10757,13 +10763,13 @@ impl GrammarParser { 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, + .into_iter().collect() }, 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,]; 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) | { + 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 : @@ -10771,8 +10777,8 @@ impl GrammarParser { = std::collections::BTreeMap::new(); let reduce_rules = vec![72]; __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 : @@ -10780,17 +10786,17 @@ impl GrammarParser { ::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) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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_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 : @@ -10798,8 +10804,8 @@ impl GrammarParser { = std::collections::BTreeMap::new(); let reduce_rules = vec![75]; __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 : @@ -10818,12 +10824,12 @@ impl GrammarParser { { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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 : @@ -10831,8 +10837,8 @@ impl GrammarParser { = std::collections::BTreeMap::new(); let reduce_rules = vec![150]; __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 : @@ -10840,17 +10846,17 @@ impl GrammarParser { ::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) | { - ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted : - shifted as usize, } }).collect() } }, + 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() } }, + 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 9365a24..c11c301 100644 --- a/scripts/diff/calculator.rs +++ b/scripts/diff/calculator.rs @@ -718,17 +718,17 @@ impl EParser { ::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) | { + .into_iter().collect() }, 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, 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, @@ -740,9 +740,9 @@ impl EParser { ::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) | { + .into_iter().collect() }, 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, @@ -750,9 +750,9 @@ impl EParser { 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) | { + __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, @@ -763,17 +763,17 @@ impl EParser { ::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) | { + .into_iter().collect() }, 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, 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, @@ -781,9 +781,9 @@ impl EParser { 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) | { + __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, @@ -793,49 +793,51 @@ impl EParser { ::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) | { + .into_iter().collect() }, 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, 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) | { - ::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, - 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) | { + 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, 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::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) | { - ::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(| - (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + 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 : { 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() } }, ]; let states: Vec = states.into_iter().map(|state| state.into()).collect(); Self { rules, states } diff --git a/scripts/diff/calculator_u8.rs b/scripts/diff/calculator_u8.rs index aa5cbf9..e07ee48 100644 --- a/scripts/diff/calculator_u8.rs +++ b/scripts/diff/calculator_u8.rs @@ -1024,17 +1024,17 @@ impl EParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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, 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, @@ -1045,17 +1045,17 @@ impl EParser { 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) | { + .into_iter().collect() }, 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(| - (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + .into_iter().collect() }, 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![(ETerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(6, false)),], @@ -1070,9 +1070,9 @@ impl EParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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, @@ -1083,26 +1083,27 @@ impl EParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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) | { + __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, 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, @@ -1118,12 +1119,12 @@ impl EParser { (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() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(ETerminalClasses::TermClass0, + 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)),], shift_goto_map_nonterm : vec![(ENonTerminals::Number, ::rusty_lr::parser::state::ShiftTarget::new(1, true)), (ENonTerminals::P, @@ -1136,9 +1137,9 @@ impl EParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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, @@ -1150,9 +1151,9 @@ 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(); __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) | { + .into_iter().collect() }, 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, @@ -1164,20 +1165,20 @@ impl EParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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, + __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, @@ -1190,9 +1191,9 @@ impl EParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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, @@ -1204,11 +1205,12 @@ impl EParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -1221,12 +1223,12 @@ impl EParser { (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() } }, - ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : - vec![(ETerminalClasses::TermClass0, + 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)),], shift_goto_map_nonterm : vec![(ENonTerminals::Number, ::rusty_lr::parser::state::ShiftTarget::new(1, true)), (ENonTerminals::P, @@ -1239,9 +1241,9 @@ impl EParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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 : @@ -1249,25 +1251,25 @@ impl EParser { 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) | { + __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, 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, 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, @@ -1285,28 +1287,28 @@ impl EParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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, @@ -1319,9 +1321,9 @@ impl EParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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 : @@ -1329,9 +1331,9 @@ impl EParser { 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) | { + __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 dfe4321..55d0788 100644 --- a/scripts/diff/json.rs +++ b/scripts/diff/json.rs @@ -2021,12 +2021,12 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); 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] = & [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)),], @@ -2037,10 +2037,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); 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] = & [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)), @@ -2053,41 +2053,42 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); 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] = & [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) | { + __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(| - (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as - usize, shifted : shifted as usize, } }).collect() } }, + 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 : { let mut __reduce_map = + std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, + 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 : { let mut __reduce_map = + std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, + 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 : vec![(JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(8, false)), @@ -2125,115 +2126,125 @@ impl JsonParser { (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, + .into_iter().collect() }, 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,]; 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(| (& - rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + 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) | { - ::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, + 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) | { - ::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, + 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) | { - ::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, + 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) | { - ::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, - 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) | { + 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, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 1usize] = [46,]; static __SHIFTED : [u8; 1usize] = [5,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::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) | { - ::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, + 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) | { - ::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, + 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) | { - ::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, - 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) | { + 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, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 1usize] = [47,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::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) | { - ::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, + 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) | { - ::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, + 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) | { - ::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, - 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) | { + 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, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 1usize] = [45,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, @@ -2243,9 +2254,9 @@ impl JsonParser { 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) | { + .into_iter().collect() }, 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, @@ -2259,20 +2270,20 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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, + __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)),], @@ -2283,28 +2294,28 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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, + __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)),], @@ -2315,20 +2326,20 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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, + __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)),], @@ -2345,20 +2356,20 @@ impl JsonParser { 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() } }, + __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) | { + __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, @@ -2375,12 +2386,12 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); 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] = & [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)), @@ -2416,12 +2427,12 @@ impl JsonParser { (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, + .into_iter().collect() }, 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,]; 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(| (& - rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + 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::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(26, false)), @@ -2430,9 +2441,9 @@ impl JsonParser { 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) | { + .into_iter().collect() }, 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, @@ -2446,10 +2457,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -2462,10 +2473,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -2478,25 +2489,26 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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) | { - ::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, - 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) | { + 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, 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::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, @@ -2514,9 +2526,9 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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, @@ -2530,10 +2542,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -2546,41 +2558,43 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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) | { - ::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, - 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) | { + 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, reduce_rules.clone()))); + __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; + 1usize] = [10,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter() + .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::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) | { - ::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, - 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) | { + 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, 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::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass12, @@ -2588,9 +2602,9 @@ impl JsonParser { 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) | { + __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, @@ -2607,12 +2621,12 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)),], @@ -2623,10 +2637,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -2639,26 +2653,26 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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, + __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 + .into_iter().collect() }, 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 : @@ -2729,11 +2743,11 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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, @@ -2757,11 +2771,11 @@ impl JsonParser { 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, & - shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted - : shifted as usize, } }).collect() } }, + .into_iter().collect() }, 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 : vec![(JsonTerminalClasses::TermClass5, ::rusty_lr::parser::state::ShiftTarget::new(55, false)), @@ -2790,13 +2804,13 @@ impl JsonParser { (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::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass5, + .into_iter().collect() }, 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)), (JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(56, false)), @@ -2823,13 +2837,13 @@ impl JsonParser { (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::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass5, + .into_iter().collect() }, 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)), (JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(57, false)), @@ -2856,13 +2870,13 @@ impl JsonParser { (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::IntermediateState { shift_goto_map_term : - vec![(JsonTerminalClasses::TermClass5, + .into_iter().collect() }, 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)), (JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(58, false)), @@ -2889,26 +2903,26 @@ impl JsonParser { (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::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) | { + .into_iter().collect() }, 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 : { + 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, 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, @@ -2976,35 +2990,36 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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, 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) | { - ::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, - 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) | { + 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, reduce_rules + .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES + : [u8; 1usize] = [16,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES + .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, @@ -3018,10 +3033,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3034,10 +3049,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3050,20 +3065,21 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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) | { - ::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, + 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, ::rusty_lr::parser::state::ShiftTarget::new(1, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(2, false)),], @@ -3075,17 +3091,17 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); 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] = & [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) | { + .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, @@ -3124,12 +3140,12 @@ impl JsonParser { (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, + .into_iter().collect() }, 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,]; 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(| (& - rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + 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::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(26, false)), @@ -3138,9 +3154,9 @@ impl JsonParser { 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) | { + .into_iter().collect() }, 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, @@ -3154,10 +3170,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3170,10 +3186,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3186,10 +3202,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3198,20 +3214,20 @@ impl JsonParser { 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 - .iter()).map(| (& rule, & 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, + .into_iter().collect() }, 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 : { + 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)),], @@ -3222,10 +3238,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3238,10 +3254,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3254,17 +3270,17 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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) | { + .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, @@ -3276,10 +3292,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3290,17 +3306,17 @@ impl JsonParser { (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) | { + .into_iter().collect() }, 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, 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, @@ -3314,10 +3330,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3330,10 +3346,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3346,10 +3362,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3360,17 +3376,17 @@ impl JsonParser { (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) | { + .into_iter().collect() }, 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, 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, @@ -3384,10 +3400,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3400,10 +3416,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3414,25 +3430,25 @@ impl JsonParser { (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) | { + .into_iter().collect() }, 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, 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, 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, @@ -3446,10 +3462,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3462,10 +3478,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3478,10 +3494,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)),], @@ -3492,10 +3508,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3506,9 +3522,9 @@ impl JsonParser { (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) | { + .into_iter().collect() }, 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, @@ -3522,10 +3538,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3538,10 +3554,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3554,10 +3570,10 @@ impl JsonParser { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3568,9 +3584,9 @@ impl JsonParser { (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) | { + .into_iter().collect() }, 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, @@ -3584,10 +3600,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3600,10 +3616,10 @@ impl JsonParser { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3614,17 +3630,17 @@ impl JsonParser { (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) | { + .into_iter().collect() }, 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, 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, @@ -3638,10 +3654,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3654,10 +3670,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3670,10 +3686,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)),], @@ -3684,10 +3700,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3698,9 +3714,9 @@ impl JsonParser { (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) | { + .into_iter().collect() }, 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, @@ -3714,10 +3730,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3730,10 +3746,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3746,10 +3762,10 @@ impl JsonParser { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3760,9 +3776,9 @@ impl JsonParser { (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) | { + .into_iter().collect() }, 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, @@ -3776,10 +3792,10 @@ impl JsonParser { mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3792,10 +3808,10 @@ impl JsonParser { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules = 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)), @@ -3806,9 +3822,9 @@ impl JsonParser { (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) | { + .into_iter().collect() }, 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() } }, ]; From e97141e7b2f5e54cd7a096d93b24fd4d7162d8dc Mon Sep 17 00:00:00 2001 From: Taehwan Kim Date: Sat, 4 Oct 2025 00:00:26 +0900 Subject: [PATCH 3/3] use Default if reduce_map was empty in code emit --- rusty_lr_parser/src/emit.rs | 18 +- rusty_lr_parser/src/parser/parser_expanded.rs | 794 ++++++++---------- scripts/diff/calculator.rs | 81 +- scripts/diff/calculator_u8.rs | 55 +- scripts/diff/json.rs | 571 ++++++------- 5 files changed, 696 insertions(+), 823 deletions(-) diff --git a/rusty_lr_parser/src/emit.rs b/rusty_lr_parser/src/emit.rs index dbece0e..d67dc77 100644 --- a/rusty_lr_parser/src/emit.rs +++ b/rusty_lr_parser/src/emit.rs @@ -766,15 +766,23 @@ 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: { static __RULES: [#rule_index_typename; #ruleset_len] = [ #ruleset_rules_body_stream diff --git a/rusty_lr_parser/src/parser/parser_expanded.rs b/rusty_lr_parser/src/parser/parser_expanded.rs index 7d00895..e9763e6 100644 --- a/rusty_lr_parser/src/parser/parser_expanded.rs +++ b/rusty_lr_parser/src/parser/parser_expanded.rs @@ -7533,15 +7533,14 @@ 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 : { 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, + 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, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & - shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + 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, ::rusty_lr_core::parser::state::ShiftTarget::new(2, true)),], @@ -7566,12 +7565,11 @@ impl GrammarParser { ::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 : { 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() } }, + 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 : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(5, true)), @@ -7635,14 +7633,13 @@ 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 : { 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::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]; @@ -7664,21 +7661,19 @@ impl GrammarParser { ::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 : { 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() } }, + 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 : { 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() } }, + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 5usize] = [32, 33, 34, 35, 36,]; static __SHIFTED : + [u8; 5usize] = [2, 2, 2, 2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule + as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), @@ -7695,14 +7690,13 @@ 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 : { 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::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]; @@ -7802,12 +7796,11 @@ 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 : { 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() } }, + 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]; @@ -7842,12 +7835,11 @@ 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 : { 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() } }, + 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]; @@ -7902,12 +7894,11 @@ impl GrammarParser { ::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 : { 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() } }, + 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]; @@ -7941,11 +7932,10 @@ 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 : { 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) | { + 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 : @@ -7991,14 +7981,13 @@ 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 : { 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::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 : vec![(GrammarTerminalClasses::plus, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), @@ -8043,14 +8032,13 @@ 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 : { 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::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 : vec![(GrammarTerminalClasses::plus, ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)), @@ -8084,23 +8072,21 @@ 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 : { 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::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 : { 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() } }, + 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]; @@ -8192,12 +8178,11 @@ 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 : { 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() } }, + 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, ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)), @@ -8291,12 +8276,11 @@ impl GrammarParser { ::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 : { 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() } }, + 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]; @@ -8309,12 +8293,11 @@ impl GrammarParser { ::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 : { 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() } }, + 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]; @@ -8327,12 +8310,11 @@ impl GrammarParser { ::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 : { 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() } }, + 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]; @@ -8345,12 +8327,11 @@ impl GrammarParser { ::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 : { 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() } }, + 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]; @@ -8363,12 +8344,11 @@ impl GrammarParser { ::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 : { 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() } }, + 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]; @@ -8404,12 +8384,11 @@ impl GrammarParser { ::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 : { 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() } }, + 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 @@ -8553,12 +8532,11 @@ 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 : { 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() } }, + 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 : vec![(GrammarTerminalClasses::ident, ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)), @@ -8567,10 +8545,9 @@ 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 : { static __RULES : [u8; 4usize] = [6, 7, - 39, 40,]; static __SHIFTED : [u8; 4usize] = [2, 2, 0, 0,]; __RULES.iter() + ::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() } }, @@ -8615,12 +8592,11 @@ impl GrammarParser { ::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 : { 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() } }, + 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 @@ -8752,14 +8728,13 @@ 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 : { 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 : + 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 : vec![(GrammarTerminalClasses::ident, @@ -8771,22 +8746,20 @@ 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 : { 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::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 : { 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() } }, + 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]; @@ -8813,11 +8786,10 @@ 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 : { 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::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 : @@ -8849,21 +8821,19 @@ 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 : { 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) | { + 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 : { 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() } }, + 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]; @@ -8881,11 +8851,10 @@ 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 : { 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::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 : @@ -8902,12 +8871,11 @@ 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 : { 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() } }, + 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, ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)), @@ -8997,16 +8965,15 @@ 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 : { 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,]; - static __SHIFTED : [u8; 45usize] = [3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 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,]; 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, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & - shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + 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]; @@ -9112,14 +9079,13 @@ 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 : { 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) | { + 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 : @@ -9143,12 +9109,11 @@ impl GrammarParser { ::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 : { 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() } }, + 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]; @@ -9163,21 +9128,19 @@ 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 : { 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() } }, + 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 : { 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() } }, + 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]; @@ -9190,12 +9153,11 @@ impl GrammarParser { ::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 : { 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() } }, + 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]; @@ -9294,16 +9256,15 @@ 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 : { 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,]; - static __SHIFTED : [u8; 45usize] = [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 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,]; 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, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & - shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + 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]; @@ -9400,14 +9361,13 @@ 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 : { 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) | { + 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 : @@ -9508,16 +9468,15 @@ 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 : { 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,]; - static __SHIFTED : [u8; 45usize] = [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 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,]; 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, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & - shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + 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]; @@ -9614,14 +9573,13 @@ 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 : { 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) | { + 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 : @@ -9722,16 +9680,15 @@ 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 : { 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,]; - static __SHIFTED : [u8; 45usize] = [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 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,]; 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, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & - shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + 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]; @@ -9828,14 +9785,13 @@ 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 : { 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) | { + 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 : @@ -9936,16 +9892,15 @@ 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 : { 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,]; - static __SHIFTED : [u8; 45usize] = [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 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,]; 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, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & - shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + 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]; @@ -10042,14 +9997,13 @@ 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 : { 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) | { + 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 : @@ -10066,12 +10020,11 @@ 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 : { 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() } }, + 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]; @@ -10084,12 +10037,11 @@ impl GrammarParser { ::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 : { 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() } }, + 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]; @@ -10104,12 +10056,11 @@ 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 : { 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() } }, + 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]; @@ -10122,12 +10073,11 @@ impl GrammarParser { ::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 : { 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() } }, + 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]; @@ -10148,21 +10098,19 @@ 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 : { 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) | { + 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 : { 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() } }, + 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]; @@ -10180,11 +10128,10 @@ 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 : { 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::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 : @@ -10201,12 +10148,11 @@ 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 : { 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() } }, + 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]; @@ -10219,12 +10165,11 @@ impl GrammarParser { ::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 : { 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() } }, + 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]; @@ -10239,12 +10184,11 @@ 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 : { 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() } }, + 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]; @@ -10257,12 +10201,11 @@ impl GrammarParser { ::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 : { 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() } }, + 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]; @@ -10300,12 +10243,11 @@ impl GrammarParser { ::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 : { 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() } }, + 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]; @@ -10338,12 +10280,11 @@ impl GrammarParser { ::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 : { 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() } }, + 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]; @@ -10442,16 +10383,15 @@ 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 : { 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,]; - static __SHIFTED : [u8; 45usize] = [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 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,]; 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, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & - shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + 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]; @@ -10548,14 +10488,13 @@ 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 : { 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) | { + 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 : @@ -10656,16 +10595,15 @@ 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 : { 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,]; - static __SHIFTED : [u8; 45usize] = [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 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,]; 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, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & - shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, - shifted : shifted as usize, } }).collect() } }, + 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]; @@ -10762,14 +10700,13 @@ 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 : { 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) | { + 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 : @@ -10784,12 +10721,11 @@ impl GrammarParser { ::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 : { 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() } }, + 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]; @@ -10844,15 +10780,13 @@ impl GrammarParser { ::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 : { 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() } }, + 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() }, + 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, diff --git a/scripts/diff/calculator.rs b/scripts/diff/calculator.rs index c11c301..a50d2cd 100644 --- a/scripts/diff/calculator.rs +++ b/scripts/diff/calculator.rs @@ -716,11 +716,10 @@ 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 : { 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::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 : { @@ -738,11 +737,10 @@ 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 : { 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::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, @@ -761,11 +759,10 @@ 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 : { 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::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 : { @@ -791,10 +788,9 @@ 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 : { static __RULES : [u8; 5usize] = [2, 2, - 3, 4, 5,]; static __SHIFTED : [u8; 5usize] = [0, 2, 0, 0, 0,]; __RULES.iter() + ::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 { @@ -808,36 +804,31 @@ impl EParser { 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 : { 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, 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) | { + 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, + 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::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 : { 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 : { 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() } }, + shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : { + static __RULES : [u8; 1usize] = [7,]; static __SHIFTED : [u8; 1usize] = [1,]; + __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as + usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { + shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : + Default::default(), ruleset : { static __RULES : [u8; 1usize] = [7,]; static + __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| + (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as + usize, shifted : shifted as usize, } }).collect() } }, ]; let states: Vec = states.into_iter().map(|state| state.into()).collect(); Self { rules, states } diff --git a/scripts/diff/calculator_u8.rs b/scripts/diff/calculator_u8.rs index e07ee48..36d6ae9 100644 --- a/scripts/diff/calculator_u8.rs +++ b/scripts/diff/calculator_u8.rs @@ -1043,19 +1043,17 @@ 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 : { static __RULES : [u8; 4usize] = [5, 8, - 9, 16,]; static __SHIFTED : [u8; 4usize] = [1, 0, 0, 1,]; __RULES.iter() + ::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 : { 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() } }, + 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 : vec![(ETerminalClasses::TermClass0, ::rusty_lr::parser::state::ShiftTarget::new(6, false)),], @@ -1117,14 +1115,13 @@ 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 : { 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, + 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)),], shift_goto_map_nonterm : vec![(ENonTerminals::Number, ::rusty_lr::parser::state::ShiftTarget::new(1, true)), (ENonTerminals::P, @@ -1149,10 +1146,9 @@ 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 : { static __RULES : [u8; 4usize] = [4, 5, - 8, 9,]; static __SHIFTED : [u8; 4usize] = [3, 1, 0, 0,]; __RULES.iter() + ::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 { @@ -1221,14 +1217,13 @@ 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 : { 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, + 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)),], shift_goto_map_nonterm : vec![(ENonTerminals::Number, ::rusty_lr::parser::state::ShiftTarget::new(1, true)), (ENonTerminals::P, diff --git a/scripts/diff/json.rs b/scripts/diff/json.rs index 55d0788..d556b2c 100644 --- a/scripts/diff/json.rs +++ b/scripts/diff/json.rs @@ -2076,19 +2076,16 @@ impl JsonParser { 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 : { 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 : { let mut __reduce_map = - std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() }, - 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() } }, + 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 : vec![(JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(8, false)), @@ -2124,127 +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 : { 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::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 : { 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, + 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 : { 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, + 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 : { 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, + 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 : { 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, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; - 1usize] = [46,]; static __SHIFTED : [u8; 1usize] = [5,]; __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, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { + static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] = + [5,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::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 : { 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, + 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 : { 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, + 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 : { 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, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; - 1usize] = [47,]; static __SHIFTED : [u8; 1usize] = [4,]; __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, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { + static __RULES : [u8; 1usize] = [47,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::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 : { 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, + 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 : { 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, + 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 : { 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, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; - 1usize] = [45,]; static __SHIFTED : [u8; 1usize] = [4,]; __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, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { + static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] = + [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14, @@ -2252,10 +2228,9 @@ 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 : { static __RULES : [u8; 4usize] = [34, - 35, 92, 93,]; static __SHIFTED : [u8; 4usize] = [1, 1, 0, 0,]; __RULES.iter() + ::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 { @@ -2425,24 +2400,22 @@ 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 : { 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::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 : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(26, false)), (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 : { static __RULES : [u8; 4usize] = [34, - 35, 92, 93,]; static __SHIFTED : [u8; 4usize] = [1, 1, 0, 0,]; __RULES.iter() + ::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 { @@ -2496,19 +2469,17 @@ impl JsonParser { ::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 : { 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, 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) | { + 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, + 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::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, @@ -2565,36 +2536,32 @@ impl JsonParser { ::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 : { 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, reduce_rules.clone()))); - __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8; - 1usize] = [10,]; static __SHIFTED : [u8; 1usize] = [3,]; __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, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { + static __RULES : [u8; 1usize] = [10,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::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 : { 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, 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) | { + 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, + 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::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass12, @@ -2669,10 +2636,9 @@ impl JsonParser { 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 : { static __RULES : [u8; 2usize] = [13, - 16,]; static __SHIFTED : [u8; 2usize] = [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 : @@ -2769,13 +2735,12 @@ 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 : { 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::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 : vec![(JsonTerminalClasses::TermClass5, ::rusty_lr::parser::state::ShiftTarget::new(55, false)), @@ -2802,15 +2767,14 @@ 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 : { 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(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)), (JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(56, false)), @@ -2835,15 +2799,14 @@ 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 : { 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(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)), (JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(57, false)), @@ -2868,15 +2831,14 @@ 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 : { 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(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)), (JsonTerminalClasses::TermClass6, ::rusty_lr::parser::state::ShiftTarget::new(58, false)), @@ -2901,20 +2863,19 @@ 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 : { 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 : { - static __RULES : [u8; 1usize] = [27,]; static __SHIFTED : [u8; 1usize] = - [5,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { + ::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 : { 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 : { @@ -3007,19 +2968,17 @@ impl JsonParser { 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 : { 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, reduce_rules - .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES - : [u8; 1usize] = [16,]; static __SHIFTED : [u8; 1usize] = [3,]; __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, + reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : { + static __RULES : [u8; 1usize] = [16,]; static __SHIFTED : [u8; 1usize] = + [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0, @@ -3072,14 +3031,12 @@ impl JsonParser { ::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 : { 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, + 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, ::rusty_lr::parser::state::ShiftTarget::new(1, false)), (JsonTerminalClasses::TermClass1, ::rusty_lr::parser::state::ShiftTarget::new(2, false)),], @@ -3138,24 +3095,22 @@ 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 : { 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::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 : vec![(JsonTerminalClasses::TermClass14, ::rusty_lr::parser::state::ShiftTarget::new(26, false)), (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 : { static __RULES : [u8; 4usize] = [34, - 35, 92, 93,]; static __SHIFTED : [u8; 4usize] = [1, 1, 0, 0,]; __RULES.iter() + ::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 { @@ -3212,21 +3167,20 @@ impl JsonParser { (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 : { static __RULES : [u8; 3usize] = [8, 13, - 16,]; static __SHIFTED : [u8; 3usize] = [2, 1, 0,]; __RULES.iter() + ::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 : { 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![], 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 : { - 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, @@ -3304,11 +3258,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(84, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, 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::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 : { @@ -3374,11 +3327,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(89, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, 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::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 : { @@ -3428,11 +3380,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(89, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, 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::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 : { @@ -3520,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 : { 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::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, @@ -3582,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 : { 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::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, @@ -3628,11 +3577,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(103, true)),], reduce_map : { let - mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map - .into_iter().collect() }, 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::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 : { @@ -3712,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 : { 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::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, @@ -3774,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 : { 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::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, @@ -3820,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 : { 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::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() } }, ];