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

Fix errors in computing character set unions

Browse source
This commit is contained in:
Max Brunsfeld 2014-02-06 09:12:03 -08:00
parent 8b1aeee0e3
commit e8337a3c70
5 changed files with 315 additions and 292 deletions
Download patch file Download diff file Expand all files Collapse all files

11
character_set_spec.cpp
View file

@ -38,6 +38,11 @@ describe("character sets", []() {
CharacterSet set({ {'a', 'r'} }, true);
set.union_with(CharacterSet({ {'s', 'z'} }, true));
AssertThat(set, Equals(CharacterSet({ {'a', 'z'} }, true)));
set = CharacterSet({ 'c' });
auto c = set.complement();
set.union_with(c);
AssertThat(set, Equals(CharacterSet({ {0, -1} }, true)));
});
it("works when the result becomes a continuous range", []() {
@ -45,6 +50,12 @@ describe("character sets", []() {
set.union_with(CharacterSet({ {'d', 'f'} }, true));
AssertThat(set, Equals(CharacterSet({ {'a', 'z'} }, true)));
});
it("does nothing for the set of all characters", []() {
CharacterSet set({ {'\0', '\xff'} }, true);
set.union_with(CharacterSet({ 'a' }));
AssertThat(set, Equals(CharacterSet({ {'\0', '\xff'} }, true)));
});
});
});

240
spec/fixtures/parsers/arithmetic.c vendored
View file

