diff --git a/spec/compiler/build_tables/item_set_closure_spec.cpp b/spec/compiler/build_tables/item_set_closure_spec.cpp index d55fcf24..d242ac47 100644 --- a/spec/compiler/build_tables/item_set_closure_spec.cpp +++ b/spec/compiler/build_tables/item_set_closure_spec.cpp @@ -41,8 +41,7 @@ describe("computing closures of item sets", []() { ParseItem(Symbol("E"), grammar.rule(Symbol("E")), {}, Symbol("__END__")), }))); - auto sym1 = rules::Symbol("v"); - ParseItemSet next_item_set = *sym_transitions(item_set, grammar)[sym1]; + ParseItemSet next_item_set = sym_transitions(item_set, grammar)[Symbol("v")]; AssertThat(next_item_set, Equals(ParseItemSet({ ParseItem(Symbol("F"), rules::blank(), { false }, Symbol("__END__")), ParseItem(Symbol("F"), rules::blank(), { false }, Symbol("*")), diff --git a/spec/compiler/build_tables/rule_transitions_spec.cpp b/spec/compiler/build_tables/rule_transitions_spec.cpp index e977d401..bc1511d4 100644 --- a/spec/compiler/build_tables/rule_transitions_spec.cpp +++ b/spec/compiler/build_tables/rule_transitions_spec.cpp @@ -4,32 +4,116 @@ using namespace rules; using namespace build_tables; +template +class rule_map : public map { +public: + bool operator==(const map &other) const { + if (this->size() != other.size()) return false; + for (const auto &pair : *this) { + auto other_pair = other.find(pair.first); + if (other_pair == other.end()) return false; + if (!pair.second->operator==(*other_pair->second)) return false; + } + return true; + } + + rule_map(const initializer_list> &list) : map(list) {} +}; + START_TEST describe("rule transitions", []() { - auto symbol1 = sym("1"); - auto symbol2 = sym("2"); - auto symbol3 = sym("3"); - auto symbol4 = sym("4"); - auto char1 = character({ 'a' }); - it("handles symbols", [&]() { AssertThat( - sym_transitions(symbol1), - Equals(transition_map({ - { symbol1, blank() } + sym_transitions(sym("1")), + Equals(rule_map({ + { Symbol("1"), blank() } }))); }); it("handles choices", [&]() { AssertThat( - sym_transitions(choice({ symbol1, symbol2 })), - Equals(transition_map({ - { symbol1, blank() }, - { symbol2, blank() } + sym_transitions(choice({ sym("1"), sym("2") })), + Equals(rule_map({ + { Symbol("1"), blank() }, + { Symbol("2"), blank() } }))); }); + it("handles sequences", [&]() { + AssertThat( + sym_transitions(seq({ sym("1"), sym("2") })), + Equals(rule_map({ + { Symbol("1"), sym("2") } + }))); + }); + + it("handles long sequences", [&]() { + AssertThat( + sym_transitions(seq({ + sym("1"), + sym("2"), + sym("3"), + sym("4") + })), + Equals(rule_map({ + { Symbol("1"), seq({ sym("2"), sym("3"), sym("4") }) } + }))); + }); + + it("handles sequences whose left sides can be blank", [&]() { + AssertThat( + sym_transitions(seq({ + choice({ + sym("1"), + blank(), + }), + seq({ + sym("1"), + sym("2") + }) + })), Equals(rule_map({ + { Symbol("1"), choice({ seq({ sym("1"), sym("2") }), sym("2"), }) } + }))); + }); + + it("handles choices with common starting symbols", [&]() { + AssertThat( + sym_transitions( + choice({ + seq({ sym("1"), sym("2") }), + seq({ sym("1"), sym("3") }) })), + Equals(rule_map({ + { Symbol("1"), choice({ sym("2"), sym("3") }) } + }))); + }); + + it("handles characters", [&]() { + AssertThat( + char_transitions(character('1')), + Equals(rule_map({ + { CharacterSet({ '1' }), blank() } + }))); + }); + + it("handles strings", [&]() { + AssertThat( + char_transitions(str("bad")), + Equals(rule_map({ + { CharacterSet({ 'b' }, true), seq({ character('a'), character('d') }) } + }))); + }); + + it("handles patterns", [&]() { + AssertThat( + char_transitions(pattern("a|b")), + Equals(rule_map({ + { CharacterSet({ 'a' }), blank() }, + { CharacterSet({ 'b' }), blank() } + }))); + }); + + it("handles choices between overlapping character sets", [&]() { AssertThat( char_transitions(choice({ @@ -39,108 +123,35 @@ describe("rule transitions", []() { seq({ character({ { 'm', 'z' } }), sym("y") }) })), - Equals(transition_map({ - { character({ {'a','l'} }), sym("x") }, - { character({ {'m','s'} }), choice({ sym("x"), sym("y") }) }, - { character({ {'t','z'} }), sym("y") }, + Equals(rule_map({ + { CharacterSet({ {'a','l'} }, true), sym("x") }, + { CharacterSet({ {'m','s'} }, true), choice({ sym("x"), sym("y") }) }, + { CharacterSet({ {'t','z'} }, true), sym("y") }, }))); }); - - it("handles sequences", [&]() { - AssertThat( - sym_transitions(seq({ symbol1, symbol2 })), - Equals(transition_map({ - { symbol1, symbol2 } - }))); - }); - - it("handles long sequences", [&]() { - AssertThat( - sym_transitions(seq({ - symbol1, - symbol2, - symbol3, - symbol4 - })), - Equals(transition_map({ - { symbol1, seq({ symbol2, symbol3, symbol4 }) } - }))); - }); - - it("handles sequences whose left sides can be blank", [&]() { - AssertThat( - sym_transitions(seq({ - choice({ - symbol1, - blank(), - }), - seq({ - symbol1, - symbol2 - }) - })), Equals(transition_map({ - { symbol1, choice({ seq({ symbol1, symbol2 }), symbol2, }) } - }))); - }); - - it("handles choices with common starting symbols", [&]() { - AssertThat( - sym_transitions( - choice({ - seq({ symbol1, symbol2 }), - seq({ symbol1, symbol3 }) })), - Equals(transition_map({ - { symbol1, choice({ symbol2, symbol3 }) } - }))); - }); - - it("handles characters", [&]() { - AssertThat( - char_transitions(char1), - Equals(transition_map({ - { char1, blank() } - }))); - }); - - it("handles strings", [&]() { - AssertThat( - char_transitions(str("bad")), - Equals(transition_map({ - { character({ 'b' }, true), seq({ character('a'), character('d') }) } - }))); - }); - - it("handles patterns", [&]() { - AssertThat( - char_transitions(pattern("a|b")), - Equals(transition_map({ - { character({ 'a' }, true), blank() }, - { character({ 'b' }, true), blank() } - }))); - }); - + it("handles repeats", [&]() { rule_ptr rule = repeat(str("ab")); AssertThat( char_transitions(rule), - Equals(transition_map({ - { - character({ 'a' }, true), - seq({ - character('b'), - choice({ - rule, - blank() + Equals(rule_map({ + { + CharacterSet({ 'a' }), + seq({ + character('b'), + choice({ + rule, + blank() + }) }) - }) - }}))); + }}))); rule = repeat(str("a")); AssertThat( char_transitions(rule), - Equals(transition_map({ + Equals(rule_map({ { - character({ 'a' }, true), + CharacterSet({ 'a' }), choice({ rule, blank() @@ -158,14 +169,14 @@ describe("rule transitions", []() { character('"'), }); - AssertThat(char_transitions(rule), Equals(transition_map({ - { character({ '"' }, false), seq({ + AssertThat(char_transitions(rule), Equals(rule_map({ + { CharacterSet({ '"' }, false), seq({ choice({ repeat(character({ '"' }, false)), blank(), }), character('"'), }) }, - { character({ '"' }, true), blank() }, + { CharacterSet({ '"' }, true), blank() }, }))); }); }); diff --git a/spec/fixtures/parsers/arithmetic.c b/spec/fixtures/parsers/arithmetic.c index 57176aaf..fd90ebe1 100644 --- a/spec/fixtures/parsers/arithmetic.c +++ b/spec/fixtures/parsers/arithmetic.c @@ -39,11 +39,11 @@ static void ts_lex(TSParser *parser) { case 2: if (LOOKAHEAD_CHAR() == '\0') ADVANCE(1); - if (LOOKAHEAD_CHAR() == '*') + if (LOOKAHEAD_CHAR() == '+') ADVANCE(3); - LEX_ERROR(2, EXPECT({"", "*"})); + LEX_ERROR(2, EXPECT({"", "+"})); case 3: - ACCEPT_TOKEN(ts_symbol_times); + ACCEPT_TOKEN(ts_symbol_plus); case 4: if (LOOKAHEAD_CHAR() == ')') ADVANCE(5); @@ -53,34 +53,30 @@ static void ts_lex(TSParser *parser) { case 6: if (LOOKAHEAD_CHAR() == ')') ADVANCE(5); - if (LOOKAHEAD_CHAR() == '*') + if (LOOKAHEAD_CHAR() == '+') ADVANCE(3); - LEX_ERROR(1, EXPECT({")-*"})); + LEX_ERROR(2, EXPECT({")", "+"})); case 7: if (LOOKAHEAD_CHAR() == ')') ADVANCE(5); if (LOOKAHEAD_CHAR() == '*') - ADVANCE(3); - if (LOOKAHEAD_CHAR() == '+') ADVANCE(8); + if (LOOKAHEAD_CHAR() == '+') + ADVANCE(3); LEX_ERROR(1, EXPECT({")-+"})); case 8: - ACCEPT_TOKEN(ts_symbol_plus); + ACCEPT_TOKEN(ts_symbol_times); case 9: - if (LOOKAHEAD_CHAR() == ')') - ADVANCE(5); - if (LOOKAHEAD_CHAR() == '+') - ADVANCE(8); - LEX_ERROR(2, EXPECT({")", "+"})); - case 10: if (LOOKAHEAD_CHAR() == '(') - ADVANCE(13); + ADVANCE(10); if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9') ADVANCE(11); if (('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') || ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z')) ADVANCE(12); LEX_ERROR(4, EXPECT({"(", "0-9", "A-Z", "a-z"})); + case 10: + ACCEPT_TOKEN(ts_aux_token1); case 11: if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9') ADVANCE(11); @@ -91,21 +87,25 @@ static void ts_lex(TSParser *parser) { ADVANCE(12); ACCEPT_TOKEN(ts_symbol_variable); case 13: - ACCEPT_TOKEN(ts_aux_token1); + if (LOOKAHEAD_CHAR() == ')') + ADVANCE(5); + if (LOOKAHEAD_CHAR() == '*') + ADVANCE(8); + LEX_ERROR(1, EXPECT({")-*"})); case 14: if (LOOKAHEAD_CHAR() == '\0') ADVANCE(1); - if (LOOKAHEAD_CHAR() == '+') + if (LOOKAHEAD_CHAR() == '*') ADVANCE(8); - LEX_ERROR(2, EXPECT({"", "+"})); + if (LOOKAHEAD_CHAR() == '+') + ADVANCE(3); + LEX_ERROR(2, EXPECT({"", "*-+"})); case 15: if (LOOKAHEAD_CHAR() == '\0') ADVANCE(1); if (LOOKAHEAD_CHAR() == '*') - ADVANCE(3); - if (LOOKAHEAD_CHAR() == '+') ADVANCE(8); - LEX_ERROR(2, EXPECT({"", "*-+"})); + LEX_ERROR(2, EXPECT({"", "*"})); default: LEX_PANIC(); } @@ -116,322 +116,266 @@ static TSParseResult ts_parse(const char *input) { START_PARSER(); switch (PARSE_STATE()) { case 0: - SET_LEX_STATE(10); + SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { case ts_symbol_expression: - SHIFT(51); - case ts_symbol_factor: - SHIFT(44); - case ts_symbol_number: - SHIFT(40); - case ts_symbol_term: SHIFT(1); + case ts_symbol_factor: + SHIFT(2); + case ts_symbol_number: + SHIFT(34); + case ts_symbol_term: + SHIFT(35); case ts_symbol_variable: - SHIFT(40); + SHIFT(34); case ts_aux_token1: - SHIFT(41); + SHIFT(49); default: PARSE_PANIC(); } case 1: - SET_LEX_STATE(14); + SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { - case ts_symbol_plus: - SHIFT(2); case ts_aux_end: - REDUCE(ts_symbol_expression, 1, COLLAPSE({0})); + ACCEPT_INPUT(); default: PARSE_PANIC(); } case 2: - SET_LEX_STATE(10); + SET_LEX_STATE(14); switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(33); - case ts_symbol_number: - SHIFT(4); - case ts_symbol_term: + case ts_symbol_plus: + REDUCE(ts_symbol_term, 1, COLLAPSE({0})); + case ts_symbol_times: SHIFT(3); - case ts_symbol_variable: - SHIFT(4); - case ts_aux_token1: - SHIFT(5); + case ts_aux_end: + REDUCE(ts_symbol_term, 1, COLLAPSE({0})); default: PARSE_PANIC(); } case 3: - SET_LEX_STATE(0); + SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { - case ts_aux_end: - REDUCE(ts_symbol_expression, 3, COLLAPSE({0, 0, 0})); + case ts_symbol_factor: + SHIFT(4); + case ts_symbol_number: + SHIFT(5); + case ts_symbol_variable: + SHIFT(5); + case ts_aux_token1: + SHIFT(6); default: PARSE_PANIC(); } case 4: SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { - case ts_symbol_times: + case ts_symbol_plus: + 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 5: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + 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 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(9); switch (LOOKAHEAD_SYM()) { - case ts_symbol_plus: + case ts_symbol_expression: SHIFT(7); + case ts_symbol_factor: + SHIFT(9); + case ts_symbol_number: + SHIFT(16); + case ts_symbol_term: + SHIFT(17); + case ts_symbol_variable: + SHIFT(16); + case ts_aux_token1: + SHIFT(26); + default: + PARSE_PANIC(); + } + case 7: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + SHIFT(8); + default: + PARSE_PANIC(); + } + case 8: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + 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 9: + SET_LEX_STATE(7); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_plus: + REDUCE(ts_symbol_term, 1, COLLAPSE({0})); + case ts_symbol_times: + SHIFT(10); + case ts_aux_token2: + REDUCE(ts_symbol_term, 1, COLLAPSE({0})); + default: + PARSE_PANIC(); + } + case 10: + SET_LEX_STATE(9); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_factor: + SHIFT(11); + case ts_symbol_number: + SHIFT(12); + case ts_symbol_variable: + SHIFT(12); + case ts_aux_token1: + SHIFT(13); + default: + PARSE_PANIC(); + } + case 11: + SET_LEX_STATE(6); + 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})); + default: + PARSE_PANIC(); + } + case 12: + SET_LEX_STATE(6); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_plus: + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + case ts_aux_token2: + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + default: + PARSE_PANIC(); + } + case 13: + SET_LEX_STATE(9); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_expression: + SHIFT(14); + case ts_symbol_factor: + SHIFT(9); + case ts_symbol_number: + SHIFT(16); + case ts_symbol_term: + SHIFT(17); + case ts_symbol_variable: + SHIFT(16); + case ts_aux_token1: + SHIFT(26); + default: + PARSE_PANIC(); + } + case 14: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + SHIFT(15); + default: + PARSE_PANIC(); + } + case 15: + SET_LEX_STATE(6); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_plus: + 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 16: + SET_LEX_STATE(7); + switch (LOOKAHEAD_SYM()) { + 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_token2: + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + default: + PARSE_PANIC(); + } + case 17: + SET_LEX_STATE(6); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_plus: + SHIFT(18); case ts_aux_token2: REDUCE(ts_symbol_expression, 1, COLLAPSE({0})); default: PARSE_PANIC(); } - case 7: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(24); - case ts_symbol_number: - SHIFT(9); - case ts_symbol_term: - SHIFT(8); - case ts_symbol_variable: - SHIFT(9); - case ts_aux_token1: - SHIFT(10); - default: - PARSE_PANIC(); - } - case 8: - SET_LEX_STATE(4); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - REDUCE(ts_symbol_expression, 3, COLLAPSE({0, 0, 0})); - default: - PARSE_PANIC(); - } - case 9: - SET_LEX_STATE(6); - 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})); - default: - PARSE_PANIC(); - } - case 10: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_expression: - SHIFT(22); - 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 11: - SET_LEX_STATE(7); - switch (LOOKAHEAD_SYM()) { - 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_token2: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); - default: - PARSE_PANIC(); - } - case 12: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_expression: - 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(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: - REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); - default: - PARSE_PANIC(); - } - case 15: - SET_LEX_STATE(7); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_plus: - REDUCE(ts_symbol_term, 1, COLLAPSE({0})); - case ts_symbol_times: - SHIFT(16); - case ts_aux_token2: - REDUCE(ts_symbol_term, 1, COLLAPSE({0})); - default: - PARSE_PANIC(); - } - case 16: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(21); - case ts_symbol_number: - SHIFT(17); - case ts_symbol_variable: - SHIFT(17); - case ts_aux_token1: - SHIFT(18); - default: - PARSE_PANIC(); - } - case 17: + case 18: SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { - case ts_symbol_plus: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); - case ts_aux_token2: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); - default: - PARSE_PANIC(); - } - case 18: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_expression: - SHIFT(19); case ts_symbol_factor: - SHIFT(15); + SHIFT(19); case ts_symbol_number: - SHIFT(11); + SHIFT(29); case ts_symbol_term: - SHIFT(6); + SHIFT(30); case ts_symbol_variable: - SHIFT(11); + SHIFT(29); case ts_aux_token1: - SHIFT(12); + SHIFT(31); default: PARSE_PANIC(); } case 19: - SET_LEX_STATE(4); + SET_LEX_STATE(13); switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: + case ts_symbol_times: SHIFT(20); + case ts_aux_token2: + REDUCE(ts_symbol_term, 1, COLLAPSE({0})); default: PARSE_PANIC(); } case 20: SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { - case ts_symbol_plus: - 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_factor: + SHIFT(21); + case ts_symbol_number: + SHIFT(22); + case ts_symbol_variable: + SHIFT(22); + case ts_aux_token1: + SHIFT(23); default: PARSE_PANIC(); } case 21: - 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})); default: PARSE_PANIC(); } case 22: - SET_LEX_STATE(4); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - SHIFT(23); - default: - PARSE_PANIC(); - } - case 23: - 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 24: - SET_LEX_STATE(6); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_times: - SHIFT(25); - case ts_aux_token2: - REDUCE(ts_symbol_term, 1, COLLAPSE({0})); - default: - PARSE_PANIC(); - } - case 25: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(30); - case ts_symbol_number: - SHIFT(26); - case ts_symbol_variable: - SHIFT(26); - case ts_aux_token1: - SHIFT(27); - default: - PARSE_PANIC(); - } - case 26: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: @@ -439,33 +383,33 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_PANIC(); } - case 27: - SET_LEX_STATE(10); + case 23: + SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { case ts_symbol_expression: - SHIFT(28); + SHIFT(24); case ts_symbol_factor: - SHIFT(15); + SHIFT(9); case ts_symbol_number: - SHIFT(11); + SHIFT(16); case ts_symbol_term: - SHIFT(6); + SHIFT(17); case ts_symbol_variable: - SHIFT(11); + SHIFT(16); case ts_aux_token1: - SHIFT(12); + SHIFT(26); default: PARSE_PANIC(); } - case 28: + case 24: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - SHIFT(29); + SHIFT(25); default: PARSE_PANIC(); } - case 29: + case 25: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: @@ -473,95 +417,157 @@ static TSParseResult ts_parse(const char *input) { default: PARSE_PANIC(); } + case 26: + SET_LEX_STATE(9); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_expression: + SHIFT(27); + case ts_symbol_factor: + SHIFT(9); + case ts_symbol_number: + SHIFT(16); + case ts_symbol_term: + SHIFT(17); + case ts_symbol_variable: + SHIFT(16); + case ts_aux_token1: + SHIFT(26); + default: + PARSE_PANIC(); + } + case 27: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + SHIFT(28); + default: + PARSE_PANIC(); + } + case 28: + 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: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + default: + PARSE_PANIC(); + } + case 29: + SET_LEX_STATE(13); + 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})); + default: + PARSE_PANIC(); + } case 30: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); + REDUCE(ts_symbol_expression, 3, COLLAPSE({0, 0, 0})); default: PARSE_PANIC(); } case 31: - SET_LEX_STATE(4); + SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: + case ts_symbol_expression: SHIFT(32); + case ts_symbol_factor: + SHIFT(9); + case ts_symbol_number: + SHIFT(16); + case ts_symbol_term: + SHIFT(17); + case ts_symbol_variable: + SHIFT(16); + case ts_aux_token1: + SHIFT(26); default: PARSE_PANIC(); } case 32: - SET_LEX_STATE(2); + SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { - 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})); + case ts_aux_token2: + SHIFT(33); default: PARSE_PANIC(); } case 33: - SET_LEX_STATE(2); + SET_LEX_STATE(13); switch (LOOKAHEAD_SYM()) { case ts_symbol_times: - SHIFT(34); - case ts_aux_end: - REDUCE(ts_symbol_term, 1, COLLAPSE({0})); + 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 34: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - 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(0); + SET_LEX_STATE(14); switch (LOOKAHEAD_SYM()) { + 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 36: - SET_LEX_STATE(10); + case 35: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_plus: + SHIFT(36); + case ts_aux_end: + REDUCE(ts_symbol_expression, 1, COLLAPSE({0})); + default: + PARSE_PANIC(); + } + case 36: + SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { - case ts_symbol_expression: - SHIFT(37); case ts_symbol_factor: - SHIFT(15); + SHIFT(37); case ts_symbol_number: - SHIFT(11); + SHIFT(44); case ts_symbol_term: - SHIFT(6); + SHIFT(45); case ts_symbol_variable: - SHIFT(11); + SHIFT(44); case ts_aux_token1: - SHIFT(12); + SHIFT(46); default: PARSE_PANIC(); } case 37: - SET_LEX_STATE(4); + SET_LEX_STATE(15); switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: + case ts_symbol_times: SHIFT(38); + case ts_aux_end: + REDUCE(ts_symbol_term, 1, COLLAPSE({0})); default: PARSE_PANIC(); } case 38: - SET_LEX_STATE(0); + SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { - case ts_aux_end: - REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + case ts_symbol_factor: + SHIFT(39); + case ts_symbol_number: + SHIFT(40); + case ts_symbol_variable: + SHIFT(40); + case ts_aux_token1: + SHIFT(41); default: PARSE_PANIC(); } @@ -574,32 +580,28 @@ static TSParseResult ts_parse(const char *input) { PARSE_PANIC(); } case 40: - SET_LEX_STATE(15); + SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { - 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); + SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { case ts_symbol_expression: SHIFT(42); case ts_symbol_factor: - SHIFT(15); + SHIFT(9); case ts_symbol_number: - SHIFT(11); + SHIFT(16); case ts_symbol_term: - SHIFT(6); + SHIFT(17); case ts_symbol_variable: - SHIFT(11); + SHIFT(16); case ts_aux_token1: - SHIFT(12); + SHIFT(26); default: PARSE_PANIC(); } @@ -612,12 +614,8 @@ static TSParseResult ts_parse(const char *input) { PARSE_PANIC(); } case 43: - SET_LEX_STATE(15); + SET_LEX_STATE(0); 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_end: REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); default: @@ -626,90 +624,92 @@ static TSParseResult ts_parse(const char *input) { case 44: SET_LEX_STATE(15); switch (LOOKAHEAD_SYM()) { - case ts_symbol_plus: - REDUCE(ts_symbol_term, 1, COLLAPSE({0})); case ts_symbol_times: - SHIFT(45); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); case ts_aux_end: - REDUCE(ts_symbol_term, 1, COLLAPSE({0})); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); default: PARSE_PANIC(); } case 45: - SET_LEX_STATE(10); + SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(50); - case ts_symbol_number: - SHIFT(46); - case ts_symbol_variable: - SHIFT(46); - case ts_aux_token1: - SHIFT(47); + case ts_aux_end: + REDUCE(ts_symbol_expression, 3, COLLAPSE({0, 0, 0})); default: PARSE_PANIC(); } case 46: - SET_LEX_STATE(14); + SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { - case ts_symbol_plus: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); - case ts_aux_end: - REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + case ts_symbol_expression: + SHIFT(47); + case ts_symbol_factor: + SHIFT(9); + case ts_symbol_number: + SHIFT(16); + case ts_symbol_term: + SHIFT(17); + case ts_symbol_variable: + SHIFT(16); + case ts_aux_token1: + SHIFT(26); default: PARSE_PANIC(); } case 47: - SET_LEX_STATE(10); + SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { - case ts_symbol_expression: + case ts_aux_token2: 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(4); + SET_LEX_STATE(15); switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - SHIFT(49); + 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 49: - SET_LEX_STATE(14); + SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { - 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})); + case ts_symbol_expression: + SHIFT(50); + case ts_symbol_factor: + SHIFT(9); + case ts_symbol_number: + SHIFT(16); + case ts_symbol_term: + SHIFT(17); + case ts_symbol_variable: + SHIFT(16); + case ts_aux_token1: + SHIFT(26); default: PARSE_PANIC(); } case 50: - SET_LEX_STATE(14); + SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { - case ts_symbol_plus: - REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); - case ts_aux_end: - REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); + case ts_aux_token2: + SHIFT(51); default: PARSE_PANIC(); } case 51: - SET_LEX_STATE(0); + SET_LEX_STATE(14); 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_end: - ACCEPT_INPUT(); + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); default: PARSE_PANIC(); } diff --git a/spec/fixtures/parsers/json.c b/spec/fixtures/parsers/json.c index b434b54d..9b7e3eb0 100644 --- a/spec/fixtures/parsers/json.c +++ b/spec/fixtures/parsers/json.c @@ -41,119 +41,119 @@ static void ts_lex(TSParser *parser) { START_LEXER(); switch (LEX_STATE()) { case 0: - if (LOOKAHEAD_CHAR() == ',') + if (LOOKAHEAD_CHAR() == '\0') ADVANCE(1); - ACCEPT_TOKEN(ts_aux_token3); + LEX_ERROR(1, EXPECT({""})); case 1: - ACCEPT_TOKEN(ts_aux_token2); + ACCEPT_TOKEN(ts_aux_end); case 2: - if (LOOKAHEAD_CHAR() == ']') + if (LOOKAHEAD_CHAR() == ',') ADVANCE(3); - LEX_ERROR(1, EXPECT({"]"})); + ACCEPT_TOKEN(ts_aux_token3); case 3: - ACCEPT_TOKEN(ts_aux_token4); + ACCEPT_TOKEN(ts_aux_token2); case 4: - if (LOOKAHEAD_CHAR() == ',') - ADVANCE(1); if (LOOKAHEAD_CHAR() == ']') - ADVANCE(3); - LEX_ERROR(2, EXPECT({",", "]"})); + ADVANCE(5); + LEX_ERROR(1, EXPECT({"]"})); case 5: - if (LOOKAHEAD_CHAR() == '}') - ADVANCE(6); - LEX_ERROR(1, EXPECT({"}"})); + ACCEPT_TOKEN(ts_aux_token4); case 6: - ACCEPT_TOKEN(ts_aux_token7); - case 7: if (LOOKAHEAD_CHAR() == ',') - ADVANCE(1); + ADVANCE(3); + if (LOOKAHEAD_CHAR() == ']') + ADVANCE(5); + LEX_ERROR(2, EXPECT({",", "]"})); + case 7: if (LOOKAHEAD_CHAR() == '}') - ADVANCE(6); - LEX_ERROR(2, EXPECT({",", "}"})); + ADVANCE(8); + LEX_ERROR(1, EXPECT({"}"})); case 8: - if (LOOKAHEAD_CHAR() == '\"') - ADVANCE(10); - if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9') - ADVANCE(9); - if (LOOKAHEAD_CHAR() == '[') - ADVANCE(16); - if (LOOKAHEAD_CHAR() == '{') - ADVANCE(17); - LEX_ERROR(4, EXPECT({"\"", "0-9", "[", "{"})); + ACCEPT_TOKEN(ts_aux_token7); case 9: - if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9') - ADVANCE(9); - ACCEPT_TOKEN(ts_symbol_number); + if (LOOKAHEAD_CHAR() == ',') + ADVANCE(3); + if (LOOKAHEAD_CHAR() == '}') + ADVANCE(8); + LEX_ERROR(2, EXPECT({",", "}"})); case 10: - if (!((LOOKAHEAD_CHAR() == '\"') || - (LOOKAHEAD_CHAR() == '\\'))) + if (LOOKAHEAD_CHAR() == '\"') ADVANCE(11); - if (LOOKAHEAD_CHAR() == '\\') - ADVANCE(12); - if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\') - ADVANCE(13); - LEX_ERROR(2, EXPECT({"-!", "#-"})); + if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9') + ADVANCE(17); + if (LOOKAHEAD_CHAR() == '[') + ADVANCE(18); + if (LOOKAHEAD_CHAR() == '{') + ADVANCE(19); + LEX_ERROR(4, EXPECT({"\"", "0-9", "[", "{"})); case 11: if (!((LOOKAHEAD_CHAR() == '\"') || (LOOKAHEAD_CHAR() == '\\'))) - ADVANCE(11); - if (LOOKAHEAD_CHAR() == '\"') - ADVANCE(15); - if (LOOKAHEAD_CHAR() == '\\') ADVANCE(12); + if (LOOKAHEAD_CHAR() == '\\') + ADVANCE(14); if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\') - ADVANCE(13); - LEX_ERROR(1, EXPECT({""})); + ADVANCE(16); + LEX_ERROR(2, EXPECT({"-!", "#-"})); case 12: if (!((LOOKAHEAD_CHAR() == '\"') || (LOOKAHEAD_CHAR() == '\\'))) - ADVANCE(11); - if (LOOKAHEAD_CHAR() == '\"') - ADVANCE(14); - if ('#' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\"') - ADVANCE(11); - if (LOOKAHEAD_CHAR() == '\\') ADVANCE(12); - if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\') + if (LOOKAHEAD_CHAR() == '\"') ADVANCE(13); + if (LOOKAHEAD_CHAR() == '\\') + ADVANCE(14); + if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\') + ADVANCE(16); LEX_ERROR(1, EXPECT({""})); case 13: - if (LOOKAHEAD_CHAR() == '\"') - ADVANCE(11); - LEX_ERROR(1, EXPECT({"\""})); + ACCEPT_TOKEN(ts_symbol_string); case 14: if (!((LOOKAHEAD_CHAR() == '\"') || (LOOKAHEAD_CHAR() == '\\'))) - ADVANCE(11); + ADVANCE(12); if (LOOKAHEAD_CHAR() == '\"') ADVANCE(15); - if (LOOKAHEAD_CHAR() == '\\') + if ('#' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\"') ADVANCE(12); + if (LOOKAHEAD_CHAR() == '\\') + ADVANCE(14); if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\') - ADVANCE(13); - ACCEPT_TOKEN(ts_symbol_string); + ADVANCE(16); + LEX_ERROR(1, EXPECT({""})); case 15: + if (!((LOOKAHEAD_CHAR() == '\"') || + (LOOKAHEAD_CHAR() == '\\'))) + ADVANCE(12); + if (LOOKAHEAD_CHAR() == '\"') + ADVANCE(13); + if (LOOKAHEAD_CHAR() == '\\') + ADVANCE(14); + if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\') + ADVANCE(16); 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); + ADVANCE(12); LEX_ERROR(1, EXPECT({"\""})); + case 17: + if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9') + ADVANCE(17); + ACCEPT_TOKEN(ts_symbol_number); + 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: - if (LOOKAHEAD_CHAR() == '\0') - ADVANCE(22); - LEX_ERROR(1, EXPECT({""})); + ACCEPT_TOKEN(ts_aux_token6); case 22: - ACCEPT_TOKEN(ts_aux_end); + if (LOOKAHEAD_CHAR() == '\"') + ADVANCE(11); + LEX_ERROR(1, EXPECT({"\""})); default: LEX_PANIC(); } @@ -164,624 +164,624 @@ static TSParseResult ts_parse(const char *input) { START_PARSER(); switch (PARSE_STATE()) { case 0: - SET_LEX_STATE(8); + SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { case ts_symbol_array: - SHIFT(52); - case ts_symbol_number: - SHIFT(52); - case ts_symbol_object: - SHIFT(52); - case ts_symbol_string: - SHIFT(52); - case ts_symbol_value: - SHIFT(53); - case ts_aux_token1: SHIFT(1); + case ts_symbol_number: + SHIFT(1); + case ts_symbol_object: + SHIFT(1); + case ts_symbol_string: + SHIFT(1); + case ts_symbol_value: + SHIFT(2); + case ts_aux_token1: + SHIFT(3); case ts_aux_token5: - SHIFT(46); + SHIFT(48); default: PARSE_PANIC(); } case 1: - SET_LEX_STATE(8); + SET_LEX_STATE(0); 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(43); - case ts_aux_token1: - SHIFT(2); - case ts_aux_token5: - SHIFT(11); + case ts_aux_end: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); default: PARSE_PANIC(); } case 2: - SET_LEX_STATE(8); + SET_LEX_STATE(0); 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(3); - case ts_aux_token1: - SHIFT(2); - case ts_aux_token5: - SHIFT(11); + case ts_aux_end: + ACCEPT_INPUT(); default: PARSE_PANIC(); } case 3: - SET_LEX_STATE(0); + SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_aux_repeat_helper2: + case ts_symbol_array: SHIFT(4); - case ts_aux_token2: - SHIFT(6); - case ts_aux_token3: + case ts_symbol_number: SHIFT(4); + case ts_symbol_object: + SHIFT(4); + case ts_symbol_string: + SHIFT(4); + case ts_symbol_value: + SHIFT(5); + case ts_aux_token1: + SHIFT(16); + case ts_aux_token5: + SHIFT(20); default: PARSE_PANIC(); } case 4: SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { - case ts_aux_token4: - SHIFT(5); + case ts_aux_token2: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + case ts_aux_token3: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); default: PARSE_PANIC(); } case 5: - SET_LEX_STATE(0); + SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { + case ts_aux_repeat_helper2: + SHIFT(6); case ts_aux_token2: - REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); + SHIFT(8); case ts_aux_token3: - REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); + SHIFT(6); default: PARSE_PANIC(); } case 6: - SET_LEX_STATE(8); + SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { - case ts_symbol_array: - SHIFT(40); - case ts_symbol_number: - SHIFT(40); - case ts_symbol_object: - SHIFT(40); - case ts_symbol_string: - SHIFT(40); - case ts_symbol_value: - SHIFT(41); - case ts_aux_token1: + case ts_aux_token4: SHIFT(7); - case ts_aux_token5: - SHIFT(34); default: PARSE_PANIC(); } case 7: - SET_LEX_STATE(8); + SET_LEX_STATE(0); 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); + case ts_aux_end: + REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); default: PARSE_PANIC(); } case 8: - SET_LEX_STATE(0); + SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_aux_repeat_helper2: + case ts_symbol_array: SHIFT(9); - case ts_aux_token2: - SHIFT(6); - case ts_aux_token3: + case ts_symbol_number: SHIFT(9); + case ts_symbol_object: + SHIFT(9); + case ts_symbol_string: + SHIFT(9); + case ts_symbol_value: + SHIFT(10); + case ts_aux_token1: + SHIFT(12); + case ts_aux_token5: + SHIFT(42); default: PARSE_PANIC(); } case 9: - SET_LEX_STATE(2); + SET_LEX_STATE(6); switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); case ts_aux_token4: - SHIFT(10); + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); default: PARSE_PANIC(); } case 10: - SET_LEX_STATE(4); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); - case ts_aux_token4: - REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); - default: - PARSE_PANIC(); - } - 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(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(14); - case ts_aux_token1: - SHIFT(2); - case ts_aux_token5: - SHIFT(11); - default: - PARSE_PANIC(); - } - case 14: - SET_LEX_STATE(0); - switch (LOOKAHEAD_SYM()) { - case ts_aux_repeat_helper1: - SHIFT(15); - case ts_aux_token2: - SHIFT(17); - case ts_aux_token3: - SHIFT(15); - default: - PARSE_PANIC(); - } - case 15: - SET_LEX_STATE(5); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token7: - SHIFT(16); - default: - PARSE_PANIC(); - } - case 16: - SET_LEX_STATE(0); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); - case ts_aux_token3: - REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); - default: - PARSE_PANIC(); - } - 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(8); - switch (LOOKAHEAD_SYM()) { - 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(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(21); - case ts_aux_token1: - SHIFT(2); - case ts_aux_token5: - SHIFT(11); - default: - PARSE_PANIC(); - } - case 21: - SET_LEX_STATE(0); + SET_LEX_STATE(6); switch (LOOKAHEAD_SYM()) { case ts_aux_repeat_helper2: - SHIFT(22); - case ts_aux_token2: - SHIFT(6); - case ts_aux_token3: - SHIFT(22); - default: - PARSE_PANIC(); - } - case 22: - SET_LEX_STATE(2); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token4: - SHIFT(23); - default: - PARSE_PANIC(); - } - case 23: - SET_LEX_STATE(7); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); - case ts_aux_token7: - REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); - default: - PARSE_PANIC(); - } - case 24: - SET_LEX_STATE(0); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - case ts_aux_token3: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); - default: - PARSE_PANIC(); - } - 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(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(28); - case ts_aux_token1: - SHIFT(2); - case ts_aux_token5: SHIFT(11); - default: - PARSE_PANIC(); - } - case 28: - SET_LEX_STATE(0); - switch (LOOKAHEAD_SYM()) { - case ts_aux_repeat_helper1: - SHIFT(29); case ts_aux_token2: - SHIFT(17); - case ts_aux_token3: - SHIFT(29); - default: - PARSE_PANIC(); - } - case 29: - SET_LEX_STATE(5); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token7: - SHIFT(30); - default: - PARSE_PANIC(); - } - 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: - REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); - default: - PARSE_PANIC(); - } - case 31: - SET_LEX_STATE(7); - 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 32: - SET_LEX_STATE(7); - switch (LOOKAHEAD_SYM()) { - case ts_aux_repeat_helper1: - SHIFT(33); - case ts_aux_token2: - SHIFT(17); - case ts_aux_token7: - REDUCE(ts_aux_repeat_helper1, 4, COLLAPSE({1, 0, 1, 0})); - default: - PARSE_PANIC(); - } - 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 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(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(37); - case ts_aux_token1: - SHIFT(2); - case ts_aux_token5: - SHIFT(11); - default: - PARSE_PANIC(); - } - case 37: - SET_LEX_STATE(0); - switch (LOOKAHEAD_SYM()) { - case ts_aux_repeat_helper1: - SHIFT(38); - case ts_aux_token2: - SHIFT(17); - case ts_aux_token3: - SHIFT(38); - default: - PARSE_PANIC(); - } - case 38: - SET_LEX_STATE(5); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token7: - SHIFT(39); - default: - PARSE_PANIC(); - } - case 39: - SET_LEX_STATE(4); - switch (LOOKAHEAD_SYM()) { - 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(4); - 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 41: - SET_LEX_STATE(4); - switch (LOOKAHEAD_SYM()) { - case ts_aux_repeat_helper2: - SHIFT(42); - case ts_aux_token2: - SHIFT(6); + SHIFT(8); case ts_aux_token4: REDUCE(ts_aux_repeat_helper2, 2, COLLAPSE({1, 0})); default: PARSE_PANIC(); } - case 42: - SET_LEX_STATE(2); + case 11: + SET_LEX_STATE(4); 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); + case 12: + SET_LEX_STATE(10); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_array: + SHIFT(4); + case ts_symbol_number: + SHIFT(4); + case ts_symbol_object: + SHIFT(4); + case ts_symbol_string: + SHIFT(4); + case ts_symbol_value: + SHIFT(13); + case ts_aux_token1: + SHIFT(16); + case ts_aux_token5: + SHIFT(20); + default: + PARSE_PANIC(); + } + case 13: + SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { case ts_aux_repeat_helper2: - SHIFT(44); + SHIFT(14); case ts_aux_token2: - SHIFT(6); + SHIFT(8); case ts_aux_token3: + SHIFT(14); + default: + PARSE_PANIC(); + } + case 14: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token4: + SHIFT(15); + default: + PARSE_PANIC(); + } + case 15: + SET_LEX_STATE(6); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); + case ts_aux_token4: + REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); + default: + PARSE_PANIC(); + } + case 16: + SET_LEX_STATE(10); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_array: + SHIFT(4); + case ts_symbol_number: + SHIFT(4); + case ts_symbol_object: + SHIFT(4); + case ts_symbol_string: + SHIFT(4); + case ts_symbol_value: + SHIFT(17); + case ts_aux_token1: + SHIFT(16); + case ts_aux_token5: + SHIFT(20); + default: + PARSE_PANIC(); + } + case 17: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + case ts_aux_repeat_helper2: + SHIFT(18); + case ts_aux_token2: + SHIFT(8); + case ts_aux_token3: + SHIFT(18); + default: + PARSE_PANIC(); + } + case 18: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token4: + SHIFT(19); + default: + PARSE_PANIC(); + } + case 19: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); + case ts_aux_token3: + REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); + default: + PARSE_PANIC(); + } + case 20: + SET_LEX_STATE(22); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_string: + SHIFT(21); + default: + PARSE_PANIC(); + } + case 21: + SET_LEX_STATE(20); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token6: + SHIFT(22); + default: + PARSE_PANIC(); + } + case 22: + SET_LEX_STATE(10); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_array: + SHIFT(4); + case ts_symbol_number: + SHIFT(4); + case ts_symbol_object: + SHIFT(4); + case ts_symbol_string: + SHIFT(4); + case ts_symbol_value: + SHIFT(23); + case ts_aux_token1: + SHIFT(16); + case ts_aux_token5: + SHIFT(20); + default: + PARSE_PANIC(); + } + case 23: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + case ts_aux_repeat_helper1: + SHIFT(24); + case ts_aux_token2: + SHIFT(26); + case ts_aux_token3: + SHIFT(24); + default: + PARSE_PANIC(); + } + case 24: + SET_LEX_STATE(7); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token7: + SHIFT(25); + default: + PARSE_PANIC(); + } + case 25: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + case ts_aux_token3: + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + default: + PARSE_PANIC(); + } + case 26: + SET_LEX_STATE(22); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_string: + SHIFT(27); + default: + PARSE_PANIC(); + } + case 27: + SET_LEX_STATE(20); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token6: + SHIFT(28); + default: + PARSE_PANIC(); + } + case 28: + SET_LEX_STATE(10); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_array: + SHIFT(29); + case ts_symbol_number: + SHIFT(29); + case ts_symbol_object: + SHIFT(29); + case ts_symbol_string: + SHIFT(29); + case ts_symbol_value: + SHIFT(30); + case ts_aux_token1: + SHIFT(32); + case ts_aux_token5: + SHIFT(36); + default: + PARSE_PANIC(); + } + case 29: + 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 30: + SET_LEX_STATE(9); + switch (LOOKAHEAD_SYM()) { + case ts_aux_repeat_helper1: + SHIFT(31); + case ts_aux_token2: + SHIFT(26); + case ts_aux_token7: + REDUCE(ts_aux_repeat_helper1, 4, COLLAPSE({1, 0, 1, 0})); + default: + PARSE_PANIC(); + } + case 31: + SET_LEX_STATE(7); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token7: + REDUCE(ts_aux_repeat_helper1, 5, COLLAPSE({1, 0, 1, 0, 1})); + default: + PARSE_PANIC(); + } + case 32: + SET_LEX_STATE(10); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_array: + SHIFT(4); + case ts_symbol_number: + SHIFT(4); + case ts_symbol_object: + SHIFT(4); + case ts_symbol_string: + SHIFT(4); + case ts_symbol_value: + SHIFT(33); + case ts_aux_token1: + SHIFT(16); + case ts_aux_token5: + SHIFT(20); + default: + PARSE_PANIC(); + } + case 33: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + case ts_aux_repeat_helper2: + SHIFT(34); + case ts_aux_token2: + SHIFT(8); + case ts_aux_token3: + SHIFT(34); + default: + PARSE_PANIC(); + } + case 34: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token4: + SHIFT(35); + default: + PARSE_PANIC(); + } + case 35: + SET_LEX_STATE(9); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); + case ts_aux_token7: + REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); + default: + PARSE_PANIC(); + } + case 36: + SET_LEX_STATE(22); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_string: + SHIFT(37); + default: + PARSE_PANIC(); + } + case 37: + SET_LEX_STATE(20); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token6: + SHIFT(38); + default: + PARSE_PANIC(); + } + case 38: + SET_LEX_STATE(10); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_array: + SHIFT(4); + case ts_symbol_number: + SHIFT(4); + case ts_symbol_object: + SHIFT(4); + case ts_symbol_string: + SHIFT(4); + case ts_symbol_value: + SHIFT(39); + case ts_aux_token1: + SHIFT(16); + case ts_aux_token5: + SHIFT(20); + default: + PARSE_PANIC(); + } + case 39: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + case ts_aux_repeat_helper1: + SHIFT(40); + case ts_aux_token2: + SHIFT(26); + case ts_aux_token3: + SHIFT(40); + default: + PARSE_PANIC(); + } + case 40: + SET_LEX_STATE(7); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token7: + SHIFT(41); + default: + PARSE_PANIC(); + } + case 41: + SET_LEX_STATE(9); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + case ts_aux_token7: + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + default: + PARSE_PANIC(); + } + case 42: + SET_LEX_STATE(22); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_string: + SHIFT(43); + default: + PARSE_PANIC(); + } + case 43: + SET_LEX_STATE(20); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token6: SHIFT(44); default: PARSE_PANIC(); } case 44: - SET_LEX_STATE(2); + SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_aux_token4: + case ts_symbol_array: + SHIFT(4); + case ts_symbol_number: + SHIFT(4); + case ts_symbol_object: + SHIFT(4); + case ts_symbol_string: + SHIFT(4); + case ts_symbol_value: SHIFT(45); + case ts_aux_token1: + SHIFT(16); + case ts_aux_token5: + SHIFT(20); default: PARSE_PANIC(); } case 45: - SET_LEX_STATE(21); + SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { - case ts_aux_end: - REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); + case ts_aux_repeat_helper1: + SHIFT(46); + case ts_aux_token2: + SHIFT(26); + case ts_aux_token3: + SHIFT(46); default: PARSE_PANIC(); } case 46: - SET_LEX_STATE(20); + SET_LEX_STATE(7); switch (LOOKAHEAD_SYM()) { - case ts_symbol_string: + case ts_aux_token7: SHIFT(47); default: PARSE_PANIC(); } case 47: - SET_LEX_STATE(18); + SET_LEX_STATE(6); switch (LOOKAHEAD_SYM()) { - case ts_aux_token6: - SHIFT(48); + 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 48: - SET_LEX_STATE(8); + SET_LEX_STATE(22); 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(49); - case ts_aux_token1: - SHIFT(2); - case ts_aux_token5: - SHIFT(11); default: PARSE_PANIC(); } case 49: - SET_LEX_STATE(0); + SET_LEX_STATE(20); switch (LOOKAHEAD_SYM()) { - case ts_aux_repeat_helper1: - SHIFT(50); - case ts_aux_token2: - SHIFT(17); - case ts_aux_token3: + case ts_aux_token6: SHIFT(50); default: PARSE_PANIC(); } case 50: - SET_LEX_STATE(5); + SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_aux_token7: + case ts_symbol_array: + SHIFT(4); + case ts_symbol_number: + SHIFT(4); + case ts_symbol_object: + SHIFT(4); + case ts_symbol_string: + SHIFT(4); + case ts_symbol_value: SHIFT(51); + case ts_aux_token1: + SHIFT(16); + case ts_aux_token5: + SHIFT(20); default: PARSE_PANIC(); } case 51: - SET_LEX_STATE(21); + SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { - case ts_aux_end: - REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + case ts_aux_repeat_helper1: + SHIFT(52); + case ts_aux_token2: + SHIFT(26); + case ts_aux_token3: + SHIFT(52); default: PARSE_PANIC(); } case 52: - SET_LEX_STATE(21); + SET_LEX_STATE(7); switch (LOOKAHEAD_SYM()) { - case ts_aux_end: - REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + case ts_aux_token7: + SHIFT(53); default: PARSE_PANIC(); } case 53: - SET_LEX_STATE(21); + SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { case ts_aux_end: - ACCEPT_INPUT(); + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); default: PARSE_PANIC(); } diff --git a/src/compiler/build_tables/follow_sets.cpp b/src/compiler/build_tables/follow_sets.cpp index 1b7068ad..16f2ed9c 100644 --- a/src/compiler/build_tables/follow_sets.cpp +++ b/src/compiler/build_tables/follow_sets.cpp @@ -16,7 +16,7 @@ namespace tree_sitter { map> result; for (auto pair : sym_transitions(item.rule)) { - auto symbol = *pair.first; + auto symbol = pair.first; if (grammar.has_definition(symbol)) { auto following_non_terminals = first_set(pair.second, grammar); if (rule_can_be_blank(pair.second)) { diff --git a/src/compiler/build_tables/item_set_transitions.cpp b/src/compiler/build_tables/item_set_transitions.cpp index 6e7d4928..214c0aec 100644 --- a/src/compiler/build_tables/item_set_transitions.cpp +++ b/src/compiler/build_tables/item_set_transitions.cpp @@ -5,6 +5,7 @@ using std::make_shared; using std::shared_ptr; +using std::map; namespace tree_sitter { using rules::CharacterSet; @@ -17,40 +18,40 @@ namespace tree_sitter { return result; } - transition_map char_transitions(const LexItemSet &item_set, const Grammar &grammar) { - transition_map result; + map char_transitions(const LexItemSet &item_set, const Grammar &grammar) { + map result; for (const LexItem &item : item_set) { - transition_map item_transitions; + map item_transitions; for (auto transition : char_transitions(item.rule)) { auto rule = transition.first; auto new_item = LexItem(item.lhs, transition.second); auto new_item_set = LexItemSet({ new_item }); - item_transitions.add(rule, make_shared(new_item_set)); + item_transitions.insert({ rule, LexItemSet(new_item_set) }); } - result = merge_char_transitions(result, item_transitions, [](shared_ptr left, shared_ptr right) { - return make_shared(merge_sets(*left, *right)); + result = merge_char_transitions(result, item_transitions, [](LexItemSet left, LexItemSet right) { + return merge_sets(left, right); }); } return result; } - transition_map sym_transitions(const ParseItemSet &item_set, const Grammar &grammar) { - transition_map result; + map sym_transitions(const ParseItemSet &item_set, const Grammar &grammar) { + map result; for (const ParseItem &item : item_set) { - transition_map item_transitions; + map item_transitions; for (auto transition : sym_transitions(item.rule)) { auto rule = transition.first; auto consumed_symbols = item.consumed_symbols; - consumed_symbols.push_back(rule->is_auxiliary); + 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)); + item_transitions.insert({ rule, ParseItemSet(new_item_set) }); } - result = merge_sym_transitions(result, item_transitions, [](shared_ptr left, shared_ptr right) { - return make_shared(merge_sets(*left, *right)); + result = merge_sym_transitions(result, item_transitions, [](ParseItemSet left, ParseItemSet right) { + return merge_sets(left, right); }); } diff --git a/src/compiler/build_tables/item_set_transitions.h b/src/compiler/build_tables/item_set_transitions.h index fc0a52d6..eeba842d 100644 --- a/src/compiler/build_tables/item_set_transitions.h +++ b/src/compiler/build_tables/item_set_transitions.h @@ -3,13 +3,13 @@ #include "character_set.h" #include "symbol.h" -#include "transition_map.h" #include "item.h" +#include namespace tree_sitter { namespace build_tables { - transition_map char_transitions(const LexItemSet &item_set, const Grammar &grammar); - transition_map sym_transitions(const ParseItemSet &item_set, const Grammar &grammar); + std::map char_transitions(const LexItemSet &item_set, const Grammar &grammar); + std::map sym_transitions(const ParseItemSet &item_set, const Grammar &grammar); } } diff --git a/src/compiler/build_tables/merge_transitions.h b/src/compiler/build_tables/merge_transitions.h index 8557402d..e2394d55 100644 --- a/src/compiler/build_tables/merge_transitions.h +++ b/src/compiler/build_tables/merge_transitions.h @@ -1,52 +1,54 @@ #ifndef __tree_sitter__merge_transitions__ #define __tree_sitter__merge_transitions__ -#include "transition_map.h" #include "character_set.h" #include "symbol.h" +#include namespace tree_sitter { namespace build_tables { template - transition_map - merge_sym_transitions(const transition_map &left, - const transition_map &right, - std::function(std::shared_ptr, std::shared_ptr)> merge_fn) { - transition_map result(left); + std::map + merge_sym_transitions(const std::map &left, + const std::map &right, + std::function merge_fn) { + std::map result(left); for (auto &pair : right) { auto rule = pair.first; bool merged = false; for (auto &existing_pair : result) { auto existing_rule = existing_pair.first; - if (existing_rule->operator==(*rule)) { + if (existing_rule == rule) { existing_pair.second = merge_fn(existing_pair.second, pair.second); merged = true; break; } } if (!merged) - result.add(pair.first, pair.second); + result.insert({ pair.first, pair.second }); } return result; } template - transition_map - merge_char_transitions(const transition_map &left, - const transition_map &right, - std::function(std::shared_ptr, std::shared_ptr)> merge_fn) { - transition_map result(left); + std::map + merge_char_transitions(const std::map &left, + const std::map &right, + std::function merge_fn) { + std::map result(left); for (auto &pair : right) { auto rule = pair.first; for (auto &existing_pair : left) { auto existing_rule = existing_pair.first; - auto intersection = existing_rule->remove_set(*rule); + auto intersection = existing_rule.remove_set(rule); if (!intersection.is_empty()) { - rule->remove_set(intersection); - result.add(std::make_shared(intersection), merge_fn(existing_pair.second, pair.second)); + result.erase(existing_pair.first); + result.insert({ existing_rule, existing_pair.second }); + rule.remove_set(intersection); + result.insert({ intersection, merge_fn(existing_pair.second, pair.second) }); } } - result.add(rule, pair.second); + result.insert({ rule, pair.second }); } return result; } diff --git a/src/compiler/build_tables/perform.cpp b/src/compiler/build_tables/perform.cpp index af72c0a4..3ece9f46 100644 --- a/src/compiler/build_tables/perform.cpp +++ b/src/compiler/build_tables/perform.cpp @@ -36,8 +36,8 @@ namespace tree_sitter { void add_shift_actions(const ParseItemSet &item_set, size_t state_index) { for (auto transition : sym_transitions(item_set, grammar)) { - rules::Symbol symbol = *transition.first; - ParseItemSet item_set = *transition.second; + rules::Symbol symbol = transition.first; + ParseItemSet item_set = transition.second; size_t new_state_index = add_parse_state(item_set); parse_table.add_action(state_index, symbol, ParseAction::Shift(new_state_index)); } @@ -45,8 +45,8 @@ namespace tree_sitter { void add_advance_actions(const LexItemSet &item_set, size_t state_index) { for (auto transition : char_transitions(item_set, grammar)) { - rules::CharacterSet rule = *transition.first; - LexItemSet item_set = *transition.second; + rules::CharacterSet rule = transition.first; + LexItemSet item_set = transition.second; size_t new_state_index = add_lex_state(item_set); lex_table.add_action(state_index, rule, LexAction::Advance(new_state_index)); } diff --git a/src/compiler/build_tables/rule_transitions.cpp b/src/compiler/build_tables/rule_transitions.cpp index 3f6ec3e2..27048fdb 100644 --- a/src/compiler/build_tables/rule_transitions.cpp +++ b/src/compiler/build_tables/rule_transitions.cpp @@ -3,6 +3,7 @@ #include "merge_transitions.h" using namespace tree_sitter::rules; +using std::map; namespace tree_sitter { namespace build_tables { @@ -11,36 +12,38 @@ namespace tree_sitter { } template - transition_map merge_transitions(const transition_map &left, const transition_map &right); + map merge_transitions(const map &left, const map &right); template<> - transition_map merge_transitions(const transition_map &left, const transition_map &right) { - return merge_char_transitions(left, right, [](rule_ptr left, rule_ptr right) -> rule_ptr { + map merge_transitions(const map &left, const map &right) { + auto transitions = merge_char_transitions(left, right, [](rule_ptr left, rule_ptr right) -> rule_ptr { return choice({ left, right }); }); + return *static_cast *>(&transitions); } template<> - transition_map merge_transitions(const transition_map &left, const transition_map &right) { - return merge_sym_transitions(left, right, [](rule_ptr left, rule_ptr right) -> rule_ptr { + map merge_transitions(const map &left, const map &right) { + auto transitions = merge_sym_transitions(left, right, [](rule_ptr left, rule_ptr right) -> rule_ptr { return choice({ left, right }); }); + return *static_cast *>(&transitions); } template - transition_map map_transitions(const transition_map &initial, std::function map_fn) { - transition_map result; + map map_transitions(const map &initial, std::function map_fn) { + map result; for (auto &pair : initial) - result.add(pair.first, map_fn(pair.second)); + result.insert({ pair.first, map_fn(pair.second) }); return result; } template class TransitionsVisitor : public rules::Visitor { public: - transition_map value; + map value; - static transition_map transitions(const rule_ptr rule) { + static map transitions(const rule_ptr rule) { TransitionsVisitor visitor; rule->accept(visitor); return visitor.value; @@ -49,7 +52,8 @@ namespace tree_sitter { void visit_atom(const Rule *rule) { auto atom = dynamic_cast(rule); if (atom) { - value = transition_map({{ std::make_shared(*atom), blank() }}); + value = map(); + value.insert({ *atom, blank() }); } } @@ -96,11 +100,11 @@ namespace tree_sitter { } }; - transition_map char_transitions(const rule_ptr &rule) { + map char_transitions(const rule_ptr &rule) { return TransitionsVisitor::transitions(rule); } - transition_map sym_transitions(const rule_ptr &rule) { + map sym_transitions(const rule_ptr &rule) { return TransitionsVisitor::transitions(rule); } diff --git a/src/compiler/build_tables/rule_transitions.h b/src/compiler/build_tables/rule_transitions.h index dd23b29c..287f431e 100644 --- a/src/compiler/build_tables/rule_transitions.h +++ b/src/compiler/build_tables/rule_transitions.h @@ -3,13 +3,13 @@ #include "character_set.h" #include "symbol.h" -#include "transition_map.h" +#include namespace tree_sitter { namespace build_tables { bool rule_can_be_blank(const rules::rule_ptr &rule); - transition_map char_transitions(const rules::rule_ptr &rule); - transition_map sym_transitions(const rules::rule_ptr &rule); + std::map char_transitions(const rules::rule_ptr &rule); + std::map sym_transitions(const rules::rule_ptr &rule); } } diff --git a/src/compiler/build_tables/transition_map.h b/src/compiler/build_tables/transition_map.h deleted file mode 100644 index 3de5daa5..00000000 --- a/src/compiler/build_tables/transition_map.h +++ /dev/null @@ -1,73 +0,0 @@ -#ifndef __TreeSitter__TransitionSet__ -#define __TreeSitter__TransitionSet__ - -#include -#include -#include "rule.h" - -namespace tree_sitter { - template - class transition_map { - typedef std::shared_ptr TKeyPtr; - typedef std::shared_ptr TValuePtr; - typedef std::pair pair_type; - typedef std::vector contents_type; - - contents_type contents; - - public: - transition_map() : contents(contents_type()) {}; - transition_map(std::vector pairs) : contents(pairs) {}; - - bool operator==(const transition_map &other) const { - if (size() != other.size()) return false; - for (int i = 0; i < size(); i++) { - auto left = contents[i]; - auto right = other.contents[i]; - if (!(*left.first == *right.first) || - !(*left.second == *right.second)) return false; - } - return true; - } - - void add(TKeyPtr key, TValuePtr value) { - contents.push_back(pair_type(key, value)); - } - - TValuePtr operator[](const TKey &key) const { - for (auto pair : *this) { - if (*pair.first == key) { - return pair.second; - } - } - return TValuePtr(); - } - -#pragma mark - Container - - typedef typename contents_type::const_iterator const_iterator; - typedef typename contents_type::iterator iterator; - iterator begin() { return contents.begin(); } - iterator end() { return contents.end(); } - const_iterator begin() const { return contents.begin(); } - const_iterator end() const { return contents.end(); } - size_t size() const { return contents.size(); } - }; - - template - std::ostream& operator<<(std::ostream &stream, const transition_map &map) { - stream << std::string("["); - bool started = false; - for (auto pair : map) { - if (started) stream << std::string(", "); - stream << pair.first->to_string() << std::string(" => "); - stream << *pair.second; - started = true; - } - stream << std::string("]"); - return stream; - } -} - - -#endif diff --git a/src/compiler/rules/character_set.h b/src/compiler/rules/character_set.h index 064a39cf..5ee64470 100644 --- a/src/compiler/rules/character_set.h +++ b/src/compiler/rules/character_set.h @@ -52,8 +52,6 @@ namespace tree_sitter { std::set ranges; }; - - typedef std::shared_ptr char_ptr; } } diff --git a/src/compiler/rules/rules.cpp b/src/compiler/rules/rules.cpp index eadab77e..8e6a3fe0 100644 --- a/src/compiler/rules/rules.cpp +++ b/src/compiler/rules/rules.cpp @@ -11,16 +11,16 @@ namespace tree_sitter { return make_shared(); } - char_ptr character(char value) { + rule_ptr character(char value) { set ranges = { value }; return make_shared(ranges); } - char_ptr character(const set &ranges) { + rule_ptr character(const set &ranges) { return make_shared(ranges); } - char_ptr character(const set &ranges, bool sign) { + rule_ptr character(const set &ranges, bool sign) { return make_shared(ranges, sign); } @@ -52,7 +52,7 @@ namespace tree_sitter { return make_shared(value); } - sym_ptr sym(const string &name) { + rule_ptr sym(const string &name) { return make_shared(name, false); } diff --git a/src/compiler/rules/rules.h b/src/compiler/rules/rules.h index 8208ed36..02fee8b1 100644 --- a/src/compiler/rules/rules.h +++ b/src/compiler/rules/rules.h @@ -16,16 +16,16 @@ namespace tree_sitter { namespace rules { rule_ptr blank(); - char_ptr character(char value); - char_ptr character(const std::set &matches); - char_ptr character(const std::set &matches, bool); + rule_ptr character(char value); + rule_ptr character(const std::set &matches); + rule_ptr character(const std::set &matches, bool); rule_ptr choice(const std::vector &rules); rule_ptr pattern(const std::string &value); rule_ptr repeat(const rule_ptr content); rule_ptr seq(const std::vector &rules); rule_ptr str(const std::string &value); - sym_ptr sym(const std::string &name); + rule_ptr sym(const std::string &name); rule_ptr aux_sym(const std::string &name); } } diff --git a/src/compiler/rules/symbol.h b/src/compiler/rules/symbol.h index 27e3358c..6488cadb 100644 --- a/src/compiler/rules/symbol.h +++ b/src/compiler/rules/symbol.h @@ -22,8 +22,6 @@ namespace tree_sitter { std::string name; bool is_auxiliary; }; - - typedef std::shared_ptr sym_ptr; } } diff --git a/tree_sitter.xcodeproj/project.pbxproj b/tree_sitter.xcodeproj/project.pbxproj index b6ffe7bd..b22b737c 100644 --- a/tree_sitter.xcodeproj/project.pbxproj +++ b/tree_sitter.xcodeproj/project.pbxproj @@ -108,7 +108,6 @@ 12AB4663188DCB9800DE79DF /* stream_methods.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = stream_methods.h; sourceTree = ""; }; 12BC470318822A17005AC502 /* parse_config.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = parse_config.cpp; sourceTree = ""; }; 12BC470618830BC5005AC502 /* first_set_spec.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = first_set_spec.cpp; sourceTree = ""; }; - 12C344421822F27700B07BE3 /* transition_map.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = transition_map.h; path = ../build_tables/transition_map.h; sourceTree = ""; }; 12D1369E18342088005F3369 /* todo.md */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = todo.md; sourceTree = ""; }; 12D136A0183570F5005F3369 /* pattern_spec.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = pattern_spec.cpp; path = spec/compiler/rules/pattern_spec.cpp; sourceTree = SOURCE_ROOT; }; 12D136A2183678A2005F3369 /* repeat.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = repeat.cpp; sourceTree = ""; }; @@ -234,7 +233,6 @@ 12EDCFA518820137005A7A07 /* perform.h */, 12EDCFA618820137005A7A07 /* rule_transitions.cpp */, 12EDCFA718820137005A7A07 /* rule_transitions.h */, - 12C344421822F27700B07BE3 /* transition_map.h */, ); path = build_tables; sourceTree = "";