traxys/tree-sitter
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Construct entire parse table statically

Browse source 
This removes the need for the 'init_parse_table' function,
which was not really thread safe
This commit is contained in:
Max Brunsfeld 2014-03-25 19:34:17 -07:00
parent 25861b7f03
commit 80b19cbb83
7 changed files with 1851 additions and 1904 deletions
Download patch file Download diff file Expand all files Collapse all files

658
examples/parsers/arithmetic.c
View file

@ -3,18 +3,20 @@
#define TS_SYMBOL_COUNT 11
enum {
ts_sym_expression,
ts_sym_factor,
ts_sym_number,
ts_sym_plus,
ts_sym_term,
ts_sym_times,
ts_sym_variable,
ts_aux_sym_token1,
ts_aux_sym_token2,
ts_sym_expression = 2,
ts_sym_factor = 3,
ts_sym_number = 4,
ts_sym_plus = 5,
ts_sym_term = 6,
ts_sym_times = 7,
ts_sym_variable = 8,
ts_aux_sym_token1 = 9,
ts_aux_sym_token2 = 10,
};
SYMBOL_NAMES = {
"error",
"end",
"expression",
"factor",
"number",
@ -26,16 +28,9 @@ SYMBOL_NAMES = {
"token2",
};
HIDDEN_SYMBOL_FLAGS = {
0,
0,
0,
0,
0,
0,
0,
1,
1,
HIDDEN_SYMBOLS(11) = {
[ts_aux_sym_token1] = 1,
[ts_aux_sym_token2] = 1,
};
LEX_FN() {
@ -136,369 +131,368 @@ LEX_FN() {
}
}
PARSE_TABLE() {
START_TABLE(52)
LEX_STATES(52) = {
[0] = 8,
[1] = 0,
[2] = 15,
[3] = 8,
[4] = 1,
[5] = 1,
[6] = 8,
[7] = 3,
[8] = 1,
[9] = 6,
[10] = 8,
[11] = 5,
[12] = 5,
[13] = 8,
[14] = 3,
[15] = 5,
[16] = 6,
[17] = 5,
[18] = 8,
[19] = 14,
[20] = 8,
[21] = 3,
[22] = 3,
[23] = 8,
[24] = 3,
[25] = 3,
[26] = 8,
[27] = 3,
[28] = 6,
[29] = 14,
[30] = 3,
[31] = 8,
[32] = 3,
[33] = 14,
[34] = 15,
[35] = 1,
[36] = 8,
[37] = 16,
[38] = 8,
[39] = 0,
[40] = 0,
[41] = 8,
[42] = 3,
[43] = 0,
[44] = 16,
[45] = 0,
[46] = 8,
[47] = 3,
[48] = 16,
[49] = 8,
[50] = 3,
[51] = 15,
};
PARSE_TABLE(52, 11) = {
[0] = {
[ts_sym_expression] = SHIFT(1),
[ts_sym_factor] = SHIFT(2),
[ts_sym_number] = SHIFT(34),
[ts_sym_term] = SHIFT(35),
[ts_sym_variable] = SHIFT(34),
[ts_aux_sym_token1] = SHIFT(49),
},
STATE(0);
SET_LEX_STATE(8);
SHIFT(ts_sym_expression, 1)
SHIFT(ts_sym_factor, 2)
SHIFT(ts_sym_number, 34)
SHIFT(ts_sym_term, 35)
SHIFT(ts_sym_variable, 34)
SHIFT(ts_aux_sym_token1, 49)
END_STATE();
[1] = {
[ts_builtin_sym_end] = ACCEPT_INPUT(),
},
STATE(1);
SET_LEX_STATE(0);
ACCEPT_INPUT(ts_builtin_sym_end)
END_STATE();
[2] = {
[ts_sym_plus] = REDUCE(ts_sym_term, 1),
[ts_sym_times] = SHIFT(3),
[ts_builtin_sym_end] = REDUCE(ts_sym_term, 1),
},
STATE(2);
SET_LEX_STATE(15);
REDUCE(ts_sym_plus, ts_sym_term, 1)
SHIFT(ts_sym_times, 3)
REDUCE(ts_builtin_sym_end, ts_sym_term, 1)
END_STATE();
[3] = {
[ts_sym_factor] = SHIFT(4),
[ts_sym_number] = SHIFT(5),
[ts_sym_variable] = SHIFT(5),
[ts_aux_sym_token1] = SHIFT(6),
},
STATE(3);
SET_LEX_STATE(8);
SHIFT(ts_sym_factor, 4)
SHIFT(ts_sym_number, 5)
SHIFT(ts_sym_variable, 5)
SHIFT(ts_aux_sym_token1, 6)
END_STATE();
[4] = {
[ts_sym_plus] = REDUCE(ts_sym_term, 3),
[ts_builtin_sym_end] = REDUCE(ts_sym_term, 3),
},
STATE(4);
SET_LEX_STATE(1);
REDUCE(ts_sym_plus, ts_sym_term, 3)
REDUCE(ts_builtin_sym_end, ts_sym_term, 3)
END_STATE();
[5] = {
[ts_sym_plus] = REDUCE(ts_sym_factor, 1),
[ts_builtin_sym_end] = REDUCE(ts_sym_factor, 1),
},
STATE(5);
SET_LEX_STATE(1);
REDUCE(ts_sym_plus, ts_sym_factor, 1)
REDUCE(ts_builtin_sym_end, ts_sym_factor, 1)
END_STATE();
[6] = {
[ts_sym_expression] = SHIFT(7),
[ts_sym_factor] = SHIFT(9),
[ts_sym_number] = SHIFT(16),
[ts_sym_term] = SHIFT(17),
[ts_sym_variable] = SHIFT(16),
[ts_aux_sym_token1] = SHIFT(26),
[ts_builtin_sym_error] = SHIFT(7),
},
STATE(6);
SET_LEX_STATE(8);
SHIFT(ts_sym_expression, 7)
SHIFT(ts_sym_factor, 9)
SHIFT(ts_sym_number, 16)
SHIFT(ts_sym_term, 17)
SHIFT(ts_sym_variable, 16)
SHIFT(ts_aux_sym_token1, 26)
SHIFT(ts_builtin_sym_error, 7)
END_STATE();
[7] = {
[ts_aux_sym_token2] = SHIFT(8),
},
STATE(7);
SET_LEX_STATE(3);
SHIFT(ts_aux_sym_token2, 8)
END_STATE();
[8] = {
[ts_sym_plus] = REDUCE(ts_sym_factor, 3),
[ts_builtin_sym_end] = REDUCE(ts_sym_factor, 3),
},
STATE(8);
SET_LEX_STATE(1);
REDUCE(ts_sym_plus, ts_sym_factor, 3)
REDUCE(ts_builtin_sym_end, ts_sym_factor, 3)
END_STATE();
[9] = {
[ts_sym_plus] = REDUCE(ts_sym_term, 1),
[ts_sym_times] = SHIFT(10),
[ts_aux_sym_token2] = REDUCE(ts_sym_term, 1),
},
STATE(9);
SET_LEX_STATE(6);
REDUCE(ts_sym_plus, ts_sym_term, 1)
SHIFT(ts_sym_times, 10)
REDUCE(ts_aux_sym_token2, ts_sym_term, 1)
END_STATE();
[10] = {
[ts_sym_factor] = SHIFT(11),
[ts_sym_number] = SHIFT(12),
[ts_sym_variable] = SHIFT(12),
[ts_aux_sym_token1] = SHIFT(13),
},
STATE(10);
SET_LEX_STATE(8);
SHIFT(ts_sym_factor, 11)
SHIFT(ts_sym_number, 12)
SHIFT(ts_sym_variable, 12)
SHIFT(ts_aux_sym_token1, 13)
END_STATE();
[11] = {
[ts_sym_plus] = REDUCE(ts_sym_term, 3),
[ts_aux_sym_token2] = REDUCE(ts_sym_term, 3),
},
STATE(11);
SET_LEX_STATE(5);
REDUCE(ts_sym_plus, ts_sym_term, 3)
REDUCE(ts_aux_sym_token2, ts_sym_term, 3)
END_STATE();
[12] = {
[ts_sym_plus] = REDUCE(ts_sym_factor, 1),
[ts_aux_sym_token2] = REDUCE(ts_sym_factor, 1),
},
STATE(12);
SET_LEX_STATE(5);
REDUCE(ts_sym_plus, ts_sym_factor, 1)
REDUCE(ts_aux_sym_token2, ts_sym_factor, 1)
END_STATE();
[13] = {
[ts_sym_expression] = SHIFT(14),
[ts_sym_factor] = SHIFT(9),
[ts_sym_number] = SHIFT(16),
[ts_sym_term] = SHIFT(17),
[ts_sym_variable] = SHIFT(16),
[ts_aux_sym_token1] = SHIFT(26),
[ts_builtin_sym_error] = SHIFT(14),
},
STATE(13);
SET_LEX_STATE(8);
SHIFT(ts_sym_expression, 14)
SHIFT(ts_sym_factor, 9)
SHIFT(ts_sym_number, 16)
SHIFT(ts_sym_term, 17)
SHIFT(ts_sym_variable, 16)
SHIFT(ts_aux_sym_token1, 26)
SHIFT(ts_builtin_sym_error, 14)
END_STATE();
[14] = {
[ts_aux_sym_token2] = SHIFT(15),
},
STATE(14);
SET_LEX_STATE(3);
SHIFT(ts_aux_sym_token2, 15)
END_STATE();
[15] = {
[ts_sym_plus] = REDUCE(ts_sym_factor, 3),
[ts_aux_sym_token2] = REDUCE(ts_sym_factor, 3),
},
STATE(15);
SET_LEX_STATE(5);
REDUCE(ts_sym_plus, ts_sym_factor, 3)
REDUCE(ts_aux_sym_token2, ts_sym_factor, 3)
END_STATE();
[16] = {
[ts_sym_plus] = REDUCE(ts_sym_factor, 1),
[ts_sym_times] = REDUCE(ts_sym_factor, 1),
[ts_aux_sym_token2] = REDUCE(ts_sym_factor, 1),
},
STATE(16);
SET_LEX_STATE(6);
REDUCE(ts_sym_plus, ts_sym_factor, 1)
REDUCE(ts_sym_times, ts_sym_factor, 1)
REDUCE(ts_aux_sym_token2, ts_sym_factor, 1)
END_STATE();
[17] = {
[ts_sym_plus] = SHIFT(18),
[ts_aux_sym_token2] = REDUCE(ts_sym_expression, 1),
},
STATE(17);
SET_LEX_STATE(5);
SHIFT(ts_sym_plus, 18)
REDUCE(ts_aux_sym_token2, ts_sym_expression, 1)
END_STATE();
[18] = {
[ts_sym_factor] = SHIFT(19),
[ts_sym_number] = SHIFT(29),
[ts_sym_term] = SHIFT(30),
[ts_sym_variable] = SHIFT(29),
[ts_aux_sym_token1] = SHIFT(31),
},
STATE(18);
SET_LEX_STATE(8);
SHIFT(ts_sym_factor, 19)
SHIFT(ts_sym_number, 29)
SHIFT(ts_sym_term, 30)
SHIFT(ts_sym_variable, 29)
SHIFT(ts_aux_sym_token1, 31)
END_STATE();
[19] = {
[ts_sym_times] = SHIFT(20),
[ts_aux_sym_token2] = REDUCE(ts_sym_term, 1),
},
STATE(19);
SET_LEX_STATE(14);
SHIFT(ts_sym_times, 20)
REDUCE(ts_aux_sym_token2, ts_sym_term, 1)
END_STATE();
[20] = {
[ts_sym_factor] = SHIFT(21),
[ts_sym_number] = SHIFT(22),
[ts_sym_variable] = SHIFT(22),
[ts_aux_sym_token1] = SHIFT(23),
},
STATE(20);
SET_LEX_STATE(8);
SHIFT(ts_sym_factor, 21)
SHIFT(ts_sym_number, 22)
SHIFT(ts_sym_variable, 22)
SHIFT(ts_aux_sym_token1, 23)
END_STATE();
[21] = {
[ts_aux_sym_token2] = REDUCE(ts_sym_term, 3),
},
STATE(21);
SET_LEX_STATE(3);
REDUCE(ts_aux_sym_token2, ts_sym_term, 3)
END_STATE();
[22] = {
[ts_aux_sym_token2] = REDUCE(ts_sym_factor, 1),
},
STATE(22);
SET_LEX_STATE(3);
REDUCE(ts_aux_sym_token2, ts_sym_factor, 1)
END_STATE();
[23] = {
[ts_sym_expression] = SHIFT(24),
[ts_sym_factor] = SHIFT(9),
[ts_sym_number] = SHIFT(16),
[ts_sym_term] = SHIFT(17),
[ts_sym_variable] = SHIFT(16),
[ts_aux_sym_token1] = SHIFT(26),
[ts_builtin_sym_error] = SHIFT(24),
},
STATE(23);
SET_LEX_STATE(8);
SHIFT(ts_sym_expression, 24)
SHIFT(ts_sym_factor, 9)
SHIFT(ts_sym_number, 16)
SHIFT(ts_sym_term, 17)
SHIFT(ts_sym_variable, 16)
SHIFT(ts_aux_sym_token1, 26)
SHIFT(ts_builtin_sym_error, 24)
END_STATE();
[24] = {
[ts_aux_sym_token2] = SHIFT(25),
},
STATE(24);
SET_LEX_STATE(3);
SHIFT(ts_aux_sym_token2, 25)
END_STATE();
[25] = {
[ts_aux_sym_token2] = REDUCE(ts_sym_factor, 3),
},
STATE(25);
SET_LEX_STATE(3);
REDUCE(ts_aux_sym_token2, ts_sym_factor, 3)
END_STATE();
[26] = {
[ts_sym_expression] = SHIFT(27),
[ts_sym_factor] = SHIFT(9),
[ts_sym_number] = SHIFT(16),
[ts_sym_term] = SHIFT(17),
[ts_sym_variable] = SHIFT(16),
[ts_aux_sym_token1] = SHIFT(26),
[ts_builtin_sym_error] = SHIFT(27),
},
STATE(26);
SET_LEX_STATE(8);
SHIFT(ts_sym_expression, 27)
SHIFT(ts_sym_factor, 9)
SHIFT(ts_sym_number, 16)
SHIFT(ts_sym_term, 17)
SHIFT(ts_sym_variable, 16)
SHIFT(ts_aux_sym_token1, 26)
SHIFT(ts_builtin_sym_error, 27)
END_STATE();
[27] = {
[ts_aux_sym_token2] = SHIFT(28),
},
STATE(27);
SET_LEX_STATE(3);
SHIFT(ts_aux_sym_token2, 28)
END_STATE();
[28] = {
[ts_sym_plus] = REDUCE(ts_sym_factor, 3),
[ts_sym_times] = REDUCE(ts_sym_factor, 3),
[ts_aux_sym_token2] = REDUCE(ts_sym_factor, 3),
},
STATE(28);
SET_LEX_STATE(6);
REDUCE(ts_sym_plus, ts_sym_factor, 3)
REDUCE(ts_sym_times, ts_sym_factor, 3)
REDUCE(ts_aux_sym_token2, ts_sym_factor, 3)
END_STATE();
[29] = {
[ts_sym_times] = REDUCE(ts_sym_factor, 1),
[ts_aux_sym_token2] = REDUCE(ts_sym_factor, 1),
},
STATE(29);
SET_LEX_STATE(14);
REDUCE(ts_sym_times, ts_sym_factor, 1)
REDUCE(ts_aux_sym_token2, ts_sym_factor, 1)
END_STATE();
[30] = {
[ts_aux_sym_token2] = REDUCE(ts_sym_expression, 3),
},
STATE(30);
SET_LEX_STATE(3);
REDUCE(ts_aux_sym_token2, ts_sym_expression, 3)
END_STATE();
[31] = {
[ts_sym_expression] = SHIFT(32),
[ts_sym_factor] = SHIFT(9),
[ts_sym_number] = SHIFT(16),
[ts_sym_term] = SHIFT(17),
[ts_sym_variable] = SHIFT(16),
[ts_aux_sym_token1] = SHIFT(26),
[ts_builtin_sym_error] = SHIFT(32),
},
STATE(31);
SET_LEX_STATE(8);
SHIFT(ts_sym_expression, 32)
SHIFT(ts_sym_factor, 9)
SHIFT(ts_sym_number, 16)
SHIFT(ts_sym_term, 17)
SHIFT(ts_sym_variable, 16)
SHIFT(ts_aux_sym_token1, 26)
SHIFT(ts_builtin_sym_error, 32)
END_STATE();
[32] = {
[ts_aux_sym_token2] = SHIFT(33),
},
STATE(32);
SET_LEX_STATE(3);
SHIFT(ts_aux_sym_token2, 33)
END_STATE();
[33] = {
[ts_sym_times] = REDUCE(ts_sym_factor, 3),
[ts_aux_sym_token2] = REDUCE(ts_sym_factor, 3),
},
STATE(33);
SET_LEX_STATE(14);
REDUCE(ts_sym_times, ts_sym_factor, 3)
REDUCE(ts_aux_sym_token2, ts_sym_factor, 3)
END_STATE();
[34] = {
[ts_sym_plus] = REDUCE(ts_sym_factor, 1),
[ts_sym_times] = REDUCE(ts_sym_factor, 1),
[ts_builtin_sym_end] = REDUCE(ts_sym_factor, 1),
},
STATE(34);
SET_LEX_STATE(15);
REDUCE(ts_sym_plus, ts_sym_factor, 1)
REDUCE(ts_sym_times, ts_sym_factor, 1)
REDUCE(ts_builtin_sym_end, ts_sym_factor, 1)
END_STATE();
[35] = {
[ts_sym_plus] = SHIFT(36),
[ts_builtin_sym_end] = REDUCE(ts_sym_expression, 1),
},
STATE(35);
SET_LEX_STATE(1);
SHIFT(ts_sym_plus, 36)
REDUCE(ts_builtin_sym_end, ts_sym_expression, 1)
END_STATE();
[36] = {
[ts_sym_factor] = SHIFT(37),
[ts_sym_number] = SHIFT(44),
[ts_sym_term] = SHIFT(45),
[ts_sym_variable] = SHIFT(44),
[ts_aux_sym_token1] = SHIFT(46),
},
STATE(36);
SET_LEX_STATE(8);
SHIFT(ts_sym_factor, 37)
SHIFT(ts_sym_number, 44)
SHIFT(ts_sym_term, 45)
SHIFT(ts_sym_variable, 44)
SHIFT(ts_aux_sym_token1, 46)
END_STATE();
[37] = {
[ts_sym_times] = SHIFT(38),
[ts_builtin_sym_end] = REDUCE(ts_sym_term, 1),
},
STATE(37);
SET_LEX_STATE(16);
SHIFT(ts_sym_times, 38)
REDUCE(ts_builtin_sym_end, ts_sym_term, 1)
END_STATE();
[38] = {
[ts_sym_factor] = SHIFT(39),
[ts_sym_number] = SHIFT(40),
[ts_sym_variable] = SHIFT(40),
[ts_aux_sym_token1] = SHIFT(41),
},
STATE(38);
SET_LEX_STATE(8);
SHIFT(ts_sym_factor, 39)
SHIFT(ts_sym_number, 40)
SHIFT(ts_sym_variable, 40)
SHIFT(ts_aux_sym_token1, 41)
END_STATE();
[39] = {
[ts_builtin_sym_end] = REDUCE(ts_sym_term, 3),
},
STATE(39);
SET_LEX_STATE(0);
REDUCE(ts_builtin_sym_end, ts_sym_term, 3)
END_STATE();
[40] = {
[ts_builtin_sym_end] = REDUCE(ts_sym_factor, 1),
},
STATE(40);
SET_LEX_STATE(0);
REDUCE(ts_builtin_sym_end, ts_sym_factor, 1)
END_STATE();
[41] = {
[ts_sym_expression] = SHIFT(42),
[ts_sym_factor] = SHIFT(9),
[ts_sym_number] = SHIFT(16),
[ts_sym_term] = SHIFT(17),
[ts_sym_variable] = SHIFT(16),
[ts_aux_sym_token1] = SHIFT(26),
[ts_builtin_sym_error] = SHIFT(42),
},
STATE(41);
SET_LEX_STATE(8);
SHIFT(ts_sym_expression, 42)
SHIFT(ts_sym_factor, 9)
SHIFT(ts_sym_number, 16)
SHIFT(ts_sym_term, 17)
SHIFT(ts_sym_variable, 16)
SHIFT(ts_aux_sym_token1, 26)
SHIFT(ts_builtin_sym_error, 42)
END_STATE();
[42] = {
[ts_aux_sym_token2] = SHIFT(43),
},
STATE(42);
SET_LEX_STATE(3);
SHIFT(ts_aux_sym_token2, 43)
END_STATE();
[43] = {
[ts_builtin_sym_end] = REDUCE(ts_sym_factor, 3),
},
STATE(43);
SET_LEX_STATE(0);
REDUCE(ts_builtin_sym_end, ts_sym_factor, 3)
END_STATE();
[44] = {
[ts_sym_times] = REDUCE(ts_sym_factor, 1),
[ts_builtin_sym_end] = REDUCE(ts_sym_factor, 1),
},
STATE(44);
SET_LEX_STATE(16);
REDUCE(ts_sym_times, ts_sym_factor, 1)
REDUCE(ts_builtin_sym_end, ts_sym_factor, 1)
END_STATE();
[45] = {
[ts_builtin_sym_end] = REDUCE(ts_sym_expression, 3),
},
STATE(45);
SET_LEX_STATE(0);
REDUCE(ts_builtin_sym_end, ts_sym_expression, 3)
END_STATE();
[46] = {
[ts_sym_expression] = SHIFT(47),
[ts_sym_factor] = SHIFT(9),
[ts_sym_number] = SHIFT(16),
[ts_sym_term] = SHIFT(17),
[ts_sym_variable] = SHIFT(16),
[ts_aux_sym_token1] = SHIFT(26),
[ts_builtin_sym_error] = SHIFT(47),
},
STATE(46);
SET_LEX_STATE(8);
SHIFT(ts_sym_expression, 47)
SHIFT(ts_sym_factor, 9)
SHIFT(ts_sym_number, 16)
SHIFT(ts_sym_term, 17)
SHIFT(ts_sym_variable, 16)
SHIFT(ts_aux_sym_token1, 26)
SHIFT(ts_builtin_sym_error, 47)
END_STATE();
[47] = {
[ts_aux_sym_token2] = SHIFT(48),
},
STATE(47);
SET_LEX_STATE(3);
SHIFT(ts_aux_sym_token2, 48)
END_STATE();
[48] = {
[ts_sym_times] = REDUCE(ts_sym_factor, 3),
[ts_builtin_sym_end] = REDUCE(ts_sym_factor, 3),
},
STATE(48);
SET_LEX_STATE(16);
REDUCE(ts_sym_times, ts_sym_factor, 3)
REDUCE(ts_builtin_sym_end, ts_sym_factor, 3)
END_STATE();
[49] = {
[ts_sym_expression] = SHIFT(50),
[ts_sym_factor] = SHIFT(9),
[ts_sym_number] = SHIFT(16),
[ts_sym_term] = SHIFT(17),
[ts_sym_variable] = SHIFT(16),
[ts_aux_sym_token1] = SHIFT(26),
[ts_builtin_sym_error] = SHIFT(50),
},
STATE(49);
SET_LEX_STATE(8);
SHIFT(ts_sym_expression, 50)
SHIFT(ts_sym_factor, 9)
SHIFT(ts_sym_number, 16)
SHIFT(ts_sym_term, 17)
SHIFT(ts_sym_variable, 16)
SHIFT(ts_aux_sym_token1, 26)
SHIFT(ts_builtin_sym_error, 50)
END_STATE();
[50] = {
[ts_aux_sym_token2] = SHIFT(51),
},
STATE(50);
SET_LEX_STATE(3);
SHIFT(ts_aux_sym_token2, 51)
END_STATE();
STATE(51);
SET_LEX_STATE(15);
REDUCE(ts_sym_plus, ts_sym_factor, 3)
REDUCE(ts_sym_times, ts_sym_factor, 3)
REDUCE(ts_builtin_sym_end, ts_sym_factor, 3)
END_STATE();
END_TABLE();
}
[51] = {
[ts_sym_plus] = REDUCE(ts_sym_factor, 3),
[ts_sym_times] = REDUCE(ts_sym_factor, 3),
[ts_builtin_sym_end] = REDUCE(ts_sym_factor, 3),
},
};
EXPORT_PARSER(ts_parser_arithmetic);

2080
examples/parsers/javascript.c
View file

File diff suppressed because it is too large Load diff

813
examples/parsers/json.c
View file

@ -3,25 +3,27 @@
#define TS_SYMBOL_COUNT 18
enum {
ts_sym_array,
ts_sym_false,
ts_sym_null,
ts_sym_number,
ts_sym_object,
ts_sym_string,
ts_sym_true,
ts_sym_value,
ts_aux_sym_repeat_helper1,
ts_aux_sym_repeat_helper2,
ts_aux_sym_token1,
ts_aux_sym_token2,
ts_aux_sym_token3,
ts_aux_sym_token4,
ts_aux_sym_token5,
ts_aux_sym_token6,
ts_sym_array = 2,
ts_sym_false = 3,
ts_sym_null = 4,
ts_sym_number = 5,
ts_sym_object = 6,
ts_sym_string = 7,
ts_sym_true = 8,
ts_sym_value = 9,
ts_aux_sym_repeat_helper1 = 10,
ts_aux_sym_repeat_helper2 = 11,
ts_aux_sym_token1 = 12,
ts_aux_sym_token2 = 13,
ts_aux_sym_token3 = 14,
ts_aux_sym_token4 = 15,
ts_aux_sym_token5 = 16,
ts_aux_sym_token6 = 17,
};
SYMBOL_NAMES = {
"error",
"end",
"array",
"false",
"null",
@ -40,23 +42,15 @@ SYMBOL_NAMES = {
"token6",
};
HIDDEN_SYMBOL_FLAGS = {
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
HIDDEN_SYMBOLS(18) = {
[ts_aux_sym_repeat_helper1] = 1,
[ts_aux_sym_repeat_helper2] = 1,
[ts_aux_sym_token1] = 1,
[ts_aux_sym_token2] = 1,
[ts_aux_sym_token3] = 1,
[ts_aux_sym_token4] = 1,
[ts_aux_sym_token5] = 1,
[ts_aux_sym_token6] = 1,
};
LEX_FN() {
@ -332,441 +326,440 @@ LEX_FN() {
}
}
PARSE_TABLE() {
START_TABLE(60)
LEX_STATES(60) = {
[0] = 8,
[1] = 0,
[2] = 0,
[3] = 41,
[4] = 39,
[5] = 8,
[6] = 1,
[7] = 1,
[8] = 4,
[9] = 0,
[10] = 43,
[11] = 39,
[12] = 8,
[13] = 1,
[14] = 4,
[15] = 41,
[16] = 39,
[17] = 8,
[18] = 1,
[19] = 4,
[20] = 1,
[21] = 42,
[22] = 5,
[23] = 5,
[24] = 7,
[25] = 1,
[26] = 8,
[27] = 5,
[28] = 7,
[29] = 41,
[30] = 39,
[31] = 8,
[32] = 1,
[33] = 4,
[34] = 5,
[35] = 5,
[36] = 1,
[37] = 4,
[38] = 5,
[39] = 42,
[40] = 5,
[41] = 7,
[42] = 5,
[43] = 5,
[44] = 1,
[45] = 1,
[46] = 1,
[47] = 4,
[48] = 1,
[49] = 1,
[50] = 4,
[51] = 0,
[52] = 1,
[53] = 4,
[54] = 0,
[55] = 42,
[56] = 5,
[57] = 7,
[58] = 0,
[59] = 0,
};
PARSE_TABLE(60, 18) = {
[0] = {
[ts_sym_array] = SHIFT(1),
[ts_sym_false] = SHIFT(1),
[ts_sym_null] = SHIFT(1),
[ts_sym_number] = SHIFT(1),
[ts_sym_object] = SHIFT(1),
[ts_sym_string] = SHIFT(1),
[ts_sym_true] = SHIFT(1),
[ts_sym_value] = SHIFT(2),
[ts_aux_sym_token1] = SHIFT(3),
[ts_aux_sym_token5] = SHIFT(55),
},
STATE(0);
SET_LEX_STATE(8);
SHIFT(ts_sym_array, 1)
SHIFT(ts_sym_false, 1)
SHIFT(ts_sym_null, 1)
SHIFT(ts_sym_number, 1)
SHIFT(ts_sym_object, 1)
SHIFT(ts_sym_string, 1)
SHIFT(ts_sym_true, 1)
SHIFT(ts_sym_value, 2)
SHIFT(ts_aux_sym_token1, 3)
SHIFT(ts_aux_sym_token5, 55)
END_STATE();
[1] = {
[ts_builtin_sym_end] = REDUCE(ts_sym_value, 1),
},
STATE(1);
SET_LEX_STATE(0);
REDUCE(ts_builtin_sym_end, ts_sym_value, 1)
END_STATE();
[2] = {
[ts_builtin_sym_end] = ACCEPT_INPUT(),
},
STATE(2);
SET_LEX_STATE(0);
ACCEPT_INPUT(ts_builtin_sym_end)
END_STATE();
[3] = {
[ts_sym_string] = SHIFT(4),
[ts_aux_sym_token4] = SHIFT(51),
[ts_builtin_sym_error] = SHIFT(52),
},
STATE(3);
SET_LEX_STATE(41);
SHIFT(ts_sym_string, 4)
SHIFT(ts_aux_sym_token4, 51)
SHIFT(ts_builtin_sym_error, 52)
END_STATE();
[4] = {
[ts_aux_sym_token2] = SHIFT(5),
},
STATE(4);
SET_LEX_STATE(39);
SHIFT(ts_aux_sym_token2, 5)
END_STATE();
[5] = {
[ts_sym_array] = SHIFT(6),
[ts_sym_false] = SHIFT(6),
[ts_sym_null] = SHIFT(6),
[ts_sym_number] = SHIFT(6),
[ts_sym_object] = SHIFT(6),
[ts_sym_string] = SHIFT(6),
[ts_sym_true] = SHIFT(6),
[ts_sym_value] = SHIFT(7),
[ts_aux_sym_token1] = SHIFT(15),
[ts_aux_sym_token5] = SHIFT(21),
},
STATE(5);
SET_LEX_STATE(8);
SHIFT(ts_sym_array, 6)
SHIFT(ts_sym_false, 6)
SHIFT(ts_sym_null, 6)
SHIFT(ts_sym_number, 6)
SHIFT(ts_sym_object, 6)
SHIFT(ts_sym_string, 6)
SHIFT(ts_sym_true, 6)
SHIFT(ts_sym_value, 7)
SHIFT(ts_aux_sym_token1, 15)
SHIFT(ts_aux_sym_token5, 21)
END_STATE();
[6] = {
[ts_aux_sym_token3] = REDUCE(ts_sym_value, 1),
[ts_aux_sym_token4] = REDUCE(ts_sym_value, 1),
},
STATE(6);
SET_LEX_STATE(1);
REDUCE(ts_aux_sym_token3, ts_sym_value, 1)
REDUCE(ts_aux_sym_token4, ts_sym_value, 1)
END_STATE();
[7] = {
[ts_aux_sym_repeat_helper1] = SHIFT(8),
[ts_aux_sym_token3] = SHIFT(10),
[ts_aux_sym_token4] = REDUCE(ts_aux_sym_repeat_helper1, 0),
},
STATE(7);
SET_LEX_STATE(1);
SHIFT(ts_aux_sym_repeat_helper1, 8)
SHIFT(ts_aux_sym_token3, 10)
REDUCE(ts_aux_sym_token4, ts_aux_sym_repeat_helper1, 0)
END_STATE();
[8] = {
[ts_aux_sym_token4] = SHIFT(9),
},
STATE(8);
SET_LEX_STATE(4);
SHIFT(ts_aux_sym_token4, 9)
END_STATE();
[9] = {
[ts_builtin_sym_end] = REDUCE(ts_sym_object, 6),
},
STATE(9);
SET_LEX_STATE(0);
REDUCE(ts_builtin_sym_end, ts_sym_object, 6)
END_STATE();
[10] = {
[ts_sym_string] = SHIFT(11),
[ts_builtin_sym_error] = SHIFT(49),
},
STATE(10);
SET_LEX_STATE(43);
SHIFT(ts_sym_string, 11)
SHIFT(ts_builtin_sym_error, 49)
END_STATE();
[11] = {
[ts_aux_sym_token2] = SHIFT(12),
},
STATE(11);
SET_LEX_STATE(39);
SHIFT(ts_aux_sym_token2, 12)
END_STATE();
[12] = {
[ts_sym_array] = SHIFT(6),
[ts_sym_false] = SHIFT(6),
[ts_sym_null] = SHIFT(6),
[ts_sym_number] = SHIFT(6),
[ts_sym_object] = SHIFT(6),
[ts_sym_string] = SHIFT(6),
[ts_sym_true] = SHIFT(6),
[ts_sym_value] = SHIFT(13),
[ts_aux_sym_token1] = SHIFT(15),
[ts_aux_sym_token5] = SHIFT(21),
},
STATE(12);
SET_LEX_STATE(8);
SHIFT(ts_sym_array, 6)
SHIFT(ts_sym_false, 6)
SHIFT(ts_sym_null, 6)
SHIFT(ts_sym_number, 6)
SHIFT(ts_sym_object, 6)
SHIFT(ts_sym_string, 6)
SHIFT(ts_sym_true, 6)
SHIFT(ts_sym_value, 13)
SHIFT(ts_aux_sym_token1, 15)
SHIFT(ts_aux_sym_token5, 21)
END_STATE();
[13] = {
[ts_aux_sym_repeat_helper1] = SHIFT(14),
[ts_aux_sym_token3] = SHIFT(10),
[ts_aux_sym_token4] = REDUCE(ts_aux_sym_repeat_helper1, 0),
},
STATE(13);
SET_LEX_STATE(1);
SHIFT(ts_aux_sym_repeat_helper1, 14)
SHIFT(ts_aux_sym_token3, 10)
REDUCE(ts_aux_sym_token4, ts_aux_sym_repeat_helper1, 0)
END_STATE();
[14] = {
[ts_aux_sym_token4] = REDUCE(ts_aux_sym_repeat_helper1, 5),
},
STATE(14);
SET_LEX_STATE(4);
REDUCE(ts_aux_sym_token4, ts_aux_sym_repeat_helper1, 5)
END_STATE();
[15] = {
[ts_sym_string] = SHIFT(16),
[ts_aux_sym_token4] = SHIFT(45),
[ts_builtin_sym_error] = SHIFT(46),
},
STATE(15);
SET_LEX_STATE(41);
SHIFT(ts_sym_string, 16)
SHIFT(ts_aux_sym_token4, 45)
SHIFT(ts_builtin_sym_error, 46)
END_STATE();
[16] = {
[ts_aux_sym_token2] = SHIFT(17),
},
STATE(16);
SET_LEX_STATE(39);
SHIFT(ts_aux_sym_token2, 17)
END_STATE();
[17] = {
[ts_sym_array] = SHIFT(6),
[ts_sym_false] = SHIFT(6),
[ts_sym_null] = SHIFT(6),
[ts_sym_number] = SHIFT(6),
[ts_sym_object] = SHIFT(6),
[ts_sym_string] = SHIFT(6),
[ts_sym_true] = SHIFT(6),
[ts_sym_value] = SHIFT(18),
[ts_aux_sym_token1] = SHIFT(15),
[ts_aux_sym_token5] = SHIFT(21),
},
STATE(17);
SET_LEX_STATE(8);
SHIFT(ts_sym_array, 6)
SHIFT(ts_sym_false, 6)
SHIFT(ts_sym_null, 6)
SHIFT(ts_sym_number, 6)
SHIFT(ts_sym_object, 6)
SHIFT(ts_sym_string, 6)
SHIFT(ts_sym_true, 6)
SHIFT(ts_sym_value, 18)
SHIFT(ts_aux_sym_token1, 15)
SHIFT(ts_aux_sym_token5, 21)
END_STATE();
[18] = {
[ts_aux_sym_repeat_helper1] = SHIFT(19),
[ts_aux_sym_token3] = SHIFT(10),
[ts_aux_sym_token4] = REDUCE(ts_aux_sym_repeat_helper1, 0),
},
STATE(18);
SET_LEX_STATE(1);
SHIFT(ts_aux_sym_repeat_helper1, 19)
SHIFT(ts_aux_sym_token3, 10)
REDUCE(ts_aux_sym_token4, ts_aux_sym_repeat_helper1, 0)
END_STATE();
[19] = {
[ts_aux_sym_token4] = SHIFT(20),
},
STATE(19);
SET_LEX_STATE(4);
SHIFT(ts_aux_sym_token4, 20)
END_STATE();
[20] = {
[ts_aux_sym_token3] = REDUCE(ts_sym_object, 6),
[ts_aux_sym_token4] = REDUCE(ts_sym_object, 6),
},
STATE(20);
SET_LEX_STATE(1);
REDUCE(ts_aux_sym_token3, ts_sym_object, 6)
REDUCE(ts_aux_sym_token4, ts_sym_object, 6)
END_STATE();
[21] = {
[ts_sym_array] = SHIFT(22),
[ts_sym_false] = SHIFT(22),
[ts_sym_null] = SHIFT(22),
[ts_sym_number] = SHIFT(22),
[ts_sym_object] = SHIFT(22),
[ts_sym_string] = SHIFT(22),
[ts_sym_true] = SHIFT(22),
[ts_sym_value] = SHIFT(23),
[ts_aux_sym_token1] = SHIFT(29),
[ts_aux_sym_token5] = SHIFT(39),
[ts_aux_sym_token6] = SHIFT(44),
[ts_builtin_sym_error] = SHIFT(23),
},
STATE(21);
SET_LEX_STATE(42);
SHIFT(ts_sym_array, 22)
SHIFT(ts_sym_false, 22)
SHIFT(ts_sym_null, 22)
SHIFT(ts_sym_number, 22)
SHIFT(ts_sym_object, 22)
SHIFT(ts_sym_string, 22)
SHIFT(ts_sym_true, 22)
SHIFT(ts_sym_value, 23)
SHIFT(ts_aux_sym_token1, 29)
SHIFT(ts_aux_sym_token5, 39)
SHIFT(ts_aux_sym_token6, 44)
SHIFT(ts_builtin_sym_error, 23)
END_STATE();
[22] = {
[ts_aux_sym_token3] = REDUCE(ts_sym_value, 1),
[ts_aux_sym_token6] = REDUCE(ts_sym_value, 1),
},
STATE(22);
SET_LEX_STATE(5);
REDUCE(ts_aux_sym_token3, ts_sym_value, 1)
REDUCE(ts_aux_sym_token6, ts_sym_value, 1)
END_STATE();
[23] = {
[ts_aux_sym_repeat_helper2] = SHIFT(24),
[ts_aux_sym_token3] = SHIFT(26),
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper2, 0),
},
STATE(23);
SET_LEX_STATE(5);
SHIFT(ts_aux_sym_repeat_helper2, 24)
SHIFT(ts_aux_sym_token3, 26)
REDUCE(ts_aux_sym_token6, ts_aux_sym_repeat_helper2, 0)
END_STATE();
[24] = {
[ts_aux_sym_token6] = SHIFT(25),
},
STATE(24);
SET_LEX_STATE(7);
SHIFT(ts_aux_sym_token6, 25)
END_STATE();
[25] = {
[ts_aux_sym_token3] = REDUCE(ts_sym_array, 4),
[ts_aux_sym_token4] = REDUCE(ts_sym_array, 4),
},
STATE(25);
SET_LEX_STATE(1);
REDUCE(ts_aux_sym_token3, ts_sym_array, 4)
REDUCE(ts_aux_sym_token4, ts_sym_array, 4)
END_STATE();
[26] = {
[ts_sym_array] = SHIFT(22),
[ts_sym_false] = SHIFT(22),
[ts_sym_null] = SHIFT(22),
[ts_sym_number] = SHIFT(22),
[ts_sym_object] = SHIFT(22),
[ts_sym_string] = SHIFT(22),
[ts_sym_true] = SHIFT(22),
[ts_sym_value] = SHIFT(27),
[ts_aux_sym_token1] = SHIFT(29),
[ts_aux_sym_token5] = SHIFT(39),
[ts_builtin_sym_error] = SHIFT(27),
},
STATE(26);
SET_LEX_STATE(8);
SHIFT(ts_sym_array, 22)
SHIFT(ts_sym_false, 22)
SHIFT(ts_sym_null, 22)
SHIFT(ts_sym_number, 22)
SHIFT(ts_sym_object, 22)
SHIFT(ts_sym_string, 22)
SHIFT(ts_sym_true, 22)
SHIFT(ts_sym_value, 27)
SHIFT(ts_aux_sym_token1, 29)
SHIFT(ts_aux_sym_token5, 39)
SHIFT(ts_builtin_sym_error, 27)
END_STATE();
[27] = {
[ts_aux_sym_repeat_helper2] = SHIFT(28),
[ts_aux_sym_token3] = SHIFT(26),
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper2, 0),
},
STATE(27);
SET_LEX_STATE(5);
SHIFT(ts_aux_sym_repeat_helper2, 28)
SHIFT(ts_aux_sym_token3, 26)
REDUCE(ts_aux_sym_token6, ts_aux_sym_repeat_helper2, 0)
END_STATE();
[28] = {
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper2, 3),
},
STATE(28);
SET_LEX_STATE(7);
REDUCE(ts_aux_sym_token6, ts_aux_sym_repeat_helper2, 3)
END_STATE();
[29] = {
[ts_sym_string] = SHIFT(30),
[ts_aux_sym_token4] = SHIFT(35),
[ts_builtin_sym_error] = SHIFT(36),
},
STATE(29);
SET_LEX_STATE(41);
SHIFT(ts_sym_string, 30)
SHIFT(ts_aux_sym_token4, 35)
SHIFT(ts_builtin_sym_error, 36)
END_STATE();
[30] = {
[ts_aux_sym_token2] = SHIFT(31),
},
STATE(30);
SET_LEX_STATE(39);
SHIFT(ts_aux_sym_token2, 31)
END_STATE();
[31] = {
[ts_sym_array] = SHIFT(6),
[ts_sym_false] = SHIFT(6),
[ts_sym_null] = SHIFT(6),
[ts_sym_number] = SHIFT(6),
[ts_sym_object] = SHIFT(6),
[ts_sym_string] = SHIFT(6),
[ts_sym_true] = SHIFT(6),
[ts_sym_value] = SHIFT(32),
[ts_aux_sym_token1] = SHIFT(15),
[ts_aux_sym_token5] = SHIFT(21),
},
STATE(31);
SET_LEX_STATE(8);
SHIFT(ts_sym_array, 6)
SHIFT(ts_sym_false, 6)
SHIFT(ts_sym_null, 6)
SHIFT(ts_sym_number, 6)
SHIFT(ts_sym_object, 6)
SHIFT(ts_sym_string, 6)
SHIFT(ts_sym_true, 6)
SHIFT(ts_sym_value, 32)
SHIFT(ts_aux_sym_token1, 15)
SHIFT(ts_aux_sym_token5, 21)
END_STATE();
[32] = {
[ts_aux_sym_repeat_helper1] = SHIFT(33),
[ts_aux_sym_token3] = SHIFT(10),
[ts_aux_sym_token4] = REDUCE(ts_aux_sym_repeat_helper1, 0),
},
STATE(32);
SET_LEX_STATE(1);
SHIFT(ts_aux_sym_repeat_helper1, 33)
SHIFT(ts_aux_sym_token3, 10)
REDUCE(ts_aux_sym_token4, ts_aux_sym_repeat_helper1, 0)
END_STATE();
[33] = {
[ts_aux_sym_token4] = SHIFT(34),
},
STATE(33);
SET_LEX_STATE(4);
SHIFT(ts_aux_sym_token4, 34)
END_STATE();
[34] = {
[ts_aux_sym_token3] = REDUCE(ts_sym_object, 6),
[ts_aux_sym_token6] = REDUCE(ts_sym_object, 6),
},
STATE(34);
SET_LEX_STATE(5);
REDUCE(ts_aux_sym_token3, ts_sym_object, 6)
REDUCE(ts_aux_sym_token6, ts_sym_object, 6)
END_STATE();
[35] = {
[ts_aux_sym_token3] = REDUCE(ts_sym_object, 2),
[ts_aux_sym_token6] = REDUCE(ts_sym_object, 2),
},
STATE(35);
SET_LEX_STATE(5);
REDUCE(ts_aux_sym_token3, ts_sym_object, 2)
REDUCE(ts_aux_sym_token6, ts_sym_object, 2)
END_STATE();
[36] = {
[ts_aux_sym_repeat_helper1] = SHIFT(37),
[ts_aux_sym_token3] = SHIFT(10),
[ts_aux_sym_token4] = REDUCE(ts_aux_sym_repeat_helper1, 0),
},
STATE(36);
SET_LEX_STATE(1);
SHIFT(ts_aux_sym_repeat_helper1, 37)
SHIFT(ts_aux_sym_token3, 10)
REDUCE(ts_aux_sym_token4, ts_aux_sym_repeat_helper1, 0)
END_STATE();
[37] = {
[ts_aux_sym_token4] = SHIFT(38),
},
STATE(37);
SET_LEX_STATE(4);
SHIFT(ts_aux_sym_token4, 38)
END_STATE();
[38] = {
[ts_aux_sym_token3] = REDUCE(ts_sym_object, 4),
[ts_aux_sym_token6] = REDUCE(ts_sym_object, 4),
},
STATE(38);
SET_LEX_STATE(5);
REDUCE(ts_aux_sym_token3, ts_sym_object, 4)
REDUCE(ts_aux_sym_token6, ts_sym_object, 4)
END_STATE();
[39] = {
[ts_sym_array] = SHIFT(22),
[ts_sym_false] = SHIFT(22),
[ts_sym_null] = SHIFT(22),
[ts_sym_number] = SHIFT(22),
[ts_sym_object] = SHIFT(22),
[ts_sym_string] = SHIFT(22),
[ts_sym_true] = SHIFT(22),
[ts_sym_value] = SHIFT(40),
[ts_aux_sym_token1] = SHIFT(29),
[ts_aux_sym_token5] = SHIFT(39),
[ts_aux_sym_token6] = SHIFT(43),
[ts_builtin_sym_error] = SHIFT(40),
},
STATE(39);
SET_LEX_STATE(42);
SHIFT(ts_sym_array, 22)
SHIFT(ts_sym_false, 22)
SHIFT(ts_sym_null, 22)
SHIFT(ts_sym_number, 22)
SHIFT(ts_sym_object, 22)
SHIFT(ts_sym_string, 22)
SHIFT(ts_sym_true, 22)
SHIFT(ts_sym_value, 40)
SHIFT(ts_aux_sym_token1, 29)
SHIFT(ts_aux_sym_token5, 39)
SHIFT(ts_aux_sym_token6, 43)
SHIFT(ts_builtin_sym_error, 40)
END_STATE();
[40] = {
[ts_aux_sym_repeat_helper2] = SHIFT(41),
[ts_aux_sym_token3] = SHIFT(26),
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper2, 0),
},
STATE(40);
SET_LEX_STATE(5);
SHIFT(ts_aux_sym_repeat_helper2, 41)
SHIFT(ts_aux_sym_token3, 26)
REDUCE(ts_aux_sym_token6, ts_aux_sym_repeat_helper2, 0)
END_STATE();
[41] = {
[ts_aux_sym_token6] = SHIFT(42),
},
STATE(41);
SET_LEX_STATE(7);
SHIFT(ts_aux_sym_token6, 42)
END_STATE();
[42] = {
[ts_aux_sym_token3] = REDUCE(ts_sym_array, 4),
[ts_aux_sym_token6] = REDUCE(ts_sym_array, 4),
},
STATE(42);
SET_LEX_STATE(5);
REDUCE(ts_aux_sym_token3, ts_sym_array, 4)
REDUCE(ts_aux_sym_token6, ts_sym_array, 4)
END_STATE();
[43] = {
[ts_aux_sym_token3] = REDUCE(ts_sym_array, 2),
[ts_aux_sym_token6] = REDUCE(ts_sym_array, 2),
},
STATE(43);
SET_LEX_STATE(5);
REDUCE(ts_aux_sym_token3, ts_sym_array, 2)
REDUCE(ts_aux_sym_token6, ts_sym_array, 2)
END_STATE();
[44] = {
[ts_aux_sym_token3] = REDUCE(ts_sym_array, 2),
[ts_aux_sym_token4] = REDUCE(ts_sym_array, 2),
},
STATE(44);
SET_LEX_STATE(1);
REDUCE(ts_aux_sym_token3, ts_sym_array, 2)
REDUCE(ts_aux_sym_token4, ts_sym_array, 2)
END_STATE();
[45] = {
[ts_aux_sym_token3] = REDUCE(ts_sym_object, 2),
[ts_aux_sym_token4] = REDUCE(ts_sym_object, 2),
},
STATE(45);
SET_LEX_STATE(1);
REDUCE(ts_aux_sym_token3, ts_sym_object, 2)
REDUCE(ts_aux_sym_token4, ts_sym_object, 2)
END_STATE();
[46] = {
[ts_aux_sym_repeat_helper1] = SHIFT(47),
[ts_aux_sym_token3] = SHIFT(10),
[ts_aux_sym_token4] = REDUCE(ts_aux_sym_repeat_helper1, 0),
},
STATE(46);
SET_LEX_STATE(1);
SHIFT(ts_aux_sym_repeat_helper1, 47)
SHIFT(ts_aux_sym_token3, 10)
REDUCE(ts_aux_sym_token4, ts_aux_sym_repeat_helper1, 0)
END_STATE();
[47] = {
[ts_aux_sym_token4] = SHIFT(48),
},
STATE(47);
SET_LEX_STATE(4);
SHIFT(ts_aux_sym_token4, 48)
END_STATE();
[48] = {
[ts_aux_sym_token3] = REDUCE(ts_sym_object, 4),
[ts_aux_sym_token4] = REDUCE(ts_sym_object, 4),
},
STATE(48);
SET_LEX_STATE(1);
REDUCE(ts_aux_sym_token3, ts_sym_object, 4)
REDUCE(ts_aux_sym_token4, ts_sym_object, 4)
END_STATE();
[49] = {
[ts_aux_sym_repeat_helper1] = SHIFT(50),
[ts_aux_sym_token3] = SHIFT(10),
[ts_aux_sym_token4] = REDUCE(ts_aux_sym_repeat_helper1, 0),
},
STATE(49);
SET_LEX_STATE(1);
SHIFT(ts_aux_sym_repeat_helper1, 50)
SHIFT(ts_aux_sym_token3, 10)
REDUCE(ts_aux_sym_token4, ts_aux_sym_repeat_helper1, 0)
END_STATE();
[50] = {
[ts_aux_sym_token4] = REDUCE(ts_aux_sym_repeat_helper1, 3),
},
STATE(50);
SET_LEX_STATE(4);
REDUCE(ts_aux_sym_token4, ts_aux_sym_repeat_helper1, 3)
END_STATE();
[51] = {
[ts_builtin_sym_end] = REDUCE(ts_sym_object, 2),
},
STATE(51);
SET_LEX_STATE(0);
REDUCE(ts_builtin_sym_end, ts_sym_object, 2)
END_STATE();
[52] = {
[ts_aux_sym_repeat_helper1] = SHIFT(53),
[ts_aux_sym_token3] = SHIFT(10),
[ts_aux_sym_token4] = REDUCE(ts_aux_sym_repeat_helper1, 0),
},
STATE(52);
SET_LEX_STATE(1);
SHIFT(ts_aux_sym_repeat_helper1, 53)
SHIFT(ts_aux_sym_token3, 10)
REDUCE(ts_aux_sym_token4, ts_aux_sym_repeat_helper1, 0)
END_STATE();
[53] = {
[ts_aux_sym_token4] = SHIFT(54),
},
STATE(53);
SET_LEX_STATE(4);
SHIFT(ts_aux_sym_token4, 54)
END_STATE();
[54] = {
[ts_builtin_sym_end] = REDUCE(ts_sym_object, 4),
},
STATE(54);
SET_LEX_STATE(0);
REDUCE(ts_builtin_sym_end, ts_sym_object, 4)
END_STATE();
[55] = {
[ts_sym_array] = SHIFT(22),
[ts_sym_false] = SHIFT(22),
[ts_sym_null] = SHIFT(22),
[ts_sym_number] = SHIFT(22),
[ts_sym_object] = SHIFT(22),
[ts_sym_string] = SHIFT(22),
[ts_sym_true] = SHIFT(22),
[ts_sym_value] = SHIFT(56),
[ts_aux_sym_token1] = SHIFT(29),
[ts_aux_sym_token5] = SHIFT(39),
[ts_aux_sym_token6] = SHIFT(59),
[ts_builtin_sym_error] = SHIFT(56),
},
STATE(55);
SET_LEX_STATE(42);
SHIFT(ts_sym_array, 22)
SHIFT(ts_sym_false, 22)
SHIFT(ts_sym_null, 22)
SHIFT(ts_sym_number, 22)
SHIFT(ts_sym_object, 22)
SHIFT(ts_sym_string, 22)
SHIFT(ts_sym_true, 22)
SHIFT(ts_sym_value, 56)
SHIFT(ts_aux_sym_token1, 29)
SHIFT(ts_aux_sym_token5, 39)
SHIFT(ts_aux_sym_token6, 59)
SHIFT(ts_builtin_sym_error, 56)
END_STATE();
[56] = {
[ts_aux_sym_repeat_helper2] = SHIFT(57),
[ts_aux_sym_token3] = SHIFT(26),
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper2, 0),
},
STATE(56);
SET_LEX_STATE(5);
SHIFT(ts_aux_sym_repeat_helper2, 57)
SHIFT(ts_aux_sym_token3, 26)
REDUCE(ts_aux_sym_token6, ts_aux_sym_repeat_helper2, 0)
END_STATE();
[57] = {
[ts_aux_sym_token6] = SHIFT(58),
},
STATE(57);
SET_LEX_STATE(7);
SHIFT(ts_aux_sym_token6, 58)
END_STATE();
[58] = {
[ts_builtin_sym_end] = REDUCE(ts_sym_array, 4),
},
STATE(58);
SET_LEX_STATE(0);
REDUCE(ts_builtin_sym_end, ts_sym_array, 4)
END_STATE();
STATE(59);
SET_LEX_STATE(0);
REDUCE(ts_builtin_sym_end, ts_sym_array, 2)
END_STATE();
END_TABLE();
}
[59] = {
[ts_builtin_sym_end] = REDUCE(ts_sym_array, 2),
},
};
EXPORT_PARSER(ts_parser_json);

