traxys/tree-sitter
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Make the EOF be an auxiliary symbol

Browse source 
This way, it couldn’t conflict if a user had a rule called “__END__”
This commit is contained in:
Max Brunsfeld 2014-02-10 18:53:01 -08:00
parent 15c9e2d398
commit 3cb65c9c81
6 changed files with 659 additions and 670 deletions
Download patch file Download diff file Expand all files Collapse all files

13
spec/compiler/build_tables/perform_spec.cpp
View file

@ -77,19 +77,6 @@ describe("building parse and lex tables", []() {
CharacterSet({ {'a', 'z'}, {'A', 'Z'} }, true),
})));
});
it("accepts when the start symbol is reduced", [&]() {
AssertThat(parse_state(1).actions, Equals(map<Symbol, parse_actions>({
{ Symbol("__END__"), parse_actions({ ParseAction::Accept() }) }
})));
});
it("has the right next states", [&]() {
AssertThat(parse_state(2).actions, Equals(map<Symbol, parse_actions>({
{ Symbol("plus"), parse_actions({ ParseAction::Shift(3) }) },
{ Symbol("__END__"), parse_actions({ ParseAction::Reduce(Symbol("expression"), { false }) }) },
})));
});
});
END_TEST

520
spec/fixtures/parsers/arithmetic.c vendored
View file

