From 5ed5ae751417ec0dccf9b70b506a2c7b61757fb7 Mon Sep 17 00:00:00 2001 From: Max Brunsfeld Date: Fri, 31 Jan 2014 00:13:05 -0800 Subject: [PATCH] In LR(1) items, only store consumed symbols as booleans the booleans represent the symbols point to auxiliary tokens or not. This is all we need to know for the purpose of building parse tables. Any other information just leads to redundant parse states. --- .../build_tables/item_set_closure_spec.cpp | 6 +- spec/fixtures/parsers/arithmetic.c | 602 +++++------ spec/fixtures/parsers/json.c | 994 +++++++----------- src/compiler/build_tables/item.cpp | 2 +- src/compiler/build_tables/item.h | 8 +- .../build_tables/item_set_transitions.cpp | 2 +- src/compiler/build_tables/perform.cpp | 10 +- src/compiler/rules/character.cpp | 18 +- src/compiler/rules/character.h | 1 + src/compiler/rules/symbol.cpp | 8 +- src/compiler/rules/symbol.h | 2 + 11 files changed, 660 insertions(+), 993 deletions(-) diff --git a/spec/compiler/build_tables/item_set_closure_spec.cpp b/spec/compiler/build_tables/item_set_closure_spec.cpp index 0c1ba836..d55fcf24 100644 --- a/spec/compiler/build_tables/item_set_closure_spec.cpp +++ b/spec/compiler/build_tables/item_set_closure_spec.cpp @@ -44,9 +44,9 @@ describe("computing closures of item sets", []() { auto sym1 = rules::Symbol("v"); ParseItemSet next_item_set = *sym_transitions(item_set, grammar)[sym1]; AssertThat(next_item_set, Equals(ParseItemSet({ - ParseItem(Symbol("F"), rules::blank(), { sym1 }, Symbol("__END__")), - ParseItem(Symbol("F"), rules::blank(), { sym1 }, Symbol("*")), - ParseItem(Symbol("F"), rules::blank(), { sym1 }, Symbol("+")), + ParseItem(Symbol("F"), rules::blank(), { false }, Symbol("__END__")), + ParseItem(Symbol("F"), rules::blank(), { false }, Symbol("*")), + ParseItem(Symbol("F"), rules::blank(), { false }, Symbol("+")), }))); }); }); diff --git a/spec/fixtures/parsers/arithmetic.c b/spec/fixtures/parsers/arithmetic.c index 9fbd973a..7d558182 100644 --- a/spec/fixtures/parsers/arithmetic.c +++ b/spec/fixtures/parsers/arithmetic.c @@ -2,28 +2,28 @@ #include enum ts_symbol { + ts_aux_token1, ts_symbol_plus, ts_aux_token2, ts_symbol_number, - ts_symbol_term, ts_symbol_factor, - ts_aux_token1, ts_symbol_times, - ts_symbol_expression, + ts_symbol_term, ts_symbol_variable, + ts_symbol_expression, ts_symbol___END__, }; static const char *ts_symbol_names[] = { + "token1", "plus", "token2", "number", - "term", "factor", - "token1", "times", - "expression", + "term", "variable", + "expression", "__END__", }; @@ -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(52); - case ts_symbol_expression: - SHIFT(1); case ts_aux_token1: - SHIFT(49); + SHIFT(42); case ts_symbol_number: - SHIFT(48); - case ts_symbol_variable: - SHIFT(47); + SHIFT(41); + case ts_symbol_factor: + SHIFT(45); case ts_symbol_term: SHIFT(2); + case ts_symbol_variable: + SHIFT(41); + case ts_symbol_expression: + SHIFT(1); default: - PARSE_ERROR(6, EXPECT({"term", "variable", "number", "token1", "expression", "factor"})); + PARSE_ERROR(6, EXPECT({"factor", "term", "expression", "variable", "number", "token1"})); } 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(39); case ts_aux_token1: - SHIFT(7); - case ts_symbol_number: 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", "number", "token1", "factor"})); + PARSE_ERROR(5, EXPECT({"term", "variable", "factor", "number", "token1"})); } case 4: SET_LEX_STATE(0); @@ -186,60 +186,50 @@ static TSParseResult ts_parse(const char *input) { PARSE_ERROR(2, EXPECT({"__END__", "times"})); } case 6: - SET_LEX_STATE(2); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_times: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); - case ts_symbol___END__: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); - default: - PARSE_ERROR(2, EXPECT({"__END__", "times"})); - } - case 7: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(19); - case ts_symbol_expression: - SHIFT(37); case ts_aux_token1: - SHIFT(16); + SHIFT(13); case ts_symbol_number: - SHIFT(15); + SHIFT(12); + case ts_symbol_expression: + SHIFT(32); case ts_symbol_variable: - SHIFT(14); + SHIFT(12); + case ts_symbol_factor: + SHIFT(16); case ts_symbol_term: - SHIFT(8); + SHIFT(7); default: - PARSE_ERROR(6, EXPECT({"term", "variable", "number", "token1", "expression", "factor"})); + PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"})); } - case 8: + case 7: SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: REDUCE(ts_symbol_expression, 1, COLLAPSE({0})); case ts_symbol_plus: - SHIFT(9); + SHIFT(8); default: PARSE_ERROR(2, EXPECT({"plus", "token2"})); } - case 9: + case 8: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(29); case ts_aux_token1: - SHIFT(13); - case ts_symbol_number: - SHIFT(12); - case ts_symbol_variable: SHIFT(11); - case ts_symbol_term: + 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", "number", "token1", "factor"})); + PARSE_ERROR(5, EXPECT({"term", "variable", "factor", "number", "token1"})); } - case 10: + case 9: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: @@ -247,45 +237,35 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_ERROR(1, EXPECT({"token2"})); } + case 10: + SET_LEX_STATE(6); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + case ts_symbol_times: + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + default: + PARSE_ERROR(2, EXPECT({"times", "token2"})); + } case 11: - SET_LEX_STATE(6); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); - case ts_symbol_times: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); - default: - PARSE_ERROR(2, EXPECT({"times", "token2"})); - } - case 12: - SET_LEX_STATE(6); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); - case ts_symbol_times: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); - default: - PARSE_ERROR(2, EXPECT({"times", "token2"})); - } - case 13: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(19); - case ts_symbol_expression: - SHIFT(27); case ts_aux_token1: - SHIFT(16); + SHIFT(13); case ts_symbol_number: - SHIFT(15); + SHIFT(12); + case ts_symbol_expression: + SHIFT(23); case ts_symbol_variable: - SHIFT(14); + SHIFT(12); + case ts_symbol_factor: + SHIFT(16); case ts_symbol_term: - SHIFT(8); + SHIFT(7); default: - PARSE_ERROR(6, EXPECT({"term", "variable", "number", "token1", "expression", "factor"})); + PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"})); } - case 14: + case 12: SET_LEX_STATE(7); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: @@ -297,83 +277,71 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_ERROR(3, EXPECT({"plus", "times", "token2"})); } + 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); + default: + PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"})); + } + case 14: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + SHIFT(15); + default: + PARSE_ERROR(1, EXPECT({"token2"})); + } case 15: SET_LEX_STATE(7); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); case ts_symbol_times: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); case ts_symbol_plus: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); default: PARSE_ERROR(3, EXPECT({"plus", "times", "token2"})); } case 16: - SET_LEX_STATE(10); + SET_LEX_STATE(7); switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(19); - case ts_symbol_expression: + case ts_aux_token2: + REDUCE(ts_symbol_term, 1, COLLAPSE({0})); + case ts_symbol_plus: + REDUCE(ts_symbol_term, 1, COLLAPSE({0})); + case ts_symbol_times: SHIFT(17); - case ts_aux_token1: - SHIFT(16); - case ts_symbol_number: - SHIFT(15); - case ts_symbol_variable: - SHIFT(14); - case ts_symbol_term: - SHIFT(8); - default: - PARSE_ERROR(6, EXPECT({"term", "variable", "number", "token1", "expression", "factor"})); - } - case 17: - SET_LEX_STATE(4); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - SHIFT(18); - default: - PARSE_ERROR(1, EXPECT({"token2"})); - } - case 18: - SET_LEX_STATE(7); - switch (LOOKAHEAD_SYM()) { - 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", "times", "token2"})); - } - case 19: - SET_LEX_STATE(7); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - REDUCE(ts_symbol_term, 1, COLLAPSE({0})); - case ts_symbol_plus: - REDUCE(ts_symbol_term, 1, COLLAPSE({0})); - case ts_symbol_times: - SHIFT(20); default: PARSE_ERROR(3, EXPECT({"times", "plus", "token2"})); } - case 20: + case 17: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(26); case ts_aux_token1: - SHIFT(23); + SHIFT(19); case ts_symbol_number: + SHIFT(18); + case ts_symbol_factor: SHIFT(22); case ts_symbol_variable: - SHIFT(21); + SHIFT(18); default: - PARSE_ERROR(4, EXPECT({"variable", "number", "token1", "factor"})); + PARSE_ERROR(4, EXPECT({"variable", "factor", "number", "token1"})); } - case 21: + case 18: SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: @@ -383,71 +351,61 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_ERROR(2, EXPECT({"plus", "token2"})); } + 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); + default: + PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"})); + } + case 20: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + SHIFT(21); + default: + PARSE_ERROR(1, EXPECT({"token2"})); + } + case 21: + SET_LEX_STATE(9); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + 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(2, EXPECT({"plus", "token2"})); + } case 22: SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); case ts_symbol_plus: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); default: PARSE_ERROR(2, EXPECT({"plus", "token2"})); } case 23: - SET_LEX_STATE(10); + SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(19); - case ts_symbol_expression: + case ts_aux_token2: SHIFT(24); - case ts_aux_token1: - SHIFT(16); - case ts_symbol_number: - SHIFT(15); - case ts_symbol_variable: - SHIFT(14); - case ts_symbol_term: - SHIFT(8); default: - PARSE_ERROR(6, EXPECT({"term", "variable", "number", "token1", "expression", "factor"})); + PARSE_ERROR(1, EXPECT({"token2"})); } case 24: - SET_LEX_STATE(4); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - SHIFT(25); - default: - PARSE_ERROR(1, EXPECT({"token2"})); - } - case 25: - SET_LEX_STATE(9); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - 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(2, EXPECT({"plus", "token2"})); - } - case 26: - SET_LEX_STATE(9); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); - case ts_symbol_plus: - REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); - default: - PARSE_ERROR(2, EXPECT({"plus", "token2"})); - } - case 27: - SET_LEX_STATE(4); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - SHIFT(28); - default: - PARSE_ERROR(1, EXPECT({"token2"})); - } - case 28: SET_LEX_STATE(6); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: @@ -457,35 +415,77 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_ERROR(2, EXPECT({"times", "token2"})); } - case 29: + case 25: SET_LEX_STATE(6); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: REDUCE(ts_symbol_term, 1, COLLAPSE({0})); case ts_symbol_times: - SHIFT(30); + SHIFT(26); default: PARSE_ERROR(2, EXPECT({"times", "token2"})); } - case 30: + case 26: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(36); case ts_aux_token1: - SHIFT(33); + SHIFT(28); case ts_symbol_number: - SHIFT(32); - case ts_symbol_variable: + SHIFT(27); + case ts_symbol_factor: SHIFT(31); + case ts_symbol_variable: + SHIFT(27); default: - PARSE_ERROR(4, EXPECT({"variable", "number", "token1", "factor"})); + PARSE_ERROR(4, EXPECT({"variable", "factor", "number", "token1"})); + } + case 27: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + default: + PARSE_ERROR(1, EXPECT({"token2"})); + } + 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); + default: + PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"})); + } + case 29: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + SHIFT(30); + default: + PARSE_ERROR(1, EXPECT({"token2"})); + } + case 30: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + default: + PARSE_ERROR(1, EXPECT({"token2"})); } case 31: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); default: PARSE_ERROR(1, EXPECT({"token2"})); } @@ -493,61 +493,11 @@ static TSParseResult ts_parse(const char *input) { SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + SHIFT(33); default: PARSE_ERROR(1, EXPECT({"token2"})); } case 33: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(19); - case ts_symbol_expression: - SHIFT(34); - case ts_aux_token1: - SHIFT(16); - case ts_symbol_number: - SHIFT(15); - case ts_symbol_variable: - SHIFT(14); - case ts_symbol_term: - SHIFT(8); - default: - PARSE_ERROR(6, EXPECT({"term", "variable", "number", "token1", "expression", "factor"})); - } - case 34: - SET_LEX_STATE(4); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - SHIFT(35); - default: - PARSE_ERROR(1, EXPECT({"token2"})); - } - case 35: - SET_LEX_STATE(4); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); - default: - PARSE_ERROR(1, EXPECT({"token2"})); - } - case 36: - SET_LEX_STATE(4); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); - default: - PARSE_ERROR(1, EXPECT({"token2"})); - } - case 37: - SET_LEX_STATE(4); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - SHIFT(38); - default: - PARSE_ERROR(1, EXPECT({"token2"})); - } - case 38: SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { case ts_symbol_times: @@ -557,31 +507,31 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_ERROR(2, EXPECT({"__END__", "times"})); } - case 39: + case 34: SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { case ts_symbol___END__: REDUCE(ts_symbol_term, 1, COLLAPSE({0})); case ts_symbol_times: - SHIFT(40); + SHIFT(35); default: PARSE_ERROR(2, EXPECT({"times", "__END__"})); } - case 40: + case 35: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(46); case ts_aux_token1: - SHIFT(43); + SHIFT(37); case ts_symbol_number: - SHIFT(42); + SHIFT(36); + case ts_symbol_factor: + SHIFT(40); case ts_symbol_variable: - SHIFT(41); + SHIFT(36); default: - PARSE_ERROR(4, EXPECT({"variable", "number", "token1", "factor"})); + PARSE_ERROR(4, EXPECT({"variable", "factor", "number", "token1"})); } - case 41: + case 36: SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { case ts_symbol___END__: @@ -589,41 +539,33 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_ERROR(1, EXPECT({"__END__"})); } - case 42: - SET_LEX_STATE(0); - switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); - default: - PARSE_ERROR(1, EXPECT({"__END__"})); - } - case 43: + case 37: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(19); + case ts_aux_token1: + SHIFT(13); + case ts_symbol_number: + SHIFT(12); case ts_symbol_expression: - SHIFT(44); - case ts_aux_token1: - SHIFT(16); - case ts_symbol_number: - SHIFT(15); + SHIFT(38); case ts_symbol_variable: - SHIFT(14); + SHIFT(12); + case ts_symbol_factor: + SHIFT(16); case ts_symbol_term: - SHIFT(8); + SHIFT(7); default: - PARSE_ERROR(6, EXPECT({"term", "variable", "number", "token1", "expression", "factor"})); + PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"})); } - case 44: + case 38: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - SHIFT(45); + SHIFT(39); default: PARSE_ERROR(1, EXPECT({"token2"})); } - case 45: + case 39: SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { case ts_symbol___END__: @@ -631,7 +573,7 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_ERROR(1, EXPECT({"__END__"})); } - case 46: + case 40: SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { case ts_symbol___END__: @@ -639,7 +581,7 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_ERROR(1, EXPECT({"__END__"})); } - case 47: + case 41: SET_LEX_STATE(15); switch (LOOKAHEAD_SYM()) { case ts_symbol_times: @@ -651,45 +593,33 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_ERROR(3, EXPECT({"__END__", "plus", "times"})); } - case 48: - SET_LEX_STATE(15); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_times: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); - case ts_symbol_plus: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); - case ts_symbol___END__: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); - default: - PARSE_ERROR(3, EXPECT({"__END__", "plus", "times"})); - } - case 49: + case 42: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(19); - case ts_symbol_expression: - SHIFT(50); case ts_aux_token1: - SHIFT(16); + SHIFT(13); case ts_symbol_number: - SHIFT(15); + SHIFT(12); + case ts_symbol_expression: + SHIFT(43); case ts_symbol_variable: - SHIFT(14); + SHIFT(12); + case ts_symbol_factor: + SHIFT(16); case ts_symbol_term: - SHIFT(8); + SHIFT(7); default: - PARSE_ERROR(6, EXPECT({"term", "variable", "number", "token1", "expression", "factor"})); + PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"})); } - case 50: + case 43: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - SHIFT(51); + SHIFT(44); default: PARSE_ERROR(1, EXPECT({"token2"})); } - case 51: + case 44: SET_LEX_STATE(15); switch (LOOKAHEAD_SYM()) { case ts_symbol_times: @@ -701,7 +631,7 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_ERROR(3, EXPECT({"__END__", "plus", "times"})); } - case 52: + case 45: SET_LEX_STATE(15); switch (LOOKAHEAD_SYM()) { case ts_symbol_plus: @@ -709,25 +639,25 @@ static TSParseResult ts_parse(const char *input) { case ts_symbol___END__: REDUCE(ts_symbol_term, 1, COLLAPSE({0})); case ts_symbol_times: - SHIFT(53); + SHIFT(46); default: PARSE_ERROR(3, EXPECT({"times", "__END__", "plus"})); } - case 53: + case 46: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(59); case ts_aux_token1: - SHIFT(56); + SHIFT(48); case ts_symbol_number: - SHIFT(55); + SHIFT(47); + case ts_symbol_factor: + SHIFT(51); case ts_symbol_variable: - SHIFT(54); + SHIFT(47); default: - PARSE_ERROR(4, EXPECT({"variable", "number", "token1", "factor"})); + PARSE_ERROR(4, EXPECT({"variable", "factor", "number", "token1"})); } - case 54: + case 47: SET_LEX_STATE(14); switch (LOOKAHEAD_SYM()) { case ts_symbol_plus: @@ -737,43 +667,33 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_ERROR(2, EXPECT({"__END__", "plus"})); } - case 55: - SET_LEX_STATE(14); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_plus: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); - case ts_symbol___END__: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); - default: - PARSE_ERROR(2, EXPECT({"__END__", "plus"})); - } - case 56: + case 48: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(19); + case ts_aux_token1: + SHIFT(13); + case ts_symbol_number: + SHIFT(12); case ts_symbol_expression: - SHIFT(57); - case ts_aux_token1: - SHIFT(16); - case ts_symbol_number: - SHIFT(15); + SHIFT(49); case ts_symbol_variable: - SHIFT(14); + SHIFT(12); + case ts_symbol_factor: + SHIFT(16); case ts_symbol_term: - SHIFT(8); + SHIFT(7); default: - PARSE_ERROR(6, EXPECT({"term", "variable", "number", "token1", "expression", "factor"})); + PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"})); } - case 57: + case 49: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - SHIFT(58); + SHIFT(50); default: PARSE_ERROR(1, EXPECT({"token2"})); } - case 58: + case 50: SET_LEX_STATE(14); switch (LOOKAHEAD_SYM()) { case ts_symbol_plus: @@ -783,7 +703,7 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_ERROR(2, EXPECT({"__END__", "plus"})); } - case 59: + case 51: SET_LEX_STATE(14); switch (LOOKAHEAD_SYM()) { case ts_symbol_plus: diff --git a/spec/fixtures/parsers/json.c b/spec/fixtures/parsers/json.c index c668b263..681dfa48 100644 --- a/spec/fixtures/parsers/json.c +++ b/spec/fixtures/parsers/json.c @@ -3,38 +3,38 @@ enum ts_symbol { ts_aux_token6, - ts_symbol_string, - ts_symbol_array, ts_symbol_number, + ts_symbol_array, + ts_symbol___END__, ts_symbol_object, - ts_aux_token5, - ts_aux_repeat_helper2, - ts_aux_token7, - ts_aux_token4, - ts_aux_token3, - ts_aux_token1, ts_aux_repeat_helper1, + ts_aux_token7, + ts_aux_token5, + ts_symbol_string, + ts_aux_token4, + ts_aux_token1, + ts_aux_token3, + ts_aux_repeat_helper2, ts_symbol_value, ts_aux_token2, - ts_symbol___END__, }; static const char *ts_symbol_names[] = { "token6", - "string", - "array", "number", + "array", + "__END__", "object", - "token5", - "repeat_helper2", - "token7", - "token4", - "token3", - "token1", "repeat_helper1", + "token7", + "token5", + "string", + "token4", + "token1", + "token3", + "repeat_helper2", "value", "token2", - "__END__", }; static void ts_lex(TSParser *parser) { @@ -128,22 +128,22 @@ static TSParseResult ts_parse(const char *input) { case 0: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_array: - SHIFT(79); - case ts_symbol_string: - SHIFT(80); + case ts_symbol_number: + SHIFT(53); case ts_aux_token5: - SHIFT(70); + SHIFT(47); + case ts_symbol_array: + SHIFT(53); + case ts_symbol_string: + SHIFT(53); + case ts_symbol_object: + SHIFT(53); case ts_aux_token1: SHIFT(2); - case ts_symbol_object: - SHIFT(78); - case ts_symbol_number: - SHIFT(81); case ts_symbol_value: SHIFT(1); default: - PARSE_ERROR(7, EXPECT({"value", "number", "object", "token1", "token5", "string", "array"})); + PARSE_ERROR(7, EXPECT({"value", "token1", "string", "object", "array", "token5", "number"})); } case 1: SET_LEX_STATE(0); @@ -156,50 +156,50 @@ static TSParseResult ts_parse(const char *input) { case 2: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_array: - SHIFT(34); - case ts_symbol_object: - SHIFT(33); case ts_symbol_number: - SHIFT(36); - case ts_symbol_value: - SHIFT(65); - case ts_symbol_string: - SHIFT(35); + SHIFT(25); case ts_aux_token5: - SHIFT(16); + SHIFT(12); + case ts_symbol_array: + SHIFT(25); + case ts_symbol_string: + SHIFT(25); + case ts_symbol_object: + SHIFT(25); + case ts_symbol_value: + SHIFT(44); case ts_aux_token1: SHIFT(3); default: - PARSE_ERROR(7, EXPECT({"token1", "token5", "string", "number", "value", "object", "array"})); + PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"})); } case 3: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_array: - SHIFT(34); - case ts_symbol_object: - SHIFT(33); case ts_symbol_number: - SHIFT(36); + SHIFT(25); + case ts_aux_token5: + SHIFT(12); + case ts_symbol_array: + SHIFT(25); + case ts_symbol_string: + SHIFT(25); + case ts_symbol_object: + SHIFT(25); case ts_symbol_value: SHIFT(4); - case ts_symbol_string: - SHIFT(35); - case ts_aux_token5: - SHIFT(16); case ts_aux_token1: SHIFT(3); default: - PARSE_ERROR(7, EXPECT({"token1", "token5", "string", "number", "value", "object", "array"})); + PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"})); } case 4: SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - SHIFT(9); - case ts_aux_token3: SHIFT(7); + case ts_aux_token3: + SHIFT(5); case ts_aux_repeat_helper2: SHIFT(5); default: @@ -224,272 +224,218 @@ static TSParseResult ts_parse(const char *input) { PARSE_ERROR(2, EXPECT({"token2", "token3"})); } case 7: - SET_LEX_STATE(4); + SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_aux_token4: + 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_symbol_object: + SHIFT(43); + case ts_symbol_value: + SHIFT(41); + case ts_aux_token1: SHIFT(8); default: - PARSE_ERROR(1, EXPECT({"token4"})); + PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"})); } case 8: - SET_LEX_STATE(2); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token3: - REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); - case ts_aux_token2: - REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); - default: - PARSE_ERROR(2, EXPECT({"token2", "token3"})); - } - case 9: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_array: - SHIFT(62); - case ts_symbol_object: - SHIFT(61); case ts_symbol_number: - SHIFT(64); - case ts_symbol_value: - SHIFT(59); - case ts_symbol_string: - SHIFT(63); + SHIFT(25); case ts_aux_token5: - SHIFT(51); - case ts_aux_token1: - SHIFT(10); - default: - PARSE_ERROR(7, EXPECT({"token1", "token5", "string", "number", "value", "object", "array"})); - } - case 10: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_array: - SHIFT(34); - case ts_symbol_object: - SHIFT(33); - case ts_symbol_number: - SHIFT(36); - case ts_symbol_value: - SHIFT(11); - case ts_symbol_string: - SHIFT(35); - case ts_aux_token5: - SHIFT(16); - case ts_aux_token1: - SHIFT(3); - default: - PARSE_ERROR(7, EXPECT({"token1", "token5", "string", "number", "value", "object", "array"})); - } - case 11: - SET_LEX_STATE(2); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - SHIFT(9); - case ts_aux_token3: - SHIFT(14); - case ts_aux_repeat_helper2: SHIFT(12); - default: - PARSE_ERROR(3, EXPECT({"repeat_helper2", "token3", "token2"})); - } - case 12: - SET_LEX_STATE(4); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token4: - SHIFT(13); - default: - PARSE_ERROR(1, EXPECT({"token4"})); - } - case 13: - SET_LEX_STATE(6); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token4: - REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); - case ts_aux_token2: - REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); - default: - PARSE_ERROR(2, EXPECT({"token2", "token4"})); - } - case 14: - SET_LEX_STATE(4); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token4: - SHIFT(15); - default: - PARSE_ERROR(1, EXPECT({"token4"})); - } - case 15: - SET_LEX_STATE(6); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token4: - REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); - case ts_aux_token2: - REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); - default: - PARSE_ERROR(2, EXPECT({"token2", "token4"})); - } - case 16: - SET_LEX_STATE(19); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_string: - SHIFT(17); - default: - PARSE_ERROR(1, EXPECT({"string"})); - } - case 17: - SET_LEX_STATE(17); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token6: - SHIFT(18); - default: - PARSE_ERROR(1, EXPECT({"token6"})); - } - case 18: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { case ts_symbol_array: - SHIFT(34); - case ts_symbol_object: - SHIFT(33); - case ts_symbol_number: - SHIFT(36); - case ts_symbol_value: - SHIFT(19); - case ts_symbol_string: - SHIFT(35); - case ts_aux_token5: - SHIFT(16); - case ts_aux_token1: - SHIFT(3); - default: - PARSE_ERROR(7, EXPECT({"token1", "token5", "string", "number", "value", "object", "array"})); - } - case 19: - SET_LEX_STATE(2); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - SHIFT(24); - case ts_aux_token3: - SHIFT(22); - case ts_aux_repeat_helper1: - SHIFT(20); - default: - PARSE_ERROR(3, EXPECT({"repeat_helper1", "token3", "token2"})); - } - case 20: - SET_LEX_STATE(7); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token7: - SHIFT(21); - default: - PARSE_ERROR(1, EXPECT({"token7"})); - } - case 21: - SET_LEX_STATE(2); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token3: - REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); - case ts_aux_token2: - REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); - default: - PARSE_ERROR(2, EXPECT({"token2", "token3"})); - } - case 22: - SET_LEX_STATE(7); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token7: - SHIFT(23); - default: - PARSE_ERROR(1, EXPECT({"token7"})); - } - case 23: - SET_LEX_STATE(2); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token3: - REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); - case ts_aux_token2: - REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); - default: - PARSE_ERROR(2, EXPECT({"token2", "token3"})); - } - case 24: - SET_LEX_STATE(19); - switch (LOOKAHEAD_SYM()) { + SHIFT(25); case ts_symbol_string: SHIFT(25); - default: - PARSE_ERROR(1, EXPECT({"string"})); - } - case 25: - SET_LEX_STATE(17); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token6: - SHIFT(26); - default: - PARSE_ERROR(1, EXPECT({"token6"})); - } - case 26: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_array: - SHIFT(48); case ts_symbol_object: - SHIFT(47); - case ts_symbol_number: - SHIFT(50); + SHIFT(25); case ts_symbol_value: - SHIFT(45); - case ts_symbol_string: - SHIFT(49); - case ts_aux_token5: - SHIFT(37); - case ts_aux_token1: - SHIFT(27); - default: - PARSE_ERROR(7, EXPECT({"token1", "token5", "string", "number", "value", "object", "array"})); - } - case 27: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_array: - SHIFT(34); - case ts_symbol_object: - SHIFT(33); - case ts_symbol_number: - SHIFT(36); - case ts_symbol_value: - SHIFT(28); - case ts_symbol_string: - SHIFT(35); - case ts_aux_token5: - SHIFT(16); + SHIFT(9); case ts_aux_token1: SHIFT(3); default: - PARSE_ERROR(7, EXPECT({"token1", "token5", "string", "number", "value", "object", "array"})); + PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"})); } - case 28: + case 9: SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - SHIFT(9); + SHIFT(7); case ts_aux_token3: - SHIFT(31); + SHIFT(10); case ts_aux_repeat_helper2: - SHIFT(29); + SHIFT(10); default: PARSE_ERROR(3, EXPECT({"repeat_helper2", "token3", "token2"})); } - case 29: + case 10: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token4: - SHIFT(30); + SHIFT(11); default: PARSE_ERROR(1, EXPECT({"token4"})); } - case 30: + case 11: + SET_LEX_STATE(6); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token4: + REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); + case ts_aux_token2: + REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); + default: + PARSE_ERROR(2, EXPECT({"token2", "token4"})); + } + case 12: + SET_LEX_STATE(19); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_string: + SHIFT(13); + default: + PARSE_ERROR(1, EXPECT({"string"})); + } + case 13: + SET_LEX_STATE(17); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token6: + SHIFT(14); + default: + PARSE_ERROR(1, EXPECT({"token6"})); + } + case 14: + 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_symbol_object: + 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"})); + } + case 15: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token3: + SHIFT(16); + case ts_aux_token2: + SHIFT(18); + case ts_aux_repeat_helper1: + SHIFT(16); + default: + PARSE_ERROR(3, EXPECT({"repeat_helper1", "token2", "token3"})); + } + case 16: + SET_LEX_STATE(7); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token7: + SHIFT(17); + default: + PARSE_ERROR(1, EXPECT({"token7"})); + } + case 17: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token3: + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + case ts_aux_token2: + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + default: + PARSE_ERROR(2, EXPECT({"token2", "token3"})); + } + case 18: + SET_LEX_STATE(19); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_string: + SHIFT(19); + default: + PARSE_ERROR(1, EXPECT({"string"})); + } + case 19: + SET_LEX_STATE(17); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token6: + SHIFT(20); + default: + PARSE_ERROR(1, EXPECT({"token6"})); + } + case 20: + SET_LEX_STATE(10); + 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_symbol_object: + 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"})); + } + 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_symbol_object: + 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"})); + } + case 22: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + SHIFT(7); + case ts_aux_token3: + SHIFT(23); + case ts_aux_repeat_helper2: + SHIFT(23); + default: + PARSE_ERROR(3, EXPECT({"repeat_helper2", "token3", "token2"})); + } + case 23: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token4: + SHIFT(24); + default: + PARSE_ERROR(1, EXPECT({"token4"})); + } + case 24: SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { case ts_aux_token7: @@ -499,161 +445,95 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_ERROR(2, EXPECT({"token2", "token7"})); } - case 31: - SET_LEX_STATE(4); + case 25: + SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { - case ts_aux_token4: - SHIFT(32); + case ts_aux_token3: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + case ts_aux_token2: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); default: - PARSE_ERROR(1, EXPECT({"token4"})); + PARSE_ERROR(2, EXPECT({"token2", "token3"})); + } + case 26: + SET_LEX_STATE(19); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_string: + SHIFT(27); + default: + PARSE_ERROR(1, EXPECT({"string"})); + } + case 27: + SET_LEX_STATE(17); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token6: + SHIFT(28); + default: + PARSE_ERROR(1, EXPECT({"token6"})); + } + case 28: + 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_symbol_object: + 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"})); + } + case 29: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token3: + SHIFT(30); + case ts_aux_token2: + SHIFT(18); + case ts_aux_repeat_helper1: + SHIFT(30); + default: + PARSE_ERROR(3, EXPECT({"repeat_helper1", "token2", "token3"})); + } + case 30: + SET_LEX_STATE(7); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token7: + SHIFT(31); + default: + PARSE_ERROR(1, EXPECT({"token7"})); + } + case 31: + SET_LEX_STATE(9); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token7: + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + case ts_aux_token2: + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + default: + PARSE_ERROR(2, EXPECT({"token2", "token7"})); } case 32: - SET_LEX_STATE(9); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token7: - REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); - case ts_aux_token2: - REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); - default: - PARSE_ERROR(2, EXPECT({"token2", "token7"})); - } - case 33: - SET_LEX_STATE(2); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token3: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - case ts_aux_token2: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - default: - PARSE_ERROR(2, EXPECT({"token2", "token3"})); - } - case 34: - SET_LEX_STATE(2); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token3: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - case ts_aux_token2: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - default: - PARSE_ERROR(2, EXPECT({"token2", "token3"})); - } - case 35: - SET_LEX_STATE(2); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token3: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - case ts_aux_token2: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - default: - PARSE_ERROR(2, EXPECT({"token2", "token3"})); - } - case 36: - SET_LEX_STATE(2); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token3: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - case ts_aux_token2: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - default: - PARSE_ERROR(2, EXPECT({"token2", "token3"})); - } - case 37: - SET_LEX_STATE(19); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_string: - SHIFT(38); - default: - PARSE_ERROR(1, EXPECT({"string"})); - } - case 38: - SET_LEX_STATE(17); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token6: - SHIFT(39); - default: - PARSE_ERROR(1, EXPECT({"token6"})); - } - case 39: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_array: - SHIFT(34); - case ts_symbol_object: - SHIFT(33); - case ts_symbol_number: - SHIFT(36); - case ts_symbol_value: - SHIFT(40); - case ts_symbol_string: - SHIFT(35); - case ts_aux_token5: - SHIFT(16); - case ts_aux_token1: - SHIFT(3); - default: - PARSE_ERROR(7, EXPECT({"token1", "token5", "string", "number", "value", "object", "array"})); - } - case 40: - SET_LEX_STATE(2); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - SHIFT(24); - case ts_aux_token3: - SHIFT(43); - case ts_aux_repeat_helper1: - SHIFT(41); - default: - PARSE_ERROR(3, EXPECT({"repeat_helper1", "token3", "token2"})); - } - case 41: - SET_LEX_STATE(7); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token7: - SHIFT(42); - default: - PARSE_ERROR(1, EXPECT({"token7"})); - } - case 42: - SET_LEX_STATE(9); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token7: - REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); - case ts_aux_token2: - REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); - default: - PARSE_ERROR(2, EXPECT({"token2", "token7"})); - } - case 43: - SET_LEX_STATE(7); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token7: - SHIFT(44); - default: - PARSE_ERROR(1, EXPECT({"token7"})); - } - case 44: - SET_LEX_STATE(9); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token7: - REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); - case ts_aux_token2: - REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); - default: - PARSE_ERROR(2, EXPECT({"token2", "token7"})); - } - case 45: SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { case ts_aux_token7: REDUCE(ts_aux_repeat_helper1, 4, COLLAPSE({1, 0, 1, 0})); case ts_aux_token2: - SHIFT(24); + SHIFT(18); case ts_aux_repeat_helper1: - SHIFT(46); + SHIFT(33); default: PARSE_ERROR(3, EXPECT({"repeat_helper1", "token2", "token7"})); } - case 46: + case 33: SET_LEX_STATE(7); switch (LOOKAHEAD_SYM()) { case ts_aux_token7: @@ -661,7 +541,7 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_ERROR(1, EXPECT({"token7"})); } - case 47: + case 34: SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { case ts_aux_token7: @@ -671,93 +551,63 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_ERROR(2, EXPECT({"token2", "token7"})); } - case 48: - SET_LEX_STATE(9); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token7: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - case ts_aux_token2: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - default: - PARSE_ERROR(2, EXPECT({"token2", "token7"})); - } - case 49: - SET_LEX_STATE(9); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token7: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - case ts_aux_token2: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - default: - PARSE_ERROR(2, EXPECT({"token2", "token7"})); - } - case 50: - SET_LEX_STATE(9); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token7: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - case ts_aux_token2: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - default: - PARSE_ERROR(2, EXPECT({"token2", "token7"})); - } - case 51: + case 35: SET_LEX_STATE(19); switch (LOOKAHEAD_SYM()) { case ts_symbol_string: - SHIFT(52); + SHIFT(36); default: PARSE_ERROR(1, EXPECT({"string"})); } - case 52: + case 36: SET_LEX_STATE(17); switch (LOOKAHEAD_SYM()) { case ts_aux_token6: - SHIFT(53); + SHIFT(37); default: PARSE_ERROR(1, EXPECT({"token6"})); } - case 53: + case 37: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_array: - SHIFT(34); - case ts_symbol_object: - SHIFT(33); case ts_symbol_number: - SHIFT(36); - case ts_symbol_value: - SHIFT(54); - case ts_symbol_string: - SHIFT(35); + SHIFT(25); case ts_aux_token5: - SHIFT(16); + SHIFT(12); + case ts_symbol_array: + SHIFT(25); + case ts_symbol_string: + SHIFT(25); + case ts_symbol_object: + SHIFT(25); + case ts_symbol_value: + SHIFT(38); case ts_aux_token1: SHIFT(3); default: - PARSE_ERROR(7, EXPECT({"token1", "token5", "string", "number", "value", "object", "array"})); + PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"})); } - case 54: + case 38: SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - SHIFT(24); case ts_aux_token3: - SHIFT(57); + SHIFT(39); + case ts_aux_token2: + SHIFT(18); case ts_aux_repeat_helper1: - SHIFT(55); + SHIFT(39); default: - PARSE_ERROR(3, EXPECT({"repeat_helper1", "token3", "token2"})); + PARSE_ERROR(3, EXPECT({"repeat_helper1", "token2", "token3"})); } - case 55: + case 39: SET_LEX_STATE(7); switch (LOOKAHEAD_SYM()) { case ts_aux_token7: - SHIFT(56); + SHIFT(40); default: PARSE_ERROR(1, EXPECT({"token7"})); } - case 56: + case 40: SET_LEX_STATE(6); switch (LOOKAHEAD_SYM()) { case ts_aux_token4: @@ -767,37 +617,19 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_ERROR(2, EXPECT({"token2", "token4"})); } - case 57: - SET_LEX_STATE(7); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token7: - SHIFT(58); - default: - PARSE_ERROR(1, EXPECT({"token7"})); - } - case 58: - SET_LEX_STATE(6); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token4: - REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); - case ts_aux_token2: - REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); - default: - PARSE_ERROR(2, EXPECT({"token2", "token4"})); - } - case 59: + case 41: SET_LEX_STATE(6); switch (LOOKAHEAD_SYM()) { case ts_aux_token4: REDUCE(ts_aux_repeat_helper2, 2, COLLAPSE({1, 0})); case ts_aux_token2: - SHIFT(9); + SHIFT(7); case ts_aux_repeat_helper2: - SHIFT(60); + SHIFT(42); default: PARSE_ERROR(3, EXPECT({"repeat_helper2", "token2", "token4"})); } - case 60: + case 42: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token4: @@ -805,7 +637,7 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_ERROR(1, EXPECT({"token4"})); } - case 61: + case 43: SET_LEX_STATE(6); switch (LOOKAHEAD_SYM()) { case ts_aux_token4: @@ -815,57 +647,27 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_ERROR(2, EXPECT({"token2", "token4"})); } - case 62: - SET_LEX_STATE(6); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token4: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - case ts_aux_token2: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - default: - PARSE_ERROR(2, EXPECT({"token2", "token4"})); - } - case 63: - SET_LEX_STATE(6); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token4: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - case ts_aux_token2: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - default: - PARSE_ERROR(2, EXPECT({"token2", "token4"})); - } - case 64: - SET_LEX_STATE(6); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token4: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - case ts_aux_token2: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - default: - PARSE_ERROR(2, EXPECT({"token2", "token4"})); - } - case 65: + case 44: SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - SHIFT(9); + SHIFT(7); case ts_aux_token3: - SHIFT(68); + SHIFT(45); case ts_aux_repeat_helper2: - SHIFT(66); + SHIFT(45); default: PARSE_ERROR(3, EXPECT({"repeat_helper2", "token3", "token2"})); } - case 66: + case 45: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token4: - SHIFT(67); + SHIFT(46); default: PARSE_ERROR(1, EXPECT({"token4"})); } - case 67: + case 46: SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { case ts_symbol___END__: @@ -873,79 +675,63 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_ERROR(1, EXPECT({"__END__"})); } - case 68: - SET_LEX_STATE(4); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token4: - SHIFT(69); - default: - PARSE_ERROR(1, EXPECT({"token4"})); - } - case 69: - SET_LEX_STATE(0); - switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: - REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); - default: - PARSE_ERROR(1, EXPECT({"__END__"})); - } - case 70: + case 47: SET_LEX_STATE(19); switch (LOOKAHEAD_SYM()) { case ts_symbol_string: - SHIFT(71); + SHIFT(48); default: PARSE_ERROR(1, EXPECT({"string"})); } - case 71: + case 48: SET_LEX_STATE(17); switch (LOOKAHEAD_SYM()) { case ts_aux_token6: - SHIFT(72); + SHIFT(49); default: PARSE_ERROR(1, EXPECT({"token6"})); } - case 72: + case 49: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_array: - SHIFT(34); - case ts_symbol_object: - SHIFT(33); case ts_symbol_number: - SHIFT(36); - case ts_symbol_value: - SHIFT(73); - case ts_symbol_string: - SHIFT(35); + SHIFT(25); case ts_aux_token5: - SHIFT(16); + SHIFT(12); + case ts_symbol_array: + SHIFT(25); + case ts_symbol_string: + SHIFT(25); + case ts_symbol_object: + SHIFT(25); + case ts_symbol_value: + SHIFT(50); case ts_aux_token1: SHIFT(3); default: - PARSE_ERROR(7, EXPECT({"token1", "token5", "string", "number", "value", "object", "array"})); + PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"})); } - case 73: + case 50: SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - SHIFT(24); case ts_aux_token3: - SHIFT(76); + SHIFT(51); + case ts_aux_token2: + SHIFT(18); case ts_aux_repeat_helper1: - SHIFT(74); + SHIFT(51); default: - PARSE_ERROR(3, EXPECT({"repeat_helper1", "token3", "token2"})); + PARSE_ERROR(3, EXPECT({"repeat_helper1", "token2", "token3"})); } - case 74: + case 51: SET_LEX_STATE(7); switch (LOOKAHEAD_SYM()) { case ts_aux_token7: - SHIFT(75); + SHIFT(52); default: PARSE_ERROR(1, EXPECT({"token7"})); } - case 75: + case 52: SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { case ts_symbol___END__: @@ -953,47 +739,7 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_ERROR(1, EXPECT({"__END__"})); } - case 76: - SET_LEX_STATE(7); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token7: - SHIFT(77); - default: - PARSE_ERROR(1, EXPECT({"token7"})); - } - case 77: - SET_LEX_STATE(0); - switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: - REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); - default: - PARSE_ERROR(1, EXPECT({"__END__"})); - } - case 78: - SET_LEX_STATE(0); - switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - default: - PARSE_ERROR(1, EXPECT({"__END__"})); - } - case 79: - SET_LEX_STATE(0); - switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - default: - PARSE_ERROR(1, EXPECT({"__END__"})); - } - case 80: - SET_LEX_STATE(0); - switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - default: - PARSE_ERROR(1, EXPECT({"__END__"})); - } - case 81: + case 53: SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { case ts_symbol___END__: diff --git a/src/compiler/build_tables/item.cpp b/src/compiler/build_tables/item.cpp index f0864866..d6619053 100644 --- a/src/compiler/build_tables/item.cpp +++ b/src/compiler/build_tables/item.cpp @@ -66,7 +66,7 @@ namespace tree_sitter { return lhs_eq && rules_eq; } - ParseItem::ParseItem(const Symbol &lhs, const rules::rule_ptr rule, const vector &consumed_symbols, const rules::Symbol &lookahead_sym) : + ParseItem::ParseItem(const Symbol &lhs, const rules::rule_ptr rule, const vector &consumed_symbols, const rules::Symbol &lookahead_sym) : Item(lhs, rule), consumed_symbols(consumed_symbols), lookahead_sym(lookahead_sym) {} diff --git a/src/compiler/build_tables/item.h b/src/compiler/build_tables/item.h index 7cc5a4b5..6dc2e535 100644 --- a/src/compiler/build_tables/item.h +++ b/src/compiler/build_tables/item.h @@ -30,11 +30,11 @@ namespace tree_sitter { class ParseItem : public Item { public: - ParseItem(const rules::Symbol &lhs, const rules::rule_ptr rule, const std::vector &consumed_symbols, const rules::Symbol &lookahead_sym); + ParseItem(const rules::Symbol &lhs, const rules::rule_ptr rule, const std::vector &consumed_symbols, const rules::Symbol &lookahead_sym); bool operator<(const ParseItem &other) const; bool operator==(const ParseItem &other) const; - const std::vector consumed_symbols; + const std::vector consumed_symbols; const rules::Symbol lookahead_sym; }; @@ -60,10 +60,10 @@ namespace std { struct hash { size_t operator()(const tree_sitter::build_tables::ParseItem &item) const { return - hash()(item.lhs) ^ + hash()(item.lhs.name) ^ hash()(*item.rule) ^ hash()(item.consumed_symbols.size()) ^ - hash()(item.lookahead_sym); + hash()(item.lookahead_sym.name); } }; diff --git a/src/compiler/build_tables/item_set_transitions.cpp b/src/compiler/build_tables/item_set_transitions.cpp index 16a042db..dc6759f8 100644 --- a/src/compiler/build_tables/item_set_transitions.cpp +++ b/src/compiler/build_tables/item_set_transitions.cpp @@ -44,7 +44,7 @@ namespace tree_sitter { auto rule = dynamic_pointer_cast(transition.first); if (rule.get()) { auto consumed_symbols = item.consumed_symbols; - consumed_symbols.push_back(*rule); + consumed_symbols.push_back(rule->is_auxiliary); auto new_item = ParseItem(item.lhs, transition.second, consumed_symbols, item.lookahead_sym); auto new_item_set = item_set_closure(ParseItemSet({ new_item }), grammar); item_transitions.add(rule, make_shared(new_item_set)); diff --git a/src/compiler/build_tables/perform.cpp b/src/compiler/build_tables/perform.cpp index 61e29ffc..8e6d5fed 100644 --- a/src/compiler/build_tables/perform.cpp +++ b/src/compiler/build_tables/perform.cpp @@ -61,20 +61,12 @@ namespace tree_sitter { } } - static vector reduce_flags(const vector &child_symbols) { - vector result; - for (auto symbol : child_symbols) { - result.push_back(symbol.is_auxiliary); - } - return result; - } - void add_reduce_actions(const ParseItemSet &item_set, size_t state_index) { for (ParseItem item : item_set) { if (item.is_done()) { ParseAction action = (item.lhs.name == START) ? ParseAction::Accept() : - ParseAction::Reduce(item.lhs, reduce_flags(item.consumed_symbols)); + ParseAction::Reduce(item.lhs, item.consumed_symbols); parse_table.add_action(state_index, item.lookahead_sym, action); } } diff --git a/src/compiler/rules/character.cpp b/src/compiler/rules/character.cpp index 044712f4..3d4fd643 100644 --- a/src/compiler/rules/character.cpp +++ b/src/compiler/rules/character.cpp @@ -49,19 +49,21 @@ namespace tree_sitter { value.range.max_character + "'"); } } - bool Character::operator==(const Rule &rule) const { const Character *other = dynamic_cast(&rule); - if (!other) return false; - 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; - return true; + return other && this->operator==(*other); } + 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; + return true; + } + size_t Character::hash_code() const { return typeid(this).hash_code() ^ hash()(to_string()); } diff --git a/src/compiler/rules/character.h b/src/compiler/rules/character.h index a5f5bcc0..afe9965d 100644 --- a/src/compiler/rules/character.h +++ b/src/compiler/rules/character.h @@ -44,6 +44,7 @@ namespace tree_sitter { Character(const std::vector &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; diff --git a/src/compiler/rules/symbol.cpp b/src/compiler/rules/symbol.cpp index 7ffd14be..de5a73ef 100644 --- a/src/compiler/rules/symbol.cpp +++ b/src/compiler/rules/symbol.cpp @@ -11,9 +11,13 @@ namespace tree_sitter { bool Symbol::operator==(const Rule &rule) const { const Symbol *other = dynamic_cast(&rule); - return other && (other->name == name) && (other->is_auxiliary == is_auxiliary); + return other && this->operator==(*other); } - + + bool Symbol::operator==(const Symbol &other) const { + return (other.name == name) && (other.is_auxiliary == is_auxiliary); + } + size_t Symbol::hash_code() const { return typeid(this).hash_code() ^ hash()(name) ^ hash()(is_auxiliary); } diff --git a/src/compiler/rules/symbol.h b/src/compiler/rules/symbol.h index ba8b15c2..6488cadb 100644 --- a/src/compiler/rules/symbol.h +++ b/src/compiler/rules/symbol.h @@ -11,6 +11,8 @@ namespace tree_sitter { Symbol(const std::string &name, bool is_auxiliary); bool operator==(const Rule& other) const; + bool operator==(const Symbol &other) const; + size_t hash_code() const; rule_ptr copy() const; std::string to_string() const;