Allow room in parse table for error and EOF entries
This commit is contained in:
Max Brunsfeld
parent
67b33a615b
commit
8e7f59db1c
5 changed files with 140 additions and 137 deletions
|
|
@ -1,5 +1,7 @@
|
|||
#include "tree_sitter/parser.h"
|
||||
|
||||
#define TS_SYMBOL_COUNT 11
|
||||
|
||||
enum {
|
||||
ts_sym_expression,
|
||||
ts_sym_factor,
|
||||
|
|
@ -116,7 +118,7 @@ LEX_FN() {
|
|||
PARSE_TABLE() {
|
||||
START_TABLE(52)
|
||||
|
||||
STATE(0, 11);
|
||||
STATE(0);
|
||||
SET_LEX_STATE(8);
|
||||
SHIFT(ts_sym_expression, 1)
|
||||
SHIFT(ts_sym_factor, 2)
|
||||
|
|
@ -126,19 +128,19 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_aux_sym_token1, 49)
|
||||
END_STATE();
|
||||
|
||||
STATE(1, 11);
|
||||
STATE(1);
|
||||
SET_LEX_STATE(0);
|
||||
ACCEPT_INPUT(ts_builtin_sym_end)
|
||||
END_STATE();
|
||||
|
||||
STATE(2, 11);
|
||||
STATE(2);
|
||||
SET_LEX_STATE(13);
|
||||
REDUCE(ts_sym_plus, ts_sym_term, 1, COLLAPSE({0}))
|
||||
SHIFT(ts_sym_times, 3)
|
||||
REDUCE(ts_builtin_sym_end, ts_sym_term, 1, COLLAPSE({0}))
|
||||
END_STATE();
|
||||
|
||||
STATE(3, 11);
|
||||
STATE(3);
|
||||
SET_LEX_STATE(8);
|
||||
SHIFT(ts_sym_factor, 4)
|
||||
SHIFT(ts_sym_number, 5)
|
||||
|
|
@ -146,19 +148,19 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_aux_sym_token1, 6)
|
||||
END_STATE();
|
||||
|
||||
STATE(4, 11);
|
||||
STATE(4);
|
||||
SET_LEX_STATE(1);
|
||||
REDUCE(ts_sym_plus, ts_sym_term, 3, COLLAPSE({0, 0, 0}))
|
||||
REDUCE(ts_builtin_sym_end, ts_sym_term, 3, COLLAPSE({0, 0, 0}))
|
||||
END_STATE();
|
||||
|
||||
STATE(5, 11);
|
||||
STATE(5);
|
||||
SET_LEX_STATE(1);
|
||||
REDUCE(ts_sym_plus, ts_sym_factor, 1, COLLAPSE({0}))
|
||||
REDUCE(ts_builtin_sym_end, ts_sym_factor, 1, COLLAPSE({0}))
|
||||
END_STATE();
|
||||
|
||||
STATE(6, 11);
|
||||
STATE(6);
|
||||
SET_LEX_STATE(8);
|
||||
SHIFT(ts_sym_expression, 7)
|
||||
SHIFT(ts_sym_factor, 9)
|
||||
|
|
@ -169,25 +171,25 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_builtin_sym_error, 7)
|
||||
END_STATE();
|
||||
|
||||
STATE(7, 11);
|
||||
STATE(7);
|
||||
SET_LEX_STATE(3);
|
||||
SHIFT(ts_aux_sym_token2, 8)
|
||||
END_STATE();
|
||||
|
||||
STATE(8, 11);
|
||||
STATE(8);
|
||||
SET_LEX_STATE(1);
|
||||
REDUCE(ts_sym_plus, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
|
||||
REDUCE(ts_builtin_sym_end, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(9, 11);
|
||||
STATE(9);
|
||||
SET_LEX_STATE(6);
|
||||
REDUCE(ts_sym_plus, ts_sym_term, 1, COLLAPSE({0}))
|
||||
SHIFT(ts_sym_times, 10)
|
||||
REDUCE(ts_aux_sym_token2, ts_sym_term, 1, COLLAPSE({0}))
|
||||
END_STATE();
|
||||
|
||||
STATE(10, 11);
|
||||
STATE(10);
|
||||
SET_LEX_STATE(8);
|
||||
SHIFT(ts_sym_factor, 11)
|
||||
SHIFT(ts_sym_number, 12)
|
||||
|
|
@ -195,19 +197,19 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_aux_sym_token1, 13)
|
||||
END_STATE();
|
||||
|
||||
STATE(11, 11);
|
||||
STATE(11);
|
||||
SET_LEX_STATE(5);
|
||||
REDUCE(ts_sym_plus, ts_sym_term, 3, COLLAPSE({0, 0, 0}))
|
||||
REDUCE(ts_aux_sym_token2, ts_sym_term, 3, COLLAPSE({0, 0, 0}))
|
||||
END_STATE();
|
||||
|
||||
STATE(12, 11);
|
||||
STATE(12);
|
||||
SET_LEX_STATE(5);
|
||||
REDUCE(ts_sym_plus, ts_sym_factor, 1, COLLAPSE({0}))
|
||||
REDUCE(ts_aux_sym_token2, ts_sym_factor, 1, COLLAPSE({0}))
|
||||
END_STATE();
|
||||
|
||||
STATE(13, 11);
|
||||
STATE(13);
|
||||
SET_LEX_STATE(8);
|
||||
SHIFT(ts_sym_expression, 14)
|
||||
SHIFT(ts_sym_factor, 9)
|
||||
|
|
@ -218,31 +220,31 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_builtin_sym_error, 14)
|
||||
END_STATE();
|
||||
|
||||
STATE(14, 11);
|
||||
STATE(14);
|
||||
SET_LEX_STATE(3);
|
||||
SHIFT(ts_aux_sym_token2, 15)
|
||||
END_STATE();
|
||||
|
||||
STATE(15, 11);
|
||||
STATE(15);
|
||||
SET_LEX_STATE(5);
|
||||
REDUCE(ts_sym_plus, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
|
||||
REDUCE(ts_aux_sym_token2, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(16, 11);
|
||||
STATE(16);
|
||||
SET_LEX_STATE(6);
|
||||
REDUCE(ts_sym_plus, ts_sym_factor, 1, COLLAPSE({0}))
|
||||
REDUCE(ts_sym_times, ts_sym_factor, 1, COLLAPSE({0}))
|
||||
REDUCE(ts_aux_sym_token2, ts_sym_factor, 1, COLLAPSE({0}))
|
||||
END_STATE();
|
||||
|
||||
STATE(17, 11);
|
||||
STATE(17);
|
||||
SET_LEX_STATE(5);
|
||||
SHIFT(ts_sym_plus, 18)
|
||||
REDUCE(ts_aux_sym_token2, ts_sym_expression, 1, COLLAPSE({0}))
|
||||
END_STATE();
|
||||
|
||||
STATE(18, 11);
|
||||
STATE(18);
|
||||
SET_LEX_STATE(8);
|
||||
SHIFT(ts_sym_factor, 19)
|
||||
SHIFT(ts_sym_number, 29)
|
||||
|
|
@ -251,13 +253,13 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_aux_sym_token1, 31)
|
||||
END_STATE();
|
||||
|
||||
STATE(19, 11);
|
||||
STATE(19);
|
||||
SET_LEX_STATE(12);
|
||||
SHIFT(ts_sym_times, 20)
|
||||
REDUCE(ts_aux_sym_token2, ts_sym_term, 1, COLLAPSE({0}))
|
||||
END_STATE();
|
||||
|
||||
STATE(20, 11);
|
||||
STATE(20);
|
||||
SET_LEX_STATE(8);
|
||||
SHIFT(ts_sym_factor, 21)
|
||||
SHIFT(ts_sym_number, 22)
|
||||
|
|
@ -265,17 +267,17 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_aux_sym_token1, 23)
|
||||
END_STATE();
|
||||
|
||||
STATE(21, 11);
|
||||
STATE(21);
|
||||
SET_LEX_STATE(3);
|
||||
REDUCE(ts_aux_sym_token2, ts_sym_term, 3, COLLAPSE({0, 0, 0}))
|
||||
END_STATE();
|
||||
|
||||
STATE(22, 11);
|
||||
STATE(22);
|
||||
SET_LEX_STATE(3);
|
||||
REDUCE(ts_aux_sym_token2, ts_sym_factor, 1, COLLAPSE({0}))
|
||||
END_STATE();
|
||||
|
||||
STATE(23, 11);
|
||||
STATE(23);
|
||||
SET_LEX_STATE(8);
|
||||
SHIFT(ts_sym_expression, 24)
|
||||
SHIFT(ts_sym_factor, 9)
|
||||
|
|
@ -286,17 +288,17 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_builtin_sym_error, 24)
|
||||
END_STATE();
|
||||
|
||||
STATE(24, 11);
|
||||
STATE(24);
|
||||
SET_LEX_STATE(3);
|
||||
SHIFT(ts_aux_sym_token2, 25)
|
||||
END_STATE();
|
||||
|
||||
STATE(25, 11);
|
||||
STATE(25);
|
||||
SET_LEX_STATE(3);
|
||||
REDUCE(ts_aux_sym_token2, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(26, 11);
|
||||
STATE(26);
|
||||
SET_LEX_STATE(8);
|
||||
SHIFT(ts_sym_expression, 27)
|
||||
SHIFT(ts_sym_factor, 9)
|
||||
|
|
@ -307,30 +309,30 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_builtin_sym_error, 27)
|
||||
END_STATE();
|
||||
|
||||
STATE(27, 11);
|
||||
STATE(27);
|
||||
SET_LEX_STATE(3);
|
||||
SHIFT(ts_aux_sym_token2, 28)
|
||||
END_STATE();
|
||||
|
||||
STATE(28, 11);
|
||||
STATE(28);
|
||||
SET_LEX_STATE(6);
|
||||
REDUCE(ts_sym_plus, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
|
||||
REDUCE(ts_sym_times, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
|
||||
REDUCE(ts_aux_sym_token2, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(29, 11);
|
||||
STATE(29);
|
||||
SET_LEX_STATE(12);
|
||||
REDUCE(ts_sym_times, ts_sym_factor, 1, COLLAPSE({0}))
|
||||
REDUCE(ts_aux_sym_token2, ts_sym_factor, 1, COLLAPSE({0}))
|
||||
END_STATE();
|
||||
|
||||
STATE(30, 11);
|
||||
STATE(30);
|
||||
SET_LEX_STATE(3);
|
||||
REDUCE(ts_aux_sym_token2, ts_sym_expression, 3, COLLAPSE({0, 0, 0}))
|
||||
END_STATE();
|
||||
|
||||
STATE(31, 11);
|
||||
STATE(31);
|
||||
SET_LEX_STATE(8);
|
||||
SHIFT(ts_sym_expression, 32)
|
||||
SHIFT(ts_sym_factor, 9)
|
||||
|
|
@ -341,31 +343,31 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_builtin_sym_error, 32)
|
||||
END_STATE();
|
||||
|
||||
STATE(32, 11);
|
||||
STATE(32);
|
||||
SET_LEX_STATE(3);
|
||||
SHIFT(ts_aux_sym_token2, 33)
|
||||
END_STATE();
|
||||
|
||||
STATE(33, 11);
|
||||
STATE(33);
|
||||
SET_LEX_STATE(12);
|
||||
REDUCE(ts_sym_times, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
|
||||
REDUCE(ts_aux_sym_token2, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(34, 11);
|
||||
STATE(34);
|
||||
SET_LEX_STATE(13);
|
||||
REDUCE(ts_sym_plus, ts_sym_factor, 1, COLLAPSE({0}))
|
||||
REDUCE(ts_sym_times, ts_sym_factor, 1, COLLAPSE({0}))
|
||||
REDUCE(ts_builtin_sym_end, ts_sym_factor, 1, COLLAPSE({0}))
|
||||
END_STATE();
|
||||
|
||||
STATE(35, 11);
|
||||
STATE(35);
|
||||
SET_LEX_STATE(1);
|
||||
SHIFT(ts_sym_plus, 36)
|
||||
REDUCE(ts_builtin_sym_end, ts_sym_expression, 1, COLLAPSE({0}))
|
||||
END_STATE();
|
||||
|
||||
STATE(36, 11);
|
||||
STATE(36);
|
||||
SET_LEX_STATE(8);
|
||||
SHIFT(ts_sym_factor, 37)
|
||||
SHIFT(ts_sym_number, 44)
|
||||
|
|
@ -374,13 +376,13 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_aux_sym_token1, 46)
|
||||
END_STATE();
|
||||
|
||||
STATE(37, 11);
|
||||
STATE(37);
|
||||
SET_LEX_STATE(14);
|
||||
SHIFT(ts_sym_times, 38)
|
||||
REDUCE(ts_builtin_sym_end, ts_sym_term, 1, COLLAPSE({0}))
|
||||
END_STATE();
|
||||
|
||||
STATE(38, 11);
|
||||
STATE(38);
|
||||
SET_LEX_STATE(8);
|
||||
SHIFT(ts_sym_factor, 39)
|
||||
SHIFT(ts_sym_number, 40)
|
||||
|
|
@ -388,17 +390,17 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_aux_sym_token1, 41)
|
||||
END_STATE();
|
||||
|
||||
STATE(39, 11);
|
||||
STATE(39);
|
||||
SET_LEX_STATE(0);
|
||||
REDUCE(ts_builtin_sym_end, ts_sym_term, 3, COLLAPSE({0, 0, 0}))
|
||||
END_STATE();
|
||||
|
||||
STATE(40, 11);
|
||||
STATE(40);
|
||||
SET_LEX_STATE(0);
|
||||
REDUCE(ts_builtin_sym_end, ts_sym_factor, 1, COLLAPSE({0}))
|
||||
END_STATE();
|
||||
|
||||
STATE(41, 11);
|
||||
STATE(41);
|
||||
SET_LEX_STATE(8);
|
||||
SHIFT(ts_sym_expression, 42)
|
||||
SHIFT(ts_sym_factor, 9)
|
||||
|
|
@ -409,28 +411,28 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_builtin_sym_error, 42)
|
||||
END_STATE();
|
||||
|
||||
STATE(42, 11);
|
||||
STATE(42);
|
||||
SET_LEX_STATE(3);
|
||||
SHIFT(ts_aux_sym_token2, 43)
|
||||
END_STATE();
|
||||
|
||||
STATE(43, 11);
|
||||
STATE(43);
|
||||
SET_LEX_STATE(0);
|
||||
REDUCE(ts_builtin_sym_end, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(44, 11);
|
||||
STATE(44);
|
||||
SET_LEX_STATE(14);
|
||||
REDUCE(ts_sym_times, ts_sym_factor, 1, COLLAPSE({0}))
|
||||
REDUCE(ts_builtin_sym_end, ts_sym_factor, 1, COLLAPSE({0}))
|
||||
END_STATE();
|
||||
|
||||
STATE(45, 11);
|
||||
STATE(45);
|
||||
SET_LEX_STATE(0);
|
||||
REDUCE(ts_builtin_sym_end, ts_sym_expression, 3, COLLAPSE({0, 0, 0}))
|
||||
END_STATE();
|
||||
|
||||
STATE(46, 11);
|
||||
STATE(46);
|
||||
SET_LEX_STATE(8);
|
||||
SHIFT(ts_sym_expression, 47)
|
||||
SHIFT(ts_sym_factor, 9)
|
||||
|
|
@ -441,18 +443,18 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_builtin_sym_error, 47)
|
||||
END_STATE();
|
||||
|
||||
STATE(47, 11);
|
||||
STATE(47);
|
||||
SET_LEX_STATE(3);
|
||||
SHIFT(ts_aux_sym_token2, 48)
|
||||
END_STATE();
|
||||
|
||||
STATE(48, 11);
|
||||
STATE(48);
|
||||
SET_LEX_STATE(14);
|
||||
REDUCE(ts_sym_times, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
|
||||
REDUCE(ts_builtin_sym_end, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(49, 11);
|
||||
STATE(49);
|
||||
SET_LEX_STATE(8);
|
||||
SHIFT(ts_sym_expression, 50)
|
||||
SHIFT(ts_sym_factor, 9)
|
||||
|
|
@ -463,12 +465,12 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_builtin_sym_error, 50)
|
||||
END_STATE();
|
||||
|
||||
STATE(50, 11);
|
||||
STATE(50);
|
||||
SET_LEX_STATE(3);
|
||||
SHIFT(ts_aux_sym_token2, 51)
|
||||
END_STATE();
|
||||
|
||||
STATE(51, 11);
|
||||
STATE(51);
|
||||
SET_LEX_STATE(13);
|
||||
REDUCE(ts_sym_plus, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
|
||||
REDUCE(ts_sym_times, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
|
||||
|
|
|
|||
|
|
@ -1,5 +1,7 @@
|
|||
#include "tree_sitter/parser.h"
|
||||
|
||||
#define TS_SYMBOL_COUNT 15
|
||||
|
||||
enum {
|
||||
ts_sym_array,
|
||||
ts_sym_number,
|
||||
|
|
@ -199,7 +201,7 @@ LEX_FN() {
|
|||
PARSE_TABLE() {
|
||||
START_TABLE(60)
|
||||
|
||||
STATE(0, 15);
|
||||
STATE(0);
|
||||
SET_LEX_STATE(8);
|
||||
SHIFT(ts_sym_array, 1)
|
||||
SHIFT(ts_sym_number, 1)
|
||||
|
|
@ -210,29 +212,29 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_sym_left_bracket, 55)
|
||||
END_STATE();
|
||||
|
||||
STATE(1, 15);
|
||||
STATE(1);
|
||||
SET_LEX_STATE(0);
|
||||
REDUCE(ts_builtin_sym_end, ts_sym_value, 1, COLLAPSE({0}))
|
||||
END_STATE();
|
||||
|
||||
STATE(2, 15);
|
||||
STATE(2);
|
||||
SET_LEX_STATE(0);
|
||||
ACCEPT_INPUT(ts_builtin_sym_end)
|
||||
END_STATE();
|
||||
|
||||
STATE(3, 15);
|
||||
STATE(3);
|
||||
SET_LEX_STATE(20);
|
||||
SHIFT(ts_sym_string, 4)
|
||||
SHIFT(ts_sym_right_brace, 51)
|
||||
SHIFT(ts_builtin_sym_error, 52)
|
||||
END_STATE();
|
||||
|
||||
STATE(4, 15);
|
||||
STATE(4);
|
||||
SET_LEX_STATE(18);
|
||||
SHIFT(ts_sym_colon, 5)
|
||||
END_STATE();
|
||||
|
||||
STATE(5, 15);
|
||||
STATE(5);
|
||||
SET_LEX_STATE(8);
|
||||
SHIFT(ts_sym_array, 6)
|
||||
SHIFT(ts_sym_number, 6)
|
||||
|
|
@ -243,31 +245,31 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_sym_left_bracket, 19)
|
||||
END_STATE();
|
||||
|
||||
STATE(6, 15);
|
||||
STATE(6);
|
||||
SET_LEX_STATE(1);
|
||||
REDUCE(ts_sym_comma, ts_sym_value, 1, COLLAPSE({0}))
|
||||
REDUCE(ts_sym_right_brace, ts_sym_value, 1, COLLAPSE({0}))
|
||||
END_STATE();
|
||||
|
||||
STATE(7, 15);
|
||||
STATE(7);
|
||||
SET_LEX_STATE(1);
|
||||
SHIFT(ts_sym_comma, 8)
|
||||
REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({}))
|
||||
SHIFT(ts_aux_sym_repeat_helper2, 49)
|
||||
END_STATE();
|
||||
|
||||
STATE(8, 15);
|
||||
STATE(8);
|
||||
SET_LEX_STATE(22);
|
||||
SHIFT(ts_sym_string, 9)
|
||||
SHIFT(ts_builtin_sym_error, 47)
|
||||
END_STATE();
|
||||
|
||||
STATE(9, 15);
|
||||
STATE(9);
|
||||
SET_LEX_STATE(18);
|
||||
SHIFT(ts_sym_colon, 10)
|
||||
END_STATE();
|
||||
|
||||
STATE(10, 15);
|
||||
STATE(10);
|
||||
SET_LEX_STATE(8);
|
||||
SHIFT(ts_sym_array, 6)
|
||||
SHIFT(ts_sym_number, 6)
|
||||
|
|
@ -278,31 +280,31 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_sym_left_bracket, 19)
|
||||
END_STATE();
|
||||
|
||||
STATE(11, 15);
|
||||
STATE(11);
|
||||
SET_LEX_STATE(1);
|
||||
SHIFT(ts_sym_comma, 8)
|
||||
REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({}))
|
||||
SHIFT(ts_aux_sym_repeat_helper2, 12)
|
||||
END_STATE();
|
||||
|
||||
STATE(12, 15);
|
||||
STATE(12);
|
||||
SET_LEX_STATE(4);
|
||||
REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 5, COLLAPSE({1, 0, 1, 0, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(13, 15);
|
||||
STATE(13);
|
||||
SET_LEX_STATE(20);
|
||||
SHIFT(ts_sym_string, 14)
|
||||
SHIFT(ts_sym_right_brace, 43)
|
||||
SHIFT(ts_builtin_sym_error, 44)
|
||||
END_STATE();
|
||||
|
||||
STATE(14, 15);
|
||||
STATE(14);
|
||||
SET_LEX_STATE(18);
|
||||
SHIFT(ts_sym_colon, 15)
|
||||
END_STATE();
|
||||
|
||||
STATE(15, 15);
|
||||
STATE(15);
|
||||
SET_LEX_STATE(8);
|
||||
SHIFT(ts_sym_array, 6)
|
||||
SHIFT(ts_sym_number, 6)
|
||||
|
|
@ -313,25 +315,25 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_sym_left_bracket, 19)
|
||||
END_STATE();
|
||||
|
||||
STATE(16, 15);
|
||||
STATE(16);
|
||||
SET_LEX_STATE(1);
|
||||
SHIFT(ts_sym_comma, 8)
|
||||
REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({}))
|
||||
SHIFT(ts_aux_sym_repeat_helper2, 17)
|
||||
END_STATE();
|
||||
|
||||
STATE(17, 15);
|
||||
STATE(17);
|
||||
SET_LEX_STATE(4);
|
||||
SHIFT(ts_sym_right_brace, 18)
|
||||
END_STATE();
|
||||
|
||||
STATE(18, 15);
|
||||
STATE(18);
|
||||
SET_LEX_STATE(1);
|
||||
REDUCE(ts_sym_comma, ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}))
|
||||
REDUCE(ts_sym_right_brace, ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(19, 15);
|
||||
STATE(19);
|
||||
SET_LEX_STATE(21);
|
||||
SHIFT(ts_sym_array, 20)
|
||||
SHIFT(ts_sym_number, 20)
|
||||
|
|
@ -344,20 +346,20 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_builtin_sym_error, 21)
|
||||
END_STATE();
|
||||
|
||||
STATE(20, 15);
|
||||
STATE(20);
|
||||
SET_LEX_STATE(5);
|
||||
REDUCE(ts_sym_comma, ts_sym_value, 1, COLLAPSE({0}))
|
||||
REDUCE(ts_sym_right_bracket, ts_sym_value, 1, COLLAPSE({0}))
|
||||
END_STATE();
|
||||
|
||||
STATE(21, 15);
|
||||
STATE(21);
|
||||
SET_LEX_STATE(5);
|
||||
SHIFT(ts_sym_comma, 22)
|
||||
REDUCE(ts_sym_right_bracket, ts_aux_sym_repeat_helper1, 0, COLLAPSE({}))
|
||||
SHIFT(ts_aux_sym_repeat_helper1, 40)
|
||||
END_STATE();
|
||||
|
||||
STATE(22, 15);
|
||||
STATE(22);
|
||||
SET_LEX_STATE(8);
|
||||
SHIFT(ts_sym_array, 20)
|
||||
SHIFT(ts_sym_number, 20)
|
||||
|
|
@ -369,31 +371,31 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_builtin_sym_error, 23)
|
||||
END_STATE();
|
||||
|
||||
STATE(23, 15);
|
||||
STATE(23);
|
||||
SET_LEX_STATE(5);
|
||||
SHIFT(ts_sym_comma, 22)
|
||||
REDUCE(ts_sym_right_bracket, ts_aux_sym_repeat_helper1, 0, COLLAPSE({}))
|
||||
SHIFT(ts_aux_sym_repeat_helper1, 24)
|
||||
END_STATE();
|
||||
|
||||
STATE(24, 15);
|
||||
STATE(24);
|
||||
SET_LEX_STATE(7);
|
||||
REDUCE(ts_sym_right_bracket, ts_aux_sym_repeat_helper1, 3, COLLAPSE({1, 0, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(25, 15);
|
||||
STATE(25);
|
||||
SET_LEX_STATE(20);
|
||||
SHIFT(ts_sym_string, 26)
|
||||
SHIFT(ts_sym_right_brace, 31)
|
||||
SHIFT(ts_builtin_sym_error, 32)
|
||||
END_STATE();
|
||||
|
||||
STATE(26, 15);
|
||||
STATE(26);
|
||||
SET_LEX_STATE(18);
|
||||
SHIFT(ts_sym_colon, 27)
|
||||
END_STATE();
|
||||
|
||||
STATE(27, 15);
|
||||
STATE(27);
|
||||
SET_LEX_STATE(8);
|
||||
SHIFT(ts_sym_array, 6)
|
||||
SHIFT(ts_sym_number, 6)
|
||||
|
|
@ -404,49 +406,49 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_sym_left_bracket, 19)
|
||||
END_STATE();
|
||||
|
||||
STATE(28, 15);
|
||||
STATE(28);
|
||||
SET_LEX_STATE(1);
|
||||
SHIFT(ts_sym_comma, 8)
|
||||
REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({}))
|
||||
SHIFT(ts_aux_sym_repeat_helper2, 29)
|
||||
END_STATE();
|
||||
|
||||
STATE(29, 15);
|
||||
STATE(29);
|
||||
SET_LEX_STATE(4);
|
||||
SHIFT(ts_sym_right_brace, 30)
|
||||
END_STATE();
|
||||
|
||||
STATE(30, 15);
|
||||
STATE(30);
|
||||
SET_LEX_STATE(5);
|
||||
REDUCE(ts_sym_comma, ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}))
|
||||
REDUCE(ts_sym_right_bracket, ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(31, 15);
|
||||
STATE(31);
|
||||
SET_LEX_STATE(5);
|
||||
REDUCE(ts_sym_comma, ts_sym_object, 2, COLLAPSE({1, 1}))
|
||||
REDUCE(ts_sym_right_bracket, ts_sym_object, 2, COLLAPSE({1, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(32, 15);
|
||||
STATE(32);
|
||||
SET_LEX_STATE(1);
|
||||
SHIFT(ts_sym_comma, 8)
|
||||
REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({}))
|
||||
SHIFT(ts_aux_sym_repeat_helper2, 33)
|
||||
END_STATE();
|
||||
|
||||
STATE(33, 15);
|
||||
STATE(33);
|
||||
SET_LEX_STATE(4);
|
||||
SHIFT(ts_sym_right_brace, 34)
|
||||
END_STATE();
|
||||
|
||||
STATE(34, 15);
|
||||
STATE(34);
|
||||
SET_LEX_STATE(5);
|
||||
REDUCE(ts_sym_comma, ts_sym_object, 4, COLLAPSE({1, 0, 1, 1}))
|
||||
REDUCE(ts_sym_right_bracket, ts_sym_object, 4, COLLAPSE({1, 0, 1, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(35, 15);
|
||||
STATE(35);
|
||||
SET_LEX_STATE(21);
|
||||
SHIFT(ts_sym_array, 20)
|
||||
SHIFT(ts_sym_number, 20)
|
||||
|
|
@ -459,116 +461,116 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_builtin_sym_error, 36)
|
||||
END_STATE();
|
||||
|
||||
STATE(36, 15);
|
||||
STATE(36);
|
||||
SET_LEX_STATE(5);
|
||||
SHIFT(ts_sym_comma, 22)
|
||||
REDUCE(ts_sym_right_bracket, ts_aux_sym_repeat_helper1, 0, COLLAPSE({}))
|
||||
SHIFT(ts_aux_sym_repeat_helper1, 37)
|
||||
END_STATE();
|
||||
|
||||
STATE(37, 15);
|
||||
STATE(37);
|
||||
SET_LEX_STATE(7);
|
||||
SHIFT(ts_sym_right_bracket, 38)
|
||||
END_STATE();
|
||||
|
||||
STATE(38, 15);
|
||||
STATE(38);
|
||||
SET_LEX_STATE(5);
|
||||
REDUCE(ts_sym_comma, ts_sym_array, 4, COLLAPSE({1, 0, 1, 1}))
|
||||
REDUCE(ts_sym_right_bracket, ts_sym_array, 4, COLLAPSE({1, 0, 1, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(39, 15);
|
||||
STATE(39);
|
||||
SET_LEX_STATE(5);
|
||||
REDUCE(ts_sym_comma, ts_sym_array, 2, COLLAPSE({1, 1}))
|
||||
REDUCE(ts_sym_right_bracket, ts_sym_array, 2, COLLAPSE({1, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(40, 15);
|
||||
STATE(40);
|
||||
SET_LEX_STATE(7);
|
||||
SHIFT(ts_sym_right_bracket, 41)
|
||||
END_STATE();
|
||||
|
||||
STATE(41, 15);
|
||||
STATE(41);
|
||||
SET_LEX_STATE(1);
|
||||
REDUCE(ts_sym_comma, ts_sym_array, 4, COLLAPSE({1, 0, 1, 1}))
|
||||
REDUCE(ts_sym_right_brace, ts_sym_array, 4, COLLAPSE({1, 0, 1, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(42, 15);
|
||||
STATE(42);
|
||||
SET_LEX_STATE(1);
|
||||
REDUCE(ts_sym_comma, ts_sym_array, 2, COLLAPSE({1, 1}))
|
||||
REDUCE(ts_sym_right_brace, ts_sym_array, 2, COLLAPSE({1, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(43, 15);
|
||||
STATE(43);
|
||||
SET_LEX_STATE(1);
|
||||
REDUCE(ts_sym_comma, ts_sym_object, 2, COLLAPSE({1, 1}))
|
||||
REDUCE(ts_sym_right_brace, ts_sym_object, 2, COLLAPSE({1, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(44, 15);
|
||||
STATE(44);
|
||||
SET_LEX_STATE(1);
|
||||
SHIFT(ts_sym_comma, 8)
|
||||
REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({}))
|
||||
SHIFT(ts_aux_sym_repeat_helper2, 45)
|
||||
END_STATE();
|
||||
|
||||
STATE(45, 15);
|
||||
STATE(45);
|
||||
SET_LEX_STATE(4);
|
||||
SHIFT(ts_sym_right_brace, 46)
|
||||
END_STATE();
|
||||
|
||||
STATE(46, 15);
|
||||
STATE(46);
|
||||
SET_LEX_STATE(1);
|
||||
REDUCE(ts_sym_comma, ts_sym_object, 4, COLLAPSE({1, 0, 1, 1}))
|
||||
REDUCE(ts_sym_right_brace, ts_sym_object, 4, COLLAPSE({1, 0, 1, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(47, 15);
|
||||
STATE(47);
|
||||
SET_LEX_STATE(1);
|
||||
SHIFT(ts_sym_comma, 8)
|
||||
REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({}))
|
||||
SHIFT(ts_aux_sym_repeat_helper2, 48)
|
||||
END_STATE();
|
||||
|
||||
STATE(48, 15);
|
||||
STATE(48);
|
||||
SET_LEX_STATE(4);
|
||||
REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 3, COLLAPSE({1, 0, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(49, 15);
|
||||
STATE(49);
|
||||
SET_LEX_STATE(4);
|
||||
SHIFT(ts_sym_right_brace, 50)
|
||||
END_STATE();
|
||||
|
||||
STATE(50, 15);
|
||||
STATE(50);
|
||||
SET_LEX_STATE(0);
|
||||
REDUCE(ts_builtin_sym_end, ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(51, 15);
|
||||
STATE(51);
|
||||
SET_LEX_STATE(0);
|
||||
REDUCE(ts_builtin_sym_end, ts_sym_object, 2, COLLAPSE({1, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(52, 15);
|
||||
STATE(52);
|
||||
SET_LEX_STATE(1);
|
||||
SHIFT(ts_sym_comma, 8)
|
||||
REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({}))
|
||||
SHIFT(ts_aux_sym_repeat_helper2, 53)
|
||||
END_STATE();
|
||||
|
||||
STATE(53, 15);
|
||||
STATE(53);
|
||||
SET_LEX_STATE(4);
|
||||
SHIFT(ts_sym_right_brace, 54)
|
||||
END_STATE();
|
||||
|
||||
STATE(54, 15);
|
||||
STATE(54);
|
||||
SET_LEX_STATE(0);
|
||||
REDUCE(ts_builtin_sym_end, ts_sym_object, 4, COLLAPSE({1, 0, 1, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(55, 15);
|
||||
STATE(55);
|
||||
SET_LEX_STATE(21);
|
||||
SHIFT(ts_sym_array, 20)
|
||||
SHIFT(ts_sym_number, 20)
|
||||
|
|
@ -581,24 +583,24 @@ PARSE_TABLE() {
|
|||
SHIFT(ts_builtin_sym_error, 56)
|
||||
END_STATE();
|
||||
|
||||
STATE(56, 15);
|
||||
STATE(56);
|
||||
SET_LEX_STATE(5);
|
||||
SHIFT(ts_sym_comma, 22)
|
||||
REDUCE(ts_sym_right_bracket, ts_aux_sym_repeat_helper1, 0, COLLAPSE({}))
|
||||
SHIFT(ts_aux_sym_repeat_helper1, 57)
|
||||
END_STATE();
|
||||
|
||||
STATE(57, 15);
|
||||
STATE(57);
|
||||
SET_LEX_STATE(7);
|
||||
SHIFT(ts_sym_right_bracket, 58)
|
||||
END_STATE();
|
||||
|
||||
STATE(58, 15);
|
||||
STATE(58);
|
||||
SET_LEX_STATE(0);
|
||||
REDUCE(ts_builtin_sym_end, ts_sym_array, 4, COLLAPSE({1, 0, 1, 1}))
|
||||
END_STATE();
|
||||
|
||||
STATE(59, 15);
|
||||
STATE(59);
|
||||
SET_LEX_STATE(0);
|
||||
REDUCE(ts_builtin_sym_end, ts_sym_array, 2, COLLAPSE({1, 1}))
|
||||
END_STATE();
|
||||
|
|
|
|||
|
|
@ -38,6 +38,7 @@ static const ts_parse_action ** ts_parse_actions; \
|
|||
static void ts_init_parse_table()
|
||||
|
||||
#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]; \
|
||||
|
|
@ -50,11 +51,11 @@ if (!done) { \
|
|||
#define END_TABLE() }
|
||||
#define END_STATE() }
|
||||
|
||||
#define STATE(state_val, num_symbols) \
|
||||
#define STATE(state_val) \
|
||||
state = state_val; \
|
||||
if (1) { \
|
||||
ts_symbol_count = num_symbols; \
|
||||
static ts_parse_action actions_for_state[num_symbols]; \
|
||||
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) \
|
||||
|
|
@ -80,29 +81,24 @@ ts_parser constructor_name() { \
|
|||
}
|
||||
|
||||
#define SHIFT(on_symbol, to_state_value) \
|
||||
actions_for_state[on_symbol].type = ts_parse_action_type_shift; \
|
||||
actions_for_state[on_symbol].data.to_state = to_state_value;
|
||||
actions_for_state[on_symbol] = (ts_parse_action) { \
|
||||
.type = ts_parse_action_type_shift, \
|
||||
.data = { .to_state = to_state_value } \
|
||||
};
|
||||
|
||||
#define REDUCE(on_symbol, symbol_val, child_count_val, collapse_flags_val) \
|
||||
do { \
|
||||
static const int collapse_flags[child_count_val] = collapse_flags_val; \
|
||||
actions_for_state[on_symbol].type = ts_parse_action_type_reduce; \
|
||||
actions_for_state[on_symbol].data.symbol = symbol_val; \
|
||||
actions_for_state[on_symbol].data.child_count = child_count_val; \
|
||||
actions_for_state[on_symbol].data.collapse_flags = collapse_flags; \
|
||||
actions_for_state[on_symbol] = (ts_parse_action) { \
|
||||
.type = ts_parse_action_type_reduce, \
|
||||
.data = { .symbol = symbol_val, .child_count = child_count_val, .collapse_flags = collapse_flags } \
|
||||
}; \
|
||||
} while(0);
|
||||
|
||||
#define ACCEPT_INPUT(on_symbol) \
|
||||
actions_for_state[on_symbol].type = ts_parse_action_type_accept; \
|
||||
|
||||
#define PARSE_ERROR(count, inputs) \
|
||||
{ \
|
||||
static const ts_symbol expected_inputs[] = inputs; \
|
||||
if (ts_lr_parser_handle_error(parser, count, expected_inputs)) \
|
||||
goto next_state; \
|
||||
else \
|
||||
goto done; \
|
||||
}
|
||||
actions_for_state[on_symbol] = (ts_parse_action) { \
|
||||
.type = ts_parse_action_type_accept, \
|
||||
};
|
||||
|
||||
#define START_LEXER() \
|
||||
ts_lexer_skip_whitespace(lexer); \
|
||||
|
|
|
|||
|
|
@ -189,6 +189,10 @@ namespace tree_sitter {
|
|||
body += _default("LEX_PANIC();");
|
||||
return _switch("LEX_STATE()", body);
|
||||
}
|
||||
|
||||
string symbol_count() {
|
||||
return "#define TS_SYMBOL_COUNT " + to_string(parse_table.symbols.size());
|
||||
}
|
||||
|
||||
string symbol_enum() {
|
||||
string result = "enum {\n";
|
||||
|
|
@ -274,7 +278,7 @@ namespace tree_sitter {
|
|||
"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++) + ", " + to_string(parse_table.symbols.size()) + ");",
|
||||
"STATE(" + to_string(state_id++) + ");",
|
||||
parse_table_row_for_state(state),
|
||||
"END_STATE();"
|
||||
});
|
||||
|
|
@ -292,10 +296,9 @@ namespace tree_sitter {
|
|||
string code() {
|
||||
return join({
|
||||
includes(),
|
||||
symbol_count(),
|
||||
symbol_enum(),
|
||||
rule_names_list(),
|
||||
// recover_function(),
|
||||
// parse_function(),
|
||||
lex_function(),
|
||||
parse_table_function(),
|
||||
parser_export(),
|
||||
|
|
|
|||
|
|
@ -79,10 +79,10 @@ size_t ts_tree_child_count(const ts_tree *tree) {
|
|||
return tree->data.children.count;
|
||||
}
|
||||
|
||||
static const char *NULL_TREE_STRING = "(NULL)";
|
||||
static const char *ERROR_TREE_STRING = "(ERROR)";
|
||||
|
||||
static size_t tree_write_to_string(const ts_tree *tree, const char **symbol_names, char *string, size_t limit) {
|
||||
static const char *NULL_TREE_STRING = "(NULL)";
|
||||
static const char *ERROR_TREE_STRING = "(ERROR)";
|
||||
|
||||
if (!tree)
|
||||
return snprintf(string, limit, "%s", NULL_TREE_STRING);
|
||||
if (tree->symbol == ts_builtin_sym_error)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue