From e8337a3c704303432fa3cf5cbca1bccc22616082 Mon Sep 17 00:00:00 2001 From: Max Brunsfeld Date: Thu, 6 Feb 2014 09:12:03 -0800 Subject: [PATCH] Fix errors in computing character set unions --- character_set_spec.cpp | 11 + spec/fixtures/parsers/arithmetic.c | 240 ++++++++++---------- spec/fixtures/parsers/json.c | 314 +++++++++++++-------------- src/compiler/rules/character_set.cpp | 39 ++-- src/compiler/rules/character_set.h | 3 + 5 files changed, 315 insertions(+), 292 deletions(-) diff --git a/character_set_spec.cpp b/character_set_spec.cpp index b01b9e13..471aa0c1 100644 --- a/character_set_spec.cpp +++ b/character_set_spec.cpp @@ -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))); + }); }); }); diff --git a/spec/fixtures/parsers/arithmetic.c b/spec/fixtures/parsers/arithmetic.c index 7f5c2b57..e1fc1ce9 100644 --- a/spec/fixtures/parsers/arithmetic.c +++ b/spec/fixtures/parsers/arithmetic.c @@ -2,28 +2,28 @@ #include 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({""})); 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({"", "*"})); 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({"", "+"})); 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({"", "*-+"})); 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(); diff --git a/spec/fixtures/parsers/json.c b/spec/fixtures/parsers/json.c index ed4722ee..1d10a3af 100644 --- a/spec/fixtures/parsers/json.c +++ b/spec/fixtures/parsers/json.c @@ -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({""})); 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({"-!", "#-"})); case 13: if ((LOOKAHEAD_CHAR() == '\"')) ADVANCE(14); if (!((LOOKAHEAD_CHAR() == '\"'))) ADVANCE(13); - LEX_ERROR(1, EXPECT({"<-\""})); + LEX_ERROR(1, EXPECT({""})); 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(); diff --git a/src/compiler/rules/character_set.cpp b/src/compiler/rules/character_set.cpp index 7d7fe5ff..6fb6aa48 100644 --- a/src/compiler/rules/character_set.cpp +++ b/src/compiler/rules/character_set.cpp @@ -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 ""; + case MAX_CHAR: + return ""; 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 ""; + 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({}) {} diff --git a/src/compiler/rules/character_set.h b/src/compiler/rules/character_set.h index 5e472f30..48b7d134 100644 --- a/src/compiler/rules/character_set.h +++ b/src/compiler/rules/character_set.h @@ -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;