@ -2,28 +2,28 @@
#include <ctype.h>
enum ts_symbol {
ts_symbol_factor,
ts_aux_token1,
ts_symbol_plus,
ts_aux_token2,
ts_symbol_variable,
ts_symbol_times,
ts_symbol_factor,
ts_symbol_term,
ts_symbol_number,
ts_symbol_times,
ts_symbol_expression,
ts_symbol_variable,
ts_aux_token2,
ts_symbol_term,
ts_symbol___END__,
};
static const char *ts_symbol_names[] = {
"factor",
"token1",
"plus",
"token2",
"variable",
"times",
"factor",
"term",
"number",
"times",
"expression",
"variable",
"token2",
"term",
"__END__",
};
@ -33,7 +33,7 @@ static void ts_lex(TSParser *parser) {
case 0:
if ((LOOKAHEAD_CHAR() == '\0'))
ADVANCE(1);
LEX_ERROR(1, EXPECT({"\0"}));
LEX_ERROR(1, EXPECT({"<EOF>"}));
case 1:
ACCEPT_TOKEN(ts_symbol___END__);
case 2:
@ -41,7 +41,7 @@ static void ts_lex(TSParser *parser) {
ADVANCE(3);
if ((LOOKAHEAD_CHAR() == '\0'))
ADVANCE(1);
LEX_ERROR(2, EXPECT({"\0", "*"}));
LEX_ERROR(2, EXPECT({"<EOF>", "*"}));
case 3:
ACCEPT_TOKEN(ts_symbol_times);
case 4:
@ -73,11 +73,11 @@ static void ts_lex(TSParser *parser) {
ADVANCE(8);
LEX_ERROR(2, EXPECT({")", "+"}));
case 10:
if ((LOOKAHEAD_CHAR() == '('))
ADVANCE(12);
if (('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') ||
('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z'))
ADVANCE(13);
if ((LOOKAHEAD_CHAR() == '('))
ADVANCE(12);
if (('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9'))
ADVANCE(11);
LEX_ERROR(4, EXPECT({"(", "0-9", "A-Z", "a-z"}));
@ -97,7 +97,7 @@ static void ts_lex(TSParser *parser) {
ADVANCE(8);
if ((LOOKAHEAD_CHAR() == '\0'))
ADVANCE(1);
LEX_ERROR(2, EXPECT({"\0", "+"}));
LEX_ERROR(2, EXPECT({"<EOF>", "+"}));
case 15:
if ((LOOKAHEAD_CHAR() == '*'))
ADVANCE(3);
@ -105,7 +105,7 @@ static void ts_lex(TSParser *parser) {
ADVANCE(8);
if ((LOOKAHEAD_CHAR() == '\0'))
ADVANCE(1);
LEX_ERROR(2, EXPECT({"\0", "*-+"}));
LEX_ERROR(2, EXPECT({"<EOF>", "*-+"}));
default:
LEX_PANIC();
}
@ -118,20 +118,20 @@ static TSParseResult ts_parse(const char *input) {
case 0:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
SHIFT(45);
case ts_aux_token1:
SHIFT(42);
case ts_symbol_expression:
SHIFT(1);
case ts_symbol_number:
SHIFT(41);
case ts_symbol_variable:
SHIFT(41);
case ts_symbol_factor:
SHIFT(45);
case ts_symbol_term:
SHIFT(2);
case ts_symbol_expression:
SHIFT(1);
default:
PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "number", "expression", "token1"}));
PARSE_PANIC();
}
case 1:
SET_LEX_STATE(0);
@ -139,7 +139,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol___END__:
ACCEPT_INPUT();
default:
PARSE_ERROR(1, EXPECT({"__END__"}));
PARSE_PANIC();
}
case 2:
SET_LEX_STATE(14);
@ -149,15 +149,15 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol_plus:
SHIFT(3);
default:
PARSE_ERROR(2, EXPECT({"plus", "__END__"}));
PARSE_PANIC();
}
case 3:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
SHIFT(34);
case ts_aux_token1:
SHIFT(6);
case ts_symbol_factor:
SHIFT(34);
case ts_symbol_number:
SHIFT(5);
case ts_symbol_variable:
@ -165,7 +165,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol_term:
SHIFT(4);
default:
PARSE_ERROR(5, EXPECT({"term", "variable", "number", "token1", "factor"}));
PARSE_PANIC();
}
case 4:
SET_LEX_STATE(0);
@ -173,7 +173,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol___END__:
REDUCE(ts_symbol_expression, 3, COLLAPSE({0, 0, 0}));
default:
PARSE_ERROR(1, EXPECT({"__END__"}));
PARSE_PANIC();
}
case 5:
SET_LEX_STATE(2);
@ -183,25 +183,25 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol___END__:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
default:
PARSE_ERROR(2, EXPECT({"__END__", "times"}));
PARSE_PANIC();
}
case 6:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token1:
SHIFT(13);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_expression:
SHIFT(32);
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_term:
SHIFT(7);
default:
PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "number", "expression", "token1"}));
PARSE_PANIC();
}
case 7:
SET_LEX_STATE(9);
@ -211,15 +211,15 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol_plus:
SHIFT(8);
default:
PARSE_ERROR(2, EXPECT({"plus", "token2"}));
PARSE_PANIC();
}
case 8:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
SHIFT(25);
case ts_aux_token1:
SHIFT(11);
case ts_symbol_factor:
SHIFT(25);
case ts_symbol_number:
SHIFT(10);
case ts_symbol_variable:
@ -227,7 +227,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol_term:
SHIFT(9);
default:
PARSE_ERROR(5, EXPECT({"term", "variable", "number", "token1", "factor"}));
PARSE_PANIC();
}
case 9:
SET_LEX_STATE(4);
@ -235,7 +235,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token2:
REDUCE(ts_symbol_expression, 3, COLLAPSE({0, 0, 0}));
default:
PARSE_ERROR(1, EXPECT({"token2"}));
PARSE_PANIC();
}
case 10:
SET_LEX_STATE(6);
@ -245,55 +245,55 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol_times:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
default:
PARSE_ERROR(2, EXPECT({"times", "token2"}));
PARSE_PANIC();
}
case 11:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token1:
SHIFT(13);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_expression:
SHIFT(23);
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_term:
SHIFT(7);
default:
PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "number", "expression", "token1"}));
PARSE_PANIC();
}
case 12:
SET_LEX_STATE(7);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_times:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_aux_token2:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_symbol_times:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_symbol_plus:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
default:
PARSE_ERROR(3, EXPECT({"plus", "token2", "times"}));
PARSE_PANIC();
}
case 13:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token1:
SHIFT(13);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_expression:
SHIFT(14);
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_term:
SHIFT(7);
default:
PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "number", "expression", "token1"}));
PARSE_PANIC();
}
case 14:
SET_LEX_STATE(4);
@ -301,19 +301,19 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token2:
SHIFT(15);
default:
PARSE_ERROR(1, EXPECT({"token2"}));
PARSE_PANIC();
}
case 15:
SET_LEX_STATE(7);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_times:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_aux_token2:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_symbol_times:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_symbol_plus:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_ERROR(3, EXPECT({"plus", "token2", "times"}));
PARSE_PANIC();
}
case 16:
SET_LEX_STATE(7);
@ -325,21 +325,21 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol_times:
SHIFT(17);
default:
PARSE_ERROR(3, EXPECT({"times", "plus", "token2"}));
PARSE_PANIC();
}
case 17:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
SHIFT(22);
case ts_aux_token1:
SHIFT(19);
case ts_symbol_factor:
SHIFT(22);
case ts_symbol_number:
SHIFT(18);
case ts_symbol_variable:
SHIFT(18);
default:
PARSE_ERROR(4, EXPECT({"variable", "number", "token1", "factor"}));
PARSE_PANIC();
}
case 18:
SET_LEX_STATE(9);
@ -349,25 +349,25 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol_plus:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
default:
PARSE_ERROR(2, EXPECT({"plus", "token2"}));
PARSE_PANIC();
}
case 19:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token1:
SHIFT(13);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_expression:
SHIFT(20);
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_term:
SHIFT(7);
default:
PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "number", "expression", "token1"}));
PARSE_PANIC();
}
case 20:
SET_LEX_STATE(4);
@ -375,7 +375,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token2:
SHIFT(21);
default:
PARSE_ERROR(1, EXPECT({"token2"}));
PARSE_PANIC();
}
case 21:
SET_LEX_STATE(9);
@ -385,7 +385,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol_plus:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_ERROR(2, EXPECT({"plus", "token2"}));
PARSE_PANIC();
}
case 22:
SET_LEX_STATE(9);
@ -395,7 +395,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol_plus:
REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0}));
default:
PARSE_ERROR(2, EXPECT({"plus", "token2"}));
PARSE_PANIC();
}
case 23:
SET_LEX_STATE(4);
@ -403,7 +403,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token2:
SHIFT(24);
default:
PARSE_ERROR(1, EXPECT({"token2"}));
PARSE_PANIC();
}
case 24:
SET_LEX_STATE(6);
@ -413,7 +413,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol_times:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_ERROR(2, EXPECT({"times", "token2"}));
PARSE_PANIC();
}
case 25:
SET_LEX_STATE(6);
@ -423,21 +423,21 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol_times:
SHIFT(26);
default:
PARSE_ERROR(2, EXPECT({"times", "token2"}));
PARSE_PANIC();
}
case 26:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
SHIFT(31);
case ts_aux_token1:
SHIFT(28);
case ts_symbol_factor:
SHIFT(31);
case ts_symbol_number:
SHIFT(27);
case ts_symbol_variable:
SHIFT(27);
default:
PARSE_ERROR(4, EXPECT({"variable", "number", "token1", "factor"}));
PARSE_PANIC();
}
case 27:
SET_LEX_STATE(4);
@ -445,25 +445,25 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token2:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
default:
PARSE_ERROR(1, EXPECT({"token2"}));
PARSE_PANIC();
}
case 28:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token1:
SHIFT(13);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_expression:
SHIFT(29);
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_term:
SHIFT(7);
default:
PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "number", "expression", "token1"}));
PARSE_PANIC();
}
case 29:
SET_LEX_STATE(4);
@ -471,7 +471,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token2:
SHIFT(30);
default:
PARSE_ERROR(1, EXPECT({"token2"}));
PARSE_PANIC();
}
case 30:
SET_LEX_STATE(4);
@ -479,7 +479,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token2:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_ERROR(1, EXPECT({"token2"}));
PARSE_PANIC();
}
case 31:
SET_LEX_STATE(4);
@ -487,7 +487,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token2:
REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0}));
default:
PARSE_ERROR(1, EXPECT({"token2"}));
PARSE_PANIC();
}
case 32:
SET_LEX_STATE(4);
@ -495,7 +495,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token2:
SHIFT(33);
default:
PARSE_ERROR(1, EXPECT({"token2"}));
PARSE_PANIC();
}
case 33:
SET_LEX_STATE(2);
@ -505,7 +505,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol___END__:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_ERROR(2, EXPECT({"__END__", "times"}));
PARSE_PANIC();
}
case 34:
SET_LEX_STATE(2);
@ -515,21 +515,21 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol_times:
SHIFT(35);
default:
PARSE_ERROR(2, EXPECT({"times", "__END__"}));
PARSE_PANIC();
}
case 35:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
SHIFT(40);
case ts_aux_token1:
SHIFT(37);
case ts_symbol_factor:
SHIFT(40);
case ts_symbol_number:
SHIFT(36);
case ts_symbol_variable:
SHIFT(36);
default:
PARSE_ERROR(4, EXPECT({"variable", "number", "token1", "factor"}));
PARSE_PANIC();
}
case 36:
SET_LEX_STATE(0);
@ -537,25 +537,25 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol___END__:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
default:
PARSE_ERROR(1, EXPECT({"__END__"}));
PARSE_PANIC();
}
case 37:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token1:
SHIFT(13);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_expression:
SHIFT(38);
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_term:
SHIFT(7);
default:
PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "number", "expression", "token1"}));
PARSE_PANIC();
}
case 38:
SET_LEX_STATE(4);
@ -563,7 +563,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token2:
SHIFT(39);
default:
PARSE_ERROR(1, EXPECT({"token2"}));
PARSE_PANIC();
}
case 39:
SET_LEX_STATE(0);
@ -571,7 +571,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol___END__:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_ERROR(1, EXPECT({"__END__"}));
PARSE_PANIC();
}
case 40:
SET_LEX_STATE(0);
@ -579,7 +579,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol___END__:
REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0}));
default:
PARSE_ERROR(1, EXPECT({"__END__"}));
PARSE_PANIC();
}
case 41:
SET_LEX_STATE(15);
@ -591,25 +591,25 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol___END__:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
default:
PARSE_ERROR(3, EXPECT({"__END__", "plus", "times"}));
PARSE_PANIC();
}
case 42:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token1:
SHIFT(13);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_expression:
SHIFT(43);
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_term:
SHIFT(7);
default:
PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "number", "expression", "token1"}));
PARSE_PANIC();
}
case 43:
SET_LEX_STATE(4);
@ -617,7 +617,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token2:
SHIFT(44);
default:
PARSE_ERROR(1, EXPECT({"token2"}));
PARSE_PANIC();
}
case 44:
SET_LEX_STATE(15);
@ -629,7 +629,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol___END__:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_ERROR(3, EXPECT({"__END__", "plus", "times"}));
PARSE_PANIC();
}
case 45:
SET_LEX_STATE(15);
@ -641,21 +641,21 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol_times:
SHIFT(46);
default:
PARSE_ERROR(3, EXPECT({"times", "__END__", "plus"}));
PARSE_PANIC();
}
case 46:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
SHIFT(51);
case ts_aux_token1:
SHIFT(48);
case ts_symbol_factor:
SHIFT(51);
case ts_symbol_number:
SHIFT(47);
case ts_symbol_variable:
SHIFT(47);
default:
PARSE_ERROR(4, EXPECT({"variable", "number", "token1", "factor"}));
PARSE_PANIC();
}
case 47:
SET_LEX_STATE(14);
@ -665,25 +665,25 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol___END__:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
default:
PARSE_ERROR(2, EXPECT({"__END__", "plus"}));
PARSE_PANIC();
}
case 48:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token1:
SHIFT(13);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_expression:
SHIFT(49);
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_term:
SHIFT(7);
default:
PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "number", "expression", "token1"}));
PARSE_PANIC();
}
case 49:
SET_LEX_STATE(4);
@ -691,7 +691,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token2:
SHIFT(50);
default:
PARSE_ERROR(1, EXPECT({"token2"}));
PARSE_PANIC();
}
case 50:
SET_LEX_STATE(14);
@ -701,7 +701,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol___END__:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_ERROR(2, EXPECT({"__END__", "plus"}));
PARSE_PANIC();
}
case 51:
SET_LEX_STATE(14);
@ -711,7 +711,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol___END__:
REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0}));
default:
PARSE_ERROR(2, EXPECT({"__END__", "plus"}));
PARSE_PANIC();
}
default:
PARSE_PANIC();

