From 48baf056b47b92f76c6cf08909afb6f24c5fa2f9 Mon Sep 17 00:00:00 2001 From: Max Brunsfeld Date: Mon, 24 Mar 2014 13:05:04 -0700 Subject: [PATCH] Store grammars' rules in vectors, not maps This way, we can keep of the order in which the rules were given, for resolving reduce/reduce conflicts. --- examples/grammars/arithmetic.cc | 2 +- examples/grammars/javascript.cc | 2 +- examples/grammars/json.cc | 2 +- examples/parsers/javascript.c | 840 +++++++++--------- examples/parsers/json.c | 54 +- include/tree_sitter/compiler.h | 8 +- .../build_tables/build_tables_spec.cc | 4 +- spec/compiler/build_tables/first_set_spec.cc | 6 +- .../compiler/build_tables/follow_sets_spec.cc | 2 +- .../build_tables/item_set_closure_spec.cc | 2 +- spec/compiler/prepare_grammar_spec.cc | 22 +- spec/runtime/languages/javascript/main.txt | 4 +- src/compiler/build_tables/build_tables.cc | 2 +- src/compiler/grammar.cc | 18 +- .../prepare_grammar/expand_repeats.cc | 17 +- .../prepare_grammar/extract_tokens.cc | 24 +- src/compiler/prepared_grammar.cc | 37 +- src/compiler/prepared_grammar.h | 12 +- 18 files changed, 525 insertions(+), 533 deletions(-) diff --git a/examples/grammars/arithmetic.cc b/examples/grammars/arithmetic.cc index 1cdc2749..6a31594b 100644 --- a/examples/grammars/arithmetic.cc +++ b/examples/grammars/arithmetic.cc @@ -5,7 +5,7 @@ namespace tree_sitter { using namespace tree_sitter::rules; Grammar arithmetic() { - return Grammar("expression", { + return Grammar({ { "expression", choice({ seq({ sym("term"), diff --git a/examples/grammars/javascript.cc b/examples/grammars/javascript.cc index 3e890b68..64230536 100644 --- a/examples/grammars/javascript.cc +++ b/examples/grammars/javascript.cc @@ -15,7 +15,7 @@ namespace tree_sitter { } Grammar javascript() { - return Grammar("program", { + return Grammar({ { "program", repeat(sym("statement")) }, { "terminator", choice({ str(";"), str("\n") }) }, { "statement", choice({ diff --git a/examples/grammars/json.cc b/examples/grammars/json.cc index 7a7cde20..ec59deaf 100644 --- a/examples/grammars/json.cc +++ b/examples/grammars/json.cc @@ -15,7 +15,7 @@ namespace tree_sitter { } Grammar json() { - return Grammar("value", { + return Grammar({ { "value", choice({ sym("object"), sym("array"), diff --git a/examples/parsers/javascript.c b/examples/parsers/javascript.c index 31d2dd24..73f2ca0b 100644 --- a/examples/parsers/javascript.c +++ b/examples/parsers/javascript.c @@ -84,9 +84,9 @@ LEX_FN() { ADVANCE(2); LEX_ERROR(); case 1: - ACCEPT_TOKEN(ts_aux_sym_token13); + ACCEPT_TOKEN(ts_aux_sym_token2); case 2: - ACCEPT_TOKEN(ts_aux_sym_token12); + ACCEPT_TOKEN(ts_aux_sym_token1); case 3: if (LOOKAHEAD_CHAR() == '\"') ADVANCE(4); @@ -221,7 +221,7 @@ LEX_FN() { ADVANCE(18); ACCEPT_TOKEN(ts_sym_number); case 19: - ACCEPT_TOKEN(ts_aux_sym_token1); + ACCEPT_TOKEN(ts_aux_sym_token12); case 20: if (LOOKAHEAD_CHAR() == 'a') ADVANCE(21); @@ -245,7 +245,7 @@ LEX_FN() { ADVANCE(26); LEX_ERROR(); case 26: - ACCEPT_TOKEN(ts_aux_sym_token8); + ACCEPT_TOKEN(ts_aux_sym_token3); case 27: if (LOOKAHEAD_CHAR() == 'u') ADVANCE(28); @@ -283,7 +283,7 @@ LEX_FN() { ADVANCE(37); LEX_ERROR(); case 37: - ACCEPT_TOKEN(ts_aux_sym_token4); + ACCEPT_TOKEN(ts_aux_sym_token8); case 38: ACCEPT_TOKEN(ts_aux_sym_token6); case 39: @@ -295,9 +295,9 @@ LEX_FN() { ADVANCE(42); LEX_ERROR(); case 41: - ACCEPT_TOKEN(ts_aux_sym_token2); + ACCEPT_TOKEN(ts_aux_sym_token11); case 42: - ACCEPT_TOKEN(ts_aux_sym_token3); + ACCEPT_TOKEN(ts_aux_sym_token13); case 43: if (LOOKAHEAD_CHAR() == ']') ADVANCE(42); @@ -353,7 +353,7 @@ LEX_FN() { ADVANCE(50); LEX_ERROR(); case 50: - ACCEPT_TOKEN(ts_aux_sym_token11); + ACCEPT_TOKEN(ts_aux_sym_token10); case 51: if (LOOKAHEAD_CHAR() == '\"') ADVANCE(4); @@ -365,39 +365,12 @@ LEX_FN() { ADVANCE(4); LEX_ERROR(); case 53: - if (LOOKAHEAD_CHAR() == '=') + if (LOOKAHEAD_CHAR() == ')') ADVANCE(54); LEX_ERROR(); case 54: ACCEPT_TOKEN(ts_aux_sym_token5); case 55: - if ((LOOKAHEAD_CHAR() == '$') || - ('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') || - (LOOKAHEAD_CHAR() == '_') || - ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z')) - ADVANCE(56); - LEX_ERROR(); - case 56: - if ((LOOKAHEAD_CHAR() == '$') || - ('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') || - (LOOKAHEAD_CHAR() == '_') || - ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z')) - ADVANCE(57); - ACCEPT_TOKEN(ts_sym_identifier); - case 57: - if ((LOOKAHEAD_CHAR() == '$') || - ('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') || - (LOOKAHEAD_CHAR() == '_') || - ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z')) - ADVANCE(57); - ACCEPT_TOKEN(ts_sym_identifier); - case 58: - if (LOOKAHEAD_CHAR() == ')') - ADVANCE(59); - LEX_ERROR(); - case 59: - ACCEPT_TOKEN(ts_aux_sym_token10); - case 60: if (LOOKAHEAD_CHAR() == '\"') ADVANCE(4); if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9') @@ -419,6 +392,33 @@ LEX_FN() { if (LOOKAHEAD_CHAR() == '}') ADVANCE(45); LEX_ERROR(); + case 56: + if (LOOKAHEAD_CHAR() == '=') + ADVANCE(57); + LEX_ERROR(); + case 57: + ACCEPT_TOKEN(ts_aux_sym_token9); + case 58: + if ((LOOKAHEAD_CHAR() == '$') || + ('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') || + (LOOKAHEAD_CHAR() == '_') || + ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z')) + ADVANCE(59); + LEX_ERROR(); + case 59: + if ((LOOKAHEAD_CHAR() == '$') || + ('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') || + (LOOKAHEAD_CHAR() == '_') || + ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z')) + ADVANCE(60); + ACCEPT_TOKEN(ts_sym_identifier); + case 60: + if ((LOOKAHEAD_CHAR() == '$') || + ('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') || + (LOOKAHEAD_CHAR() == '_') || + ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z')) + ADVANCE(60); + ACCEPT_TOKEN(ts_sym_identifier); case 61: if (LOOKAHEAD_CHAR() == '{') ADVANCE(38); @@ -428,14 +428,14 @@ LEX_FN() { ADVANCE(63); LEX_ERROR(); case 63: - ACCEPT_TOKEN(ts_aux_sym_token9); + ACCEPT_TOKEN(ts_aux_sym_token4); case 64: if ((LOOKAHEAD_CHAR() == '$') || ('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') || (LOOKAHEAD_CHAR() == '_') || ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'e') || ('g' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z')) - ADVANCE(57); + ADVANCE(60); if (LOOKAHEAD_CHAR() == 'f') ADVANCE(65); if ('g' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'f') @@ -446,7 +446,7 @@ LEX_FN() { ('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') || (LOOKAHEAD_CHAR() == '_') || ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z')) - ADVANCE(57); + ADVANCE(60); ACCEPT_TOKEN(ts_sym_identifier); case 66: if ((LOOKAHEAD_CHAR() == '$') || @@ -454,7 +454,7 @@ LEX_FN() { (LOOKAHEAD_CHAR() == '_') || ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 't') || ('v' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z')) - ADVANCE(57); + ADVANCE(60); if (LOOKAHEAD_CHAR() == 'u') ADVANCE(67); if ('v' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'u') @@ -466,7 +466,7 @@ LEX_FN() { (LOOKAHEAD_CHAR() == '_') || ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'k') || ('m' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z')) - ADVANCE(57); + ADVANCE(60); if (LOOKAHEAD_CHAR() == 'l') ADVANCE(68); if ('m' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'l') @@ -478,7 +478,7 @@ LEX_FN() { (LOOKAHEAD_CHAR() == '_') || ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'k') || ('m' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z')) - ADVANCE(57); + ADVANCE(60); if (LOOKAHEAD_CHAR() == 'l') ADVANCE(69); if ('m' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'l') @@ -489,7 +489,7 @@ LEX_FN() { ('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') || (LOOKAHEAD_CHAR() == '_') || ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z')) - ADVANCE(57); + ADVANCE(60); ACCEPT_TOKEN(ts_sym_identifier); case 70: if ((LOOKAHEAD_CHAR() == '$') || @@ -497,7 +497,7 @@ LEX_FN() { (LOOKAHEAD_CHAR() == '_') || ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'q') || ('s' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z')) - ADVANCE(57); + ADVANCE(60); if (LOOKAHEAD_CHAR() == 'r') ADVANCE(71); if ('s' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'r') @@ -509,7 +509,7 @@ LEX_FN() { (LOOKAHEAD_CHAR() == '_') || ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 't') || ('v' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z')) - ADVANCE(57); + ADVANCE(60); if (LOOKAHEAD_CHAR() == 'u') ADVANCE(72); if ('v' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'u') @@ -521,7 +521,7 @@ LEX_FN() { (LOOKAHEAD_CHAR() == '_') || ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'd') || ('f' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z')) - ADVANCE(57); + ADVANCE(60); if (LOOKAHEAD_CHAR() == 'e') ADVANCE(73); if ('f' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'e') @@ -532,14 +532,14 @@ LEX_FN() { ('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') || (LOOKAHEAD_CHAR() == '_') || ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z')) - ADVANCE(57); + ADVANCE(60); ACCEPT_TOKEN(ts_sym_identifier); case 74: if ((LOOKAHEAD_CHAR() == '$') || ('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') || (LOOKAHEAD_CHAR() == '_') || ('b' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z')) - ADVANCE(57); + ADVANCE(60); if (LOOKAHEAD_CHAR() == 'a') ADVANCE(75); if ('b' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'a') @@ -551,7 +551,7 @@ LEX_FN() { (LOOKAHEAD_CHAR() == '_') || ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'q') || ('s' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z')) - ADVANCE(57); + ADVANCE(60); if (LOOKAHEAD_CHAR() == 'r') ADVANCE(76); if ('s' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'r') @@ -562,7 +562,7 @@ LEX_FN() { ('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') || (LOOKAHEAD_CHAR() == '_') || ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z')) - ADVANCE(57); + ADVANCE(60); ACCEPT_TOKEN(ts_sym_identifier); case ts_lex_state_error: if (LOOKAHEAD_CHAR() == '\n') @@ -577,11 +577,11 @@ LEX_FN() { ('o' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 's') || (LOOKAHEAD_CHAR() == 'u') || ('w' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z')) - ADVANCE(56); + ADVANCE(59); if (LOOKAHEAD_CHAR() == '(') ADVANCE(63); if (LOOKAHEAD_CHAR() == ')') - ADVANCE(59); + ADVANCE(54); if (LOOKAHEAD_CHAR() == ',') ADVANCE(41); if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9') @@ -591,7 +591,7 @@ LEX_FN() { if (LOOKAHEAD_CHAR() == ';') ADVANCE(2); if (LOOKAHEAD_CHAR() == '=') - ADVANCE(54); + ADVANCE(57); if (LOOKAHEAD_CHAR() == '[') ADVANCE(19); if (LOOKAHEAD_CHAR() == ']') @@ -642,25 +642,25 @@ PARSE_TABLE() { SHIFT(ts_sym_statement, 8) SHIFT(ts_sym_string, 1) SHIFT(ts_sym_true, 1) - SHIFT(ts_aux_sym_repeat_helper4, 112) - SHIFT(ts_aux_sym_token1, 10) - SHIFT(ts_aux_sym_token4, 59) - SHIFT(ts_aux_sym_token6, 63) - SHIFT(ts_aux_sym_token8, 73) - REDUCE(ts_builtin_sym_end, ts_aux_sym_repeat_helper4, 0, COLLAPSE({})) + SHIFT(ts_aux_sym_repeat_helper1, 112) + SHIFT(ts_aux_sym_token12, 10) + SHIFT(ts_aux_sym_token3, 59) + SHIFT(ts_aux_sym_token6, 80) + SHIFT(ts_aux_sym_token8, 90) + REDUCE(ts_builtin_sym_end, ts_aux_sym_repeat_helper1, 0, COLLAPSE({})) END_STATE(); STATE(1); SET_LEX_STATE(0); - REDUCE(ts_aux_sym_token12, ts_sym_literal, 1, COLLAPSE({0})) - REDUCE(ts_aux_sym_token13, ts_sym_literal, 1, COLLAPSE({0})) + REDUCE(ts_aux_sym_token1, ts_sym_literal, 1, COLLAPSE({0})) + REDUCE(ts_aux_sym_token2, ts_sym_literal, 1, COLLAPSE({0})) END_STATE(); STATE(2); SET_LEX_STATE(0); SHIFT(ts_sym_terminator, 3) - SHIFT(ts_aux_sym_token12, 4) - SHIFT(ts_aux_sym_token13, 4) + SHIFT(ts_aux_sym_token1, 4) + SHIFT(ts_aux_sym_token2, 4) END_STATE(); STATE(3); @@ -670,8 +670,8 @@ PARSE_TABLE() { REDUCE(ts_sym_number, ts_sym_statement, 2, COLLAPSE({0, 1})) REDUCE(ts_sym_string, ts_sym_statement, 2, COLLAPSE({0, 1})) REDUCE(ts_sym_true, ts_sym_statement, 2, COLLAPSE({0, 1})) - REDUCE(ts_aux_sym_token1, ts_sym_statement, 2, COLLAPSE({0, 1})) - REDUCE(ts_aux_sym_token4, ts_sym_statement, 2, COLLAPSE({0, 1})) + REDUCE(ts_aux_sym_token12, ts_sym_statement, 2, COLLAPSE({0, 1})) + REDUCE(ts_aux_sym_token3, ts_sym_statement, 2, COLLAPSE({0, 1})) REDUCE(ts_aux_sym_token6, ts_sym_statement, 2, COLLAPSE({0, 1})) REDUCE(ts_aux_sym_token8, ts_sym_statement, 2, COLLAPSE({0, 1})) REDUCE(ts_builtin_sym_end, ts_sym_statement, 2, COLLAPSE({0, 1})) @@ -684,8 +684,8 @@ PARSE_TABLE() { REDUCE(ts_sym_number, ts_sym_terminator, 1, COLLAPSE({1})) REDUCE(ts_sym_string, ts_sym_terminator, 1, COLLAPSE({1})) REDUCE(ts_sym_true, ts_sym_terminator, 1, COLLAPSE({1})) - REDUCE(ts_aux_sym_token1, ts_sym_terminator, 1, COLLAPSE({1})) - REDUCE(ts_aux_sym_token4, ts_sym_terminator, 1, COLLAPSE({1})) + REDUCE(ts_aux_sym_token12, ts_sym_terminator, 1, COLLAPSE({1})) + REDUCE(ts_aux_sym_token3, ts_sym_terminator, 1, COLLAPSE({1})) REDUCE(ts_aux_sym_token6, ts_sym_terminator, 1, COLLAPSE({1})) REDUCE(ts_aux_sym_token8, ts_sym_terminator, 1, COLLAPSE({1})) REDUCE(ts_builtin_sym_end, ts_sym_terminator, 1, COLLAPSE({1})) @@ -698,8 +698,8 @@ PARSE_TABLE() { REDUCE(ts_sym_number, ts_sym_statement, 1, COLLAPSE({0})) REDUCE(ts_sym_string, ts_sym_statement, 1, COLLAPSE({0})) REDUCE(ts_sym_true, ts_sym_statement, 1, COLLAPSE({0})) - REDUCE(ts_aux_sym_token1, ts_sym_statement, 1, COLLAPSE({0})) - REDUCE(ts_aux_sym_token4, ts_sym_statement, 1, COLLAPSE({0})) + REDUCE(ts_aux_sym_token12, ts_sym_statement, 1, COLLAPSE({0})) + REDUCE(ts_aux_sym_token3, ts_sym_statement, 1, COLLAPSE({0})) REDUCE(ts_aux_sym_token6, ts_sym_statement, 1, COLLAPSE({0})) REDUCE(ts_aux_sym_token8, ts_sym_statement, 1, COLLAPSE({0})) REDUCE(ts_builtin_sym_end, ts_sym_statement, 1, COLLAPSE({0})) @@ -707,8 +707,8 @@ PARSE_TABLE() { STATE(6); SET_LEX_STATE(0); - REDUCE(ts_aux_sym_token12, ts_sym_expression, 1, COLLAPSE({0})) - REDUCE(ts_aux_sym_token13, ts_sym_expression, 1, COLLAPSE({0})) + REDUCE(ts_aux_sym_token1, ts_sym_expression, 1, COLLAPSE({0})) + REDUCE(ts_aux_sym_token2, ts_sym_expression, 1, COLLAPSE({0})) END_STATE(); STATE(7); @@ -730,17 +730,17 @@ PARSE_TABLE() { SHIFT(ts_sym_statement, 8) SHIFT(ts_sym_string, 1) SHIFT(ts_sym_true, 1) - SHIFT(ts_aux_sym_repeat_helper4, 9) - SHIFT(ts_aux_sym_token1, 10) - SHIFT(ts_aux_sym_token4, 59) - SHIFT(ts_aux_sym_token6, 63) - SHIFT(ts_aux_sym_token8, 73) - REDUCE(ts_builtin_sym_end, ts_aux_sym_repeat_helper4, 0, COLLAPSE({})) + SHIFT(ts_aux_sym_repeat_helper1, 9) + SHIFT(ts_aux_sym_token12, 10) + SHIFT(ts_aux_sym_token3, 59) + SHIFT(ts_aux_sym_token6, 80) + SHIFT(ts_aux_sym_token8, 90) + REDUCE(ts_builtin_sym_end, ts_aux_sym_repeat_helper1, 0, COLLAPSE({})) END_STATE(); STATE(9); SET_LEX_STATE(39); - REDUCE(ts_builtin_sym_end, ts_aux_sym_repeat_helper4, 2, COLLAPSE({0, 1})) + REDUCE(ts_builtin_sym_end, ts_aux_sym_repeat_helper1, 2, COLLAPSE({0, 1})) END_STATE(); STATE(10); @@ -754,34 +754,34 @@ PARSE_TABLE() { SHIFT(ts_sym_object, 11) SHIFT(ts_sym_string, 11) SHIFT(ts_sym_true, 11) - SHIFT(ts_aux_sym_token1, 19) - SHIFT(ts_aux_sym_token3, 58) + SHIFT(ts_aux_sym_token12, 19) + SHIFT(ts_aux_sym_token13, 58) SHIFT(ts_aux_sym_token6, 24) SHIFT(ts_builtin_sym_error, 12) END_STATE(); STATE(11); SET_LEX_STATE(40); - REDUCE(ts_aux_sym_token2, ts_sym_literal, 1, COLLAPSE({0})) - REDUCE(ts_aux_sym_token3, ts_sym_literal, 1, COLLAPSE({0})) + REDUCE(ts_aux_sym_token11, ts_sym_literal, 1, COLLAPSE({0})) + REDUCE(ts_aux_sym_token13, ts_sym_literal, 1, COLLAPSE({0})) END_STATE(); STATE(12); SET_LEX_STATE(40); - SHIFT(ts_aux_sym_repeat_helper1, 13) - SHIFT(ts_aux_sym_token2, 15) - REDUCE(ts_aux_sym_token3, ts_aux_sym_repeat_helper1, 0, COLLAPSE({})) + SHIFT(ts_aux_sym_repeat_helper4, 13) + SHIFT(ts_aux_sym_token11, 15) + REDUCE(ts_aux_sym_token13, ts_aux_sym_repeat_helper4, 0, COLLAPSE({})) END_STATE(); STATE(13); SET_LEX_STATE(43); - SHIFT(ts_aux_sym_token3, 14) + SHIFT(ts_aux_sym_token13, 14) END_STATE(); STATE(14); SET_LEX_STATE(0); - REDUCE(ts_aux_sym_token12, ts_sym_array, 4, COLLAPSE({1, 0, 1, 1})) - REDUCE(ts_aux_sym_token13, ts_sym_array, 4, COLLAPSE({1, 0, 1, 1})) + REDUCE(ts_aux_sym_token1, ts_sym_array, 4, COLLAPSE({1, 0, 1, 1})) + REDUCE(ts_aux_sym_token2, ts_sym_array, 4, COLLAPSE({1, 0, 1, 1})) END_STATE(); STATE(15); @@ -795,27 +795,27 @@ PARSE_TABLE() { SHIFT(ts_sym_object, 11) SHIFT(ts_sym_string, 11) SHIFT(ts_sym_true, 11) - SHIFT(ts_aux_sym_token1, 19) + SHIFT(ts_aux_sym_token12, 19) SHIFT(ts_aux_sym_token6, 24) SHIFT(ts_builtin_sym_error, 16) END_STATE(); STATE(16); SET_LEX_STATE(40); - SHIFT(ts_aux_sym_repeat_helper1, 17) - SHIFT(ts_aux_sym_token2, 15) - REDUCE(ts_aux_sym_token3, ts_aux_sym_repeat_helper1, 0, COLLAPSE({})) + SHIFT(ts_aux_sym_repeat_helper4, 17) + SHIFT(ts_aux_sym_token11, 15) + REDUCE(ts_aux_sym_token13, ts_aux_sym_repeat_helper4, 0, COLLAPSE({})) END_STATE(); STATE(17); SET_LEX_STATE(43); - REDUCE(ts_aux_sym_token3, ts_aux_sym_repeat_helper1, 3, COLLAPSE({1, 0, 1})) + REDUCE(ts_aux_sym_token13, ts_aux_sym_repeat_helper4, 3, COLLAPSE({1, 0, 1})) END_STATE(); STATE(18); SET_LEX_STATE(40); - REDUCE(ts_aux_sym_token2, ts_sym_expression, 1, COLLAPSE({0})) - REDUCE(ts_aux_sym_token3, ts_sym_expression, 1, COLLAPSE({0})) + REDUCE(ts_aux_sym_token11, ts_sym_expression, 1, COLLAPSE({0})) + REDUCE(ts_aux_sym_token13, ts_sym_expression, 1, COLLAPSE({0})) END_STATE(); STATE(19); @@ -829,34 +829,34 @@ PARSE_TABLE() { SHIFT(ts_sym_object, 11) SHIFT(ts_sym_string, 11) SHIFT(ts_sym_true, 11) - SHIFT(ts_aux_sym_token1, 19) - SHIFT(ts_aux_sym_token3, 23) + SHIFT(ts_aux_sym_token12, 19) + SHIFT(ts_aux_sym_token13, 23) SHIFT(ts_aux_sym_token6, 24) SHIFT(ts_builtin_sym_error, 20) END_STATE(); STATE(20); SET_LEX_STATE(40); - SHIFT(ts_aux_sym_repeat_helper1, 21) - SHIFT(ts_aux_sym_token2, 15) - REDUCE(ts_aux_sym_token3, ts_aux_sym_repeat_helper1, 0, COLLAPSE({})) + SHIFT(ts_aux_sym_repeat_helper4, 21) + SHIFT(ts_aux_sym_token11, 15) + REDUCE(ts_aux_sym_token13, ts_aux_sym_repeat_helper4, 0, COLLAPSE({})) END_STATE(); STATE(21); SET_LEX_STATE(43); - SHIFT(ts_aux_sym_token3, 22) + SHIFT(ts_aux_sym_token13, 22) END_STATE(); STATE(22); SET_LEX_STATE(40); - REDUCE(ts_aux_sym_token2, ts_sym_array, 4, COLLAPSE({1, 0, 1, 1})) - REDUCE(ts_aux_sym_token3, ts_sym_array, 4, COLLAPSE({1, 0, 1, 1})) + REDUCE(ts_aux_sym_token11, ts_sym_array, 4, COLLAPSE({1, 0, 1, 1})) + REDUCE(ts_aux_sym_token13, ts_sym_array, 4, COLLAPSE({1, 0, 1, 1})) END_STATE(); STATE(23); SET_LEX_STATE(40); - REDUCE(ts_aux_sym_token2, ts_sym_array, 2, COLLAPSE({1, 1})) - REDUCE(ts_aux_sym_token3, ts_sym_array, 2, COLLAPSE({1, 1})) + REDUCE(ts_aux_sym_token11, ts_sym_array, 2, COLLAPSE({1, 1})) + REDUCE(ts_aux_sym_token13, ts_sym_array, 2, COLLAPSE({1, 1})) END_STATE(); STATE(24); @@ -868,7 +868,7 @@ PARSE_TABLE() { STATE(25); SET_LEX_STATE(49); - SHIFT(ts_aux_sym_token11, 26) + SHIFT(ts_aux_sym_token10, 26) END_STATE(); STATE(26); @@ -882,20 +882,20 @@ PARSE_TABLE() { SHIFT(ts_sym_object, 27) SHIFT(ts_sym_string, 27) SHIFT(ts_sym_true, 27) - SHIFT(ts_aux_sym_token1, 37) + SHIFT(ts_aux_sym_token12, 37) SHIFT(ts_aux_sym_token6, 42) END_STATE(); STATE(27); SET_LEX_STATE(44); - REDUCE(ts_aux_sym_token2, ts_sym_literal, 1, COLLAPSE({0})) + REDUCE(ts_aux_sym_token11, ts_sym_literal, 1, COLLAPSE({0})) REDUCE(ts_aux_sym_token7, ts_sym_literal, 1, COLLAPSE({0})) END_STATE(); STATE(28); SET_LEX_STATE(44); SHIFT(ts_aux_sym_repeat_helper3, 29) - SHIFT(ts_aux_sym_token2, 31) + SHIFT(ts_aux_sym_token11, 31) REDUCE(ts_aux_sym_token7, ts_aux_sym_repeat_helper3, 0, COLLAPSE({})) END_STATE(); @@ -906,8 +906,8 @@ PARSE_TABLE() { STATE(30); SET_LEX_STATE(40); - REDUCE(ts_aux_sym_token2, ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})) - REDUCE(ts_aux_sym_token3, ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})) + REDUCE(ts_aux_sym_token11, ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})) + REDUCE(ts_aux_sym_token13, ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})) END_STATE(); STATE(31); @@ -918,7 +918,7 @@ PARSE_TABLE() { STATE(32); SET_LEX_STATE(49); - SHIFT(ts_aux_sym_token11, 33) + SHIFT(ts_aux_sym_token10, 33) END_STATE(); STATE(33); @@ -932,14 +932,14 @@ PARSE_TABLE() { SHIFT(ts_sym_object, 27) SHIFT(ts_sym_string, 27) SHIFT(ts_sym_true, 27) - SHIFT(ts_aux_sym_token1, 37) + SHIFT(ts_aux_sym_token12, 37) SHIFT(ts_aux_sym_token6, 42) END_STATE(); STATE(34); SET_LEX_STATE(44); SHIFT(ts_aux_sym_repeat_helper3, 35) - SHIFT(ts_aux_sym_token2, 31) + SHIFT(ts_aux_sym_token11, 31) REDUCE(ts_aux_sym_token7, ts_aux_sym_repeat_helper3, 0, COLLAPSE({})) END_STATE(); @@ -950,7 +950,7 @@ PARSE_TABLE() { STATE(36); SET_LEX_STATE(44); - REDUCE(ts_aux_sym_token2, ts_sym_expression, 1, COLLAPSE({0})) + REDUCE(ts_aux_sym_token11, ts_sym_expression, 1, COLLAPSE({0})) REDUCE(ts_aux_sym_token7, ts_sym_expression, 1, COLLAPSE({0})) END_STATE(); @@ -965,33 +965,33 @@ PARSE_TABLE() { SHIFT(ts_sym_object, 11) SHIFT(ts_sym_string, 11) SHIFT(ts_sym_true, 11) - SHIFT(ts_aux_sym_token1, 19) - SHIFT(ts_aux_sym_token3, 41) + SHIFT(ts_aux_sym_token12, 19) + SHIFT(ts_aux_sym_token13, 41) SHIFT(ts_aux_sym_token6, 24) SHIFT(ts_builtin_sym_error, 38) END_STATE(); STATE(38); SET_LEX_STATE(40); - SHIFT(ts_aux_sym_repeat_helper1, 39) - SHIFT(ts_aux_sym_token2, 15) - REDUCE(ts_aux_sym_token3, ts_aux_sym_repeat_helper1, 0, COLLAPSE({})) + SHIFT(ts_aux_sym_repeat_helper4, 39) + SHIFT(ts_aux_sym_token11, 15) + REDUCE(ts_aux_sym_token13, ts_aux_sym_repeat_helper4, 0, COLLAPSE({})) END_STATE(); STATE(39); SET_LEX_STATE(43); - SHIFT(ts_aux_sym_token3, 40) + SHIFT(ts_aux_sym_token13, 40) END_STATE(); STATE(40); SET_LEX_STATE(44); - REDUCE(ts_aux_sym_token2, ts_sym_array, 4, COLLAPSE({1, 0, 1, 1})) + REDUCE(ts_aux_sym_token11, ts_sym_array, 4, COLLAPSE({1, 0, 1, 1})) REDUCE(ts_aux_sym_token7, ts_sym_array, 4, COLLAPSE({1, 0, 1, 1})) END_STATE(); STATE(41); SET_LEX_STATE(44); - REDUCE(ts_aux_sym_token2, ts_sym_array, 2, COLLAPSE({1, 1})) + REDUCE(ts_aux_sym_token11, ts_sym_array, 2, COLLAPSE({1, 1})) REDUCE(ts_aux_sym_token7, ts_sym_array, 2, COLLAPSE({1, 1})) END_STATE(); @@ -1004,7 +1004,7 @@ PARSE_TABLE() { STATE(43); SET_LEX_STATE(49); - SHIFT(ts_aux_sym_token11, 44) + SHIFT(ts_aux_sym_token10, 44) END_STATE(); STATE(44); @@ -1018,14 +1018,14 @@ PARSE_TABLE() { SHIFT(ts_sym_object, 27) SHIFT(ts_sym_string, 27) SHIFT(ts_sym_true, 27) - SHIFT(ts_aux_sym_token1, 37) + SHIFT(ts_aux_sym_token12, 37) SHIFT(ts_aux_sym_token6, 42) END_STATE(); STATE(45); SET_LEX_STATE(44); SHIFT(ts_aux_sym_repeat_helper3, 46) - SHIFT(ts_aux_sym_token2, 31) + SHIFT(ts_aux_sym_token11, 31) REDUCE(ts_aux_sym_token7, ts_aux_sym_repeat_helper3, 0, COLLAPSE({})) END_STATE(); @@ -1036,20 +1036,20 @@ PARSE_TABLE() { STATE(47); SET_LEX_STATE(44); - REDUCE(ts_aux_sym_token2, ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})) + REDUCE(ts_aux_sym_token11, ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})) REDUCE(ts_aux_sym_token7, ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})) END_STATE(); STATE(48); SET_LEX_STATE(44); - REDUCE(ts_aux_sym_token2, ts_sym_object, 2, COLLAPSE({1, 1})) + REDUCE(ts_aux_sym_token11, ts_sym_object, 2, COLLAPSE({1, 1})) REDUCE(ts_aux_sym_token7, ts_sym_object, 2, COLLAPSE({1, 1})) END_STATE(); STATE(49); SET_LEX_STATE(44); SHIFT(ts_aux_sym_repeat_helper3, 50) - SHIFT(ts_aux_sym_token2, 31) + SHIFT(ts_aux_sym_token11, 31) REDUCE(ts_aux_sym_token7, ts_aux_sym_repeat_helper3, 0, COLLAPSE({})) END_STATE(); @@ -1060,14 +1060,14 @@ PARSE_TABLE() { STATE(51); SET_LEX_STATE(44); - REDUCE(ts_aux_sym_token2, ts_sym_object, 4, COLLAPSE({1, 0, 1, 1})) + REDUCE(ts_aux_sym_token11, ts_sym_object, 4, COLLAPSE({1, 0, 1, 1})) REDUCE(ts_aux_sym_token7, ts_sym_object, 4, COLLAPSE({1, 0, 1, 1})) END_STATE(); STATE(52); SET_LEX_STATE(44); SHIFT(ts_aux_sym_repeat_helper3, 53) - SHIFT(ts_aux_sym_token2, 31) + SHIFT(ts_aux_sym_token11, 31) REDUCE(ts_aux_sym_token7, ts_aux_sym_repeat_helper3, 0, COLLAPSE({})) END_STATE(); @@ -1078,14 +1078,14 @@ PARSE_TABLE() { STATE(54); SET_LEX_STATE(40); - REDUCE(ts_aux_sym_token2, ts_sym_object, 2, COLLAPSE({1, 1})) - REDUCE(ts_aux_sym_token3, ts_sym_object, 2, COLLAPSE({1, 1})) + REDUCE(ts_aux_sym_token11, ts_sym_object, 2, COLLAPSE({1, 1})) + REDUCE(ts_aux_sym_token13, ts_sym_object, 2, COLLAPSE({1, 1})) END_STATE(); STATE(55); SET_LEX_STATE(44); SHIFT(ts_aux_sym_repeat_helper3, 56) - SHIFT(ts_aux_sym_token2, 31) + SHIFT(ts_aux_sym_token11, 31) REDUCE(ts_aux_sym_token7, ts_aux_sym_repeat_helper3, 0, COLLAPSE({})) END_STATE(); @@ -1096,63 +1096,266 @@ PARSE_TABLE() { STATE(57); SET_LEX_STATE(40); - REDUCE(ts_aux_sym_token2, ts_sym_object, 4, COLLAPSE({1, 0, 1, 1})) - REDUCE(ts_aux_sym_token3, ts_sym_object, 4, COLLAPSE({1, 0, 1, 1})) + REDUCE(ts_aux_sym_token11, ts_sym_object, 4, COLLAPSE({1, 0, 1, 1})) + REDUCE(ts_aux_sym_token13, ts_sym_object, 4, COLLAPSE({1, 0, 1, 1})) END_STATE(); STATE(58); SET_LEX_STATE(0); - REDUCE(ts_aux_sym_token12, ts_sym_array, 2, COLLAPSE({1, 1})) - REDUCE(ts_aux_sym_token13, ts_sym_array, 2, COLLAPSE({1, 1})) + REDUCE(ts_aux_sym_token1, ts_sym_array, 2, COLLAPSE({1, 1})) + REDUCE(ts_aux_sym_token2, ts_sym_array, 2, COLLAPSE({1, 1})) END_STATE(); STATE(59); - SET_LEX_STATE(55); - SHIFT(ts_sym_identifier, 60) + SET_LEX_STATE(62); + SHIFT(ts_aux_sym_token4, 60) END_STATE(); STATE(60); - SET_LEX_STATE(53); - SHIFT(ts_aux_sym_token5, 61) + SET_LEX_STATE(48); + SHIFT(ts_sym_array, 61) + SHIFT(ts_sym_expression, 62) + SHIFT(ts_sym_false, 61) + SHIFT(ts_sym_literal, 94) + SHIFT(ts_sym_null, 61) + SHIFT(ts_sym_number, 61) + SHIFT(ts_sym_object, 61) + SHIFT(ts_sym_string, 61) + SHIFT(ts_sym_true, 61) + SHIFT(ts_aux_sym_token12, 95) + SHIFT(ts_aux_sym_token6, 100) END_STATE(); STATE(61); - SET_LEX_STATE(48); + SET_LEX_STATE(53); + REDUCE(ts_aux_sym_token5, ts_sym_literal, 1, COLLAPSE({0})) + END_STATE(); + + STATE(62); + SET_LEX_STATE(53); + SHIFT(ts_aux_sym_token5, 63) + END_STATE(); + + STATE(63); + SET_LEX_STATE(61); + SHIFT(ts_sym_block, 64) + SHIFT(ts_aux_sym_token6, 65) + END_STATE(); + + STATE(64); + SET_LEX_STATE(3); + REDUCE(ts_sym_false, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) + REDUCE(ts_sym_null, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) + REDUCE(ts_sym_number, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) + REDUCE(ts_sym_string, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) + REDUCE(ts_sym_true, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) + REDUCE(ts_aux_sym_token12, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) + REDUCE(ts_aux_sym_token3, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) + REDUCE(ts_aux_sym_token6, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) + REDUCE(ts_aux_sym_token8, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) + REDUCE(ts_builtin_sym_end, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) + END_STATE(); + + STATE(65); + SET_LEX_STATE(55); SHIFT(ts_sym_array, 1) - SHIFT(ts_sym_expression, 62) + SHIFT(ts_sym_assignment, 66) + SHIFT(ts_sym_expression, 66) SHIFT(ts_sym_false, 1) + SHIFT(ts_sym_if, 69) SHIFT(ts_sym_literal, 6) SHIFT(ts_sym_null, 1) SHIFT(ts_sym_number, 1) SHIFT(ts_sym_object, 1) + SHIFT(ts_sym_statement, 70) SHIFT(ts_sym_string, 1) SHIFT(ts_sym_true, 1) - SHIFT(ts_aux_sym_token1, 10) - SHIFT(ts_aux_sym_token6, 63) + SHIFT(ts_aux_sym_repeat_helper2, 110) + SHIFT(ts_aux_sym_token12, 10) + SHIFT(ts_aux_sym_token3, 72) + SHIFT(ts_aux_sym_token6, 80) + REDUCE(ts_aux_sym_token7, ts_aux_sym_repeat_helper2, 0, COLLAPSE({})) + SHIFT(ts_aux_sym_token8, 90) END_STATE(); - STATE(62); + STATE(66); SET_LEX_STATE(0); - REDUCE(ts_aux_sym_token12, ts_sym_assignment, 4, COLLAPSE({1, 0, 1, 0})) - REDUCE(ts_aux_sym_token13, ts_sym_assignment, 4, COLLAPSE({1, 0, 1, 0})) + SHIFT(ts_sym_terminator, 67) + SHIFT(ts_aux_sym_token1, 68) + SHIFT(ts_aux_sym_token2, 68) END_STATE(); - STATE(63); + STATE(67); + SET_LEX_STATE(55); + REDUCE(ts_sym_false, ts_sym_statement, 2, COLLAPSE({0, 1})) + REDUCE(ts_sym_null, ts_sym_statement, 2, COLLAPSE({0, 1})) + REDUCE(ts_sym_number, ts_sym_statement, 2, COLLAPSE({0, 1})) + REDUCE(ts_sym_string, ts_sym_statement, 2, COLLAPSE({0, 1})) + REDUCE(ts_sym_true, ts_sym_statement, 2, COLLAPSE({0, 1})) + REDUCE(ts_aux_sym_token12, ts_sym_statement, 2, COLLAPSE({0, 1})) + REDUCE(ts_aux_sym_token3, ts_sym_statement, 2, COLLAPSE({0, 1})) + REDUCE(ts_aux_sym_token6, ts_sym_statement, 2, COLLAPSE({0, 1})) + REDUCE(ts_aux_sym_token7, ts_sym_statement, 2, COLLAPSE({0, 1})) + REDUCE(ts_aux_sym_token8, ts_sym_statement, 2, COLLAPSE({0, 1})) + END_STATE(); + + STATE(68); + SET_LEX_STATE(55); + REDUCE(ts_sym_false, ts_sym_terminator, 1, COLLAPSE({1})) + REDUCE(ts_sym_null, ts_sym_terminator, 1, COLLAPSE({1})) + REDUCE(ts_sym_number, ts_sym_terminator, 1, COLLAPSE({1})) + REDUCE(ts_sym_string, ts_sym_terminator, 1, COLLAPSE({1})) + REDUCE(ts_sym_true, ts_sym_terminator, 1, COLLAPSE({1})) + REDUCE(ts_aux_sym_token12, ts_sym_terminator, 1, COLLAPSE({1})) + REDUCE(ts_aux_sym_token3, ts_sym_terminator, 1, COLLAPSE({1})) + REDUCE(ts_aux_sym_token6, ts_sym_terminator, 1, COLLAPSE({1})) + REDUCE(ts_aux_sym_token7, ts_sym_terminator, 1, COLLAPSE({1})) + REDUCE(ts_aux_sym_token8, ts_sym_terminator, 1, COLLAPSE({1})) + END_STATE(); + + STATE(69); + SET_LEX_STATE(55); + REDUCE(ts_sym_false, ts_sym_statement, 1, COLLAPSE({0})) + REDUCE(ts_sym_null, ts_sym_statement, 1, COLLAPSE({0})) + REDUCE(ts_sym_number, ts_sym_statement, 1, COLLAPSE({0})) + REDUCE(ts_sym_string, ts_sym_statement, 1, COLLAPSE({0})) + REDUCE(ts_sym_true, ts_sym_statement, 1, COLLAPSE({0})) + REDUCE(ts_aux_sym_token12, ts_sym_statement, 1, COLLAPSE({0})) + REDUCE(ts_aux_sym_token3, ts_sym_statement, 1, COLLAPSE({0})) + REDUCE(ts_aux_sym_token6, ts_sym_statement, 1, COLLAPSE({0})) + REDUCE(ts_aux_sym_token7, ts_sym_statement, 1, COLLAPSE({0})) + REDUCE(ts_aux_sym_token8, ts_sym_statement, 1, COLLAPSE({0})) + END_STATE(); + + STATE(70); + SET_LEX_STATE(55); + SHIFT(ts_sym_array, 1) + SHIFT(ts_sym_assignment, 66) + SHIFT(ts_sym_expression, 66) + SHIFT(ts_sym_false, 1) + SHIFT(ts_sym_if, 69) + SHIFT(ts_sym_literal, 6) + SHIFT(ts_sym_null, 1) + SHIFT(ts_sym_number, 1) + SHIFT(ts_sym_object, 1) + SHIFT(ts_sym_statement, 70) + SHIFT(ts_sym_string, 1) + SHIFT(ts_sym_true, 1) + SHIFT(ts_aux_sym_repeat_helper2, 71) + SHIFT(ts_aux_sym_token12, 10) + SHIFT(ts_aux_sym_token3, 72) + SHIFT(ts_aux_sym_token6, 80) + REDUCE(ts_aux_sym_token7, ts_aux_sym_repeat_helper2, 0, COLLAPSE({})) + SHIFT(ts_aux_sym_token8, 90) + END_STATE(); + + STATE(71); + SET_LEX_STATE(46); + REDUCE(ts_aux_sym_token7, ts_aux_sym_repeat_helper2, 2, COLLAPSE({0, 1})) + END_STATE(); + + STATE(72); + SET_LEX_STATE(62); + SHIFT(ts_aux_sym_token4, 73) + END_STATE(); + + STATE(73); + SET_LEX_STATE(48); + SHIFT(ts_sym_array, 61) + SHIFT(ts_sym_expression, 74) + SHIFT(ts_sym_false, 61) + SHIFT(ts_sym_literal, 94) + SHIFT(ts_sym_null, 61) + SHIFT(ts_sym_number, 61) + SHIFT(ts_sym_object, 61) + SHIFT(ts_sym_string, 61) + SHIFT(ts_sym_true, 61) + SHIFT(ts_aux_sym_token12, 95) + SHIFT(ts_aux_sym_token6, 100) + END_STATE(); + + STATE(74); + SET_LEX_STATE(53); + SHIFT(ts_aux_sym_token5, 75) + END_STATE(); + + STATE(75); + SET_LEX_STATE(61); + SHIFT(ts_sym_block, 76) + SHIFT(ts_aux_sym_token6, 77) + END_STATE(); + + STATE(76); + SET_LEX_STATE(55); + REDUCE(ts_sym_false, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) + REDUCE(ts_sym_null, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) + REDUCE(ts_sym_number, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) + REDUCE(ts_sym_string, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) + REDUCE(ts_sym_true, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) + REDUCE(ts_aux_sym_token12, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) + REDUCE(ts_aux_sym_token3, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) + REDUCE(ts_aux_sym_token6, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) + REDUCE(ts_aux_sym_token7, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) + REDUCE(ts_aux_sym_token8, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) + END_STATE(); + + STATE(77); + SET_LEX_STATE(55); + SHIFT(ts_sym_array, 1) + SHIFT(ts_sym_assignment, 66) + SHIFT(ts_sym_expression, 66) + SHIFT(ts_sym_false, 1) + SHIFT(ts_sym_if, 69) + SHIFT(ts_sym_literal, 6) + SHIFT(ts_sym_null, 1) + SHIFT(ts_sym_number, 1) + SHIFT(ts_sym_object, 1) + SHIFT(ts_sym_statement, 70) + SHIFT(ts_sym_string, 1) + SHIFT(ts_sym_true, 1) + SHIFT(ts_aux_sym_repeat_helper2, 78) + SHIFT(ts_aux_sym_token12, 10) + SHIFT(ts_aux_sym_token3, 72) + SHIFT(ts_aux_sym_token6, 80) + REDUCE(ts_aux_sym_token7, ts_aux_sym_repeat_helper2, 0, COLLAPSE({})) + SHIFT(ts_aux_sym_token8, 90) + END_STATE(); + + STATE(78); + SET_LEX_STATE(46); + SHIFT(ts_aux_sym_token7, 79) + END_STATE(); + + STATE(79); + SET_LEX_STATE(55); + REDUCE(ts_sym_false, ts_sym_block, 3, COLLAPSE({1, 1, 1})) + REDUCE(ts_sym_null, ts_sym_block, 3, COLLAPSE({1, 1, 1})) + REDUCE(ts_sym_number, ts_sym_block, 3, COLLAPSE({1, 1, 1})) + REDUCE(ts_sym_string, ts_sym_block, 3, COLLAPSE({1, 1, 1})) + REDUCE(ts_sym_true, ts_sym_block, 3, COLLAPSE({1, 1, 1})) + REDUCE(ts_aux_sym_token12, ts_sym_block, 3, COLLAPSE({1, 1, 1})) + REDUCE(ts_aux_sym_token3, ts_sym_block, 3, COLLAPSE({1, 1, 1})) + REDUCE(ts_aux_sym_token6, ts_sym_block, 3, COLLAPSE({1, 1, 1})) + REDUCE(ts_aux_sym_token7, ts_sym_block, 3, COLLAPSE({1, 1, 1})) + REDUCE(ts_aux_sym_token8, ts_sym_block, 3, COLLAPSE({1, 1, 1})) + END_STATE(); + + STATE(80); SET_LEX_STATE(51); - SHIFT(ts_sym_string, 64) - SHIFT(ts_aux_sym_token7, 69) - SHIFT(ts_builtin_sym_error, 70) + SHIFT(ts_sym_string, 81) + SHIFT(ts_aux_sym_token7, 86) + SHIFT(ts_builtin_sym_error, 87) END_STATE(); - STATE(64); + STATE(81); SET_LEX_STATE(49); - SHIFT(ts_aux_sym_token11, 65) + SHIFT(ts_aux_sym_token10, 82) END_STATE(); - STATE(65); + STATE(82); SET_LEX_STATE(48); SHIFT(ts_sym_array, 27) - SHIFT(ts_sym_expression, 66) + SHIFT(ts_sym_expression, 83) SHIFT(ts_sym_false, 27) SHIFT(ts_sym_literal, 36) SHIFT(ts_sym_null, 27) @@ -1160,289 +1363,86 @@ PARSE_TABLE() { SHIFT(ts_sym_object, 27) SHIFT(ts_sym_string, 27) SHIFT(ts_sym_true, 27) - SHIFT(ts_aux_sym_token1, 37) + SHIFT(ts_aux_sym_token12, 37) SHIFT(ts_aux_sym_token6, 42) END_STATE(); - STATE(66); - SET_LEX_STATE(44); - SHIFT(ts_aux_sym_repeat_helper3, 67) - SHIFT(ts_aux_sym_token2, 31) - REDUCE(ts_aux_sym_token7, ts_aux_sym_repeat_helper3, 0, COLLAPSE({})) - END_STATE(); - - STATE(67); - SET_LEX_STATE(46); - SHIFT(ts_aux_sym_token7, 68) - END_STATE(); - - STATE(68); - SET_LEX_STATE(0); - REDUCE(ts_aux_sym_token12, ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})) - REDUCE(ts_aux_sym_token13, ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})) - END_STATE(); - - STATE(69); - SET_LEX_STATE(0); - REDUCE(ts_aux_sym_token12, ts_sym_object, 2, COLLAPSE({1, 1})) - REDUCE(ts_aux_sym_token13, ts_sym_object, 2, COLLAPSE({1, 1})) - END_STATE(); - - STATE(70); - SET_LEX_STATE(44); - SHIFT(ts_aux_sym_repeat_helper3, 71) - SHIFT(ts_aux_sym_token2, 31) - REDUCE(ts_aux_sym_token7, ts_aux_sym_repeat_helper3, 0, COLLAPSE({})) - END_STATE(); - - STATE(71); - SET_LEX_STATE(46); - SHIFT(ts_aux_sym_token7, 72) - END_STATE(); - - STATE(72); - SET_LEX_STATE(0); - REDUCE(ts_aux_sym_token12, ts_sym_object, 4, COLLAPSE({1, 0, 1, 1})) - REDUCE(ts_aux_sym_token13, ts_sym_object, 4, COLLAPSE({1, 0, 1, 1})) - END_STATE(); - - STATE(73); - SET_LEX_STATE(62); - SHIFT(ts_aux_sym_token9, 74) - END_STATE(); - - STATE(74); - SET_LEX_STATE(48); - SHIFT(ts_sym_array, 75) - SHIFT(ts_sym_expression, 76) - SHIFT(ts_sym_false, 75) - SHIFT(ts_sym_literal, 94) - SHIFT(ts_sym_null, 75) - SHIFT(ts_sym_number, 75) - SHIFT(ts_sym_object, 75) - SHIFT(ts_sym_string, 75) - SHIFT(ts_sym_true, 75) - SHIFT(ts_aux_sym_token1, 95) - SHIFT(ts_aux_sym_token6, 100) - END_STATE(); - - STATE(75); - SET_LEX_STATE(58); - REDUCE(ts_aux_sym_token10, ts_sym_literal, 1, COLLAPSE({0})) - END_STATE(); - - STATE(76); - SET_LEX_STATE(58); - SHIFT(ts_aux_sym_token10, 77) - END_STATE(); - - STATE(77); - SET_LEX_STATE(61); - SHIFT(ts_sym_block, 78) - SHIFT(ts_aux_sym_token6, 79) - END_STATE(); - - STATE(78); - SET_LEX_STATE(3); - REDUCE(ts_sym_false, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) - REDUCE(ts_sym_null, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) - REDUCE(ts_sym_number, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) - REDUCE(ts_sym_string, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) - REDUCE(ts_sym_true, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) - REDUCE(ts_aux_sym_token1, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) - REDUCE(ts_aux_sym_token4, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) - REDUCE(ts_aux_sym_token6, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) - REDUCE(ts_aux_sym_token8, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) - REDUCE(ts_builtin_sym_end, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) - END_STATE(); - - STATE(79); - SET_LEX_STATE(60); - SHIFT(ts_sym_array, 1) - SHIFT(ts_sym_assignment, 80) - SHIFT(ts_sym_expression, 80) - SHIFT(ts_sym_false, 1) - SHIFT(ts_sym_if, 83) - SHIFT(ts_sym_literal, 6) - SHIFT(ts_sym_null, 1) - SHIFT(ts_sym_number, 1) - SHIFT(ts_sym_object, 1) - SHIFT(ts_sym_statement, 84) - SHIFT(ts_sym_string, 1) - SHIFT(ts_sym_true, 1) - SHIFT(ts_aux_sym_repeat_helper2, 110) - SHIFT(ts_aux_sym_token1, 10) - SHIFT(ts_aux_sym_token4, 59) - SHIFT(ts_aux_sym_token6, 63) - REDUCE(ts_aux_sym_token7, ts_aux_sym_repeat_helper2, 0, COLLAPSE({})) - SHIFT(ts_aux_sym_token8, 86) - END_STATE(); - - STATE(80); - SET_LEX_STATE(0); - SHIFT(ts_sym_terminator, 81) - SHIFT(ts_aux_sym_token12, 82) - SHIFT(ts_aux_sym_token13, 82) - END_STATE(); - - STATE(81); - SET_LEX_STATE(60); - REDUCE(ts_sym_false, ts_sym_statement, 2, COLLAPSE({0, 1})) - REDUCE(ts_sym_null, ts_sym_statement, 2, COLLAPSE({0, 1})) - REDUCE(ts_sym_number, ts_sym_statement, 2, COLLAPSE({0, 1})) - REDUCE(ts_sym_string, ts_sym_statement, 2, COLLAPSE({0, 1})) - REDUCE(ts_sym_true, ts_sym_statement, 2, COLLAPSE({0, 1})) - REDUCE(ts_aux_sym_token1, ts_sym_statement, 2, COLLAPSE({0, 1})) - REDUCE(ts_aux_sym_token4, ts_sym_statement, 2, COLLAPSE({0, 1})) - REDUCE(ts_aux_sym_token6, ts_sym_statement, 2, COLLAPSE({0, 1})) - REDUCE(ts_aux_sym_token7, ts_sym_statement, 2, COLLAPSE({0, 1})) - REDUCE(ts_aux_sym_token8, ts_sym_statement, 2, COLLAPSE({0, 1})) - END_STATE(); - - STATE(82); - SET_LEX_STATE(60); - REDUCE(ts_sym_false, ts_sym_terminator, 1, COLLAPSE({1})) - REDUCE(ts_sym_null, ts_sym_terminator, 1, COLLAPSE({1})) - REDUCE(ts_sym_number, ts_sym_terminator, 1, COLLAPSE({1})) - REDUCE(ts_sym_string, ts_sym_terminator, 1, COLLAPSE({1})) - REDUCE(ts_sym_true, ts_sym_terminator, 1, COLLAPSE({1})) - REDUCE(ts_aux_sym_token1, ts_sym_terminator, 1, COLLAPSE({1})) - REDUCE(ts_aux_sym_token4, ts_sym_terminator, 1, COLLAPSE({1})) - REDUCE(ts_aux_sym_token6, ts_sym_terminator, 1, COLLAPSE({1})) - REDUCE(ts_aux_sym_token7, ts_sym_terminator, 1, COLLAPSE({1})) - REDUCE(ts_aux_sym_token8, ts_sym_terminator, 1, COLLAPSE({1})) - END_STATE(); - STATE(83); - SET_LEX_STATE(60); - REDUCE(ts_sym_false, ts_sym_statement, 1, COLLAPSE({0})) - REDUCE(ts_sym_null, ts_sym_statement, 1, COLLAPSE({0})) - REDUCE(ts_sym_number, ts_sym_statement, 1, COLLAPSE({0})) - REDUCE(ts_sym_string, ts_sym_statement, 1, COLLAPSE({0})) - REDUCE(ts_sym_true, ts_sym_statement, 1, COLLAPSE({0})) - REDUCE(ts_aux_sym_token1, ts_sym_statement, 1, COLLAPSE({0})) - REDUCE(ts_aux_sym_token4, ts_sym_statement, 1, COLLAPSE({0})) - REDUCE(ts_aux_sym_token6, ts_sym_statement, 1, COLLAPSE({0})) - REDUCE(ts_aux_sym_token7, ts_sym_statement, 1, COLLAPSE({0})) - REDUCE(ts_aux_sym_token8, ts_sym_statement, 1, COLLAPSE({0})) + SET_LEX_STATE(44); + SHIFT(ts_aux_sym_repeat_helper3, 84) + SHIFT(ts_aux_sym_token11, 31) + REDUCE(ts_aux_sym_token7, ts_aux_sym_repeat_helper3, 0, COLLAPSE({})) END_STATE(); STATE(84); - SET_LEX_STATE(60); - SHIFT(ts_sym_array, 1) - SHIFT(ts_sym_assignment, 80) - SHIFT(ts_sym_expression, 80) - SHIFT(ts_sym_false, 1) - SHIFT(ts_sym_if, 83) - SHIFT(ts_sym_literal, 6) - SHIFT(ts_sym_null, 1) - SHIFT(ts_sym_number, 1) - SHIFT(ts_sym_object, 1) - SHIFT(ts_sym_statement, 84) - SHIFT(ts_sym_string, 1) - SHIFT(ts_sym_true, 1) - SHIFT(ts_aux_sym_repeat_helper2, 85) - SHIFT(ts_aux_sym_token1, 10) - SHIFT(ts_aux_sym_token4, 59) - SHIFT(ts_aux_sym_token6, 63) - REDUCE(ts_aux_sym_token7, ts_aux_sym_repeat_helper2, 0, COLLAPSE({})) - SHIFT(ts_aux_sym_token8, 86) + SET_LEX_STATE(46); + SHIFT(ts_aux_sym_token7, 85) END_STATE(); STATE(85); - SET_LEX_STATE(46); - REDUCE(ts_aux_sym_token7, ts_aux_sym_repeat_helper2, 2, COLLAPSE({0, 1})) + SET_LEX_STATE(0); + REDUCE(ts_aux_sym_token1, ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})) + REDUCE(ts_aux_sym_token2, ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})) END_STATE(); STATE(86); - SET_LEX_STATE(62); - SHIFT(ts_aux_sym_token9, 87) + SET_LEX_STATE(0); + REDUCE(ts_aux_sym_token1, ts_sym_object, 2, COLLAPSE({1, 1})) + REDUCE(ts_aux_sym_token2, ts_sym_object, 2, COLLAPSE({1, 1})) END_STATE(); STATE(87); - SET_LEX_STATE(48); - SHIFT(ts_sym_array, 75) - SHIFT(ts_sym_expression, 88) - SHIFT(ts_sym_false, 75) - SHIFT(ts_sym_literal, 94) - SHIFT(ts_sym_null, 75) - SHIFT(ts_sym_number, 75) - SHIFT(ts_sym_object, 75) - SHIFT(ts_sym_string, 75) - SHIFT(ts_sym_true, 75) - SHIFT(ts_aux_sym_token1, 95) - SHIFT(ts_aux_sym_token6, 100) + SET_LEX_STATE(44); + SHIFT(ts_aux_sym_repeat_helper3, 88) + SHIFT(ts_aux_sym_token11, 31) + REDUCE(ts_aux_sym_token7, ts_aux_sym_repeat_helper3, 0, COLLAPSE({})) END_STATE(); STATE(88); - SET_LEX_STATE(58); - SHIFT(ts_aux_sym_token10, 89) + SET_LEX_STATE(46); + SHIFT(ts_aux_sym_token7, 89) END_STATE(); STATE(89); - SET_LEX_STATE(61); - SHIFT(ts_sym_block, 90) - SHIFT(ts_aux_sym_token6, 91) + SET_LEX_STATE(0); + REDUCE(ts_aux_sym_token1, ts_sym_object, 4, COLLAPSE({1, 0, 1, 1})) + REDUCE(ts_aux_sym_token2, ts_sym_object, 4, COLLAPSE({1, 0, 1, 1})) END_STATE(); STATE(90); - SET_LEX_STATE(60); - REDUCE(ts_sym_false, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) - REDUCE(ts_sym_null, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) - REDUCE(ts_sym_number, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) - REDUCE(ts_sym_string, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) - REDUCE(ts_sym_true, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) - REDUCE(ts_aux_sym_token1, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) - REDUCE(ts_aux_sym_token4, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) - REDUCE(ts_aux_sym_token6, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) - REDUCE(ts_aux_sym_token7, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) - REDUCE(ts_aux_sym_token8, ts_sym_if, 5, COLLAPSE({1, 1, 0, 1, 0})) + SET_LEX_STATE(58); + SHIFT(ts_sym_identifier, 91) END_STATE(); STATE(91); - SET_LEX_STATE(60); + SET_LEX_STATE(56); + SHIFT(ts_aux_sym_token9, 92) + END_STATE(); + + STATE(92); + SET_LEX_STATE(48); SHIFT(ts_sym_array, 1) - SHIFT(ts_sym_assignment, 80) - SHIFT(ts_sym_expression, 80) + SHIFT(ts_sym_expression, 93) SHIFT(ts_sym_false, 1) - SHIFT(ts_sym_if, 83) SHIFT(ts_sym_literal, 6) SHIFT(ts_sym_null, 1) SHIFT(ts_sym_number, 1) SHIFT(ts_sym_object, 1) - SHIFT(ts_sym_statement, 84) SHIFT(ts_sym_string, 1) SHIFT(ts_sym_true, 1) - SHIFT(ts_aux_sym_repeat_helper2, 92) - SHIFT(ts_aux_sym_token1, 10) - SHIFT(ts_aux_sym_token4, 59) - SHIFT(ts_aux_sym_token6, 63) - REDUCE(ts_aux_sym_token7, ts_aux_sym_repeat_helper2, 0, COLLAPSE({})) - SHIFT(ts_aux_sym_token8, 86) - END_STATE(); - - STATE(92); - SET_LEX_STATE(46); - SHIFT(ts_aux_sym_token7, 93) + SHIFT(ts_aux_sym_token12, 10) + SHIFT(ts_aux_sym_token6, 80) END_STATE(); STATE(93); - SET_LEX_STATE(60); - REDUCE(ts_sym_false, ts_sym_block, 3, COLLAPSE({1, 1, 1})) - REDUCE(ts_sym_null, ts_sym_block, 3, COLLAPSE({1, 1, 1})) - REDUCE(ts_sym_number, ts_sym_block, 3, COLLAPSE({1, 1, 1})) - REDUCE(ts_sym_string, ts_sym_block, 3, COLLAPSE({1, 1, 1})) - REDUCE(ts_sym_true, ts_sym_block, 3, COLLAPSE({1, 1, 1})) - REDUCE(ts_aux_sym_token1, ts_sym_block, 3, COLLAPSE({1, 1, 1})) - REDUCE(ts_aux_sym_token4, ts_sym_block, 3, COLLAPSE({1, 1, 1})) - REDUCE(ts_aux_sym_token6, ts_sym_block, 3, COLLAPSE({1, 1, 1})) - REDUCE(ts_aux_sym_token7, ts_sym_block, 3, COLLAPSE({1, 1, 1})) - REDUCE(ts_aux_sym_token8, ts_sym_block, 3, COLLAPSE({1, 1, 1})) + SET_LEX_STATE(0); + REDUCE(ts_aux_sym_token1, ts_sym_assignment, 4, COLLAPSE({1, 0, 1, 0})) + REDUCE(ts_aux_sym_token2, ts_sym_assignment, 4, COLLAPSE({1, 0, 1, 0})) END_STATE(); STATE(94); - SET_LEX_STATE(58); - REDUCE(ts_aux_sym_token10, ts_sym_expression, 1, COLLAPSE({0})) + SET_LEX_STATE(53); + REDUCE(ts_aux_sym_token5, ts_sym_expression, 1, COLLAPSE({0})) END_STATE(); STATE(95); @@ -1456,32 +1456,32 @@ PARSE_TABLE() { SHIFT(ts_sym_object, 11) SHIFT(ts_sym_string, 11) SHIFT(ts_sym_true, 11) - SHIFT(ts_aux_sym_token1, 19) - SHIFT(ts_aux_sym_token3, 99) + SHIFT(ts_aux_sym_token12, 19) + SHIFT(ts_aux_sym_token13, 99) SHIFT(ts_aux_sym_token6, 24) SHIFT(ts_builtin_sym_error, 96) END_STATE(); STATE(96); SET_LEX_STATE(40); - SHIFT(ts_aux_sym_repeat_helper1, 97) - SHIFT(ts_aux_sym_token2, 15) - REDUCE(ts_aux_sym_token3, ts_aux_sym_repeat_helper1, 0, COLLAPSE({})) + SHIFT(ts_aux_sym_repeat_helper4, 97) + SHIFT(ts_aux_sym_token11, 15) + REDUCE(ts_aux_sym_token13, ts_aux_sym_repeat_helper4, 0, COLLAPSE({})) END_STATE(); STATE(97); SET_LEX_STATE(43); - SHIFT(ts_aux_sym_token3, 98) + SHIFT(ts_aux_sym_token13, 98) END_STATE(); STATE(98); - SET_LEX_STATE(58); - REDUCE(ts_aux_sym_token10, ts_sym_array, 4, COLLAPSE({1, 0, 1, 1})) + SET_LEX_STATE(53); + REDUCE(ts_aux_sym_token5, ts_sym_array, 4, COLLAPSE({1, 0, 1, 1})) END_STATE(); STATE(99); - SET_LEX_STATE(58); - REDUCE(ts_aux_sym_token10, ts_sym_array, 2, COLLAPSE({1, 1})) + SET_LEX_STATE(53); + REDUCE(ts_aux_sym_token5, ts_sym_array, 2, COLLAPSE({1, 1})) END_STATE(); STATE(100); @@ -1493,7 +1493,7 @@ PARSE_TABLE() { STATE(101); SET_LEX_STATE(49); - SHIFT(ts_aux_sym_token11, 102) + SHIFT(ts_aux_sym_token10, 102) END_STATE(); STATE(102); @@ -1507,14 +1507,14 @@ PARSE_TABLE() { SHIFT(ts_sym_object, 27) SHIFT(ts_sym_string, 27) SHIFT(ts_sym_true, 27) - SHIFT(ts_aux_sym_token1, 37) + SHIFT(ts_aux_sym_token12, 37) SHIFT(ts_aux_sym_token6, 42) END_STATE(); STATE(103); SET_LEX_STATE(44); SHIFT(ts_aux_sym_repeat_helper3, 104) - SHIFT(ts_aux_sym_token2, 31) + SHIFT(ts_aux_sym_token11, 31) REDUCE(ts_aux_sym_token7, ts_aux_sym_repeat_helper3, 0, COLLAPSE({})) END_STATE(); @@ -1524,19 +1524,19 @@ PARSE_TABLE() { END_STATE(); STATE(105); - SET_LEX_STATE(58); - REDUCE(ts_aux_sym_token10, ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})) + SET_LEX_STATE(53); + REDUCE(ts_aux_sym_token5, ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1})) END_STATE(); STATE(106); - SET_LEX_STATE(58); - REDUCE(ts_aux_sym_token10, ts_sym_object, 2, COLLAPSE({1, 1})) + SET_LEX_STATE(53); + REDUCE(ts_aux_sym_token5, ts_sym_object, 2, COLLAPSE({1, 1})) END_STATE(); STATE(107); SET_LEX_STATE(44); SHIFT(ts_aux_sym_repeat_helper3, 108) - SHIFT(ts_aux_sym_token2, 31) + SHIFT(ts_aux_sym_token11, 31) REDUCE(ts_aux_sym_token7, ts_aux_sym_repeat_helper3, 0, COLLAPSE({})) END_STATE(); @@ -1546,8 +1546,8 @@ PARSE_TABLE() { END_STATE(); STATE(109); - SET_LEX_STATE(58); - REDUCE(ts_aux_sym_token10, ts_sym_object, 4, COLLAPSE({1, 0, 1, 1})) + SET_LEX_STATE(53); + REDUCE(ts_aux_sym_token5, ts_sym_object, 4, COLLAPSE({1, 0, 1, 1})) END_STATE(); STATE(110); @@ -1562,8 +1562,8 @@ PARSE_TABLE() { REDUCE(ts_sym_number, ts_sym_block, 3, COLLAPSE({1, 1, 1})) REDUCE(ts_sym_string, ts_sym_block, 3, COLLAPSE({1, 1, 1})) REDUCE(ts_sym_true, ts_sym_block, 3, COLLAPSE({1, 1, 1})) - REDUCE(ts_aux_sym_token1, ts_sym_block, 3, COLLAPSE({1, 1, 1})) - REDUCE(ts_aux_sym_token4, ts_sym_block, 3, COLLAPSE({1, 1, 1})) + REDUCE(ts_aux_sym_token12, ts_sym_block, 3, COLLAPSE({1, 1, 1})) + REDUCE(ts_aux_sym_token3, ts_sym_block, 3, COLLAPSE({1, 1, 1})) REDUCE(ts_aux_sym_token6, ts_sym_block, 3, COLLAPSE({1, 1, 1})) REDUCE(ts_aux_sym_token8, ts_sym_block, 3, COLLAPSE({1, 1, 1})) REDUCE(ts_builtin_sym_end, ts_sym_block, 3, COLLAPSE({1, 1, 1})) diff --git a/examples/parsers/json.c b/examples/parsers/json.c index 302e1b53..9ae1817b 100644 --- a/examples/parsers/json.c +++ b/examples/parsers/json.c @@ -387,8 +387,8 @@ PARSE_TABLE() { STATE(7); SET_LEX_STATE(1); SHIFT(ts_sym_comma, 8) - REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({})) - SHIFT(ts_aux_sym_repeat_helper2, 49) + REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper1, 0, COLLAPSE({})) + SHIFT(ts_aux_sym_repeat_helper1, 49) END_STATE(); STATE(8); @@ -419,13 +419,13 @@ PARSE_TABLE() { STATE(11); SET_LEX_STATE(1); SHIFT(ts_sym_comma, 8) - REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({})) - SHIFT(ts_aux_sym_repeat_helper2, 12) + REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper1, 0, COLLAPSE({})) + SHIFT(ts_aux_sym_repeat_helper1, 12) END_STATE(); STATE(12); SET_LEX_STATE(4); - REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 5, COLLAPSE({1, 0, 1, 0, 1})) + REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper1, 5, COLLAPSE({1, 0, 1, 0, 1})) END_STATE(); STATE(13); @@ -457,8 +457,8 @@ PARSE_TABLE() { STATE(16); SET_LEX_STATE(1); SHIFT(ts_sym_comma, 8) - REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({})) - SHIFT(ts_aux_sym_repeat_helper2, 17) + REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper1, 0, COLLAPSE({})) + SHIFT(ts_aux_sym_repeat_helper1, 17) END_STATE(); STATE(17); @@ -497,8 +497,8 @@ PARSE_TABLE() { STATE(21); SET_LEX_STATE(5); SHIFT(ts_sym_comma, 22) - REDUCE(ts_sym_right_bracket, ts_aux_sym_repeat_helper1, 0, COLLAPSE({})) - SHIFT(ts_aux_sym_repeat_helper1, 40) + REDUCE(ts_sym_right_bracket, ts_aux_sym_repeat_helper2, 0, COLLAPSE({})) + SHIFT(ts_aux_sym_repeat_helper2, 40) END_STATE(); STATE(22); @@ -519,13 +519,13 @@ PARSE_TABLE() { STATE(23); SET_LEX_STATE(5); SHIFT(ts_sym_comma, 22) - REDUCE(ts_sym_right_bracket, ts_aux_sym_repeat_helper1, 0, COLLAPSE({})) - SHIFT(ts_aux_sym_repeat_helper1, 24) + REDUCE(ts_sym_right_bracket, ts_aux_sym_repeat_helper2, 0, COLLAPSE({})) + SHIFT(ts_aux_sym_repeat_helper2, 24) END_STATE(); STATE(24); SET_LEX_STATE(7); - REDUCE(ts_sym_right_bracket, ts_aux_sym_repeat_helper1, 3, COLLAPSE({1, 0, 1})) + REDUCE(ts_sym_right_bracket, ts_aux_sym_repeat_helper2, 3, COLLAPSE({1, 0, 1})) END_STATE(); STATE(25); @@ -557,8 +557,8 @@ PARSE_TABLE() { STATE(28); SET_LEX_STATE(1); SHIFT(ts_sym_comma, 8) - REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({})) - SHIFT(ts_aux_sym_repeat_helper2, 29) + REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper1, 0, COLLAPSE({})) + SHIFT(ts_aux_sym_repeat_helper1, 29) END_STATE(); STATE(29); @@ -581,8 +581,8 @@ PARSE_TABLE() { STATE(32); SET_LEX_STATE(1); SHIFT(ts_sym_comma, 8) - REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({})) - SHIFT(ts_aux_sym_repeat_helper2, 33) + REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper1, 0, COLLAPSE({})) + SHIFT(ts_aux_sym_repeat_helper1, 33) END_STATE(); STATE(33); @@ -615,8 +615,8 @@ PARSE_TABLE() { STATE(36); SET_LEX_STATE(5); SHIFT(ts_sym_comma, 22) - REDUCE(ts_sym_right_bracket, ts_aux_sym_repeat_helper1, 0, COLLAPSE({})) - SHIFT(ts_aux_sym_repeat_helper1, 37) + REDUCE(ts_sym_right_bracket, ts_aux_sym_repeat_helper2, 0, COLLAPSE({})) + SHIFT(ts_aux_sym_repeat_helper2, 37) END_STATE(); STATE(37); @@ -662,8 +662,8 @@ PARSE_TABLE() { STATE(44); SET_LEX_STATE(1); SHIFT(ts_sym_comma, 8) - REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({})) - SHIFT(ts_aux_sym_repeat_helper2, 45) + REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper1, 0, COLLAPSE({})) + SHIFT(ts_aux_sym_repeat_helper1, 45) END_STATE(); STATE(45); @@ -680,13 +680,13 @@ PARSE_TABLE() { STATE(47); SET_LEX_STATE(1); SHIFT(ts_sym_comma, 8) - REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({})) - SHIFT(ts_aux_sym_repeat_helper2, 48) + REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper1, 0, COLLAPSE({})) + SHIFT(ts_aux_sym_repeat_helper1, 48) END_STATE(); STATE(48); SET_LEX_STATE(4); - REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 3, COLLAPSE({1, 0, 1})) + REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper1, 3, COLLAPSE({1, 0, 1})) END_STATE(); STATE(49); @@ -707,8 +707,8 @@ PARSE_TABLE() { STATE(52); SET_LEX_STATE(1); SHIFT(ts_sym_comma, 8) - REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({})) - SHIFT(ts_aux_sym_repeat_helper2, 53) + REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper1, 0, COLLAPSE({})) + SHIFT(ts_aux_sym_repeat_helper1, 53) END_STATE(); STATE(53); @@ -740,8 +740,8 @@ PARSE_TABLE() { STATE(56); SET_LEX_STATE(5); SHIFT(ts_sym_comma, 22) - REDUCE(ts_sym_right_bracket, ts_aux_sym_repeat_helper1, 0, COLLAPSE({})) - SHIFT(ts_aux_sym_repeat_helper1, 57) + REDUCE(ts_sym_right_bracket, ts_aux_sym_repeat_helper2, 0, COLLAPSE({})) + SHIFT(ts_aux_sym_repeat_helper2, 57) END_STATE(); STATE(57); diff --git a/include/tree_sitter/compiler.h b/include/tree_sitter/compiler.h index ad334920..b5f437e6 100644 --- a/include/tree_sitter/compiler.h +++ b/include/tree_sitter/compiler.h @@ -2,7 +2,6 @@ #define TREE_SITTER_COMPILER_H_ #include -#include #include #include @@ -26,10 +25,11 @@ namespace tree_sitter { class Grammar { public: - Grammar(std::string start_rule_name, const std::map &rules); + Grammar(const std::vector> &rules); bool operator==(const Grammar &other) const; - const std::string start_rule_name; - const std::map rules; + std::string start_rule_name() const; + const rules::rule_ptr rule(const std::string &name) const; + const std::vector> rules; }; std::ostream& operator<<(std::ostream &stream, const Grammar &grammar); diff --git a/spec/compiler/build_tables/build_tables_spec.cc b/spec/compiler/build_tables/build_tables_spec.cc index 4c116c24..1122ac40 100644 --- a/spec/compiler/build_tables/build_tables_spec.cc +++ b/spec/compiler/build_tables/build_tables_spec.cc @@ -20,7 +20,7 @@ static set keys(const map &map) { START_TEST describe("building parse and lex tables", []() { - PreparedGrammar grammar("expression", { + PreparedGrammar grammar({ { "expression", choice({ seq({ sym("term"), @@ -37,7 +37,7 @@ describe("building parse and lex tables", []() { }) }) } }, {}); - PreparedGrammar lex_grammar("", { + PreparedGrammar lex_grammar({ { "plus", str("+") }, { "variable", pattern("\\w+") }, { "number", pattern("\\d+") }, diff --git a/spec/compiler/build_tables/first_set_spec.cc b/spec/compiler/build_tables/first_set_spec.cc index 3eb512ef..0657ccfe 100644 --- a/spec/compiler/build_tables/first_set_spec.cc +++ b/spec/compiler/build_tables/first_set_spec.cc @@ -9,7 +9,7 @@ using namespace rules; START_TEST describe("computing FIRST sets", []() { - const PreparedGrammar null_grammar("", {}, {}); + const PreparedGrammar null_grammar({}, {}); describe("for a sequence AB", [&]() { it("ignores B when A cannot be blank", [&]() { @@ -41,7 +41,7 @@ describe("computing FIRST sets", []() { sym("A") }), sym("A") }); - Grammar grammar("A", { + Grammar grammar({ { "A", choice({ seq({ sym("y"), @@ -56,7 +56,7 @@ describe("computing FIRST sets", []() { }); it("includes FIRST(B) when A is a non-terminal and its expansion can be blank", [&]() { - Grammar grammar("A", {{ "A", choice({ sym("x"), blank() }) }}); + Grammar grammar({{ "A", choice({ sym("x"), blank() }) }}); auto rule = seq({ sym("A"), diff --git a/spec/compiler/build_tables/follow_sets_spec.cc b/spec/compiler/build_tables/follow_sets_spec.cc index 41c9b3ad..11375d69 100644 --- a/spec/compiler/build_tables/follow_sets_spec.cc +++ b/spec/compiler/build_tables/follow_sets_spec.cc @@ -9,7 +9,7 @@ using namespace rules; START_TEST describe("computing FOLLOW sets", []() { - const PreparedGrammar grammar("", { + const PreparedGrammar grammar({ { "A", sym("a") }, { "B", sym("b") }, }, {}); diff --git a/spec/compiler/build_tables/item_set_closure_spec.cc b/spec/compiler/build_tables/item_set_closure_spec.cc index b9bc49e3..a2da20d0 100644 --- a/spec/compiler/build_tables/item_set_closure_spec.cc +++ b/spec/compiler/build_tables/item_set_closure_spec.cc @@ -9,7 +9,7 @@ using namespace rules; START_TEST describe("computing closures of item sets", []() { - PreparedGrammar grammar("E", { + PreparedGrammar grammar({ { "E", choice({ seq({ sym("T"), diff --git a/spec/compiler/prepare_grammar_spec.cc b/spec/compiler/prepare_grammar_spec.cc index c824a520..bf1aee8b 100644 --- a/spec/compiler/prepare_grammar_spec.cc +++ b/spec/compiler/prepare_grammar_spec.cc @@ -11,7 +11,7 @@ using prepare_grammar::prepare_grammar; describe("preparing a grammar", []() { describe("extracting tokens", []() { it("moves strings and patterns into a separate 'lexical' grammar", [&]() { - pair result = prepare_grammar(Grammar("rule1", { + pair result = prepare_grammar(Grammar({ { "rule1", seq({ str("ab"), seq({ @@ -20,7 +20,7 @@ describe("preparing a grammar", []() { str("ab") }) } })); - AssertThat(result.first, Equals(PreparedGrammar("rule1", { + AssertThat(result.first, Equals(PreparedGrammar({ { "rule1", seq({ make_shared("token1", SymbolTypeAuxiliary), seq({ @@ -29,42 +29,42 @@ describe("preparing a grammar", []() { make_shared("token1", SymbolTypeAuxiliary) }) } }, {}))); - AssertThat(result.second, Equals(PreparedGrammar("", {}, { + AssertThat(result.second, Equals(PreparedGrammar({}, { { "token1", str("ab") }, }))); }); it("moves entire rules into the lexical grammar when possible, preserving their names", [&]() { - auto result = prepare_grammar(Grammar("rule1", { + auto result = prepare_grammar(Grammar({ { "rule1", sym("rule2") }, { "rule2", pattern("a|b") } })); - AssertThat(result.first, Equals(PreparedGrammar("rule1", { + AssertThat(result.first, Equals(PreparedGrammar({ { "rule1", sym("rule2") } }, {}))); - AssertThat(result.second, Equals(PreparedGrammar("", { + AssertThat(result.second, Equals(PreparedGrammar({ { "rule2", pattern("a|b") }, }, {}))); }); it("does not extract blanks into tokens", [&]() { - pair result = prepare_grammar(Grammar("rule1", { + pair result = prepare_grammar(Grammar({ { "rule1", choice({ sym("rule2"), blank() }) }, })); - AssertThat(result.first, Equals(PreparedGrammar("rule1", { + AssertThat(result.first, Equals(PreparedGrammar({ { "rule1", choice({ sym("rule2"), blank() }) }, }, {}))); - AssertThat(result.second, Equals(PreparedGrammar("", {}, {}))); + AssertThat(result.second, Equals(PreparedGrammar({}, {}))); }); }); describe("expanding repeats", []() { it("replaces repeat rules with pairs of recursive rules", [&]() { - PreparedGrammar result = prepare_grammar(Grammar("rule1", { + PreparedGrammar result = prepare_grammar(Grammar({ { "rule1", seq({ sym("x"), repeat(seq({ sym("a"), sym("b") })), @@ -72,7 +72,7 @@ describe("preparing a grammar", []() { }) }, })).first; - AssertThat(result, Equals(PreparedGrammar("rule1", { + AssertThat(result, Equals(PreparedGrammar({ { "rule1", seq({ sym("x"), make_shared("repeat_helper1", SymbolTypeAuxiliary), diff --git a/spec/runtime/languages/javascript/main.txt b/spec/runtime/languages/javascript/main.txt index a3bed332..6d91267e 100644 --- a/spec/runtime/languages/javascript/main.txt +++ b/spec/runtime/languages/javascript/main.txt @@ -11,7 +11,9 @@ var x = {}; ========================================== parses if statements ========================================== -if (1) { var x = 2; } +if (1) { + var x = 2; +} --- (program (statement (if diff --git a/src/compiler/build_tables/build_tables.cc b/src/compiler/build_tables/build_tables.cc index d60b5941..bfe57e5f 100644 --- a/src/compiler/build_tables/build_tables.cc +++ b/src/compiler/build_tables/build_tables.cc @@ -153,7 +153,7 @@ namespace tree_sitter { lex_grammar(lex_grammar) {} pair build() { - auto start_symbol = make_shared(grammar.start_rule_name); + auto start_symbol = make_shared(grammar.start_rule_name()); ParseItem item(rules::START, start_symbol, {}, rules::END_OF_INPUT); ParseItemSet item_set = item_set_closure(ParseItemSet({ item }), grammar); add_parse_state(item_set); diff --git a/src/compiler/grammar.cc b/src/compiler/grammar.cc index f2593c5f..d6f46fac 100644 --- a/src/compiler/grammar.cc +++ b/src/compiler/grammar.cc @@ -3,26 +3,28 @@ namespace tree_sitter { using std::string; - using std::map; using std::ostream; using rules::rule_ptr; - Grammar::Grammar(std::string start_rule_name, const map &rules) : - start_rule_name(start_rule_name), + Grammar::Grammar(const std::vector> &rules) : rules(rules) {} bool Grammar::operator==(const Grammar &other) const { - if (other.start_rule_name != start_rule_name) return false; if (other.rules.size() != rules.size()) return false; - for (auto pair : rules) { - auto other_pair = other.rules.find(pair.first); - if (other_pair == other.rules.end()) return false; - if (!other_pair->second->operator==(*pair.second)) return false; + for (size_t i = 0; i < rules.size(); i++) { + auto &pair = rules[i]; + auto &other_pair = other.rules[i]; + if (other_pair.first != pair.first) return false; + if (!other_pair.second->operator==(*pair.second)) return false; } return true; } + + string Grammar::start_rule_name() const { + return rules.front().first; + } ostream& operator<<(ostream &stream, const Grammar &grammar) { stream << string("# +#include #include #include "compiler/prepared_grammar.h" #include "compiler/rules/visitor.h" @@ -11,8 +11,9 @@ namespace tree_sitter { using std::string; + using std::vector; + using std::pair; using std::to_string; - using std::map; using std::make_shared; using rules::rule_ptr; using rules::Blank; @@ -33,7 +34,7 @@ namespace tree_sitter { void visit(const Repeat *rule) { rule_ptr inner_rule = apply(rule->content); string helper_rule_name = string("repeat_helper") + to_string(aux_rules.size() + 1); - aux_rules.insert({ helper_rule_name, make_repeat_helper(helper_rule_name, inner_rule) }); + aux_rules.push_back({ helper_rule_name, make_repeat_helper(helper_rule_name, inner_rule) }); value = make_shared(helper_rule_name, rules::SymbolTypeAuxiliary); } @@ -50,19 +51,19 @@ namespace tree_sitter { } public: - map aux_rules; + vector> aux_rules; }; PreparedGrammar expand_repeats(const PreparedGrammar &grammar) { - map rules, aux_rules(grammar.aux_rules); + vector> rules, aux_rules(grammar.aux_rules); ExpandRepeats expander; for (auto &pair : grammar.rules) - rules.insert({ pair.first, expander.apply(pair.second) }); + rules.push_back({ pair.first, expander.apply(pair.second) }); - aux_rules.insert(expander.aux_rules.begin(), expander.aux_rules.end()); + aux_rules.insert(aux_rules.end(), expander.aux_rules.begin(), expander.aux_rules.end()); - return PreparedGrammar(grammar.start_rule_name, rules, aux_rules); + return PreparedGrammar(rules, aux_rules); } } } \ No newline at end of file diff --git a/src/compiler/prepare_grammar/extract_tokens.cc b/src/compiler/prepare_grammar/extract_tokens.cc index 649952be..584887a3 100644 --- a/src/compiler/prepare_grammar/extract_tokens.cc +++ b/src/compiler/prepare_grammar/extract_tokens.cc @@ -1,5 +1,5 @@ #include "compiler/prepare_grammar/extract_tokens.h" -#include +#include #include #include "tree_sitter/compiler.h" #include "compiler/prepared_grammar.h" @@ -16,7 +16,7 @@ namespace tree_sitter { using std::pair; using std::string; using std::to_string; - using std::map; + using std::vector; using std::make_shared; using rules::rule_ptr; @@ -41,7 +41,7 @@ namespace tree_sitter { if (*pair.second == *rule) return pair.first; string name = "token" + to_string(tokens.size() + 1); - tokens.insert({ name, rule }); + tokens.push_back({ name, rule }); return name; } @@ -67,36 +67,36 @@ namespace tree_sitter { } public: - map tokens; + vector> tokens; }; pair extract_tokens(const PreparedGrammar &input_grammar) { - map rules, tokens, aux_rules, aux_tokens; + vector> rules, tokens, aux_rules, aux_tokens; TokenExtractor extractor; for (auto &pair : input_grammar.rules) { string name = pair.first; rule_ptr rule = pair.second; if (IsToken().apply(rule)) - tokens.insert({ name, rule }); + tokens.push_back({ name, rule }); else - rules.insert({ name, extractor.apply(rule) }); + rules.push_back({ name, extractor.apply(rule) }); } for (auto &pair : input_grammar.aux_rules) { string name = pair.first; rule_ptr rule = pair.second; if (IsToken().apply(rule)) - aux_tokens.insert({ name, rule }); + aux_tokens.push_back({ name, rule }); else - aux_rules.insert({ name, extractor.apply(rule) }); + aux_rules.push_back({ name, extractor.apply(rule) }); } - aux_tokens.insert(extractor.tokens.begin(), extractor.tokens.end()); + aux_tokens.insert(aux_tokens.end(), extractor.tokens.begin(), extractor.tokens.end()); return { - PreparedGrammar(input_grammar.start_rule_name, rules, aux_rules), - PreparedGrammar("", tokens, aux_tokens) + PreparedGrammar(rules, aux_rules), + PreparedGrammar(tokens, aux_tokens) }; } } diff --git a/src/compiler/prepared_grammar.cc b/src/compiler/prepared_grammar.cc index ec6386ab..73d822c1 100644 --- a/src/compiler/prepared_grammar.cc +++ b/src/compiler/prepared_grammar.cc @@ -1,28 +1,19 @@ #include "compiler/prepared_grammar.h" -#include +#include #include #include #include "compiler/rules/symbol.h" namespace tree_sitter { using std::string; - using std::initializer_list; using std::pair; - using std::map; using std::ostream; using rules::rule_ptr; using rules::Symbol; - PreparedGrammar::PreparedGrammar(std::string start_rule_name, - const map &rules, - const map &aux_rules) : - Grammar(start_rule_name, rules), - aux_rules(aux_rules) {} - - PreparedGrammar::PreparedGrammar(std::string start_rule_name, - const initializer_list> &rules, - const initializer_list> &aux_rules) : - Grammar(start_rule_name, rules), + PreparedGrammar::PreparedGrammar(const std::vector> &rules, + const std::vector> &aux_rules) : + Grammar(rules), aux_rules(aux_rules) {} PreparedGrammar::PreparedGrammar(const Grammar &grammar) : @@ -30,21 +21,21 @@ namespace tree_sitter { aux_rules({}) {} const rule_ptr PreparedGrammar::rule(const Symbol &symbol) const { - auto map = symbol.is_auxiliary() ? aux_rules : rules; - auto iter = map.find(symbol.name); - if (iter != map.end()) - return iter->second; - else - return rule_ptr(); + auto rule_set = symbol.is_auxiliary() ? aux_rules : rules; + for (auto &pair : rule_set) + if (pair.first == symbol.name) + return pair.second; + return rule_ptr(); } bool PreparedGrammar::operator==(const PreparedGrammar &other) const { if (!Grammar::operator==(other)) return false; if (other.aux_rules.size() != aux_rules.size()) return false; - for (auto pair : aux_rules) { - auto other_pair = other.aux_rules.find(pair.first); - if (other_pair == other.aux_rules.end()) return false; - if (!other_pair->second->operator==(*pair.second)) return false; + for (size_t i = 0; i < aux_rules.size(); i++) { + auto &pair = aux_rules[i]; + auto &other_pair = other.aux_rules[i]; + if (other_pair.first != pair.first) return false; + if (!other_pair.second->operator==(*pair.second)) return false; } return true; } diff --git a/src/compiler/prepared_grammar.h b/src/compiler/prepared_grammar.h index ee2804fa..04368e9d 100644 --- a/src/compiler/prepared_grammar.h +++ b/src/compiler/prepared_grammar.h @@ -1,7 +1,7 @@ #ifndef COMPILER_PREPARED_GRAMMAR_H_ #define COMPILER_PREPARED_GRAMMAR_H_ -#include +#include #include #include #include "tree_sitter/compiler.h" @@ -10,19 +10,15 @@ namespace tree_sitter { class PreparedGrammar : public Grammar { public: - PreparedGrammar(std::string start_rule_name, - const std::map &rules, - const std::map &aux_rules); - PreparedGrammar(std::string start_rule_name, - const std::initializer_list> &rules, - const std::initializer_list> &aux_rules); + PreparedGrammar(const std::vector> &rules, + const std::vector> &aux_rules); PreparedGrammar(const Grammar &grammar); bool operator==(const PreparedGrammar &other) const; bool has_definition(const rules::Symbol &symbol) const; const rules::rule_ptr rule(const rules::Symbol &symbol) const; - const std::map aux_rules; + const std::vector> aux_rules; }; std::ostream& operator<<(std::ostream &stream, const PreparedGrammar &grammar);