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

Update runtime code naming

Browse source 
Also, add macros so that code generator doesn't
need to know about any runtime variables names
or types
This commit is contained in:
Max Brunsfeld 2014-02-20 13:30:43 -08:00
parent 1b56832cb7
commit 6ed6aa05cc
11 changed files with 579 additions and 575 deletions
Download patch file Download diff file Expand all files Collapse all files

429
examples/parsers/arithmetic.c
View file

@ -1,19 +1,19 @@
#include "tree_sitter/parser.h"
enum ts_symbol {
ts_symbol_expression,
ts_symbol_factor,
ts_symbol_number,
ts_symbol_plus,
ts_symbol_term,
ts_symbol_times,
ts_symbol_variable,
ts_aux_end,
ts_aux_token1,
ts_aux_token2,
enum {
ts_sym_expression,
ts_sym_factor,
ts_sym_number,
ts_sym_plus,
ts_sym_term,
ts_sym_times,
ts_sym_variable,
ts_aux_sym_end,
ts_aux_sym_token1,
ts_aux_sym_token2,
};
static const char *ts_symbol_names[] = {
SYMBOL_NAMES {
"expression",
"factor",
"number",
@ -26,7 +26,7 @@ static const char *ts_symbol_names[] = {
"token2",
};
static void ts_lex(TSParser *parser) {
LEX_FN() {
START_LEXER();
switch (LEX_STATE()) {
case 0:
@ -34,7 +34,7 @@ static void ts_lex(TSParser *parser) {
ADVANCE(1);
LEX_ERROR(1, EXPECT({"<EOF>"}));
case 1:
ACCEPT_TOKEN(ts_aux_end);
ACCEPT_TOKEN(ts_aux_sym_end);
case 2:
if (LOOKAHEAD_CHAR() == '\0')
ADVANCE(1);
@ -42,13 +42,13 @@ static void ts_lex(TSParser *parser) {
ADVANCE(3);
LEX_ERROR(2, EXPECT({"<EOF>", "+"}));
case 3:
ACCEPT_TOKEN(ts_symbol_plus);
ACCEPT_TOKEN(ts_sym_plus);
case 4:
if (LOOKAHEAD_CHAR() == ')')
ADVANCE(5);
LEX_ERROR(1, EXPECT({")"}));
case 5:
ACCEPT_TOKEN(ts_aux_token2);
ACCEPT_TOKEN(ts_aux_sym_token2);
case 6:
if (LOOKAHEAD_CHAR() == ')')
ADVANCE(5);
@ -64,7 +64,7 @@ static void ts_lex(TSParser *parser) {
ADVANCE(3);
LEX_ERROR(1, EXPECT({")-+"}));
case 8:
ACCEPT_TOKEN(ts_symbol_times);
ACCEPT_TOKEN(ts_sym_times);
case 9:
if (LOOKAHEAD_CHAR() == '(')
ADVANCE(10);
@ -75,16 +75,16 @@ static void ts_lex(TSParser *parser) {
ADVANCE(12);
LEX_ERROR(4, EXPECT({"(", "0-9", "A-Z", "a-z"}));
case 10:
ACCEPT_TOKEN(ts_aux_token1);
ACCEPT_TOKEN(ts_aux_sym_token1);
case 11:
if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9')
ADVANCE(11);
ACCEPT_TOKEN(ts_symbol_number);
ACCEPT_TOKEN(ts_sym_number);
case 12:
if (('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') ||
('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z'))
ADVANCE(12);
ACCEPT_TOKEN(ts_symbol_variable);
ACCEPT_TOKEN(ts_sym_variable);
case 13:
if (LOOKAHEAD_CHAR() == ')')
ADVANCE(5);
@ -111,23 +111,23 @@ static void ts_lex(TSParser *parser) {
FINISH_LEXER();
}
static TSParseResult ts_parse(const char *input) {
PARSE_FN() {
START_PARSER();
switch (PARSE_STATE()) {
case 0:
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_expression:
case ts_sym_expression:
SHIFT(1);
case ts_symbol_factor:
case ts_sym_factor:
SHIFT(2);
case ts_symbol_number:
case ts_sym_number:
SHIFT(34);
case ts_symbol_term:
case ts_sym_term:
SHIFT(35);
case ts_symbol_variable:
case ts_sym_variable:
SHIFT(34);
case ts_aux_token1:
case ts_aux_sym_token1:
SHIFT(49);
default:
PARSE_PANIC();
@ -135,7 +135,7 @@ static TSParseResult ts_parse(const char *input) {
case 1:
SET_LEX_STATE(0);
switch (LOOKAHEAD_SYM()) {
case ts_aux_end:
case ts_aux_sym_end:
ACCEPT_INPUT();
default:
PARSE_PANIC();
@ -143,25 +143,25 @@ static TSParseResult ts_parse(const char *input) {
case 2:
SET_LEX_STATE(14);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
REDUCE(ts_symbol_term, 1, COLLAPSE({0}));
case ts_symbol_times:
case ts_sym_plus:
REDUCE(ts_sym_term, 1, COLLAPSE({0}));
case ts_sym_times:
SHIFT(3);
case ts_aux_end:
REDUCE(ts_symbol_term, 1, COLLAPSE({0}));
case ts_aux_sym_end:
REDUCE(ts_sym_term, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 3:
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
case ts_sym_factor:
SHIFT(4);
case ts_symbol_number:
case ts_sym_number:
SHIFT(5);
case ts_symbol_variable:
case ts_sym_variable:
SHIFT(5);
case ts_aux_token1:
case ts_aux_sym_token1:
SHIFT(6);
default:
PARSE_PANIC();
@ -169,37 +169,37 @@ static TSParseResult ts_parse(const char *input) {
case 4:
SET_LEX_STATE(2);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0}));
case ts_aux_end:
REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0}));
case ts_sym_plus:
REDUCE(ts_sym_term, 3, COLLAPSE({0, 0, 0}));
case ts_aux_sym_end:
REDUCE(ts_sym_term, 3, COLLAPSE({0, 0, 0}));
default:
PARSE_PANIC();
}
case 5:
SET_LEX_STATE(2);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_aux_end:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_sym_plus:
REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
case ts_aux_sym_end:
REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 6:
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_expression:
case ts_sym_expression:
SHIFT(7);
case ts_symbol_factor:
case ts_sym_factor:
SHIFT(9);
case ts_symbol_number:
case ts_sym_number:
SHIFT(16);
case ts_symbol_term:
case ts_sym_term:
SHIFT(17);
case ts_symbol_variable:
case ts_sym_variable:
SHIFT(16);
case ts_aux_token1:
case ts_aux_sym_token1:
SHIFT(26);
default:
PARSE_PANIC();
@ -207,7 +207,7 @@ static TSParseResult ts_parse(const char *input) {
case 7:
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
case ts_aux_sym_token2:
SHIFT(8);
default:
PARSE_PANIC();
@ -215,35 +215,35 @@ static TSParseResult ts_parse(const char *input) {
case 8:
SET_LEX_STATE(2);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_aux_end:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_sym_plus:
REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
case ts_aux_sym_end:
REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_PANIC();
}
case 9:
SET_LEX_STATE(7);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
REDUCE(ts_symbol_term, 1, COLLAPSE({0}));
case ts_symbol_times:
case ts_sym_plus:
REDUCE(ts_sym_term, 1, COLLAPSE({0}));
case ts_sym_times:
SHIFT(10);
case ts_aux_token2:
REDUCE(ts_symbol_term, 1, COLLAPSE({0}));
case ts_aux_sym_token2:
REDUCE(ts_sym_term, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 10:
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
case ts_sym_factor:
SHIFT(11);
case ts_symbol_number:
case ts_sym_number:
SHIFT(12);
case ts_symbol_variable:
case ts_sym_variable:
SHIFT(12);
case ts_aux_token1:
case ts_aux_sym_token1:
SHIFT(13);
default:
PARSE_PANIC();
@ -251,37 +251,37 @@ static TSParseResult ts_parse(const char *input) {
case 11:
SET_LEX_STATE(6);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0}));
case ts_aux_token2:
REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0}));
case ts_sym_plus:
REDUCE(ts_sym_term, 3, COLLAPSE({0, 0, 0}));
case ts_aux_sym_token2:
REDUCE(ts_sym_term, 3, COLLAPSE({0, 0, 0}));
default:
PARSE_PANIC();
}
case 12:
SET_LEX_STATE(6);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_aux_token2:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_sym_plus:
REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
case ts_aux_sym_token2:
REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 13:
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_expression:
case ts_sym_expression:
SHIFT(14);
case ts_symbol_factor:
case ts_sym_factor:
SHIFT(9);
case ts_symbol_number:
case ts_sym_number:
SHIFT(16);
case ts_symbol_term:
case ts_sym_term:
SHIFT(17);
case ts_symbol_variable:
case ts_sym_variable:
SHIFT(16);
case ts_aux_token1:
case ts_aux_sym_token1:
SHIFT(26);
default:
PARSE_PANIC();
@ -289,7 +289,7 @@ static TSParseResult ts_parse(const char *input) {
case 14:
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
case ts_aux_sym_token2:
SHIFT(15);
default:
PARSE_PANIC();
@ -297,47 +297,47 @@ static TSParseResult ts_parse(const char *input) {
case 15:
SET_LEX_STATE(6);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_aux_token2:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_sym_plus:
REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
case ts_aux_sym_token2:
REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_PANIC();
}
case 16:
SET_LEX_STATE(7);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_symbol_times:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_aux_token2:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_sym_plus:
REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
case ts_sym_times:
REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
case ts_aux_sym_token2:
REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 17:
SET_LEX_STATE(6);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
case ts_sym_plus:
SHIFT(18);
case ts_aux_token2:
REDUCE(ts_symbol_expression, 1, COLLAPSE({0}));
case ts_aux_sym_token2:
REDUCE(ts_sym_expression, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 18:
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
case ts_sym_factor:
SHIFT(19);
case ts_symbol_number:
case ts_sym_number:
SHIFT(29);
case ts_symbol_term:
case ts_sym_term:
SHIFT(30);
case ts_symbol_variable:
case ts_sym_variable:
SHIFT(29);
case ts_aux_token1:
case ts_aux_sym_token1:
SHIFT(31);
default:
PARSE_PANIC();
@ -345,23 +345,23 @@ static TSParseResult ts_parse(const char *input) {
case 19:
SET_LEX_STATE(13);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_times:
case ts_sym_times:
SHIFT(20);
case ts_aux_token2:
REDUCE(ts_symbol_term, 1, COLLAPSE({0}));
case ts_aux_sym_token2:
REDUCE(ts_sym_term, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 20:
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
case ts_sym_factor:
SHIFT(21);
case ts_symbol_number:
case ts_sym_number:
SHIFT(22);
case ts_symbol_variable:
case ts_sym_variable:
SHIFT(22);
case ts_aux_token1:
case ts_aux_sym_token1:
SHIFT(23);
default:
PARSE_PANIC();
@ -369,33 +369,33 @@ static TSParseResult ts_parse(const char *input) {
case 21:
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0}));
case ts_aux_sym_token2:
REDUCE(ts_sym_term, 3, COLLAPSE({0, 0, 0}));
default:
PARSE_PANIC();
}
case 22:
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_aux_sym_token2:
REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 23:
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_expression:
case ts_sym_expression:
SHIFT(24);
case ts_symbol_factor:
case ts_sym_factor:
SHIFT(9);
case ts_symbol_number:
case ts_sym_number:
SHIFT(16);
case ts_symbol_term:
case ts_sym_term:
SHIFT(17);
case ts_symbol_variable:
case ts_sym_variable:
SHIFT(16);
case ts_aux_token1:
case ts_aux_sym_token1:
SHIFT(26);
default:
PARSE_PANIC();
@ -403,7 +403,7 @@ static TSParseResult ts_parse(const char *input) {
case 24:
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
case ts_aux_sym_token2:
SHIFT(25);
default:
PARSE_PANIC();
@ -411,25 +411,25 @@ static TSParseResult ts_parse(const char *input) {
case 25:
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_aux_sym_token2:
REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_PANIC();
}
case 26:
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_expression:
case ts_sym_expression:
SHIFT(27);
case ts_symbol_factor:
case ts_sym_factor:
SHIFT(9);
case ts_symbol_number:
case ts_sym_number:
SHIFT(16);
case ts_symbol_term:
case ts_sym_term:
SHIFT(17);
case ts_symbol_variable:
case ts_sym_variable:
SHIFT(16);
case ts_aux_token1:
case ts_aux_sym_token1:
SHIFT(26);
default:
PARSE_PANIC();
@ -437,7 +437,7 @@ static TSParseResult ts_parse(const char *input) {
case 27:
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
case ts_aux_sym_token2:
SHIFT(28);
default:
PARSE_PANIC();
@ -445,47 +445,47 @@ static TSParseResult ts_parse(const char *input) {
case 28:
SET_LEX_STATE(7);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_symbol_times:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_aux_token2:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_sym_plus:
REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
case ts_sym_times:
REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
case ts_aux_sym_token2:
REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_PANIC();
}
case 29:
SET_LEX_STATE(13);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_times:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_aux_token2:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_sym_times:
REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
case ts_aux_sym_token2:
REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 30:
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
REDUCE(ts_symbol_expression, 3, COLLAPSE({0, 0, 0}));
case ts_aux_sym_token2:
REDUCE(ts_sym_expression, 3, COLLAPSE({0, 0, 0}));
default:
PARSE_PANIC();
}
case 31:
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_expression:
case ts_sym_expression:
SHIFT(32);
case ts_symbol_factor:
case ts_sym_factor:
SHIFT(9);
case ts_symbol_number:
case ts_sym_number:
SHIFT(16);
case ts_symbol_term:
case ts_sym_term:
SHIFT(17);
case ts_symbol_variable:
case ts_sym_variable:
SHIFT(16);
case ts_aux_token1:
case ts_aux_sym_token1:
SHIFT(26);
default:
PARSE_PANIC();
@ -493,7 +493,7 @@ static TSParseResult ts_parse(const char *input) {
case 32:
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
case ts_aux_sym_token2:
SHIFT(33);
default:
PARSE_PANIC();
@ -501,47 +501,47 @@ static TSParseResult ts_parse(const char *input) {
case 33:
SET_LEX_STATE(13);
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}));
case ts_sym_times:
REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
case ts_aux_sym_token2:
REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_PANIC();
}
case 34:
SET_LEX_STATE(14);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_symbol_times:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_aux_end:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_sym_plus:
REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
case ts_sym_times:
REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
case ts_aux_sym_end:
REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 35:
SET_LEX_STATE(2);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
case ts_sym_plus:
SHIFT(36);
case ts_aux_end:
REDUCE(ts_symbol_expression, 1, COLLAPSE({0}));
case ts_aux_sym_end:
REDUCE(ts_sym_expression, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 36:
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
case ts_sym_factor:
SHIFT(37);
case ts_symbol_number:
case ts_sym_number:
SHIFT(44);
case ts_symbol_term:
case ts_sym_term:
SHIFT(45);
case ts_symbol_variable:
case ts_sym_variable:
SHIFT(44);
case ts_aux_token1:
case ts_aux_sym_token1:
SHIFT(46);
default:
PARSE_PANIC();
@ -549,23 +549,23 @@ static TSParseResult ts_parse(const char *input) {
case 37:
SET_LEX_STATE(15);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_times:
case ts_sym_times:
SHIFT(38);
case ts_aux_end:
REDUCE(ts_symbol_term, 1, COLLAPSE({0}));
case ts_aux_sym_end:
REDUCE(ts_sym_term, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 38:
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_factor:
case ts_sym_factor:
SHIFT(39);
case ts_symbol_number:
case ts_sym_number:
SHIFT(40);
case ts_symbol_variable:
case ts_sym_variable:
SHIFT(40);
case ts_aux_token1:
case ts_aux_sym_token1:
SHIFT(41);
default:
PARSE_PANIC();
@ -573,33 +573,33 @@ static TSParseResult ts_parse(const char *input) {
case 39:
SET_LEX_STATE(0);
switch (LOOKAHEAD_SYM()) {
case ts_aux_end:
REDUCE(ts_symbol_term, 3, COLLAPSE({0, 0, 0}));
case ts_aux_sym_end:
REDUCE(ts_sym_term, 3, COLLAPSE({0, 0, 0}));
default:
PARSE_PANIC();
}
case 40:
SET_LEX_STATE(0);
switch (LOOKAHEAD_SYM()) {
case ts_aux_end:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_aux_sym_end:
REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 41:
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_expression:
case ts_sym_expression:
SHIFT(42);
case ts_symbol_factor:
case ts_sym_factor:
SHIFT(9);
case ts_symbol_number:
case ts_sym_number:
SHIFT(16);
case ts_symbol_term:
case ts_sym_term:
SHIFT(17);
case ts_symbol_variable:
case ts_sym_variable:
SHIFT(16);
case ts_aux_token1:
case ts_aux_sym_token1:
SHIFT(26);
default:
PARSE_PANIC();
@ -607,7 +607,7 @@ static TSParseResult ts_parse(const char *input) {
case 42:
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
case ts_aux_sym_token2:
SHIFT(43);
default:
PARSE_PANIC();
@ -615,43 +615,43 @@ static TSParseResult ts_parse(const char *input) {
case 43:
SET_LEX_STATE(0);
switch (LOOKAHEAD_SYM()) {
case ts_aux_end:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_aux_sym_end:
REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_PANIC();
}
case 44:
SET_LEX_STATE(15);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_times:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_aux_end:
REDUCE(ts_symbol_factor, 1, COLLAPSE({0}));
case ts_sym_times:
REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
case ts_aux_sym_end:
REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 45:
SET_LEX_STATE(0);
switch (LOOKAHEAD_SYM()) {
case ts_aux_end:
REDUCE(ts_symbol_expression, 3, COLLAPSE({0, 0, 0}));
case ts_aux_sym_end:
REDUCE(ts_sym_expression, 3, COLLAPSE({0, 0, 0}));
default:
PARSE_PANIC();
}
case 46:
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_expression:
case ts_sym_expression:
SHIFT(47);
case ts_symbol_factor:
case ts_sym_factor:
SHIFT(9);
case ts_symbol_number:
case ts_sym_number:
SHIFT(16);
case ts_symbol_term:
case ts_sym_term:
SHIFT(17);
case ts_symbol_variable:
case ts_sym_variable:
SHIFT(16);
case ts_aux_token1:
case ts_aux_sym_token1:
SHIFT(26);
default:
PARSE_PANIC();
@ -659,7 +659,7 @@ static TSParseResult ts_parse(const char *input) {
case 47:
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
case ts_aux_sym_token2:
SHIFT(48);
default:
PARSE_PANIC();
@ -667,27 +667,27 @@ static TSParseResult ts_parse(const char *input) {
case 48:
SET_LEX_STATE(15);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_times:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_aux_end:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_sym_times:
REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
case ts_aux_sym_end:
REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_PANIC();
}
case 49:
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_expression:
case ts_sym_expression:
SHIFT(50);
case ts_symbol_factor:
case ts_sym_factor:
SHIFT(9);
case ts_symbol_number:
case ts_sym_number:
SHIFT(16);
case ts_symbol_term:
case ts_sym_term:
SHIFT(17);
case ts_symbol_variable:
case ts_sym_variable:
SHIFT(16);
case ts_aux_token1:
case ts_aux_sym_token1:
SHIFT(26);
default:
PARSE_PANIC();
@ -695,7 +695,7 @@ static TSParseResult ts_parse(const char *input) {
case 50:
SET_LEX_STATE(4);
switch (LOOKAHEAD_SYM()) {
case ts_aux_token2:
case ts_aux_sym_token2:
SHIFT(51);
default:
PARSE_PANIC();
@ -703,12 +703,12 @@ static TSParseResult ts_parse(const char *input) {
case 51:
SET_LEX_STATE(14);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_plus:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_symbol_times:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_aux_end:
REDUCE(ts_symbol_factor, 3, COLLAPSE({1, 0, 1}));
case ts_sym_plus:
REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
case ts_sym_times:
REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
case ts_aux_sym_end:
REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_PANIC();
}
@ -718,7 +718,4 @@ static TSParseResult ts_parse(const char *input) {
FINISH_PARSER();
}
TSParseConfig ts_parse_config_arithmetic = {
.parse_fn = ts_parse,
.symbol_names = ts_symbol_names
};
EXPORT_PARSER(ts_parse_config_arithmetic);

401
examples/parsers/json.c
View file

@ -1,23 +1,23 @@
#include "tree_sitter/parser.h"
enum ts_symbol {
ts_symbol_array,
ts_symbol_number,
ts_symbol_object,
ts_symbol_string,
ts_symbol_value,
ts_symbol_colon,
ts_symbol_comma,
ts_symbol_left_brace,
ts_symbol_left_bracket,
ts_symbol_right_brace,
ts_symbol_right_bracket,
ts_aux_end,
ts_aux_repeat_helper1,
ts_aux_repeat_helper2,
enum {
ts_sym_array,
ts_sym_number,
ts_sym_object,
ts_sym_string,
ts_sym_value,
ts_sym_colon,
ts_sym_comma,
ts_sym_left_brace,
ts_sym_left_bracket,
ts_sym_right_brace,
ts_sym_right_bracket,
ts_aux_sym_end,
ts_aux_sym_repeat_helper1,
ts_aux_sym_repeat_helper2,
};
static const char *ts_symbol_names[] = {
SYMBOL_NAMES {
"array",
"number",
"object",
@ -34,7 +34,7 @@ static const char *ts_symbol_names[] = {
"repeat_helper2",
};
static void ts_lex(TSParser *parser) {
LEX_FN() {
START_LEXER();
switch (LEX_STATE()) {
case 0:
@ -42,7 +42,7 @@ static void ts_lex(TSParser *parser) {
ADVANCE(1);
LEX_ERROR(1, EXPECT({"<EOF>"}));
case 1:
ACCEPT_TOKEN(ts_aux_end);
ACCEPT_TOKEN(ts_aux_sym_end);
case 2:
if (LOOKAHEAD_CHAR() == ',')
ADVANCE(3);
@ -50,9 +50,9 @@ static void ts_lex(TSParser *parser) {
ADVANCE(4);
LEX_ERROR(2, EXPECT({",", "}"}));
case 3:
ACCEPT_TOKEN(ts_symbol_comma);
ACCEPT_TOKEN(ts_sym_comma);
case 4:
ACCEPT_TOKEN(ts_symbol_right_brace);
ACCEPT_TOKEN(ts_sym_right_brace);
case 5:
if (LOOKAHEAD_CHAR() == '}')
ADVANCE(4);
@ -64,7 +64,7 @@ static void ts_lex(TSParser *parser) {
ADVANCE(7);
LEX_ERROR(2, EXPECT({",", "]"}));
case 7:
ACCEPT_TOKEN(ts_symbol_right_bracket);
ACCEPT_TOKEN(ts_sym_right_bracket);
case 8:
if (LOOKAHEAD_CHAR() == ']')
ADVANCE(7);
@ -102,7 +102,7 @@ static void ts_lex(TSParser *parser) {
ADVANCE(15);
LEX_ERROR(1, EXPECT({"<ANY>"}));
case 12:
ACCEPT_TOKEN(ts_symbol_string);
ACCEPT_TOKEN(ts_sym_string);
case 13:
if (!((LOOKAHEAD_CHAR() == '\"') ||
(LOOKAHEAD_CHAR() == '\\')))
@ -126,7 +126,7 @@ static void ts_lex(TSParser *parser) {
ADVANCE(13);
if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\')
ADVANCE(15);
ACCEPT_TOKEN(ts_symbol_string);
ACCEPT_TOKEN(ts_sym_string);
case 15:
if (LOOKAHEAD_CHAR() == '\"')
ADVANCE(11);
@ -134,17 +134,17 @@ static void ts_lex(TSParser *parser) {
case 16:
if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9')
ADVANCE(16);
ACCEPT_TOKEN(ts_symbol_number);
ACCEPT_TOKEN(ts_sym_number);
case 17:
ACCEPT_TOKEN(ts_symbol_left_bracket);
ACCEPT_TOKEN(ts_sym_left_bracket);
case 18:
ACCEPT_TOKEN(ts_symbol_left_brace);
ACCEPT_TOKEN(ts_sym_left_brace);
case 19:
if (LOOKAHEAD_CHAR() == ':')
ADVANCE(20);
LEX_ERROR(1, EXPECT({":"}));
case 20:
ACCEPT_TOKEN(ts_symbol_colon);
ACCEPT_TOKEN(ts_sym_colon);
case 21:
if (LOOKAHEAD_CHAR() == '\"')
ADVANCE(10);
@ -173,25 +173,25 @@ static void ts_lex(TSParser *parser) {
FINISH_LEXER();
}
static TSParseResult ts_parse(const char *input) {
PARSE_FN() {
START_PARSER();
switch (PARSE_STATE()) {
case 0:
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_array:
case ts_sym_array:
SHIFT(1);
case ts_symbol_number:
case ts_sym_number:
SHIFT(1);
case ts_symbol_object:
case ts_sym_object:
SHIFT(1);
case ts_symbol_string:
case ts_sym_string:
SHIFT(1);
case ts_symbol_value:
case ts_sym_value:
SHIFT(2);
case ts_symbol_left_brace:
case ts_sym_left_brace:
SHIFT(3);
case ts_symbol_left_bracket:
case ts_sym_left_bracket:
SHIFT(44);
default:
PARSE_PANIC();
@ -199,15 +199,15 @@ static TSParseResult ts_parse(const char *input) {
case 1:
SET_LEX_STATE(0);
switch (LOOKAHEAD_SYM()) {
case ts_aux_end:
REDUCE(ts_symbol_value, 1, COLLAPSE({0}));
case ts_aux_sym_end:
REDUCE(ts_sym_value, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 2:
SET_LEX_STATE(0);
switch (LOOKAHEAD_SYM()) {
case ts_aux_end:
case ts_aux_sym_end:
ACCEPT_INPUT();
default:
PARSE_PANIC();
@ -215,9 +215,9 @@ static TSParseResult ts_parse(const char *input) {
case 3:
SET_LEX_STATE(21);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_string:
case ts_sym_string:
SHIFT(4);
case ts_symbol_right_brace:
case ts_sym_right_brace:
SHIFT(43);
default:
PARSE_PANIC();
@ -225,7 +225,7 @@ static TSParseResult ts_parse(const char *input) {
case 4:
SET_LEX_STATE(19);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_colon:
case ts_sym_colon:
SHIFT(5);
default:
PARSE_PANIC();
@ -233,19 +233,19 @@ static TSParseResult ts_parse(const char *input) {
case 5:
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_array:
case ts_sym_array:
SHIFT(6);
case ts_symbol_number:
case ts_sym_number:
SHIFT(6);
case ts_symbol_object:
case ts_sym_object:
SHIFT(6);
case ts_symbol_string:
case ts_sym_string:
SHIFT(6);
case ts_symbol_value:
case ts_sym_value:
SHIFT(7);
case ts_symbol_left_brace:
case ts_sym_left_brace:
SHIFT(13);
case ts_symbol_left_bracket:
case ts_sym_left_bracket:
SHIFT(19);
default:
PARSE_PANIC();
@ -253,21 +253,21 @@ static TSParseResult ts_parse(const char *input) {
case 6:
SET_LEX_STATE(2);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_comma:
REDUCE(ts_symbol_value, 1, COLLAPSE({0}));
case ts_symbol_right_brace:
REDUCE(ts_symbol_value, 1, COLLAPSE({0}));
case ts_sym_comma:
REDUCE(ts_sym_value, 1, COLLAPSE({0}));
case ts_sym_right_brace:
REDUCE(ts_sym_value, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 7:
SET_LEX_STATE(2);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_comma:
case ts_sym_comma:
SHIFT(8);
case ts_symbol_right_brace:
REDUCE(ts_aux_repeat_helper2, 0, COLLAPSE({}));
case ts_aux_repeat_helper2:
case ts_sym_right_brace:
REDUCE(ts_aux_sym_repeat_helper2, 0, COLLAPSE({}));
case ts_aux_sym_repeat_helper2:
SHIFT(41);
default:
PARSE_PANIC();
@ -275,7 +275,7 @@ static TSParseResult ts_parse(const char *input) {
case 8:
SET_LEX_STATE(23);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_string:
case ts_sym_string:
SHIFT(9);
default:
PARSE_PANIC();
@ -283,7 +283,7 @@ static TSParseResult ts_parse(const char *input) {
case 9:
SET_LEX_STATE(19);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_colon:
case ts_sym_colon:
SHIFT(10);
default:
PARSE_PANIC();
@ -291,19 +291,19 @@ static TSParseResult ts_parse(const char *input) {
case 10:
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_array:
case ts_sym_array:
SHIFT(6);
case ts_symbol_number:
case ts_sym_number:
SHIFT(6);
case ts_symbol_object:
case ts_sym_object:
SHIFT(6);
case ts_symbol_string:
case ts_sym_string:
SHIFT(6);
case ts_symbol_value:
case ts_sym_value:
SHIFT(11);
case ts_symbol_left_brace:
case ts_sym_left_brace:
SHIFT(13);
case ts_symbol_left_bracket:
case ts_sym_left_bracket:
SHIFT(19);
default:
PARSE_PANIC();
@ -311,11 +311,11 @@ static TSParseResult ts_parse(const char *input) {
case 11:
SET_LEX_STATE(2);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_comma:
case ts_sym_comma:
SHIFT(8);
case ts_symbol_right_brace:
REDUCE(ts_aux_repeat_helper2, 0, COLLAPSE({}));
case ts_aux_repeat_helper2:
case ts_sym_right_brace:
REDUCE(ts_aux_sym_repeat_helper2, 0, COLLAPSE({}));
case ts_aux_sym_repeat_helper2:
SHIFT(12);
default:
PARSE_PANIC();
@ -323,17 +323,17 @@ static TSParseResult ts_parse(const char *input) {
case 12:
SET_LEX_STATE(5);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_right_brace:
REDUCE(ts_aux_repeat_helper2, 5, COLLAPSE({1, 0, 1, 0, 1}));
case ts_sym_right_brace:
REDUCE(ts_aux_sym_repeat_helper2, 5, COLLAPSE({1, 0, 1, 0, 1}));
default:
PARSE_PANIC();
}
case 13:
SET_LEX_STATE(21);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_string:
case ts_sym_string:
SHIFT(14);
case ts_symbol_right_brace:
case ts_sym_right_brace:
SHIFT(40);
default:
PARSE_PANIC();
@ -341,7 +341,7 @@ static TSParseResult ts_parse(const char *input) {
case 14:
SET_LEX_STATE(19);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_colon:
case ts_sym_colon:
SHIFT(15);
default:
PARSE_PANIC();
@ -349,19 +349,19 @@ static TSParseResult ts_parse(const char *input) {
case 15:
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_array:
case ts_sym_array:
SHIFT(6);
case ts_symbol_number:
case ts_sym_number:
SHIFT(6);
case ts_symbol_object:
case ts_sym_object:
SHIFT(6);
case ts_symbol_string:
case ts_sym_string:
SHIFT(6);
case ts_symbol_value:
case ts_sym_value:
SHIFT(16);
case ts_symbol_left_brace:
case ts_sym_left_brace:
SHIFT(13);
case ts_symbol_left_bracket:
case ts_sym_left_bracket:
SHIFT(19);
default:
PARSE_PANIC();
@ -369,11 +369,11 @@ static TSParseResult ts_parse(const char *input) {
case 16:
SET_LEX_STATE(2);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_comma:
case ts_sym_comma:
SHIFT(8);
case ts_symbol_right_brace:
REDUCE(ts_aux_repeat_helper2, 0, COLLAPSE({}));
case ts_aux_repeat_helper2:
case ts_sym_right_brace:
REDUCE(ts_aux_sym_repeat_helper2, 0, COLLAPSE({}));
case ts_aux_sym_repeat_helper2:
SHIFT(17);
default:
PARSE_PANIC();
@ -381,7 +381,7 @@ static TSParseResult ts_parse(const char *input) {
case 17:
SET_LEX_STATE(5);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_right_brace:
case ts_sym_right_brace:
SHIFT(18);
default:
PARSE_PANIC();
@ -389,31 +389,31 @@ static TSParseResult ts_parse(const char *input) {
case 18:
SET_LEX_STATE(2);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_comma:
REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}));
case ts_symbol_right_brace:
REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}));
case ts_sym_comma:
REDUCE(ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}));
case ts_sym_right_brace:
REDUCE(ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}));
default:
PARSE_PANIC();
}
case 19:
SET_LEX_STATE(22);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_array:
case ts_sym_array:
SHIFT(20);
case ts_symbol_number:
case ts_sym_number:
SHIFT(20);
case ts_symbol_object:
case ts_sym_object:
SHIFT(20);
case ts_symbol_string:
case ts_sym_string:
SHIFT(20);
case ts_symbol_value:
case ts_sym_value:
SHIFT(21);
case ts_symbol_left_brace:
case ts_sym_left_brace:
SHIFT(25);
case ts_symbol_left_bracket:
case ts_sym_left_bracket:
SHIFT(32);
case ts_symbol_right_bracket:
case ts_sym_right_bracket:
SHIFT(39);
default:
PARSE_PANIC();
@ -421,21 +421,21 @@ static TSParseResult ts_parse(const char *input) {
case 20:
SET_LEX_STATE(6);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_comma:
REDUCE(ts_symbol_value, 1, COLLAPSE({0}));
case ts_symbol_right_bracket:
REDUCE(ts_symbol_value, 1, COLLAPSE({0}));
case ts_sym_comma:
REDUCE(ts_sym_value, 1, COLLAPSE({0}));
case ts_sym_right_bracket:
REDUCE(ts_sym_value, 1, COLLAPSE({0}));
default:
PARSE_PANIC();
}
case 21:
SET_LEX_STATE(6);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_comma:
case ts_sym_comma:
SHIFT(22);
case ts_symbol_right_bracket:
REDUCE(ts_aux_repeat_helper1, 0, COLLAPSE({}));
case ts_aux_repeat_helper1:
case ts_sym_right_bracket:
REDUCE(ts_aux_sym_repeat_helper1, 0, COLLAPSE({}));
case ts_aux_sym_repeat_helper1:
SHIFT(37);
default:
PARSE_PANIC();
@ -443,19 +443,19 @@ static TSParseResult ts_parse(const char *input) {
case 22:
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_array:
case ts_sym_array:
SHIFT(20);
case ts_symbol_number:
case ts_sym_number:
SHIFT(20);
case ts_symbol_object:
case ts_sym_object:
SHIFT(20);
case ts_symbol_string:
case ts_sym_string:
SHIFT(20);
case ts_symbol_value:
case ts_sym_value:
SHIFT(23);
case ts_symbol_left_brace:
case ts_sym_left_brace:
SHIFT(25);
case ts_symbol_left_bracket:
case ts_sym_left_bracket:
SHIFT(32);
default:
PARSE_PANIC();
@ -463,11 +463,11 @@ static TSParseResult ts_parse(const char *input) {
case 23:
SET_LEX_STATE(6);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_comma:
case ts_sym_comma:
SHIFT(22);
case ts_symbol_right_bracket:
REDUCE(ts_aux_repeat_helper1, 0, COLLAPSE({}));
case ts_aux_repeat_helper1:
case ts_sym_right_bracket:
REDUCE(ts_aux_sym_repeat_helper1, 0, COLLAPSE({}));
case ts_aux_sym_repeat_helper1:
SHIFT(24);
default:
PARSE_PANIC();
@ -475,17 +475,17 @@ static TSParseResult ts_parse(const char *input) {
case 24:
SET_LEX_STATE(8);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_right_bracket:
REDUCE(ts_aux_repeat_helper1, 3, COLLAPSE({1, 0, 1}));
case ts_sym_right_bracket:
REDUCE(ts_aux_sym_repeat_helper1, 3, COLLAPSE({1, 0, 1}));
default:
PARSE_PANIC();
}
case 25:
SET_LEX_STATE(21);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_string:
case ts_sym_string:
SHIFT(26);
case ts_symbol_right_brace:
case ts_sym_right_brace:
SHIFT(31);
default:
PARSE_PANIC();
@ -493,7 +493,7 @@ static TSParseResult ts_parse(const char *input) {
case 26:
SET_LEX_STATE(19);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_colon:
case ts_sym_colon:
SHIFT(27);
default:
PARSE_PANIC();
@ -501,19 +501,19 @@ static TSParseResult ts_parse(const char *input) {
case 27:
SET_LEX_STATE(9);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_array:
case ts_sym_array:
SHIFT(6);
case ts_symbol_number:
case ts_sym_number:
SHIFT(6);
case ts_symbol_object:
case ts_sym_object:
SHIFT(6);
case ts_symbol_string:
case ts_sym_string:
SHIFT(6);
case ts_symbol_value:
case ts_sym_value:
SHIFT(28);
case ts_symbol_left_brace:
case ts_sym_left_brace:
SHIFT(13);
case ts_symbol_left_bracket:
case ts_sym_left_bracket:
SHIFT(19);
default:
PARSE_PANIC();
@ -521,11 +521,11 @@ static TSParseResult ts_parse(const char *input) {
case 28:
SET_LEX_STATE(2);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_comma:
case ts_sym_comma:
SHIFT(8);
case ts_symbol_right_brace:
REDUCE(ts_aux_repeat_helper2, 0, COLLAPSE({}));
case ts_aux_repeat_helper2:
case ts_sym_right_brace:
REDUCE(ts_aux_sym_repeat_helper2, 0, COLLAPSE({}));
case ts_aux_sym_repeat_helper2:
SHIFT(29);
default:
PARSE_PANIC();
@ -533,7 +533,7 @@ static TSParseResult ts_parse(const char *input) {
case 29:
SET_LEX_STATE(5);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_right_brace:
case ts_sym_right_brace:
SHIFT(30);
default:
PARSE_PANIC();
@ -541,41 +541,41 @@ static TSParseResult ts_parse(const char *input) {
case 30:
SET_LEX_STATE(6);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_comma:
REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}));
case ts_symbol_right_bracket:
REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}));
case ts_sym_comma:
REDUCE(ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}));
case ts_sym_right_bracket:
REDUCE(ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}));
default:
PARSE_PANIC();
}
case 31:
SET_LEX_STATE(6);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_comma:
REDUCE(ts_symbol_object, 2, COLLAPSE({1, 1}));
case ts_symbol_right_bracket:
REDUCE(ts_symbol_object, 2, COLLAPSE({1, 1}));
case ts_sym_comma:
REDUCE(ts_sym_object, 2, COLLAPSE({1, 1}));
case ts_sym_right_bracket:
REDUCE(ts_sym_object, 2, COLLAPSE({1, 1}));
default:
PARSE_PANIC();
}
case 32:
SET_LEX_STATE(22);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_array:
case ts_sym_array:
SHIFT(20);
case ts_symbol_number:
case ts_sym_number:
SHIFT(20);
case ts_symbol_object:
case ts_sym_object:
SHIFT(20);
case ts_symbol_string:
case ts_sym_string:
SHIFT(20);
case ts_symbol_value:
case ts_sym_value:
SHIFT(33);
case ts_symbol_left_brace:
case ts_sym_left_brace:
SHIFT(25);
case ts_symbol_left_bracket:
case ts_sym_left_bracket:
SHIFT(32);
case ts_symbol_right_bracket:
case ts_sym_right_bracket:
SHIFT(36);
default:
PARSE_PANIC();
@ -583,11 +583,11 @@ static TSParseResult ts_parse(const char *input) {
case 33:
SET_LEX_STATE(6);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_comma:
case ts_sym_comma:
SHIFT(22);
case ts_symbol_right_bracket:
REDUCE(ts_aux_repeat_helper1, 0, COLLAPSE({}));
case ts_aux_repeat_helper1:
case ts_sym_right_bracket:
REDUCE(ts_aux_sym_repeat_helper1, 0, COLLAPSE({}));
case ts_aux_sym_repeat_helper1:
SHIFT(34);
default:
PARSE_PANIC();
@ -595,7 +595,7 @@ static TSParseResult ts_parse(const char *input) {
case 34:
SET_LEX_STATE(8);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_right_bracket:
case ts_sym_right_bracket:
SHIFT(35);
default:
PARSE_PANIC();
@ -603,27 +603,27 @@ static TSParseResult ts_parse(const char *input) {
case 35:
SET_LEX_STATE(6);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_comma:
REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1}));
case ts_symbol_right_bracket:
REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1}));
case ts_sym_comma:
REDUCE(ts_sym_array, 4, COLLAPSE({1, 0, 1, 1}));
case ts_sym_right_bracket:
REDUCE(ts_sym_array, 4, COLLAPSE({1, 0, 1, 1}));
default:
PARSE_PANIC();
}
case 36:
SET_LEX_STATE(6);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_comma:
REDUCE(ts_symbol_array, 2, COLLAPSE({1, 1}));
case ts_symbol_right_bracket:
REDUCE(ts_symbol_array, 2, COLLAPSE({1, 1}));
case ts_sym_comma:
REDUCE(ts_sym_array, 2, COLLAPSE({1, 1}));
case ts_sym_right_bracket:
REDUCE(ts_sym_array, 2, COLLAPSE({1, 1}));
default:
PARSE_PANIC();
}
case 37:
SET_LEX_STATE(8);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_right_bracket:
case ts_sym_right_bracket:
SHIFT(38);
default:
PARSE_PANIC();
@ -631,37 +631,37 @@ static TSParseResult ts_parse(const char *input) {
case 38:
SET_LEX_STATE(2);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_comma:
REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1}));
case ts_symbol_right_brace:
REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1}));
case ts_sym_comma:
REDUCE(ts_sym_array, 4, COLLAPSE({1, 0, 1, 1}));
case ts_sym_right_brace:
REDUCE(ts_sym_array, 4, COLLAPSE({1, 0, 1, 1}));
default:
PARSE_PANIC();
}
case 39:
SET_LEX_STATE(2);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_comma:
REDUCE(ts_symbol_array, 2, COLLAPSE({1, 1}));
case ts_symbol_right_brace:
REDUCE(ts_symbol_array, 2, COLLAPSE({1, 1}));
case ts_sym_comma:
REDUCE(ts_sym_array, 2, COLLAPSE({1, 1}));
case ts_sym_right_brace:
REDUCE(ts_sym_array, 2, COLLAPSE({1, 1}));
default:
PARSE_PANIC();
}
case 40:
SET_LEX_STATE(2);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_comma:
REDUCE(ts_symbol_object, 2, COLLAPSE({1, 1}));
case ts_symbol_right_brace:
REDUCE(ts_symbol_object, 2, COLLAPSE({1, 1}));
case ts_sym_comma:
REDUCE(ts_sym_object, 2, COLLAPSE({1, 1}));
case ts_sym_right_brace:
REDUCE(ts_sym_object, 2, COLLAPSE({1, 1}));
default:
PARSE_PANIC();
}
case 41:
SET_LEX_STATE(5);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_right_brace:
case ts_sym_right_brace:
SHIFT(42);
default:
PARSE_PANIC();
@ -669,37 +669,37 @@ static TSParseResult ts_parse(const char *input) {
case 42:
SET_LEX_STATE(0);
switch (LOOKAHEAD_SYM()) {
case ts_aux_end:
REDUCE(ts_symbol_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}));
case ts_aux_sym_end:
REDUCE(ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}));
default:
PARSE_PANIC();
}
case 43:
SET_LEX_STATE(0);
switch (LOOKAHEAD_SYM()) {
case ts_aux_end:
REDUCE(ts_symbol_object, 2, COLLAPSE({1, 1}));
case ts_aux_sym_end:
REDUCE(ts_sym_object, 2, COLLAPSE({1, 1}));
default:
PARSE_PANIC();
}
case 44:
SET_LEX_STATE(22);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_array:
case ts_sym_array:
SHIFT(20);
case ts_symbol_number:
case ts_sym_number:
SHIFT(20);
case ts_symbol_object:
case ts_sym_object:
SHIFT(20);
case ts_symbol_string:
case ts_sym_string:
SHIFT(20);
case ts_symbol_value:
case ts_sym_value:
SHIFT(45);
case ts_symbol_left_brace:
case ts_sym_left_brace:
SHIFT(25);
case ts_symbol_left_bracket:
case ts_sym_left_bracket:
SHIFT(32);
case ts_symbol_right_bracket:
case ts_sym_right_bracket:
SHIFT(48);
default:
PARSE_PANIC();
@ -707,11 +707,11 @@ static TSParseResult ts_parse(const char *input) {
case 45:
SET_LEX_STATE(6);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_comma:
case ts_sym_comma:
SHIFT(22);
case ts_symbol_right_bracket:
REDUCE(ts_aux_repeat_helper1, 0, COLLAPSE({}));
case ts_aux_repeat_helper1:
case ts_sym_right_bracket:
REDUCE(ts_aux_sym_repeat_helper1, 0, COLLAPSE({}));
case ts_aux_sym_repeat_helper1:
SHIFT(46);
default:
PARSE_PANIC();
@ -719,7 +719,7 @@ static TSParseResult ts_parse(const char *input) {
case 46:
SET_LEX_STATE(8);
switch (LOOKAHEAD_SYM()) {
case ts_symbol_right_bracket:
case ts_sym_right_bracket:
SHIFT(47);
default:
PARSE_PANIC();
@ -727,16 +727,16 @@ static TSParseResult ts_parse(const char *input) {
case 47:
SET_LEX_STATE(0);
switch (LOOKAHEAD_SYM()) {
case ts_aux_end:
REDUCE(ts_symbol_array, 4, COLLAPSE({1, 0, 1, 1}));
case ts_aux_sym_end:
REDUCE(ts_sym_array, 4, COLLAPSE({1, 0, 1, 1}));
default:
PARSE_PANIC();
}
case 48:
SET_LEX_STATE(0);
switch (LOOKAHEAD_SYM()) {
case ts_aux_end:
REDUCE(ts_symbol_array, 2, COLLAPSE({1, 1}));
case ts_aux_sym_end:
REDUCE(ts_sym_array, 2, COLLAPSE({1, 1}));
default:
PARSE_PANIC();
}
@ -746,7 +746,4 @@ static TSParseResult ts_parse(const char *input) {
FINISH_PARSER();
}
TSParseConfig ts_parse_config_json = {
.parse_fn = ts_parse,
.symbol_names = ts_symbol_names
};
EXPORT_PARSER(ts_parse_config_json);

83
include/tree_sitter/parser.h
View file

@ -28,31 +28,31 @@ extern "C" {
static int INITIAL_STACK_SIZE = 100;
static const char *ts_symbol_names[];
typedef int TSState;
typedef int ts_state;
typedef struct {
TSState state;
TSTree *node;
} TSStackEntry;
ts_state state;
ts_tree *node;
} ts_stack_entry;
typedef struct {
const char *input;
size_t position;
TSTree *lookahead_node;
TSTree *prev_lookahead_node;
TSState lex_state;
TSStackEntry *stack;
ts_tree *lookahead_node;
ts_tree *prev_lookahead_node;
ts_state lex_state;
ts_stack_entry *stack;
size_t stack_size;
TSParseResult result;
} TSParser;
ts_parse_result result;
} ts_parser;
static TSParser TSParserMake(const char *input) {
TSParser result = {
static ts_parser TSParserMake(const char *input) {
ts_parser result = {
.input = input,
.position = 0,
.lookahead_node = NULL,
.lex_state = 0,
.stack = calloc(INITIAL_STACK_SIZE, sizeof(TSStackEntry)),
.stack = calloc(INITIAL_STACK_SIZE, sizeof(ts_stack_entry)),
.stack_size = 0,
.result = {
.tree = NULL,
@ -65,23 +65,23 @@ static TSParser TSParserMake(const char *input) {
return result;
}
static char TSParserLookaheadChar(const TSParser *parser) {
static char TSParserLookaheadChar(const ts_parser *parser) {
return parser->input[parser->position];
}
static long TSParserLookaheadSym(const TSParser *parser) {
TSTree *node = parser->lookahead_node;
static long TSParserLookaheadSym(const ts_parser *parser) {
ts_tree *node = parser->lookahead_node;
return node ? node->value : -1;
}
static TSState TSParserParseState(const TSParser *parser) {
static ts_state TSParserParseState(const ts_parser *parser) {
if (parser->stack_size == 0) return 0;
return parser->stack[parser->stack_size - 1].state;
}
static void TSParserShift(TSParser *parser, TSState parse_state) {
static void TSParserShift(ts_parser *parser, ts_state parse_state) {
DEBUG_PARSE("shift: %d \n", parse_state);
TSStackEntry *entry = (parser->stack + parser->stack_size);
ts_stack_entry *entry = (parser->stack + parser->stack_size);
entry->state = parse_state;
entry->node = parser->lookahead_node;
parser->lookahead_node = parser->prev_lookahead_node;
@ -89,12 +89,12 @@ static void TSParserShift(TSParser *parser, TSState parse_state) {
parser->stack_size++;
}
static void TSParserReduce(TSParser *parser, TSSymbol symbol, int immediate_child_count, const int *collapse_flags) {
static void TSParserReduce(ts_parser *parser, ts_symbol symbol, int immediate_child_count, const int *collapse_flags) {
parser->stack_size -= immediate_child_count;
int total_child_count = 0;
for (int i = 0; i < immediate_child_count; i++) {
TSTree *child = parser->stack[parser->stack_size + i].node;
ts_tree *child = parser->stack[parser->stack_size + i].node;
if (collapse_flags[i]) {
total_child_count += child->child_count;
} else {
@ -102,12 +102,12 @@ static void TSParserReduce(TSParser *parser, TSSymbol symbol, int immediate_chil
}
}
TSTree **children = malloc(total_child_count * sizeof(TSTree *));
ts_tree **children = malloc(total_child_count * sizeof(ts_tree *));
int n = 0;
for (int i = 0; i < immediate_child_count; i++) {
TSTree *child = parser->stack[parser->stack_size + i].node;
ts_tree *child = parser->stack[parser->stack_size + i].node;
if (collapse_flags[i]) {
memcpy(children + n, child->children, (child->child_count * sizeof(TSTree *)));
memcpy(children + n, child->children, (child->child_count * sizeof(ts_tree *)));
n += child->child_count;
} else {
children[n] = child;
@ -116,47 +116,62 @@ static void TSParserReduce(TSParser *parser, TSSymbol symbol, int immediate_chil
}
parser->prev_lookahead_node = parser->lookahead_node;
parser->lookahead_node = TSTreeMake(symbol, total_child_count, children);
parser->lookahead_node = ts_tree_make(symbol, total_child_count, children);
DEBUG_PARSE("reduce: %s, state: %u \n", ts_symbol_names[symbol], TSParserParseState(parser));
}
static void TSParserError(TSParser *parser, size_t count, const char **expected_inputs) {
TSParseError *error = &parser->result.error;
static void TSParserError(ts_parser *parser, size_t count, const char **expected_inputs) {
ts_error *error = &parser->result.error;
error->position = parser->position;
error->expected_input_count = count;
error->expected_inputs = expected_inputs;
error->lookahead_sym = TSParserLookaheadSym(parser);
}
static int TSParserHasError(const TSParser *parser) {
static int TSParserHasError(const ts_parser *parser) {
return (parser->result.error.expected_inputs != NULL);
}
static void TSParserAdvance(TSParser *parser, TSState lex_state) {
static void TSParserAdvance(ts_parser *parser, ts_state lex_state) {
DEBUG_LEX("character: '%c' \n", TSParserLookaheadChar(parser));
parser->position++;
parser->lex_state = lex_state;
}
static void TSParserSetLookaheadSym(TSParser *parser, TSSymbol symbol) {
static void TSParserSetLookaheadSym(ts_parser *parser, ts_symbol symbol) {
DEBUG_LEX("token: %s \n", ts_symbol_names[symbol]);
parser->lookahead_node = TSTreeMake(symbol, 0, NULL);
parser->lookahead_node = ts_tree_make(symbol, 0, NULL);
}
static void TSParserAcceptInput(TSParser *parser) {
static void TSParserAcceptInput(ts_parser *parser) {
parser->result.tree = parser->stack[parser->stack_size - 1].node;
DEBUG_PARSE("accept \n");
}
static void TSParserSkipWhitespace(TSParser *parser) {
static void TSParserSkipWhitespace(ts_parser *parser) {
while (isspace(parser->input[parser->position]))
parser->position++;
}
#pragma mark - DSL
#define LEX_FN() \
static void ts_lex(ts_parser *parser)
#define PARSE_FN() \
static ts_parse_result ts_parse(const char *input)
#define SYMBOL_NAMES \
static const char *ts_symbol_names[] =
#define EXPORT_PARSER(name) \
ts_parse_config name = { \
.parse_fn = ts_parse, \
.symbol_names = ts_symbol_names \
};
#define START_PARSER() \
TSParser p = TSParserMake(input), *parser = &p; \
ts_parser p = TSParserMake(input), *parser = &p; \
next_state:
#define START_LEXER() \

48
include/tree_sitter/runtime.h
View file

@ -12,44 +12,44 @@ typedef struct {
size_t expected_input_count;
size_t position;
long lookahead_sym;
} TSParseError;
} ts_error;
const char * TSParseErrorToString(const TSParseError *error, const char *input_string, const char **symbol_names);
const char * ts_error_string(const ts_error *error, const char *input_string, const char **symbol_names);
typedef size_t TSSymbol;
typedef size_t ts_symbol;
typedef struct TSTree {
TSSymbol value;
struct TSTree **children;
typedef struct ts_tree {
ts_symbol value;
struct ts_tree **children;
size_t child_count;
size_t ref_count;
} TSTree;
} ts_tree;
TSTree * TSTreeMake(TSSymbol value, size_t child_count, TSTree **children);
void TSTreeRetain(TSTree *tree);
void TSTreeRelease(TSTree *tree);
int TSTreeEquals(const TSTree *tree1, const TSTree *tree2);
char * TSTreeToString(const TSTree *tree, const char **names);
ts_tree * ts_tree_make(ts_symbol value, size_t child_count, ts_tree **children);
void ts_tree_retain(ts_tree *tree);
void ts_tree_release(ts_tree *tree);
int ts_tree_equals(const ts_tree *tree1, const ts_tree *tree2);
char * ts_tree_string(const ts_tree *tree, const char **names);
typedef struct {
TSParseError error;
TSTree *tree;
} TSParseResult;
ts_error error;
ts_tree *tree;
} ts_parse_result;
typedef TSParseResult TSParseFn(const char *);
typedef ts_parse_result ts_parse_fn(const char *);
typedef struct {
TSParseFn *parse_fn;
ts_parse_fn *parse_fn;
const char **symbol_names;
} TSParseConfig;
} ts_parse_config;
typedef struct TSDocument TSDocument;
typedef struct ts_document ts_document;
TSDocument * TSDocumentMake();
void TSDocumentSetUp(TSDocument *document, TSParseConfig config);
void TSDocumentSetText(TSDocument *document, const char *text);
TSTree * TSDocumentTree(const TSDocument *document);
const char * TSDocumentToString(const TSDocument *document);
ts_document * ts_document_make();
void ts_document_set_parser(ts_document *document, ts_parse_config config);
void ts_document_set_text(ts_document *document, const char *text);
ts_tree * ts_document_tree(const ts_document *document);
const char * ts_document_string(const ts_document *document);
#ifdef __cplusplus
}

32
spec/runtime/arithmetic_spec.cpp
View file

@ -1,46 +1,46 @@
#include "spec_helper.h"
extern TSParseConfig ts_parse_config_arithmetic;
extern ts_parse_config ts_parse_config_arithmetic;
START_TEST
describe("arithmetic", []() {
TSDocument *document;
ts_document *document;
before_each([&]() {
document = TSDocumentMake();
TSDocumentSetUp(document, ts_parse_config_arithmetic);
document = ts_document_make();
ts_document_set_parser(document, ts_parse_config_arithmetic);
});
it("parses variables", [&]() {
TSDocumentSetText(document, "x");
AssertThat(string(TSDocumentToString(document)), Equals(
ts_document_set_text(document, "x");
AssertThat(string(ts_document_string(document)), Equals(
"(expression (term (factor (variable))))"));
});
it("parses numbers", [&]() {
TSDocumentSetText(document, "5");
AssertThat(string(TSDocumentToString(document)), Equals(
ts_document_set_text(document, "5");
AssertThat(string(ts_document_string(document)), Equals(
"(expression (term (factor (number))))"));
});
it("parses products of variables", [&]() {
TSDocumentSetText(document, "x + y");
AssertThat(string(TSDocumentToString(document)), Equals(
ts_document_set_text(document, "x + y");
AssertThat(string(ts_document_string(document)), Equals(
"(expression (term (factor (variable))) (plus) (term (factor (variable))))"));
TSDocumentSetText(document, "x * y");
AssertThat(string(TSDocumentToString(document)), Equals(
ts_document_set_text(document, "x * y");
AssertThat(string(ts_document_string(document)), Equals(
"(expression (term (factor (variable)) (times) (factor (variable))))"));
});
it("parses complex trees", [&]() {
TSDocumentSetText(document, "x * y + z * a");
AssertThat(string(TSDocumentToString(document)), Equals(
ts_document_set_text(document, "x * y + z * a");
AssertThat(string(ts_document_string(document)), Equals(
"(expression (term (factor (variable)) (times) (factor (variable))) (plus) (term (factor (variable)) (times) (factor (variable))))"));
TSDocumentSetText(document, "x * (y + z)");
AssertThat(string(TSDocumentToString(document)), Equals(
ts_document_set_text(document, "x * (y + z)");
AssertThat(string(ts_document_string(document)), Equals(
"(expression (term (factor (variable)) (times) (factor (expression (term (factor (variable))) (plus) (term (factor (variable)))))))"));
});
});

44
spec/runtime/json_spec.cpp
View file

@ -1,48 +1,48 @@
#include "spec_helper.h"
extern TSParseConfig ts_parse_config_json;
extern ts_parse_config ts_parse_config_json;
START_TEST
describe("json", []() {
TSDocument *document;
ts_document *document;
before_each([&]() {
document = TSDocumentMake();
TSDocumentSetUp(document, ts_parse_config_json);
document = ts_document_make();
ts_document_set_parser(document, ts_parse_config_json);
});
it("parses strings", [&]() {
TSDocumentSetText(document, "\"\"");
AssertThat(string(TSDocumentToString(document)), Equals("(value (string))"));
ts_document_set_text(document, "\"\"");
AssertThat(string(ts_document_string(document)), Equals("(value (string))"));
TSDocumentSetText(document, "\"simple-string\"");
AssertThat(string(TSDocumentToString(document)), Equals("(value (string))"));
ts_document_set_text(document, "\"simple-string\"");
AssertThat(string(ts_document_string(document)), Equals("(value (string))"));
TSDocumentSetText(document, "\"this is a \\\"string\\\" within a string\"");
AssertThat(string(TSDocumentToString(document)), Equals("(value (string))"));
ts_document_set_text(document, "\"this is a \\\"string\\\" within a string\"");
AssertThat(string(ts_document_string(document)), Equals("(value (string))"));
});
it("parses objects", [&]() {
TSDocumentSetText(document, "{}");
AssertThat(string(TSDocumentToString(document)), Equals("(value (object))"));
ts_document_set_text(document, "{}");
AssertThat(string(ts_document_string(document)), Equals("(value (object))"));
TSDocumentSetText(document, "{ \"key1\": 1 }");
AssertThat(string(TSDocumentToString(document)), Equals("(value (object (string) (value (number))))"));
ts_document_set_text(document, "{ \"key1\": 1 }");
AssertThat(string(ts_document_string(document)), Equals("(value (object (string) (value (number))))"));
TSDocumentSetText(document, "{\"key1\": 1, \"key2\": 2 }");
AssertThat(string(TSDocumentToString(document)), Equals("(value (object (string) (value (number)) (string) (value (number))))"));
ts_document_set_text(document, "{\"key1\": 1, \"key2\": 2 }");
AssertThat(string(ts_document_string(document)), Equals("(value (object (string) (value (number)) (string) (value (number))))"));
});
it("parses arrays", [&]() {
TSDocumentSetText(document, "[]");
AssertThat(string(TSDocumentToString(document)), Equals("(value (array))"));
ts_document_set_text(document, "[]");
AssertThat(string(ts_document_string(document)), Equals("(value (array))"));
TSDocumentSetText(document, "[5]");
AssertThat(string(TSDocumentToString(document)), Equals("(value (array (value (number))))"));
ts_document_set_text(document, "[5]");
AssertThat(string(ts_document_string(document)), Equals("(value (array (value (number))))"));
TSDocumentSetText(document, "[1, 2, 3]");
AssertThat(string(TSDocumentToString(document)), Equals("(value (array (value (number)) (value (number)) (value (number))))"));
ts_document_set_text(document, "[1, 2, 3]");
AssertThat(string(ts_document_string(document)), Equals("(value (array (value (number)) (value (number)) (value (number))))"));
});
});

46
spec/runtime/tree_spec.cpp
View file

@ -6,51 +6,51 @@ enum { cat, dog, pig };
static const char *names[] = { "cat", "dog", "pig" };
describe("trees", []() {
TSTree *tree1, *parent1;
ts_tree *tree1, *parent1;
before_each([&]() {
tree1 = TSTreeMake(cat, 0, NULL);
parent1 = TSTreeMake(dog, 1, &tree1);
tree1 = ts_tree_make(cat, 0, NULL);
parent1 = ts_tree_make(dog, 1, &tree1);
});
after_each([&]() {
TSTreeRelease(tree1);
TSTreeRelease(parent1);
ts_tree_release(tree1);
ts_tree_release(parent1);
});
describe("equality", [&]() {
it("returns true for identical trees", [&]() {
TSTree *tree2 = TSTreeMake(cat, 0, NULL);
AssertThat(TSTreeEquals(tree1, tree2), Equals(1));
ts_tree *tree2 = ts_tree_make(cat, 0, NULL);
AssertThat(ts_tree_equals(tree1, tree2), Equals(1));
TSTree *parent2 = TSTreeMake(dog, 1, &tree2);
AssertThat(TSTreeEquals(parent1, parent2), Equals(1));
ts_tree *parent2 = ts_tree_make(dog, 1, &tree2);
AssertThat(ts_tree_equals(parent1, parent2), Equals(1));
TSTreeRelease(tree2);
TSTreeRelease(parent2);
ts_tree_release(tree2);
ts_tree_release(parent2);
});
it("returns false for different trees", [&]() {
TSTree *different_tree = TSTreeMake(pig, 0, NULL);
AssertThat(TSTreeEquals(tree1, different_tree), Equals(0));
ts_tree *different_tree = ts_tree_make(pig, 0, NULL);
AssertThat(ts_tree_equals(tree1, different_tree), Equals(0));
TSTree *different_parent = TSTreeMake(dog, 1, &different_tree);
AssertThat(TSTreeEquals(parent1, different_parent), Equals(0));
ts_tree *different_parent = ts_tree_make(dog, 1, &different_tree);
AssertThat(ts_tree_equals(parent1, different_parent), Equals(0));
TSTree *parent_with_same_type = TSTreeMake(cat, 1, &different_parent);
AssertThat(TSTreeEquals(parent_with_same_type, tree1), Equals(0));
AssertThat(TSTreeEquals(tree1, parent_with_same_type), Equals(0));
ts_tree *parent_with_same_type = ts_tree_make(cat, 1, &different_parent);
AssertThat(ts_tree_equals(parent_with_same_type, tree1), Equals(0));
AssertThat(ts_tree_equals(tree1, parent_with_same_type), Equals(0));
TSTreeRelease(different_tree);
TSTreeRelease(different_parent);
TSTreeRelease(parent_with_same_type);
ts_tree_release(different_tree);
ts_tree_release(different_parent);
ts_tree_release(parent_with_same_type);
});
});
describe("serialization", [&]() {
it("returns a readable string", [&]() {
AssertThat(string(TSTreeToString(tree1, names)), Equals("(cat)"));
AssertThat(string(TSTreeToString(parent1, names)), Equals("(dog (cat))"));
AssertThat(string(ts_tree_string(tree1, names)), Equals("(cat)"));
AssertThat(string(ts_tree_string(parent1, names)), Equals("(dog (cat))"));
});
});
});

19
src/compiler/generate_code/c_code.cpp
View file

@ -86,9 +86,9 @@ namespace tree_sitter {
string symbol_id(rules::Symbol symbol) {
if (symbol.is_auxiliary())
return "ts_aux_" + symbol.name;
return "ts_aux_sym_" + symbol.name;
else
return "ts_symbol_" + symbol.name;
return "ts_sym_" + symbol.name;
}
string character_code(char character) {
@ -232,14 +232,14 @@ namespace tree_sitter {
}
string symbol_enum() {
string result = "enum ts_symbol {\n";
string result = "enum {\n";
for (auto symbol : parse_table.symbols)
result += indent(symbol_id(symbol)) + ",\n";
return result + "};";
}
string rule_names_list() {
string result = "static const char *ts_symbol_names[] = {\n";
string result = "SYMBOL_NAMES {\n";
for (auto symbol : parse_table.symbols)
result += indent(string("\"") + symbol.name) + "\",\n";
return result + "};";
@ -251,7 +251,7 @@ namespace tree_sitter {
string lex_function() {
return join({
"static void ts_lex(TSParser *parser) {",
"LEX_FN() {",
indent("START_LEXER();"),
indent(switch_on_lex_state()),
indent("FINISH_LEXER();"),
@ -261,7 +261,7 @@ namespace tree_sitter {
string parse_function() {
return join({
"static TSParseResult ts_parse(const char *input) {",
"PARSE_FN() {",
indent("START_PARSER();"),
indent(switch_on_parse_state()),
indent("FINISH_PARSER();"),
@ -270,12 +270,7 @@ namespace tree_sitter {
}
string parse_config_struct() {
return join({
"TSParseConfig ts_parse_config_" + name + " = {",
indent(".parse_fn = ts_parse,"),
indent(".symbol_names = ts_symbol_names"),
"};"
});
return "EXPORT_PARSER(ts_parse_config_" + name + ");";
}
string code() {

26
src/runtime/document.cpp
View file

@ -1,37 +1,37 @@
#include "tree_sitter/runtime.h"
struct TSDocument {
TSParseFn *parse_fn;
struct ts_document {
ts_parse_fn *parse_fn;
const char **symbol_names;
const char *text;
TSParseError error;
TSTree *tree;
ts_error error;
ts_tree *tree;
};
TSDocument * TSDocumentMake() {
return new TSDocument();
ts_document * ts_document_make() {
return new ts_document();
}
void TSDocumentSetUp(TSDocument *document, TSParseConfig config) {
void ts_document_set_parser(ts_document *document, ts_parse_config config) {
document->parse_fn = config.parse_fn;
document->symbol_names = config.symbol_names;
}
void TSDocumentSetText(TSDocument *document, const char *text) {
TSParseResult result = document->parse_fn(text);
void ts_document_set_text(ts_document *document, const char *text) {
ts_parse_result result = document->parse_fn(text);
document->text = text;
document->tree = result.tree;
document->error = result.error;
}
TSTree * TSDocumentTree(const TSDocument *document) {
ts_tree * ts_document_tree(const ts_document *document) {
return document->tree;
}
const char * TSDocumentToString(const TSDocument *document) {
const char * ts_document_string(const ts_document *document) {
if (document->error.expected_inputs != NULL) {
return TSParseErrorToString(&document->error, document->text, document->symbol_names);
return ts_error_string(&document->error, document->text, document->symbol_names);
} else {
return TSTreeToString(document->tree, document->symbol_names);
return ts_tree_string(document->tree, document->symbol_names);
}
}

2
src/runtime/error.cpp
View file

@ -4,7 +4,7 @@
using std::string;
const char * TSParseErrorToString(const TSParseError *error, const char *input_string, const char **symbol_names) {
const char * ts_error_string(const ts_error *error, const char *input_string, const char **symbol_names) {
string result = string("Unexpected character '") + input_string[error->position] + "'. Expected: ";
for (int i = 0; i < error->expected_input_count; i++)
result += string(error->expected_inputs[i]) + " ";

24
src/runtime/tree.cpp
View file

@ -4,42 +4,42 @@
using std::string;
TSTree * TSTreeMake(TSSymbol value, size_t child_count, TSTree **children) {
TSTree *result = new TSTree();
ts_tree * ts_tree_make(ts_symbol value, size_t child_count, ts_tree **children) {
ts_tree *result = new ts_tree();
result->value = value;
result->child_count = child_count;
result->children = children;
result->ref_count = 0;
for (int i = 0; i < child_count; i++)
TSTreeRetain(children[i]);
ts_tree_retain(children[i]);
return result;
}
void TSTreeRetain(TSTree *tree) {
void ts_tree_retain(ts_tree *tree) {
tree->ref_count++;
}
void TSTreeRelease(TSTree *tree) {
void ts_tree_release(ts_tree *tree) {
tree->ref_count--;
if (tree->ref_count == 0) {
for (int i = 0; i < tree->child_count; i++)
TSTreeRelease(tree->children[i]);
ts_tree_release(tree->children[i]);
free(tree);
}
}
int TSTreeEquals(const TSTree *node1, const TSTree *node2) {
int ts_tree_equals(const ts_tree *node1, const ts_tree *node2) {
if (node1->value != node2->value) return 0;
if (node1->child_count != node2->child_count) return 0;
for (int i = 0; i < node1->child_count; i++) {
TSTree *child1 = node1->children[i];
TSTree *child2 = node2->children[i];
if (!TSTreeEquals(child1, child2)) return 0;
ts_tree *child1 = node1->children[i];
ts_tree *child2 = node2->children[i];
if (!ts_tree_equals(child1, child2)) return 0;
}
return 1;
}
static string __tree_to_string(const TSTree *tree, const char **symbol_names) {
static string __tree_to_string(const ts_tree *tree, const char **symbol_names) {
if (!tree) return "#<null-tree>";
string result = string("(") + symbol_names[tree->value];
for (int i = 0; i < tree->child_count; i++)
@ -47,7 +47,7 @@ static string __tree_to_string(const TSTree *tree, const char **symbol_names) {
return result + ")";
}
char * TSTreeToString(const TSTree *tree, const char **symbol_names) {
char * ts_tree_string(const ts_tree *tree, const char **symbol_names) {
string value(__tree_to_string(tree, symbol_names));
char *result = (char *)malloc(value.size());
strcpy(result, value.c_str());