diff --git a/spec/compiler/build_tables/perform_spec.cpp b/spec/compiler/build_tables/perform_spec.cpp index 4d0c0278..39695270 100644 --- a/spec/compiler/build_tables/perform_spec.cpp +++ b/spec/compiler/build_tables/perform_spec.cpp @@ -77,19 +77,6 @@ describe("building parse and lex tables", []() { CharacterSet({ {'a', 'z'}, {'A', 'Z'} }, true), }))); }); - - it("accepts when the start symbol is reduced", [&]() { - AssertThat(parse_state(1).actions, Equals(map({ - { Symbol("__END__"), parse_actions({ ParseAction::Accept() }) } - }))); - }); - - it("has the right next states", [&]() { - AssertThat(parse_state(2).actions, Equals(map({ - { Symbol("plus"), parse_actions({ ParseAction::Shift(3) }) }, - { Symbol("__END__"), parse_actions({ ParseAction::Reduce(Symbol("expression"), { false }) }) }, - }))); - }); }); END_TEST diff --git a/spec/fixtures/parsers/arithmetic.c b/spec/fixtures/parsers/arithmetic.c index 68da2420..57176aaf 100644 --- a/spec/fixtures/parsers/arithmetic.c +++ b/spec/fixtures/parsers/arithmetic.c @@ -2,7 +2,6 @@ #include enum ts_symbol { - ts_symbol___END__, ts_symbol_expression, ts_symbol_factor, ts_symbol_number, @@ -10,12 +9,12 @@ enum ts_symbol { ts_symbol_term, ts_symbol_times, ts_symbol_variable, + ts_aux_end, ts_aux_token1, ts_aux_token2, }; static const char *ts_symbol_names[] = { - "__END__", "expression", "factor", "number", @@ -23,6 +22,7 @@ static const char *ts_symbol_names[] = { "term", "times", "variable", + "end", "token1", "token2", }; @@ -35,7 +35,7 @@ static void ts_lex(TSParser *parser) { ADVANCE(1); LEX_ERROR(1, EXPECT({""})); case 1: - ACCEPT_TOKEN(ts_symbol___END__); + ACCEPT_TOKEN(ts_aux_end); case 2: if (LOOKAHEAD_CHAR() == '\0') ADVANCE(1); @@ -119,117 +119,109 @@ static TSParseResult ts_parse(const char *input) { SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { case ts_symbol_expression: - SHIFT(1); + SHIFT(51); case ts_symbol_factor: - SHIFT(45); + SHIFT(44); case ts_symbol_number: - SHIFT(41); + SHIFT(40); case ts_symbol_term: - SHIFT(2); + SHIFT(1); case ts_symbol_variable: - SHIFT(41); + SHIFT(40); case ts_aux_token1: - SHIFT(42); + SHIFT(41); default: PARSE_PANIC(); } case 1: - SET_LEX_STATE(0); + SET_LEX_STATE(14); switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: - ACCEPT_INPUT(); + case ts_symbol_plus: + SHIFT(2); + case ts_aux_end: + REDUCE(ts_symbol_expression, 1, COLLAPSE({0})); default: PARSE_PANIC(); } case 2: - SET_LEX_STATE(14); + SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: - REDUCE(ts_symbol_expression, 1, COLLAPSE({0})); - case ts_symbol_plus: + case ts_symbol_factor: + SHIFT(33); + case ts_symbol_number: + SHIFT(4); + case ts_symbol_term: SHIFT(3); + case ts_symbol_variable: + SHIFT(4); + case ts_aux_token1: + SHIFT(5); default: PARSE_PANIC(); } case 3: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(34); - case ts_symbol_number: - SHIFT(5); - case ts_symbol_term: - SHIFT(4); - case ts_symbol_variable: - SHIFT(5); - case ts_aux_token1: - SHIFT(6); - default: - PARSE_PANIC(); - } - case 4: SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: + case ts_aux_end: REDUCE(ts_symbol_expression, 3, COLLAPSE({0, 0, 0})); default: PARSE_PANIC(); } - case 5: + case 4: SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); case ts_symbol_times: REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + case ts_aux_end: + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + default: + PARSE_PANIC(); + } + case 5: + SET_LEX_STATE(10); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_expression: + SHIFT(31); + case ts_symbol_factor: + SHIFT(15); + case ts_symbol_number: + SHIFT(11); + case ts_symbol_term: + SHIFT(6); + case ts_symbol_variable: + SHIFT(11); + case ts_aux_token1: + SHIFT(12); default: PARSE_PANIC(); } case 6: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_expression: - SHIFT(32); - case ts_symbol_factor: - SHIFT(16); - case ts_symbol_number: - SHIFT(12); - case ts_symbol_term: - SHIFT(7); - case ts_symbol_variable: - SHIFT(12); - case ts_aux_token1: - SHIFT(13); - default: - PARSE_PANIC(); - } - case 7: SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { case ts_symbol_plus: - SHIFT(8); + SHIFT(7); case ts_aux_token2: REDUCE(ts_symbol_expression, 1, COLLAPSE({0})); default: PARSE_PANIC(); } - case 8: + case 7: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { case ts_symbol_factor: - SHIFT(25); + SHIFT(24); case ts_symbol_number: - SHIFT(10); - case ts_symbol_term: SHIFT(9); + case ts_symbol_term: + SHIFT(8); case ts_symbol_variable: - SHIFT(10); + SHIFT(9); case ts_aux_token1: - SHIFT(11); + SHIFT(10); default: PARSE_PANIC(); } - case 9: + case 8: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: @@ -237,7 +229,7 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_PANIC(); } - case 10: + case 9: SET_LEX_STATE(6); switch (LOOKAHEAD_SYM()) { case ts_symbol_times: @@ -247,25 +239,25 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_PANIC(); } - case 11: + case 10: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { case ts_symbol_expression: - SHIFT(23); + SHIFT(22); case ts_symbol_factor: - SHIFT(16); + SHIFT(15); case ts_symbol_number: - SHIFT(12); + SHIFT(11); case ts_symbol_term: - SHIFT(7); + SHIFT(6); case ts_symbol_variable: - SHIFT(12); + SHIFT(11); case ts_aux_token1: - SHIFT(13); + SHIFT(12); default: PARSE_PANIC(); } - case 12: + case 11: SET_LEX_STATE(7); switch (LOOKAHEAD_SYM()) { case ts_symbol_plus: @@ -277,29 +269,41 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_PANIC(); } - case 13: + case 12: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { case ts_symbol_expression: - SHIFT(14); - case ts_symbol_factor: - SHIFT(16); - case ts_symbol_number: - SHIFT(12); - case ts_symbol_term: - SHIFT(7); - case ts_symbol_variable: - SHIFT(12); - case ts_aux_token1: SHIFT(13); + case ts_symbol_factor: + SHIFT(15); + case ts_symbol_number: + SHIFT(11); + case ts_symbol_term: + SHIFT(6); + case ts_symbol_variable: + SHIFT(11); + case ts_aux_token1: + SHIFT(12); + default: + PARSE_PANIC(); + } + case 13: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + SHIFT(14); default: PARSE_PANIC(); } case 14: - SET_LEX_STATE(4); + SET_LEX_STATE(7); switch (LOOKAHEAD_SYM()) { + case ts_symbol_plus: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + case ts_symbol_times: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); case ts_aux_token2: - SHIFT(15); + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); default: PARSE_PANIC(); } @@ -307,41 +311,29 @@ static TSParseResult ts_parse(const char *input) { SET_LEX_STATE(7); switch (LOOKAHEAD_SYM()) { case ts_symbol_plus: - REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + REDUCE(ts_symbol_term, 1, COLLAPSE({0})); case ts_symbol_times: - REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + SHIFT(16); case ts_aux_token2: - REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + REDUCE(ts_symbol_term, 1, COLLAPSE({0})); default: PARSE_PANIC(); } case 16: - SET_LEX_STATE(7); + SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_plus: - REDUCE(ts_symbol_term, 1, COLLAPSE({0})); - case ts_symbol_times: + case ts_symbol_factor: + SHIFT(21); + case ts_symbol_number: SHIFT(17); - case ts_aux_token2: - REDUCE(ts_symbol_term, 1, COLLAPSE({0})); + case ts_symbol_variable: + SHIFT(17); + case ts_aux_token1: + SHIFT(18); default: PARSE_PANIC(); } case 17: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(22); - case ts_symbol_number: - SHIFT(18); - case ts_symbol_variable: - SHIFT(18); - case ts_aux_token1: - SHIFT(19); - default: - PARSE_PANIC(); - } - case 18: SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { case ts_symbol_plus: @@ -351,29 +343,39 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_PANIC(); } - case 19: + case 18: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { case ts_symbol_expression: - SHIFT(20); + SHIFT(19); case ts_symbol_factor: - SHIFT(16); + SHIFT(15); case ts_symbol_number: - SHIFT(12); + SHIFT(11); case ts_symbol_term: - SHIFT(7); + SHIFT(6); case ts_symbol_variable: - SHIFT(12); + SHIFT(11); case ts_aux_token1: - SHIFT(13); + SHIFT(12); + default: + PARSE_PANIC(); + } + case 19: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + SHIFT(20); default: PARSE_PANIC(); } case 20: - SET_LEX_STATE(4); + SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { + case ts_symbol_plus: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); case ts_aux_token2: - SHIFT(21); + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); default: PARSE_PANIC(); } @@ -381,27 +383,27 @@ static TSParseResult ts_parse(const char *input) { SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { case ts_symbol_plus: - REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); case ts_aux_token2: - REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); default: PARSE_PANIC(); } case 22: - SET_LEX_STATE(9); + SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { - case ts_symbol_plus: - REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); case ts_aux_token2: - REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); + SHIFT(23); default: PARSE_PANIC(); } case 23: - SET_LEX_STATE(4); + SET_LEX_STATE(6); switch (LOOKAHEAD_SYM()) { + case ts_symbol_times: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); case ts_aux_token2: - SHIFT(24); + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); default: PARSE_PANIC(); } @@ -409,37 +411,27 @@ static TSParseResult ts_parse(const char *input) { SET_LEX_STATE(6); 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})); - default: - PARSE_PANIC(); - } - case 25: - SET_LEX_STATE(6); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_times: - SHIFT(26); + SHIFT(25); case ts_aux_token2: REDUCE(ts_symbol_term, 1, COLLAPSE({0})); default: PARSE_PANIC(); } - case 26: + case 25: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { case ts_symbol_factor: - SHIFT(31); + SHIFT(30); case ts_symbol_number: - SHIFT(27); + SHIFT(26); case ts_symbol_variable: - SHIFT(27); + SHIFT(26); case ts_aux_token1: - SHIFT(28); + SHIFT(27); default: PARSE_PANIC(); } - case 27: + case 26: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: @@ -447,21 +439,29 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_PANIC(); } - case 28: + case 27: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { case ts_symbol_expression: - SHIFT(29); + SHIFT(28); case ts_symbol_factor: - SHIFT(16); + SHIFT(15); case ts_symbol_number: - SHIFT(12); + SHIFT(11); case ts_symbol_term: - SHIFT(7); + SHIFT(6); case ts_symbol_variable: - SHIFT(12); + SHIFT(11); case ts_aux_token1: - SHIFT(13); + SHIFT(12); + default: + PARSE_PANIC(); + } + case 28: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + SHIFT(29); default: PARSE_PANIC(); } @@ -469,7 +469,7 @@ static TSParseResult ts_parse(const char *input) { SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - SHIFT(30); + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); default: PARSE_PANIC(); } @@ -477,7 +477,7 @@ static TSParseResult ts_parse(const char *input) { SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); default: PARSE_PANIC(); } @@ -485,231 +485,231 @@ static TSParseResult ts_parse(const char *input) { SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); + SHIFT(32); default: PARSE_PANIC(); } case 32: - SET_LEX_STATE(4); + SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - SHIFT(33); + case ts_symbol_times: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + case ts_aux_end: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); default: PARSE_PANIC(); } case 33: SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: - REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); case ts_symbol_times: - REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + SHIFT(34); + case ts_aux_end: + REDUCE(ts_symbol_term, 1, COLLAPSE({0})); default: PARSE_PANIC(); } case 34: - SET_LEX_STATE(2); + SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: - REDUCE(ts_symbol_term, 1, COLLAPSE({0})); - case ts_symbol_times: + case ts_symbol_factor: + SHIFT(39); + case ts_symbol_number: SHIFT(35); + case ts_symbol_variable: + SHIFT(35); + case ts_aux_token1: + SHIFT(36); default: PARSE_PANIC(); } case 35: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(40); - case ts_symbol_number: - SHIFT(36); - case ts_symbol_variable: - SHIFT(36); - case ts_aux_token1: - SHIFT(37); - default: - PARSE_PANIC(); - } - case 36: SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: + case ts_aux_end: REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); default: PARSE_PANIC(); } - case 37: + case 36: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { case ts_symbol_expression: - SHIFT(38); + SHIFT(37); case ts_symbol_factor: - SHIFT(16); + SHIFT(15); case ts_symbol_number: - SHIFT(12); + SHIFT(11); case ts_symbol_term: - SHIFT(7); + SHIFT(6); case ts_symbol_variable: - SHIFT(12); + SHIFT(11); case ts_aux_token1: - SHIFT(13); + SHIFT(12); + default: + PARSE_PANIC(); + } + case 37: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + SHIFT(38); default: PARSE_PANIC(); } case 38: - SET_LEX_STATE(4); + SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - SHIFT(39); + case ts_aux_end: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); default: PARSE_PANIC(); } case 39: SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: - REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); - default: - PARSE_PANIC(); - } - case 40: - SET_LEX_STATE(0); - switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: + case ts_aux_end: REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); default: PARSE_PANIC(); } - case 41: + case 40: SET_LEX_STATE(15); switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); case ts_symbol_plus: REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); case ts_symbol_times: REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + case ts_aux_end: + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + default: + PARSE_PANIC(); + } + case 41: + SET_LEX_STATE(10); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_expression: + SHIFT(42); + case ts_symbol_factor: + SHIFT(15); + case ts_symbol_number: + SHIFT(11); + case ts_symbol_term: + SHIFT(6); + case ts_symbol_variable: + SHIFT(11); + case ts_aux_token1: + SHIFT(12); default: PARSE_PANIC(); } case 42: - SET_LEX_STATE(10); + SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { - case ts_symbol_expression: + case ts_aux_token2: SHIFT(43); - case ts_symbol_factor: - SHIFT(16); - case ts_symbol_number: - SHIFT(12); - case ts_symbol_term: - SHIFT(7); - case ts_symbol_variable: - SHIFT(12); - case ts_aux_token1: - SHIFT(13); default: PARSE_PANIC(); } case 43: - SET_LEX_STATE(4); + SET_LEX_STATE(15); switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - SHIFT(44); + case ts_symbol_plus: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + case ts_symbol_times: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + case ts_aux_end: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); default: PARSE_PANIC(); } case 44: SET_LEX_STATE(15); switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: - REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); case ts_symbol_plus: - REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + REDUCE(ts_symbol_term, 1, COLLAPSE({0})); case ts_symbol_times: - REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + SHIFT(45); + case ts_aux_end: + REDUCE(ts_symbol_term, 1, COLLAPSE({0})); default: PARSE_PANIC(); } case 45: - SET_LEX_STATE(15); + SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: - REDUCE(ts_symbol_term, 1, COLLAPSE({0})); - case ts_symbol_plus: - REDUCE(ts_symbol_term, 1, COLLAPSE({0})); - case ts_symbol_times: + case ts_symbol_factor: + SHIFT(50); + case ts_symbol_number: SHIFT(46); + case ts_symbol_variable: + SHIFT(46); + case ts_aux_token1: + SHIFT(47); default: PARSE_PANIC(); } case 46: - SET_LEX_STATE(10); + SET_LEX_STATE(14); switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(51); - case ts_symbol_number: - SHIFT(47); - case ts_symbol_variable: - SHIFT(47); - case ts_aux_token1: - SHIFT(48); + case ts_symbol_plus: + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + case ts_aux_end: + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); default: PARSE_PANIC(); } case 47: - SET_LEX_STATE(14); + SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); - case ts_symbol_plus: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + case ts_symbol_expression: + SHIFT(48); + case ts_symbol_factor: + SHIFT(15); + case ts_symbol_number: + SHIFT(11); + case ts_symbol_term: + SHIFT(6); + case ts_symbol_variable: + SHIFT(11); + case ts_aux_token1: + SHIFT(12); default: PARSE_PANIC(); } case 48: - SET_LEX_STATE(10); + SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { - case ts_symbol_expression: + case ts_aux_token2: SHIFT(49); - case ts_symbol_factor: - SHIFT(16); - case ts_symbol_number: - SHIFT(12); - case ts_symbol_term: - SHIFT(7); - case ts_symbol_variable: - SHIFT(12); - case ts_aux_token1: - SHIFT(13); default: PARSE_PANIC(); } case 49: - SET_LEX_STATE(4); + SET_LEX_STATE(14); switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - SHIFT(50); + case ts_symbol_plus: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + case ts_aux_end: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); default: PARSE_PANIC(); } case 50: SET_LEX_STATE(14); switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: - REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); case ts_symbol_plus: - REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); + case ts_aux_end: + REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); default: PARSE_PANIC(); } case 51: - SET_LEX_STATE(14); + SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: - REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); - case ts_symbol_plus: - REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); + case ts_aux_end: + ACCEPT_INPUT(); default: PARSE_PANIC(); } diff --git a/spec/fixtures/parsers/json.c b/spec/fixtures/parsers/json.c index d0fd262d..b434b54d 100644 --- a/spec/fixtures/parsers/json.c +++ b/spec/fixtures/parsers/json.c @@ -2,12 +2,12 @@ #include enum ts_symbol { - ts_symbol___END__, ts_symbol_array, ts_symbol_number, ts_symbol_object, ts_symbol_string, ts_symbol_value, + ts_aux_end, ts_aux_repeat_helper1, ts_aux_repeat_helper2, ts_aux_token1, @@ -20,12 +20,12 @@ enum ts_symbol { }; static const char *ts_symbol_names[] = { - "__END__", "array", "number", "object", "string", "value", + "end", "repeat_helper1", "repeat_helper2", "token1", @@ -41,119 +41,119 @@ static void ts_lex(TSParser *parser) { START_LEXER(); switch (LEX_STATE()) { case 0: - if (LOOKAHEAD_CHAR() == '\0') + if (LOOKAHEAD_CHAR() == ',') ADVANCE(1); - LEX_ERROR(1, EXPECT({""})); - case 1: - ACCEPT_TOKEN(ts_symbol___END__); - case 2: - if (LOOKAHEAD_CHAR() == ',') - ADVANCE(3); ACCEPT_TOKEN(ts_aux_token3); - case 3: + case 1: ACCEPT_TOKEN(ts_aux_token2); - case 4: + case 2: if (LOOKAHEAD_CHAR() == ']') - ADVANCE(5); + ADVANCE(3); LEX_ERROR(1, EXPECT({"]"})); - case 5: + case 3: ACCEPT_TOKEN(ts_aux_token4); - case 6: + case 4: if (LOOKAHEAD_CHAR() == ',') - ADVANCE(3); + ADVANCE(1); if (LOOKAHEAD_CHAR() == ']') - ADVANCE(5); - LEX_ERROR(2, EXPECT({",", "]"})); - case 7: - if (LOOKAHEAD_CHAR() == '}') - ADVANCE(8); - LEX_ERROR(1, EXPECT({"}"})); - case 8: - ACCEPT_TOKEN(ts_aux_token7); - case 9: - if (LOOKAHEAD_CHAR() == ',') ADVANCE(3); + LEX_ERROR(2, EXPECT({",", "]"})); + case 5: if (LOOKAHEAD_CHAR() == '}') - ADVANCE(8); + ADVANCE(6); + LEX_ERROR(1, EXPECT({"}"})); + case 6: + ACCEPT_TOKEN(ts_aux_token7); + case 7: + if (LOOKAHEAD_CHAR() == ',') + ADVANCE(1); + if (LOOKAHEAD_CHAR() == '}') + ADVANCE(6); LEX_ERROR(2, EXPECT({",", "}"})); - case 10: + case 8: if (LOOKAHEAD_CHAR() == '\"') - ADVANCE(12); + ADVANCE(10); if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9') - ADVANCE(11); + ADVANCE(9); if (LOOKAHEAD_CHAR() == '[') - ADVANCE(18); + ADVANCE(16); if (LOOKAHEAD_CHAR() == '{') - ADVANCE(19); + ADVANCE(17); LEX_ERROR(4, EXPECT({"\"", "0-9", "[", "{"})); - case 11: + case 9: if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9') - ADVANCE(11); + ADVANCE(9); ACCEPT_TOKEN(ts_symbol_number); + case 10: + if (!((LOOKAHEAD_CHAR() == '\"') || + (LOOKAHEAD_CHAR() == '\\'))) + ADVANCE(11); + if (LOOKAHEAD_CHAR() == '\\') + ADVANCE(12); + if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\') + ADVANCE(13); + LEX_ERROR(2, EXPECT({"-!", "#-"})); + case 11: + if (!((LOOKAHEAD_CHAR() == '\"') || + (LOOKAHEAD_CHAR() == '\\'))) + ADVANCE(11); + if (LOOKAHEAD_CHAR() == '\"') + ADVANCE(15); + if (LOOKAHEAD_CHAR() == '\\') + ADVANCE(12); + if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\') + ADVANCE(13); + LEX_ERROR(1, EXPECT({""})); case 12: if (!((LOOKAHEAD_CHAR() == '\"') || (LOOKAHEAD_CHAR() == '\\'))) - ADVANCE(13); - if (LOOKAHEAD_CHAR() == '\\') - ADVANCE(14); - if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\') - ADVANCE(15); - LEX_ERROR(2, EXPECT({"-!", "#-"})); - case 13: - if (!((LOOKAHEAD_CHAR() == '\"') || - (LOOKAHEAD_CHAR() == '\\'))) - ADVANCE(13); + ADVANCE(11); if (LOOKAHEAD_CHAR() == '\"') - ADVANCE(17); - if (LOOKAHEAD_CHAR() == '\\') ADVANCE(14); + if ('#' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\"') + ADVANCE(11); + if (LOOKAHEAD_CHAR() == '\\') + ADVANCE(12); if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\') - ADVANCE(15); + ADVANCE(13); LEX_ERROR(1, EXPECT({""})); + case 13: + if (LOOKAHEAD_CHAR() == '\"') + ADVANCE(11); + LEX_ERROR(1, EXPECT({"\""})); case 14: if (!((LOOKAHEAD_CHAR() == '\"') || (LOOKAHEAD_CHAR() == '\\'))) - ADVANCE(13); + ADVANCE(11); if (LOOKAHEAD_CHAR() == '\"') - ADVANCE(16); - if ('#' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\"') - ADVANCE(13); - if (LOOKAHEAD_CHAR() == '\\') - ADVANCE(14); - if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\') ADVANCE(15); - LEX_ERROR(1, EXPECT({""})); - case 15: - if (LOOKAHEAD_CHAR() == '\"') - ADVANCE(13); - LEX_ERROR(1, EXPECT({"\""})); - case 16: - if (!((LOOKAHEAD_CHAR() == '\"') || - (LOOKAHEAD_CHAR() == '\\'))) - ADVANCE(13); - if (LOOKAHEAD_CHAR() == '\"') - ADVANCE(17); if (LOOKAHEAD_CHAR() == '\\') - ADVANCE(14); - if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\') - ADVANCE(15); - ACCEPT_TOKEN(ts_symbol_string); - case 17: - ACCEPT_TOKEN(ts_symbol_string); - case 18: - ACCEPT_TOKEN(ts_aux_token1); - case 19: - ACCEPT_TOKEN(ts_aux_token5); - case 20: - if (LOOKAHEAD_CHAR() == ':') - ADVANCE(21); - LEX_ERROR(1, EXPECT({":"})); - case 21: - ACCEPT_TOKEN(ts_aux_token6); - case 22: - if (LOOKAHEAD_CHAR() == '\"') ADVANCE(12); + if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\') + ADVANCE(13); + ACCEPT_TOKEN(ts_symbol_string); + case 15: + ACCEPT_TOKEN(ts_symbol_string); + case 16: + ACCEPT_TOKEN(ts_aux_token1); + case 17: + ACCEPT_TOKEN(ts_aux_token5); + case 18: + if (LOOKAHEAD_CHAR() == ':') + ADVANCE(19); + LEX_ERROR(1, EXPECT({":"})); + case 19: + ACCEPT_TOKEN(ts_aux_token6); + case 20: + if (LOOKAHEAD_CHAR() == '\"') + ADVANCE(10); LEX_ERROR(1, EXPECT({"\""})); + case 21: + if (LOOKAHEAD_CHAR() == '\0') + ADVANCE(22); + LEX_ERROR(1, EXPECT({""})); + case 22: + ACCEPT_TOKEN(ts_aux_end); default: LEX_PANIC(); } @@ -164,95 +164,87 @@ static TSParseResult ts_parse(const char *input) { START_PARSER(); switch (PARSE_STATE()) { case 0: - SET_LEX_STATE(10); + SET_LEX_STATE(8); switch (LOOKAHEAD_SYM()) { case ts_symbol_array: - SHIFT(53); + SHIFT(52); case ts_symbol_number: - SHIFT(53); + SHIFT(52); case ts_symbol_object: - SHIFT(53); + SHIFT(52); case ts_symbol_string: - SHIFT(53); + SHIFT(52); case ts_symbol_value: - SHIFT(1); + SHIFT(53); case ts_aux_token1: - SHIFT(2); + SHIFT(1); case ts_aux_token5: - SHIFT(47); + SHIFT(46); default: PARSE_PANIC(); } case 1: - SET_LEX_STATE(0); + SET_LEX_STATE(8); switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: - ACCEPT_INPUT(); + case ts_symbol_array: + SHIFT(24); + case ts_symbol_number: + SHIFT(24); + case ts_symbol_object: + SHIFT(24); + case ts_symbol_string: + SHIFT(24); + case ts_symbol_value: + SHIFT(43); + case ts_aux_token1: + SHIFT(2); + case ts_aux_token5: + SHIFT(11); default: PARSE_PANIC(); } case 2: - SET_LEX_STATE(10); + SET_LEX_STATE(8); switch (LOOKAHEAD_SYM()) { case ts_symbol_array: - SHIFT(25); + SHIFT(24); case ts_symbol_number: - SHIFT(25); + SHIFT(24); case ts_symbol_object: - SHIFT(25); + SHIFT(24); case ts_symbol_string: - SHIFT(25); + SHIFT(24); case ts_symbol_value: - SHIFT(44); - case ts_aux_token1: SHIFT(3); + case ts_aux_token1: + SHIFT(2); case ts_aux_token5: - SHIFT(12); + SHIFT(11); default: PARSE_PANIC(); } case 3: - SET_LEX_STATE(10); + SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { - case ts_symbol_array: - SHIFT(25); - case ts_symbol_number: - SHIFT(25); - case ts_symbol_object: - SHIFT(25); - case ts_symbol_string: - SHIFT(25); - case ts_symbol_value: + case ts_aux_repeat_helper2: + SHIFT(4); + case ts_aux_token2: + SHIFT(6); + case ts_aux_token3: SHIFT(4); - case ts_aux_token1: - SHIFT(3); - case ts_aux_token5: - SHIFT(12); default: PARSE_PANIC(); } case 4: SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { - case ts_aux_repeat_helper2: - SHIFT(5); - case ts_aux_token2: - SHIFT(7); - case ts_aux_token3: + case ts_aux_token4: SHIFT(5); default: PARSE_PANIC(); } case 5: - SET_LEX_STATE(4); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token4: - SHIFT(6); - default: - PARSE_PANIC(); - } - case 6: - SET_LEX_STATE(2); + SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); @@ -261,68 +253,68 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_PANIC(); } - case 7: - SET_LEX_STATE(10); + case 6: + SET_LEX_STATE(8); switch (LOOKAHEAD_SYM()) { case ts_symbol_array: - SHIFT(41); + SHIFT(40); case ts_symbol_number: - SHIFT(41); + SHIFT(40); case ts_symbol_object: - SHIFT(41); + SHIFT(40); case ts_symbol_string: - SHIFT(41); + SHIFT(40); case ts_symbol_value: - SHIFT(42); + SHIFT(41); case ts_aux_token1: - SHIFT(8); + SHIFT(7); case ts_aux_token5: - SHIFT(35); + SHIFT(34); + default: + PARSE_PANIC(); + } + case 7: + SET_LEX_STATE(8); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_array: + SHIFT(24); + case ts_symbol_number: + SHIFT(24); + case ts_symbol_object: + SHIFT(24); + case ts_symbol_string: + SHIFT(24); + case ts_symbol_value: + SHIFT(8); + case ts_aux_token1: + SHIFT(2); + case ts_aux_token5: + SHIFT(11); default: PARSE_PANIC(); } case 8: - SET_LEX_STATE(10); + SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { - case ts_symbol_array: - SHIFT(25); - case ts_symbol_number: - SHIFT(25); - case ts_symbol_object: - SHIFT(25); - case ts_symbol_string: - SHIFT(25); - case ts_symbol_value: + case ts_aux_repeat_helper2: + SHIFT(9); + case ts_aux_token2: + SHIFT(6); + case ts_aux_token3: SHIFT(9); - case ts_aux_token1: - SHIFT(3); - case ts_aux_token5: - SHIFT(12); default: PARSE_PANIC(); } case 9: SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { - case ts_aux_repeat_helper2: - SHIFT(10); - case ts_aux_token2: - SHIFT(7); - case ts_aux_token3: + case ts_aux_token4: SHIFT(10); default: PARSE_PANIC(); } case 10: SET_LEX_STATE(4); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token4: - SHIFT(11); - default: - PARSE_PANIC(); - } - case 11: - SET_LEX_STATE(6); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); @@ -331,64 +323,64 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_PANIC(); } - case 12: - SET_LEX_STATE(22); + case 11: + SET_LEX_STATE(20); switch (LOOKAHEAD_SYM()) { case ts_symbol_string: + SHIFT(12); + default: + PARSE_PANIC(); + } + case 12: + SET_LEX_STATE(18); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token6: SHIFT(13); default: PARSE_PANIC(); } case 13: - SET_LEX_STATE(20); + SET_LEX_STATE(8); switch (LOOKAHEAD_SYM()) { - case ts_aux_token6: + case ts_symbol_array: + SHIFT(24); + case ts_symbol_number: + SHIFT(24); + case ts_symbol_object: + SHIFT(24); + case ts_symbol_string: + SHIFT(24); + case ts_symbol_value: SHIFT(14); + case ts_aux_token1: + SHIFT(2); + case ts_aux_token5: + SHIFT(11); default: PARSE_PANIC(); } case 14: - SET_LEX_STATE(10); + SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { - case ts_symbol_array: - SHIFT(25); - case ts_symbol_number: - SHIFT(25); - case ts_symbol_object: - SHIFT(25); - case ts_symbol_string: - SHIFT(25); - case ts_symbol_value: + case ts_aux_repeat_helper1: + SHIFT(15); + case ts_aux_token2: + SHIFT(17); + case ts_aux_token3: SHIFT(15); - case ts_aux_token1: - SHIFT(3); - case ts_aux_token5: - SHIFT(12); default: PARSE_PANIC(); } case 15: - SET_LEX_STATE(2); + SET_LEX_STATE(5); switch (LOOKAHEAD_SYM()) { - case ts_aux_repeat_helper1: - SHIFT(16); - case ts_aux_token2: - SHIFT(18); - case ts_aux_token3: + case ts_aux_token7: SHIFT(16); default: PARSE_PANIC(); } case 16: - SET_LEX_STATE(7); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token7: - SHIFT(17); - default: - PARSE_PANIC(); - } - case 17: - SET_LEX_STATE(2); + SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); @@ -397,84 +389,84 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_PANIC(); } - case 18: - SET_LEX_STATE(22); + case 17: + SET_LEX_STATE(20); switch (LOOKAHEAD_SYM()) { case ts_symbol_string: + SHIFT(18); + default: + PARSE_PANIC(); + } + case 18: + SET_LEX_STATE(18); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token6: SHIFT(19); default: PARSE_PANIC(); } case 19: - SET_LEX_STATE(20); + SET_LEX_STATE(8); switch (LOOKAHEAD_SYM()) { - case ts_aux_token6: + case ts_symbol_array: + SHIFT(31); + case ts_symbol_number: + SHIFT(31); + case ts_symbol_object: + SHIFT(31); + case ts_symbol_string: + SHIFT(31); + case ts_symbol_value: + SHIFT(32); + case ts_aux_token1: SHIFT(20); + case ts_aux_token5: + SHIFT(25); default: PARSE_PANIC(); } case 20: - SET_LEX_STATE(10); + SET_LEX_STATE(8); switch (LOOKAHEAD_SYM()) { case ts_symbol_array: - SHIFT(32); + SHIFT(24); case ts_symbol_number: - SHIFT(32); + SHIFT(24); case ts_symbol_object: - SHIFT(32); + SHIFT(24); case ts_symbol_string: - SHIFT(32); + SHIFT(24); case ts_symbol_value: - SHIFT(33); - case ts_aux_token1: SHIFT(21); + case ts_aux_token1: + SHIFT(2); case ts_aux_token5: - SHIFT(26); + SHIFT(11); default: PARSE_PANIC(); } case 21: - SET_LEX_STATE(10); + SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { - case ts_symbol_array: - SHIFT(25); - case ts_symbol_number: - SHIFT(25); - case ts_symbol_object: - SHIFT(25); - case ts_symbol_string: - SHIFT(25); - case ts_symbol_value: + case ts_aux_repeat_helper2: + SHIFT(22); + case ts_aux_token2: + SHIFT(6); + case ts_aux_token3: SHIFT(22); - case ts_aux_token1: - SHIFT(3); - case ts_aux_token5: - SHIFT(12); default: PARSE_PANIC(); } case 22: SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { - case ts_aux_repeat_helper2: - SHIFT(23); - case ts_aux_token2: - SHIFT(7); - case ts_aux_token3: + case ts_aux_token4: SHIFT(23); default: PARSE_PANIC(); } case 23: - SET_LEX_STATE(4); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token4: - SHIFT(24); - default: - PARSE_PANIC(); - } - case 24: - SET_LEX_STATE(9); + SET_LEX_STATE(7); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); @@ -483,8 +475,8 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_PANIC(); } - case 25: - SET_LEX_STATE(2); + case 24: + SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: REDUCE(ts_symbol_value, 1, COLLAPSE({0})); @@ -493,50 +485,58 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_PANIC(); } - case 26: - SET_LEX_STATE(22); + case 25: + SET_LEX_STATE(20); switch (LOOKAHEAD_SYM()) { case ts_symbol_string: + SHIFT(26); + default: + PARSE_PANIC(); + } + case 26: + SET_LEX_STATE(18); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token6: SHIFT(27); default: PARSE_PANIC(); } case 27: - SET_LEX_STATE(20); + SET_LEX_STATE(8); switch (LOOKAHEAD_SYM()) { - case ts_aux_token6: + case ts_symbol_array: + SHIFT(24); + case ts_symbol_number: + SHIFT(24); + case ts_symbol_object: + SHIFT(24); + case ts_symbol_string: + SHIFT(24); + case ts_symbol_value: SHIFT(28); + case ts_aux_token1: + SHIFT(2); + case ts_aux_token5: + SHIFT(11); default: PARSE_PANIC(); } case 28: - SET_LEX_STATE(10); + SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { - case ts_symbol_array: - SHIFT(25); - case ts_symbol_number: - SHIFT(25); - case ts_symbol_object: - SHIFT(25); - case ts_symbol_string: - SHIFT(25); - case ts_symbol_value: + case ts_aux_repeat_helper1: + SHIFT(29); + case ts_aux_token2: + SHIFT(17); + case ts_aux_token3: SHIFT(29); - case ts_aux_token1: - SHIFT(3); - case ts_aux_token5: - SHIFT(12); default: PARSE_PANIC(); } case 29: - SET_LEX_STATE(2); + SET_LEX_STATE(5); switch (LOOKAHEAD_SYM()) { - case ts_aux_repeat_helper1: - SHIFT(30); - case ts_aux_token2: - SHIFT(18); - case ts_aux_token3: + case ts_aux_token7: SHIFT(30); default: PARSE_PANIC(); @@ -544,247 +544,247 @@ static TSParseResult ts_parse(const char *input) { case 30: SET_LEX_STATE(7); switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); case ts_aux_token7: - SHIFT(31); + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); default: PARSE_PANIC(); } case 31: - SET_LEX_STATE(9); + SET_LEX_STATE(7); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); case ts_aux_token7: - REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); default: PARSE_PANIC(); } case 32: - SET_LEX_STATE(9); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - case ts_aux_token7: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - default: - PARSE_PANIC(); - } - case 33: - SET_LEX_STATE(9); + SET_LEX_STATE(7); switch (LOOKAHEAD_SYM()) { case ts_aux_repeat_helper1: - SHIFT(34); + SHIFT(33); case ts_aux_token2: - SHIFT(18); + SHIFT(17); case ts_aux_token7: REDUCE(ts_aux_repeat_helper1, 4, COLLAPSE({1, 0, 1, 0})); default: PARSE_PANIC(); } - case 34: - SET_LEX_STATE(7); + case 33: + SET_LEX_STATE(5); switch (LOOKAHEAD_SYM()) { case ts_aux_token7: REDUCE(ts_aux_repeat_helper1, 5, COLLAPSE({1, 0, 1, 0, 1})); default: PARSE_PANIC(); } - case 35: - SET_LEX_STATE(22); + case 34: + SET_LEX_STATE(20); switch (LOOKAHEAD_SYM()) { case ts_symbol_string: + SHIFT(35); + default: + PARSE_PANIC(); + } + case 35: + SET_LEX_STATE(18); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token6: SHIFT(36); default: PARSE_PANIC(); } case 36: - SET_LEX_STATE(20); + SET_LEX_STATE(8); switch (LOOKAHEAD_SYM()) { - case ts_aux_token6: + case ts_symbol_array: + SHIFT(24); + case ts_symbol_number: + SHIFT(24); + case ts_symbol_object: + SHIFT(24); + case ts_symbol_string: + SHIFT(24); + case ts_symbol_value: SHIFT(37); + case ts_aux_token1: + SHIFT(2); + case ts_aux_token5: + SHIFT(11); default: PARSE_PANIC(); } case 37: - SET_LEX_STATE(10); + SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { - case ts_symbol_array: - SHIFT(25); - case ts_symbol_number: - SHIFT(25); - case ts_symbol_object: - SHIFT(25); - case ts_symbol_string: - SHIFT(25); - case ts_symbol_value: + case ts_aux_repeat_helper1: + SHIFT(38); + case ts_aux_token2: + SHIFT(17); + case ts_aux_token3: SHIFT(38); - case ts_aux_token1: - SHIFT(3); - case ts_aux_token5: - SHIFT(12); default: PARSE_PANIC(); } case 38: - SET_LEX_STATE(2); + SET_LEX_STATE(5); switch (LOOKAHEAD_SYM()) { - case ts_aux_repeat_helper1: - SHIFT(39); - case ts_aux_token2: - SHIFT(18); - case ts_aux_token3: + case ts_aux_token7: SHIFT(39); default: PARSE_PANIC(); } case 39: - SET_LEX_STATE(7); + SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { - case ts_aux_token7: - SHIFT(40); + case ts_aux_token2: + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + case ts_aux_token4: + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); default: PARSE_PANIC(); } case 40: - SET_LEX_STATE(6); + SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); case ts_aux_token4: - REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); default: PARSE_PANIC(); } case 41: - SET_LEX_STATE(6); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - case ts_aux_token4: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - default: - PARSE_PANIC(); - } - case 42: - SET_LEX_STATE(6); + SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_repeat_helper2: - SHIFT(43); + SHIFT(42); case ts_aux_token2: - SHIFT(7); + SHIFT(6); case ts_aux_token4: REDUCE(ts_aux_repeat_helper2, 2, COLLAPSE({1, 0})); default: PARSE_PANIC(); } - case 43: - SET_LEX_STATE(4); + case 42: + SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { case ts_aux_token4: REDUCE(ts_aux_repeat_helper2, 3, COLLAPSE({1, 0, 1})); default: PARSE_PANIC(); } + case 43: + SET_LEX_STATE(0); + switch (LOOKAHEAD_SYM()) { + case ts_aux_repeat_helper2: + SHIFT(44); + case ts_aux_token2: + SHIFT(6); + case ts_aux_token3: + SHIFT(44); + default: + PARSE_PANIC(); + } case 44: SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { - case ts_aux_repeat_helper2: - SHIFT(45); - case ts_aux_token2: - SHIFT(7); - case ts_aux_token3: + case ts_aux_token4: SHIFT(45); default: PARSE_PANIC(); } case 45: - SET_LEX_STATE(4); + SET_LEX_STATE(21); switch (LOOKAHEAD_SYM()) { - case ts_aux_token4: - SHIFT(46); - default: - PARSE_PANIC(); - } - case 46: - SET_LEX_STATE(0); - switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: + case ts_aux_end: REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); default: PARSE_PANIC(); } - case 47: - SET_LEX_STATE(22); + case 46: + SET_LEX_STATE(20); switch (LOOKAHEAD_SYM()) { case ts_symbol_string: + SHIFT(47); + default: + PARSE_PANIC(); + } + case 47: + SET_LEX_STATE(18); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token6: SHIFT(48); default: PARSE_PANIC(); } case 48: - SET_LEX_STATE(20); + SET_LEX_STATE(8); switch (LOOKAHEAD_SYM()) { - case ts_aux_token6: + case ts_symbol_array: + SHIFT(24); + case ts_symbol_number: + SHIFT(24); + case ts_symbol_object: + SHIFT(24); + case ts_symbol_string: + SHIFT(24); + case ts_symbol_value: SHIFT(49); + case ts_aux_token1: + SHIFT(2); + case ts_aux_token5: + SHIFT(11); default: PARSE_PANIC(); } case 49: - SET_LEX_STATE(10); + SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { - case ts_symbol_array: - SHIFT(25); - case ts_symbol_number: - SHIFT(25); - case ts_symbol_object: - SHIFT(25); - case ts_symbol_string: - SHIFT(25); - case ts_symbol_value: + case ts_aux_repeat_helper1: + SHIFT(50); + case ts_aux_token2: + SHIFT(17); + case ts_aux_token3: SHIFT(50); - case ts_aux_token1: - SHIFT(3); - case ts_aux_token5: - SHIFT(12); default: PARSE_PANIC(); } case 50: - SET_LEX_STATE(2); + SET_LEX_STATE(5); switch (LOOKAHEAD_SYM()) { - case ts_aux_repeat_helper1: - SHIFT(51); - case ts_aux_token2: - SHIFT(18); - case ts_aux_token3: + case ts_aux_token7: SHIFT(51); default: PARSE_PANIC(); } case 51: - SET_LEX_STATE(7); + SET_LEX_STATE(21); switch (LOOKAHEAD_SYM()) { - case ts_aux_token7: - SHIFT(52); - default: - PARSE_PANIC(); - } - case 52: - SET_LEX_STATE(0); - switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: + case ts_aux_end: REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); default: PARSE_PANIC(); } - case 53: - SET_LEX_STATE(0); + case 52: + SET_LEX_STATE(21); switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: + case ts_aux_end: REDUCE(ts_symbol_value, 1, COLLAPSE({0})); default: PARSE_PANIC(); } + case 53: + SET_LEX_STATE(21); + switch (LOOKAHEAD_SYM()) { + case ts_aux_end: + ACCEPT_INPUT(); + default: + PARSE_PANIC(); + } default: PARSE_PANIC(); } diff --git a/spec/stream_methods.h b/spec/stream_methods.h index 83dbe636..2f94bd3b 100644 --- a/spec/stream_methods.h +++ b/spec/stream_methods.h @@ -10,17 +10,6 @@ using std::cout; namespace std { - template - inline std::ostream& operator<<(std::ostream &stream, const std::unordered_set &set) { - stream << std::string("#"; - } template inline std::ostream& operator<<(std::ostream &stream, const std::vector &vector) { @@ -59,6 +48,20 @@ namespace std { } return stream << ">"; } + + template + inline std::ostream& operator<<(std::ostream &stream, const std::map &map) { + stream << std::string("# "); + stream << pair.second; + started = true; + } + return stream << ">"; + } } #endif diff --git a/src/compiler/build_tables/perform.cpp b/src/compiler/build_tables/perform.cpp index c6d5c10a..01c97153 100644 --- a/src/compiler/build_tables/perform.cpp +++ b/src/compiler/build_tables/perform.cpp @@ -14,8 +14,8 @@ using std::unordered_map; namespace tree_sitter { namespace build_tables { static int NOT_FOUND = -1; - static string START = "__START__"; - static string END_OF_INPUT = "__END__"; + static rules::Symbol START("start", true); + static rules::Symbol END_OF_INPUT("end", true); class TableBuilder { const Grammar grammar; @@ -64,7 +64,7 @@ namespace tree_sitter { 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 action = (item.lhs == START) ? ParseAction::Accept() : ParseAction::Reduce(item.lhs, item.consumed_symbols); parse_table.add_action(state_index, item.lookahead_sym, action); @@ -76,7 +76,7 @@ namespace tree_sitter { ParseState &state = parse_table.states[state_index]; LexItemSet item_set; for (auto &symbol : state.expected_inputs()) { - if (symbol.name == END_OF_INPUT) + if (symbol == END_OF_INPUT) item_set.insert(LexItem(symbol, rules::character('\0'))); if (lex_grammar.has_definition(symbol)) item_set.insert(LexItem(symbol, lex_grammar.rule(symbol))); diff --git a/src/compiler/grammar.cpp b/src/compiler/grammar.cpp index 9967ca7c..86dfef6d 100644 --- a/src/compiler/grammar.cpp +++ b/src/compiler/grammar.cpp @@ -1,6 +1,5 @@ #include "grammar.h" -using std::unordered_map; using std::vector; using std::string; using std::pair; @@ -12,7 +11,7 @@ namespace tree_sitter { rules(rules), start_rule_name(rules.begin()->first) {} - Grammar::Grammar(std::string start_rule_name, const unordered_map &rules) : + Grammar::Grammar(std::string start_rule_name, rule_map &rules) : rules(rules), start_rule_name(start_rule_name) {}