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

Store character rules’ matches in a set, not a vector

Browse source
This commit is contained in:
Max Brunsfeld 2014-01-31 18:56:02 -08:00
parent 5ed5ae7514
commit 716a4a4259
9 changed files with 218 additions and 218 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -2,28 +2,28 @@
#include <ctype.h>
enum ts_symbol {
ts_aux_token1,
ts_symbol_plus,
ts_aux_token2,
ts_symbol_number,
ts_symbol_variable,
ts_symbol_factor,
ts_symbol_times,
ts_aux_token1,
ts_symbol_term,
ts_symbol_variable,
ts_symbol_expression,
ts_aux_token2,
ts_symbol___END__,
};
static const char *ts_symbol_names[] = {
"token1",
"plus",
"token2",
"number",
"variable",
"factor",
"times",
"token1",
"term",
"variable",
"expression",
"token2",
"__END__",
};
@ -73,14 +73,14 @@ static void ts_lex(TSParser *parser) {
ADVANCE(8);
LEX_ERROR(2, EXPECT({"')'", "'+'"}));
case 10:
if (('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z') ||
('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z'))
ADVANCE(13);
if ((LOOKAHEAD_CHAR() == '('))
ADVANCE(12);
if (('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') ||
('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z'))
ADVANCE(13);
if ((isdigit(LOOKAHEAD_CHAR())))
ADVANCE(11);
LEX_ERROR(4, EXPECT({"'A'-'Z'", "'a'-'z'", "'('", "<digit>"}));
LEX_ERROR(4, EXPECT({"'A'-'Z'", "'('", "'a'-'z'", "<digit>"}));
case 11:
if ((isdigit(LOOKAHEAD_CHAR())))
ADVANCE(11);
@ -88,8 +88,8 @@ static void ts_lex(TSParser *parser) {
case 12:
ACCEPT_TOKEN(ts_aux_token1);
case 13:
if (('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z') ||
('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z'))
if (('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') ||
('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z'))
ADVANCE(13);
ACCEPT_TOKEN(ts_symbol_variable);
case 14:
@ -99,13 +99,13 @@ static void ts_lex(TSParser *parser) {
ADVANCE(1);
LEX_ERROR(2, EXPECT({"'+'", "<EOF>"}));
case 15:
if ((LOOKAHEAD_CHAR() == '+'))
ADVANCE(8);
if ((LOOKAHEAD_CHAR() == '*'))
ADVANCE(3);
if ((LOOKAHEAD_CHAR() == '+'))
ADVANCE(8);
if ((LOOKAHEAD_CHAR() == '\0'))
ADVANCE(1);
LEX_ERROR(3, EXPECT({"'+'", "'*'", "<EOF>"}));
LEX_ERROR(3, 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_aux_token1:
SHIFT(42);
case ts_symbol_number:
SHIFT(41);
case ts_symbol_factor:
SHIFT(45);
case ts_symbol_term:
SHIFT(2);
case ts_aux_token1:
SHIFT(42);
case ts_symbol_number:
SHIFT(41);
case ts_symbol_variable:
SHIFT(41);
case ts_symbol_expression:
SHIFT(1);
default:
PARSE_ERROR(6, EXPECT({"factor", "term", "expression", "variable", "number", "token1"}));
PARSE_ERROR(6, EXPECT({"expression", "variable", "number", "token1", "term", "factor"}));
}
case 1:
SET_LEX_STATE(0);
@ -154,18 +154,18 @@ static TSParseResult ts_parse(const char *input) {
case 3:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
SHIFT(34);
case ts_aux_token1:
SHIFT(6);
case ts_symbol_number:
SHIFT(5);
case ts_symbol_factor:
SHIFT(34);
case ts_symbol_variable:
SHIFT(5);
case ts_symbol_term:
SHIFT(4);
default:
PARSE_ERROR(5, EXPECT({"term", "variable", "factor", "number", "token1"}));
PARSE_ERROR(5, EXPECT({"term", "variable", "number", "token1", "factor"}));
}
case 4:
SET_LEX_STATE(0);
@ -188,20 +188,20 @@ static TSParseResult ts_parse(const char *input) {
case 6:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_expression:
SHIFT(32);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_term:
SHIFT(7);
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_expression:
SHIFT(32);
default:
PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"}));
PARSE_ERROR(6, EXPECT({"expression", "variable", "number", "token1", "term", "factor"}));
}
case 7:
SET_LEX_STATE(9);
@ -216,18 +216,18 @@ static TSParseResult ts_parse(const char *input) {
case 8:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
SHIFT(25);
case ts_aux_token1:
SHIFT(11);
case ts_symbol_number:
SHIFT(10);
case ts_symbol_factor:
SHIFT(25);
case ts_symbol_variable:
SHIFT(10);
case ts_symbol_term:
SHIFT(9);
default:
PARSE_ERROR(5, EXPECT({"term", "variable", "factor", "number", "token1"}));
PARSE_ERROR(5, EXPECT({"term", "variable", "number", "token1", "factor"}));
}
case 9:
SET_LEX_STATE(4);
@ -250,20 +250,20 @@ static TSParseResult ts_parse(const char *input) {
case 11:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_expression:
SHIFT(23);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_term:
SHIFT(7);
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_expression:
SHIFT(23);
default:
PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"}));
PARSE_ERROR(6, EXPECT({"expression", "variable", "number", "token1", "term", "factor"}));
}
case 12:
SET_LEX_STATE(7);
@ -280,20 +280,20 @@ static TSParseResult ts_parse(const char *input) {
case 13:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_expression:
SHIFT(14);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_term:
SHIFT(7);
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_expression:
SHIFT(14);
default:
PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"}));
PARSE_ERROR(6, EXPECT({"expression", "variable", "number", "token1", "term", "factor"}));
}
case 14:
SET_LEX_STATE(4);
@ -330,16 +330,16 @@ static TSParseResult ts_parse(const char *input) {
case 17:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
SHIFT(22);
case ts_aux_token1:
SHIFT(19);
case ts_symbol_number:
SHIFT(18);
case ts_symbol_factor:
SHIFT(22);
case ts_symbol_variable:
SHIFT(18);
default:
PARSE_ERROR(4, EXPECT({"variable", "factor", "number", "token1"}));
PARSE_ERROR(4, EXPECT({"variable", "number", "token1", "factor"}));
}
case 18:
SET_LEX_STATE(9);
@ -354,20 +354,20 @@ static TSParseResult ts_parse(const char *input) {
case 19:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_expression:
SHIFT(20);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_term:
SHIFT(7);
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_expression:
SHIFT(20);
default:
PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"}));
PARSE_ERROR(6, EXPECT({"expression", "variable", "number", "token1", "term", "factor"}));
}
case 20:
SET_LEX_STATE(4);
@ -428,16 +428,16 @@ static TSParseResult ts_parse(const char *input) {
case 26:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
SHIFT(31);
case ts_aux_token1:
SHIFT(28);
case ts_symbol_number:
SHIFT(27);
case ts_symbol_factor:
SHIFT(31);
case ts_symbol_variable:
SHIFT(27);
default:
PARSE_ERROR(4, EXPECT({"variable", "factor", "number", "token1"}));
PARSE_ERROR(4, EXPECT({"variable", "number", "token1", "factor"}));
}
case 27:
SET_LEX_STATE(4);
@ -450,20 +450,20 @@ static TSParseResult ts_parse(const char *input) {
case 28:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_expression:
SHIFT(29);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_term:
SHIFT(7);
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_expression:
SHIFT(29);
default:
PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"}));
PARSE_ERROR(6, EXPECT({"expression", "variable", "number", "token1", "term", "factor"}));
}
case 29:
SET_LEX_STATE(4);
@ -520,16 +520,16 @@ static TSParseResult ts_parse(const char *input) {
case 35:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
SHIFT(40);
case ts_aux_token1:
SHIFT(37);
case ts_symbol_number:
SHIFT(36);
case ts_symbol_factor:
SHIFT(40);
case ts_symbol_variable:
SHIFT(36);
default:
PARSE_ERROR(4, EXPECT({"variable", "factor", "number", "token1"}));
PARSE_ERROR(4, EXPECT({"variable", "number", "token1", "factor"}));
}
case 36:
SET_LEX_STATE(0);
@ -542,20 +542,20 @@ static TSParseResult ts_parse(const char *input) {
case 37:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_expression:
SHIFT(38);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_term:
SHIFT(7);
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_expression:
SHIFT(38);
default:
PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"}));
PARSE_ERROR(6, EXPECT({"expression", "variable", "number", "token1", "term", "factor"}));
}
case 38:
SET_LEX_STATE(4);
@ -596,20 +596,20 @@ static TSParseResult ts_parse(const char *input) {
case 42:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_expression:
SHIFT(43);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_term:
SHIFT(7);
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_expression:
SHIFT(43);
default:
PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"}));
PARSE_ERROR(6, EXPECT({"expression", "variable", "number", "token1", "term", "factor"}));
}
case 43:
SET_LEX_STATE(4);
@ -634,28 +634,28 @@ static TSParseResult ts_parse(const char *input) {
case 45:
SET_LEX_STATE(15);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
REDUCE(ts_symbol_term, 1, COLLAPSE({0}));
case ts_symbol___END__:
REDUCE(ts_symbol_term, 1, COLLAPSE({0}));
case ts_symbol_plus:
REDUCE(ts_symbol_term, 1, COLLAPSE({0}));
case ts_symbol_times:
SHIFT(46);
default:
PARSE_ERROR(3, EXPECT({"times", "__END__", "plus"}));
PARSE_ERROR(3, EXPECT({"times", "plus", "__END__"}));
}
case 46:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
SHIFT(51);
case ts_aux_token1:
SHIFT(48);
case ts_symbol_number:
SHIFT(47);
case ts_symbol_factor:
SHIFT(51);
case ts_symbol_variable:
SHIFT(47);
default:
PARSE_ERROR(4, EXPECT({"variable", "factor", "number", "token1"}));
PARSE_ERROR(4, EXPECT({"variable", "number", "token1", "factor"}));
}
case 47:
SET_LEX_STATE(14);
@ -670,20 +670,20 @@ static TSParseResult ts_parse(const char *input) {
case 48:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_expression:
SHIFT(49);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_term:
SHIFT(7);
case ts_aux_token1:
SHIFT(13);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_variable:
SHIFT(12);
case ts_symbol_expression:
SHIFT(49);
default:
PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"}));
PARSE_ERROR(6, EXPECT({"expression", "variable", "number", "token1", "term", "factor"}));
}
case 49:
SET_LEX_STATE(4);

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

@ -2,39 +2,39 @@
#include <ctype.h>
enum ts_symbol {
ts_aux_token6,
ts_symbol_number,
ts_symbol_string,
ts_symbol_array,
ts_symbol___END__,
ts_aux_token3,
ts_symbol_object,
ts_aux_repeat_helper1,
ts_aux_token6,
ts_symbol_number,
ts_aux_token7,
ts_aux_token5,
ts_symbol_string,
ts_aux_token4,
ts_aux_token1,
ts_aux_token3,
ts_symbol___END__,
ts_aux_token2,
ts_aux_repeat_helper2,
ts_symbol_value,
ts_aux_token2,
ts_aux_token1,
};
static const char *ts_symbol_names[] = {
"token6",
"number",
"string",
"array",
"__END__",
"token3",
"object",
"repeat_helper1",
"token6",
"number",
"token7",
"token5",
"string",
"token4",
"token1",
"token3",
"__END__",
"token2",
"repeat_helper2",
"value",
"token2",
"token1",
};
static void ts_lex(TSParser *parser) {
@ -130,20 +130,20 @@ static TSParseResult ts_parse(const char *input) {
switch (LOOKAHEAD_SYM()) {
case ts_symbol_number:
SHIFT(53);
case ts_aux_token5:
SHIFT(47);
case ts_symbol_array:
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({"value", "token1", "string", "object", "array", "token5", "number"}));
PARSE_ERROR(7, EXPECT({"value", "token1", "array", "string", "token5", "object", "number"}));
}
case 1:
SET_LEX_STATE(0);
@ -158,40 +158,40 @@ static TSParseResult ts_parse(const char *input) {
switch (LOOKAHEAD_SYM()) {
case ts_symbol_number:
SHIFT(25);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_string:
SHIFT(25);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_object:
SHIFT(25);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_value:
SHIFT(44);
case ts_aux_token1:
SHIFT(3);
default:
PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"}));
PARSE_ERROR(7, EXPECT({"token1", "value", "array", "string", "object", "token5", "number"}));
}
case 3:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_number:
SHIFT(25);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_string:
SHIFT(25);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_object:
SHIFT(25);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_value:
SHIFT(4);
case ts_aux_token1:
SHIFT(3);
default:
PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"}));
PARSE_ERROR(7, EXPECT({"token1", "value", "array", "string", "object", "token5", "number"}));
}
case 4:
SET_LEX_STATE(2);
@ -228,40 +228,40 @@ static TSParseResult ts_parse(const char *input) {
switch (LOOKAHEAD_SYM()) {
case ts_symbol_number:
SHIFT(43);
case ts_aux_token5:
SHIFT(35);
case ts_symbol_array:
SHIFT(43);
case ts_symbol_string:
SHIFT(43);
case ts_aux_token5:
SHIFT(35);
case ts_symbol_object:
SHIFT(43);
case ts_symbol_array:
SHIFT(43);
case ts_symbol_value:
SHIFT(41);
case ts_aux_token1:
SHIFT(8);
default:
PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"}));
PARSE_ERROR(7, EXPECT({"token1", "value", "array", "string", "object", "token5", "number"}));
}
case 8:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_number:
SHIFT(25);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_string:
SHIFT(25);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_object:
SHIFT(25);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_value:
SHIFT(9);
case ts_aux_token1:
SHIFT(3);
default:
PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"}));
PARSE_ERROR(7, EXPECT({"token1", "value", "array", "string", "object", "token5", "number"}));
}
case 9:
SET_LEX_STATE(2);
@ -314,20 +314,20 @@ static TSParseResult ts_parse(const char *input) {
switch (LOOKAHEAD_SYM()) {
case ts_symbol_number:
SHIFT(25);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_string:
SHIFT(25);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_object:
SHIFT(25);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_value:
SHIFT(15);
case ts_aux_token1:
SHIFT(3);
default:
PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"}));
PARSE_ERROR(7, EXPECT({"token1", "value", "array", "string", "object", "token5", "number"}));
}
case 15:
SET_LEX_STATE(2);
@ -380,40 +380,40 @@ static TSParseResult ts_parse(const char *input) {
switch (LOOKAHEAD_SYM()) {
case ts_symbol_number:
SHIFT(34);
case ts_aux_token5:
SHIFT(26);
case ts_symbol_array:
SHIFT(34);
case ts_symbol_string:
SHIFT(34);
case ts_aux_token5:
SHIFT(26);
case ts_symbol_object:
SHIFT(34);
case ts_symbol_array:
SHIFT(34);
case ts_symbol_value:
SHIFT(32);
case ts_aux_token1:
SHIFT(21);
default:
PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"}));
PARSE_ERROR(7, EXPECT({"token1", "value", "array", "string", "object", "token5", "number"}));
}
case 21:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_number:
SHIFT(25);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_string:
SHIFT(25);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_object:
SHIFT(25);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_value:
SHIFT(22);
case ts_aux_token1:
SHIFT(3);
default:
PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"}));
PARSE_ERROR(7, EXPECT({"token1", "value", "array", "string", "object", "token5", "number"}));
}
case 22:
SET_LEX_STATE(2);
@ -476,20 +476,20 @@ static TSParseResult ts_parse(const char *input) {
switch (LOOKAHEAD_SYM()) {
case ts_symbol_number:
SHIFT(25);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_string:
SHIFT(25);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_object:
SHIFT(25);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_value:
SHIFT(29);
case ts_aux_token1:
SHIFT(3);
default:
PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"}));
PARSE_ERROR(7, EXPECT({"token1", "value", "array", "string", "object", "token5", "number"}));
}
case 29:
SET_LEX_STATE(2);
@ -572,20 +572,20 @@ static TSParseResult ts_parse(const char *input) {
switch (LOOKAHEAD_SYM()) {
case ts_symbol_number:
SHIFT(25);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_string:
SHIFT(25);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_object:
SHIFT(25);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_value:
SHIFT(38);
case ts_aux_token1:
SHIFT(3);
default:
PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"}));
PARSE_ERROR(7, EXPECT({"token1", "value", "array", "string", "object", "token5", "number"}));
}
case 38:
SET_LEX_STATE(2);
@ -696,20 +696,20 @@ static TSParseResult ts_parse(const char *input) {
switch (LOOKAHEAD_SYM()) {
case ts_symbol_number:
SHIFT(25);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_string:
SHIFT(25);
case ts_aux_token5:
SHIFT(12);
case ts_symbol_object:
SHIFT(25);
case ts_symbol_array:
SHIFT(25);
case ts_symbol_value:
SHIFT(50);
case ts_aux_token1:
SHIFT(3);
default:
PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"}));
PARSE_ERROR(7, EXPECT({"token1", "value", "array", "string", "object", "token5", "number"}));
}
case 50:
SET_LEX_STATE(2);

2
src/compiler/build_tables/item_set_transitions.cpp
View file

@ -27,7 +27,7 @@ namespace tree_sitter {
item_transitions.add(rule, make_shared<LexItemSet>(new_item_set));
}
}
result.merge(item_transitions, [](shared_ptr<const LexItemSet> left, shared_ptr<const LexItemSet> right) -> shared_ptr<const LexItemSet> {
return make_shared<LexItemSet>(merge_sets(*left, *right));
});

1
src/compiler/lex_table.cpp
View file

@ -4,7 +4,6 @@ using std::string;
using std::to_string;
using std::unordered_map;
using std::unordered_set;
using std::vector;
using tree_sitter::rules::Symbol;
namespace tree_sitter {

13
src/compiler/rules/character.cpp
View file

@ -12,10 +12,6 @@ namespace tree_sitter {
value.range.max_character = bounds.second;
}
Character::Character(char character) : matches({ CharacterMatch(character) }), sign(true) {}
Character::Character(CharacterClass char_class) : matches({ CharacterMatch(char_class) }), sign(true) {}
Character::Character(const std::vector<CharacterMatch> &matches, bool sign) : matches(matches), sign(sign) {}
bool CharacterMatch::operator==(const CharacterMatch &right) const {
if (type != right.type)
return false;
@ -50,6 +46,10 @@ namespace tree_sitter {
}
}
Character::Character(char character) : matches({ CharacterMatch(character) }), sign(true) {}
Character::Character(CharacterClass char_class) : matches({ CharacterMatch(char_class) }), sign(true) {}
Character::Character(const std::unordered_set<CharacterMatch> &matches, bool sign) : matches(matches), sign(sign) {}
bool Character::operator==(const Rule &rule) const {
const Character *other = dynamic_cast<const Character *>(&rule);
return other && this->operator==(*other);
@ -57,10 +57,7 @@ namespace tree_sitter {
bool Character::operator==(const Character &other) const {
if (other.sign != sign) return false;
auto size = matches.size();
if (other.matches.size() != size) return false;
for (int i = 0; i < size; i++)
if (!(matches[i] == other.matches[i])) return false;
if (other.matches != matches) return false;
return true;
}

46
src/compiler/rules/character.h
View file

@ -1,8 +1,7 @@
#ifndef __tree_sitter__char__
#define __tree_sitter__char__
#ifndef __tree_sitter__character__
#define __tree_sitter__character__
#include "rule.h"
#include <vector>
#include <unordered_set>
namespace tree_sitter {
@ -35,24 +34,6 @@ namespace tree_sitter {
bool operator==(const CharacterMatch &) const;
std::string to_string() const;
};
class Character : public Rule {
public:
Character(char character);
Character(CharacterClass character_class);
Character(char min_character, char max_character);
Character(const std::vector<CharacterMatch> &matches, bool sign);
bool operator==(const Rule& other) const;
bool operator==(const Character& other) const;
size_t hash_code() const;
rule_ptr copy() const;
std::string to_string() const;
void accept(Visitor &visitor) const;
std::vector<CharacterMatch> matches;
bool sign;
};
}
}
@ -76,6 +57,29 @@ namespace std {
};
}
namespace tree_sitter {
namespace rules {
class Character : public Rule {
public:
Character(char character);
Character(CharacterClass character_class);
Character(char min_character, char max_character);
Character(const std::unordered_set<CharacterMatch> &matches, bool sign);
bool operator==(const Rule& other) const;
bool operator==(const Character& other) const;
size_t hash_code() const;
rule_ptr copy() const;
std::string to_string() const;
void accept(Visitor &visitor) const;
std::unordered_set<CharacterMatch> matches;
bool sign;
};
}
}
namespace std {
template<>
struct hash<tree_sitter::rules::Character> : hash<tree_sitter::rules::Rule> {};

4
src/compiler/rules/pattern.cpp
View file

@ -44,9 +44,9 @@ namespace tree_sitter {
next();
is_affirmative = false;
}
std::vector<CharacterMatch> matches;
std::unordered_set<CharacterMatch> matches;
while (has_more_input() && (peek() != ']'))
matches.push_back(single_char());
matches.insert(single_char());
return character(matches, is_affirmative);
}

2
src/compiler/rules/rules.cpp
View file

@ -18,7 +18,7 @@ namespace tree_sitter {
return make_shared<Character>(value);
}
rule_ptr character(const std::vector<CharacterMatch> &matches, bool is_affirmative) {
rule_ptr character(const std::unordered_set<CharacterMatch> &matches, bool is_affirmative) {
return make_shared<Character>(matches, is_affirmative);
}

4
src/compiler/rules/rules.h
View file

@ -17,8 +17,8 @@ namespace tree_sitter {
rule_ptr blank();
rule_ptr character(char value);
rule_ptr character(CharacterClass value);
rule_ptr character(const std::vector<CharacterMatch> &matches);
rule_ptr character(const std::vector<CharacterMatch> &matches, bool);
rule_ptr character(const std::unordered_set<CharacterMatch> &matches);
rule_ptr character(const std::unordered_set<CharacterMatch> &matches, bool);
rule_ptr choice(const std::initializer_list<rule_ptr> &rules);
rule_ptr pattern(const std::string &value);