From 7d297f2f9e51796345365226a032cea7be24bf5f Mon Sep 17 00:00:00 2001 From: Max Brunsfeld Date: Tue, 28 Jan 2014 22:09:37 -0800 Subject: [PATCH] Remove auxiliary rules from syntax tree --- include/parser.h | 40 +- .../build_tables/item_set_closure_spec.cpp | 23 +- spec/compiler/build_tables/perform_spec.cpp | 2 +- spec/fixtures/parsers/arithmetic.c | 702 +++++++------ spec/fixtures/parsers/json.c | 978 +++++++++++------- spec/runtime/arithmetic_spec.cpp | 2 +- spec/runtime/json_spec.cpp | 6 +- src/compiler/build_tables/item.cpp | 13 +- src/compiler/build_tables/item.h | 7 +- .../build_tables/item_set_closure.cpp | 2 +- .../build_tables/item_set_transitions.cpp | 4 +- src/compiler/build_tables/perform.cpp | 12 +- src/compiler/generate_code/c_code.cpp | 13 +- src/compiler/parse_table.cpp | 19 +- src/compiler/parse_table.h | 8 +- 15 files changed, 1107 insertions(+), 724 deletions(-) diff --git a/include/parser.h b/include/parser.h index 5dcc671e..963d6c7d 100644 --- a/include/parser.h +++ b/include/parser.h @@ -7,6 +7,7 @@ extern "C" { #include "tree.h" #include "parse_config.h" #include +#include // #define TS_DEBUG_PARSE // #define TS_DEBUG_LEX @@ -88,16 +89,34 @@ static void TSParserShift(TSParser *parser, TSState parse_state) { parser->stack_size++; } -static void TSParserReduce(TSParser *parser, TSSymbol symbol, int child_count) { - parser->stack_size -= child_count; +static void TSParserReduce(TSParser *parser, TSSymbol symbol, int immediate_child_count, const int *collapse_flags) { + parser->stack_size -= immediate_child_count; - TSTree **children = malloc(child_count * sizeof(TSTree *)); - for (int i = 0; i < child_count; i++) { - children[i] = parser->stack[parser->stack_size + i].node; + int total_child_count = 0; + for (int i = 0; i < immediate_child_count; i++) { + TSTree *child = parser->stack[parser->stack_size + i].node; + if (collapse_flags[i]) { + total_child_count += child->child_count; + } else { + total_child_count++; + } + } + + TSTree **children = malloc(total_child_count * sizeof(TSTree *)); + int n = 0; + for (int i = 0; i < immediate_child_count; i++) { + TSTree *child = parser->stack[parser->stack_size + i].node; + if (collapse_flags[i]) { + memcpy(children + n, child->children, (child->child_count * sizeof(TSTree *))); + n += child->child_count; + } else { + children[n] = child; + n++; + } } parser->prev_lookahead_node = parser->lookahead_node; - parser->lookahead_node = TSTreeMake(symbol, child_count, children); + parser->lookahead_node = TSTreeMake(symbol, total_child_count, children); DEBUG_PARSE("reduce: %s, state: %u \n", ts_symbol_names[symbol], TSParserParseState(parser)); } @@ -173,8 +192,12 @@ parser->lex_state #define ADVANCE(state_index) \ { TSParserAdvance(parser, state_index); goto next_state; } -#define REDUCE(symbol, child_count) \ -{ TSParserReduce(parser, symbol, child_count); goto next_state; } +#define REDUCE(symbol, child_count, collapse_flags) \ +{ \ +static const int flags[] = collapse_flags; \ +TSParserReduce(parser, symbol, child_count, flags); \ +goto next_state; \ +} #define ACCEPT_INPUT() \ { TSParserAcceptInput(parser); goto done; } @@ -203,6 +226,7 @@ printf("Lex error: unexpected state %ud", LEX_STATE()); printf("Parse error: unexpected state %ud", PARSE_STATE()); #define EXPECT(...) __VA_ARGS__ +#define COLLAPSE(...) __VA_ARGS__ #define FINISH_PARSER() \ done: \ diff --git a/spec/compiler/build_tables/item_set_closure_spec.cpp b/spec/compiler/build_tables/item_set_closure_spec.cpp index 8daf4fe5..0c1ba836 100644 --- a/spec/compiler/build_tables/item_set_closure_spec.cpp +++ b/spec/compiler/build_tables/item_set_closure_spec.cpp @@ -30,22 +30,23 @@ describe("computing closures of item sets", []() { it("computes the item set closure", [&]() { ParseItemSet item_set = item_set_closure(ParseItemSet({ - ParseItem(Symbol("E"), grammar.rule(Symbol("E")), 0, Symbol("__END__")) + ParseItem(Symbol("E"), grammar.rule(Symbol("E")), {}, Symbol("__END__")) }), grammar); AssertThat(item_set, Equals(ParseItemSet({ - ParseItem(Symbol("F"), grammar.rule(Symbol("F")), 0, Symbol("__END__")), - ParseItem(Symbol("F"), grammar.rule(Symbol("F")), 0, Symbol("+")), - ParseItem(Symbol("F"), grammar.rule(Symbol("F")), 0, Symbol("*")), - ParseItem(Symbol("T"), grammar.rule(Symbol("T")), 0, Symbol("__END__")), - ParseItem(Symbol("T"), grammar.rule(Symbol("T")), 0, Symbol("+")), - ParseItem(Symbol("E"), grammar.rule(Symbol("E")), 0, Symbol("__END__")), + ParseItem(Symbol("F"), grammar.rule(Symbol("F")), {}, Symbol("__END__")), + ParseItem(Symbol("F"), grammar.rule(Symbol("F")), {}, Symbol("+")), + ParseItem(Symbol("F"), grammar.rule(Symbol("F")), {}, Symbol("*")), + ParseItem(Symbol("T"), grammar.rule(Symbol("T")), {}, Symbol("__END__")), + ParseItem(Symbol("T"), grammar.rule(Symbol("T")), {}, Symbol("+")), + ParseItem(Symbol("E"), grammar.rule(Symbol("E")), {}, Symbol("__END__")), }))); - ParseItemSet next_item_set = *sym_transitions(item_set, grammar)[rules::Symbol("v")]; + auto sym1 = rules::Symbol("v"); + ParseItemSet next_item_set = *sym_transitions(item_set, grammar)[sym1]; AssertThat(next_item_set, Equals(ParseItemSet({ - ParseItem(Symbol("F"), rules::blank(), 1, Symbol("__END__")), - ParseItem(Symbol("F"), rules::blank(), 1, Symbol("*")), - ParseItem(Symbol("F"), rules::blank(), 1, Symbol("+")), + ParseItem(Symbol("F"), rules::blank(), { sym1 }, Symbol("__END__")), + ParseItem(Symbol("F"), rules::blank(), { sym1 }, Symbol("*")), + ParseItem(Symbol("F"), rules::blank(), { sym1 }, Symbol("+")), }))); }); }); diff --git a/spec/compiler/build_tables/perform_spec.cpp b/spec/compiler/build_tables/perform_spec.cpp index c7d708f5..3d6256e0 100644 --- a/spec/compiler/build_tables/perform_spec.cpp +++ b/spec/compiler/build_tables/perform_spec.cpp @@ -101,7 +101,7 @@ describe("building parse and lex tables", []() { it("has the right next states", [&]() { AssertThat(parse_state(2).actions, Equals(unordered_map({ { Symbol("plus"), parse_actions({ ParseAction::Shift(3) }) }, - { Symbol("__END__"), parse_actions({ ParseAction::Reduce(Symbol("expression"), 1) }) }, + { Symbol("__END__"), parse_actions({ ParseAction::Reduce(Symbol("expression"), { false }) }) }, }))); }); }); diff --git a/spec/fixtures/parsers/arithmetic.c b/spec/fixtures/parsers/arithmetic.c index 551a8eb5..01ae8655 100644 --- a/spec/fixtures/parsers/arithmetic.c +++ b/spec/fixtures/parsers/arithmetic.c @@ -4,27 +4,27 @@ enum ts_symbol { ts_symbol_factor, ts_aux_token1, - ts_symbol_plus, ts_aux_token2, ts_symbol_number, - ts_symbol_variable, ts_symbol_times, - ts_symbol_term, - ts_symbol_expression, ts_symbol___END__, + ts_symbol_term, + ts_symbol_plus, + ts_symbol_expression, + ts_symbol_variable, }; static const char *ts_symbol_names[] = { "factor", "token1", - "plus", "token2", "number", - "variable", "times", - "term", - "expression", "__END__", + "term", + "plus", + "expression", + "variable", }; static void ts_lex(TSParser *parser) { @@ -117,19 +117,19 @@ static TSParseResult ts_parse(const char *input) { SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { case ts_symbol_factor: - SHIFT(45); + SHIFT(52); case ts_symbol_number: - SHIFT(41); + SHIFT(48); case ts_symbol_variable: - SHIFT(41); - case ts_aux_token1: - SHIFT(42); + SHIFT(47); case ts_symbol_term: SHIFT(2); + case ts_aux_token1: + SHIFT(49); case ts_symbol_expression: SHIFT(1); default: - PARSE_ERROR(6, EXPECT({"expression", "term", "token1", "number", "variable", "factor"})); + PARSE_ERROR(6, EXPECT({"expression", "token1", "term", "variable", "number", "factor"})); } case 1: SET_LEX_STATE(0); @@ -143,7 +143,7 @@ static TSParseResult ts_parse(const char *input) { SET_LEX_STATE(14); switch (LOOKAHEAD_SYM()) { case ts_symbol___END__: - REDUCE(ts_symbol_expression, 1); + REDUCE(ts_symbol_expression, 1, COLLAPSE({0})); case ts_symbol_plus: SHIFT(3); default: @@ -152,24 +152,24 @@ static TSParseResult ts_parse(const char *input) { case 3: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_number: - SHIFT(5); + case ts_aux_token1: + SHIFT(7); case ts_symbol_factor: - SHIFT(34); + SHIFT(39); + case ts_symbol_number: + SHIFT(6); case ts_symbol_variable: SHIFT(5); - case ts_aux_token1: - SHIFT(6); case ts_symbol_term: SHIFT(4); default: - PARSE_ERROR(5, EXPECT({"term", "token1", "variable", "factor", "number"})); + PARSE_ERROR(5, EXPECT({"term", "variable", "number", "factor", "token1"})); } case 4: SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { case ts_symbol___END__: - REDUCE(ts_symbol_expression, 3); + REDUCE(ts_symbol_expression, 3, COLLAPSE({0, 0, 0})); default: PARSE_ERROR(1, EXPECT({"__END__"})); } @@ -177,211 +177,207 @@ static TSParseResult ts_parse(const char *input) { SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { case ts_symbol_times: - REDUCE(ts_symbol_factor, 1); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); case ts_symbol___END__: - REDUCE(ts_symbol_factor, 1); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); default: PARSE_ERROR(2, EXPECT({"__END__", "times"})); } case 6: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_times: + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + case ts_symbol___END__: + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + default: + PARSE_ERROR(2, EXPECT({"__END__", "times"})); + } + case 7: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { case ts_symbol_factor: - SHIFT(16); + SHIFT(19); case ts_symbol_expression: - SHIFT(32); - case ts_symbol_number: - SHIFT(12); - case ts_symbol_variable: - SHIFT(12); + SHIFT(37); case ts_aux_token1: - SHIFT(13); + SHIFT(16); + case ts_symbol_number: + SHIFT(15); + case ts_symbol_variable: + SHIFT(14); case ts_symbol_term: - SHIFT(7); + SHIFT(8); default: - PARSE_ERROR(6, EXPECT({"term", "token1", "number", "expression", "variable", "factor"})); + PARSE_ERROR(6, EXPECT({"term", "variable", "token1", "expression", "number", "factor"})); } - case 7: + case 8: SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - REDUCE(ts_symbol_expression, 1); + REDUCE(ts_symbol_expression, 1, COLLAPSE({0})); case ts_symbol_plus: - SHIFT(8); + SHIFT(9); default: PARSE_ERROR(2, EXPECT({"plus", "token2"})); } - case 8: + case 9: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_number: - SHIFT(10); - case ts_symbol_factor: - SHIFT(25); - case ts_symbol_variable: - SHIFT(10); case ts_aux_token1: + SHIFT(13); + case ts_symbol_factor: + SHIFT(29); + case ts_symbol_number: + SHIFT(12); + case ts_symbol_variable: SHIFT(11); case ts_symbol_term: - SHIFT(9); + SHIFT(10); default: - PARSE_ERROR(5, EXPECT({"term", "token1", "variable", "factor", "number"})); + PARSE_ERROR(5, EXPECT({"term", "variable", "number", "factor", "token1"})); } - case 9: + case 10: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - REDUCE(ts_symbol_expression, 3); + REDUCE(ts_symbol_expression, 3, COLLAPSE({0, 0, 0})); default: PARSE_ERROR(1, EXPECT({"token2"})); } - case 10: + case 11: SET_LEX_STATE(6); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - REDUCE(ts_symbol_factor, 1); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); case ts_symbol_times: - REDUCE(ts_symbol_factor, 1); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); default: PARSE_ERROR(2, EXPECT({"times", "token2"})); } - case 11: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(16); - case ts_symbol_expression: - SHIFT(23); - case ts_symbol_number: - SHIFT(12); - case ts_symbol_variable: - SHIFT(12); - case ts_aux_token1: - SHIFT(13); - case ts_symbol_term: - SHIFT(7); - default: - PARSE_ERROR(6, EXPECT({"term", "token1", "number", "expression", "variable", "factor"})); - } case 12: - SET_LEX_STATE(7); + SET_LEX_STATE(6); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - REDUCE(ts_symbol_factor, 1); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); case ts_symbol_times: - REDUCE(ts_symbol_factor, 1); - case ts_symbol_plus: - REDUCE(ts_symbol_factor, 1); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); default: - PARSE_ERROR(3, EXPECT({"plus", "times", "token2"})); + PARSE_ERROR(2, EXPECT({"times", "token2"})); } case 13: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { case ts_symbol_factor: - SHIFT(16); + SHIFT(19); case ts_symbol_expression: - SHIFT(14); - case ts_symbol_number: - SHIFT(12); - case ts_symbol_variable: - SHIFT(12); + SHIFT(27); case ts_aux_token1: - SHIFT(13); + SHIFT(16); + case ts_symbol_number: + SHIFT(15); + case ts_symbol_variable: + SHIFT(14); case ts_symbol_term: - SHIFT(7); + SHIFT(8); default: - PARSE_ERROR(6, EXPECT({"term", "token1", "number", "expression", "variable", "factor"})); + PARSE_ERROR(6, EXPECT({"term", "variable", "token1", "expression", "number", "factor"})); } case 14: - SET_LEX_STATE(4); + SET_LEX_STATE(7); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - SHIFT(15); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + case ts_symbol_times: + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + case ts_symbol_plus: + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); default: - PARSE_ERROR(1, EXPECT({"token2"})); + PARSE_ERROR(3, EXPECT({"plus", "times", "token2"})); } case 15: SET_LEX_STATE(7); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - REDUCE(ts_symbol_factor, 3); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); case ts_symbol_times: - REDUCE(ts_symbol_factor, 3); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); case ts_symbol_plus: - REDUCE(ts_symbol_factor, 3); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); default: PARSE_ERROR(3, EXPECT({"plus", "times", "token2"})); } case 16: - SET_LEX_STATE(7); + SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_plus: - REDUCE(ts_symbol_term, 1); - case ts_aux_token2: - REDUCE(ts_symbol_term, 1); - case ts_symbol_times: + case ts_symbol_factor: + SHIFT(19); + case ts_symbol_expression: SHIFT(17); + case ts_aux_token1: + SHIFT(16); + case ts_symbol_number: + SHIFT(15); + case ts_symbol_variable: + SHIFT(14); + case ts_symbol_term: + SHIFT(8); default: - PARSE_ERROR(3, EXPECT({"times", "token2", "plus"})); + PARSE_ERROR(6, EXPECT({"term", "variable", "token1", "expression", "number", "factor"})); } case 17: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token1: - SHIFT(19); - case ts_symbol_number: - SHIFT(18); - case ts_symbol_factor: - SHIFT(22); - case ts_symbol_variable: - SHIFT(18); - default: - PARSE_ERROR(4, EXPECT({"variable", "factor", "number", "token1"})); - } - case 18: - SET_LEX_STATE(9); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - REDUCE(ts_symbol_factor, 1); - case ts_symbol_plus: - REDUCE(ts_symbol_factor, 1); - default: - PARSE_ERROR(2, EXPECT({"plus", "token2"})); - } - case 19: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(16); - case ts_symbol_expression: - SHIFT(20); - case ts_symbol_number: - SHIFT(12); - case ts_symbol_variable: - SHIFT(12); - case ts_aux_token1: - SHIFT(13); - case ts_symbol_term: - SHIFT(7); - default: - PARSE_ERROR(6, EXPECT({"term", "token1", "number", "expression", "variable", "factor"})); - } - case 20: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - SHIFT(21); + SHIFT(18); default: PARSE_ERROR(1, EXPECT({"token2"})); } + case 18: + SET_LEX_STATE(7); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + case ts_symbol_times: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + case ts_symbol_plus: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + default: + PARSE_ERROR(3, EXPECT({"plus", "times", "token2"})); + } + case 19: + SET_LEX_STATE(7); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_plus: + REDUCE(ts_symbol_term, 1, COLLAPSE({0})); + case ts_aux_token2: + REDUCE(ts_symbol_term, 1, COLLAPSE({0})); + case ts_symbol_times: + SHIFT(20); + default: + PARSE_ERROR(3, EXPECT({"times", "token2", "plus"})); + } + case 20: + SET_LEX_STATE(10); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token1: + SHIFT(23); + case ts_symbol_factor: + SHIFT(26); + case ts_symbol_number: + SHIFT(22); + case ts_symbol_variable: + SHIFT(21); + default: + PARSE_ERROR(4, EXPECT({"variable", "number", "factor", "token1"})); + } case 21: SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - REDUCE(ts_symbol_factor, 3); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); case ts_symbol_plus: - REDUCE(ts_symbol_factor, 3); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); default: PARSE_ERROR(2, EXPECT({"plus", "token2"})); } @@ -389,101 +385,105 @@ static TSParseResult ts_parse(const char *input) { SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - REDUCE(ts_symbol_term, 3); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); case ts_symbol_plus: - REDUCE(ts_symbol_term, 3); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); default: PARSE_ERROR(2, EXPECT({"plus", "token2"})); } case 23: + SET_LEX_STATE(10); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_factor: + SHIFT(19); + case ts_symbol_expression: + SHIFT(24); + case ts_aux_token1: + SHIFT(16); + case ts_symbol_number: + SHIFT(15); + case ts_symbol_variable: + SHIFT(14); + case ts_symbol_term: + SHIFT(8); + default: + PARSE_ERROR(6, EXPECT({"term", "variable", "token1", "expression", "number", "factor"})); + } + case 24: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - SHIFT(24); + SHIFT(25); default: PARSE_ERROR(1, EXPECT({"token2"})); } - case 24: - SET_LEX_STATE(6); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - REDUCE(ts_symbol_factor, 3); - case ts_symbol_times: - REDUCE(ts_symbol_factor, 3); - default: - PARSE_ERROR(2, EXPECT({"times", "token2"})); - } case 25: - SET_LEX_STATE(6); + SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - REDUCE(ts_symbol_term, 1); - case ts_symbol_times: - SHIFT(26); + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + case ts_symbol_plus: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); default: - PARSE_ERROR(2, EXPECT({"times", "token2"})); + PARSE_ERROR(2, EXPECT({"plus", "token2"})); } case 26: - SET_LEX_STATE(10); + SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { - case ts_aux_token1: - SHIFT(28); - case ts_symbol_number: - SHIFT(27); - case ts_symbol_factor: - SHIFT(31); - case ts_symbol_variable: - SHIFT(27); + case ts_aux_token2: + REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); + case ts_symbol_plus: + REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); default: - PARSE_ERROR(4, EXPECT({"variable", "factor", "number", "token1"})); + PARSE_ERROR(2, EXPECT({"plus", "token2"})); } case 27: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - REDUCE(ts_symbol_factor, 1); + SHIFT(28); default: PARSE_ERROR(1, EXPECT({"token2"})); } case 28: - SET_LEX_STATE(10); + SET_LEX_STATE(6); switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(16); - case ts_symbol_expression: - SHIFT(29); - case ts_symbol_number: - SHIFT(12); - case ts_symbol_variable: - SHIFT(12); - case ts_aux_token1: - SHIFT(13); - case ts_symbol_term: - SHIFT(7); + case ts_aux_token2: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + case ts_symbol_times: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); default: - PARSE_ERROR(6, EXPECT({"term", "token1", "number", "expression", "variable", "factor"})); + PARSE_ERROR(2, EXPECT({"times", "token2"})); } case 29: - SET_LEX_STATE(4); + SET_LEX_STATE(6); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: + REDUCE(ts_symbol_term, 1, COLLAPSE({0})); + case ts_symbol_times: SHIFT(30); default: - PARSE_ERROR(1, EXPECT({"token2"})); + PARSE_ERROR(2, EXPECT({"times", "token2"})); } case 30: - SET_LEX_STATE(4); + SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - REDUCE(ts_symbol_factor, 3); + case ts_aux_token1: + SHIFT(33); + case ts_symbol_factor: + SHIFT(36); + case ts_symbol_number: + SHIFT(32); + case ts_symbol_variable: + SHIFT(31); default: - PARSE_ERROR(1, EXPECT({"token2"})); + PARSE_ERROR(4, EXPECT({"variable", "number", "factor", "token1"})); } case 31: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - REDUCE(ts_symbol_term, 3); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); default: PARSE_ERROR(1, EXPECT({"token2"})); } @@ -491,223 +491,303 @@ static TSParseResult ts_parse(const char *input) { SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - SHIFT(33); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); default: PARSE_ERROR(1, EXPECT({"token2"})); } case 33: + SET_LEX_STATE(10); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_factor: + SHIFT(19); + case ts_symbol_expression: + SHIFT(34); + case ts_aux_token1: + SHIFT(16); + case ts_symbol_number: + SHIFT(15); + case ts_symbol_variable: + SHIFT(14); + case ts_symbol_term: + SHIFT(8); + default: + PARSE_ERROR(6, EXPECT({"term", "variable", "token1", "expression", "number", "factor"})); + } + case 34: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + SHIFT(35); + default: + PARSE_ERROR(1, EXPECT({"token2"})); + } + case 35: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + default: + PARSE_ERROR(1, EXPECT({"token2"})); + } + case 36: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); + default: + PARSE_ERROR(1, EXPECT({"token2"})); + } + case 37: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + SHIFT(38); + default: + PARSE_ERROR(1, EXPECT({"token2"})); + } + case 38: SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { case ts_symbol_times: - REDUCE(ts_symbol_factor, 3); + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); case ts_symbol___END__: - REDUCE(ts_symbol_factor, 3); + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); default: PARSE_ERROR(2, EXPECT({"__END__", "times"})); } - case 34: + case 39: SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { case ts_symbol___END__: - REDUCE(ts_symbol_term, 1); + REDUCE(ts_symbol_term, 1, COLLAPSE({0})); case ts_symbol_times: - SHIFT(35); + SHIFT(40); default: PARSE_ERROR(2, EXPECT({"times", "__END__"})); } - case 35: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token1: - SHIFT(37); - case ts_symbol_number: - SHIFT(36); - case ts_symbol_factor: - SHIFT(40); - case ts_symbol_variable: - SHIFT(36); - default: - PARSE_ERROR(4, EXPECT({"variable", "factor", "number", "token1"})); - } - case 36: - SET_LEX_STATE(0); - switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: - REDUCE(ts_symbol_factor, 1); - default: - PARSE_ERROR(1, EXPECT({"__END__"})); - } - case 37: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(16); - case ts_symbol_expression: - SHIFT(38); - case ts_symbol_number: - SHIFT(12); - case ts_symbol_variable: - SHIFT(12); - case ts_aux_token1: - SHIFT(13); - case ts_symbol_term: - SHIFT(7); - default: - PARSE_ERROR(6, EXPECT({"term", "token1", "number", "expression", "variable", "factor"})); - } - case 38: - SET_LEX_STATE(4); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - SHIFT(39); - default: - PARSE_ERROR(1, EXPECT({"token2"})); - } - case 39: - SET_LEX_STATE(0); - switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: - REDUCE(ts_symbol_factor, 3); - default: - PARSE_ERROR(1, EXPECT({"__END__"})); - } case 40: - SET_LEX_STATE(0); + SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol___END__: - REDUCE(ts_symbol_term, 3); + case ts_aux_token1: + SHIFT(43); + case ts_symbol_factor: + SHIFT(46); + case ts_symbol_number: + SHIFT(42); + case ts_symbol_variable: + SHIFT(41); default: - PARSE_ERROR(1, EXPECT({"__END__"})); + PARSE_ERROR(4, EXPECT({"variable", "number", "factor", "token1"})); } case 41: - SET_LEX_STATE(15); + SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { - case ts_symbol_times: - REDUCE(ts_symbol_factor, 1); - case ts_symbol_plus: - REDUCE(ts_symbol_factor, 1); case ts_symbol___END__: - REDUCE(ts_symbol_factor, 1); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); default: - PARSE_ERROR(3, EXPECT({"__END__", "plus", "times"})); + PARSE_ERROR(1, EXPECT({"__END__"})); } case 42: + SET_LEX_STATE(0); + switch (LOOKAHEAD_SYM()) { + case ts_symbol___END__: + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + default: + PARSE_ERROR(1, EXPECT({"__END__"})); + } + case 43: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { case ts_symbol_factor: - SHIFT(16); + SHIFT(19); case ts_symbol_expression: - SHIFT(43); - case ts_symbol_number: - SHIFT(12); - case ts_symbol_variable: - SHIFT(12); + SHIFT(44); case ts_aux_token1: - SHIFT(13); + SHIFT(16); + case ts_symbol_number: + SHIFT(15); + case ts_symbol_variable: + SHIFT(14); case ts_symbol_term: - SHIFT(7); + SHIFT(8); default: - PARSE_ERROR(6, EXPECT({"term", "token1", "number", "expression", "variable", "factor"})); + PARSE_ERROR(6, EXPECT({"term", "variable", "token1", "expression", "number", "factor"})); } - case 43: + case 44: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - SHIFT(44); + SHIFT(45); default: PARSE_ERROR(1, EXPECT({"token2"})); } - case 44: + case 45: + SET_LEX_STATE(0); + switch (LOOKAHEAD_SYM()) { + case ts_symbol___END__: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + default: + PARSE_ERROR(1, EXPECT({"__END__"})); + } + case 46: + SET_LEX_STATE(0); + switch (LOOKAHEAD_SYM()) { + case ts_symbol___END__: + REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); + default: + PARSE_ERROR(1, EXPECT({"__END__"})); + } + case 47: SET_LEX_STATE(15); switch (LOOKAHEAD_SYM()) { case ts_symbol_times: - REDUCE(ts_symbol_factor, 3); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); case ts_symbol_plus: - REDUCE(ts_symbol_factor, 3); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); case ts_symbol___END__: - REDUCE(ts_symbol_factor, 3); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); default: PARSE_ERROR(3, EXPECT({"__END__", "plus", "times"})); } - case 45: + case 48: + SET_LEX_STATE(15); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_times: + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + case ts_symbol_plus: + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + case ts_symbol___END__: + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + default: + PARSE_ERROR(3, EXPECT({"__END__", "plus", "times"})); + } + case 49: + SET_LEX_STATE(10); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_factor: + SHIFT(19); + case ts_symbol_expression: + SHIFT(50); + case ts_aux_token1: + SHIFT(16); + case ts_symbol_number: + SHIFT(15); + case ts_symbol_variable: + SHIFT(14); + case ts_symbol_term: + SHIFT(8); + default: + PARSE_ERROR(6, EXPECT({"term", "variable", "token1", "expression", "number", "factor"})); + } + case 50: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + SHIFT(51); + default: + PARSE_ERROR(1, EXPECT({"token2"})); + } + case 51: + SET_LEX_STATE(15); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_times: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + case ts_symbol_plus: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + case ts_symbol___END__: + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); + default: + PARSE_ERROR(3, EXPECT({"__END__", "plus", "times"})); + } + case 52: SET_LEX_STATE(15); switch (LOOKAHEAD_SYM()) { case ts_symbol_plus: - REDUCE(ts_symbol_term, 1); + REDUCE(ts_symbol_term, 1, COLLAPSE({0})); case ts_symbol___END__: - REDUCE(ts_symbol_term, 1); + REDUCE(ts_symbol_term, 1, COLLAPSE({0})); case ts_symbol_times: - SHIFT(46); + SHIFT(53); default: PARSE_ERROR(3, EXPECT({"times", "__END__", "plus"})); } - case 46: + case 53: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { case ts_aux_token1: - SHIFT(48); - case ts_symbol_number: - SHIFT(47); + SHIFT(56); case ts_symbol_factor: - SHIFT(51); + SHIFT(59); + case ts_symbol_number: + SHIFT(55); case ts_symbol_variable: - SHIFT(47); + SHIFT(54); default: - PARSE_ERROR(4, EXPECT({"variable", "factor", "number", "token1"})); + PARSE_ERROR(4, EXPECT({"variable", "number", "factor", "token1"})); } - case 47: + case 54: SET_LEX_STATE(14); switch (LOOKAHEAD_SYM()) { case ts_symbol_plus: - REDUCE(ts_symbol_factor, 1); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); case ts_symbol___END__: - REDUCE(ts_symbol_factor, 1); + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); default: PARSE_ERROR(2, EXPECT({"__END__", "plus"})); } - case 48: + case 55: + SET_LEX_STATE(14); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_plus: + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + case ts_symbol___END__: + REDUCE(ts_symbol_factor, 1, COLLAPSE({0})); + default: + PARSE_ERROR(2, EXPECT({"__END__", "plus"})); + } + case 56: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { case ts_symbol_factor: - SHIFT(16); + SHIFT(19); case ts_symbol_expression: - SHIFT(49); - case ts_symbol_number: - SHIFT(12); - case ts_symbol_variable: - SHIFT(12); + SHIFT(57); case ts_aux_token1: - SHIFT(13); + SHIFT(16); + case ts_symbol_number: + SHIFT(15); + case ts_symbol_variable: + SHIFT(14); case ts_symbol_term: - SHIFT(7); + SHIFT(8); default: - PARSE_ERROR(6, EXPECT({"term", "token1", "number", "expression", "variable", "factor"})); + PARSE_ERROR(6, EXPECT({"term", "variable", "token1", "expression", "number", "factor"})); } - case 49: + case 57: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - SHIFT(50); + SHIFT(58); default: PARSE_ERROR(1, EXPECT({"token2"})); } - case 50: + case 58: SET_LEX_STATE(14); switch (LOOKAHEAD_SYM()) { case ts_symbol_plus: - REDUCE(ts_symbol_factor, 3); + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); case ts_symbol___END__: - REDUCE(ts_symbol_factor, 3); + REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1})); default: PARSE_ERROR(2, EXPECT({"__END__", "plus"})); } - case 51: + case 59: SET_LEX_STATE(14); switch (LOOKAHEAD_SYM()) { case ts_symbol_plus: - REDUCE(ts_symbol_term, 3); + REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); case ts_symbol___END__: - REDUCE(ts_symbol_term, 3); + REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0})); default: PARSE_ERROR(2, EXPECT({"__END__", "plus"})); } diff --git a/spec/fixtures/parsers/json.c b/spec/fixtures/parsers/json.c index 60664e5a..6b583e9b 100644 --- a/spec/fixtures/parsers/json.c +++ b/spec/fixtures/parsers/json.c @@ -5,36 +5,36 @@ enum ts_symbol { ts_symbol_number, ts_symbol_string, ts_aux_repeat_helper1, - ts_aux_token1, - ts_aux_token5, + ts_aux_token7, ts_symbol_array, ts_aux_token4, + ts_aux_token5, ts_aux_token3, - ts_aux_token7, ts_aux_token2, - ts_symbol___END__, - ts_symbol_object, - ts_aux_token6, + ts_aux_token1, ts_aux_repeat_helper2, + ts_aux_token6, ts_symbol_value, + ts_symbol_object, + ts_symbol___END__, }; static const char *ts_symbol_names[] = { "number", "string", "repeat_helper1", - "token1", - "token5", + "token7", "array", "token4", + "token5", "token3", - "token7", "token2", - "__END__", - "object", - "token6", + "token1", "repeat_helper2", + "token6", "value", + "object", + "__END__", }; static void ts_lex(TSParser *parser) { @@ -129,21 +129,21 @@ static TSParseResult ts_parse(const char *input) { SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { case ts_symbol_number: - SHIFT(53); - case ts_symbol_array: - SHIFT(53); - case ts_symbol_string: - SHIFT(53); + SHIFT(81); case ts_aux_token5: - SHIFT(47); + SHIFT(70); + case ts_symbol_array: + SHIFT(79); + case ts_symbol_object: + SHIFT(78); case ts_aux_token1: SHIFT(2); - case ts_symbol_object: - SHIFT(53); + case ts_symbol_string: + SHIFT(80); case ts_symbol_value: SHIFT(1); default: - PARSE_ERROR(7, EXPECT({"value", "object", "token1", "token5", "string", "array", "number"})); + PARSE_ERROR(7, EXPECT({"value", "string", "token1", "object", "array", "token5", "number"})); } case 1: SET_LEX_STATE(0); @@ -157,49 +157,49 @@ static TSParseResult ts_parse(const char *input) { SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { case ts_symbol_number: - SHIFT(25); - case ts_symbol_array: - SHIFT(25); - case ts_symbol_string: - SHIFT(25); + SHIFT(36); case ts_aux_token5: - SHIFT(12); + SHIFT(16); + case ts_symbol_array: + SHIFT(34); case ts_symbol_object: - SHIFT(25); + SHIFT(33); + case ts_symbol_string: + SHIFT(35); case ts_symbol_value: - SHIFT(44); + SHIFT(65); case ts_aux_token1: SHIFT(3); default: - PARSE_ERROR(7, EXPECT({"token1", "value", "object", "token5", "string", "array", "number"})); + PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"})); } case 3: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { case ts_symbol_number: - SHIFT(25); - case ts_symbol_array: - SHIFT(25); - case ts_symbol_string: - SHIFT(25); + SHIFT(36); case ts_aux_token5: - SHIFT(12); + SHIFT(16); + case ts_symbol_array: + SHIFT(34); case ts_symbol_object: - SHIFT(25); + SHIFT(33); + case ts_symbol_string: + SHIFT(35); case ts_symbol_value: SHIFT(4); case ts_aux_token1: SHIFT(3); default: - PARSE_ERROR(7, EXPECT({"token1", "value", "object", "token5", "string", "array", "number"})); + PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"})); } case 4: SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - SHIFT(7); + SHIFT(9); case ts_aux_token3: - SHIFT(5); + SHIFT(7); case ts_aux_repeat_helper2: SHIFT(5); default: @@ -217,533 +217,787 @@ static TSParseResult ts_parse(const char *input) { SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { case ts_aux_token3: - REDUCE(ts_symbol_array, 4); + REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); case ts_aux_token2: - REDUCE(ts_symbol_array, 4); + REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); default: PARSE_ERROR(2, EXPECT({"token2", "token3"})); } case 7: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_number: - SHIFT(43); - case ts_symbol_array: - SHIFT(43); - case ts_symbol_object: - SHIFT(43); - case ts_symbol_value: - SHIFT(41); - case ts_symbol_string: - SHIFT(43); - case ts_aux_token5: - SHIFT(35); - case ts_aux_token1: - SHIFT(8); - default: - PARSE_ERROR(7, EXPECT({"token1", "token5", "string", "value", "object", "array", "number"})); - } - case 8: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_number: - SHIFT(25); - case ts_symbol_array: - SHIFT(25); - case ts_symbol_string: - SHIFT(25); - case ts_aux_token5: - SHIFT(12); - case ts_symbol_object: - SHIFT(25); - case ts_symbol_value: - SHIFT(9); - case ts_aux_token1: - SHIFT(3); - default: - PARSE_ERROR(7, EXPECT({"token1", "value", "object", "token5", "string", "array", "number"})); - } - case 9: - SET_LEX_STATE(2); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - SHIFT(7); - case ts_aux_token3: - SHIFT(10); - case ts_aux_repeat_helper2: - SHIFT(10); - default: - PARSE_ERROR(3, EXPECT({"repeat_helper2", "token3", "token2"})); - } - case 10: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token4: - SHIFT(11); + SHIFT(8); default: PARSE_ERROR(1, EXPECT({"token4"})); } + case 8: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token3: + REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); + case ts_aux_token2: + REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); + default: + PARSE_ERROR(2, EXPECT({"token2", "token3"})); + } + case 9: + SET_LEX_STATE(10); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_number: + SHIFT(64); + case ts_aux_token5: + SHIFT(51); + case ts_symbol_array: + SHIFT(62); + case ts_symbol_object: + SHIFT(61); + case ts_symbol_string: + SHIFT(63); + case ts_symbol_value: + SHIFT(59); + case ts_aux_token1: + SHIFT(10); + default: + PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"})); + } + case 10: + SET_LEX_STATE(10); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_number: + SHIFT(36); + case ts_aux_token5: + SHIFT(16); + case ts_symbol_array: + SHIFT(34); + case ts_symbol_object: + SHIFT(33); + case ts_symbol_string: + SHIFT(35); + case ts_symbol_value: + SHIFT(11); + case ts_aux_token1: + SHIFT(3); + default: + PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"})); + } case 11: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + SHIFT(9); + case ts_aux_token3: + SHIFT(14); + case ts_aux_repeat_helper2: + SHIFT(12); + default: + PARSE_ERROR(3, EXPECT({"repeat_helper2", "token3", "token2"})); + } + case 12: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token4: + SHIFT(13); + default: + PARSE_ERROR(1, EXPECT({"token4"})); + } + case 13: SET_LEX_STATE(6); switch (LOOKAHEAD_SYM()) { case ts_aux_token4: - REDUCE(ts_symbol_array, 4); + REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); case ts_aux_token2: - REDUCE(ts_symbol_array, 4); + REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); default: PARSE_ERROR(2, EXPECT({"token2", "token4"})); } - case 12: - SET_LEX_STATE(19); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_string: - SHIFT(13); - default: - PARSE_ERROR(1, EXPECT({"string"})); - } - case 13: - SET_LEX_STATE(17); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token6: - SHIFT(14); - default: - PARSE_ERROR(1, EXPECT({"token6"})); - } case 14: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_number: - SHIFT(25); - case ts_symbol_array: - SHIFT(25); - case ts_symbol_object: - SHIFT(25); - case ts_symbol_value: - SHIFT(15); - case ts_symbol_string: - SHIFT(25); - case ts_aux_token5: - SHIFT(12); - case ts_aux_token1: - SHIFT(3); - default: - PARSE_ERROR(7, EXPECT({"token1", "token5", "string", "value", "object", "array", "number"})); - } - case 15: - SET_LEX_STATE(2); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - SHIFT(18); - case ts_aux_token3: - SHIFT(16); - case ts_aux_repeat_helper1: - SHIFT(16); - default: - PARSE_ERROR(3, EXPECT({"repeat_helper1", "token3", "token2"})); - } - case 16: - SET_LEX_STATE(7); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token7: - SHIFT(17); - default: - PARSE_ERROR(1, EXPECT({"token7"})); - } - case 17: - SET_LEX_STATE(2); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token3: - REDUCE(ts_symbol_object, 6); - case ts_aux_token2: - REDUCE(ts_symbol_object, 6); - default: - PARSE_ERROR(2, EXPECT({"token2", "token3"})); - } - case 18: - SET_LEX_STATE(19); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_string: - SHIFT(19); - default: - PARSE_ERROR(1, EXPECT({"string"})); - } - case 19: - SET_LEX_STATE(17); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token6: - SHIFT(20); - default: - PARSE_ERROR(1, EXPECT({"token6"})); - } - case 20: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_number: - SHIFT(34); - case ts_symbol_array: - SHIFT(34); - case ts_symbol_object: - SHIFT(34); - case ts_symbol_value: - SHIFT(32); - case ts_symbol_string: - SHIFT(34); - case ts_aux_token5: - SHIFT(26); - case ts_aux_token1: - SHIFT(21); - default: - PARSE_ERROR(7, EXPECT({"token1", "token5", "string", "value", "object", "array", "number"})); - } - case 21: - SET_LEX_STATE(10); - switch (LOOKAHEAD_SYM()) { - case ts_symbol_number: - SHIFT(25); - case ts_symbol_array: - SHIFT(25); - case ts_symbol_string: - SHIFT(25); - case ts_aux_token5: - SHIFT(12); - case ts_symbol_object: - SHIFT(25); - case ts_symbol_value: - SHIFT(22); - case ts_aux_token1: - SHIFT(3); - default: - PARSE_ERROR(7, EXPECT({"token1", "value", "object", "token5", "string", "array", "number"})); - } - case 22: - SET_LEX_STATE(2); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token2: - SHIFT(7); - case ts_aux_token3: - SHIFT(23); - case ts_aux_repeat_helper2: - SHIFT(23); - default: - PARSE_ERROR(3, EXPECT({"repeat_helper2", "token3", "token2"})); - } - case 23: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token4: - SHIFT(24); + SHIFT(15); default: PARSE_ERROR(1, EXPECT({"token4"})); } - case 24: - SET_LEX_STATE(9); + case 15: + SET_LEX_STATE(6); switch (LOOKAHEAD_SYM()) { - case ts_aux_token7: - REDUCE(ts_symbol_array, 4); + case ts_aux_token4: + REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); case ts_aux_token2: - REDUCE(ts_symbol_array, 4); + REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); default: - PARSE_ERROR(2, EXPECT({"token2", "token7"})); + PARSE_ERROR(2, EXPECT({"token2", "token4"})); } - case 25: - SET_LEX_STATE(2); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token3: - REDUCE(ts_symbol_value, 1); - case ts_aux_token2: - REDUCE(ts_symbol_value, 1); - default: - PARSE_ERROR(2, EXPECT({"token2", "token3"})); - } - case 26: + case 16: SET_LEX_STATE(19); switch (LOOKAHEAD_SYM()) { case ts_symbol_string: - SHIFT(27); + SHIFT(17); default: PARSE_ERROR(1, EXPECT({"string"})); } - case 27: + case 17: SET_LEX_STATE(17); switch (LOOKAHEAD_SYM()) { case ts_aux_token6: - SHIFT(28); + SHIFT(18); default: PARSE_ERROR(1, EXPECT({"token6"})); } - case 28: + case 18: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { case ts_symbol_number: - SHIFT(25); - case ts_symbol_array: - SHIFT(25); - case ts_symbol_object: - SHIFT(25); - case ts_symbol_value: - SHIFT(29); - case ts_symbol_string: - SHIFT(25); + SHIFT(36); case ts_aux_token5: - SHIFT(12); + SHIFT(16); + case ts_symbol_array: + SHIFT(34); + case ts_symbol_object: + SHIFT(33); + case ts_symbol_string: + SHIFT(35); + case ts_symbol_value: + SHIFT(19); case ts_aux_token1: SHIFT(3); default: - PARSE_ERROR(7, EXPECT({"token1", "token5", "string", "value", "object", "array", "number"})); + PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"})); } - case 29: + case 19: SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - SHIFT(18); + SHIFT(24); case ts_aux_token3: - SHIFT(30); + SHIFT(22); case ts_aux_repeat_helper1: - SHIFT(30); + SHIFT(20); default: PARSE_ERROR(3, EXPECT({"repeat_helper1", "token3", "token2"})); } - case 30: + case 20: SET_LEX_STATE(7); switch (LOOKAHEAD_SYM()) { case ts_aux_token7: - SHIFT(31); + SHIFT(21); default: PARSE_ERROR(1, EXPECT({"token7"})); } - case 31: + case 21: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token3: + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + case ts_aux_token2: + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + default: + PARSE_ERROR(2, EXPECT({"token2", "token3"})); + } + case 22: + SET_LEX_STATE(7); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token7: + SHIFT(23); + default: + PARSE_ERROR(1, EXPECT({"token7"})); + } + case 23: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token3: + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + case ts_aux_token2: + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + default: + PARSE_ERROR(2, EXPECT({"token2", "token3"})); + } + case 24: + SET_LEX_STATE(19); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_string: + SHIFT(25); + default: + PARSE_ERROR(1, EXPECT({"string"})); + } + case 25: + SET_LEX_STATE(17); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token6: + SHIFT(26); + default: + PARSE_ERROR(1, EXPECT({"token6"})); + } + case 26: + SET_LEX_STATE(10); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_number: + SHIFT(50); + case ts_aux_token5: + SHIFT(37); + case ts_symbol_array: + SHIFT(48); + case ts_symbol_object: + SHIFT(47); + case ts_symbol_string: + SHIFT(49); + case ts_symbol_value: + SHIFT(45); + case ts_aux_token1: + SHIFT(27); + default: + PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"})); + } + case 27: + SET_LEX_STATE(10); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_number: + SHIFT(36); + case ts_aux_token5: + SHIFT(16); + case ts_symbol_array: + SHIFT(34); + case ts_symbol_object: + SHIFT(33); + case ts_symbol_string: + SHIFT(35); + case ts_symbol_value: + SHIFT(28); + case ts_aux_token1: + SHIFT(3); + default: + PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"})); + } + case 28: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + SHIFT(9); + case ts_aux_token3: + SHIFT(31); + case ts_aux_repeat_helper2: + SHIFT(29); + default: + PARSE_ERROR(3, EXPECT({"repeat_helper2", "token3", "token2"})); + } + case 29: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token4: + SHIFT(30); + default: + PARSE_ERROR(1, EXPECT({"token4"})); + } + case 30: SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { case ts_aux_token7: - REDUCE(ts_symbol_object, 6); + REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); case ts_aux_token2: - REDUCE(ts_symbol_object, 6); + REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); default: PARSE_ERROR(2, EXPECT({"token2", "token7"})); } + case 31: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token4: + SHIFT(32); + default: + PARSE_ERROR(1, EXPECT({"token4"})); + } case 32: SET_LEX_STATE(9); switch (LOOKAHEAD_SYM()) { case ts_aux_token7: - REDUCE(ts_aux_repeat_helper1, 4); + REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); case ts_aux_token2: - SHIFT(18); - case ts_aux_repeat_helper1: - SHIFT(33); - default: - PARSE_ERROR(3, EXPECT({"repeat_helper1", "token2", "token7"})); - } - case 33: - SET_LEX_STATE(7); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token7: - REDUCE(ts_aux_repeat_helper1, 5); - default: - PARSE_ERROR(1, EXPECT({"token7"})); - } - case 34: - SET_LEX_STATE(9); - switch (LOOKAHEAD_SYM()) { - case ts_aux_token7: - REDUCE(ts_symbol_value, 1); - case ts_aux_token2: - REDUCE(ts_symbol_value, 1); + REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); default: PARSE_ERROR(2, EXPECT({"token2", "token7"})); } + case 33: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token3: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + case ts_aux_token2: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + default: + PARSE_ERROR(2, EXPECT({"token2", "token3"})); + } + case 34: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token3: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + case ts_aux_token2: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + default: + PARSE_ERROR(2, EXPECT({"token2", "token3"})); + } case 35: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token3: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + case ts_aux_token2: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + default: + PARSE_ERROR(2, EXPECT({"token2", "token3"})); + } + case 36: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token3: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + case ts_aux_token2: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + default: + PARSE_ERROR(2, EXPECT({"token2", "token3"})); + } + case 37: SET_LEX_STATE(19); switch (LOOKAHEAD_SYM()) { case ts_symbol_string: - SHIFT(36); + SHIFT(38); default: PARSE_ERROR(1, EXPECT({"string"})); } - case 36: + case 38: SET_LEX_STATE(17); switch (LOOKAHEAD_SYM()) { case ts_aux_token6: - SHIFT(37); + SHIFT(39); default: PARSE_ERROR(1, EXPECT({"token6"})); } - case 37: + case 39: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { case ts_symbol_number: - SHIFT(25); - case ts_symbol_array: - SHIFT(25); - case ts_symbol_object: - SHIFT(25); - case ts_symbol_value: - SHIFT(38); - case ts_symbol_string: - SHIFT(25); + SHIFT(36); case ts_aux_token5: - SHIFT(12); + SHIFT(16); + case ts_symbol_array: + SHIFT(34); + case ts_symbol_object: + SHIFT(33); + case ts_symbol_string: + SHIFT(35); + case ts_symbol_value: + SHIFT(40); case ts_aux_token1: SHIFT(3); default: - PARSE_ERROR(7, EXPECT({"token1", "token5", "string", "value", "object", "array", "number"})); + PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"})); } - case 38: + case 40: SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - SHIFT(18); + SHIFT(24); case ts_aux_token3: - SHIFT(39); + SHIFT(43); case ts_aux_repeat_helper1: - SHIFT(39); + SHIFT(41); default: PARSE_ERROR(3, EXPECT({"repeat_helper1", "token3", "token2"})); } - case 39: + case 41: SET_LEX_STATE(7); switch (LOOKAHEAD_SYM()) { case ts_aux_token7: - SHIFT(40); + SHIFT(42); default: PARSE_ERROR(1, EXPECT({"token7"})); } - case 40: + case 42: + SET_LEX_STATE(9); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token7: + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + case ts_aux_token2: + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + default: + PARSE_ERROR(2, EXPECT({"token2", "token7"})); + } + case 43: + SET_LEX_STATE(7); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token7: + SHIFT(44); + default: + PARSE_ERROR(1, EXPECT({"token7"})); + } + case 44: + SET_LEX_STATE(9); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token7: + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + case ts_aux_token2: + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + default: + PARSE_ERROR(2, EXPECT({"token2", "token7"})); + } + case 45: + SET_LEX_STATE(9); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + SHIFT(24); + case ts_aux_token7: + REDUCE(ts_aux_repeat_helper1, 4, COLLAPSE({1, 0, 1, 0})); + case ts_aux_repeat_helper1: + SHIFT(46); + default: + PARSE_ERROR(3, EXPECT({"repeat_helper1", "token7", "token2"})); + } + case 46: + 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_ERROR(1, EXPECT({"token7"})); + } + case 47: + SET_LEX_STATE(9); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token7: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + case ts_aux_token2: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + default: + PARSE_ERROR(2, EXPECT({"token2", "token7"})); + } + case 48: + SET_LEX_STATE(9); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token7: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + case ts_aux_token2: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + default: + PARSE_ERROR(2, EXPECT({"token2", "token7"})); + } + case 49: + SET_LEX_STATE(9); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token7: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + case ts_aux_token2: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + default: + PARSE_ERROR(2, EXPECT({"token2", "token7"})); + } + case 50: + SET_LEX_STATE(9); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token7: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + case ts_aux_token2: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + default: + PARSE_ERROR(2, EXPECT({"token2", "token7"})); + } + case 51: + SET_LEX_STATE(19); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_string: + SHIFT(52); + default: + PARSE_ERROR(1, EXPECT({"string"})); + } + case 52: + SET_LEX_STATE(17); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token6: + SHIFT(53); + default: + PARSE_ERROR(1, EXPECT({"token6"})); + } + case 53: + SET_LEX_STATE(10); + switch (LOOKAHEAD_SYM()) { + case ts_symbol_number: + SHIFT(36); + case ts_aux_token5: + SHIFT(16); + case ts_symbol_array: + SHIFT(34); + case ts_symbol_object: + SHIFT(33); + case ts_symbol_string: + SHIFT(35); + case ts_symbol_value: + SHIFT(54); + case ts_aux_token1: + SHIFT(3); + default: + PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"})); + } + case 54: + SET_LEX_STATE(2); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token2: + SHIFT(24); + case ts_aux_token3: + SHIFT(57); + case ts_aux_repeat_helper1: + SHIFT(55); + default: + PARSE_ERROR(3, EXPECT({"repeat_helper1", "token3", "token2"})); + } + case 55: + SET_LEX_STATE(7); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token7: + SHIFT(56); + default: + PARSE_ERROR(1, EXPECT({"token7"})); + } + case 56: SET_LEX_STATE(6); switch (LOOKAHEAD_SYM()) { case ts_aux_token4: - REDUCE(ts_symbol_object, 6); + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); case ts_aux_token2: - REDUCE(ts_symbol_object, 6); + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); default: PARSE_ERROR(2, EXPECT({"token2", "token4"})); } - case 41: + case 57: + SET_LEX_STATE(7); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token7: + SHIFT(58); + default: + PARSE_ERROR(1, EXPECT({"token7"})); + } + case 58: SET_LEX_STATE(6); switch (LOOKAHEAD_SYM()) { case ts_aux_token4: - REDUCE(ts_aux_repeat_helper2, 2); + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); case ts_aux_token2: - SHIFT(7); + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + default: + PARSE_ERROR(2, EXPECT({"token2", "token4"})); + } + case 59: + SET_LEX_STATE(6); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token4: + REDUCE(ts_aux_repeat_helper2, 2, COLLAPSE({1, 0})); + case ts_aux_token2: + SHIFT(9); case ts_aux_repeat_helper2: - SHIFT(42); + SHIFT(60); default: PARSE_ERROR(3, EXPECT({"repeat_helper2", "token2", "token4"})); } - case 42: + case 60: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token4: - REDUCE(ts_aux_repeat_helper2, 3); + REDUCE(ts_aux_repeat_helper2, 3, COLLAPSE({1, 0, 1})); default: PARSE_ERROR(1, EXPECT({"token4"})); } - case 43: + case 61: SET_LEX_STATE(6); switch (LOOKAHEAD_SYM()) { case ts_aux_token4: - REDUCE(ts_symbol_value, 1); + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); case ts_aux_token2: - REDUCE(ts_symbol_value, 1); + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); default: PARSE_ERROR(2, EXPECT({"token2", "token4"})); } - case 44: + case 62: + SET_LEX_STATE(6); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token4: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + case ts_aux_token2: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + default: + PARSE_ERROR(2, EXPECT({"token2", "token4"})); + } + case 63: + SET_LEX_STATE(6); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token4: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + case ts_aux_token2: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + default: + PARSE_ERROR(2, EXPECT({"token2", "token4"})); + } + case 64: + SET_LEX_STATE(6); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token4: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + case ts_aux_token2: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + default: + PARSE_ERROR(2, EXPECT({"token2", "token4"})); + } + case 65: SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - SHIFT(7); + SHIFT(9); case ts_aux_token3: - SHIFT(45); + SHIFT(68); case ts_aux_repeat_helper2: - SHIFT(45); + SHIFT(66); default: PARSE_ERROR(3, EXPECT({"repeat_helper2", "token3", "token2"})); } - case 45: + case 66: SET_LEX_STATE(4); switch (LOOKAHEAD_SYM()) { case ts_aux_token4: - SHIFT(46); + SHIFT(67); default: PARSE_ERROR(1, EXPECT({"token4"})); } - case 46: + case 67: SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { case ts_symbol___END__: - REDUCE(ts_symbol_array, 4); + REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); default: PARSE_ERROR(1, EXPECT({"__END__"})); } - case 47: + case 68: + SET_LEX_STATE(4); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token4: + SHIFT(69); + default: + PARSE_ERROR(1, EXPECT({"token4"})); + } + case 69: + SET_LEX_STATE(0); + switch (LOOKAHEAD_SYM()) { + case ts_symbol___END__: + REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1})); + default: + PARSE_ERROR(1, EXPECT({"__END__"})); + } + case 70: SET_LEX_STATE(19); switch (LOOKAHEAD_SYM()) { case ts_symbol_string: - SHIFT(48); + SHIFT(71); default: PARSE_ERROR(1, EXPECT({"string"})); } - case 48: + case 71: SET_LEX_STATE(17); switch (LOOKAHEAD_SYM()) { case ts_aux_token6: - SHIFT(49); + SHIFT(72); default: PARSE_ERROR(1, EXPECT({"token6"})); } - case 49: + case 72: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { case ts_symbol_number: - SHIFT(25); - case ts_symbol_array: - SHIFT(25); - case ts_symbol_object: - SHIFT(25); - case ts_symbol_value: - SHIFT(50); - case ts_symbol_string: - SHIFT(25); + SHIFT(36); case ts_aux_token5: - SHIFT(12); + SHIFT(16); + case ts_symbol_array: + SHIFT(34); + case ts_symbol_object: + SHIFT(33); + case ts_symbol_string: + SHIFT(35); + case ts_symbol_value: + SHIFT(73); case ts_aux_token1: SHIFT(3); default: - PARSE_ERROR(7, EXPECT({"token1", "token5", "string", "value", "object", "array", "number"})); + PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"})); } - case 50: + case 73: SET_LEX_STATE(2); switch (LOOKAHEAD_SYM()) { case ts_aux_token2: - SHIFT(18); + SHIFT(24); case ts_aux_token3: - SHIFT(51); + SHIFT(76); case ts_aux_repeat_helper1: - SHIFT(51); + SHIFT(74); default: PARSE_ERROR(3, EXPECT({"repeat_helper1", "token3", "token2"})); } - case 51: + case 74: SET_LEX_STATE(7); switch (LOOKAHEAD_SYM()) { case ts_aux_token7: - SHIFT(52); + SHIFT(75); default: PARSE_ERROR(1, EXPECT({"token7"})); } - case 52: + case 75: SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { case ts_symbol___END__: - REDUCE(ts_symbol_object, 6); + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); default: PARSE_ERROR(1, EXPECT({"__END__"})); } - case 53: + case 76: + SET_LEX_STATE(7); + switch (LOOKAHEAD_SYM()) { + case ts_aux_token7: + SHIFT(77); + default: + PARSE_ERROR(1, EXPECT({"token7"})); + } + case 77: SET_LEX_STATE(0); switch (LOOKAHEAD_SYM()) { case ts_symbol___END__: - REDUCE(ts_symbol_value, 1); + REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})); + default: + PARSE_ERROR(1, EXPECT({"__END__"})); + } + case 78: + SET_LEX_STATE(0); + switch (LOOKAHEAD_SYM()) { + case ts_symbol___END__: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + default: + PARSE_ERROR(1, EXPECT({"__END__"})); + } + case 79: + SET_LEX_STATE(0); + switch (LOOKAHEAD_SYM()) { + case ts_symbol___END__: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + default: + PARSE_ERROR(1, EXPECT({"__END__"})); + } + case 80: + SET_LEX_STATE(0); + switch (LOOKAHEAD_SYM()) { + case ts_symbol___END__: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); + default: + PARSE_ERROR(1, EXPECT({"__END__"})); + } + case 81: + SET_LEX_STATE(0); + switch (LOOKAHEAD_SYM()) { + case ts_symbol___END__: + REDUCE(ts_symbol_value, 1, COLLAPSE({0})); default: PARSE_ERROR(1, EXPECT({"__END__"})); } diff --git a/spec/runtime/arithmetic_spec.cpp b/spec/runtime/arithmetic_spec.cpp index 4732a8e0..77aa00f1 100644 --- a/spec/runtime/arithmetic_spec.cpp +++ b/spec/runtime/arithmetic_spec.cpp @@ -36,7 +36,7 @@ describe("arithmetic", []() { TSDocumentSetText(document, "x*(y+z)"); AssertThat(string(TSDocumentToString(document)), Equals( - "(expression (term (factor (variable)) (times) (factor (token1) (expression (term (factor (variable))) (plus) (term (factor (variable)))) (token2))))")); + "(expression (term (factor (variable)) (times) (factor (expression (term (factor (variable))) (plus) (term (factor (variable)))))))")); }); }); diff --git a/spec/runtime/json_spec.cpp b/spec/runtime/json_spec.cpp index 419637f8..92628713 100644 --- a/spec/runtime/json_spec.cpp +++ b/spec/runtime/json_spec.cpp @@ -20,15 +20,15 @@ describe("json", []() { it("parses objects", [&]() { TSDocumentSetText(document, "{\"key1\":1,\"key2\":2}"); - AssertThat(string(TSDocumentToString(document)), Equals("(value (object (token5) (string) (token6) (value (number)) (repeat_helper1 (token2) (string) (token6) (value (number))) (token7)))")); + AssertThat(string(TSDocumentToString(document)), Equals("(value (object (string) (value (number)) (string) (value (number))))")); TSDocumentSetText(document, "{\"key1\":1}"); - AssertThat(string(TSDocumentToString(document)), Equals("(value (object (token5) (string) (token6) (value (number)) (token3) (token7)))")); + AssertThat(string(TSDocumentToString(document)), Equals("(value (object (string) (value (number))))")); }); it("parses arrays", [&]() { TSDocumentSetText(document, "[1,2,3]"); - AssertThat(string(TSDocumentToString(document)), Equals("(value (array (token1) (value (number)) (repeat_helper2 (token2) (value (number)) (repeat_helper2 (token2) (value (number)))) (token4)))")); + AssertThat(string(TSDocumentToString(document)), Equals("(value (array (value (number)) (value (number)) (value (number))))")); }); }); diff --git a/src/compiler/build_tables/item.cpp b/src/compiler/build_tables/item.cpp index 91cb003c..f0864866 100644 --- a/src/compiler/build_tables/item.cpp +++ b/src/compiler/build_tables/item.cpp @@ -5,6 +5,7 @@ using std::string; using std::to_string; using std::ostream; +using std::vector; using tree_sitter::rules::Symbol; namespace tree_sitter { @@ -33,7 +34,7 @@ namespace tree_sitter { string("' ") << *item.rule << string(" ") << - to_string(item.consumed_sym_count) << + to_string(item.consumed_symbols.size()) << string(" ") << item.lookahead_sym << string(">"); @@ -51,8 +52,8 @@ namespace tree_sitter { if (other.lhs < lhs) return false; if (rule->to_string() < other.rule->to_string()) return true; if (rule->to_string() > other.rule->to_string()) return false; - if (consumed_sym_count < other.consumed_sym_count) return true; - if (consumed_sym_count > other.consumed_sym_count) return false; + if (consumed_symbols < other.consumed_symbols) return true; + if (consumed_symbols > other.consumed_symbols) return false; if (lookahead_sym < other.lookahead_sym) return true; return false; } @@ -65,15 +66,15 @@ namespace tree_sitter { return lhs_eq && rules_eq; } - ParseItem::ParseItem(const Symbol &lhs, const rules::rule_ptr rule, int consumed_sym_count, const rules::Symbol &lookahead_sym) : + ParseItem::ParseItem(const Symbol &lhs, const rules::rule_ptr rule, const vector &consumed_symbols, const rules::Symbol &lookahead_sym) : Item(lhs, rule), - consumed_sym_count(consumed_sym_count), + consumed_symbols(consumed_symbols), lookahead_sym(lookahead_sym) {} bool ParseItem::operator==(const ParseItem &other) const { bool lhs_eq = other.lhs == lhs; bool rules_eq = (*other.rule == *rule); - bool consumed_sym_counts_eq = (other.consumed_sym_count == consumed_sym_count); + bool consumed_sym_counts_eq = (other.consumed_symbols == consumed_symbols); bool lookaheads_eq = other.lookahead_sym == lookahead_sym; return lhs_eq && rules_eq && consumed_sym_counts_eq && lookaheads_eq; } diff --git a/src/compiler/build_tables/item.h b/src/compiler/build_tables/item.h index d15da384..7cc5a4b5 100644 --- a/src/compiler/build_tables/item.h +++ b/src/compiler/build_tables/item.h @@ -6,6 +6,7 @@ #include #include #include "symbol.h" +#include namespace tree_sitter { class Grammar; @@ -29,11 +30,11 @@ namespace tree_sitter { class ParseItem : public Item { public: - ParseItem(const rules::Symbol &lhs, const rules::rule_ptr rule, int consumed_sym_count, const rules::Symbol &lookahead_sym); + ParseItem(const rules::Symbol &lhs, const rules::rule_ptr rule, const std::vector &consumed_symbols, const rules::Symbol &lookahead_sym); bool operator<(const ParseItem &other) const; bool operator==(const ParseItem &other) const; - const int consumed_sym_count; + const std::vector consumed_symbols; const rules::Symbol lookahead_sym; }; @@ -61,7 +62,7 @@ namespace std { return hash()(item.lhs) ^ hash()(*item.rule) ^ - hash()(item.consumed_sym_count) ^ + hash()(item.consumed_symbols.size()) ^ hash()(item.lookahead_sym); } }; diff --git a/src/compiler/build_tables/item_set_closure.cpp b/src/compiler/build_tables/item_set_closure.cpp index 1b4b081b..3580fffa 100644 --- a/src/compiler/build_tables/item_set_closure.cpp +++ b/src/compiler/build_tables/item_set_closure.cpp @@ -20,7 +20,7 @@ namespace tree_sitter { auto non_terminal = pair.first; auto terminals = pair.second; for (rules::Symbol terminal : terminals) { - auto next_item = ParseItem(non_terminal, grammar.rule(non_terminal), 0, terminal); + auto next_item = ParseItem(non_terminal, grammar.rule(non_terminal), {}, terminal); add_item(item_set, next_item, grammar); } } diff --git a/src/compiler/build_tables/item_set_transitions.cpp b/src/compiler/build_tables/item_set_transitions.cpp index 410b630b..16a042db 100644 --- a/src/compiler/build_tables/item_set_transitions.cpp +++ b/src/compiler/build_tables/item_set_transitions.cpp @@ -43,7 +43,9 @@ namespace tree_sitter { for (auto transition : rule_transitions(item.rule)) { auto rule = dynamic_pointer_cast(transition.first); if (rule.get()) { - auto new_item = ParseItem(item.lhs, transition.second, item.consumed_sym_count + 1, item.lookahead_sym); + auto consumed_symbols = item.consumed_symbols; + consumed_symbols.push_back(*rule); + auto new_item = ParseItem(item.lhs, transition.second, consumed_symbols, item.lookahead_sym); auto new_item_set = item_set_closure(ParseItemSet({ new_item }), grammar); item_transitions.add(rule, make_shared(new_item_set)); } diff --git a/src/compiler/build_tables/perform.cpp b/src/compiler/build_tables/perform.cpp index ca13114f..ca323e33 100644 --- a/src/compiler/build_tables/perform.cpp +++ b/src/compiler/build_tables/perform.cpp @@ -60,13 +60,21 @@ namespace tree_sitter { } } } + + static vector reduce_flags(const vector &child_symbols) { + vector result; + for (auto symbol : child_symbols) { + result.push_back(symbol.is_auxiliary); + } + return result; + } void add_reduce_actions(const ParseItemSet &item_set, size_t state_index) { for (ParseItem item : item_set) { if (item.is_done()) { ParseAction action = (item.lhs.name == START) ? ParseAction::Accept() : - ParseAction::Reduce(item.lhs, item.consumed_sym_count); + ParseAction::Reduce(item.lhs, reduce_flags(item.consumed_symbols)); parse_table.add_action(state_index, item.lookahead_sym, action); } } @@ -116,7 +124,7 @@ namespace tree_sitter { lex_grammar(lex_grammar) {}; pair build() { - auto item = ParseItem(START, rules::sym(grammar.start_rule_name), 0, END_OF_INPUT); + auto item = ParseItem(START, rules::sym(grammar.start_rule_name), {}, END_OF_INPUT); ParseItemSet item_set = item_set_closure(ParseItemSet({ item }), grammar); add_parse_state(item_set); return pair(parse_table, lex_table); diff --git a/src/compiler/generate_code/c_code.cpp b/src/compiler/generate_code/c_code.cpp index 98627495..b19dc33a 100644 --- a/src/compiler/generate_code/c_code.cpp +++ b/src/compiler/generate_code/c_code.cpp @@ -118,6 +118,17 @@ namespace tree_sitter { } } + string collapse_flags(vector flags) { + string result; + bool started = false; + for (auto flag : flags) { + if (started) result += ", "; + result += (flag ? "1" : "0"); + started = true; + } + return result; + } + string code_for_parse_actions(const unordered_set &actions, const unordered_set &expected_inputs) { auto action = actions.begin(); if (action == actions.end()) { @@ -129,7 +140,7 @@ namespace tree_sitter { case ParseActionTypeShift: return "SHIFT(" + to_string(action->state_index) + ");"; case ParseActionTypeReduce: - return "REDUCE(" + symbol_id(action->symbol) + ", " + std::to_string(action->child_symbol_count) + ");"; + return "REDUCE(" + symbol_id(action->symbol) + ", " + to_string(action->child_flags.size()) + ", COLLAPSE({" + collapse_flags(action->child_flags) + "}));"; default: return ""; } diff --git a/src/compiler/parse_table.cpp b/src/compiler/parse_table.cpp index de93abde..9752734e 100644 --- a/src/compiler/parse_table.cpp +++ b/src/compiler/parse_table.cpp @@ -4,37 +4,38 @@ using std::string; using std::ostream; using std::to_string; using std::unordered_set; +using std::vector; using tree_sitter::rules::Symbol; namespace tree_sitter { // Action - ParseAction::ParseAction(ParseActionType type, size_t state_index, rules::Symbol symbol, size_t child_symbol_count) : + ParseAction::ParseAction(ParseActionType type, size_t state_index, rules::Symbol symbol, const vector &child_flags) : type(type), state_index(state_index), symbol(symbol), - child_symbol_count(child_symbol_count) {}; + child_flags(child_flags) {}; ParseAction ParseAction::Error() { - return ParseAction(ParseActionTypeError, -1, Symbol(""), -1); + return ParseAction(ParseActionTypeError, -1, Symbol(""), {}); } ParseAction ParseAction::Accept() { - return ParseAction(ParseActionTypeAccept, -1, Symbol(""), -1); + return ParseAction(ParseActionTypeAccept, -1, Symbol(""), {}); } ParseAction ParseAction::Shift(size_t state_index) { - return ParseAction(ParseActionTypeShift, state_index, Symbol(""), -1); + return ParseAction(ParseActionTypeShift, state_index, Symbol(""), {}); } - ParseAction ParseAction::Reduce(Symbol symbol, size_t child_symbol_count) { - return ParseAction(ParseActionTypeReduce, -1, symbol, child_symbol_count); + ParseAction ParseAction::Reduce(Symbol symbol, const vector &child_flags) { + return ParseAction(ParseActionTypeReduce, -1, symbol, child_flags); } bool ParseAction::operator==(const ParseAction &other) const { bool types_eq = type == other.type; bool state_indices_eq = state_index == other.state_index; - bool child_symbol_counts_eq = child_symbol_count == other.child_symbol_count; - return types_eq && state_indices_eq && child_symbol_counts_eq; + bool child_flags_eq = child_flags == other.child_flags; + return types_eq && state_indices_eq && child_flags_eq; } ostream& operator<<(ostream &stream, const ParseAction &action) { diff --git a/src/compiler/parse_table.h b/src/compiler/parse_table.h index 41847044..8996700f 100644 --- a/src/compiler/parse_table.h +++ b/src/compiler/parse_table.h @@ -15,16 +15,16 @@ namespace tree_sitter { } ParseActionType; class ParseAction { - ParseAction(ParseActionType type, size_t state_index, rules::Symbol symbol, size_t child_symbol_count); + ParseAction(ParseActionType type, size_t state_index, rules::Symbol symbol, const std::vector &child_flags); public: static ParseAction Accept(); static ParseAction Error(); static ParseAction Shift(size_t state_index); - static ParseAction Reduce(rules::Symbol symbol, size_t child_symbol_count); + static ParseAction Reduce(rules::Symbol symbol, const std::vector &child_flags); bool operator==(const ParseAction &action) const; ParseActionType type; - size_t child_symbol_count; + std::vector child_flags; rules::Symbol symbol; size_t state_index; }; @@ -40,7 +40,7 @@ namespace std { hash()(action.type) ^ hash()(action.symbol) ^ hash()(action.state_index) ^ - hash()(action.child_symbol_count)); + hash()(action.child_flags.size())); } }; }