88
include/tree_sitter/parser.h
View file

@ -31,35 +31,11 @@ extern "C" {
#define DEBUG_PARSE(...)
#endif
#define PARSE_TABLE() \
static size_t ts_symbol_count; \
static const state_id * ts_lex_states; \
static const ts_parse_action ** ts_parse_actions; \
static void ts_init_parse_table()
#define LEX_STATES(num_states) \
static state_id ts_lex_states[num_states]
#define START_TABLE(num_states) \
ts_symbol_count = TS_SYMBOL_COUNT; \
static int done = 0; \
if (!done) { \
static const ts_parse_action *parse_actions[num_states]; \
static state_id lex_states[num_states]; \
ts_parse_actions = parse_actions; \
ts_lex_states = lex_states; \
done = 1; \
state_id state;
#define END_TABLE() }
#define END_STATE() }
#define STATE(state_val) \
state = state_val; \
if (1) { \
static ts_parse_action actions_for_state_array[TS_SYMBOL_COUNT + 2]; \
ts_parse_action *actions_for_state = actions_for_state_array + 2; \
parse_actions[state] = actions_for_state;
#define SET_LEX_STATE(lex_state_val) \
lex_states[state] = lex_state_val
#define PARSE_TABLE(num_states, num_symbols) \
static const ts_parse_action ts_parse_actions[num_states][num_symbols]
#define LEX_FN() \
static ts_tree * \
@ -68,37 +44,36 @@ ts_lex(ts_lexer *lexer, state_id lex_state)
#define SYMBOL_NAMES \
static const char *ts_symbol_names[]
#define HIDDEN_SYMBOL_FLAGS \
static const int hidden_symbol_flags[]
#define HIDDEN_SYMBOLS(num_symbols) \
static const int hidden_symbol_flags[num_symbols]
#define EXPORT_PARSER(constructor_name) \
ts_parser constructor_name() { \
ts_init_parse_table(); \
ts_parser result = { \
.parse_fn = ts_parse, \
.symbol_names = ts_symbol_names, \
.data = ts_lr_parser_make(hidden_symbol_flags), \
.data = ts_lr_parser_make(TS_SYMBOL_COUNT, (const ts_parse_action *)ts_parse_actions, ts_lex_states, hidden_symbol_flags), \
.free_fn = NULL \
}; \
return result; \
}
#define SHIFT(on_symbol, to_state_value) \
actions_for_state[on_symbol] = (ts_parse_action) { \
#define SHIFT(to_state_value) \
(ts_parse_action) { \
.type = ts_parse_action_type_shift, \
.data = { .to_state = to_state_value } \
};
}
#define REDUCE(on_symbol, symbol_val, child_count_val) \
actions_for_state[on_symbol] = (ts_parse_action) { \
#define REDUCE(symbol_val, child_count_val) \
(ts_parse_action) { \
.type = ts_parse_action_type_reduce, \
.data = { .symbol = symbol_val, .child_count = child_count_val } \
}; \
}
#define ACCEPT_INPUT(on_symbol) \
actions_for_state[on_symbol] = (ts_parse_action) { \
#define ACCEPT_INPUT() \
(ts_parse_action) { \
.type = ts_parse_action_type_accept, \
};
}
#define START_LEXER() \
ts_lexer_skip_whitespace(lexer); \
@ -241,14 +216,13 @@ typedef struct {
};
} data;
} ts_parse_action;
/*
* Forward declarations
* The file including this header should use these macros to provide definitions.
*/
LEX_FN();
PARSE_TABLE();
/*
@ -260,15 +234,25 @@ typedef struct {
const int *hidden_symbol_flags;
ts_tree *lookahead;
ts_tree *next_lookahead;
const ts_parse_action *parse_table;
const state_id *lex_states;
size_t symbol_count;
} ts_lr_parser;
static ts_lr_parser * ts_lr_parser_make(const int *hidden_symbol_flags) {
static ts_lr_parser * ts_lr_parser_make(size_t symbol_count, const ts_parse_action *parse_table, const state_id *lex_states, const int *hidden_symbol_flags) {
ts_lr_parser *result = malloc(sizeof(ts_lr_parser));
result->lexer = ts_lexer_make();
result->stack = ts_stack_make();
result->symbol_count = symbol_count;
result->parse_table = parse_table;
result->lex_states = lex_states;
result->hidden_symbol_flags = hidden_symbol_flags;
return result;
}
static const ts_parse_action * ts_lr_parser_table_actions(ts_lr_parser *parser, state_id state) {
return parser->parse_table + (state * parser->symbol_count);
}
static size_t ts_lr_parser_breakdown_stack(ts_lr_parser *parser, ts_input_edit *edit) {
ts_stack *stack = &parser->stack;
@ -292,7 +276,7 @@ static size_t ts_lr_parser_breakdown_stack(ts_lr_parser *parser, ts_input_edit *
for (size_t i = 0; i < child_count && position < edit->position; i++) {
ts_tree *child = children[i];
state_id state = ts_stack_top_state(stack);
state_id next_state = ts_parse_actions[state][ts_tree_symbol(child)].data.to_state;
state_id next_state = ts_lr_parser_table_actions(parser, state)[ts_tree_symbol(child)].data.to_state;
ts_stack_push(stack, next_state, child);
ts_tree_retain(child);
position += ts_tree_total_size(child);
@ -330,14 +314,14 @@ static void ts_lr_parser_reduce(ts_lr_parser *parser, ts_symbol symbol, int chil
static ts_symbol * ts_lr_parser_expected_symbols(ts_lr_parser *parser, size_t *count) {
*count = 0;
const ts_parse_action *actions = ts_parse_actions[ts_stack_top_state(&parser->stack)];
for (size_t i = 0; i < ts_symbol_count; i++)
const ts_parse_action *actions = ts_lr_parser_table_actions(parser, ts_stack_top_state(&parser->stack));
for (size_t i = 0; i < parser->symbol_count; i++)
if (actions[i].type != ts_parse_action_type_error)
++(*count);
size_t n = 0;
ts_symbol *result = malloc(*count * sizeof(*result));
for (size_t i = 0; i < ts_symbol_count; i++)
for (size_t i = 0; i < parser->symbol_count; i++)
if (actions[i].type != ts_parse_action_type_error)
result[n++] = i;
@ -367,10 +351,10 @@ static int ts_lr_parser_handle_error(ts_lr_parser *parser) {
*/
for (long i = parser->stack.size - 1; i >= 0; i--) {
state_id stack_state = parser->stack.entries[i].state;
ts_parse_action action_on_error = ts_parse_actions[stack_state][ts_builtin_sym_error];
ts_parse_action action_on_error = ts_lr_parser_table_actions(parser, stack_state)[ts_builtin_sym_error];
if (action_on_error.type == ts_parse_action_type_shift) {
state_id state_after_error = action_on_error.data.to_state;
if (ts_parse_actions[state_after_error][ts_tree_symbol(parser->lookahead)].type != ts_parse_action_type_error) {
if (ts_lr_parser_table_actions(parser, state_after_error)[ts_tree_symbol(parser->lookahead)].type != ts_parse_action_type_error) {
ts_stack_shrink(&parser->stack, i + 1);
ts_stack_push(&parser->stack, state_after_error, error);
return 1;
@ -387,8 +371,8 @@ static const ts_tree * ts_parse(void *data, ts_input input, ts_input_edit *edit)
while (!done) {
state_id state = ts_stack_top_state(&parser->stack);
if (!parser->lookahead)
parser->lookahead = ts_lex(&parser->lexer, ts_lex_states[state]);
ts_parse_action action = ts_parse_actions[state][ts_tree_symbol(parser->lookahead)];
parser->lookahead = ts_lex(&parser->lexer, parser->lex_states[state]);
ts_parse_action action = ts_lr_parser_table_actions(parser, state)[ts_tree_symbol(parser->lookahead)];
switch (action.type) {
case ts_parse_action_type_shift:
ts_lr_parser_shift(parser, action.data.to_state);

4
include/tree_sitter/runtime.h
View file

@ -8,8 +8,8 @@ extern "C" {
#include <stdlib.h>
typedef int ts_symbol;
static const ts_symbol ts_builtin_sym_error = -1;
static const ts_symbol ts_builtin_sym_end = -2;
static const ts_symbol ts_builtin_sym_error = 0;
static const ts_symbol ts_builtin_sym_end = 1;
typedef struct ts_tree ts_tree;
ts_tree * ts_tree_make_leaf(ts_symbol symbol, size_t size, size_t offset);

4
spec/runtime/tree_spec.cc
View file

@ -9,8 +9,8 @@ static ts_tree ** tree_array(vector<ts_tree *> trees) {
START_TEST
enum { cat, dog, pig };
static const char *names[] = { "cat", "dog", "pig" };
enum { cat = 2, dog = 3, pig = 4 };
static const char *names[] = { "error", "end", "cat", "dog", "pig" };
describe("trees", []() {
ts_tree *tree1, *parent1;

108
src/compiler/generate_code/c_code.cc
View file

@ -55,7 +55,22 @@ namespace tree_sitter {
parse_table(parse_table),
lex_table(lex_table)
{}
string code() {
return join({
includes(),
symbol_count(),
symbol_enum(),
rule_names_list(),
hidden_symbols_list(),
lex_function(),
lex_states_list(),
parse_table_array(),
parser_export(),
}, "\n\n") + "\n";
}
private:
string symbol_id(rules::Symbol symbol) {
if (symbol.is_built_in()) {
if (symbol == rules::ERROR)
@ -114,16 +129,14 @@ namespace tree_sitter {
return "!(" + condition_for_character_set(rule.complement()) + ")";
}
string code_for_parse_actions(const rules::Symbol &symbol, const ParseAction &action) {
string sym_id = symbol_id(symbol);
string code_for_parse_action(const ParseAction &action) {
switch (action.type) {
case ParseActionTypeAccept:
return "ACCEPT_INPUT(" + sym_id + ")";
return "ACCEPT_INPUT()";
case ParseActionTypeShift:
return "SHIFT(" + sym_id + ", " + to_string(action.state_index) + ")";
return "SHIFT(" + to_string(action.state_index) + ")";
case ParseActionTypeReduce:
return "REDUCE(" +
sym_id + ", " +
symbol_id(action.symbol) + ", " +
to_string(action.child_flags.size()) + ")";
default:
@ -131,18 +144,6 @@ namespace tree_sitter {
}
}
string parse_error_call(const set<rules::Symbol> &expected_inputs) {
string result = "PARSE_ERROR(" + to_string(expected_inputs.size()) + ", EXPECT({";
bool started = false;
for (auto &symbol : expected_inputs) {
if (started) result += ", ";
started = true;
result += symbol_id(symbol);
}
result += "}));";
return result;
}
string code_for_lex_actions(const LexAction &action,
const set<rules::CharacterSet> &expected_inputs) {
switch (action.type) {
@ -181,26 +182,30 @@ namespace tree_sitter {
string symbol_enum() {
string result = "enum {\n";
size_t index = 2;
for (auto symbol : parse_table.symbols)
if (!symbol.is_built_in())
result += indent(symbol_id(symbol)) + ",\n";
result += indent(symbol_id(symbol)) + " = " + to_string(index++) + ",\n";
return result + "};";
}
string rule_names_list() {
string result = "SYMBOL_NAMES = {\n";
result += indent(string("\"") + "error") + "\",\n";
result += indent(string("\"") + "end") + "\",\n";
for (auto symbol : parse_table.symbols)
if (!symbol.is_built_in())
result += indent(string("\"") + symbol.name) + "\",\n";
return result + "};";
}
string hidden_symbol_flags() {
string result = "HIDDEN_SYMBOL_FLAGS = {\n";
string hidden_symbols_list() {
string result = "HIDDEN_SYMBOLS(" + to_string(parse_table.symbols.size()) + ") = {";
for (auto &symbol : parse_table.symbols)
if (!symbol.is_built_in())
result += indent(symbol.is_hidden() ? "1" : "0") + ",\n";
return result + "};";
if (symbol.is_hidden())
result += indent("\n[" + symbol_id(symbol) + "] = 1,");
return result + "\n};";
}
string includes() {
@ -224,49 +229,34 @@ namespace tree_sitter {
return result;
}
string parse_table_row_for_state(const ParseState &state) {
string result("SET_LEX_STATE(" + to_string(state.lex_state_id) + ");");
for (auto &pair : state.actions) {
result += "\n" + code_for_parse_actions(pair.first, pair.second);
}
return result;
}
string parse_table_function() {
string lex_states_list() {
size_t state_id = 0;
return join({
"PARSE_TABLE() {",
indent(join({
"START_TABLE(" + to_string(parse_table.states.size()) + ")",
join(map_to_string<ParseState>(parse_table.states, [&](ParseState state) -> string {
return join({
"STATE(" + to_string(state_id++) + ");",
parse_table_row_for_state(state),
"END_STATE();"
});
}), "\n\n"),
"END_TABLE();",
}, "\n\n")),
"}"
"LEX_STATES(" + to_string(parse_table.states.size()) + ") = {",
indent(join(map_to_string<ParseState>(parse_table.states, [&](ParseState state) {
return "[" + to_string(state_id++) + "] = " + to_string(state.lex_state_id) + ",";
}))),
"};"
});
}
string parse_table_array() {
size_t state_id = 0;
return join({
"PARSE_TABLE(" + to_string(parse_table.states.size()) + ", " + to_string(parse_table.symbols.size()) + ") = {",
indent(join(map_to_string<ParseState>(parse_table.states, [&](ParseState state) {
string result = "[" + to_string(state_id++) + "] = {";
for (auto &pair : state.actions)
result += indent("\n[" + symbol_id(pair.first) + "] = " + code_for_parse_action(pair.second) + ",");
return result + "\n},";
}), "\n\n")),
"};"
});
}
string parser_export() {
return "EXPORT_PARSER(ts_parser_" + name + ");";
}
string code() {
return join({
includes(),
symbol_count(),
symbol_enum(),
rule_names_list(),
hidden_symbol_flags(),
lex_function(),
parse_table_function(),
parser_export(),
}, "\n\n") + "\n";
}
};
string c_code(string name, const ParseTable &parse_table, const LexTable &lex_table) {