From c3b65d22bfc24763248ca15333d1f6bf3347e30b Mon Sep 17 00:00:00 2001 From: Max Brunsfeld Date: Tue, 28 Jan 2014 18:44:14 -0800 Subject: [PATCH] Improve prepare_grammar specs --- spec/compiler/expand_repeats_spec.cpp | 37 ---- ...kens_spec.cpp => prepare_grammar_spec.cpp} | 64 +++++-- spec/fixtures/parsers/arithmetic.c | 178 +++++++++--------- spec/fixtures/parsers/json.c | 112 +++++------ tree_sitter.xcodeproj/project.pbxproj | 20 +- 5 files changed, 193 insertions(+), 218 deletions(-) delete mode 100644 spec/compiler/expand_repeats_spec.cpp rename spec/compiler/{prepare_grammar/extract_tokens_spec.cpp => prepare_grammar_spec.cpp} (50%) diff --git a/spec/compiler/expand_repeats_spec.cpp b/spec/compiler/expand_repeats_spec.cpp deleted file mode 100644 index 92cd2d0e..00000000 --- a/spec/compiler/expand_repeats_spec.cpp +++ /dev/null @@ -1,37 +0,0 @@ -#include "spec_helper.h" -#include "prepare_grammar/expand_repeats.h" - -START_TEST - -using prepare_grammar::expand_repeats; -using namespace rules; - -describe("expanding repeat rules in a grammar", []() { - it("replaces repeat rules with pairs of recursive rules", [&]() { - Grammar result = expand_repeats(Grammar({ - { "rule1", seq({ - sym("x"), - repeat(seq({ sym("a"), sym("b") })), - sym("y") - }) }, - })); - - AssertThat(result, Equals(Grammar("rule1", { - { "rule1", seq({ - sym("x"), - aux_sym("repeat_helper1"), - sym("y") - }) }, - }, { - { "repeat_helper1", seq({ - seq({ sym("a"), sym("b") }), - choice({ - aux_sym("repeat_helper1") , - blank() - }), - }) } - }))); - }); -}); - -END_TEST \ No newline at end of file diff --git a/spec/compiler/prepare_grammar/extract_tokens_spec.cpp b/spec/compiler/prepare_grammar_spec.cpp similarity index 50% rename from spec/compiler/prepare_grammar/extract_tokens_spec.cpp rename to spec/compiler/prepare_grammar_spec.cpp index c26d2772..eace36b3 100644 --- a/spec/compiler/prepare_grammar/extract_tokens_spec.cpp +++ b/spec/compiler/prepare_grammar_spec.cpp @@ -1,14 +1,14 @@ #include "spec_helper.h" -#include "prepare_grammar/extract_tokens.h" +#include "prepare_grammar/perform.h" START_TEST -using prepare_grammar::extract_tokens; using namespace rules; +using prepare_grammar::perform; describe("preparing a grammar", []() { - it("extracts character-based subtrees into a separate grammar", [&]() { - pair result = extract_tokens(Grammar({ + it("moves sub-rules that don't contain symbols into a separate 'lexical' grammar", [&]() { + pair result = perform(Grammar({ { "rule1", seq({ character('a'), character('b'), @@ -28,7 +28,7 @@ describe("preparing a grammar", []() { sym("rule3") }), aux_sym("token1") }) } }))); - + AssertThat(result.second, Equals(Grammar("", {}, { { "token1", rules::seq({ rules::character('a'), @@ -36,8 +36,8 @@ describe("preparing a grammar", []() { }))); }); - it("turns entire rules into tokens when they contain no symbols", [&]() { - auto result = extract_tokens(Grammar({ + it("moves entire rules into the lexical grammar when possible, preserving their names", [&]() { + auto result = perform(Grammar({ { "rule1", sym("rule2") }, { "rule2", seq({ character('a'), @@ -55,27 +55,51 @@ describe("preparing a grammar", []() { }))); }); - it("looks inside sequences, choices and repeats", [&]() { - auto result = extract_tokens(Grammar({ + it("replaces repeat rules with pairs of recursive rules", [&]() { + Grammar result = perform(Grammar({ { "rule1", seq({ - choice({ - repeat(choice({ str("stuff"), sym("a") })), - sym("b"), - }), - sym("c") }) } - })); + sym("x"), + repeat(seq({ sym("a"), sym("b") })), + sym("y") + }) }, + })).first; - AssertThat(result.first, Equals(Grammar({ + AssertThat(result, Equals(Grammar("rule1", { { "rule1", seq({ + sym("x"), + aux_sym("repeat_helper1"), + sym("y") + }) }, + }, { + { "repeat_helper1", seq({ + seq({ sym("a"), sym("b") }), choice({ - repeat(choice({ aux_sym("token1"), sym("a") })), - sym("b"), + aux_sym("repeat_helper1") , + blank() }), - sym("c") }) } + }) } + }))); + }); + + it("does not replace repeat rules that can be moved into the lexical grammar", [&]() { + pair result = perform(Grammar({ + { "rule1", seq({ + sym("x"), + repeat(seq({ str("a"), str("b") })), + sym("y") + }) }, + })); + + AssertThat(result.first, Equals(Grammar("rule1", { + { "rule1", seq({ + sym("x"), + aux_sym("token1"), + sym("y") + }) }, }))); AssertThat(result.second, Equals(Grammar("", {}, { - { "token1", str("stuff") }, + { "token1", repeat(seq({ str("a"), str("b") })) }, }))); }); }); diff --git a/spec/fixtures/parsers/arithmetic.c b/spec/fixtures/parsers/arithmetic.c index 70a91561..551a8eb5 100644 --- a/spec/fixtures/parsers/arithmetic.c +++ b/spec/fixtures/parsers/arithmetic.c @@ -2,28 +2,28 @@ #include enum ts_symbol { - ts_symbol_number, - ts_symbol_expression, - ts_symbol_variable, 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__, }; static const char *ts_symbol_names[] = { - "number", - "expression", - "variable", "factor", "token1", "plus", "token2", + "number", + "variable", "times", "term", + "expression", "__END__", }; @@ -118,18 +118,18 @@ static TSParseResult ts_parse(const char *input) { switch (LOOKAHEAD_SYM()) { case ts_symbol_factor: SHIFT(45); - case ts_aux_token1: - SHIFT(42); case ts_symbol_number: SHIFT(41); - case ts_symbol_expression: - SHIFT(1); case ts_symbol_variable: SHIFT(41); + case ts_aux_token1: + SHIFT(42); case ts_symbol_term: SHIFT(2); + case ts_symbol_expression: + SHIFT(1); default: - PARSE_ERROR(6, EXPECT({"term", "expression", "variable", "number", "token1", "factor"})); + PARSE_ERROR(6, EXPECT({"expression", "term", "token1", "number", "variable", "factor"})); } case 1: SET_LEX_STATE(0); @@ -152,18 +152,18 @@ static TSParseResult ts_parse(const char *input) { case 3: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(34); - case ts_aux_token1: - SHIFT(6); case ts_symbol_number: SHIFT(5); + case ts_symbol_factor: + SHIFT(34); case ts_symbol_variable: SHIFT(5); + case ts_aux_token1: + SHIFT(6); case ts_symbol_term: SHIFT(4); default: - PARSE_ERROR(5, EXPECT({"term", "variable", "number", "token1", "factor"})); + PARSE_ERROR(5, EXPECT({"term", "token1", "variable", "factor", "number"})); } case 4: SET_LEX_STATE(0); @@ -186,20 +186,20 @@ static TSParseResult ts_parse(const char *input) { case 6: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_variable: - SHIFT(12); - case ts_symbol_expression: - SHIFT(32); case ts_symbol_factor: SHIFT(16); - case ts_aux_token1: - SHIFT(13); + case ts_symbol_expression: + SHIFT(32); 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", "variable", "expression", "number", "token1", "factor"})); + PARSE_ERROR(6, EXPECT({"term", "token1", "number", "expression", "variable", "factor"})); } case 7: SET_LEX_STATE(9); @@ -214,18 +214,18 @@ static TSParseResult ts_parse(const char *input) { case 8: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(25); - case ts_aux_token1: - SHIFT(11); case ts_symbol_number: SHIFT(10); + case ts_symbol_factor: + SHIFT(25); case ts_symbol_variable: SHIFT(10); + case ts_aux_token1: + SHIFT(11); case ts_symbol_term: SHIFT(9); default: - PARSE_ERROR(5, EXPECT({"term", "variable", "number", "token1", "factor"})); + PARSE_ERROR(5, EXPECT({"term", "token1", "variable", "factor", "number"})); } case 9: SET_LEX_STATE(4); @@ -248,20 +248,20 @@ static TSParseResult ts_parse(const char *input) { case 11: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_variable: - SHIFT(12); - case ts_symbol_expression: - SHIFT(23); case ts_symbol_factor: SHIFT(16); - case ts_aux_token1: - SHIFT(13); + 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", "variable", "expression", "number", "token1", "factor"})); + PARSE_ERROR(6, EXPECT({"term", "token1", "number", "expression", "variable", "factor"})); } case 12: SET_LEX_STATE(7); @@ -278,20 +278,20 @@ static TSParseResult ts_parse(const char *input) { case 13: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_variable: - SHIFT(12); - case ts_symbol_expression: - SHIFT(14); case ts_symbol_factor: SHIFT(16); - case ts_aux_token1: - SHIFT(13); + case ts_symbol_expression: + SHIFT(14); 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", "variable", "expression", "number", "token1", "factor"})); + PARSE_ERROR(6, EXPECT({"term", "token1", "number", "expression", "variable", "factor"})); } case 14: SET_LEX_STATE(4); @@ -328,16 +328,16 @@ static TSParseResult ts_parse(const char *input) { case 17: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(22); 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", "number", "token1", "factor"})); + PARSE_ERROR(4, EXPECT({"variable", "factor", "number", "token1"})); } case 18: SET_LEX_STATE(9); @@ -352,20 +352,20 @@ static TSParseResult ts_parse(const char *input) { case 19: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_variable: - SHIFT(12); - case ts_symbol_expression: - SHIFT(20); case ts_symbol_factor: SHIFT(16); - case ts_aux_token1: - SHIFT(13); + 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", "variable", "expression", "number", "token1", "factor"})); + PARSE_ERROR(6, EXPECT({"term", "token1", "number", "expression", "variable", "factor"})); } case 20: SET_LEX_STATE(4); @@ -426,16 +426,16 @@ static TSParseResult ts_parse(const char *input) { case 26: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(31); case ts_aux_token1: SHIFT(28); case ts_symbol_number: SHIFT(27); + case ts_symbol_factor: + SHIFT(31); case ts_symbol_variable: SHIFT(27); default: - PARSE_ERROR(4, EXPECT({"variable", "number", "token1", "factor"})); + PARSE_ERROR(4, EXPECT({"variable", "factor", "number", "token1"})); } case 27: SET_LEX_STATE(4); @@ -448,20 +448,20 @@ static TSParseResult ts_parse(const char *input) { case 28: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_variable: - SHIFT(12); - case ts_symbol_expression: - SHIFT(29); case ts_symbol_factor: SHIFT(16); - case ts_aux_token1: - SHIFT(13); + 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); default: - PARSE_ERROR(6, EXPECT({"term", "variable", "expression", "number", "token1", "factor"})); + PARSE_ERROR(6, EXPECT({"term", "token1", "number", "expression", "variable", "factor"})); } case 29: SET_LEX_STATE(4); @@ -518,16 +518,16 @@ static TSParseResult ts_parse(const char *input) { case 35: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(40); 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", "number", "token1", "factor"})); + PARSE_ERROR(4, EXPECT({"variable", "factor", "number", "token1"})); } case 36: SET_LEX_STATE(0); @@ -540,20 +540,20 @@ static TSParseResult ts_parse(const char *input) { case 37: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_variable: - SHIFT(12); - case ts_symbol_expression: - SHIFT(38); case ts_symbol_factor: SHIFT(16); - case ts_aux_token1: - SHIFT(13); + 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", "variable", "expression", "number", "token1", "factor"})); + PARSE_ERROR(6, EXPECT({"term", "token1", "number", "expression", "variable", "factor"})); } case 38: SET_LEX_STATE(4); @@ -594,20 +594,20 @@ static TSParseResult ts_parse(const char *input) { case 42: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_variable: - SHIFT(12); - case ts_symbol_expression: - SHIFT(43); case ts_symbol_factor: SHIFT(16); - case ts_aux_token1: - SHIFT(13); + case ts_symbol_expression: + SHIFT(43); 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", "variable", "expression", "number", "token1", "factor"})); + PARSE_ERROR(6, EXPECT({"term", "token1", "number", "expression", "variable", "factor"})); } case 43: SET_LEX_STATE(4); @@ -644,16 +644,16 @@ static TSParseResult ts_parse(const char *input) { case 46: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_factor: - SHIFT(51); case ts_aux_token1: SHIFT(48); case ts_symbol_number: SHIFT(47); + case ts_symbol_factor: + SHIFT(51); case ts_symbol_variable: SHIFT(47); default: - PARSE_ERROR(4, EXPECT({"variable", "number", "token1", "factor"})); + PARSE_ERROR(4, EXPECT({"variable", "factor", "number", "token1"})); } case 47: SET_LEX_STATE(14); @@ -668,20 +668,20 @@ static TSParseResult ts_parse(const char *input) { case 48: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_variable: - SHIFT(12); - case ts_symbol_expression: - SHIFT(49); case ts_symbol_factor: SHIFT(16); - case ts_aux_token1: - SHIFT(13); + case ts_symbol_expression: + SHIFT(49); 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", "variable", "expression", "number", "token1", "factor"})); + PARSE_ERROR(6, EXPECT({"term", "token1", "number", "expression", "variable", "factor"})); } case 49: SET_LEX_STATE(4); diff --git a/spec/fixtures/parsers/json.c b/spec/fixtures/parsers/json.c index 8fcc3744..60664e5a 100644 --- a/spec/fixtures/parsers/json.c +++ b/spec/fixtures/parsers/json.c @@ -2,38 +2,38 @@ #include enum ts_symbol { - ts_aux_token6, ts_symbol_number, ts_symbol_string, - ts_symbol_array, - ts_symbol_object, ts_aux_repeat_helper1, - ts_aux_token7, - ts_aux_repeat_helper2, - ts_aux_token4, - ts_aux_token5, ts_aux_token1, - ts_symbol___END__, + ts_aux_token5, + ts_symbol_array, + ts_aux_token4, ts_aux_token3, + ts_aux_token7, ts_aux_token2, + ts_symbol___END__, + ts_symbol_object, + ts_aux_token6, + ts_aux_repeat_helper2, ts_symbol_value, }; static const char *ts_symbol_names[] = { - "token6", "number", "string", - "array", - "object", "repeat_helper1", - "token7", - "repeat_helper2", - "token4", - "token5", "token1", - "__END__", + "token5", + "array", + "token4", "token3", + "token7", "token2", + "__END__", + "object", + "token6", + "repeat_helper2", "value", }; @@ -128,22 +128,22 @@ static TSParseResult ts_parse(const char *input) { case 0: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { + case ts_symbol_number: + SHIFT(53); case ts_symbol_array: SHIFT(53); - case ts_symbol_object: - SHIFT(53); - case ts_aux_token1: - SHIFT(2); case ts_symbol_string: SHIFT(53); case ts_aux_token5: SHIFT(47); - case ts_symbol_number: + case ts_aux_token1: + SHIFT(2); + case ts_symbol_object: SHIFT(53); case ts_symbol_value: SHIFT(1); default: - PARSE_ERROR(7, EXPECT({"value", "number", "token5", "string", "token1", "object", "array"})); + PARSE_ERROR(7, EXPECT({"value", "object", "token1", "token5", "string", "array", "number"})); } case 1: SET_LEX_STATE(0); @@ -156,42 +156,42 @@ static TSParseResult ts_parse(const char *input) { case 2: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_array: + case ts_symbol_number: SHIFT(25); - case ts_symbol_object: + case ts_symbol_array: SHIFT(25); case ts_symbol_string: SHIFT(25); case ts_aux_token5: SHIFT(12); - case ts_symbol_number: + case ts_symbol_object: SHIFT(25); case ts_symbol_value: SHIFT(44); case ts_aux_token1: SHIFT(3); default: - PARSE_ERROR(7, EXPECT({"token1", "string", "token5", "value", "number", "object", "array"})); + PARSE_ERROR(7, EXPECT({"token1", "value", "object", "token5", "string", "array", "number"})); } case 3: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_array: + case ts_symbol_number: SHIFT(25); - case ts_symbol_object: + case ts_symbol_array: SHIFT(25); case ts_symbol_string: SHIFT(25); case ts_aux_token5: SHIFT(12); - case ts_symbol_number: + case ts_symbol_object: SHIFT(25); case ts_symbol_value: SHIFT(4); case ts_aux_token1: SHIFT(3); default: - PARSE_ERROR(7, EXPECT({"token1", "string", "token5", "value", "number", "object", "array"})); + PARSE_ERROR(7, EXPECT({"token1", "value", "object", "token5", "string", "array", "number"})); } case 4: SET_LEX_STATE(2); @@ -226,12 +226,12 @@ static TSParseResult ts_parse(const char *input) { 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_number: - SHIFT(43); case ts_symbol_value: SHIFT(41); case ts_symbol_string: @@ -241,27 +241,27 @@ static TSParseResult ts_parse(const char *input) { case ts_aux_token1: SHIFT(8); default: - PARSE_ERROR(7, EXPECT({"token1", "number", "value", "token5", "string", "object", "array"})); + PARSE_ERROR(7, EXPECT({"token1", "token5", "string", "value", "object", "array", "number"})); } case 8: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_array: + case ts_symbol_number: SHIFT(25); - case ts_symbol_object: + case ts_symbol_array: SHIFT(25); case ts_symbol_string: SHIFT(25); case ts_aux_token5: SHIFT(12); - case ts_symbol_number: + case ts_symbol_object: SHIFT(25); case ts_symbol_value: SHIFT(9); case ts_aux_token1: SHIFT(3); default: - PARSE_ERROR(7, EXPECT({"token1", "string", "token5", "value", "number", "object", "array"})); + PARSE_ERROR(7, EXPECT({"token1", "value", "object", "token5", "string", "array", "number"})); } case 9: SET_LEX_STATE(2); @@ -312,12 +312,12 @@ static TSParseResult ts_parse(const char *input) { 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_number: - SHIFT(25); case ts_symbol_value: SHIFT(15); case ts_symbol_string: @@ -327,7 +327,7 @@ static TSParseResult ts_parse(const char *input) { case ts_aux_token1: SHIFT(3); default: - PARSE_ERROR(7, EXPECT({"token1", "number", "value", "token5", "string", "object", "array"})); + PARSE_ERROR(7, EXPECT({"token1", "token5", "string", "value", "object", "array", "number"})); } case 15: SET_LEX_STATE(2); @@ -378,12 +378,12 @@ static TSParseResult ts_parse(const char *input) { 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_number: - SHIFT(34); case ts_symbol_value: SHIFT(32); case ts_symbol_string: @@ -393,27 +393,27 @@ static TSParseResult ts_parse(const char *input) { case ts_aux_token1: SHIFT(21); default: - PARSE_ERROR(7, EXPECT({"token1", "number", "value", "token5", "string", "object", "array"})); + PARSE_ERROR(7, EXPECT({"token1", "token5", "string", "value", "object", "array", "number"})); } case 21: SET_LEX_STATE(10); switch (LOOKAHEAD_SYM()) { - case ts_symbol_array: + case ts_symbol_number: SHIFT(25); - case ts_symbol_object: + case ts_symbol_array: SHIFT(25); case ts_symbol_string: SHIFT(25); case ts_aux_token5: SHIFT(12); - case ts_symbol_number: + case ts_symbol_object: SHIFT(25); case ts_symbol_value: SHIFT(22); case ts_aux_token1: SHIFT(3); default: - PARSE_ERROR(7, EXPECT({"token1", "string", "token5", "value", "number", "object", "array"})); + PARSE_ERROR(7, EXPECT({"token1", "value", "object", "token5", "string", "array", "number"})); } case 22: SET_LEX_STATE(2); @@ -474,12 +474,12 @@ static TSParseResult ts_parse(const char *input) { case 28: 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_number: - SHIFT(25); case ts_symbol_value: SHIFT(29); case ts_symbol_string: @@ -489,7 +489,7 @@ static TSParseResult ts_parse(const char *input) { case ts_aux_token1: SHIFT(3); default: - PARSE_ERROR(7, EXPECT({"token1", "number", "value", "token5", "string", "object", "array"})); + PARSE_ERROR(7, EXPECT({"token1", "token5", "string", "value", "object", "array", "number"})); } case 29: SET_LEX_STATE(2); @@ -570,12 +570,12 @@ static TSParseResult ts_parse(const char *input) { case 37: 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_number: - SHIFT(25); case ts_symbol_value: SHIFT(38); case ts_symbol_string: @@ -585,7 +585,7 @@ static TSParseResult ts_parse(const char *input) { case ts_aux_token1: SHIFT(3); default: - PARSE_ERROR(7, EXPECT({"token1", "number", "value", "token5", "string", "object", "array"})); + PARSE_ERROR(7, EXPECT({"token1", "token5", "string", "value", "object", "array", "number"})); } case 38: SET_LEX_STATE(2); @@ -694,12 +694,12 @@ static TSParseResult ts_parse(const char *input) { case 49: 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_number: - SHIFT(25); case ts_symbol_value: SHIFT(50); case ts_symbol_string: @@ -709,7 +709,7 @@ static TSParseResult ts_parse(const char *input) { case ts_aux_token1: SHIFT(3); default: - PARSE_ERROR(7, EXPECT({"token1", "number", "value", "token5", "string", "object", "array"})); + PARSE_ERROR(7, EXPECT({"token1", "token5", "string", "value", "object", "array", "number"})); } case 50: SET_LEX_STATE(2); diff --git a/tree_sitter.xcodeproj/project.pbxproj b/tree_sitter.xcodeproj/project.pbxproj index 21a02c40..4f728673 100644 --- a/tree_sitter.xcodeproj/project.pbxproj +++ b/tree_sitter.xcodeproj/project.pbxproj @@ -14,7 +14,7 @@ 12130614182C3A1700FCF928 /* seq.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 12130612182C3A1700FCF928 /* seq.cpp */; }; 12130617182C3D2900FCF928 /* string.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 12130615182C3D2900FCF928 /* string.cpp */; }; 1214930E181E200B008E9BDA /* main.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 121492E9181E200B008E9BDA /* main.cpp */; }; - 1225CC6418765693000D4723 /* extract_tokens_spec.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1225CC6318765693000D4723 /* extract_tokens_spec.cpp */; }; + 1225CC6418765693000D4723 /* prepare_grammar_spec.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1225CC6318765693000D4723 /* prepare_grammar_spec.cpp */; }; 1251209B1830145300C9B56A /* rule.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1251209A1830145300C9B56A /* rule.cpp */; }; 125120A4183083BD00C9B56A /* arithmetic.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 125120A3183083BD00C9B56A /* arithmetic.cpp */; }; 12AB465F188BD03E00DE79DF /* follow_sets.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 12AB465D188BD03E00DE79DF /* follow_sets.cpp */; }; @@ -26,7 +26,6 @@ 12E75A9A1891BF57001B8F10 /* json.c in Sources */ = {isa = PBXBuildFile; fileRef = 12E75A981891BF3B001B8F10 /* json.c */; }; 12E75A9C1891C17D001B8F10 /* json_spec.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 12E75A9B1891C17D001B8F10 /* json_spec.cpp */; }; 12E75AA218930931001B8F10 /* expand_repeats.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 12E75AA018930931001B8F10 /* expand_repeats.cpp */; }; - 12E75AA318930982001B8F10 /* expand_repeats_spec.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 12E75A9E189308C4001B8F10 /* expand_repeats_spec.cpp */; }; 12EDCF8A187B498C005A7A07 /* tree_spec.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 12EDCF89187B498C005A7A07 /* tree_spec.cpp */; }; 12EDCF8D187C6282005A7A07 /* document.c in Sources */ = {isa = PBXBuildFile; fileRef = 12EDCF8C187C6282005A7A07 /* document.c */; }; 12EDCF981881FCD5005A7A07 /* extract_tokens.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 12EDCF8F1881FCCA005A7A07 /* extract_tokens.cpp */; }; @@ -97,7 +96,7 @@ 121492E9181E200B008E9BDA /* main.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = main.cpp; path = spec/main.cpp; sourceTree = SOURCE_ROOT; }; 121492EA181E200B008E9BDA /* rules_spec.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = rules_spec.cpp; path = spec/compiler/rules/rules_spec.cpp; sourceTree = SOURCE_ROOT; }; 121D8B3018795CC0003CF44B /* parser.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = parser.h; sourceTree = ""; }; - 1225CC6318765693000D4723 /* extract_tokens_spec.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = extract_tokens_spec.cpp; path = prepare_grammar/extract_tokens_spec.cpp; sourceTree = ""; }; + 1225CC6318765693000D4723 /* prepare_grammar_spec.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = prepare_grammar_spec.cpp; sourceTree = ""; }; 1251209A1830145300C9B56A /* rule.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = rule.cpp; sourceTree = ""; }; 125120A218307FFD00C9B56A /* test_grammars.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = test_grammars.h; path = spec/fixtures/grammars/test_grammars.h; sourceTree = SOURCE_ROOT; }; 125120A3183083BD00C9B56A /* arithmetic.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = arithmetic.cpp; path = spec/fixtures/grammars/arithmetic.cpp; sourceTree = SOURCE_ROOT; }; @@ -117,7 +116,6 @@ 12E75A961891BD32001B8F10 /* json.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = json.cpp; sourceTree = ""; }; 12E75A981891BF3B001B8F10 /* json.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = json.c; sourceTree = ""; }; 12E75A9B1891C17D001B8F10 /* json_spec.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = json_spec.cpp; sourceTree = ""; }; - 12E75A9E189308C4001B8F10 /* expand_repeats_spec.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = expand_repeats_spec.cpp; sourceTree = ""; }; 12E75AA018930931001B8F10 /* expand_repeats.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = expand_repeats.cpp; path = src/compiler/prepare_grammar/expand_repeats.cpp; sourceTree = SOURCE_ROOT; }; 12E75AA118930931001B8F10 /* expand_repeats.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = expand_repeats.h; path = src/compiler/prepare_grammar/expand_repeats.h; sourceTree = SOURCE_ROOT; }; 12EDCF89187B498C005A7A07 /* tree_spec.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = tree_spec.cpp; sourceTree = ""; }; @@ -322,15 +320,6 @@ path = spec; sourceTree = ""; }; - 12E75A9D1892D4F1001B8F10 /* prepare_grammar */ = { - isa = PBXGroup; - children = ( - 1225CC6318765693000D4723 /* extract_tokens_spec.cpp */, - 12E75A9E189308C4001B8F10 /* expand_repeats_spec.cpp */, - ); - name = prepare_grammar; - sourceTree = ""; - }; 12ED72A5186FC6D90089229B /* prepare_grammar */ = { isa = PBXGroup; children = ( @@ -399,9 +388,9 @@ 12FD40AE185EE6610041A84E /* compiler */ = { isa = PBXGroup; children = ( - 12E75A9D1892D4F1001B8F10 /* prepare_grammar */, 1213061C182C854F00FCF928 /* build_tables */, 12FD4063185E75290041A84E /* compile_fixtures.cpp */, + 1225CC6318765693000D4723 /* prepare_grammar_spec.cpp */, 12D1369F18357066005F3369 /* rules */, ); path = compiler; @@ -532,8 +521,7 @@ 1214930E181E200B008E9BDA /* main.cpp in Sources */, 12F9A651182DD6BC00FAF50C /* grammar.cpp in Sources */, 12D136A4183678A2005F3369 /* repeat.cpp in Sources */, - 12E75AA318930982001B8F10 /* expand_repeats_spec.cpp in Sources */, - 1225CC6418765693000D4723 /* extract_tokens_spec.cpp in Sources */, + 1225CC6418765693000D4723 /* prepare_grammar_spec.cpp in Sources */, 12EDCF9A1881FCD9005A7A07 /* search_for_symbols.cpp in Sources */, 12FD40F3186641C00041A84E /* char_match.cpp in Sources */, 12EDCFB21882039A005A7A07 /* perform.cpp in Sources */,