@ -2,7 +2,6 @@
#include <ctype.h>
enum ts_symbol {
ts_symbol___END__,
ts_symbol_expression,
ts_symbol_factor,
ts_symbol_number,
@ -10,12 +9,12 @@ enum ts_symbol {
ts_symbol_term,
ts_symbol_times,
ts_symbol_variable,
ts_aux_end,
ts_aux_token1,
ts_aux_token2,
};
static const char *ts_symbol_names[] = {
"__END__",
"expression",
"factor",
"number",
@ -23,6 +22,7 @@ static const char *ts_symbol_names[] = {
"term",
"times",
"variable",
"end",
"token1",
"token2",
};
@ -35,7 +35,7 @@ static void ts_lex(TSParser *parser) {
ADVANCE(1);
LEX_ERROR(1, EXPECT({"<EOF>"}));
case 1:
ACCEPT_TOKEN(ts_symbol___END__);
ACCEPT_TOKEN(ts_aux_end);
case 2:
if (LOOKAHEAD_CHAR() == '\0')
ADVANCE(1);
@ -119,117 +119,109 @@ static TSParseResult ts_parse(const char *input) {
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_expression:
SHIFT(1);
SHIFT(51);
case ts_symbol_factor:
SHIFT(45);
SHIFT(44);
case ts_symbol_number:
SHIFT(41);
SHIFT(40);
case ts_symbol_term:
SHIFT(2);
SHIFT(1);
case ts_symbol_variable:
SHIFT(41);
SHIFT(40);
case ts_aux_token1:
SHIFT(42);
SHIFT(41);
default:
PARSE_PANIC();
}
case 1:
SET_LEX_STATE(0);
SET_LEX_STATE(14);
switch (LOOKAHEAD_SYM()) {
case ts_symbol___END__:
ACCEPT_INPUT();
case ts_symbol_plus:
SHIFT(2);
case ts_aux_end:
REDUCE(ts_symbol_expression, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 2:
SET_LEX_STATE(14);
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol___END__:
REDUCE(ts_symbol_expression, 1, COLLAPSE({0}));
case ts_symbol_plus:
case ts_symbol_factor:
SHIFT(33);
case ts_symbol_number:
SHIFT(4);
case ts_symbol_term:
SHIFT(3);
case ts_symbol_variable:
SHIFT(4);
case ts_aux_token1:
SHIFT(5);
default:
PARSE_PANIC();
}
case 3:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
SHIFT(34);
case ts_symbol_number:
SHIFT(5);
case ts_symbol_term:
SHIFT(4);
case ts_symbol_variable:
SHIFT(5);
case ts_aux_token1:
SHIFT(6);
default:
PARSE_PANIC();
}
case 4:
SET_LEX_STATE(0);
switch (LOOKAHEAD_SYM()) {
case ts_symbol___END__:
case ts_aux_end:
REDUCE(ts_symbol_expression, 3, COLLAPSE({0, 0, 0}));
default:
PARSE_PANIC();
}
case 5:
case 4:
SET_LEX_STATE(2);
switch (LOOKAHEAD_SYM()) {
case ts_symbol___END__:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_symbol_times:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_aux_end:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 5:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_expression:
SHIFT(31);
case ts_symbol_factor:
SHIFT(15);
case ts_symbol_number:
SHIFT(11);
case ts_symbol_term:
SHIFT(6);
case ts_symbol_variable:
SHIFT(11);
case ts_aux_token1:
SHIFT(12);
default:
PARSE_PANIC();
}
case 6:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_expression:
SHIFT(32);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_term:
SHIFT(7);
case ts_symbol_variable:
SHIFT(12);
case ts_aux_token1:
SHIFT(13);
default:
PARSE_PANIC();
}
case 7:
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
SHIFT(8);
SHIFT(7);
case ts_aux_token2:
REDUCE(ts_symbol_expression, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 8:
case 7:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
SHIFT(25);
SHIFT(24);
case ts_symbol_number:
SHIFT(10);
case ts_symbol_term:
SHIFT(9);
case ts_symbol_term:
SHIFT(8);
case ts_symbol_variable:
SHIFT(10);
SHIFT(9);
case ts_aux_token1:
SHIFT(11);
SHIFT(10);
default:
PARSE_PANIC();
}
case 9:
case 8:
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
@ -237,7 +229,7 @@ static TSParseResult ts_parse(const char *input) {
default:
PARSE_PANIC();
}
case 10:
case 9:
SET_LEX_STATE(6);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_times:
@ -247,25 +239,25 @@ static TSParseResult ts_parse(const char *input) {
default:
PARSE_PANIC();
}
case 11:
case 10:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_expression:
SHIFT(23);
SHIFT(22);
case ts_symbol_factor:
SHIFT(16);
SHIFT(15);
case ts_symbol_number:
SHIFT(12);
SHIFT(11);
case ts_symbol_term:
SHIFT(7);
SHIFT(6);
case ts_symbol_variable:
SHIFT(12);
SHIFT(11);
case ts_aux_token1:
SHIFT(13);
SHIFT(12);
default:
PARSE_PANIC();
}
case 12:
case 11:
SET_LEX_STATE(7);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
@ -277,29 +269,41 @@ static TSParseResult ts_parse(const char *input) {
default:
PARSE_PANIC();
}
case 13:
case 12:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_expression:
SHIFT(14);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_term:
SHIFT(7);
case ts_symbol_variable:
SHIFT(12);
case ts_aux_token1:
SHIFT(13);
case ts_symbol_factor:
SHIFT(15);
case ts_symbol_number:
SHIFT(11);
case ts_symbol_term:
SHIFT(6);
case ts_symbol_variable:
SHIFT(11);
case ts_aux_token1:
SHIFT(12);
default:
PARSE_PANIC();
}
case 13:
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
SHIFT(14);
default:
PARSE_PANIC();
}
case 14:
SET_LEX_STATE(4);
SET_LEX_STATE(7);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_symbol_times:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_aux_token2:
SHIFT(15);
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_PANIC();
}
@ -307,41 +311,29 @@ static TSParseResult ts_parse(const char *input) {
SET_LEX_STATE(7);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
REDUCE(ts_symbol_term, 1, COLLAPSE({0}));
case ts_symbol_times:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
SHIFT(16);
case ts_aux_token2:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
REDUCE(ts_symbol_term, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 16:
SET_LEX_STATE(7);
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
REDUCE(ts_symbol_term, 1, COLLAPSE({0}));
case ts_symbol_times:
case ts_symbol_factor:
SHIFT(21);
case ts_symbol_number:
SHIFT(17);
case ts_aux_token2:
REDUCE(ts_symbol_term, 1, COLLAPSE({0}));
case ts_symbol_variable:
SHIFT(17);
case ts_aux_token1:
SHIFT(18);
default:
PARSE_PANIC();
}
case 17:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
SHIFT(22);
case ts_symbol_number:
SHIFT(18);
case ts_symbol_variable:
SHIFT(18);
case ts_aux_token1:
SHIFT(19);
default:
PARSE_PANIC();
}
case 18:
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
@ -351,29 +343,39 @@ static TSParseResult ts_parse(const char *input) {
default:
PARSE_PANIC();
}
case 19:
case 18:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_expression:
SHIFT(20);
SHIFT(19);
case ts_symbol_factor:
SHIFT(16);
SHIFT(15);
case ts_symbol_number:
SHIFT(12);
SHIFT(11);
case ts_symbol_term:
SHIFT(7);
SHIFT(6);
case ts_symbol_variable:
SHIFT(12);
SHIFT(11);
case ts_aux_token1:
SHIFT(13);
SHIFT(12);
default:
PARSE_PANIC();
}
case 19:
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
SHIFT(20);
default:
PARSE_PANIC();
}
case 20:
SET_LEX_STATE(4);
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_aux_token2:
SHIFT(21);
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_PANIC();
}
@ -381,27 +383,27 @@ static TSParseResult ts_parse(const char *input) {
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0}));
case ts_aux_token2:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0}));
default:
PARSE_PANIC();
}
case 22:
SET_LEX_STATE(9);
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0}));
case ts_aux_token2:
REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0}));
SHIFT(23);
default:
PARSE_PANIC();
}
case 23:
SET_LEX_STATE(4);
SET_LEX_STATE(6);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_times:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_aux_token2:
SHIFT(24);
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_PANIC();
}
@ -409,37 +411,27 @@ static TSParseResult ts_parse(const char *input) {
SET_LEX_STATE(6);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_times:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_aux_token2:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_PANIC();
}
case 25:
SET_LEX_STATE(6);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_times:
SHIFT(26);
SHIFT(25);
case ts_aux_token2:
REDUCE(ts_symbol_term, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 26:
case 25:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
SHIFT(31);
SHIFT(30);
case ts_symbol_number:
SHIFT(27);
SHIFT(26);
case ts_symbol_variable:
SHIFT(27);
SHIFT(26);
case ts_aux_token1:
SHIFT(28);
SHIFT(27);
default:
PARSE_PANIC();
}
case 27:
case 26:
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
@ -447,21 +439,29 @@ static TSParseResult ts_parse(const char *input) {
default:
PARSE_PANIC();
}
case 28:
case 27:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_expression:
SHIFT(29);
SHIFT(28);
case ts_symbol_factor:
SHIFT(16);
SHIFT(15);
case ts_symbol_number:
SHIFT(12);
SHIFT(11);
case ts_symbol_term:
SHIFT(7);
SHIFT(6);
case ts_symbol_variable:
SHIFT(12);
SHIFT(11);
case ts_aux_token1:
SHIFT(13);
SHIFT(12);
default:
PARSE_PANIC();
}
case 28:
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
SHIFT(29);
default:
PARSE_PANIC();
}
@ -469,7 +469,7 @@ static TSParseResult ts_parse(const char *input) {
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
SHIFT(30);
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_PANIC();
}
@ -477,7 +477,7 @@ static TSParseResult ts_parse(const char *input) {
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0}));
default:
PARSE_PANIC();
}
@ -485,231 +485,231 @@ static TSParseResult ts_parse(const char *input) {
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0}));
SHIFT(32);
default:
PARSE_PANIC();
}
case 32:
SET_LEX_STATE(4);
SET_LEX_STATE(2);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
SHIFT(33);
case ts_symbol_times:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_aux_end:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_PANIC();
}
case 33:
SET_LEX_STATE(2);
switch (LOOKAHEAD_SYM()) {
case ts_symbol___END__:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_symbol_times:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
SHIFT(34);
case ts_aux_end:
REDUCE(ts_symbol_term, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 34:
SET_LEX_STATE(2);
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol___END__:
REDUCE(ts_symbol_term, 1, COLLAPSE({0}));
case ts_symbol_times:
case ts_symbol_factor:
SHIFT(39);
case ts_symbol_number:
SHIFT(35);
case ts_symbol_variable:
SHIFT(35);
case ts_aux_token1:
SHIFT(36);
default:
PARSE_PANIC();
}
case 35:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
SHIFT(40);
case ts_symbol_number:
SHIFT(36);
case ts_symbol_variable:
SHIFT(36);
case ts_aux_token1:
SHIFT(37);
default:
PARSE_PANIC();
}
case 36:
SET_LEX_STATE(0);
switch (LOOKAHEAD_SYM()) {
case ts_symbol___END__:
case ts_aux_end:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 37:
case 36:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_expression:
SHIFT(38);
SHIFT(37);
case ts_symbol_factor:
SHIFT(16);
SHIFT(15);
case ts_symbol_number:
SHIFT(12);
SHIFT(11);
case ts_symbol_term:
SHIFT(7);
SHIFT(6);
case ts_symbol_variable:
SHIFT(12);
SHIFT(11);
case ts_aux_token1:
SHIFT(13);
SHIFT(12);
default:
PARSE_PANIC();
}
case 37:
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
SHIFT(38);
default:
PARSE_PANIC();
}
case 38:
SET_LEX_STATE(4);
SET_LEX_STATE(0);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
SHIFT(39);
case ts_aux_end:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_PANIC();
}
case 39:
SET_LEX_STATE(0);
switch (LOOKAHEAD_SYM()) {
case ts_symbol___END__:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_PANIC();
}
case 40:
SET_LEX_STATE(0);
switch (LOOKAHEAD_SYM()) {
case ts_symbol___END__:
case ts_aux_end:
REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0}));
default:
PARSE_PANIC();
}
case 41:
case 40:
SET_LEX_STATE(15);
switch (LOOKAHEAD_SYM()) {
case ts_symbol___END__:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_symbol_plus:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_symbol_times:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_aux_end:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 41:
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_expression:
SHIFT(42);
case ts_symbol_factor:
SHIFT(15);
case ts_symbol_number:
SHIFT(11);
case ts_symbol_term:
SHIFT(6);
case ts_symbol_variable:
SHIFT(11);
case ts_aux_token1:
SHIFT(12);
default:
PARSE_PANIC();
}
case 42:
SET_LEX_STATE(10);
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_expression:
case ts_aux_token2:
SHIFT(43);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_term:
SHIFT(7);
case ts_symbol_variable:
SHIFT(12);
case ts_aux_token1:
SHIFT(13);
default:
PARSE_PANIC();
}
case 43:
SET_LEX_STATE(4);
SET_LEX_STATE(15);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
SHIFT(44);
case ts_symbol_plus:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_symbol_times:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_aux_end:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_PANIC();
}
case 44:
SET_LEX_STATE(15);
switch (LOOKAHEAD_SYM()) {
case ts_symbol___END__:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_symbol_plus:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
REDUCE(ts_symbol_term, 1, COLLAPSE({0}));
case ts_symbol_times:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
SHIFT(45);
case ts_aux_end:
REDUCE(ts_symbol_term, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 45:
SET_LEX_STATE(15);
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol___END__:
REDUCE(ts_symbol_term, 1, COLLAPSE({0}));
case ts_symbol_plus:
REDUCE(ts_symbol_term, 1, COLLAPSE({0}));
case ts_symbol_times:
case ts_symbol_factor:
SHIFT(50);
case ts_symbol_number:
SHIFT(46);
case ts_symbol_variable:
SHIFT(46);
case ts_aux_token1:
SHIFT(47);
default:
PARSE_PANIC();
}
case 46:
SET_LEX_STATE(10);
SET_LEX_STATE(14);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
SHIFT(51);
case ts_symbol_number:
SHIFT(47);
case ts_symbol_variable:
SHIFT(47);
case ts_aux_token1:
SHIFT(48);
case ts_symbol_plus:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_aux_end:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 47:
SET_LEX_STATE(14);
SET_LEX_STATE(10);
switch (LOOKAHEAD_SYM()) {
case ts_symbol___END__:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_symbol_plus:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_symbol_expression:
SHIFT(48);
case ts_symbol_factor:
SHIFT(15);
case ts_symbol_number:
SHIFT(11);
case ts_symbol_term:
SHIFT(6);
case ts_symbol_variable:
SHIFT(11);
case ts_aux_token1:
SHIFT(12);
default:
PARSE_PANIC();
}
case 48:
SET_LEX_STATE(10);
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_expression:
case ts_aux_token2:
SHIFT(49);
case ts_symbol_factor:
SHIFT(16);
case ts_symbol_number:
SHIFT(12);
case ts_symbol_term:
SHIFT(7);
case ts_symbol_variable:
SHIFT(12);
case ts_aux_token1:
SHIFT(13);
default:
PARSE_PANIC();
}
case 49:
SET_LEX_STATE(4);
SET_LEX_STATE(14);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
SHIFT(50);
case ts_symbol_plus:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_aux_end:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_PANIC();
}
case 50:
SET_LEX_STATE(14);
switch (LOOKAHEAD_SYM()) {
case ts_symbol___END__:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_symbol_plus:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0}));
case ts_aux_end:
REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0}));
default:
PARSE_PANIC();
}
case 51:
SET_LEX_STATE(14);
SET_LEX_STATE(0);
switch (LOOKAHEAD_SYM()) {
case ts_symbol___END__:
REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0}));
case ts_symbol_plus:
REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0}));
case ts_aux_end:
ACCEPT_INPUT();
default:
PARSE_PANIC();
}