314
spec/fixtures/parsers/json.c vendored
View file

@ -4,37 +4,37 @@
enum ts_symbol {
ts_aux_token6,
ts_symbol_number,
ts_aux_repeat_helper1,
ts_aux_token7,
ts_aux_repeat_helper2,
ts_aux_token5,
ts_symbol_value,
ts_symbol___END__,
ts_aux_token3,
ts_aux_token2,
ts_symbol_string,
ts_symbol_object,
ts_aux_token4,
ts_symbol_array,
ts_symbol_value,
ts_aux_token5,
ts_aux_repeat_helper1,
ts_aux_repeat_helper2,
ts_aux_token4,
ts_aux_token3,
ts_aux_token1,
ts_symbol_object,
ts_aux_token2,
ts_aux_token7,
ts_symbol___END__,
};
static const char *ts_symbol_names[] = {
"token6",
"number",
"repeat_helper1",
"token7",
"repeat_helper2",
"token5",
"value",
"__END__",
"token3",
"token2",
"string",
"object",
"token4",
"array",
"value",
"token5",
"repeat_helper1",
"repeat_helper2",
"token4",
"token3",
"token1",
"object",
"token2",
"token7",
"__END__",
};
static void ts_lex(TSParser *parser) {
@ -43,7 +43,7 @@ static void ts_lex(TSParser *parser) {
case 0:
if ((LOOKAHEAD_CHAR() == '\0'))
ADVANCE(1);
LEX_ERROR(1, EXPECT({"\0"}));
LEX_ERROR(1, EXPECT({"<EOF>"}));
case 1:
ACCEPT_TOKEN(ts_symbol___END__);
case 2:
@ -77,12 +77,12 @@ static void ts_lex(TSParser *parser) {
ADVANCE(3);
LEX_ERROR(2, EXPECT({",", "}"}));
case 10:
if ((LOOKAHEAD_CHAR() == '['))
ADVANCE(15);
if ((LOOKAHEAD_CHAR() == '{'))
ADVANCE(16);
if ((LOOKAHEAD_CHAR() == '\"'))
ADVANCE(12);
if ((LOOKAHEAD_CHAR() == '['))
ADVANCE(15);
if (('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9'))
ADVANCE(11);
LEX_ERROR(4, EXPECT({"\"", "0-9", "[", "{"}));
@ -93,13 +93,13 @@ static void ts_lex(TSParser *parser) {
case 12:
if (!((LOOKAHEAD_CHAR() == '\"')))
ADVANCE(13);
LEX_ERROR(1, EXPECT({"<-!"}));
LEX_ERROR(2, EXPECT({"<EOF>-!", "#-<MAX>"}));
case 13:
if ((LOOKAHEAD_CHAR() == '\"'))
ADVANCE(14);
if (!((LOOKAHEAD_CHAR() == '\"')))
ADVANCE(13);
LEX_ERROR(1, EXPECT({"<-\""}));
LEX_ERROR(1, EXPECT({"<ANY>"}));
case 14:
ACCEPT_TOKEN(ts_symbol_string);
case 15:
@ -128,22 +128,22 @@ static TSParseResult ts_parse(const char *input) {
case 0:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_string:
SHIFT(53);
case ts_aux_token1:
SHIFT(2);
case ts_symbol_object:
SHIFT(53);
case ts_symbol_value:
SHIFT(1);
case ts_aux_token5:
SHIFT(47);
case ts_symbol_number:
SHIFT(53);
case ts_symbol_string:
SHIFT(53);
case ts_symbol_array:
SHIFT(53);
case ts_symbol_object:
SHIFT(53);
case ts_aux_token5:
SHIFT(47);
case ts_aux_token1:
SHIFT(2);
case ts_symbol_value:
SHIFT(1);
default:
PARSE_ERROR(7, EXPECT({"array", "number", "token5", "value", "object", "token1", "string"}));
PARSE_PANIC();
}
case 1:
SET_LEX_STATE(0);
@ -151,47 +151,47 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol___END__:
ACCEPT_INPUT();
default:
PARSE_ERROR(1, EXPECT({"__END__"}));
PARSE_PANIC();
}
case 2:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_string:
SHIFT(25);
case ts_aux_token1:
SHIFT(3);
case ts_symbol_object:
SHIFT(25);
case ts_symbol_number:
SHIFT(25);
case ts_symbol_string:
SHIFT(25);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_value:
SHIFT(44);
case ts_symbol_object:
SHIFT(25);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_value:
SHIFT(44);
case ts_aux_token1:
SHIFT(3);
default:
PARSE_ERROR(7, EXPECT({"token5", "value", "array", "number", "object", "token1", "string"}));
PARSE_PANIC();
}
case 3:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_string:
SHIFT(25);
case ts_aux_token1:
SHIFT(3);
case ts_symbol_object:
SHIFT(25);
case ts_symbol_number:
SHIFT(25);
case ts_symbol_string:
SHIFT(25);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_value:
SHIFT(4);
case ts_symbol_object:
SHIFT(25);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_value:
SHIFT(4);
case ts_aux_token1:
SHIFT(3);
default:
PARSE_ERROR(7, EXPECT({"token5", "value", "array", "number", "object", "token1", "string"}));
PARSE_PANIC();
}
case 4:
SET_LEX_STATE(2);
@ -203,7 +203,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_repeat_helper2:
SHIFT(5);
default:
PARSE_ERROR(3, EXPECT({"repeat_helper2", "token3", "token2"}));
PARSE_PANIC();
}
case 5:
SET_LEX_STATE(4);
@ -211,7 +211,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token4:
SHIFT(6);
default:
PARSE_ERROR(1, EXPECT({"token4"}));
PARSE_PANIC();
}
case 6:
SET_LEX_STATE(2);
@ -221,47 +221,47 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token2:
REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1}));
default:
PARSE_ERROR(2, EXPECT({"token2", "token3"}));
PARSE_PANIC();
}
case 7:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_number:
SHIFT(43);
case ts_symbol_string:
SHIFT(43);
case ts_aux_token1:
SHIFT(8);
case ts_aux_token5:
SHIFT(35);
case ts_symbol_object:
SHIFT(43);
case ts_symbol_number:
SHIFT(43);
case ts_symbol_array:
SHIFT(43);
case ts_symbol_value:
SHIFT(41);
case ts_aux_token5:
SHIFT(35);
case ts_aux_token1:
SHIFT(8);
default:
PARSE_ERROR(7, EXPECT({"token5", "value", "array", "number", "object", "token1", "string"}));
PARSE_PANIC();
}
case 8:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_string:
SHIFT(25);
case ts_aux_token1:
SHIFT(3);
case ts_symbol_object:
SHIFT(25);
case ts_symbol_number:
SHIFT(25);
case ts_symbol_string:
SHIFT(25);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_value:
SHIFT(9);
case ts_symbol_object:
SHIFT(25);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_value:
SHIFT(9);
case ts_aux_token1:
SHIFT(3);
default:
PARSE_ERROR(7, EXPECT({"token5", "value", "array", "number", "object", "token1", "string"}));
PARSE_PANIC();
}
case 9:
SET_LEX_STATE(2);
@ -273,7 +273,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_repeat_helper2:
SHIFT(10);
default:
PARSE_ERROR(3, EXPECT({"repeat_helper2", "token3", "token2"}));
PARSE_PANIC();
}
case 10:
SET_LEX_STATE(4);
@ -281,7 +281,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token4:
SHIFT(11);
default:
PARSE_ERROR(1, EXPECT({"token4"}));
PARSE_PANIC();
}
case 11:
SET_LEX_STATE(6);
@ -291,7 +291,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token2:
REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1}));
default:
PARSE_ERROR(2, EXPECT({"token2", "token4"}));
PARSE_PANIC();
}
case 12:
SET_LEX_STATE(19);
@ -299,7 +299,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol_string:
SHIFT(13);
default:
PARSE_ERROR(1, EXPECT({"string"}));
PARSE_PANIC();
}
case 13:
SET_LEX_STATE(17);
@ -307,27 +307,27 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token6:
SHIFT(14);
default:
PARSE_ERROR(1, EXPECT({"token6"}));
PARSE_PANIC();
}
case 14:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_number:
SHIFT(25);
case ts_symbol_string:
SHIFT(25);
case ts_aux_token1:
SHIFT(3);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_object:
SHIFT(25);
case ts_symbol_number:
SHIFT(25);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_value:
SHIFT(15);
case ts_aux_token5:
SHIFT(12);
case ts_aux_token1:
SHIFT(3);
default:
PARSE_ERROR(7, EXPECT({"token5", "value", "array", "number", "object", "token1", "string"}));
PARSE_PANIC();
}
case 15:
SET_LEX_STATE(2);
@ -339,7 +339,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_repeat_helper1:
SHIFT(16);
default:
PARSE_ERROR(3, EXPECT({"repeat_helper1", "token3", "token2"}));
PARSE_PANIC();
}
case 16:
SET_LEX_STATE(7);
@ -347,7 +347,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token7:
SHIFT(17);
default:
PARSE_ERROR(1, EXPECT({"token7"}));
PARSE_PANIC();
}
case 17:
SET_LEX_STATE(2);
@ -357,7 +357,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token2:
REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}));
default:
PARSE_ERROR(2, EXPECT({"token2", "token3"}));
PARSE_PANIC();
}
case 18:
SET_LEX_STATE(19);
@ -365,7 +365,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol_string:
SHIFT(19);
default:
PARSE_ERROR(1, EXPECT({"string"}));
PARSE_PANIC();
}
case 19:
SET_LEX_STATE(17);
@ -373,47 +373,47 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token6:
SHIFT(20);
default:
PARSE_ERROR(1, EXPECT({"token6"}));
PARSE_PANIC();
}
case 20:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_number:
SHIFT(34);
case ts_symbol_string:
SHIFT(34);
case ts_aux_token1:
SHIFT(21);
case ts_aux_token5:
SHIFT(26);
case ts_symbol_object:
SHIFT(34);
case ts_symbol_number:
SHIFT(34);
case ts_symbol_array:
SHIFT(34);
case ts_symbol_value:
SHIFT(32);
case ts_aux_token5:
SHIFT(26);
case ts_aux_token1:
SHIFT(21);
default:
PARSE_ERROR(7, EXPECT({"token5", "value", "array", "number", "object", "token1", "string"}));
PARSE_PANIC();
}
case 21:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_string:
SHIFT(25);
case ts_aux_token1:
SHIFT(3);
case ts_symbol_object:
SHIFT(25);
case ts_symbol_number:
SHIFT(25);
case ts_symbol_string:
SHIFT(25);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_value:
SHIFT(22);
case ts_symbol_object:
SHIFT(25);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_value:
SHIFT(22);
case ts_aux_token1:
SHIFT(3);
default:
PARSE_ERROR(7, EXPECT({"token5", "value", "array", "number", "object", "token1", "string"}));
PARSE_PANIC();
}
case 22:
SET_LEX_STATE(2);
@ -425,7 +425,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_repeat_helper2:
SHIFT(23);
default:
PARSE_ERROR(3, EXPECT({"repeat_helper2", "token3", "token2"}));
PARSE_PANIC();
}
case 23:
SET_LEX_STATE(4);
@ -433,7 +433,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token4:
SHIFT(24);
default:
PARSE_ERROR(1, EXPECT({"token4"}));
PARSE_PANIC();
}
case 24:
SET_LEX_STATE(9);
@ -443,7 +443,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token2:
REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1}));
default:
PARSE_ERROR(2, EXPECT({"token2", "token7"}));
PARSE_PANIC();
}
case 25:
SET_LEX_STATE(2);
@ -453,7 +453,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token2:
REDUCE(ts_symbol_value, 1, COLLAPSE({0}));
default:
PARSE_ERROR(2, EXPECT({"token2", "token3"}));
PARSE_PANIC();
}
case 26:
SET_LEX_STATE(19);
@ -461,7 +461,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol_string:
SHIFT(27);
default:
PARSE_ERROR(1, EXPECT({"string"}));
PARSE_PANIC();
}
case 27:
SET_LEX_STATE(17);
@ -469,27 +469,27 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token6:
SHIFT(28);
default:
PARSE_ERROR(1, EXPECT({"token6"}));
PARSE_PANIC();
}
case 28:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_number:
SHIFT(25);
case ts_symbol_string:
SHIFT(25);
case ts_aux_token1:
SHIFT(3);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_object:
SHIFT(25);
case ts_symbol_number:
SHIFT(25);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_value:
SHIFT(29);
case ts_aux_token5:
SHIFT(12);
case ts_aux_token1:
SHIFT(3);
default:
PARSE_ERROR(7, EXPECT({"token5", "value", "array", "number", "object", "token1", "string"}));
PARSE_PANIC();
}
case 29:
SET_LEX_STATE(2);
@ -501,7 +501,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_repeat_helper1:
SHIFT(30);
default:
PARSE_ERROR(3, EXPECT({"repeat_helper1", "token3", "token2"}));
PARSE_PANIC();
}
case 30:
SET_LEX_STATE(7);
@ -509,7 +509,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token7:
SHIFT(31);
default:
PARSE_ERROR(1, EXPECT({"token7"}));
PARSE_PANIC();
}
case 31:
SET_LEX_STATE(9);
@ -519,7 +519,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token2:
REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}));
default:
PARSE_ERROR(2, EXPECT({"token2", "token7"}));
PARSE_PANIC();
}
case 32:
SET_LEX_STATE(9);
@ -531,7 +531,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_repeat_helper1:
SHIFT(33);
default:
PARSE_ERROR(3, EXPECT({"repeat_helper1", "token2", "token7"}));
PARSE_PANIC();
}
case 33:
SET_LEX_STATE(7);
@ -539,7 +539,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token7:
REDUCE(ts_aux_repeat_helper1, 5, COLLAPSE({1, 0, 1, 0, 1}));
default:
PARSE_ERROR(1, EXPECT({"token7"}));
PARSE_PANIC();
}
case 34:
SET_LEX_STATE(9);
@ -549,7 +549,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token2:
REDUCE(ts_symbol_value, 1, COLLAPSE({0}));
default:
PARSE_ERROR(2, EXPECT({"token2", "token7"}));
PARSE_PANIC();
}
case 35:
SET_LEX_STATE(19);
@ -557,7 +557,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol_string:
SHIFT(36);
default:
PARSE_ERROR(1, EXPECT({"string"}));
PARSE_PANIC();
}
case 36:
SET_LEX_STATE(17);
@ -565,27 +565,27 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token6:
SHIFT(37);
default:
PARSE_ERROR(1, EXPECT({"token6"}));
PARSE_PANIC();
}
case 37:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_number:
SHIFT(25);
case ts_symbol_string:
SHIFT(25);
case ts_aux_token1:
SHIFT(3);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_object:
SHIFT(25);
case ts_symbol_number:
SHIFT(25);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_value:
SHIFT(38);
case ts_aux_token5:
SHIFT(12);
case ts_aux_token1:
SHIFT(3);
default:
PARSE_ERROR(7, EXPECT({"token5", "value", "array", "number", "object", "token1", "string"}));
PARSE_PANIC();
}
case 38:
SET_LEX_STATE(2);
@ -597,7 +597,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_repeat_helper1:
SHIFT(39);
default:
PARSE_ERROR(3, EXPECT({"repeat_helper1", "token3", "token2"}));
PARSE_PANIC();
}
case 39:
SET_LEX_STATE(7);
@ -605,7 +605,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token7:
SHIFT(40);
default:
PARSE_ERROR(1, EXPECT({"token7"}));
PARSE_PANIC();
}
case 40:
SET_LEX_STATE(6);
@ -615,7 +615,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token2:
REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}));
default:
PARSE_ERROR(2, EXPECT({"token2", "token4"}));
PARSE_PANIC();
}
case 41:
SET_LEX_STATE(6);
@ -627,7 +627,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_repeat_helper2:
SHIFT(42);
default:
PARSE_ERROR(3, EXPECT({"repeat_helper2", "token4", "token2"}));
PARSE_PANIC();
}
case 42:
SET_LEX_STATE(4);
@ -635,7 +635,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token4:
REDUCE(ts_aux_repeat_helper2, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_ERROR(1, EXPECT({"token4"}));
PARSE_PANIC();
}
case 43:
SET_LEX_STATE(6);
@ -645,7 +645,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token2:
REDUCE(ts_symbol_value, 1, COLLAPSE({0}));
default:
PARSE_ERROR(2, EXPECT({"token2", "token4"}));
PARSE_PANIC();
}
case 44:
SET_LEX_STATE(2);
@ -657,7 +657,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_repeat_helper2:
SHIFT(45);
default:
PARSE_ERROR(3, EXPECT({"repeat_helper2", "token3", "token2"}));
PARSE_PANIC();
}
case 45:
SET_LEX_STATE(4);
@ -665,7 +665,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token4:
SHIFT(46);
default:
PARSE_ERROR(1, EXPECT({"token4"}));
PARSE_PANIC();
}
case 46:
SET_LEX_STATE(0);
@ -673,7 +673,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol___END__:
REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1}));
default:
PARSE_ERROR(1, EXPECT({"__END__"}));
PARSE_PANIC();
}
case 47:
SET_LEX_STATE(19);
@ -681,7 +681,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol_string:
SHIFT(48);
default:
PARSE_ERROR(1, EXPECT({"string"}));
PARSE_PANIC();
}
case 48:
SET_LEX_STATE(17);
@ -689,27 +689,27 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token6:
SHIFT(49);
default:
PARSE_ERROR(1, EXPECT({"token6"}));
PARSE_PANIC();
}
case 49:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_number:
SHIFT(25);
case ts_symbol_string:
SHIFT(25);
case ts_aux_token1:
SHIFT(3);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_object:
SHIFT(25);
case ts_symbol_number:
SHIFT(25);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_value:
SHIFT(50);
case ts_aux_token5:
SHIFT(12);
case ts_aux_token1:
SHIFT(3);
default:
PARSE_ERROR(7, EXPECT({"token5", "value", "array", "number", "object", "token1", "string"}));
PARSE_PANIC();
}
case 50:
SET_LEX_STATE(2);
@ -721,7 +721,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_repeat_helper1:
SHIFT(51);
default:
PARSE_ERROR(3, EXPECT({"repeat_helper1", "token3", "token2"}));
PARSE_PANIC();
}
case 51:
SET_LEX_STATE(7);
@ -729,7 +729,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_aux_token7:
SHIFT(52);
default:
PARSE_ERROR(1, EXPECT({"token7"}));
PARSE_PANIC();
}
case 52:
SET_LEX_STATE(0);
@ -737,7 +737,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol___END__:
REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}));
default:
PARSE_ERROR(1, EXPECT({"__END__"}));
PARSE_PANIC();
}
case 53:
SET_LEX_STATE(0);
@ -745,7 +745,7 @@ static TSParseResult ts_parse(const char *input) {
case ts_symbol___END__:
REDUCE(ts_symbol_value, 1, COLLAPSE({0}));
default:
PARSE_ERROR(1, EXPECT({"__END__"}));
PARSE_PANIC();
}
default:
PARSE_PANIC();

