#[doc(hidden)]
mod __table {
use super::gazelle;
pub static DATA: &[u32] = &[
15u32, 12u32, 13u32, 14u32, 15u32, 33u32, 16u32, 27u32, 20u32, 22u32, 16u32,
26u32, 4294967295u32, 22u32, 42u32, 8u32, 19u32, 21u32, 37u32, 25u32, 5u32, 6u32,
41u32, 46u32, 48u32, 49u32, 50u32, 39u32, 24u32, 18u32, 32u32, 43u32, 9u32, 0u32,
7u32, 29u32, 2u32, 34u32, 11u32, 0u32, 0u32, 0u32, 0u32, 0u32, 30u32, 0u32, 0u32,
0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32,
0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32,
0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32,
0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32,
0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32,
0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32,
0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32,
];
pub static CHECK: &[u32] = &[
1u32, 18u32, 19u32, 20u32, 1u32, 4u32, 7u32, 6u32, 3u32, 10u32, 7u32, 9u32, 0u32,
10u32, 1u32, 13u32, 17u32, 2u32, 1u32, 15u32, 16u32, 5u32, 1u32, 1u32, 1u32,
1u32, 1u32, 7u32, 14u32, 21u32, 12u32, 25u32, 23u32, 4294967295u32, 8u32, 16u32,
4u32, 8u32, 11u32, 4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32,
4294967295u32, 16u32, 4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32,
4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32,
4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32,
4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32,
4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32,
4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32,
4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32,
4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32,
4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32,
4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32,
4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32,
4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32,
4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32,
4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32,
4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32,
4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32,
4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32,
4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32, 4294967295u32,
];
pub static ACTION_BASE: &[i32] = &[
5i32,
12i32,
0i32,
7i32,
13i32,
10i32,
11i32,
16i32,
16i32,
30i32,
31i32,
33i32,
34i32,
35i32,
36i32,
-17i32,
37i32,
17i32,
21i32,
22i32,
23i32,
24i32,
25i32,
-1i32,
3i32,
3i32,
13i32,
15i32,
38i32,
39i32,
40i32,
1i32,
20i32,
26i32,
41i32,
42i32,
43i32,
18i32,
44i32,
45i32,
2i32,
27i32,
14i32,
46i32,
47i32,
48i32,
49i32,
4i32,
19i32,
28i32,
8i32,
];
pub static GOTO_BASE: &[i32] = &[
50i32, 51i32, 29i32, 52i32, 32i32, 6i32, 53i32, 9i32, 54i32, 55i32, 56i32, 57i32,
58i32, 59i32, 60i32, 61i32,
];
pub static RULES: &[(u32, u8)] = &[
(37u32, 1u8),
(30u32, 2u8),
(30u32, 0u8),
(31u32, 3u8),
(31u32, 1u8),
(32u32, 2u8),
(32u32, 1u8),
(22u32, 9u8),
(23u32, 4u8),
(33u32, 1u8),
(33u32, 0u8),
(34u32, 1u8),
(34u32, 0u8),
(24u32, 3u8),
(25u32, 2u8),
(35u32, 3u8),
(35u32, 1u8),
(26u32, 4u8),
(36u32, 2u8),
(36u32, 1u8),
(27u32, 2u8),
(28u32, 2u8),
(29u32, 5u8),
(29u32, 2u8),
(29u32, 2u8),
(29u32, 2u8),
(29u32, 1u8),
(29u32, 1u8),
];
pub static STATE_SYMBOL: &[u32] = &[
0u32, 22u32, 26u32, 26u32, 32u32, 16u32, 5u32, 8u32, 13u32, 29u32, 29u32, 11u32,
18u32, 19u32, 20u32, 1u32, 7u32, 33u32, 21u32, 17u32, 3u32, 2u32, 10u32, 36u32,
14u32, 15u32, 9u32, 6u32, 23u32, 16u32, 16u32, 30u32, 12u32, 4u32, 24u32, 24u32,
25u32, 1u32, 34u32, 7u32, 31u32, 1u32, 1u32, 27u32, 27u32, 28u32, 1u32, 35u32,
1u32, 1u32, 1u32,
];
pub static DEFAULT_REDUCE: &[u32] = &[
0u32, 0u32, 5u32, 6u32, 7u32, 17u32, 9u32, 10u32, 10u32, 18u32, 19u32, 22u32,
23u32, 24u32, 25u32, 26u32, 27u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32, 0u32,
0u32, 0u32, 0u32, 0u32, 1u32, 2u32, 8u32, 0u32, 0u32, 0u32, 3u32, 4u32, 11u32,
12u32, 13u32, 14u32, 0u32, 0u32, 0u32, 15u32, 16u32, 20u32, 21u32, 0u32, 0u32,
0u32, 0u32,
];
pub static DEFAULT_GOTO: &[u32] = &[
1u32, 28u32, 35u32, 36u32, 3u32, 44u32, 45u32, 10u32, 31u32, 40u32, 4u32, 17u32,
38u32, 47u32, 23u32, 4294967295u32,
];
pub const NUM_STATES: usize = 51usize;
pub const NUM_TERMINALS: u32 = 22u32;
#[allow(dead_code)]
pub const NUM_NON_TERMINALS: u32 = 16u32;
pub static SYMBOL_NAMES: &[&str] = &[
"$",
"IDENT",
"NUM",
"KW_START",
"KW_TERMINALS",
"KW_PREC",
"KW_EXPECT",
"UNDERSCORE",
"LBRACE",
"RBRACE",
"LPAREN",
"RPAREN",
"COLON",
"COMMA",
"EQ",
"PIPE",
"SEMI",
"FAT_ARROW",
"QUESTION",
"STAR",
"PLUS",
"PERCENT",
"grammar_def",
"expect_decl",
"terminal_item",
"type_annot",
"rule",
"alt",
"variant",
"term",
"__expect_decl_star",
"__terminal_item_sep_comma",
"__rule_plus",
"__kw_prec_opt",
"__type_annot_opt",
"__alt_sep_pipe",
"__term_plus",
"__start",
];
static STATE_ITEMS_0: &[(u16, u8)] = &[(0u16, 0u8), (7u16, 0u8)];
static STATE_ITEMS_1: &[(u16, u8)] = &[(0u16, 1u8)];
static STATE_ITEMS_2: &[(u16, u8)] = &[(5u16, 2u8), (5u16, 2u8)];
static STATE_ITEMS_3: &[(u16, u8)] = &[(6u16, 1u8), (6u16, 1u8)];
static STATE_ITEMS_4: &[(u16, u8)] = &[
(5u16, 1u8),
(5u16, 1u8),
(7u16, 9u8),
(17u16, 0u8),
(17u16, 0u8),
];
static STATE_ITEMS_5: &[(u16, u8)] = &[(17u16, 4u8), (17u16, 4u8)];
static STATE_ITEMS_6: &[(u16, u8)] = &[(9u16, 1u8)];
static STATE_ITEMS_7: &[(u16, u8)] = &[
(3u16, 0u8),
(3u16, 0u8),
(4u16, 0u8),
(4u16, 0u8),
(7u16, 6u8),
(9u16, 0u8),
(10u16, 0u8),
(13u16, 0u8),
(13u16, 0u8),
];
static STATE_ITEMS_8: &[(u16, u8)] = &[
(3u16, 2u8),
(3u16, 2u8),
(9u16, 0u8),
(10u16, 0u8),
(13u16, 0u8),
(13u16, 0u8),
];
static STATE_ITEMS_9: &[(u16, u8)] = &[
(18u16, 2u8),
(18u16, 2u8),
(18u16, 2u8),
(18u16, 2u8),
];
static STATE_ITEMS_10: &[(u16, u8)] = &[
(19u16, 1u8),
(19u16, 1u8),
(19u16, 1u8),
(19u16, 1u8),
];
static STATE_ITEMS_11: &[(u16, u8)] = &[
(22u16, 5u8),
(22u16, 5u8),
(22u16, 5u8),
(22u16, 5u8),
];
static STATE_ITEMS_12: &[(u16, u8)] = &[
(23u16, 2u8),
(23u16, 2u8),
(23u16, 2u8),
(23u16, 2u8),
];
static STATE_ITEMS_13: &[(u16, u8)] = &[
(24u16, 2u8),
(24u16, 2u8),
(24u16, 2u8),
(24u16, 2u8),
];
static STATE_ITEMS_14: &[(u16, u8)] = &[
(25u16, 2u8),
(25u16, 2u8),
(25u16, 2u8),
(25u16, 2u8),
];
static STATE_ITEMS_15: &[(u16, u8)] = &[
(23u16, 1u8),
(23u16, 1u8),
(23u16, 1u8),
(23u16, 1u8),
(24u16, 1u8),
(24u16, 1u8),
(24u16, 1u8),
(24u16, 1u8),
(25u16, 1u8),
(25u16, 1u8),
(25u16, 1u8),
(25u16, 1u8),
(26u16, 1u8),
(26u16, 1u8),
(26u16, 1u8),
(26u16, 1u8),
];
static STATE_ITEMS_16: &[(u16, u8)] = &[
(27u16, 1u8),
(27u16, 1u8),
(27u16, 1u8),
(27u16, 1u8),
];
static STATE_ITEMS_17: &[(u16, u8)] = &[(13u16, 1u8), (13u16, 1u8)];
static STATE_ITEMS_18: &[(u16, u8)] = &[
(22u16, 3u8),
(22u16, 3u8),
(22u16, 3u8),
(22u16, 3u8),
];
static STATE_ITEMS_19: &[(u16, u8)] = &[(21u16, 1u8), (21u16, 1u8)];
static STATE_ITEMS_20: &[(u16, u8)] = &[(7u16, 1u8)];
static STATE_ITEMS_21: &[(u16, u8)] = &[(8u16, 2u8), (8u16, 2u8)];
static STATE_ITEMS_22: &[(u16, u8)] = &[
(22u16, 1u8),
(22u16, 1u8),
(22u16, 1u8),
(22u16, 1u8),
];
static STATE_ITEMS_23: &[(u16, u8)] = &[
(18u16, 1u8),
(18u16, 1u8),
(18u16, 1u8),
(18u16, 1u8),
(20u16, 1u8),
(20u16, 1u8),
(21u16, 0u8),
(21u16, 0u8),
(22u16, 0u8),
(22u16, 0u8),
(22u16, 0u8),
(22u16, 0u8),
(23u16, 0u8),
(23u16, 0u8),
(23u16, 0u8),
(23u16, 0u8),
(24u16, 0u8),
(24u16, 0u8),
(24u16, 0u8),
(24u16, 0u8),
(25u16, 0u8),
(25u16, 0u8),
(25u16, 0u8),
(25u16, 0u8),
(26u16, 0u8),
(26u16, 0u8),
(26u16, 0u8),
(26u16, 0u8),
(27u16, 0u8),
(27u16, 0u8),
(27u16, 0u8),
(27u16, 0u8),
];
static STATE_ITEMS_24: &[(u16, u8)] = &[
(15u16, 0u8),
(15u16, 0u8),
(16u16, 0u8),
(16u16, 0u8),
(17u16, 2u8),
(17u16, 2u8),
(18u16, 0u8),
(18u16, 0u8),
(18u16, 0u8),
(18u16, 0u8),
(19u16, 0u8),
(19u16, 0u8),
(19u16, 0u8),
(19u16, 0u8),
(20u16, 0u8),
(20u16, 0u8),
(22u16, 0u8),
(22u16, 0u8),
(22u16, 0u8),
(22u16, 0u8),
(23u16, 0u8),
(23u16, 0u8),
(23u16, 0u8),
(23u16, 0u8),
(24u16, 0u8),
(24u16, 0u8),
(24u16, 0u8),
(24u16, 0u8),
(25u16, 0u8),
(25u16, 0u8),
(25u16, 0u8),
(25u16, 0u8),
(26u16, 0u8),
(26u16, 0u8),
(26u16, 0u8),
(26u16, 0u8),
(27u16, 0u8),
(27u16, 0u8),
(27u16, 0u8),
(27u16, 0u8),
];
static STATE_ITEMS_25: &[(u16, u8)] = &[
(15u16, 2u8),
(15u16, 2u8),
(18u16, 0u8),
(18u16, 0u8),
(18u16, 0u8),
(18u16, 0u8),
(19u16, 0u8),
(19u16, 0u8),
(19u16, 0u8),
(19u16, 0u8),
(20u16, 0u8),
(20u16, 0u8),
(22u16, 0u8),
(22u16, 0u8),
(22u16, 0u8),
(22u16, 0u8),
(23u16, 0u8),
(23u16, 0u8),
(23u16, 0u8),
(23u16, 0u8),
(24u16, 0u8),
(24u16, 0u8),
(24u16, 0u8),
(24u16, 0u8),
(25u16, 0u8),
(25u16, 0u8),
(25u16, 0u8),
(25u16, 0u8),
(26u16, 0u8),
(26u16, 0u8),
(26u16, 0u8),
(26u16, 0u8),
(27u16, 0u8),
(27u16, 0u8),
(27u16, 0u8),
(27u16, 0u8),
];
static STATE_ITEMS_26: &[(u16, u8)] = &[
(5u16, 0u8),
(5u16, 0u8),
(6u16, 0u8),
(6u16, 0u8),
(7u16, 8u8),
(17u16, 0u8),
(17u16, 0u8),
];
static STATE_ITEMS_27: &[(u16, u8)] = &[(8u16, 1u8), (8u16, 1u8)];
static STATE_ITEMS_28: &[(u16, u8)] = &[(1u16, 2u8), (1u16, 2u8)];
static STATE_ITEMS_29: &[(u16, u8)] = &[
(1u16, 0u8),
(1u16, 0u8),
(2u16, 0u8),
(2u16, 0u8),
(7u16, 3u8),
];
static STATE_ITEMS_30: &[(u16, u8)] = &[(8u16, 4u8), (8u16, 4u8)];
static STATE_ITEMS_31: &[(u16, u8)] = &[
(1u16, 1u8),
(1u16, 1u8),
(7u16, 4u8),
(8u16, 0u8),
(8u16, 0u8),
];
static STATE_ITEMS_32: &[(u16, u8)] = &[(14u16, 1u8), (14u16, 1u8)];
static STATE_ITEMS_33: &[(u16, u8)] = &[(7u16, 5u8)];
static STATE_ITEMS_34: &[(u16, u8)] = &[(3u16, 3u8), (3u16, 3u8)];
static STATE_ITEMS_35: &[(u16, u8)] = &[(4u16, 1u8), (4u16, 1u8)];
static STATE_ITEMS_36: &[(u16, u8)] = &[(11u16, 1u8), (11u16, 1u8)];
static STATE_ITEMS_37: &[(u16, u8)] = &[
(11u16, 0u8),
(11u16, 0u8),
(12u16, 0u8),
(12u16, 0u8),
(13u16, 2u8),
(13u16, 2u8),
(14u16, 0u8),
(14u16, 0u8),
];
static STATE_ITEMS_38: &[(u16, u8)] = &[(13u16, 3u8), (13u16, 3u8)];
static STATE_ITEMS_39: &[(u16, u8)] = &[(14u16, 2u8), (14u16, 2u8)];
static STATE_ITEMS_40: &[(u16, u8)] = &[(3u16, 1u8), (3u16, 1u8), (7u16, 7u8)];
static STATE_ITEMS_41: &[(u16, u8)] = &[
(22u16, 4u8),
(22u16, 4u8),
(22u16, 4u8),
(22u16, 4u8),
];
static STATE_ITEMS_42: &[(u16, u8)] = &[(17u16, 1u8), (17u16, 1u8)];
static STATE_ITEMS_43: &[(u16, u8)] = &[(15u16, 3u8), (15u16, 3u8)];
static STATE_ITEMS_44: &[(u16, u8)] = &[(16u16, 1u8), (16u16, 1u8)];
static STATE_ITEMS_45: &[(u16, u8)] = &[(20u16, 2u8), (20u16, 2u8)];
static STATE_ITEMS_46: &[(u16, u8)] = &[(21u16, 2u8), (21u16, 2u8)];
static STATE_ITEMS_47: &[(u16, u8)] = &[
(15u16, 1u8),
(15u16, 1u8),
(17u16, 3u8),
(17u16, 3u8),
];
static STATE_ITEMS_48: &[(u16, u8)] = &[(7u16, 2u8)];
static STATE_ITEMS_49: &[(u16, u8)] = &[(8u16, 3u8), (8u16, 3u8)];
static STATE_ITEMS_50: &[(u16, u8)] = &[
(22u16, 2u8),
(22u16, 2u8),
(22u16, 2u8),
(22u16, 2u8),
];
pub static STATE_ITEMS: &[&[(u16, u8)]] = &[
STATE_ITEMS_0,
STATE_ITEMS_1,
STATE_ITEMS_2,
STATE_ITEMS_3,
STATE_ITEMS_4,
STATE_ITEMS_5,
STATE_ITEMS_6,
STATE_ITEMS_7,
STATE_ITEMS_8,
STATE_ITEMS_9,
STATE_ITEMS_10,
STATE_ITEMS_11,
STATE_ITEMS_12,
STATE_ITEMS_13,
STATE_ITEMS_14,
STATE_ITEMS_15,
STATE_ITEMS_16,
STATE_ITEMS_17,
STATE_ITEMS_18,
STATE_ITEMS_19,
STATE_ITEMS_20,
STATE_ITEMS_21,
STATE_ITEMS_22,
STATE_ITEMS_23,
STATE_ITEMS_24,
STATE_ITEMS_25,
STATE_ITEMS_26,
STATE_ITEMS_27,
STATE_ITEMS_28,
STATE_ITEMS_29,
STATE_ITEMS_30,
STATE_ITEMS_31,
STATE_ITEMS_32,
STATE_ITEMS_33,
STATE_ITEMS_34,
STATE_ITEMS_35,
STATE_ITEMS_36,
STATE_ITEMS_37,
STATE_ITEMS_38,
STATE_ITEMS_39,
STATE_ITEMS_40,
STATE_ITEMS_41,
STATE_ITEMS_42,
STATE_ITEMS_43,
STATE_ITEMS_44,
STATE_ITEMS_45,
STATE_ITEMS_46,
STATE_ITEMS_47,
STATE_ITEMS_48,
STATE_ITEMS_49,
STATE_ITEMS_50,
];
static RULE_RHS_0: &[u32] = &[22u32];
static RULE_RHS_1: &[u32] = &[30u32, 23u32];
static RULE_RHS_2: &[u32] = &[];
static RULE_RHS_3: &[u32] = &[31u32, 13u32, 24u32];
static RULE_RHS_4: &[u32] = &[24u32];
static RULE_RHS_5: &[u32] = &[32u32, 26u32];
static RULE_RHS_6: &[u32] = &[26u32];
static RULE_RHS_7: &[u32] = &[
3u32, 1u32, 16u32, 30u32, 4u32, 8u32, 31u32, 9u32, 32u32,
];
static RULE_RHS_8: &[u32] = &[6u32, 2u32, 1u32, 16u32];
static RULE_RHS_9: &[u32] = &[5u32];
static RULE_RHS_10: &[u32] = &[];
static RULE_RHS_11: &[u32] = &[25u32];
static RULE_RHS_12: &[u32] = &[];
static RULE_RHS_13: &[u32] = &[33u32, 1u32, 34u32];
static RULE_RHS_14: &[u32] = &[12u32, 7u32];
static RULE_RHS_15: &[u32] = &[35u32, 15u32, 27u32];
static RULE_RHS_16: &[u32] = &[27u32];
static RULE_RHS_17: &[u32] = &[1u32, 14u32, 35u32, 16u32];
static RULE_RHS_18: &[u32] = &[36u32, 29u32];
static RULE_RHS_19: &[u32] = &[29u32];
static RULE_RHS_20: &[u32] = &[36u32, 28u32];
static RULE_RHS_21: &[u32] = &[17u32, 1u32];
static RULE_RHS_22: &[u32] = &[10u32, 1u32, 21u32, 1u32, 11u32];
static RULE_RHS_23: &[u32] = &[1u32, 18u32];
static RULE_RHS_24: &[u32] = &[1u32, 19u32];
static RULE_RHS_25: &[u32] = &[1u32, 20u32];
static RULE_RHS_26: &[u32] = &[1u32];
static RULE_RHS_27: &[u32] = &[7u32];
pub static RULE_RHS: &[&[u32]] = &[
RULE_RHS_0,
RULE_RHS_1,
RULE_RHS_2,
RULE_RHS_3,
RULE_RHS_4,
RULE_RHS_5,
RULE_RHS_6,
RULE_RHS_7,
RULE_RHS_8,
RULE_RHS_9,
RULE_RHS_10,
RULE_RHS_11,
RULE_RHS_12,
RULE_RHS_13,
RULE_RHS_14,
RULE_RHS_15,
RULE_RHS_16,
RULE_RHS_17,
RULE_RHS_18,
RULE_RHS_19,
RULE_RHS_20,
RULE_RHS_21,
RULE_RHS_22,
RULE_RHS_23,
RULE_RHS_24,
RULE_RHS_25,
RULE_RHS_26,
RULE_RHS_27,
];
pub fn symbol_id(name: &str) -> gazelle::SymbolId {
match name {
"IDENT" => gazelle::SymbolId::new(1u32),
"NUM" => gazelle::SymbolId::new(2u32),
"KW_START" => gazelle::SymbolId::new(3u32),
"KW_TERMINALS" => gazelle::SymbolId::new(4u32),
"KW_PREC" => gazelle::SymbolId::new(5u32),
"KW_EXPECT" => gazelle::SymbolId::new(6u32),
"UNDERSCORE" => gazelle::SymbolId::new(7u32),
"LBRACE" => gazelle::SymbolId::new(8u32),
"RBRACE" => gazelle::SymbolId::new(9u32),
"LPAREN" => gazelle::SymbolId::new(10u32),
"RPAREN" => gazelle::SymbolId::new(11u32),
"COLON" => gazelle::SymbolId::new(12u32),
"COMMA" => gazelle::SymbolId::new(13u32),
"EQ" => gazelle::SymbolId::new(14u32),
"PIPE" => gazelle::SymbolId::new(15u32),
"SEMI" => gazelle::SymbolId::new(16u32),
"FAT_ARROW" => gazelle::SymbolId::new(17u32),
"QUESTION" => gazelle::SymbolId::new(18u32),
"STAR" => gazelle::SymbolId::new(19u32),
"PLUS" => gazelle::SymbolId::new(20u32),
"PERCENT" => gazelle::SymbolId::new(21u32),
"grammar_def" => gazelle::SymbolId::new(22u32),
"expect_decl" => gazelle::SymbolId::new(23u32),
"terminal_item" => gazelle::SymbolId::new(24u32),
"type_annot" => gazelle::SymbolId::new(25u32),
"rule" => gazelle::SymbolId::new(26u32),
"alt" => gazelle::SymbolId::new(27u32),
"variant" => gazelle::SymbolId::new(28u32),
"term" => gazelle::SymbolId::new(29u32),
"__expect_decl_star" => gazelle::SymbolId::new(30u32),
"__terminal_item_sep_comma" => gazelle::SymbolId::new(31u32),
"__rule_plus" => gazelle::SymbolId::new(32u32),
"__kw_prec_opt" => gazelle::SymbolId::new(33u32),
"__type_annot_opt" => gazelle::SymbolId::new(34u32),
"__alt_sep_pipe" => gazelle::SymbolId::new(35u32),
"__term_plus" => gazelle::SymbolId::new(36u32),
"__start" => gazelle::SymbolId::new(37u32),
_ => panic!("unknown symbol: {}", name),
}
}
pub static TABLE: gazelle::ParseTable<'static> = gazelle::ParseTable::new(
DATA,
CHECK,
ACTION_BASE,
GOTO_BASE,
RULES,
NUM_TERMINALS,
DEFAULT_REDUCE,
DEFAULT_GOTO,
);
pub static ERROR_INFO: gazelle::ErrorInfo<'static> = gazelle::ErrorInfo {
symbol_names: SYMBOL_NAMES,
state_items: STATE_ITEMS,
rule_rhs: RULE_RHS,
state_symbols: STATE_SYMBOL,
};
}
pub enum Terminal<A: Types> {
Ident(A::Ident),
Num(A::Num),
KwStart,
KwTerminals,
KwPrec,
KwExpect,
Underscore,
Lbrace,
Rbrace,
Lparen,
Rparen,
Colon,
Comma,
Eq,
Pipe,
Semi,
FatArrow,
Question,
Star,
Plus,
Percent,
#[doc(hidden)]
__Phantom(std::marker::PhantomData<A>),
}
impl<A: Types> Terminal<A> {
pub fn symbol_id(&self) -> gazelle::SymbolId {
match self {
Self::Ident(_) => gazelle::SymbolId::new(1u32),
Self::Num(_) => gazelle::SymbolId::new(2u32),
Self::KwStart => gazelle::SymbolId::new(3u32),
Self::KwTerminals => gazelle::SymbolId::new(4u32),
Self::KwPrec => gazelle::SymbolId::new(5u32),
Self::KwExpect => gazelle::SymbolId::new(6u32),
Self::Underscore => gazelle::SymbolId::new(7u32),
Self::Lbrace => gazelle::SymbolId::new(8u32),
Self::Rbrace => gazelle::SymbolId::new(9u32),
Self::Lparen => gazelle::SymbolId::new(10u32),
Self::Rparen => gazelle::SymbolId::new(11u32),
Self::Colon => gazelle::SymbolId::new(12u32),
Self::Comma => gazelle::SymbolId::new(13u32),
Self::Eq => gazelle::SymbolId::new(14u32),
Self::Pipe => gazelle::SymbolId::new(15u32),
Self::Semi => gazelle::SymbolId::new(16u32),
Self::FatArrow => gazelle::SymbolId::new(17u32),
Self::Question => gazelle::SymbolId::new(18u32),
Self::Star => gazelle::SymbolId::new(19u32),
Self::Plus => gazelle::SymbolId::new(20u32),
Self::Percent => gazelle::SymbolId::new(21u32),
Self::__Phantom(_) => unreachable!(),
}
}
pub fn to_token(
&self,
symbol_ids: &impl Fn(&str) -> gazelle::SymbolId,
) -> gazelle::Token {
match self {
Self::Ident(_) => gazelle::Token::new(symbol_ids("IDENT")),
Self::Num(_) => gazelle::Token::new(symbol_ids("NUM")),
Self::KwStart => gazelle::Token::new(symbol_ids("KW_START")),
Self::KwTerminals => gazelle::Token::new(symbol_ids("KW_TERMINALS")),
Self::KwPrec => gazelle::Token::new(symbol_ids("KW_PREC")),
Self::KwExpect => gazelle::Token::new(symbol_ids("KW_EXPECT")),
Self::Underscore => gazelle::Token::new(symbol_ids("UNDERSCORE")),
Self::Lbrace => gazelle::Token::new(symbol_ids("LBRACE")),
Self::Rbrace => gazelle::Token::new(symbol_ids("RBRACE")),
Self::Lparen => gazelle::Token::new(symbol_ids("LPAREN")),
Self::Rparen => gazelle::Token::new(symbol_ids("RPAREN")),
Self::Colon => gazelle::Token::new(symbol_ids("COLON")),
Self::Comma => gazelle::Token::new(symbol_ids("COMMA")),
Self::Eq => gazelle::Token::new(symbol_ids("EQ")),
Self::Pipe => gazelle::Token::new(symbol_ids("PIPE")),
Self::Semi => gazelle::Token::new(symbol_ids("SEMI")),
Self::FatArrow => gazelle::Token::new(symbol_ids("FAT_ARROW")),
Self::Question => gazelle::Token::new(symbol_ids("QUESTION")),
Self::Star => gazelle::Token::new(symbol_ids("STAR")),
Self::Plus => gazelle::Token::new(symbol_ids("PLUS")),
Self::Percent => gazelle::Token::new(symbol_ids("PERCENT")),
Self::__Phantom(_) => unreachable!(),
}
}
pub fn precedence(&self) -> Option<gazelle::Precedence> {
match self {
Self::Ident(_) => None,
Self::Num(_) => None,
Self::KwStart => None,
Self::KwTerminals => None,
Self::KwPrec => None,
Self::KwExpect => None,
Self::Underscore => None,
Self::Lbrace => None,
Self::Rbrace => None,
Self::Lparen => None,
Self::Rparen => None,
Self::Colon => None,
Self::Comma => None,
Self::Eq => None,
Self::Pipe => None,
Self::Semi => None,
Self::FatArrow => None,
Self::Question => None,
Self::Star => None,
Self::Plus => None,
Self::Percent => None,
Self::__Phantom(_) => unreachable!(),
}
}
}
pub enum Alt<A: Types> {
Alt(Vec<A::Term>, A::Variant),
}
impl<A: Types> std::fmt::Debug for Alt<A> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Alt(f0, f1) => f.debug_tuple("Alt").field(f0).field(f1).finish(),
}
}
}
pub enum ExpectDecl<A: Types> {
ExpectDecl(A::Num, A::Ident),
}
impl<A: Types> std::fmt::Debug for ExpectDecl<A> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::ExpectDecl(f0, f1) => {
f.debug_tuple("ExpectDecl").field(f0).field(f1).finish()
}
}
}
}
pub enum GrammarDef<A: Types> {
GrammarDef(A::Ident, Vec<A::ExpectDecl>, Vec<A::TerminalItem>, Vec<A::Rule>),
}
impl<A: Types> std::fmt::Debug for GrammarDef<A> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::GrammarDef(f0, f1, f2, f3) => {
f.debug_tuple("GrammarDef")
.field(f0)
.field(f1)
.field(f2)
.field(f3)
.finish()
}
}
}
}
pub enum Rule<A: Types> {
Rule(A::Ident, Vec<A::Alt>),
}
impl<A: Types> std::fmt::Debug for Rule<A> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Rule(f0, f1) => f.debug_tuple("Rule").field(f0).field(f1).finish(),
}
}
}
pub enum Term<A: Types> {
SymSep(A::Ident, A::Ident),
SymOpt(A::Ident),
SymStar(A::Ident),
SymPlus(A::Ident),
SymPlain(A::Ident),
SymEmpty,
}
impl<A: Types> std::fmt::Debug for Term<A> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::SymSep(f0, f1) => f.debug_tuple("SymSep").field(f0).field(f1).finish(),
Self::SymOpt(f0) => f.debug_tuple("SymOpt").field(f0).finish(),
Self::SymStar(f0) => f.debug_tuple("SymStar").field(f0).finish(),
Self::SymPlus(f0) => f.debug_tuple("SymPlus").field(f0).finish(),
Self::SymPlain(f0) => f.debug_tuple("SymPlain").field(f0).finish(),
Self::SymEmpty => f.write_str("SymEmpty"),
}
}
}
pub enum TerminalItem<A: Types> {
TerminalItem(Option<()>, A::Ident, Option<A::TypeAnnot>),
}
impl<A: Types> std::fmt::Debug for TerminalItem<A> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::TerminalItem(f0, f1, f2) => {
f.debug_tuple("TerminalItem").field(f0).field(f1).field(f2).finish()
}
}
}
}
pub enum TypeAnnot<A: Types> {
TypeAnnot,
#[doc(hidden)]
_Phantom(std::convert::Infallible, std::marker::PhantomData<A>),
}
impl<A: Types> std::fmt::Debug for TypeAnnot<A> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::TypeAnnot => f.write_str("TypeAnnot"),
_ => unreachable!(),
}
}
}
pub enum Variant<A: Types> {
Variant(A::Ident),
}
impl<A: Types> std::fmt::Debug for Variant<A> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Variant(f0) => f.debug_tuple("Variant").field(f0).finish(),
}
}
}
pub trait Types: Sized {
type Error: From<gazelle::ParseError>;
type Ident: std::fmt::Debug;
type Num: std::fmt::Debug;
type GrammarDef: std::fmt::Debug;
type ExpectDecl: std::fmt::Debug;
type TerminalItem: std::fmt::Debug;
type TypeAnnot: std::fmt::Debug;
type Rule: std::fmt::Debug;
type Alt: std::fmt::Debug;
type Variant: std::fmt::Debug;
type Term: std::fmt::Debug;
#[allow(unused_variables)]
fn set_token_range(&mut self, start: usize, end: usize) {}
}
impl<A: Types> gazelle::AstNode for GrammarDef<A> {
type Output = A::GrammarDef;
type Error = A::Error;
}
impl<A: Types> gazelle::AstNode for ExpectDecl<A> {
type Output = A::ExpectDecl;
type Error = A::Error;
}
impl<A: Types> gazelle::AstNode for TerminalItem<A> {
type Output = A::TerminalItem;
type Error = A::Error;
}
impl<A: Types> gazelle::AstNode for TypeAnnot<A> {
type Output = A::TypeAnnot;
type Error = A::Error;
}
impl<A: Types> gazelle::AstNode for Rule<A> {
type Output = A::Rule;
type Error = A::Error;
}
impl<A: Types> gazelle::AstNode for Alt<A> {
type Output = A::Alt;
type Error = A::Error;
}
impl<A: Types> gazelle::AstNode for Variant<A> {
type Output = A::Variant;
type Error = A::Error;
}
impl<A: Types> gazelle::AstNode for Term<A> {
type Output = A::Term;
type Error = A::Error;
}
#[doc(hidden)]
union __Value<A: Types> {
__ident: std::mem::ManuallyDrop<A::Ident>,
__num: std::mem::ManuallyDrop<A::Num>,
__grammar_def: std::mem::ManuallyDrop<A::GrammarDef>,
__expect_decl: std::mem::ManuallyDrop<A::ExpectDecl>,
__terminal_item: std::mem::ManuallyDrop<A::TerminalItem>,
__type_annot: std::mem::ManuallyDrop<A::TypeAnnot>,
__rule: std::mem::ManuallyDrop<A::Rule>,
__alt: std::mem::ManuallyDrop<A::Alt>,
__variant: std::mem::ManuallyDrop<A::Variant>,
__term: std::mem::ManuallyDrop<A::Term>,
____expect_decl_star: std::mem::ManuallyDrop<Vec<A::ExpectDecl>>,
____terminal_item_sep_comma: std::mem::ManuallyDrop<Vec<A::TerminalItem>>,
____rule_plus: std::mem::ManuallyDrop<Vec<A::Rule>>,
____kw_prec_opt: std::mem::ManuallyDrop<Option<()>>,
____type_annot_opt: std::mem::ManuallyDrop<Option<A::TypeAnnot>>,
____alt_sep_pipe: std::mem::ManuallyDrop<Vec<A::Alt>>,
____term_plus: std::mem::ManuallyDrop<Vec<A::Term>>,
__unit: (),
__phantom: std::mem::ManuallyDrop<std::marker::PhantomData<A>>,
}
pub struct Parser<A: Types> {
parser: gazelle::Parser<'static>,
value_stack: Vec<__Value<A>>,
}
impl<A: Types> Parser<A> {
pub fn new() -> Self {
Self {
parser: gazelle::Parser::new(__table::TABLE),
value_stack: Vec::new(),
}
}
pub fn state(&self) -> usize {
self.parser.state()
}
pub fn format_error(
&self,
err: &gazelle::ParseError,
display_names: Option<&std::collections::HashMap<&str, &str>>,
tokens: Option<&[&str]>,
) -> String {
self.parser.format_error(err, &__table::ERROR_INFO, display_names, tokens)
}
pub fn error_info() -> &'static gazelle::ErrorInfo<'static> {
&__table::ERROR_INFO
}
pub fn recover(&mut self, buffer: &[gazelle::Token]) -> Vec<gazelle::RecoveryInfo> {
self.parser.recover(buffer)
}
fn drain_values(&mut self) {
for i in (0..self.value_stack.len()).rev() {
let union_val = self.value_stack.pop().unwrap();
let sym_id = __table::STATE_SYMBOL[self.parser.state_at(i)];
unsafe {
match sym_id {
1u32 => {
std::mem::ManuallyDrop::into_inner(union_val.__ident);
}
2u32 => {
std::mem::ManuallyDrop::into_inner(union_val.__num);
}
22u32 => {
std::mem::ManuallyDrop::into_inner(union_val.__grammar_def);
}
23u32 => {
std::mem::ManuallyDrop::into_inner(union_val.__expect_decl);
}
24u32 => {
std::mem::ManuallyDrop::into_inner(union_val.__terminal_item);
}
25u32 => {
std::mem::ManuallyDrop::into_inner(union_val.__type_annot);
}
26u32 => {
std::mem::ManuallyDrop::into_inner(union_val.__rule);
}
27u32 => {
std::mem::ManuallyDrop::into_inner(union_val.__alt);
}
28u32 => {
std::mem::ManuallyDrop::into_inner(union_val.__variant);
}
29u32 => {
std::mem::ManuallyDrop::into_inner(union_val.__term);
}
30u32 => {
std::mem::ManuallyDrop::into_inner(
union_val.____expect_decl_star,
);
}
31u32 => {
std::mem::ManuallyDrop::into_inner(
union_val.____terminal_item_sep_comma,
);
}
32u32 => {
std::mem::ManuallyDrop::into_inner(union_val.____rule_plus);
}
33u32 => {
std::mem::ManuallyDrop::into_inner(union_val.____kw_prec_opt);
}
34u32 => {
std::mem::ManuallyDrop::into_inner(union_val.____type_annot_opt);
}
35u32 => {
std::mem::ManuallyDrop::into_inner(union_val.____alt_sep_pipe);
}
36u32 => {
std::mem::ManuallyDrop::into_inner(union_val.____term_plus);
}
_ => {}
}
}
}
}
}
#[allow(clippy::result_large_err)]
impl<
A: Types + gazelle::Action<GrammarDef<A>> + gazelle::Action<ExpectDecl<A>>
+ gazelle::Action<TerminalItem<A>> + gazelle::Action<TypeAnnot<A>>
+ gazelle::Action<Rule<A>> + gazelle::Action<Alt<A>>
+ gazelle::Action<Variant<A>> + gazelle::Action<Term<A>>,
> Parser<A> {
pub fn push(
&mut self,
terminal: Terminal<A>,
actions: &mut A,
) -> Result<(), A::Error> {
let token = gazelle::Token {
terminal: terminal.symbol_id(),
prec: terminal.precedence(),
};
loop {
match self.parser.maybe_reduce(Some(token)) {
Ok(Some((rule, _, start_idx))) => {
self.do_reduce(rule, start_idx, actions)?;
}
Ok(None) => break,
Err(e) => {
self.drain_values();
self.parser.restore_checkpoint();
return Err(e.into());
}
}
}
self.parser.shift(token);
match terminal {
Terminal::Ident(v) => {
self.value_stack
.push(__Value {
__ident: std::mem::ManuallyDrop::new(v),
});
}
Terminal::Num(v) => {
self.value_stack
.push(__Value {
__num: std::mem::ManuallyDrop::new(v),
});
}
Terminal::KwStart => {
self.value_stack.push(__Value { __unit: () });
}
Terminal::KwTerminals => {
self.value_stack.push(__Value { __unit: () });
}
Terminal::KwPrec => {
self.value_stack.push(__Value { __unit: () });
}
Terminal::KwExpect => {
self.value_stack.push(__Value { __unit: () });
}
Terminal::Underscore => {
self.value_stack.push(__Value { __unit: () });
}
Terminal::Lbrace => {
self.value_stack.push(__Value { __unit: () });
}
Terminal::Rbrace => {
self.value_stack.push(__Value { __unit: () });
}
Terminal::Lparen => {
self.value_stack.push(__Value { __unit: () });
}
Terminal::Rparen => {
self.value_stack.push(__Value { __unit: () });
}
Terminal::Colon => {
self.value_stack.push(__Value { __unit: () });
}
Terminal::Comma => {
self.value_stack.push(__Value { __unit: () });
}
Terminal::Eq => {
self.value_stack.push(__Value { __unit: () });
}
Terminal::Pipe => {
self.value_stack.push(__Value { __unit: () });
}
Terminal::Semi => {
self.value_stack.push(__Value { __unit: () });
}
Terminal::FatArrow => {
self.value_stack.push(__Value { __unit: () });
}
Terminal::Question => {
self.value_stack.push(__Value { __unit: () });
}
Terminal::Star => {
self.value_stack.push(__Value { __unit: () });
}
Terminal::Plus => {
self.value_stack.push(__Value { __unit: () });
}
Terminal::Percent => {
self.value_stack.push(__Value { __unit: () });
}
Terminal::__Phantom(_) => unreachable!(),
}
Ok(())
}
pub fn finish(mut self, actions: &mut A) -> Result<A::GrammarDef, (Self, A::Error)> {
loop {
match self.parser.maybe_reduce(None) {
Ok(Some((0, _, _))) => {
let union_val = self.value_stack.pop().unwrap();
return Ok(unsafe {
std::mem::ManuallyDrop::into_inner(union_val.__grammar_def)
});
}
Ok(Some((rule, _, start_idx))) => {
if let Err(e) = self.do_reduce(rule, start_idx, actions) {
return Err((self, e));
}
}
Ok(None) => unreachable!(),
Err(e) => {
self.drain_values();
self.parser.restore_checkpoint();
return Err((self, e.into()));
}
}
}
}
fn do_reduce(
&mut self,
rule: usize,
start_idx: usize,
actions: &mut A,
) -> Result<(), A::Error> {
if rule == 0 {
return Ok(());
}
actions.set_token_range(start_idx, self.parser.token_count());
let original_rule_idx = rule - 1;
let value = match original_rule_idx {
0usize => {
let v1 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().__expect_decl,
)
};
let v0 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().____expect_decl_star,
)
};
{
let mut v0 = v0;
v0.push(v1);
__Value {
____expect_decl_star: std::mem::ManuallyDrop::new(v0),
}
}
}
1usize => {
__Value {
____expect_decl_star: std::mem::ManuallyDrop::new(Vec::new()),
}
}
2usize => {
let v2 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().__terminal_item,
)
};
let _ = self.value_stack.pop().unwrap();
let v0 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().____terminal_item_sep_comma,
)
};
{
let mut v0 = v0;
v0.push(v2);
__Value {
____terminal_item_sep_comma: std::mem::ManuallyDrop::new(v0),
}
}
}
3usize => {
let v0 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().__terminal_item,
)
};
__Value {
____terminal_item_sep_comma: std::mem::ManuallyDrop::new(vec![v0]),
}
}
4usize => {
let v1 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().__rule,
)
};
let v0 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().____rule_plus,
)
};
{
let mut v0 = v0;
v0.push(v1);
__Value {
____rule_plus: std::mem::ManuallyDrop::new(v0),
}
}
}
5usize => {
let v0 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().__rule,
)
};
__Value {
____rule_plus: std::mem::ManuallyDrop::new(vec![v0]),
}
}
6usize => {
let v8 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().____rule_plus,
)
};
let _ = self.value_stack.pop().unwrap();
let v6 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().____terminal_item_sep_comma,
)
};
let _ = self.value_stack.pop().unwrap();
let _ = self.value_stack.pop().unwrap();
let v3 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().____expect_decl_star,
)
};
let _ = self.value_stack.pop().unwrap();
let v1 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().__ident,
)
};
let _ = self.value_stack.pop().unwrap();
__Value {
__grammar_def: std::mem::ManuallyDrop::new(
gazelle::Action::build(
actions,
GrammarDef::GrammarDef(v1, v3, v6, v8),
)?,
),
}
}
7usize => {
let _ = self.value_stack.pop().unwrap();
let v2 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().__ident,
)
};
let v1 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().__num,
)
};
let _ = self.value_stack.pop().unwrap();
__Value {
__expect_decl: std::mem::ManuallyDrop::new(
gazelle::Action::build(actions, ExpectDecl::ExpectDecl(v1, v2))?,
),
}
}
8usize => {
let _ = self.value_stack.pop().unwrap();
__Value {
____kw_prec_opt: std::mem::ManuallyDrop::new(Some(())),
}
}
9usize => {
__Value {
____kw_prec_opt: std::mem::ManuallyDrop::new(None),
}
}
10usize => {
let v0 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().__type_annot,
)
};
__Value {
____type_annot_opt: std::mem::ManuallyDrop::new(Some(v0)),
}
}
11usize => {
__Value {
____type_annot_opt: std::mem::ManuallyDrop::new(None),
}
}
12usize => {
let v2 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().____type_annot_opt,
)
};
let v1 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().__ident,
)
};
let v0 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().____kw_prec_opt,
)
};
__Value {
__terminal_item: std::mem::ManuallyDrop::new(
gazelle::Action::build(
actions,
TerminalItem::TerminalItem(v0, v1, v2),
)?,
),
}
}
13usize => {
let _ = self.value_stack.pop().unwrap();
let _ = self.value_stack.pop().unwrap();
__Value {
__type_annot: std::mem::ManuallyDrop::new(
gazelle::Action::build(actions, TypeAnnot::TypeAnnot)?,
),
}
}
14usize => {
let v2 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().__alt,
)
};
let _ = self.value_stack.pop().unwrap();
let v0 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().____alt_sep_pipe,
)
};
{
let mut v0 = v0;
v0.push(v2);
__Value {
____alt_sep_pipe: std::mem::ManuallyDrop::new(v0),
}
}
}
15usize => {
let v0 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().__alt,
)
};
__Value {
____alt_sep_pipe: std::mem::ManuallyDrop::new(vec![v0]),
}
}
16usize => {
let _ = self.value_stack.pop().unwrap();
let v2 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().____alt_sep_pipe,
)
};
let _ = self.value_stack.pop().unwrap();
let v0 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().__ident,
)
};
__Value {
__rule: std::mem::ManuallyDrop::new(
gazelle::Action::build(actions, Rule::Rule(v0, v2))?,
),
}
}
17usize => {
let v1 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().__term,
)
};
let v0 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().____term_plus,
)
};
{
let mut v0 = v0;
v0.push(v1);
__Value {
____term_plus: std::mem::ManuallyDrop::new(v0),
}
}
}
18usize => {
let v0 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().__term,
)
};
__Value {
____term_plus: std::mem::ManuallyDrop::new(vec![v0]),
}
}
19usize => {
let v1 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().__variant,
)
};
let v0 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().____term_plus,
)
};
__Value {
__alt: std::mem::ManuallyDrop::new(
gazelle::Action::build(actions, Alt::Alt(v0, v1))?,
),
}
}
20usize => {
let v1 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().__ident,
)
};
let _ = self.value_stack.pop().unwrap();
__Value {
__variant: std::mem::ManuallyDrop::new(
gazelle::Action::build(actions, Variant::Variant(v1))?,
),
}
}
21usize => {
let _ = self.value_stack.pop().unwrap();
let v3 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().__ident,
)
};
let _ = self.value_stack.pop().unwrap();
let v1 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().__ident,
)
};
let _ = self.value_stack.pop().unwrap();
__Value {
__term: std::mem::ManuallyDrop::new(
gazelle::Action::build(actions, Term::SymSep(v1, v3))?,
),
}
}
22usize => {
let _ = self.value_stack.pop().unwrap();
let v0 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().__ident,
)
};
__Value {
__term: std::mem::ManuallyDrop::new(
gazelle::Action::build(actions, Term::SymOpt(v0))?,
),
}
}
23usize => {
let _ = self.value_stack.pop().unwrap();
let v0 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().__ident,
)
};
__Value {
__term: std::mem::ManuallyDrop::new(
gazelle::Action::build(actions, Term::SymStar(v0))?,
),
}
}
24usize => {
let _ = self.value_stack.pop().unwrap();
let v0 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().__ident,
)
};
__Value {
__term: std::mem::ManuallyDrop::new(
gazelle::Action::build(actions, Term::SymPlus(v0))?,
),
}
}
25usize => {
let v0 = unsafe {
std::mem::ManuallyDrop::into_inner(
self.value_stack.pop().unwrap().__ident,
)
};
__Value {
__term: std::mem::ManuallyDrop::new(
gazelle::Action::build(actions, Term::SymPlain(v0))?,
),
}
}
26usize => {
let _ = self.value_stack.pop().unwrap();
__Value {
__term: std::mem::ManuallyDrop::new(
gazelle::Action::build(actions, Term::SymEmpty)?,
),
}
}
_ => return Ok(()),
};
self.value_stack.push(value);
Ok(())
}
}
impl<A: Types> Default for Parser<A> {
fn default() -> Self {
Self::new()
}
}
impl<A: Types> Drop for Parser<A> {
fn drop(&mut self) {
self.drain_values();
}
}