760
spec/fixtures/parsers/json.c vendored
View file

File diff suppressed because it is too large Load diff

25
spec/stream_methods.h
View file

@ -10,17 +10,6 @@
using std::cout;
namespace std {
template<typename T>
inline std::ostream& operator<<(std::ostream &stream, const std::unordered_set<T> &set) {
stream << std::string("#<set: ");
bool started = false;
for (auto item : set) {
if (started) stream << std::string(", ");
stream << item;
started = true;
}
return stream << ">";
}
template<typename T>
inline std::ostream& operator<<(std::ostream &stream, const std::vector<T> &vector) {
@ -59,6 +48,20 @@ namespace std {
}
return stream << ">";
}
template<typename TKey, typename TValue>
inline std::ostream& operator<<(std::ostream &stream, const std::map<TKey, TValue> &map) {
stream << std::string("#<map: ");
bool started = false;
for (auto pair : map) {
if (started) stream << std::string(", ");
stream << pair.first;
stream << std::string(" => ");
stream << pair.second;
started = true;
}
return stream << ">";
}
}
#endif

8
src/compiler/build_tables/perform.cpp
View file

@ -14,8 +14,8 @@ using std::unordered_map;
namespace tree_sitter {
namespace build_tables {
static int NOT_FOUND = -1;
static string START = "__START__";
static string END_OF_INPUT = "__END__";
static rules::Symbol START("start", true);
static rules::Symbol END_OF_INPUT("end", true);
class TableBuilder {
const Grammar grammar;
@ -64,7 +64,7 @@ namespace tree_sitter {
void add_reduce_actions(const ParseItemSet &item_set, size_t state_index) {
for (ParseItem item : item_set) {
if (item.is_done()) {
ParseAction action = (item.lhs.name == START) ?
ParseAction action = (item.lhs == START) ?
ParseAction::Accept() :
ParseAction::Reduce(item.lhs, item.consumed_symbols);
parse_table.add_action(state_index, item.lookahead_sym, action);
@ -76,7 +76,7 @@ namespace tree_sitter {
ParseState &state = parse_table.states[state_index];
LexItemSet item_set;
for (auto &symbol : state.expected_inputs()) {
if (symbol.name == END_OF_INPUT)
if (symbol == END_OF_INPUT)
item_set.insert(LexItem(symbol, rules::character('\0')));
if (lex_grammar.has_definition(symbol))
item_set.insert(LexItem(symbol, lex_grammar.rule(symbol)));

3
src/compiler/grammar.cpp
View file

@ -1,6 +1,5 @@
#include "grammar.h"
using std::unordered_map;
using std::vector;
using std::string;
using std::pair;
@ -12,7 +11,7 @@ namespace tree_sitter {
rules(rules),
start_rule_name(rules.begin()->first) {}
Grammar::Grammar(std::string start_rule_name, const unordered_map<string, const rules::rule_ptr> &rules) :
Grammar::Grammar(std::string start_rule_name, rule_map &rules) :
rules(rules),
start_rule_name(start_rule_name) {}