39
src/compiler/rules/character_set.cpp
View file

@ -6,10 +6,13 @@ using std::set;
namespace tree_sitter {
namespace rules {
char MAX_CHAR = -1;
const char MAX_CHAR = '\xff';
CharacterRange::CharacterRange(char value) : min(value), max(value) {}
CharacterRange::CharacterRange(char min, char max) : min(min), max(max) {}
CharacterRange::CharacterRange(char min, char max) :
min(min),
max(max)
{}
bool CharacterRange::operator==(const CharacterRange &other) const {
return min == other.min && max == other.max;
@ -25,34 +28,40 @@ namespace tree_sitter {
string escape_character(char input) {
switch (input) {
case '\0':
return "\\0";
return "<EOF>";
case MAX_CHAR:
return "<MAX>";
default:
return string() + input;
}
}
int CharacterRange::max_int() const {
return max == MAX_CHAR ? 255 : (int)max;
}
int CharacterRange::min_int() const {
return (int)min;
}
bool CharacterRange::is_adjacent(const CharacterRange &other) const {
return
(min <= other.min && max >= (other.min - 1)) ||
(min <= (other.max + 1) && max >= other.max);
(min_int() <= other.min_int() && max_int() >= (other.min_int() - 1)) ||
(min_int() <= (other.max_int() + 1) && max_int() >= other.max_int());
}
void CharacterRange::add_range(const CharacterRange &other) {
if (other.min < min) min = other.min;
if (other.max > max) max = other.max;
if (other.max_int() > max_int()) max = other.max;
}
string CharacterRange::to_string() const {
if (min == max) {
if (min == 0 && max == MAX_CHAR)
return "<ANY>";
if (min == max)
return escape_character(min);
} else {
if (min == 0)
return string("<-") + max;
else if (max == MAX_CHAR)
return string() + min + "->";
else
return string() + min + "-" + max;
}
else
return string() + escape_character(min) + "-" + escape_character(max);
}
CharacterSet::CharacterSet() : ranges({}) {}

3
src/compiler/rules/character_set.h
View file

@ -12,6 +12,9 @@ namespace tree_sitter {
CharacterRange(char);
CharacterRange(char, char);
int max_int() const;
int min_int() const;
bool operator==(const CharacterRange &) const;
bool operator<(const CharacterRange &) const;