From 6ed6aa05cc8f45bf3bb99c75209ac973867906ce Mon Sep 17 00:00:00 2001 From: Max Brunsfeld Date: Thu, 20 Feb 2014 13:30:43 -0800 Subject: [PATCH] Update runtime code naming Also, add macros so that code generator doesn't need to know about any runtime variables names or types --- examples/parsers/arithmetic.c | 429 +++++++++++++------------- examples/parsers/json.c | 401 ++++++++++++------------ include/tree_sitter/parser.h | 83 +++-- include/tree_sitter/runtime.h | 48 +-- spec/runtime/arithmetic_spec.cpp | 32 +- spec/runtime/json_spec.cpp | 44 +-- spec/runtime/tree_spec.cpp | 46 +-- src/compiler/generate_code/c_code.cpp | 19 +- src/runtime/document.cpp | 26 +- src/runtime/error.cpp | 2 +- src/runtime/tree.cpp | 24 +- 11 files changed, 579 insertions(+), 575 deletions(-) diff --git a/examples/parsers/arithmetic.c b/examples/parsers/arithmetic.c index 29113e45..dd37460e 100644 --- a/examples/parsers/arithmetic.c +++ b/examples/parsers/arithmetic.c @@ -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({""})); 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({"", "+"})); 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); diff --git a/examples/parsers/json.c b/examples/parsers/json.c index 08258c19..b86f0080 100644 --- a/examples/parsers/json.c +++ b/examples/parsers/json.c @@ -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({""})); 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({""})); 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); diff --git a/include/tree_sitter/parser.h b/include/tree_sitter/parser.h index 930f387b..7dc2f636 100644 --- a/include/tree_sitter/parser.h +++ b/include/tree_sitter/parser.h @@ -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() \ diff --git a/include/tree_sitter/runtime.h b/include/tree_sitter/runtime.h index e42d4727..ffa7193f 100644 --- a/include/tree_sitter/runtime.h +++ b/include/tree_sitter/runtime.h @@ -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 } diff --git a/spec/runtime/arithmetic_spec.cpp b/spec/runtime/arithmetic_spec.cpp index c68096c0..4d4e97c2 100644 --- a/spec/runtime/arithmetic_spec.cpp +++ b/spec/runtime/arithmetic_spec.cpp @@ -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)))))))")); }); }); diff --git a/spec/runtime/json_spec.cpp b/spec/runtime/json_spec.cpp index 8788f3d5..19f5fa4f 100644 --- a/spec/runtime/json_spec.cpp +++ b/spec/runtime/json_spec.cpp @@ -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))))")); }); }); diff --git a/spec/runtime/tree_spec.cpp b/spec/runtime/tree_spec.cpp index 2bcddaff..321dc2fc 100644 --- a/spec/runtime/tree_spec.cpp +++ b/spec/runtime/tree_spec.cpp @@ -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))")); }); }); }); diff --git a/src/compiler/generate_code/c_code.cpp b/src/compiler/generate_code/c_code.cpp index 9cb0d67b..fd56979c 100644 --- a/src/compiler/generate_code/c_code.cpp +++ b/src/compiler/generate_code/c_code.cpp @@ -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() { diff --git a/src/runtime/document.cpp b/src/runtime/document.cpp index 484b27e8..8e0069ba 100644 --- a/src/runtime/document.cpp +++ b/src/runtime/document.cpp @@ -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); } } diff --git a/src/runtime/error.cpp b/src/runtime/error.cpp index f3378470..78c171fc 100644 --- a/src/runtime/error.cpp +++ b/src/runtime/error.cpp @@ -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]) + " "; diff --git a/src/runtime/tree.cpp b/src/runtime/tree.cpp index 0644a8cb..384ca8cc 100644 --- a/src/runtime/tree.cpp +++ b/src/runtime/tree.cpp @@ -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 "#"; 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());