From 7adb0bf34fd46122e30f7a4df69f6db4eeb60996 Mon Sep 17 00:00:00 2001 From: Max Brunsfeld Date: Sat, 29 Mar 2014 16:29:34 -0700 Subject: [PATCH] Add golang example grammar Also, support '\a' character class shorthand in regexes, for alphabetical characters --- examples/grammars/golang.cc | 138 + examples/grammars/javascript.cc | 2 +- examples/parsers/golang.c | 2896 +++++++++++++++++ examples/parsers/javascript.c | 1886 ++++++----- .../build_tables/build_tables_spec.cc | 4 +- spec/compiler/compile_examples.cc | 2 + spec/compiler/rules/pattern_spec.cc | 2 +- spec/runtime/language_specs.cc | 46 +- spec/runtime/languages/golang/main.txt | 77 + src/compiler/rules/pattern.cc | 6 +- 10 files changed, 4044 insertions(+), 1015 deletions(-) create mode 100644 examples/grammars/golang.cc create mode 100644 examples/parsers/golang.c create mode 100644 spec/runtime/languages/golang/main.txt diff --git a/examples/grammars/golang.cc b/examples/grammars/golang.cc new file mode 100644 index 00000000..3bdd8bd4 --- /dev/null +++ b/examples/grammars/golang.cc @@ -0,0 +1,138 @@ +#include "tree_sitter/compiler.h" + +namespace tree_sitter_examples { + using tree_sitter::Grammar; + using namespace tree_sitter::rules; + + static rule_ptr comma_sep(const rule_ptr &element) { + return choice({ + seq({ element, repeat(seq({ str(","), element })) }), + blank(), + }); + } + + extern const Grammar golang({ + { "program", seq({ + sym("package_directive"), + repeat(sym("imports_block")), + repeat(sym("declaration")) }) }, + { "package_directive", seq({ + sym("_package"), + sym("package_name") }) }, + { "imports_block", seq({ + sym("_import"), + choice({ + seq({ + str("("), + err(repeat(sym("package_import"))), + str(")") + }), + sym("package_import") + }) + }) }, + { "package_import", sym("string") }, + { "declaration", seq({ + choice({ + sym("type_declaration"), + sym("var_declaration"), + sym("func_declaration") }), + blank() }) }, + + // Declarations + { "type_declaration", seq({ + sym("_type"), + sym("type_name"), + sym("type_expression") }) }, + { "var_declaration", seq({ + sym("_var"), + sym("var_name"), + str("="), + sym("expression"), + }) }, + { "func_declaration", seq({ + sym("_func"), + sym("var_name"), + sym("_func_signature"), + sym("statement_block"), + }) }, + { "statement_block", seq({ + str("{"), + str("}"), + }) }, + { "expression", choice({ + sym("number"), + }) }, + { "type_expression", choice({ + sym("pointer_type"), + sym("slice_type"), + sym("map_type"), + sym("interface_type"), + sym("struct_type"), + sym("type_name") }) }, + + // Type expressions + { "pointer_type", seq({ + str("*"), + sym("type_expression") }) }, + { "map_type", seq({ + sym("_map"), + str("["), + sym("type_expression"), + str("]"), + sym("type_expression") }) }, + { "slice_type", seq({ + str("["), + str("]"), + sym("type_expression") }) }, + { "struct_type", seq({ + sym("_struct"), + str("{"), + repeat(seq({ + sym("var_name"), + sym("type_expression") })), + str("}") }) }, + { "interface_type", seq({ + sym("_interface"), + str("{"), + repeat(seq({ + sym("var_name"), + sym("_func_signature") })), + str("}") }) }, + + // Value expressions + { "_func_signature", seq({ + str("("), + comma_sep(seq({ + comma_sep(sym("var_name")), + sym("type_expression"), + })), + str(")"), + choice({ + seq({ + str("("), + choice({ + comma_sep(seq({ sym("var_name"), sym("type_name") })), + comma_sep(sym("type_name")), + }), + str(")") }), + sym("type_name"), + blank() })}) }, + + // Keywords + { "_map", str("map") }, + { "_interface", str("interface") }, + { "_struct", str("struct") }, + { "_package", str("package") }, + { "_import", str("import") }, + { "_var", str("var") }, + { "_func", str("func") }, + { "_type", str("type") }, + + { "string", pattern("\"([^\"]|\\\\\")+\"") }, + { "package_name", sym("_identifier") }, + { "var_name", sym("_identifier") }, + { "type_name", sym("_identifier") }, + { "_identifier", pattern("\\a[\\w_]*") }, + { "number", pattern("\\d+(.\\d+)?") }, + }); +} diff --git a/examples/grammars/javascript.cc b/examples/grammars/javascript.cc index 083a8293..3cf10251 100644 --- a/examples/grammars/javascript.cc +++ b/examples/grammars/javascript.cc @@ -123,7 +123,7 @@ namespace tree_sitter_examples { { "false", str("false") }, { "string", pattern("\"([^\"]|\\\\\")+\"") }, - { "identifier", pattern("[\\w_$]+") }, + { "identifier", pattern("\\a[\\w_$]*") }, { "number", pattern("\\d+(.\\d+)?") }, }); } diff --git a/examples/parsers/golang.c b/examples/parsers/golang.c new file mode 100644 index 00000000..5e2ff1ab --- /dev/null +++ b/examples/parsers/golang.c @@ -0,0 +1,2896 @@ +#include "tree_sitter/parser.h" + +STATE_COUNT = 225; +SYMBOL_COUNT = 52; + +enum { + ts_sym__func = 2, + ts_sym__func_signature = 3, + ts_sym__identifier = 4, + ts_sym__import = 5, + ts_sym__interface = 6, + ts_sym__map = 7, + ts_sym__package = 8, + ts_sym__struct = 9, + ts_sym__type = 10, + ts_sym__var = 11, + ts_sym_declaration = 12, + ts_sym_expression = 13, + ts_sym_func_declaration = 14, + ts_sym_imports_block = 15, + ts_sym_interface_type = 16, + ts_sym_map_type = 17, + ts_sym_number = 18, + ts_sym_package_directive = 19, + ts_sym_package_import = 20, + ts_sym_package_name = 21, + ts_sym_pointer_type = 22, + ts_sym_program = 23, + ts_sym_slice_type = 24, + ts_sym_statement_block = 25, + ts_sym_string = 26, + ts_sym_struct_type = 27, + ts_sym_type_declaration = 28, + ts_sym_type_expression = 29, + ts_sym_type_name = 30, + ts_sym_var_declaration = 31, + ts_sym_var_name = 32, + ts_aux_sym_repeat_helper1 = 33, + ts_aux_sym_repeat_helper10 = 34, + ts_aux_sym_repeat_helper2 = 35, + ts_aux_sym_repeat_helper3 = 36, + ts_aux_sym_repeat_helper4 = 37, + ts_aux_sym_repeat_helper5 = 38, + ts_aux_sym_repeat_helper6 = 39, + ts_aux_sym_repeat_helper7 = 40, + ts_aux_sym_repeat_helper8 = 41, + ts_aux_sym_repeat_helper9 = 42, + ts_aux_sym_token1 = 43, + ts_aux_sym_token2 = 44, + ts_aux_sym_token3 = 45, + ts_aux_sym_token4 = 46, + ts_aux_sym_token5 = 47, + ts_aux_sym_token6 = 48, + ts_aux_sym_token7 = 49, + ts_aux_sym_token8 = 50, + ts_aux_sym_token9 = 51, +}; + +SYMBOL_NAMES = { + [ts_sym__func] = "_func", + [ts_sym__func_signature] = "_func_signature", + [ts_sym__identifier] = "_identifier", + [ts_sym__import] = "_import", + [ts_sym__interface] = "_interface", + [ts_sym__map] = "_map", + [ts_sym__package] = "_package", + [ts_sym__struct] = "_struct", + [ts_sym__type] = "_type", + [ts_sym__var] = "_var", + [ts_sym_declaration] = "declaration", + [ts_sym_expression] = "expression", + [ts_sym_func_declaration] = "func_declaration", + [ts_sym_imports_block] = "imports_block", + [ts_sym_interface_type] = "interface_type", + [ts_sym_map_type] = "map_type", + [ts_sym_number] = "number", + [ts_sym_package_directive] = "package_directive", + [ts_sym_package_import] = "package_import", + [ts_sym_package_name] = "package_name", + [ts_sym_pointer_type] = "pointer_type", + [ts_sym_program] = "program", + [ts_sym_slice_type] = "slice_type", + [ts_sym_statement_block] = "statement_block", + [ts_sym_string] = "string", + [ts_sym_struct_type] = "struct_type", + [ts_sym_type_declaration] = "type_declaration", + [ts_sym_type_expression] = "type_expression", + [ts_sym_type_name] = "type_name", + [ts_sym_var_declaration] = "var_declaration", + [ts_sym_var_name] = "var_name", + [ts_aux_sym_repeat_helper1] = "repeat_helper1", + [ts_aux_sym_repeat_helper10] = "repeat_helper10", + [ts_aux_sym_repeat_helper2] = "repeat_helper2", + [ts_aux_sym_repeat_helper3] = "repeat_helper3", + [ts_aux_sym_repeat_helper4] = "repeat_helper4", + [ts_aux_sym_repeat_helper5] = "repeat_helper5", + [ts_aux_sym_repeat_helper6] = "repeat_helper6", + [ts_aux_sym_repeat_helper7] = "repeat_helper7", + [ts_aux_sym_repeat_helper8] = "repeat_helper8", + [ts_aux_sym_repeat_helper9] = "repeat_helper9", + [ts_aux_sym_token1] = "'('", + [ts_aux_sym_token2] = "')'", + [ts_aux_sym_token3] = "'='", + [ts_aux_sym_token4] = "'{'", + [ts_aux_sym_token5] = "'}'", + [ts_aux_sym_token6] = "'*'", + [ts_aux_sym_token7] = "'['", + [ts_aux_sym_token8] = "']'", + [ts_aux_sym_token9] = "','", + [ts_builtin_sym_end] = "end", + [ts_builtin_sym_error] = "error", +}; + +HIDDEN_SYMBOLS = { + [ts_sym__func] = 1, + [ts_sym__func_signature] = 1, + [ts_sym__identifier] = 1, + [ts_sym__import] = 1, + [ts_sym__interface] = 1, + [ts_sym__map] = 1, + [ts_sym__package] = 1, + [ts_sym__struct] = 1, + [ts_sym__type] = 1, + [ts_sym__var] = 1, + [ts_aux_sym_repeat_helper1] = 1, + [ts_aux_sym_repeat_helper10] = 1, + [ts_aux_sym_repeat_helper2] = 1, + [ts_aux_sym_repeat_helper3] = 1, + [ts_aux_sym_repeat_helper4] = 1, + [ts_aux_sym_repeat_helper5] = 1, + [ts_aux_sym_repeat_helper6] = 1, + [ts_aux_sym_repeat_helper7] = 1, + [ts_aux_sym_repeat_helper8] = 1, + [ts_aux_sym_repeat_helper9] = 1, + [ts_aux_sym_token1] = 1, + [ts_aux_sym_token2] = 1, + [ts_aux_sym_token3] = 1, + [ts_aux_sym_token4] = 1, + [ts_aux_sym_token5] = 1, + [ts_aux_sym_token6] = 1, + [ts_aux_sym_token7] = 1, + [ts_aux_sym_token8] = 1, + [ts_aux_sym_token9] = 1, +}; + +LEX_FN() { + START_LEXER(); + switch (lex_state) { + case 0: + if (lookahead == 'f') + ADVANCE(1); + if (lookahead == 'i') + ADVANCE(5); + if (lookahead == 't') + ADVANCE(11); + if (lookahead == 'v') + ADVANCE(15); + LEX_ERROR(); + case 1: + if (lookahead == 'u') + ADVANCE(2); + LEX_ERROR(); + case 2: + if (lookahead == 'n') + ADVANCE(3); + LEX_ERROR(); + case 3: + if (lookahead == 'c') + ADVANCE(4); + LEX_ERROR(); + case 4: + ACCEPT_TOKEN(ts_sym__func); + case 5: + if (lookahead == 'm') + ADVANCE(6); + LEX_ERROR(); + case 6: + if (lookahead == 'p') + ADVANCE(7); + LEX_ERROR(); + case 7: + if (lookahead == 'o') + ADVANCE(8); + LEX_ERROR(); + case 8: + if (lookahead == 'r') + ADVANCE(9); + LEX_ERROR(); + case 9: + if (lookahead == 't') + ADVANCE(10); + LEX_ERROR(); + case 10: + ACCEPT_TOKEN(ts_sym__import); + case 11: + if (lookahead == 'y') + ADVANCE(12); + LEX_ERROR(); + case 12: + if (lookahead == 'p') + ADVANCE(13); + LEX_ERROR(); + case 13: + if (lookahead == 'e') + ADVANCE(14); + LEX_ERROR(); + case 14: + ACCEPT_TOKEN(ts_sym__type); + case 15: + if (lookahead == 'a') + ADVANCE(16); + LEX_ERROR(); + case 16: + if (lookahead == 'r') + ADVANCE(17); + LEX_ERROR(); + case 17: + ACCEPT_TOKEN(ts_sym__var); + case 18: + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) + ADVANCE(19); + LEX_ERROR(); + case 19: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + ACCEPT_TOKEN(ts_sym__identifier); + case 20: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + ACCEPT_TOKEN(ts_sym__identifier); + case 21: + if (lookahead == '\"') + ADVANCE(22); + if (lookahead == ')') + ADVANCE(32); + LEX_ERROR(); + case 22: + if (!((lookahead == '\"') || + (lookahead == '\\'))) + ADVANCE(23); + if (lookahead == '\\') + ADVANCE(29); + if (']' <= lookahead && lookahead <= '\\') + ADVANCE(31); + LEX_ERROR(); + case 23: + if (!((lookahead == '\"') || + (lookahead == '\\'))) + ADVANCE(24); + if (lookahead == '\"') + ADVANCE(25); + if (lookahead == '\\') + ADVANCE(26); + if (']' <= lookahead && lookahead <= '\\') + ADVANCE(28); + LEX_ERROR(); + case 24: + if (!((lookahead == '\"') || + (lookahead == '\\'))) + ADVANCE(24); + if (lookahead == '\"') + ADVANCE(25); + if (lookahead == '\\') + ADVANCE(26); + if (']' <= lookahead && lookahead <= '\\') + ADVANCE(28); + LEX_ERROR(); + case 25: + ACCEPT_TOKEN(ts_sym_string); + case 26: + if (!((lookahead == '\"') || + (lookahead == '\\'))) + ADVANCE(24); + if (lookahead == '\"') + ADVANCE(27); + if ('#' <= lookahead && lookahead <= '\"') + ADVANCE(24); + if (lookahead == '\\') + ADVANCE(26); + if (']' <= lookahead && lookahead <= '\\') + ADVANCE(28); + LEX_ERROR(); + case 27: + if (!((lookahead == '\"') || + (lookahead == '\\'))) + ADVANCE(24); + if (lookahead == '\"') + ADVANCE(25); + if (lookahead == '\\') + ADVANCE(26); + if (']' <= lookahead && lookahead <= '\\') + ADVANCE(28); + ACCEPT_TOKEN(ts_sym_string); + case 28: + if (lookahead == '\"') + ADVANCE(24); + LEX_ERROR(); + case 29: + if (!((lookahead == '\"') || + (lookahead == '\\'))) + ADVANCE(24); + if (lookahead == '\"') + ADVANCE(30); + if ('#' <= lookahead && lookahead <= '\"') + ADVANCE(23); + if (lookahead == '\\') + ADVANCE(26); + if (']' <= lookahead && lookahead <= '\\') + ADVANCE(28); + LEX_ERROR(); + case 30: + if (!((lookahead == '\"') || + (lookahead == '\\'))) + ADVANCE(24); + if (lookahead == '\"') + ADVANCE(25); + if (lookahead == '\\') + ADVANCE(26); + if (']' <= lookahead && lookahead <= '\\') + ADVANCE(28); + ACCEPT_TOKEN(ts_sym_string); + case 31: + if (lookahead == '\"') + ADVANCE(23); + LEX_ERROR(); + case 32: + ACCEPT_TOKEN(ts_aux_sym_token2); + case 33: + if (lookahead == ')') + ADVANCE(32); + LEX_ERROR(); + case 34: + if (lookahead == '\"') + ADVANCE(22); + if (lookahead == '(') + ADVANCE(35); + LEX_ERROR(); + case 35: + ACCEPT_TOKEN(ts_aux_sym_token1); + case 36: + if (lookahead == 'f') + ADVANCE(1); + if (lookahead == 't') + ADVANCE(11); + if (lookahead == 'v') + ADVANCE(15); + LEX_ERROR(); + case 37: + if (lookahead == '(') + ADVANCE(35); + LEX_ERROR(); + case 38: + if (lookahead == '}') + ADVANCE(39); + LEX_ERROR(); + case 39: + ACCEPT_TOKEN(ts_aux_sym_token5); + case 40: + if (lookahead == '{') + ADVANCE(41); + LEX_ERROR(); + case 41: + ACCEPT_TOKEN(ts_aux_sym_token4); + case 42: + if (lookahead == ')') + ADVANCE(32); + if (lookahead == '*') + ADVANCE(52); + if (lookahead == ',') + ADVANCE(53); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'h') || + ('j' <= lookahead && lookahead <= 'l') || + ('n' <= lookahead && lookahead <= 'r') || + ('t' <= lookahead && lookahead <= 'z')) + ADVANCE(19); + if (lookahead == '[') + ADVANCE(54); + if (lookahead == 'i') + ADVANCE(55); + if (lookahead == 'm') + ADVANCE(64); + if (lookahead == 's') + ADVANCE(69); + LEX_ERROR(); + case 43: + if (lookahead == 'n') + ADVANCE(44); + LEX_ERROR(); + case 44: + if (lookahead == 't') + ADVANCE(45); + LEX_ERROR(); + case 45: + if (lookahead == 'e') + ADVANCE(46); + LEX_ERROR(); + case 46: + if (lookahead == 'r') + ADVANCE(47); + LEX_ERROR(); + case 47: + if (lookahead == 'f') + ADVANCE(48); + LEX_ERROR(); + case 48: + if (lookahead == 'a') + ADVANCE(49); + LEX_ERROR(); + case 49: + if (lookahead == 'c') + ADVANCE(50); + LEX_ERROR(); + case 50: + if (lookahead == 'e') + ADVANCE(51); + LEX_ERROR(); + case 51: + ACCEPT_TOKEN(ts_sym__interface); + case 52: + ACCEPT_TOKEN(ts_aux_sym_token6); + case 53: + ACCEPT_TOKEN(ts_aux_sym_token9); + case 54: + ACCEPT_TOKEN(ts_aux_sym_token7); + case 55: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'm') || + ('o' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'n') + ADVANCE(56); + ACCEPT_TOKEN(ts_sym__identifier); + case 56: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 's') || + ('u' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 't') + ADVANCE(57); + ACCEPT_TOKEN(ts_sym__identifier); + case 57: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'd') || + ('f' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'e') + ADVANCE(58); + ACCEPT_TOKEN(ts_sym__identifier); + case 58: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'q') || + ('s' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'r') + ADVANCE(59); + ACCEPT_TOKEN(ts_sym__identifier); + case 59: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'e') || + ('g' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'f') + ADVANCE(60); + ACCEPT_TOKEN(ts_sym__identifier); + case 60: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('b' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'a') + ADVANCE(61); + ACCEPT_TOKEN(ts_sym__identifier); + case 61: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'b') || + ('d' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'c') + ADVANCE(62); + ACCEPT_TOKEN(ts_sym__identifier); + case 62: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'd') || + ('f' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'e') + ADVANCE(63); + ACCEPT_TOKEN(ts_sym__identifier); + case 63: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + ACCEPT_TOKEN(ts_sym__interface); + case 64: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('b' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'a') + ADVANCE(67); + ACCEPT_TOKEN(ts_sym__identifier); + case 65: + if (lookahead == 'p') + ADVANCE(66); + LEX_ERROR(); + case 66: + ACCEPT_TOKEN(ts_sym__map); + case 67: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'o') || + ('q' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'p') + ADVANCE(68); + ACCEPT_TOKEN(ts_sym__identifier); + case 68: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + ACCEPT_TOKEN(ts_sym__map); + case 69: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 's') || + ('u' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 't') + ADVANCE(75); + ACCEPT_TOKEN(ts_sym__identifier); + case 70: + if (lookahead == 'r') + ADVANCE(71); + LEX_ERROR(); + case 71: + if (lookahead == 'u') + ADVANCE(72); + LEX_ERROR(); + case 72: + if (lookahead == 'c') + ADVANCE(73); + LEX_ERROR(); + case 73: + if (lookahead == 't') + ADVANCE(74); + LEX_ERROR(); + case 74: + ACCEPT_TOKEN(ts_sym__struct); + case 75: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'q') || + ('s' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'r') + ADVANCE(76); + ACCEPT_TOKEN(ts_sym__identifier); + case 76: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 't') || + ('v' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'u') + ADVANCE(77); + ACCEPT_TOKEN(ts_sym__identifier); + case 77: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'b') || + ('d' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'c') + ADVANCE(78); + ACCEPT_TOKEN(ts_sym__identifier); + case 78: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 's') || + ('u' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 't') + ADVANCE(79); + ACCEPT_TOKEN(ts_sym__identifier); + case 79: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + ACCEPT_TOKEN(ts_sym__struct); + case 80: + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) + ADVANCE(19); + if (lookahead == '}') + ADVANCE(39); + LEX_ERROR(); + case 81: + if (lookahead == ']') + ADVANCE(82); + LEX_ERROR(); + case 82: + ACCEPT_TOKEN(ts_aux_sym_token8); + case 83: + if (lookahead == '*') + ADVANCE(52); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'h') || + ('j' <= lookahead && lookahead <= 'l') || + ('n' <= lookahead && lookahead <= 'r') || + ('t' <= lookahead && lookahead <= 'z')) + ADVANCE(19); + if (lookahead == '[') + ADVANCE(54); + if (lookahead == 'i') + ADVANCE(55); + if ('j' <= lookahead && lookahead <= 'i') + ADVANCE(43); + if (lookahead == 'm') + ADVANCE(64); + if ('n' <= lookahead && lookahead <= 'm') + ADVANCE(84); + if (lookahead == 's') + ADVANCE(69); + if ('t' <= lookahead && lookahead <= 's') + ADVANCE(85); + LEX_ERROR(); + case 84: + if (lookahead == 'a') + ADVANCE(65); + LEX_ERROR(); + case 85: + if (lookahead == 't') + ADVANCE(70); + LEX_ERROR(); + case 86: + if (lookahead == '[') + ADVANCE(54); + LEX_ERROR(); + case 87: + if (lookahead == ')') + ADVANCE(32); + if (lookahead == ',') + ADVANCE(53); + LEX_ERROR(); + case 88: + if (lookahead == ')') + ADVANCE(32); + if (lookahead == ',') + ADVANCE(53); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) + ADVANCE(19); + LEX_ERROR(); + case 89: + if (lookahead == ')') + ADVANCE(32); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) + ADVANCE(19); + LEX_ERROR(); + case 90: + if (lookahead == '(') + ADVANCE(35); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) + ADVANCE(19); + if (lookahead == '}') + ADVANCE(39); + LEX_ERROR(); + case 91: + if (lookahead == '*') + ADVANCE(52); + if (lookahead == ',') + ADVANCE(53); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'h') || + ('j' <= lookahead && lookahead <= 'l') || + ('n' <= lookahead && lookahead <= 'r') || + ('t' <= lookahead && lookahead <= 'z')) + ADVANCE(19); + if (lookahead == '[') + ADVANCE(54); + if (lookahead == 'i') + ADVANCE(55); + if ('j' <= lookahead && lookahead <= 'i') + ADVANCE(43); + if (lookahead == 'm') + ADVANCE(64); + if ('n' <= lookahead && lookahead <= 'm') + ADVANCE(84); + if (lookahead == 's') + ADVANCE(69); + if ('t' <= lookahead && lookahead <= 's') + ADVANCE(85); + LEX_ERROR(); + case 92: + if (lookahead == ')') + ADVANCE(32); + if (lookahead == '*') + ADVANCE(52); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'h') || + ('j' <= lookahead && lookahead <= 'l') || + ('n' <= lookahead && lookahead <= 'r') || + ('t' <= lookahead && lookahead <= 'z')) + ADVANCE(19); + if (lookahead == '[') + ADVANCE(54); + if (lookahead == 'i') + ADVANCE(55); + if (lookahead == 'm') + ADVANCE(64); + if (lookahead == 's') + ADVANCE(69); + LEX_ERROR(); + case 93: + if (lookahead == '(') + ADVANCE(35); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) + ADVANCE(19); + if (lookahead == '{') + ADVANCE(41); + LEX_ERROR(); + case 94: + if (lookahead == '=') + ADVANCE(95); + LEX_ERROR(); + case 95: + ACCEPT_TOKEN(ts_aux_sym_token3); + case 96: + if ('0' <= lookahead && lookahead <= '9') + ADVANCE(97); + LEX_ERROR(); + case 97: + if (lookahead == '.') + ADVANCE(98); + if ('0' <= lookahead && lookahead <= '9') + ADVANCE(101); + ACCEPT_TOKEN(ts_sym_number); + case 98: + if ('0' <= lookahead && lookahead <= '9') + ADVANCE(99); + LEX_ERROR(); + case 99: + if ('0' <= lookahead && lookahead <= '9') + ADVANCE(100); + ACCEPT_TOKEN(ts_sym_number); + case 100: + if ('0' <= lookahead && lookahead <= '9') + ADVANCE(100); + ACCEPT_TOKEN(ts_sym_number); + case 101: + if (lookahead == '.') + ADVANCE(98); + if ('0' <= lookahead && lookahead <= '9') + ADVANCE(101); + ACCEPT_TOKEN(ts_sym_number); + case 102: + LEX_ERROR(); + case 103: + if (lookahead == 'p') + ADVANCE(104); + LEX_ERROR(); + case 104: + if (lookahead == 'a') + ADVANCE(105); + LEX_ERROR(); + case 105: + if (lookahead == 'c') + ADVANCE(106); + LEX_ERROR(); + case 106: + if (lookahead == 'k') + ADVANCE(107); + LEX_ERROR(); + case 107: + if (lookahead == 'a') + ADVANCE(108); + LEX_ERROR(); + case 108: + if (lookahead == 'g') + ADVANCE(109); + LEX_ERROR(); + case 109: + if (lookahead == 'e') + ADVANCE(110); + LEX_ERROR(); + case 110: + ACCEPT_TOKEN(ts_sym__package); + case 111: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 't') || + ('v' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'u') + ADVANCE(112); + if ('v' <= lookahead && lookahead <= 'u') + ADVANCE(2); + ACCEPT_TOKEN(ts_sym__identifier); + case 112: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'm') || + ('o' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'n') + ADVANCE(113); + if ('o' <= lookahead && lookahead <= 'n') + ADVANCE(3); + ACCEPT_TOKEN(ts_sym__identifier); + case 113: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'b') || + ('d' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'c') + ADVANCE(114); + if ('d' <= lookahead && lookahead <= 'c') + ADVANCE(4); + ACCEPT_TOKEN(ts_sym__identifier); + case 114: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + ACCEPT_TOKEN(ts_sym__func); + case 115: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'l') || + ('o' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'm') + ADVANCE(116); + if ('n' <= lookahead && lookahead <= 'm') + ADVANCE(6); + if (lookahead == 'n') + ADVANCE(56); + if ('o' <= lookahead && lookahead <= 'n') + ADVANCE(44); + ACCEPT_TOKEN(ts_sym__identifier); + case 116: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'o') || + ('q' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'p') + ADVANCE(117); + if ('q' <= lookahead && lookahead <= 'p') + ADVANCE(7); + ACCEPT_TOKEN(ts_sym__identifier); + case 117: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'n') || + ('p' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'o') + ADVANCE(118); + if ('p' <= lookahead && lookahead <= 'o') + ADVANCE(8); + ACCEPT_TOKEN(ts_sym__identifier); + case 118: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'q') || + ('s' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'r') + ADVANCE(119); + if ('s' <= lookahead && lookahead <= 'r') + ADVANCE(9); + ACCEPT_TOKEN(ts_sym__identifier); + case 119: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 's') || + ('u' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 't') + ADVANCE(120); + if ('u' <= lookahead && lookahead <= 't') + ADVANCE(10); + ACCEPT_TOKEN(ts_sym__identifier); + case 120: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + ACCEPT_TOKEN(ts_sym__import); + case 121: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('b' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'a') + ADVANCE(122); + if ('b' <= lookahead && lookahead <= 'a') + ADVANCE(105); + ACCEPT_TOKEN(ts_sym__identifier); + case 122: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'b') || + ('d' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'c') + ADVANCE(123); + if ('d' <= lookahead && lookahead <= 'c') + ADVANCE(106); + ACCEPT_TOKEN(ts_sym__identifier); + case 123: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'j') || + ('l' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'k') + ADVANCE(124); + if ('l' <= lookahead && lookahead <= 'k') + ADVANCE(107); + ACCEPT_TOKEN(ts_sym__identifier); + case 124: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('b' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'a') + ADVANCE(125); + if ('b' <= lookahead && lookahead <= 'a') + ADVANCE(108); + ACCEPT_TOKEN(ts_sym__identifier); + case 125: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'f') || + ('h' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'g') + ADVANCE(126); + if ('h' <= lookahead && lookahead <= 'g') + ADVANCE(109); + ACCEPT_TOKEN(ts_sym__identifier); + case 126: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'd') || + ('f' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'e') + ADVANCE(127); + if ('f' <= lookahead && lookahead <= 'e') + ADVANCE(110); + ACCEPT_TOKEN(ts_sym__identifier); + case 127: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + ACCEPT_TOKEN(ts_sym__package); + case 128: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'x') || + (lookahead == 'z')) + ADVANCE(20); + if (lookahead == 'y') + ADVANCE(129); + if ('z' <= lookahead && lookahead <= 'y') + ADVANCE(12); + ACCEPT_TOKEN(ts_sym__identifier); + case 129: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'o') || + ('q' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'p') + ADVANCE(130); + if ('q' <= lookahead && lookahead <= 'p') + ADVANCE(13); + ACCEPT_TOKEN(ts_sym__identifier); + case 130: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'd') || + ('f' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'e') + ADVANCE(131); + if ('f' <= lookahead && lookahead <= 'e') + ADVANCE(14); + ACCEPT_TOKEN(ts_sym__identifier); + case 131: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + ACCEPT_TOKEN(ts_sym__type); + case 132: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('b' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'a') + ADVANCE(133); + ACCEPT_TOKEN(ts_sym__identifier); + case 133: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'q') || + ('s' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + if (lookahead == 'r') + ADVANCE(134); + ACCEPT_TOKEN(ts_sym__identifier); + case 134: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'z')) + ADVANCE(20); + ACCEPT_TOKEN(ts_sym__var); + case ts_lex_state_error: + if (lookahead == '\"') + ADVANCE(22); + if (lookahead == '(') + ADVANCE(35); + if (lookahead == ')') + ADVANCE(32); + if (lookahead == '*') + ADVANCE(52); + if (lookahead == ',') + ADVANCE(53); + if ('0' <= lookahead && lookahead <= '9') + ADVANCE(97); + if (lookahead == '=') + ADVANCE(95); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'e') || + ('g' <= lookahead && lookahead <= 'h') || + ('j' <= lookahead && lookahead <= 'l') || + ('n' <= lookahead && lookahead <= 'o') || + ('q' <= lookahead && lookahead <= 'r') || + (lookahead == 'u') || + ('w' <= lookahead && lookahead <= 'z')) + ADVANCE(19); + if (lookahead == '[') + ADVANCE(54); + if (lookahead == ']') + ADVANCE(82); + if (lookahead == 'f') + ADVANCE(111); + if ('g' <= lookahead && lookahead <= 'f') + ADVANCE(1); + if (lookahead == 'i') + ADVANCE(115); + if ('j' <= lookahead && lookahead <= 'i') + ADVANCE(43); + if (lookahead == 'm') + ADVANCE(64); + if ('n' <= lookahead && lookahead <= 'm') + ADVANCE(84); + if (lookahead == 'p') + ADVANCE(121); + if ('q' <= lookahead && lookahead <= 'p') + ADVANCE(104); + if (lookahead == 's') + ADVANCE(69); + if ('t' <= lookahead && lookahead <= 's') + ADVANCE(85); + if (lookahead == 't') + ADVANCE(128); + if ('u' <= lookahead && lookahead <= 't') + ADVANCE(11); + if (lookahead == 'v') + ADVANCE(132); + if ('w' <= lookahead && lookahead <= 'v') + ADVANCE(15); + if (lookahead == '{') + ADVANCE(41); + if (lookahead == '}') + ADVANCE(39); + LEX_ERROR(); + default: + LEX_PANIC(); + } +} + +LEX_STATES = { + [0] = 103, + [1] = 18, + [2] = 0, + [3] = 0, + [4] = 0, + [5] = 34, + [6] = 0, + [7] = 0, + [8] = 21, + [9] = 21, + [10] = 21, + [11] = 33, + [12] = 33, + [13] = 0, + [14] = 0, + [15] = 36, + [16] = 36, + [17] = 18, + [18] = 37, + [19] = 37, + [20] = 40, + [21] = 36, + [22] = 38, + [23] = 36, + [24] = 92, + [25] = 42, + [26] = 40, + [27] = 80, + [28] = 37, + [29] = 80, + [30] = 38, + [31] = 92, + [32] = 86, + [33] = 83, + [34] = 81, + [35] = 40, + [36] = 80, + [37] = 38, + [38] = 81, + [39] = 86, + [40] = 83, + [41] = 40, + [42] = 80, + [43] = 83, + [44] = 83, + [45] = 80, + [46] = 40, + [47] = 80, + [48] = 38, + [49] = 80, + [50] = 86, + [51] = 83, + [52] = 81, + [53] = 81, + [54] = 83, + [55] = 40, + [56] = 80, + [57] = 38, + [58] = 80, + [59] = 80, + [60] = 80, + [61] = 83, + [62] = 80, + [63] = 81, + [64] = 83, + [65] = 80, + [66] = 83, + [67] = 81, + [68] = 81, + [69] = 83, + [70] = 81, + [71] = 80, + [72] = 38, + [73] = 38, + [74] = 81, + [75] = 81, + [76] = 83, + [77] = 81, + [78] = 81, + [79] = 83, + [80] = 87, + [81] = 40, + [82] = 80, + [83] = 38, + [84] = 87, + [85] = 87, + [86] = 87, + [87] = 83, + [88] = 87, + [89] = 81, + [90] = 83, + [91] = 87, + [92] = 87, + [93] = 33, + [94] = 90, + [95] = 80, + [96] = 89, + [97] = 88, + [98] = 87, + [99] = 33, + [100] = 80, + [101] = 18, + [102] = 87, + [103] = 33, + [104] = 18, + [105] = 87, + [106] = 33, + [107] = 80, + [108] = 18, + [109] = 18, + [110] = 18, + [111] = 87, + [112] = 33, + [113] = 80, + [114] = 83, + [115] = 87, + [116] = 33, + [117] = 91, + [118] = 83, + [119] = 87, + [120] = 33, + [121] = 18, + [122] = 91, + [123] = 91, + [124] = 83, + [125] = 91, + [126] = 83, + [127] = 87, + [128] = 33, + [129] = 90, + [130] = 80, + [131] = 89, + [132] = 87, + [133] = 33, + [134] = 80, + [135] = 18, + [136] = 87, + [137] = 33, + [138] = 80, + [139] = 18, + [140] = 91, + [141] = 83, + [142] = 90, + [143] = 80, + [144] = 89, + [145] = 87, + [146] = 33, + [147] = 18, + [148] = 87, + [149] = 33, + [150] = 80, + [151] = 38, + [152] = 87, + [153] = 87, + [154] = 33, + [155] = 93, + [156] = 40, + [157] = 40, + [158] = 89, + [159] = 87, + [160] = 33, + [161] = 40, + [162] = 18, + [163] = 87, + [164] = 33, + [165] = 40, + [166] = 40, + [167] = 91, + [168] = 83, + [169] = 87, + [170] = 33, + [171] = 93, + [172] = 40, + [173] = 89, + [174] = 87, + [175] = 33, + [176] = 40, + [177] = 18, + [178] = 87, + [179] = 33, + [180] = 40, + [181] = 93, + [182] = 40, + [183] = 89, + [184] = 87, + [185] = 33, + [186] = 18, + [187] = 87, + [188] = 33, + [189] = 40, + [190] = 18, + [191] = 83, + [192] = 83, + [193] = 36, + [194] = 40, + [195] = 80, + [196] = 38, + [197] = 36, + [198] = 86, + [199] = 83, + [200] = 81, + [201] = 83, + [202] = 40, + [203] = 80, + [204] = 38, + [205] = 36, + [206] = 36, + [207] = 36, + [208] = 83, + [209] = 36, + [210] = 81, + [211] = 83, + [212] = 36, + [213] = 36, + [214] = 18, + [215] = 94, + [216] = 94, + [217] = 96, + [218] = 36, + [219] = 36, + [220] = 36, + [221] = 36, + [222] = 102, + [223] = 102, + [224] = 102, +}; + +PARSE_TABLE = { + [0] = { + [ts_sym__package] = SHIFT(1), + [ts_sym_package_directive] = SHIFT(4), + [ts_sym_program] = SHIFT(224), + }, + + [1] = { + [ts_sym__identifier] = SHIFT(2), + [ts_sym_package_name] = SHIFT(3), + }, + + [2] = { + [ts_sym__func] = REDUCE(ts_sym_package_name, 1), + [ts_sym__import] = REDUCE(ts_sym_package_name, 1), + [ts_sym__type] = REDUCE(ts_sym_package_name, 1), + [ts_sym__var] = REDUCE(ts_sym_package_name, 1), + [ts_builtin_sym_end] = REDUCE(ts_sym_package_name, 1), + }, + + [3] = { + [ts_sym__func] = REDUCE(ts_sym_package_directive, 2), + [ts_sym__import] = REDUCE(ts_sym_package_directive, 2), + [ts_sym__type] = REDUCE(ts_sym_package_directive, 2), + [ts_sym__var] = REDUCE(ts_sym_package_directive, 2), + [ts_builtin_sym_end] = REDUCE(ts_sym_package_directive, 2), + }, + + [4] = { + [ts_sym__func] = REDUCE(ts_aux_sym_repeat_helper1, 0), + [ts_sym__import] = SHIFT(5), + [ts_sym__type] = REDUCE(ts_aux_sym_repeat_helper1, 0), + [ts_sym__var] = REDUCE(ts_aux_sym_repeat_helper1, 0), + [ts_sym_imports_block] = SHIFT(14), + [ts_aux_sym_repeat_helper1] = SHIFT(16), + [ts_builtin_sym_end] = REDUCE(ts_aux_sym_repeat_helper1, 0), + }, + + [5] = { + [ts_sym_package_import] = SHIFT(6), + [ts_sym_string] = SHIFT(7), + [ts_aux_sym_token1] = SHIFT(8), + }, + + [6] = { + [ts_sym__func] = REDUCE(ts_sym_imports_block, 2), + [ts_sym__import] = REDUCE(ts_sym_imports_block, 2), + [ts_sym__type] = REDUCE(ts_sym_imports_block, 2), + [ts_sym__var] = REDUCE(ts_sym_imports_block, 2), + [ts_builtin_sym_end] = REDUCE(ts_sym_imports_block, 2), + }, + + [7] = { + [ts_sym__func] = REDUCE(ts_sym_package_import, 1), + [ts_sym__import] = REDUCE(ts_sym_package_import, 1), + [ts_sym__type] = REDUCE(ts_sym_package_import, 1), + [ts_sym__var] = REDUCE(ts_sym_package_import, 1), + [ts_builtin_sym_end] = REDUCE(ts_sym_package_import, 1), + }, + + [8] = { + [ts_sym_package_import] = SHIFT(9), + [ts_sym_string] = SHIFT(10), + [ts_aux_sym_repeat_helper3] = SHIFT(12), + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper3, 0), + [ts_builtin_sym_error] = SHIFT(12), + }, + + [9] = { + [ts_sym_package_import] = SHIFT(9), + [ts_sym_string] = SHIFT(10), + [ts_aux_sym_repeat_helper3] = SHIFT(11), + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper3, 0), + }, + + [10] = { + [ts_sym_string] = REDUCE(ts_sym_package_import, 1), + [ts_aux_sym_token2] = REDUCE(ts_sym_package_import, 1), + }, + + [11] = { + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper3, 2), + }, + + [12] = { + [ts_aux_sym_token2] = SHIFT(13), + }, + + [13] = { + [ts_sym__func] = REDUCE(ts_sym_imports_block, 4), + [ts_sym__import] = REDUCE(ts_sym_imports_block, 4), + [ts_sym__type] = REDUCE(ts_sym_imports_block, 4), + [ts_sym__var] = REDUCE(ts_sym_imports_block, 4), + [ts_builtin_sym_end] = REDUCE(ts_sym_imports_block, 4), + }, + + [14] = { + [ts_sym__func] = REDUCE(ts_aux_sym_repeat_helper1, 0), + [ts_sym__import] = SHIFT(5), + [ts_sym__type] = REDUCE(ts_aux_sym_repeat_helper1, 0), + [ts_sym__var] = REDUCE(ts_aux_sym_repeat_helper1, 0), + [ts_sym_imports_block] = SHIFT(14), + [ts_aux_sym_repeat_helper1] = SHIFT(15), + [ts_builtin_sym_end] = REDUCE(ts_aux_sym_repeat_helper1, 0), + }, + + [15] = { + [ts_sym__func] = REDUCE(ts_aux_sym_repeat_helper1, 2), + [ts_sym__type] = REDUCE(ts_aux_sym_repeat_helper1, 2), + [ts_sym__var] = REDUCE(ts_aux_sym_repeat_helper1, 2), + [ts_builtin_sym_end] = REDUCE(ts_aux_sym_repeat_helper1, 2), + }, + + [16] = { + [ts_sym__func] = SHIFT(17), + [ts_sym__type] = SHIFT(190), + [ts_sym__var] = SHIFT(214), + [ts_sym_declaration] = SHIFT(220), + [ts_sym_func_declaration] = SHIFT(221), + [ts_sym_type_declaration] = SHIFT(221), + [ts_sym_var_declaration] = SHIFT(221), + [ts_aux_sym_repeat_helper2] = SHIFT(223), + [ts_builtin_sym_end] = REDUCE(ts_aux_sym_repeat_helper2, 0), + }, + + [17] = { + [ts_sym__identifier] = SHIFT(18), + [ts_sym_var_name] = SHIFT(19), + }, + + [18] = { + [ts_aux_sym_token1] = REDUCE(ts_sym_var_name, 1), + }, + + [19] = { + [ts_sym__func_signature] = SHIFT(20), + [ts_aux_sym_token1] = SHIFT(24), + }, + + [20] = { + [ts_sym_statement_block] = SHIFT(21), + [ts_aux_sym_token4] = SHIFT(22), + }, + + [21] = { + [ts_sym__func] = REDUCE(ts_sym_func_declaration, 4), + [ts_sym__type] = REDUCE(ts_sym_func_declaration, 4), + [ts_sym__var] = REDUCE(ts_sym_func_declaration, 4), + [ts_builtin_sym_end] = REDUCE(ts_sym_func_declaration, 4), + }, + + [22] = { + [ts_aux_sym_token5] = SHIFT(23), + }, + + [23] = { + [ts_sym__func] = REDUCE(ts_sym_statement_block, 2), + [ts_sym__type] = REDUCE(ts_sym_statement_block, 2), + [ts_sym__var] = REDUCE(ts_sym_statement_block, 2), + [ts_builtin_sym_end] = REDUCE(ts_sym_statement_block, 2), + }, + + [24] = { + [ts_sym__identifier] = SHIFT(25), + [ts_sym__interface] = SHIFT(26), + [ts_sym__map] = SHIFT(32), + [ts_sym__struct] = SHIFT(81), + [ts_sym_interface_type] = SHIFT(85), + [ts_sym_map_type] = SHIFT(85), + [ts_sym_pointer_type] = SHIFT(85), + [ts_sym_slice_type] = SHIFT(85), + [ts_sym_struct_type] = SHIFT(85), + [ts_sym_type_expression] = SHIFT(153), + [ts_sym_type_name] = SHIFT(85), + [ts_sym_var_name] = SHIFT(167), + [ts_aux_sym_token2] = SHIFT(181), + [ts_aux_sym_token6] = SHIFT(87), + [ts_aux_sym_token7] = SHIFT(89), + }, + + [25] = { + [ts_sym__identifier] = REDUCE(ts_sym_var_name, 1), + [ts_sym__interface] = REDUCE(ts_sym_var_name, 1), + [ts_sym__map] = REDUCE(ts_sym_var_name, 1), + [ts_sym__struct] = REDUCE(ts_sym_var_name, 1), + [ts_aux_sym_token2] = REDUCE(ts_sym_type_name, 1), + [ts_aux_sym_token6] = REDUCE(ts_sym_var_name, 1), + [ts_aux_sym_token7] = REDUCE(ts_sym_var_name, 1), + [ts_aux_sym_token9] = REDUCE(ts_sym_var_name, 1), + }, + + [26] = { + [ts_aux_sym_token4] = SHIFT(27), + }, + + [27] = { + [ts_sym__identifier] = SHIFT(18), + [ts_sym_var_name] = SHIFT(28), + [ts_aux_sym_repeat_helper5] = SHIFT(151), + [ts_aux_sym_token5] = REDUCE(ts_aux_sym_repeat_helper5, 0), + }, + + [28] = { + [ts_sym__func_signature] = SHIFT(29), + [ts_aux_sym_token1] = SHIFT(31), + }, + + [29] = { + [ts_sym__identifier] = SHIFT(18), + [ts_sym_var_name] = SHIFT(28), + [ts_aux_sym_repeat_helper5] = SHIFT(30), + [ts_aux_sym_token5] = REDUCE(ts_aux_sym_repeat_helper5, 0), + }, + + [30] = { + [ts_aux_sym_token5] = REDUCE(ts_aux_sym_repeat_helper5, 3), + }, + + [31] = { + [ts_sym__identifier] = SHIFT(25), + [ts_sym__interface] = SHIFT(26), + [ts_sym__map] = SHIFT(32), + [ts_sym__struct] = SHIFT(81), + [ts_sym_interface_type] = SHIFT(85), + [ts_sym_map_type] = SHIFT(85), + [ts_sym_pointer_type] = SHIFT(85), + [ts_sym_slice_type] = SHIFT(85), + [ts_sym_struct_type] = SHIFT(85), + [ts_sym_type_expression] = SHIFT(92), + [ts_sym_type_name] = SHIFT(85), + [ts_sym_var_name] = SHIFT(125), + [ts_aux_sym_token2] = SHIFT(142), + [ts_aux_sym_token6] = SHIFT(87), + [ts_aux_sym_token7] = SHIFT(89), + }, + + [32] = { + [ts_aux_sym_token7] = SHIFT(33), + }, + + [33] = { + [ts_sym__identifier] = SHIFT(34), + [ts_sym__interface] = SHIFT(35), + [ts_sym__map] = SHIFT(39), + [ts_sym__struct] = SHIFT(41), + [ts_sym_interface_type] = SHIFT(52), + [ts_sym_map_type] = SHIFT(52), + [ts_sym_pointer_type] = SHIFT(52), + [ts_sym_slice_type] = SHIFT(52), + [ts_sym_struct_type] = SHIFT(52), + [ts_sym_type_expression] = SHIFT(78), + [ts_sym_type_name] = SHIFT(52), + [ts_aux_sym_token6] = SHIFT(66), + [ts_aux_sym_token7] = SHIFT(68), + }, + + [34] = { + [ts_aux_sym_token8] = REDUCE(ts_sym_type_name, 1), + }, + + [35] = { + [ts_aux_sym_token4] = SHIFT(36), + }, + + [36] = { + [ts_sym__identifier] = SHIFT(18), + [ts_sym_var_name] = SHIFT(28), + [ts_aux_sym_repeat_helper5] = SHIFT(37), + [ts_aux_sym_token5] = REDUCE(ts_aux_sym_repeat_helper5, 0), + }, + + [37] = { + [ts_aux_sym_token5] = SHIFT(38), + }, + + [38] = { + [ts_aux_sym_token8] = REDUCE(ts_sym_interface_type, 4), + }, + + [39] = { + [ts_aux_sym_token7] = SHIFT(40), + }, + + [40] = { + [ts_sym__identifier] = SHIFT(34), + [ts_sym__interface] = SHIFT(35), + [ts_sym__map] = SHIFT(39), + [ts_sym__struct] = SHIFT(41), + [ts_sym_interface_type] = SHIFT(52), + [ts_sym_map_type] = SHIFT(52), + [ts_sym_pointer_type] = SHIFT(52), + [ts_sym_slice_type] = SHIFT(52), + [ts_sym_struct_type] = SHIFT(52), + [ts_sym_type_expression] = SHIFT(75), + [ts_sym_type_name] = SHIFT(52), + [ts_aux_sym_token6] = SHIFT(66), + [ts_aux_sym_token7] = SHIFT(68), + }, + + [41] = { + [ts_aux_sym_token4] = SHIFT(42), + }, + + [42] = { + [ts_sym__identifier] = SHIFT(43), + [ts_sym_var_name] = SHIFT(44), + [ts_aux_sym_repeat_helper4] = SHIFT(73), + [ts_aux_sym_token5] = REDUCE(ts_aux_sym_repeat_helper4, 0), + }, + + [43] = { + [ts_sym__identifier] = REDUCE(ts_sym_var_name, 1), + [ts_sym__interface] = REDUCE(ts_sym_var_name, 1), + [ts_sym__map] = REDUCE(ts_sym_var_name, 1), + [ts_sym__struct] = REDUCE(ts_sym_var_name, 1), + [ts_aux_sym_token6] = REDUCE(ts_sym_var_name, 1), + [ts_aux_sym_token7] = REDUCE(ts_sym_var_name, 1), + }, + + [44] = { + [ts_sym__identifier] = SHIFT(45), + [ts_sym__interface] = SHIFT(46), + [ts_sym__map] = SHIFT(50), + [ts_sym__struct] = SHIFT(55), + [ts_sym_interface_type] = SHIFT(59), + [ts_sym_map_type] = SHIFT(59), + [ts_sym_pointer_type] = SHIFT(59), + [ts_sym_slice_type] = SHIFT(59), + [ts_sym_struct_type] = SHIFT(59), + [ts_sym_type_expression] = SHIFT(71), + [ts_sym_type_name] = SHIFT(59), + [ts_aux_sym_token6] = SHIFT(61), + [ts_aux_sym_token7] = SHIFT(63), + }, + + [45] = { + [ts_sym__identifier] = REDUCE(ts_sym_type_name, 1), + [ts_aux_sym_token5] = REDUCE(ts_sym_type_name, 1), + }, + + [46] = { + [ts_aux_sym_token4] = SHIFT(47), + }, + + [47] = { + [ts_sym__identifier] = SHIFT(18), + [ts_sym_var_name] = SHIFT(28), + [ts_aux_sym_repeat_helper5] = SHIFT(48), + [ts_aux_sym_token5] = REDUCE(ts_aux_sym_repeat_helper5, 0), + }, + + [48] = { + [ts_aux_sym_token5] = SHIFT(49), + }, + + [49] = { + [ts_sym__identifier] = REDUCE(ts_sym_interface_type, 4), + [ts_aux_sym_token5] = REDUCE(ts_sym_interface_type, 4), + }, + + [50] = { + [ts_aux_sym_token7] = SHIFT(51), + }, + + [51] = { + [ts_sym__identifier] = SHIFT(34), + [ts_sym__interface] = SHIFT(35), + [ts_sym__map] = SHIFT(39), + [ts_sym__struct] = SHIFT(41), + [ts_sym_interface_type] = SHIFT(52), + [ts_sym_map_type] = SHIFT(52), + [ts_sym_pointer_type] = SHIFT(52), + [ts_sym_slice_type] = SHIFT(52), + [ts_sym_struct_type] = SHIFT(52), + [ts_sym_type_expression] = SHIFT(53), + [ts_sym_type_name] = SHIFT(52), + [ts_aux_sym_token6] = SHIFT(66), + [ts_aux_sym_token7] = SHIFT(68), + }, + + [52] = { + [ts_aux_sym_token8] = REDUCE(ts_sym_type_expression, 1), + }, + + [53] = { + [ts_aux_sym_token8] = SHIFT(54), + }, + + [54] = { + [ts_sym__identifier] = SHIFT(45), + [ts_sym__interface] = SHIFT(46), + [ts_sym__map] = SHIFT(50), + [ts_sym__struct] = SHIFT(55), + [ts_sym_interface_type] = SHIFT(59), + [ts_sym_map_type] = SHIFT(59), + [ts_sym_pointer_type] = SHIFT(59), + [ts_sym_slice_type] = SHIFT(59), + [ts_sym_struct_type] = SHIFT(59), + [ts_sym_type_expression] = SHIFT(60), + [ts_sym_type_name] = SHIFT(59), + [ts_aux_sym_token6] = SHIFT(61), + [ts_aux_sym_token7] = SHIFT(63), + }, + + [55] = { + [ts_aux_sym_token4] = SHIFT(56), + }, + + [56] = { + [ts_sym__identifier] = SHIFT(43), + [ts_sym_var_name] = SHIFT(44), + [ts_aux_sym_repeat_helper4] = SHIFT(57), + [ts_aux_sym_token5] = REDUCE(ts_aux_sym_repeat_helper4, 0), + }, + + [57] = { + [ts_aux_sym_token5] = SHIFT(58), + }, + + [58] = { + [ts_sym__identifier] = REDUCE(ts_sym_struct_type, 4), + [ts_aux_sym_token5] = REDUCE(ts_sym_struct_type, 4), + }, + + [59] = { + [ts_sym__identifier] = REDUCE(ts_sym_type_expression, 1), + [ts_aux_sym_token5] = REDUCE(ts_sym_type_expression, 1), + }, + + [60] = { + [ts_sym__identifier] = REDUCE(ts_sym_map_type, 5), + [ts_aux_sym_token5] = REDUCE(ts_sym_map_type, 5), + }, + + [61] = { + [ts_sym__identifier] = SHIFT(45), + [ts_sym__interface] = SHIFT(46), + [ts_sym__map] = SHIFT(50), + [ts_sym__struct] = SHIFT(55), + [ts_sym_interface_type] = SHIFT(59), + [ts_sym_map_type] = SHIFT(59), + [ts_sym_pointer_type] = SHIFT(59), + [ts_sym_slice_type] = SHIFT(59), + [ts_sym_struct_type] = SHIFT(59), + [ts_sym_type_expression] = SHIFT(62), + [ts_sym_type_name] = SHIFT(59), + [ts_aux_sym_token6] = SHIFT(61), + [ts_aux_sym_token7] = SHIFT(63), + }, + + [62] = { + [ts_sym__identifier] = REDUCE(ts_sym_pointer_type, 2), + [ts_aux_sym_token5] = REDUCE(ts_sym_pointer_type, 2), + }, + + [63] = { + [ts_aux_sym_token8] = SHIFT(64), + }, + + [64] = { + [ts_sym__identifier] = SHIFT(45), + [ts_sym__interface] = SHIFT(46), + [ts_sym__map] = SHIFT(50), + [ts_sym__struct] = SHIFT(55), + [ts_sym_interface_type] = SHIFT(59), + [ts_sym_map_type] = SHIFT(59), + [ts_sym_pointer_type] = SHIFT(59), + [ts_sym_slice_type] = SHIFT(59), + [ts_sym_struct_type] = SHIFT(59), + [ts_sym_type_expression] = SHIFT(65), + [ts_sym_type_name] = SHIFT(59), + [ts_aux_sym_token6] = SHIFT(61), + [ts_aux_sym_token7] = SHIFT(63), + }, + + [65] = { + [ts_sym__identifier] = REDUCE(ts_sym_slice_type, 3), + [ts_aux_sym_token5] = REDUCE(ts_sym_slice_type, 3), + }, + + [66] = { + [ts_sym__identifier] = SHIFT(34), + [ts_sym__interface] = SHIFT(35), + [ts_sym__map] = SHIFT(39), + [ts_sym__struct] = SHIFT(41), + [ts_sym_interface_type] = SHIFT(52), + [ts_sym_map_type] = SHIFT(52), + [ts_sym_pointer_type] = SHIFT(52), + [ts_sym_slice_type] = SHIFT(52), + [ts_sym_struct_type] = SHIFT(52), + [ts_sym_type_expression] = SHIFT(67), + [ts_sym_type_name] = SHIFT(52), + [ts_aux_sym_token6] = SHIFT(66), + [ts_aux_sym_token7] = SHIFT(68), + }, + + [67] = { + [ts_aux_sym_token8] = REDUCE(ts_sym_pointer_type, 2), + }, + + [68] = { + [ts_aux_sym_token8] = SHIFT(69), + }, + + [69] = { + [ts_sym__identifier] = SHIFT(34), + [ts_sym__interface] = SHIFT(35), + [ts_sym__map] = SHIFT(39), + [ts_sym__struct] = SHIFT(41), + [ts_sym_interface_type] = SHIFT(52), + [ts_sym_map_type] = SHIFT(52), + [ts_sym_pointer_type] = SHIFT(52), + [ts_sym_slice_type] = SHIFT(52), + [ts_sym_struct_type] = SHIFT(52), + [ts_sym_type_expression] = SHIFT(70), + [ts_sym_type_name] = SHIFT(52), + [ts_aux_sym_token6] = SHIFT(66), + [ts_aux_sym_token7] = SHIFT(68), + }, + + [70] = { + [ts_aux_sym_token8] = REDUCE(ts_sym_slice_type, 3), + }, + + [71] = { + [ts_sym__identifier] = SHIFT(43), + [ts_sym_var_name] = SHIFT(44), + [ts_aux_sym_repeat_helper4] = SHIFT(72), + [ts_aux_sym_token5] = REDUCE(ts_aux_sym_repeat_helper4, 0), + }, + + [72] = { + [ts_aux_sym_token5] = REDUCE(ts_aux_sym_repeat_helper4, 3), + }, + + [73] = { + [ts_aux_sym_token5] = SHIFT(74), + }, + + [74] = { + [ts_aux_sym_token8] = REDUCE(ts_sym_struct_type, 4), + }, + + [75] = { + [ts_aux_sym_token8] = SHIFT(76), + }, + + [76] = { + [ts_sym__identifier] = SHIFT(34), + [ts_sym__interface] = SHIFT(35), + [ts_sym__map] = SHIFT(39), + [ts_sym__struct] = SHIFT(41), + [ts_sym_interface_type] = SHIFT(52), + [ts_sym_map_type] = SHIFT(52), + [ts_sym_pointer_type] = SHIFT(52), + [ts_sym_slice_type] = SHIFT(52), + [ts_sym_struct_type] = SHIFT(52), + [ts_sym_type_expression] = SHIFT(77), + [ts_sym_type_name] = SHIFT(52), + [ts_aux_sym_token6] = SHIFT(66), + [ts_aux_sym_token7] = SHIFT(68), + }, + + [77] = { + [ts_aux_sym_token8] = REDUCE(ts_sym_map_type, 5), + }, + + [78] = { + [ts_aux_sym_token8] = SHIFT(79), + }, + + [79] = { + [ts_sym__identifier] = SHIFT(80), + [ts_sym__interface] = SHIFT(26), + [ts_sym__map] = SHIFT(32), + [ts_sym__struct] = SHIFT(81), + [ts_sym_interface_type] = SHIFT(85), + [ts_sym_map_type] = SHIFT(85), + [ts_sym_pointer_type] = SHIFT(85), + [ts_sym_slice_type] = SHIFT(85), + [ts_sym_struct_type] = SHIFT(85), + [ts_sym_type_expression] = SHIFT(86), + [ts_sym_type_name] = SHIFT(85), + [ts_aux_sym_token6] = SHIFT(87), + [ts_aux_sym_token7] = SHIFT(89), + }, + + [80] = { + [ts_aux_sym_token2] = REDUCE(ts_sym_type_name, 1), + [ts_aux_sym_token9] = REDUCE(ts_sym_type_name, 1), + }, + + [81] = { + [ts_aux_sym_token4] = SHIFT(82), + }, + + [82] = { + [ts_sym__identifier] = SHIFT(43), + [ts_sym_var_name] = SHIFT(44), + [ts_aux_sym_repeat_helper4] = SHIFT(83), + [ts_aux_sym_token5] = REDUCE(ts_aux_sym_repeat_helper4, 0), + }, + + [83] = { + [ts_aux_sym_token5] = SHIFT(84), + }, + + [84] = { + [ts_aux_sym_token2] = REDUCE(ts_sym_struct_type, 4), + [ts_aux_sym_token9] = REDUCE(ts_sym_struct_type, 4), + }, + + [85] = { + [ts_aux_sym_token2] = REDUCE(ts_sym_type_expression, 1), + [ts_aux_sym_token9] = REDUCE(ts_sym_type_expression, 1), + }, + + [86] = { + [ts_aux_sym_token2] = REDUCE(ts_sym_map_type, 5), + [ts_aux_sym_token9] = REDUCE(ts_sym_map_type, 5), + }, + + [87] = { + [ts_sym__identifier] = SHIFT(80), + [ts_sym__interface] = SHIFT(26), + [ts_sym__map] = SHIFT(32), + [ts_sym__struct] = SHIFT(81), + [ts_sym_interface_type] = SHIFT(85), + [ts_sym_map_type] = SHIFT(85), + [ts_sym_pointer_type] = SHIFT(85), + [ts_sym_slice_type] = SHIFT(85), + [ts_sym_struct_type] = SHIFT(85), + [ts_sym_type_expression] = SHIFT(88), + [ts_sym_type_name] = SHIFT(85), + [ts_aux_sym_token6] = SHIFT(87), + [ts_aux_sym_token7] = SHIFT(89), + }, + + [88] = { + [ts_aux_sym_token2] = REDUCE(ts_sym_pointer_type, 2), + [ts_aux_sym_token9] = REDUCE(ts_sym_pointer_type, 2), + }, + + [89] = { + [ts_aux_sym_token8] = SHIFT(90), + }, + + [90] = { + [ts_sym__identifier] = SHIFT(80), + [ts_sym__interface] = SHIFT(26), + [ts_sym__map] = SHIFT(32), + [ts_sym__struct] = SHIFT(81), + [ts_sym_interface_type] = SHIFT(85), + [ts_sym_map_type] = SHIFT(85), + [ts_sym_pointer_type] = SHIFT(85), + [ts_sym_slice_type] = SHIFT(85), + [ts_sym_struct_type] = SHIFT(85), + [ts_sym_type_expression] = SHIFT(91), + [ts_sym_type_name] = SHIFT(85), + [ts_aux_sym_token6] = SHIFT(87), + [ts_aux_sym_token7] = SHIFT(89), + }, + + [91] = { + [ts_aux_sym_token2] = REDUCE(ts_sym_slice_type, 3), + [ts_aux_sym_token9] = REDUCE(ts_sym_slice_type, 3), + }, + + [92] = { + [ts_aux_sym_repeat_helper8] = SHIFT(93), + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper8, 0), + [ts_aux_sym_token9] = SHIFT(114), + }, + + [93] = { + [ts_aux_sym_token2] = SHIFT(94), + }, + + [94] = { + [ts_sym__identifier] = SHIFT(45), + [ts_sym_type_name] = SHIFT(95), + [ts_aux_sym_token1] = SHIFT(96), + [ts_aux_sym_token5] = REDUCE(ts_sym__func_signature, 4), + }, + + [95] = { + [ts_sym__identifier] = REDUCE(ts_sym__func_signature, 5), + [ts_aux_sym_token5] = REDUCE(ts_sym__func_signature, 5), + }, + + [96] = { + [ts_sym__identifier] = SHIFT(97), + [ts_sym_type_name] = SHIFT(98), + [ts_sym_var_name] = SHIFT(104), + [ts_aux_sym_token2] = SHIFT(113), + }, + + [97] = { + [ts_sym__identifier] = REDUCE(ts_sym_var_name, 1), + [ts_aux_sym_token2] = REDUCE(ts_sym_type_name, 1), + [ts_aux_sym_token9] = REDUCE(ts_sym_type_name, 1), + }, + + [98] = { + [ts_aux_sym_repeat_helper10] = SHIFT(99), + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper10, 0), + [ts_aux_sym_token9] = SHIFT(101), + }, + + [99] = { + [ts_aux_sym_token2] = SHIFT(100), + }, + + [100] = { + [ts_sym__identifier] = REDUCE(ts_sym__func_signature, 8), + [ts_aux_sym_token5] = REDUCE(ts_sym__func_signature, 8), + }, + + [101] = { + [ts_sym__identifier] = SHIFT(80), + [ts_sym_type_name] = SHIFT(102), + }, + + [102] = { + [ts_aux_sym_repeat_helper10] = SHIFT(103), + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper10, 0), + [ts_aux_sym_token9] = SHIFT(101), + }, + + [103] = { + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper10, 3), + }, + + [104] = { + [ts_sym__identifier] = SHIFT(80), + [ts_sym_type_name] = SHIFT(105), + }, + + [105] = { + [ts_aux_sym_repeat_helper9] = SHIFT(106), + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper9, 0), + [ts_aux_sym_token9] = SHIFT(108), + }, + + [106] = { + [ts_aux_sym_token2] = SHIFT(107), + }, + + [107] = { + [ts_sym__identifier] = REDUCE(ts_sym__func_signature, 9), + [ts_aux_sym_token5] = REDUCE(ts_sym__func_signature, 9), + }, + + [108] = { + [ts_sym__identifier] = SHIFT(109), + [ts_sym_var_name] = SHIFT(110), + }, + + [109] = { + [ts_sym__identifier] = REDUCE(ts_sym_var_name, 1), + }, + + [110] = { + [ts_sym__identifier] = SHIFT(80), + [ts_sym_type_name] = SHIFT(111), + }, + + [111] = { + [ts_aux_sym_repeat_helper9] = SHIFT(112), + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper9, 0), + [ts_aux_sym_token9] = SHIFT(108), + }, + + [112] = { + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper9, 4), + }, + + [113] = { + [ts_sym__identifier] = REDUCE(ts_sym__func_signature, 6), + [ts_aux_sym_token5] = REDUCE(ts_sym__func_signature, 6), + }, + + [114] = { + [ts_sym__identifier] = SHIFT(25), + [ts_sym__interface] = SHIFT(26), + [ts_sym__map] = SHIFT(32), + [ts_sym__struct] = SHIFT(81), + [ts_sym_interface_type] = SHIFT(85), + [ts_sym_map_type] = SHIFT(85), + [ts_sym_pointer_type] = SHIFT(85), + [ts_sym_slice_type] = SHIFT(85), + [ts_sym_struct_type] = SHIFT(85), + [ts_sym_type_expression] = SHIFT(115), + [ts_sym_type_name] = SHIFT(85), + [ts_sym_var_name] = SHIFT(117), + [ts_aux_sym_token6] = SHIFT(87), + [ts_aux_sym_token7] = SHIFT(89), + }, + + [115] = { + [ts_aux_sym_repeat_helper8] = SHIFT(116), + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper8, 0), + [ts_aux_sym_token9] = SHIFT(114), + }, + + [116] = { + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper8, 3), + }, + + [117] = { + [ts_sym__identifier] = REDUCE(ts_aux_sym_repeat_helper7, 0), + [ts_sym__interface] = REDUCE(ts_aux_sym_repeat_helper7, 0), + [ts_sym__map] = REDUCE(ts_aux_sym_repeat_helper7, 0), + [ts_sym__struct] = REDUCE(ts_aux_sym_repeat_helper7, 0), + [ts_aux_sym_repeat_helper7] = SHIFT(118), + [ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper7, 0), + [ts_aux_sym_token7] = REDUCE(ts_aux_sym_repeat_helper7, 0), + [ts_aux_sym_token9] = SHIFT(121), + }, + + [118] = { + [ts_sym__identifier] = SHIFT(80), + [ts_sym__interface] = SHIFT(26), + [ts_sym__map] = SHIFT(32), + [ts_sym__struct] = SHIFT(81), + [ts_sym_interface_type] = SHIFT(85), + [ts_sym_map_type] = SHIFT(85), + [ts_sym_pointer_type] = SHIFT(85), + [ts_sym_slice_type] = SHIFT(85), + [ts_sym_struct_type] = SHIFT(85), + [ts_sym_type_expression] = SHIFT(119), + [ts_sym_type_name] = SHIFT(85), + [ts_aux_sym_token6] = SHIFT(87), + [ts_aux_sym_token7] = SHIFT(89), + }, + + [119] = { + [ts_aux_sym_repeat_helper8] = SHIFT(120), + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper8, 0), + [ts_aux_sym_token9] = SHIFT(114), + }, + + [120] = { + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper8, 5), + }, + + [121] = { + [ts_sym__identifier] = SHIFT(122), + [ts_sym_var_name] = SHIFT(123), + }, + + [122] = { + [ts_sym__identifier] = REDUCE(ts_sym_var_name, 1), + [ts_sym__interface] = REDUCE(ts_sym_var_name, 1), + [ts_sym__map] = REDUCE(ts_sym_var_name, 1), + [ts_sym__struct] = REDUCE(ts_sym_var_name, 1), + [ts_aux_sym_token6] = REDUCE(ts_sym_var_name, 1), + [ts_aux_sym_token7] = REDUCE(ts_sym_var_name, 1), + [ts_aux_sym_token9] = REDUCE(ts_sym_var_name, 1), + }, + + [123] = { + [ts_sym__identifier] = REDUCE(ts_aux_sym_repeat_helper7, 0), + [ts_sym__interface] = REDUCE(ts_aux_sym_repeat_helper7, 0), + [ts_sym__map] = REDUCE(ts_aux_sym_repeat_helper7, 0), + [ts_sym__struct] = REDUCE(ts_aux_sym_repeat_helper7, 0), + [ts_aux_sym_repeat_helper7] = SHIFT(124), + [ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper7, 0), + [ts_aux_sym_token7] = REDUCE(ts_aux_sym_repeat_helper7, 0), + [ts_aux_sym_token9] = SHIFT(121), + }, + + [124] = { + [ts_sym__identifier] = REDUCE(ts_aux_sym_repeat_helper7, 3), + [ts_sym__interface] = REDUCE(ts_aux_sym_repeat_helper7, 3), + [ts_sym__map] = REDUCE(ts_aux_sym_repeat_helper7, 3), + [ts_sym__struct] = REDUCE(ts_aux_sym_repeat_helper7, 3), + [ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper7, 3), + [ts_aux_sym_token7] = REDUCE(ts_aux_sym_repeat_helper7, 3), + }, + + [125] = { + [ts_sym__identifier] = REDUCE(ts_aux_sym_repeat_helper6, 0), + [ts_sym__interface] = REDUCE(ts_aux_sym_repeat_helper6, 0), + [ts_sym__map] = REDUCE(ts_aux_sym_repeat_helper6, 0), + [ts_sym__struct] = REDUCE(ts_aux_sym_repeat_helper6, 0), + [ts_aux_sym_repeat_helper6] = SHIFT(126), + [ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper6, 0), + [ts_aux_sym_token7] = REDUCE(ts_aux_sym_repeat_helper6, 0), + [ts_aux_sym_token9] = SHIFT(139), + }, + + [126] = { + [ts_sym__identifier] = SHIFT(80), + [ts_sym__interface] = SHIFT(26), + [ts_sym__map] = SHIFT(32), + [ts_sym__struct] = SHIFT(81), + [ts_sym_interface_type] = SHIFT(85), + [ts_sym_map_type] = SHIFT(85), + [ts_sym_pointer_type] = SHIFT(85), + [ts_sym_slice_type] = SHIFT(85), + [ts_sym_struct_type] = SHIFT(85), + [ts_sym_type_expression] = SHIFT(127), + [ts_sym_type_name] = SHIFT(85), + [ts_aux_sym_token6] = SHIFT(87), + [ts_aux_sym_token7] = SHIFT(89), + }, + + [127] = { + [ts_aux_sym_repeat_helper8] = SHIFT(128), + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper8, 0), + [ts_aux_sym_token9] = SHIFT(114), + }, + + [128] = { + [ts_aux_sym_token2] = SHIFT(129), + }, + + [129] = { + [ts_sym__identifier] = SHIFT(45), + [ts_sym_type_name] = SHIFT(130), + [ts_aux_sym_token1] = SHIFT(131), + [ts_aux_sym_token5] = REDUCE(ts_sym__func_signature, 6), + }, + + [130] = { + [ts_sym__identifier] = REDUCE(ts_sym__func_signature, 7), + [ts_aux_sym_token5] = REDUCE(ts_sym__func_signature, 7), + }, + + [131] = { + [ts_sym__identifier] = SHIFT(97), + [ts_sym_type_name] = SHIFT(132), + [ts_sym_var_name] = SHIFT(135), + [ts_aux_sym_token2] = SHIFT(100), + }, + + [132] = { + [ts_aux_sym_repeat_helper10] = SHIFT(133), + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper10, 0), + [ts_aux_sym_token9] = SHIFT(101), + }, + + [133] = { + [ts_aux_sym_token2] = SHIFT(134), + }, + + [134] = { + [ts_sym__identifier] = REDUCE(ts_sym__func_signature, 10), + [ts_aux_sym_token5] = REDUCE(ts_sym__func_signature, 10), + }, + + [135] = { + [ts_sym__identifier] = SHIFT(80), + [ts_sym_type_name] = SHIFT(136), + }, + + [136] = { + [ts_aux_sym_repeat_helper9] = SHIFT(137), + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper9, 0), + [ts_aux_sym_token9] = SHIFT(108), + }, + + [137] = { + [ts_aux_sym_token2] = SHIFT(138), + }, + + [138] = { + [ts_sym__identifier] = REDUCE(ts_sym__func_signature, 11), + [ts_aux_sym_token5] = REDUCE(ts_sym__func_signature, 11), + }, + + [139] = { + [ts_sym__identifier] = SHIFT(122), + [ts_sym_var_name] = SHIFT(140), + }, + + [140] = { + [ts_sym__identifier] = REDUCE(ts_aux_sym_repeat_helper6, 0), + [ts_sym__interface] = REDUCE(ts_aux_sym_repeat_helper6, 0), + [ts_sym__map] = REDUCE(ts_aux_sym_repeat_helper6, 0), + [ts_sym__struct] = REDUCE(ts_aux_sym_repeat_helper6, 0), + [ts_aux_sym_repeat_helper6] = SHIFT(141), + [ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper6, 0), + [ts_aux_sym_token7] = REDUCE(ts_aux_sym_repeat_helper6, 0), + [ts_aux_sym_token9] = SHIFT(139), + }, + + [141] = { + [ts_sym__identifier] = REDUCE(ts_aux_sym_repeat_helper6, 3), + [ts_sym__interface] = REDUCE(ts_aux_sym_repeat_helper6, 3), + [ts_sym__map] = REDUCE(ts_aux_sym_repeat_helper6, 3), + [ts_sym__struct] = REDUCE(ts_aux_sym_repeat_helper6, 3), + [ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper6, 3), + [ts_aux_sym_token7] = REDUCE(ts_aux_sym_repeat_helper6, 3), + }, + + [142] = { + [ts_sym__identifier] = SHIFT(45), + [ts_sym_type_name] = SHIFT(143), + [ts_aux_sym_token1] = SHIFT(144), + [ts_aux_sym_token5] = REDUCE(ts_sym__func_signature, 2), + }, + + [143] = { + [ts_sym__identifier] = REDUCE(ts_sym__func_signature, 3), + [ts_aux_sym_token5] = REDUCE(ts_sym__func_signature, 3), + }, + + [144] = { + [ts_sym__identifier] = SHIFT(97), + [ts_sym_type_name] = SHIFT(145), + [ts_sym_var_name] = SHIFT(147), + [ts_aux_sym_token2] = SHIFT(150), + }, + + [145] = { + [ts_aux_sym_repeat_helper10] = SHIFT(146), + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper10, 0), + [ts_aux_sym_token9] = SHIFT(101), + }, + + [146] = { + [ts_aux_sym_token2] = SHIFT(113), + }, + + [147] = { + [ts_sym__identifier] = SHIFT(80), + [ts_sym_type_name] = SHIFT(148), + }, + + [148] = { + [ts_aux_sym_repeat_helper9] = SHIFT(149), + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper9, 0), + [ts_aux_sym_token9] = SHIFT(108), + }, + + [149] = { + [ts_aux_sym_token2] = SHIFT(130), + }, + + [150] = { + [ts_sym__identifier] = REDUCE(ts_sym__func_signature, 4), + [ts_aux_sym_token5] = REDUCE(ts_sym__func_signature, 4), + }, + + [151] = { + [ts_aux_sym_token5] = SHIFT(152), + }, + + [152] = { + [ts_aux_sym_token2] = REDUCE(ts_sym_interface_type, 4), + [ts_aux_sym_token9] = REDUCE(ts_sym_interface_type, 4), + }, + + [153] = { + [ts_aux_sym_repeat_helper8] = SHIFT(154), + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper8, 0), + [ts_aux_sym_token9] = SHIFT(114), + }, + + [154] = { + [ts_aux_sym_token2] = SHIFT(155), + }, + + [155] = { + [ts_sym__identifier] = SHIFT(156), + [ts_sym_type_name] = SHIFT(157), + [ts_aux_sym_token1] = SHIFT(158), + [ts_aux_sym_token4] = REDUCE(ts_sym__func_signature, 4), + }, + + [156] = { + [ts_aux_sym_token4] = REDUCE(ts_sym_type_name, 1), + }, + + [157] = { + [ts_aux_sym_token4] = REDUCE(ts_sym__func_signature, 5), + }, + + [158] = { + [ts_sym__identifier] = SHIFT(97), + [ts_sym_type_name] = SHIFT(159), + [ts_sym_var_name] = SHIFT(162), + [ts_aux_sym_token2] = SHIFT(166), + }, + + [159] = { + [ts_aux_sym_repeat_helper10] = SHIFT(160), + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper10, 0), + [ts_aux_sym_token9] = SHIFT(101), + }, + + [160] = { + [ts_aux_sym_token2] = SHIFT(161), + }, + + [161] = { + [ts_aux_sym_token4] = REDUCE(ts_sym__func_signature, 8), + }, + + [162] = { + [ts_sym__identifier] = SHIFT(80), + [ts_sym_type_name] = SHIFT(163), + }, + + [163] = { + [ts_aux_sym_repeat_helper9] = SHIFT(164), + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper9, 0), + [ts_aux_sym_token9] = SHIFT(108), + }, + + [164] = { + [ts_aux_sym_token2] = SHIFT(165), + }, + + [165] = { + [ts_aux_sym_token4] = REDUCE(ts_sym__func_signature, 9), + }, + + [166] = { + [ts_aux_sym_token4] = REDUCE(ts_sym__func_signature, 6), + }, + + [167] = { + [ts_sym__identifier] = REDUCE(ts_aux_sym_repeat_helper6, 0), + [ts_sym__interface] = REDUCE(ts_aux_sym_repeat_helper6, 0), + [ts_sym__map] = REDUCE(ts_aux_sym_repeat_helper6, 0), + [ts_sym__struct] = REDUCE(ts_aux_sym_repeat_helper6, 0), + [ts_aux_sym_repeat_helper6] = SHIFT(168), + [ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper6, 0), + [ts_aux_sym_token7] = REDUCE(ts_aux_sym_repeat_helper6, 0), + [ts_aux_sym_token9] = SHIFT(139), + }, + + [168] = { + [ts_sym__identifier] = SHIFT(80), + [ts_sym__interface] = SHIFT(26), + [ts_sym__map] = SHIFT(32), + [ts_sym__struct] = SHIFT(81), + [ts_sym_interface_type] = SHIFT(85), + [ts_sym_map_type] = SHIFT(85), + [ts_sym_pointer_type] = SHIFT(85), + [ts_sym_slice_type] = SHIFT(85), + [ts_sym_struct_type] = SHIFT(85), + [ts_sym_type_expression] = SHIFT(169), + [ts_sym_type_name] = SHIFT(85), + [ts_aux_sym_token6] = SHIFT(87), + [ts_aux_sym_token7] = SHIFT(89), + }, + + [169] = { + [ts_aux_sym_repeat_helper8] = SHIFT(170), + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper8, 0), + [ts_aux_sym_token9] = SHIFT(114), + }, + + [170] = { + [ts_aux_sym_token2] = SHIFT(171), + }, + + [171] = { + [ts_sym__identifier] = SHIFT(156), + [ts_sym_type_name] = SHIFT(172), + [ts_aux_sym_token1] = SHIFT(173), + [ts_aux_sym_token4] = REDUCE(ts_sym__func_signature, 6), + }, + + [172] = { + [ts_aux_sym_token4] = REDUCE(ts_sym__func_signature, 7), + }, + + [173] = { + [ts_sym__identifier] = SHIFT(97), + [ts_sym_type_name] = SHIFT(174), + [ts_sym_var_name] = SHIFT(177), + [ts_aux_sym_token2] = SHIFT(161), + }, + + [174] = { + [ts_aux_sym_repeat_helper10] = SHIFT(175), + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper10, 0), + [ts_aux_sym_token9] = SHIFT(101), + }, + + [175] = { + [ts_aux_sym_token2] = SHIFT(176), + }, + + [176] = { + [ts_aux_sym_token4] = REDUCE(ts_sym__func_signature, 10), + }, + + [177] = { + [ts_sym__identifier] = SHIFT(80), + [ts_sym_type_name] = SHIFT(178), + }, + + [178] = { + [ts_aux_sym_repeat_helper9] = SHIFT(179), + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper9, 0), + [ts_aux_sym_token9] = SHIFT(108), + }, + + [179] = { + [ts_aux_sym_token2] = SHIFT(180), + }, + + [180] = { + [ts_aux_sym_token4] = REDUCE(ts_sym__func_signature, 11), + }, + + [181] = { + [ts_sym__identifier] = SHIFT(156), + [ts_sym_type_name] = SHIFT(182), + [ts_aux_sym_token1] = SHIFT(183), + [ts_aux_sym_token4] = REDUCE(ts_sym__func_signature, 2), + }, + + [182] = { + [ts_aux_sym_token4] = REDUCE(ts_sym__func_signature, 3), + }, + + [183] = { + [ts_sym__identifier] = SHIFT(97), + [ts_sym_type_name] = SHIFT(184), + [ts_sym_var_name] = SHIFT(186), + [ts_aux_sym_token2] = SHIFT(189), + }, + + [184] = { + [ts_aux_sym_repeat_helper10] = SHIFT(185), + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper10, 0), + [ts_aux_sym_token9] = SHIFT(101), + }, + + [185] = { + [ts_aux_sym_token2] = SHIFT(166), + }, + + [186] = { + [ts_sym__identifier] = SHIFT(80), + [ts_sym_type_name] = SHIFT(187), + }, + + [187] = { + [ts_aux_sym_repeat_helper9] = SHIFT(188), + [ts_aux_sym_token2] = REDUCE(ts_aux_sym_repeat_helper9, 0), + [ts_aux_sym_token9] = SHIFT(108), + }, + + [188] = { + [ts_aux_sym_token2] = SHIFT(172), + }, + + [189] = { + [ts_aux_sym_token4] = REDUCE(ts_sym__func_signature, 4), + }, + + [190] = { + [ts_sym__identifier] = SHIFT(191), + [ts_sym_type_name] = SHIFT(192), + }, + + [191] = { + [ts_sym__identifier] = REDUCE(ts_sym_type_name, 1), + [ts_sym__interface] = REDUCE(ts_sym_type_name, 1), + [ts_sym__map] = REDUCE(ts_sym_type_name, 1), + [ts_sym__struct] = REDUCE(ts_sym_type_name, 1), + [ts_aux_sym_token6] = REDUCE(ts_sym_type_name, 1), + [ts_aux_sym_token7] = REDUCE(ts_sym_type_name, 1), + }, + + [192] = { + [ts_sym__identifier] = SHIFT(193), + [ts_sym__interface] = SHIFT(194), + [ts_sym__map] = SHIFT(198), + [ts_sym__struct] = SHIFT(202), + [ts_sym_interface_type] = SHIFT(206), + [ts_sym_map_type] = SHIFT(206), + [ts_sym_pointer_type] = SHIFT(206), + [ts_sym_slice_type] = SHIFT(206), + [ts_sym_struct_type] = SHIFT(206), + [ts_sym_type_expression] = SHIFT(213), + [ts_sym_type_name] = SHIFT(206), + [ts_aux_sym_token6] = SHIFT(208), + [ts_aux_sym_token7] = SHIFT(210), + }, + + [193] = { + [ts_sym__func] = REDUCE(ts_sym_type_name, 1), + [ts_sym__type] = REDUCE(ts_sym_type_name, 1), + [ts_sym__var] = REDUCE(ts_sym_type_name, 1), + [ts_builtin_sym_end] = REDUCE(ts_sym_type_name, 1), + }, + + [194] = { + [ts_aux_sym_token4] = SHIFT(195), + }, + + [195] = { + [ts_sym__identifier] = SHIFT(18), + [ts_sym_var_name] = SHIFT(28), + [ts_aux_sym_repeat_helper5] = SHIFT(196), + [ts_aux_sym_token5] = REDUCE(ts_aux_sym_repeat_helper5, 0), + }, + + [196] = { + [ts_aux_sym_token5] = SHIFT(197), + }, + + [197] = { + [ts_sym__func] = REDUCE(ts_sym_interface_type, 4), + [ts_sym__type] = REDUCE(ts_sym_interface_type, 4), + [ts_sym__var] = REDUCE(ts_sym_interface_type, 4), + [ts_builtin_sym_end] = REDUCE(ts_sym_interface_type, 4), + }, + + [198] = { + [ts_aux_sym_token7] = SHIFT(199), + }, + + [199] = { + [ts_sym__identifier] = SHIFT(34), + [ts_sym__interface] = SHIFT(35), + [ts_sym__map] = SHIFT(39), + [ts_sym__struct] = SHIFT(41), + [ts_sym_interface_type] = SHIFT(52), + [ts_sym_map_type] = SHIFT(52), + [ts_sym_pointer_type] = SHIFT(52), + [ts_sym_slice_type] = SHIFT(52), + [ts_sym_struct_type] = SHIFT(52), + [ts_sym_type_expression] = SHIFT(200), + [ts_sym_type_name] = SHIFT(52), + [ts_aux_sym_token6] = SHIFT(66), + [ts_aux_sym_token7] = SHIFT(68), + }, + + [200] = { + [ts_aux_sym_token8] = SHIFT(201), + }, + + [201] = { + [ts_sym__identifier] = SHIFT(193), + [ts_sym__interface] = SHIFT(194), + [ts_sym__map] = SHIFT(198), + [ts_sym__struct] = SHIFT(202), + [ts_sym_interface_type] = SHIFT(206), + [ts_sym_map_type] = SHIFT(206), + [ts_sym_pointer_type] = SHIFT(206), + [ts_sym_slice_type] = SHIFT(206), + [ts_sym_struct_type] = SHIFT(206), + [ts_sym_type_expression] = SHIFT(207), + [ts_sym_type_name] = SHIFT(206), + [ts_aux_sym_token6] = SHIFT(208), + [ts_aux_sym_token7] = SHIFT(210), + }, + + [202] = { + [ts_aux_sym_token4] = SHIFT(203), + }, + + [203] = { + [ts_sym__identifier] = SHIFT(43), + [ts_sym_var_name] = SHIFT(44), + [ts_aux_sym_repeat_helper4] = SHIFT(204), + [ts_aux_sym_token5] = REDUCE(ts_aux_sym_repeat_helper4, 0), + }, + + [204] = { + [ts_aux_sym_token5] = SHIFT(205), + }, + + [205] = { + [ts_sym__func] = REDUCE(ts_sym_struct_type, 4), + [ts_sym__type] = REDUCE(ts_sym_struct_type, 4), + [ts_sym__var] = REDUCE(ts_sym_struct_type, 4), + [ts_builtin_sym_end] = REDUCE(ts_sym_struct_type, 4), + }, + + [206] = { + [ts_sym__func] = REDUCE(ts_sym_type_expression, 1), + [ts_sym__type] = REDUCE(ts_sym_type_expression, 1), + [ts_sym__var] = REDUCE(ts_sym_type_expression, 1), + [ts_builtin_sym_end] = REDUCE(ts_sym_type_expression, 1), + }, + + [207] = { + [ts_sym__func] = REDUCE(ts_sym_map_type, 5), + [ts_sym__type] = REDUCE(ts_sym_map_type, 5), + [ts_sym__var] = REDUCE(ts_sym_map_type, 5), + [ts_builtin_sym_end] = REDUCE(ts_sym_map_type, 5), + }, + + [208] = { + [ts_sym__identifier] = SHIFT(193), + [ts_sym__interface] = SHIFT(194), + [ts_sym__map] = SHIFT(198), + [ts_sym__struct] = SHIFT(202), + [ts_sym_interface_type] = SHIFT(206), + [ts_sym_map_type] = SHIFT(206), + [ts_sym_pointer_type] = SHIFT(206), + [ts_sym_slice_type] = SHIFT(206), + [ts_sym_struct_type] = SHIFT(206), + [ts_sym_type_expression] = SHIFT(209), + [ts_sym_type_name] = SHIFT(206), + [ts_aux_sym_token6] = SHIFT(208), + [ts_aux_sym_token7] = SHIFT(210), + }, + + [209] = { + [ts_sym__func] = REDUCE(ts_sym_pointer_type, 2), + [ts_sym__type] = REDUCE(ts_sym_pointer_type, 2), + [ts_sym__var] = REDUCE(ts_sym_pointer_type, 2), + [ts_builtin_sym_end] = REDUCE(ts_sym_pointer_type, 2), + }, + + [210] = { + [ts_aux_sym_token8] = SHIFT(211), + }, + + [211] = { + [ts_sym__identifier] = SHIFT(193), + [ts_sym__interface] = SHIFT(194), + [ts_sym__map] = SHIFT(198), + [ts_sym__struct] = SHIFT(202), + [ts_sym_interface_type] = SHIFT(206), + [ts_sym_map_type] = SHIFT(206), + [ts_sym_pointer_type] = SHIFT(206), + [ts_sym_slice_type] = SHIFT(206), + [ts_sym_struct_type] = SHIFT(206), + [ts_sym_type_expression] = SHIFT(212), + [ts_sym_type_name] = SHIFT(206), + [ts_aux_sym_token6] = SHIFT(208), + [ts_aux_sym_token7] = SHIFT(210), + }, + + [212] = { + [ts_sym__func] = REDUCE(ts_sym_slice_type, 3), + [ts_sym__type] = REDUCE(ts_sym_slice_type, 3), + [ts_sym__var] = REDUCE(ts_sym_slice_type, 3), + [ts_builtin_sym_end] = REDUCE(ts_sym_slice_type, 3), + }, + + [213] = { + [ts_sym__func] = REDUCE(ts_sym_type_declaration, 3), + [ts_sym__type] = REDUCE(ts_sym_type_declaration, 3), + [ts_sym__var] = REDUCE(ts_sym_type_declaration, 3), + [ts_builtin_sym_end] = REDUCE(ts_sym_type_declaration, 3), + }, + + [214] = { + [ts_sym__identifier] = SHIFT(215), + [ts_sym_var_name] = SHIFT(216), + }, + + [215] = { + [ts_aux_sym_token3] = REDUCE(ts_sym_var_name, 1), + }, + + [216] = { + [ts_aux_sym_token3] = SHIFT(217), + }, + + [217] = { + [ts_sym_expression] = SHIFT(218), + [ts_sym_number] = SHIFT(219), + }, + + [218] = { + [ts_sym__func] = REDUCE(ts_sym_var_declaration, 4), + [ts_sym__type] = REDUCE(ts_sym_var_declaration, 4), + [ts_sym__var] = REDUCE(ts_sym_var_declaration, 4), + [ts_builtin_sym_end] = REDUCE(ts_sym_var_declaration, 4), + }, + + [219] = { + [ts_sym__func] = REDUCE(ts_sym_expression, 1), + [ts_sym__type] = REDUCE(ts_sym_expression, 1), + [ts_sym__var] = REDUCE(ts_sym_expression, 1), + [ts_builtin_sym_end] = REDUCE(ts_sym_expression, 1), + }, + + [220] = { + [ts_sym__func] = SHIFT(17), + [ts_sym__type] = SHIFT(190), + [ts_sym__var] = SHIFT(214), + [ts_sym_declaration] = SHIFT(220), + [ts_sym_func_declaration] = SHIFT(221), + [ts_sym_type_declaration] = SHIFT(221), + [ts_sym_var_declaration] = SHIFT(221), + [ts_aux_sym_repeat_helper2] = SHIFT(222), + [ts_builtin_sym_end] = REDUCE(ts_aux_sym_repeat_helper2, 0), + }, + + [221] = { + [ts_sym__func] = REDUCE(ts_sym_declaration, 1), + [ts_sym__type] = REDUCE(ts_sym_declaration, 1), + [ts_sym__var] = REDUCE(ts_sym_declaration, 1), + [ts_builtin_sym_end] = REDUCE(ts_sym_declaration, 1), + }, + + [222] = { + [ts_builtin_sym_end] = REDUCE(ts_aux_sym_repeat_helper2, 2), + }, + + [223] = { + [ts_builtin_sym_end] = REDUCE(ts_sym_program, 3), + }, + + [224] = { + [ts_builtin_sym_end] = ACCEPT_INPUT(), + }, +}; + +EXPORT_PARSER(ts_parser_golang); diff --git a/examples/parsers/javascript.c b/examples/parsers/javascript.c index da728397..36e8bd44 100644 --- a/examples/parsers/javascript.c +++ b/examples/parsers/javascript.c @@ -153,407 +153,422 @@ LEX_FN() { ACCEPT_TOKEN(ts_aux_sym_token11); case 5: if (lookahead == '\"') - ADVANCE(6); - if ((lookahead == '$') || - ('A' <= lookahead && lookahead <= 'Z') || - (lookahead == '_') || + ADVANCE(11); + if ('0' <= lookahead && lookahead <= '9') + ADVANCE(21); + if (('A' <= lookahead && lookahead <= 'Z') || ('a' <= lookahead && lookahead <= 'e') || ('g' <= lookahead && lookahead <= 'm') || ('o' <= lookahead && lookahead <= 's') || ('u' <= lookahead && lookahead <= 'z')) - ADVANCE(16); - if ('0' <= lookahead && lookahead <= '9') - ADVANCE(18); + ADVANCE(26); if (lookahead == '[') - ADVANCE(23); + ADVANCE(28); if (lookahead == 'f') - ADVANCE(24); + ADVANCE(29); if ('g' <= lookahead && lookahead <= 'f') - ADVANCE(47); - if (lookahead == 'n') ADVANCE(48); - if ('o' <= lookahead && lookahead <= 'n') - ADVANCE(55); + if (lookahead == 'n') + ADVANCE(49); if (lookahead == 't') ADVANCE(56); - if ('u' <= lookahead && lookahead <= 't') - ADVANCE(63); if (lookahead == '{') - ADVANCE(64); + ADVANCE(63); LEX_ERROR(); case 6: - if (!((lookahead == '\"') || - (lookahead == '\\'))) + if (lookahead == 'a') ADVANCE(7); - if (lookahead == '\\') - ADVANCE(13); - if (']' <= lookahead && lookahead <= '\\') - ADVANCE(15); LEX_ERROR(); case 7: - if (!((lookahead == '\"') || - (lookahead == '\\'))) + if (lookahead == 'l') ADVANCE(8); - if (lookahead == '\"') - ADVANCE(9); - if (lookahead == '\\') - ADVANCE(10); - if (']' <= lookahead && lookahead <= '\\') - ADVANCE(12); LEX_ERROR(); case 8: - if (!((lookahead == '\"') || - (lookahead == '\\'))) - ADVANCE(8); - if (lookahead == '\"') + if (lookahead == 's') ADVANCE(9); - if (lookahead == '\\') - ADVANCE(10); - if (']' <= lookahead && lookahead <= '\\') - ADVANCE(12); LEX_ERROR(); case 9: - ACCEPT_TOKEN(ts_sym_string); - case 10: - if (!((lookahead == '\"') || - (lookahead == '\\'))) - ADVANCE(8); - if (lookahead == '\"') - ADVANCE(11); - if ('#' <= lookahead && lookahead <= '\"') - ADVANCE(8); - if (lookahead == '\\') + if (lookahead == 'e') ADVANCE(10); - if (']' <= lookahead && lookahead <= '\\') - ADVANCE(12); LEX_ERROR(); + case 10: + ACCEPT_TOKEN(ts_sym_false); case 11: if (!((lookahead == '\"') || (lookahead == '\\'))) - ADVANCE(8); - if (lookahead == '\"') - ADVANCE(9); - if (lookahead == '\\') - ADVANCE(10); - if (']' <= lookahead && lookahead <= '\\') ADVANCE(12); - ACCEPT_TOKEN(ts_sym_string); + if (lookahead == '\\') + ADVANCE(18); + if (']' <= lookahead && lookahead <= '\\') + ADVANCE(20); + LEX_ERROR(); case 12: + if (!((lookahead == '\"') || + (lookahead == '\\'))) + ADVANCE(13); if (lookahead == '\"') - ADVANCE(8); + ADVANCE(14); + if (lookahead == '\\') + ADVANCE(15); + if (']' <= lookahead && lookahead <= '\\') + ADVANCE(17); LEX_ERROR(); case 13: if (!((lookahead == '\"') || (lookahead == '\\'))) - ADVANCE(8); + ADVANCE(13); if (lookahead == '\"') ADVANCE(14); - if ('#' <= lookahead && lookahead <= '\"') - ADVANCE(7); if (lookahead == '\\') - ADVANCE(10); + ADVANCE(15); if (']' <= lookahead && lookahead <= '\\') - ADVANCE(12); + ADVANCE(17); LEX_ERROR(); case 14: - if (!((lookahead == '\"') || - (lookahead == '\\'))) - ADVANCE(8); - if (lookahead == '\"') - ADVANCE(9); - if (lookahead == '\\') - ADVANCE(10); - if (']' <= lookahead && lookahead <= '\\') - ADVANCE(12); ACCEPT_TOKEN(ts_sym_string); case 15: + if (!((lookahead == '\"') || + (lookahead == '\\'))) + ADVANCE(13); if (lookahead == '\"') - ADVANCE(7); + ADVANCE(16); + if ('#' <= lookahead && lookahead <= '\"') + ADVANCE(13); + if (lookahead == '\\') + ADVANCE(15); + if (']' <= lookahead && lookahead <= '\\') + ADVANCE(17); LEX_ERROR(); case 16: - if ((lookahead == '$') || - ('A' <= lookahead && lookahead <= 'Z') || - (lookahead == '_') || - ('a' <= lookahead && lookahead <= 'z')) + if (!((lookahead == '\"') || + (lookahead == '\\'))) + ADVANCE(13); + if (lookahead == '\"') + ADVANCE(14); + if (lookahead == '\\') + ADVANCE(15); + if (']' <= lookahead && lookahead <= '\\') ADVANCE(17); - ACCEPT_TOKEN(ts_sym_identifier); + ACCEPT_TOKEN(ts_sym_string); case 17: - if ((lookahead == '$') || - ('A' <= lookahead && lookahead <= 'Z') || - (lookahead == '_') || - ('a' <= lookahead && lookahead <= 'z')) - ADVANCE(17); - ACCEPT_TOKEN(ts_sym_identifier); - case 18: - if (lookahead == '.') - ADVANCE(19); - if ('0' <= lookahead && lookahead <= '9') - ADVANCE(22); - ACCEPT_TOKEN(ts_sym_number); - case 19: - if ('0' <= lookahead && lookahead <= '9') - ADVANCE(20); + if (lookahead == '\"') + ADVANCE(13); LEX_ERROR(); + case 18: + if (!((lookahead == '\"') || + (lookahead == '\\'))) + ADVANCE(13); + if (lookahead == '\"') + ADVANCE(19); + if ('#' <= lookahead && lookahead <= '\"') + ADVANCE(12); + if (lookahead == '\\') + ADVANCE(15); + if (']' <= lookahead && lookahead <= '\\') + ADVANCE(17); + LEX_ERROR(); + case 19: + if (!((lookahead == '\"') || + (lookahead == '\\'))) + ADVANCE(13); + if (lookahead == '\"') + ADVANCE(14); + if (lookahead == '\\') + ADVANCE(15); + if (']' <= lookahead && lookahead <= '\\') + ADVANCE(17); + ACCEPT_TOKEN(ts_sym_string); case 20: - if ('0' <= lookahead && lookahead <= '9') - ADVANCE(21); - ACCEPT_TOKEN(ts_sym_number); + if (lookahead == '\"') + ADVANCE(12); + LEX_ERROR(); case 21: + if (lookahead == '.') + ADVANCE(22); if ('0' <= lookahead && lookahead <= '9') - ADVANCE(21); + ADVANCE(25); ACCEPT_TOKEN(ts_sym_number); case 22: - if (lookahead == '.') - ADVANCE(19); if ('0' <= lookahead && lookahead <= '9') - ADVANCE(22); - ACCEPT_TOKEN(ts_sym_number); + ADVANCE(23); + LEX_ERROR(); case 23: - ACCEPT_TOKEN(ts_aux_sym_token9); + if ('0' <= lookahead && lookahead <= '9') + ADVANCE(24); + ACCEPT_TOKEN(ts_sym_number); case 24: + if ('0' <= lookahead && lookahead <= '9') + ADVANCE(24); + ACCEPT_TOKEN(ts_sym_number); + case 25: + if (lookahead == '.') + ADVANCE(22); + if ('0' <= lookahead && lookahead <= '9') + ADVANCE(25); + ACCEPT_TOKEN(ts_sym_number); + case 26: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'z')) + ADVANCE(27); + ACCEPT_TOKEN(ts_sym_identifier); + case 27: + if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'z')) + ADVANCE(27); + ACCEPT_TOKEN(ts_sym_identifier); + case 28: + ACCEPT_TOKEN(ts_aux_sym_token9); + case 29: + if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('b' <= lookahead && lookahead <= 't') || ('v' <= lookahead && lookahead <= 'z')) - ADVANCE(17); - if (lookahead == 'a') - ADVANCE(29); - if (lookahead == 'u') - ADVANCE(33); - if ('v' <= lookahead && lookahead <= 'u') - ADVANCE(46); - ACCEPT_TOKEN(ts_sym_identifier); - case 25: - if (lookahead == 'l') - ADVANCE(26); - LEX_ERROR(); - case 26: - if (lookahead == 's') ADVANCE(27); - LEX_ERROR(); - case 27: - if (lookahead == 'e') - ADVANCE(28); - LEX_ERROR(); - case 28: - ACCEPT_TOKEN(ts_sym_false); - case 29: + if (lookahead == 'a') + ADVANCE(30); + if (lookahead == 'u') + ADVANCE(34); + if ('v' <= lookahead && lookahead <= 'u') + ADVANCE(47); + ACCEPT_TOKEN(ts_sym_identifier); + case 30: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'k') || ('m' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); if (lookahead == 'l') - ADVANCE(30); + ADVANCE(31); if ('m' <= lookahead && lookahead <= 'l') - ADVANCE(26); + ADVANCE(8); ACCEPT_TOKEN(ts_sym_identifier); - case 30: + case 31: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'r') || ('t' <= lookahead && lookahead <= 'z')) - ADVANCE(17); - if (lookahead == 's') - ADVANCE(31); - if ('t' <= lookahead && lookahead <= 's') ADVANCE(27); + if (lookahead == 's') + ADVANCE(32); + if ('t' <= lookahead && lookahead <= 's') + ADVANCE(9); ACCEPT_TOKEN(ts_sym_identifier); - case 31: + case 32: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'd') || ('f' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); if (lookahead == 'e') - ADVANCE(32); + ADVANCE(33); if ('f' <= lookahead && lookahead <= 'e') - ADVANCE(28); + ADVANCE(10); ACCEPT_TOKEN(ts_sym_identifier); - case 32: + case 33: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); ACCEPT_TOKEN(ts_sym_false); - case 33: + case 34: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'm') || ('o' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); if (lookahead == 'n') - ADVANCE(34); + ADVANCE(35); if ('o' <= lookahead && lookahead <= 'n') - ADVANCE(45); + ADVANCE(46); ACCEPT_TOKEN(ts_sym_identifier); - case 34: + case 35: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'b') || ('d' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); if (lookahead == 'c') - ADVANCE(35); + ADVANCE(36); if ('d' <= lookahead && lookahead <= 'c') - ADVANCE(44); + ADVANCE(45); ACCEPT_TOKEN(ts_sym_identifier); - case 35: + case 36: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 's') || ('u' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); if (lookahead == 't') - ADVANCE(36); + ADVANCE(37); if ('u' <= lookahead && lookahead <= 't') - ADVANCE(43); + ADVANCE(44); ACCEPT_TOKEN(ts_sym_identifier); - case 36: + case 37: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'h') || ('j' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); if (lookahead == 'i') - ADVANCE(37); + ADVANCE(38); if ('j' <= lookahead && lookahead <= 'i') - ADVANCE(42); + ADVANCE(43); ACCEPT_TOKEN(ts_sym_identifier); - case 37: + case 38: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'n') || ('p' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); if (lookahead == 'o') - ADVANCE(38); + ADVANCE(39); if ('p' <= lookahead && lookahead <= 'o') - ADVANCE(41); + ADVANCE(42); ACCEPT_TOKEN(ts_sym_identifier); - case 38: + case 39: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'm') || ('o' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); if (lookahead == 'n') - ADVANCE(39); - if ('o' <= lookahead && lookahead <= 'n') ADVANCE(40); + if ('o' <= lookahead && lookahead <= 'n') + ADVANCE(41); ACCEPT_TOKEN(ts_sym_identifier); - case 39: + case 40: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'z')) - ADVANCE(17); - ACCEPT_TOKEN(ts_sym__function); - case 40: + ADVANCE(27); ACCEPT_TOKEN(ts_sym__function); case 41: - if (lookahead == 'n') - ADVANCE(40); - LEX_ERROR(); + ACCEPT_TOKEN(ts_sym__function); case 42: - if (lookahead == 'o') + if (lookahead == 'n') ADVANCE(41); LEX_ERROR(); case 43: - if (lookahead == 'i') + if (lookahead == 'o') ADVANCE(42); LEX_ERROR(); case 44: - if (lookahead == 't') + if (lookahead == 'i') ADVANCE(43); LEX_ERROR(); case 45: - if (lookahead == 'c') + if (lookahead == 't') ADVANCE(44); LEX_ERROR(); case 46: - if (lookahead == 'n') + if (lookahead == 'c') ADVANCE(45); LEX_ERROR(); case 47: - if (lookahead == 'a') - ADVANCE(25); + if (lookahead == 'n') + ADVANCE(46); LEX_ERROR(); case 48: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('b' <= lookahead && lookahead <= 'z')) + ADVANCE(27); + if (lookahead == 'a') + ADVANCE(30); + if ('b' <= lookahead && lookahead <= 'a') + ADVANCE(7); + ACCEPT_TOKEN(ts_sym_identifier); + case 49: + if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 't') || ('v' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); if (lookahead == 'u') - ADVANCE(49); - if ('v' <= lookahead && lookahead <= 'u') - ADVANCE(54); - ACCEPT_TOKEN(ts_sym_identifier); - case 49: - if ((lookahead == '$') || - ('A' <= lookahead && lookahead <= 'Z') || - (lookahead == '_') || - ('a' <= lookahead && lookahead <= 'k') || - ('m' <= lookahead && lookahead <= 'z')) - ADVANCE(17); - if (lookahead == 'l') - ADVANCE(50); - if ('m' <= lookahead && lookahead <= 'l') ADVANCE(53); ACCEPT_TOKEN(ts_sym_identifier); case 50: + if (lookahead == 'l') + ADVANCE(51); + LEX_ERROR(); + case 51: + if (lookahead == 'l') + ADVANCE(52); + LEX_ERROR(); + case 52: + ACCEPT_TOKEN(ts_sym_null); + case 53: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'k') || ('m' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); if (lookahead == 'l') - ADVANCE(51); - if ('m' <= lookahead && lookahead <= 'l') - ADVANCE(52); + ADVANCE(54); ACCEPT_TOKEN(ts_sym_identifier); - case 51: + case 54: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + (lookahead == '_') || + ('a' <= lookahead && lookahead <= 'k') || + ('m' <= lookahead && lookahead <= 'z')) + ADVANCE(27); + if (lookahead == 'l') + ADVANCE(55); + ACCEPT_TOKEN(ts_sym_identifier); + case 55: + if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); ACCEPT_TOKEN(ts_sym_null); - case 52: - ACCEPT_TOKEN(ts_sym_null); - case 53: - if (lookahead == 'l') - ADVANCE(52); - LEX_ERROR(); - case 54: - if (lookahead == 'l') - ADVANCE(53); - LEX_ERROR(); - case 55: - if (lookahead == 'u') - ADVANCE(54); - LEX_ERROR(); case 56: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'q') || ('s' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); if (lookahead == 'r') ADVANCE(60); ACCEPT_TOKEN(ts_sym_identifier); @@ -569,260 +584,233 @@ LEX_FN() { ACCEPT_TOKEN(ts_sym_true); case 60: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 't') || ('v' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); if (lookahead == 'u') ADVANCE(61); ACCEPT_TOKEN(ts_sym_identifier); case 61: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'd') || ('f' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); if (lookahead == 'e') ADVANCE(62); ACCEPT_TOKEN(ts_sym_identifier); case 62: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); ACCEPT_TOKEN(ts_sym_true); case 63: - if (lookahead == 'r') - ADVANCE(57); - LEX_ERROR(); - case 64: ACCEPT_TOKEN(ts_aux_sym_token1); - case 65: + case 64: if (lookahead == '\n') ADVANCE(1); if (lookahead == ';') ADVANCE(4); LEX_ERROR(); - case 66: + case 65: if (lookahead == '(') ADVANCE(2); if (lookahead == ')') - ADVANCE(67); + ADVANCE(66); if (lookahead == ',') - ADVANCE(68); - if (lookahead == '.') - ADVANCE(3); - LEX_ERROR(); - case 67: - ACCEPT_TOKEN(ts_aux_sym_token4); - case 68: - ACCEPT_TOKEN(ts_aux_sym_token6); - case 69: - if (lookahead == '(') - ADVANCE(2); - if (lookahead == ')') ADVANCE(67); if (lookahead == '.') ADVANCE(3); LEX_ERROR(); - case 70: + case 66: + ACCEPT_TOKEN(ts_aux_sym_token4); + case 67: + ACCEPT_TOKEN(ts_aux_sym_token6); + case 68: + if (lookahead == '(') + ADVANCE(2); + if (lookahead == ')') + ADVANCE(66); + if (lookahead == '.') + ADVANCE(3); + LEX_ERROR(); + case 69: if (lookahead == '\"') - ADVANCE(6); - if ((lookahead == '$') || - ('A' <= lookahead && lookahead <= 'Z') || - (lookahead == '_') || + ADVANCE(11); + if ('0' <= lookahead && lookahead <= '9') + ADVANCE(21); + if (('A' <= lookahead && lookahead <= 'Z') || ('a' <= lookahead && lookahead <= 'e') || ('g' <= lookahead && lookahead <= 'h') || ('j' <= lookahead && lookahead <= 'm') || ('o' <= lookahead && lookahead <= 's') || (lookahead == 'u') || ('w' <= lookahead && lookahead <= 'z')) - ADVANCE(16); - if ('0' <= lookahead && lookahead <= '9') - ADVANCE(18); + ADVANCE(26); if (lookahead == '[') - ADVANCE(23); + ADVANCE(28); if (lookahead == 'f') - ADVANCE(74); + ADVANCE(73); if ('g' <= lookahead && lookahead <= 'f') - ADVANCE(77); - if (lookahead == 'i') - ADVANCE(78); - if ('j' <= lookahead && lookahead <= 'i') - ADVANCE(81); - if (lookahead == 'n') ADVANCE(48); - if ('o' <= lookahead && lookahead <= 'n') - ADVANCE(55); + if (lookahead == 'i') + ADVANCE(76); + if (lookahead == 'n') + ADVANCE(49); if (lookahead == 't') ADVANCE(56); - if ('u' <= lookahead && lookahead <= 't') - ADVANCE(63); if (lookahead == 'v') - ADVANCE(82); - if ('w' <= lookahead && lookahead <= 'v') - ADVANCE(87); + ADVANCE(79); if (lookahead == '{') - ADVANCE(64); + ADVANCE(63); if (lookahead == '}') - ADVANCE(88); + ADVANCE(84); + LEX_ERROR(); + case 70: + if (lookahead == 'a') + ADVANCE(7); + if (lookahead == 'o') + ADVANCE(71); + if (lookahead == 'u') + ADVANCE(47); LEX_ERROR(); case 71: - if (lookahead == 'o') + if (lookahead == 'r') ADVANCE(72); - if (lookahead == 'u') - ADVANCE(46); LEX_ERROR(); case 72: - if (lookahead == 'r') - ADVANCE(73); - LEX_ERROR(); - case 73: ACCEPT_TOKEN(ts_sym__for); - case 74: + case 73: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('b' <= lookahead && lookahead <= 'n') || ('p' <= lookahead && lookahead <= 't') || ('v' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); if (lookahead == 'a') - ADVANCE(29); + ADVANCE(30); if (lookahead == 'o') - ADVANCE(75); + ADVANCE(74); if (lookahead == 'u') - ADVANCE(33); + ADVANCE(34); ACCEPT_TOKEN(ts_sym_identifier); - case 75: + case 74: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'q') || ('s' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); if (lookahead == 'r') - ADVANCE(76); + ADVANCE(75); ACCEPT_TOKEN(ts_sym_identifier); - case 76: + case 75: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); ACCEPT_TOKEN(ts_sym__for); - case 77: - if ((lookahead == '$') || - ('A' <= lookahead && lookahead <= 'Z') || - (lookahead == '_') || - ('a' <= lookahead && lookahead <= 't') || - ('v' <= lookahead && lookahead <= 'z')) - ADVANCE(17); - if (lookahead == 'u') - ADVANCE(33); - ACCEPT_TOKEN(ts_sym_identifier); - case 78: + case 76: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'e') || ('g' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); if (lookahead == 'f') - ADVANCE(79); - if ('g' <= lookahead && lookahead <= 'f') - ADVANCE(80); + ADVANCE(78); ACCEPT_TOKEN(ts_sym_identifier); - case 79: + case 77: + ACCEPT_TOKEN(ts_sym__if); + case 78: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); ACCEPT_TOKEN(ts_sym__if); - case 80: - ACCEPT_TOKEN(ts_sym__if); - case 81: - if (lookahead == 'f') - ADVANCE(80); - LEX_ERROR(); - case 82: + case 79: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('b' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); if (lookahead == 'a') - ADVANCE(83); - if ('b' <= lookahead && lookahead <= 'a') - ADVANCE(86); + ADVANCE(82); ACCEPT_TOKEN(ts_sym_identifier); - case 83: + case 80: + if (lookahead == 'r') + ADVANCE(81); + LEX_ERROR(); + case 81: + ACCEPT_TOKEN(ts_sym__var); + case 82: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'q') || ('s' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); if (lookahead == 'r') - ADVANCE(84); - if ('s' <= lookahead && lookahead <= 'r') - ADVANCE(85); + ADVANCE(83); ACCEPT_TOKEN(ts_sym_identifier); - case 84: + case 83: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); ACCEPT_TOKEN(ts_sym__var); + case 84: + ACCEPT_TOKEN(ts_aux_sym_token2); case 85: - ACCEPT_TOKEN(ts_sym__var); - case 86: - if (lookahead == 'r') - ADVANCE(85); - LEX_ERROR(); - case 87: - if (lookahead == 'a') + if (lookahead == '\n') + ADVANCE(1); + if (lookahead == ';') + ADVANCE(4); + if (lookahead == '=') ADVANCE(86); LEX_ERROR(); + case 86: + ACCEPT_TOKEN(ts_aux_sym_token5); + case 87: + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) + ADVANCE(26); + LEX_ERROR(); case 88: - ACCEPT_TOKEN(ts_aux_sym_token2); + if (lookahead == '(') + ADVANCE(2); + if (lookahead == ',') + ADVANCE(67); + if (lookahead == '.') + ADVANCE(3); + if (lookahead == '}') + ADVANCE(84); + LEX_ERROR(); case 89: - if (lookahead == '\n') - ADVANCE(1); - if (lookahead == ';') - ADVANCE(4); - if (lookahead == '=') - ADVANCE(90); + if (lookahead == '}') + ADVANCE(84); LEX_ERROR(); case 90: - ACCEPT_TOKEN(ts_aux_sym_token5); - case 91: - if ((lookahead == '$') || - ('A' <= lookahead && lookahead <= 'Z') || - (lookahead == '_') || - ('a' <= lookahead && lookahead <= 'z')) - ADVANCE(16); - LEX_ERROR(); - case 92: - if (lookahead == '(') - ADVANCE(2); - if (lookahead == ',') - ADVANCE(68); - if (lookahead == '.') - ADVANCE(3); - if (lookahead == '}') - ADVANCE(88); - LEX_ERROR(); - case 93: - if (lookahead == '}') - ADVANCE(88); - LEX_ERROR(); - case 94: if (lookahead == '\n') ADVANCE(1); if (lookahead == '(') @@ -830,15 +818,15 @@ LEX_FN() { if (lookahead == '.') ADVANCE(3); if (lookahead == ':') - ADVANCE(95); + ADVANCE(91); if (lookahead == ';') ADVANCE(4); if (lookahead == '=') - ADVANCE(90); + ADVANCE(86); LEX_ERROR(); - case 95: + case 91: ACCEPT_TOKEN(ts_aux_sym_token8); - case 96: + case 92: if (lookahead == '\n') ADVANCE(1); if (lookahead == '(') @@ -846,541 +834,479 @@ LEX_FN() { if (lookahead == '.') ADVANCE(3); if (lookahead == ':') - ADVANCE(95); + ADVANCE(91); if (lookahead == ';') ADVANCE(4); LEX_ERROR(); - case 97: + case 93: if (lookahead == '(') ADVANCE(2); if (lookahead == ',') - ADVANCE(68); + ADVANCE(67); if (lookahead == '.') ADVANCE(3); if (lookahead == ']') - ADVANCE(98); + ADVANCE(94); LEX_ERROR(); - case 98: + case 94: ACCEPT_TOKEN(ts_aux_sym_token10); - case 99: + case 95: if (lookahead == '\n') ADVANCE(1); if (lookahead == ';') ADVANCE(4); if (lookahead == '}') - ADVANCE(88); + ADVANCE(84); + LEX_ERROR(); + case 96: + if (lookahead == '{') + ADVANCE(63); + LEX_ERROR(); + case 97: + if (lookahead == ')') + ADVANCE(66); + LEX_ERROR(); + case 98: + if (lookahead == ')') + ADVANCE(66); + if (lookahead == ',') + ADVANCE(67); + LEX_ERROR(); + case 99: + if (lookahead == ')') + ADVANCE(66); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) + ADVANCE(26); LEX_ERROR(); case 100: - if (lookahead == '{') - ADVANCE(64); + if (lookahead == '(') + ADVANCE(2); LEX_ERROR(); case 101: - if (lookahead == ')') - ADVANCE(67); + if (lookahead == '(') + ADVANCE(2); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) + ADVANCE(26); LEX_ERROR(); case 102: - if (lookahead == ')') - ADVANCE(67); - if (lookahead == ',') - ADVANCE(68); + if (lookahead == ']') + ADVANCE(94); LEX_ERROR(); case 103: - if ((lookahead == '$') || - ('A' <= lookahead && lookahead <= 'Z') || - (lookahead == '_') || - ('a' <= lookahead && lookahead <= 'z')) - ADVANCE(16); - if (lookahead == ')') + if (lookahead == ',') ADVANCE(67); + if (lookahead == ']') + ADVANCE(94); LEX_ERROR(); case 104: - if (lookahead == '(') - ADVANCE(2); - LEX_ERROR(); - case 105: - if ((lookahead == '$') || - ('A' <= lookahead && lookahead <= 'Z') || - (lookahead == '_') || - ('a' <= lookahead && lookahead <= 'z')) - ADVANCE(16); - if (lookahead == '(') - ADVANCE(2); - LEX_ERROR(); - case 106: - if (lookahead == ']') - ADVANCE(98); - LEX_ERROR(); - case 107: - if (lookahead == ',') - ADVANCE(68); - if (lookahead == ']') - ADVANCE(98); - LEX_ERROR(); - case 108: if (lookahead == '\"') - ADVANCE(6); - if ((lookahead == '$') || - ('A' <= lookahead && lookahead <= 'Z') || - (lookahead == '_') || + ADVANCE(11); + if ('0' <= lookahead && lookahead <= '9') + ADVANCE(21); + if (('A' <= lookahead && lookahead <= 'Z') || ('a' <= lookahead && lookahead <= 'e') || ('g' <= lookahead && lookahead <= 'm') || ('o' <= lookahead && lookahead <= 's') || ('u' <= lookahead && lookahead <= 'z')) - ADVANCE(16); - if ('0' <= lookahead && lookahead <= '9') - ADVANCE(18); + ADVANCE(26); if (lookahead == '[') - ADVANCE(23); + ADVANCE(28); if (lookahead == ']') - ADVANCE(98); + ADVANCE(94); if (lookahead == 'f') - ADVANCE(24); + ADVANCE(29); if ('g' <= lookahead && lookahead <= 'f') - ADVANCE(47); - if (lookahead == 'n') ADVANCE(48); - if ('o' <= lookahead && lookahead <= 'n') - ADVANCE(55); + if (lookahead == 'n') + ADVANCE(49); if (lookahead == 't') ADVANCE(56); - if ('u' <= lookahead && lookahead <= 't') - ADVANCE(63); if (lookahead == '{') - ADVANCE(64); + ADVANCE(63); + LEX_ERROR(); + case 105: + if (lookahead == ':') + ADVANCE(91); + LEX_ERROR(); + case 106: + if (lookahead == ',') + ADVANCE(67); + if (lookahead == '}') + ADVANCE(84); + LEX_ERROR(); + case 107: + if (lookahead == '\"') + ADVANCE(11); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) + ADVANCE(26); + if (lookahead == '}') + ADVANCE(84); + LEX_ERROR(); + case 108: + if (lookahead == '(') + ADVANCE(2); + if (lookahead == ',') + ADVANCE(67); + if (lookahead == '.') + ADVANCE(3); + if (lookahead == '=') + ADVANCE(86); + if (lookahead == '}') + ADVANCE(84); LEX_ERROR(); case 109: - if (lookahead == ':') - ADVANCE(95); + if (lookahead == '\"') + ADVANCE(11); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) + ADVANCE(26); LEX_ERROR(); case 110: + if (lookahead == '(') + ADVANCE(2); if (lookahead == ',') - ADVANCE(68); - if (lookahead == '}') - ADVANCE(88); + ADVANCE(67); + if (lookahead == '.') + ADVANCE(3); + if (lookahead == '=') + ADVANCE(86); + if (lookahead == ']') + ADVANCE(94); LEX_ERROR(); case 111: if (lookahead == '\"') - ADVANCE(6); - if ((lookahead == '$') || - ('A' <= lookahead && lookahead <= 'Z') || - (lookahead == '_') || - ('a' <= lookahead && lookahead <= 'z')) - ADVANCE(16); - if (lookahead == '}') - ADVANCE(88); + ADVANCE(11); + if (lookahead == ')') + ADVANCE(66); + if ('0' <= lookahead && lookahead <= '9') + ADVANCE(21); + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'e') || + ('g' <= lookahead && lookahead <= 'm') || + ('o' <= lookahead && lookahead <= 's') || + ('u' <= lookahead && lookahead <= 'z')) + ADVANCE(26); + if (lookahead == '[') + ADVANCE(28); + if (lookahead == 'f') + ADVANCE(29); + if ('g' <= lookahead && lookahead <= 'f') + ADVANCE(48); + if (lookahead == 'n') + ADVANCE(49); + if (lookahead == 't') + ADVANCE(56); + if (lookahead == '{') + ADVANCE(63); LEX_ERROR(); case 112: if (lookahead == '(') ADVANCE(2); + if (lookahead == ')') + ADVANCE(66); if (lookahead == ',') - ADVANCE(68); + ADVANCE(67); if (lookahead == '.') ADVANCE(3); if (lookahead == '=') - ADVANCE(90); - if (lookahead == '}') - ADVANCE(88); + ADVANCE(86); LEX_ERROR(); case 113: - if (lookahead == '\"') - ADVANCE(6); - if ((lookahead == '$') || - ('A' <= lookahead && lookahead <= 'Z') || - (lookahead == '_') || - ('a' <= lookahead && lookahead <= 'z')) - ADVANCE(16); + if (lookahead == '\n') + ADVANCE(1); + if (lookahead == ',') + ADVANCE(67); + if (lookahead == ';') + ADVANCE(4); + if (lookahead == '}') + ADVANCE(84); LEX_ERROR(); case 114: + if (lookahead == '\n') + ADVANCE(1); if (lookahead == '(') ADVANCE(2); - if (lookahead == ',') - ADVANCE(68); if (lookahead == '.') ADVANCE(3); + if (lookahead == ';') + ADVANCE(4); if (lookahead == '=') - ADVANCE(90); - if (lookahead == ']') - ADVANCE(98); + ADVANCE(86); LEX_ERROR(); case 115: if (lookahead == '\"') - ADVANCE(6); - if ((lookahead == '$') || - ('A' <= lookahead && lookahead <= 'Z') || - (lookahead == '_') || - ('a' <= lookahead && lookahead <= 'e') || - ('g' <= lookahead && lookahead <= 'm') || - ('o' <= lookahead && lookahead <= 's') || - ('u' <= lookahead && lookahead <= 'z')) - ADVANCE(16); - if (lookahead == ')') - ADVANCE(67); + ADVANCE(11); if ('0' <= lookahead && lookahead <= '9') - ADVANCE(18); - if (lookahead == '[') - ADVANCE(23); - if (lookahead == 'f') - ADVANCE(24); - if ('g' <= lookahead && lookahead <= 'f') - ADVANCE(47); - if (lookahead == 'n') - ADVANCE(48); - if ('o' <= lookahead && lookahead <= 'n') - ADVANCE(55); - if (lookahead == 't') - ADVANCE(56); - if ('u' <= lookahead && lookahead <= 't') - ADVANCE(63); - if (lookahead == '{') - ADVANCE(64); - LEX_ERROR(); - case 116: - if (lookahead == '(') - ADVANCE(2); - if (lookahead == ')') - ADVANCE(67); - if (lookahead == ',') - ADVANCE(68); - if (lookahead == '.') - ADVANCE(3); - if (lookahead == '=') - ADVANCE(90); - LEX_ERROR(); - case 117: - if (lookahead == '\n') - ADVANCE(1); - if (lookahead == ',') - ADVANCE(68); - if (lookahead == ';') - ADVANCE(4); - if (lookahead == '}') - ADVANCE(88); - LEX_ERROR(); - case 118: - if (lookahead == '\n') - ADVANCE(1); - if (lookahead == '(') - ADVANCE(2); - if (lookahead == '.') - ADVANCE(3); - if (lookahead == ';') - ADVANCE(4); - if (lookahead == '=') - ADVANCE(90); - LEX_ERROR(); - case 119: - if (lookahead == '\"') - ADVANCE(6); - if ((lookahead == '$') || - ('A' <= lookahead && lookahead <= 'Z') || - (lookahead == '_') || + ADVANCE(21); + if (('A' <= lookahead && lookahead <= 'Z') || ('a' <= lookahead && lookahead <= 'd') || ('g' <= lookahead && lookahead <= 'h') || ('j' <= lookahead && lookahead <= 'm') || ('o' <= lookahead && lookahead <= 's') || (lookahead == 'u') || ('w' <= lookahead && lookahead <= 'z')) - ADVANCE(16); - if ('0' <= lookahead && lookahead <= '9') - ADVANCE(18); + ADVANCE(26); if (lookahead == '[') - ADVANCE(23); + ADVANCE(28); if (lookahead == 'e') - ADVANCE(121); + ADVANCE(116); if ('f' <= lookahead && lookahead <= 'e') - ADVANCE(128); + ADVANCE(123); if (lookahead == 'f') - ADVANCE(74); + ADVANCE(73); if ('g' <= lookahead && lookahead <= 'f') - ADVANCE(129); - if (lookahead == 'i') - ADVANCE(78); - if ('j' <= lookahead && lookahead <= 'i') - ADVANCE(81); - if (lookahead == 'n') ADVANCE(48); - if ('o' <= lookahead && lookahead <= 'n') - ADVANCE(55); + if (lookahead == 'i') + ADVANCE(76); + if (lookahead == 'n') + ADVANCE(49); if (lookahead == 't') ADVANCE(56); - if ('u' <= lookahead && lookahead <= 't') - ADVANCE(63); if (lookahead == 'v') - ADVANCE(82); - if ('w' <= lookahead && lookahead <= 'v') - ADVANCE(87); + ADVANCE(79); if (lookahead == '{') - ADVANCE(64); + ADVANCE(63); if (lookahead == '}') - ADVANCE(88); + ADVANCE(84); LEX_ERROR(); - case 120: - if (lookahead == 'o') - ADVANCE(72); - LEX_ERROR(); - case 121: + case 116: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'k') || ('m' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); if (lookahead == 'l') - ADVANCE(122); + ADVANCE(117); if ('m' <= lookahead && lookahead <= 'l') - ADVANCE(127); + ADVANCE(122); ACCEPT_TOKEN(ts_sym_identifier); - case 122: + case 117: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'r') || ('t' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); if (lookahead == 's') - ADVANCE(123); + ADVANCE(118); if ('t' <= lookahead && lookahead <= 's') - ADVANCE(126); + ADVANCE(121); ACCEPT_TOKEN(ts_sym_identifier); - case 123: + case 118: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'd') || ('f' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); if (lookahead == 'e') - ADVANCE(124); + ADVANCE(119); if ('f' <= lookahead && lookahead <= 'e') - ADVANCE(125); + ADVANCE(120); ACCEPT_TOKEN(ts_sym_identifier); - case 124: + case 119: if ((lookahead == '$') || + ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || (lookahead == '_') || ('a' <= lookahead && lookahead <= 'z')) - ADVANCE(17); + ADVANCE(27); ACCEPT_TOKEN(ts_sym__else); - case 125: + case 120: ACCEPT_TOKEN(ts_sym__else); - case 126: + case 121: if (lookahead == 'e') - ADVANCE(125); + ADVANCE(120); LEX_ERROR(); - case 127: + case 122: if (lookahead == 's') - ADVANCE(126); + ADVANCE(121); LEX_ERROR(); - case 128: + case 123: if (lookahead == 'l') - ADVANCE(127); - if (lookahead == 'u') - ADVANCE(46); + ADVANCE(122); LEX_ERROR(); - case 129: - if ((lookahead == '$') || - ('A' <= lookahead && lookahead <= 'Z') || - (lookahead == '_') || - ('a' <= lookahead && lookahead <= 'n') || - ('p' <= lookahead && lookahead <= 'z')) - ADVANCE(17); - if (lookahead == 'o') - ADVANCE(75); - ACCEPT_TOKEN(ts_sym_identifier); - case 130: + case 124: if (lookahead == '\"') - ADVANCE(6); - if ((lookahead == '$') || - ('A' <= lookahead && lookahead <= 'Z') || - (lookahead == '_') || + ADVANCE(11); + if ('0' <= lookahead && lookahead <= '9') + ADVANCE(21); + if (('A' <= lookahead && lookahead <= 'Z') || ('a' <= lookahead && lookahead <= 'e') || ('g' <= lookahead && lookahead <= 'h') || ('j' <= lookahead && lookahead <= 'm') || ('o' <= lookahead && lookahead <= 's') || (lookahead == 'u') || ('w' <= lookahead && lookahead <= 'z')) - ADVANCE(16); - if ('0' <= lookahead && lookahead <= '9') - ADVANCE(18); + ADVANCE(26); if (lookahead == '[') - ADVANCE(23); + ADVANCE(28); if (lookahead == 'f') - ADVANCE(74); + ADVANCE(73); if ('g' <= lookahead && lookahead <= 'f') - ADVANCE(77); - if (lookahead == 'i') - ADVANCE(78); - if ('j' <= lookahead && lookahead <= 'i') - ADVANCE(81); - if (lookahead == 'n') ADVANCE(48); - if ('o' <= lookahead && lookahead <= 'n') - ADVANCE(55); + if (lookahead == 'i') + ADVANCE(76); + if (lookahead == 'n') + ADVANCE(49); if (lookahead == 't') ADVANCE(56); - if ('u' <= lookahead && lookahead <= 't') - ADVANCE(63); if (lookahead == 'v') - ADVANCE(82); - if ('w' <= lookahead && lookahead <= 'v') - ADVANCE(87); + ADVANCE(79); if (lookahead == '{') - ADVANCE(64); + ADVANCE(63); LEX_ERROR(); - case 131: + case 125: if (lookahead == '(') ADVANCE(2); if (lookahead == ')') - ADVANCE(67); + ADVANCE(66); if (lookahead == '.') ADVANCE(3); if (lookahead == '=') - ADVANCE(90); + ADVANCE(86); LEX_ERROR(); - case 132: + case 126: if (lookahead == '\"') - ADVANCE(6); - if ((lookahead == '$') || - ('A' <= lookahead && lookahead <= 'Z') || - (lookahead == '_') || + ADVANCE(11); + if ('0' <= lookahead && lookahead <= '9') + ADVANCE(21); + if (('A' <= lookahead && lookahead <= 'Z') || ('a' <= lookahead && lookahead <= 'e') || ('g' <= lookahead && lookahead <= 'm') || ('o' <= lookahead && lookahead <= 's') || (lookahead == 'u') || ('w' <= lookahead && lookahead <= 'z')) - ADVANCE(16); - if ('0' <= lookahead && lookahead <= '9') - ADVANCE(18); + ADVANCE(26); if (lookahead == '[') - ADVANCE(23); + ADVANCE(28); if (lookahead == 'f') - ADVANCE(24); + ADVANCE(29); if ('g' <= lookahead && lookahead <= 'f') - ADVANCE(47); + ADVANCE(6); if (lookahead == 'n') - ADVANCE(48); + ADVANCE(49); if ('o' <= lookahead && lookahead <= 'n') - ADVANCE(55); + ADVANCE(127); if (lookahead == 't') ADVANCE(56); if ('u' <= lookahead && lookahead <= 't') - ADVANCE(63); + ADVANCE(128); if (lookahead == 'v') - ADVANCE(82); + ADVANCE(79); if ('w' <= lookahead && lookahead <= 'v') - ADVANCE(87); + ADVANCE(129); if (lookahead == '{') - ADVANCE(64); + ADVANCE(63); LEX_ERROR(); - case 133: + case 127: + if (lookahead == 'u') + ADVANCE(50); + LEX_ERROR(); + case 128: + if (lookahead == 'r') + ADVANCE(57); + LEX_ERROR(); + case 129: + if (lookahead == 'a') + ADVANCE(80); + LEX_ERROR(); + case 130: if (lookahead == '\"') - ADVANCE(6); - if ((lookahead == '$') || - ('A' <= lookahead && lookahead <= 'Z') || - (lookahead == '_') || + ADVANCE(11); + if ('0' <= lookahead && lookahead <= '9') + ADVANCE(21); + if (('A' <= lookahead && lookahead <= 'Z') || ('a' <= lookahead && lookahead <= 'd') || ('g' <= lookahead && lookahead <= 'h') || ('j' <= lookahead && lookahead <= 'm') || ('o' <= lookahead && lookahead <= 's') || (lookahead == 'u') || ('w' <= lookahead && lookahead <= 'z')) - ADVANCE(16); - if ('0' <= lookahead && lookahead <= '9') - ADVANCE(18); + ADVANCE(26); if (lookahead == '[') - ADVANCE(23); + ADVANCE(28); if (lookahead == 'e') - ADVANCE(121); + ADVANCE(116); if ('f' <= lookahead && lookahead <= 'e') - ADVANCE(128); + ADVANCE(123); if (lookahead == 'f') - ADVANCE(74); + ADVANCE(73); if ('g' <= lookahead && lookahead <= 'f') - ADVANCE(129); - if (lookahead == 'i') - ADVANCE(78); - if ('j' <= lookahead && lookahead <= 'i') - ADVANCE(81); - if (lookahead == 'n') ADVANCE(48); - if ('o' <= lookahead && lookahead <= 'n') - ADVANCE(55); + if (lookahead == 'i') + ADVANCE(76); + if (lookahead == 'n') + ADVANCE(49); if (lookahead == 't') ADVANCE(56); - if ('u' <= lookahead && lookahead <= 't') - ADVANCE(63); if (lookahead == 'v') - ADVANCE(82); - if ('w' <= lookahead && lookahead <= 'v') - ADVANCE(87); + ADVANCE(79); if (lookahead == '{') - ADVANCE(64); + ADVANCE(63); LEX_ERROR(); - case 134: + case 131: LEX_ERROR(); case ts_lex_state_error: if (lookahead == '\n') ADVANCE(1); if (lookahead == '\"') - ADVANCE(6); - if ((lookahead == '$') || - ('A' <= lookahead && lookahead <= 'Z') || - (lookahead == '_') || + ADVANCE(11); + if (lookahead == '(') + ADVANCE(2); + if (lookahead == ')') + ADVANCE(66); + if (lookahead == ',') + ADVANCE(67); + if (lookahead == '.') + ADVANCE(3); + if ('0' <= lookahead && lookahead <= '9') + ADVANCE(21); + if (lookahead == ':') + ADVANCE(91); + if (lookahead == ';') + ADVANCE(4); + if (lookahead == '=') + ADVANCE(86); + if (('A' <= lookahead && lookahead <= 'Z') || ('a' <= lookahead && lookahead <= 'd') || ('g' <= lookahead && lookahead <= 'h') || ('j' <= lookahead && lookahead <= 'm') || ('o' <= lookahead && lookahead <= 's') || (lookahead == 'u') || ('w' <= lookahead && lookahead <= 'z')) - ADVANCE(16); - if (lookahead == '(') - ADVANCE(2); - if (lookahead == ')') - ADVANCE(67); - if (lookahead == ',') - ADVANCE(68); - if (lookahead == '.') - ADVANCE(3); - if ('0' <= lookahead && lookahead <= '9') - ADVANCE(18); - if (lookahead == ':') - ADVANCE(95); - if (lookahead == ';') - ADVANCE(4); - if (lookahead == '=') - ADVANCE(90); + ADVANCE(26); if (lookahead == '[') - ADVANCE(23); + ADVANCE(28); if (lookahead == ']') - ADVANCE(98); + ADVANCE(94); if (lookahead == 'e') - ADVANCE(121); - if ('f' <= lookahead && lookahead <= 'e') - ADVANCE(128); + ADVANCE(116); if (lookahead == 'f') - ADVANCE(74); + ADVANCE(73); if ('g' <= lookahead && lookahead <= 'f') - ADVANCE(129); - if (lookahead == 'i') - ADVANCE(78); - if ('j' <= lookahead && lookahead <= 'i') - ADVANCE(81); - if (lookahead == 'n') ADVANCE(48); - if ('o' <= lookahead && lookahead <= 'n') - ADVANCE(55); + if (lookahead == 'i') + ADVANCE(76); + if (lookahead == 'n') + ADVANCE(49); if (lookahead == 't') ADVANCE(56); - if ('u' <= lookahead && lookahead <= 't') - ADVANCE(63); if (lookahead == 'v') - ADVANCE(82); + ADVANCE(79); if ('w' <= lookahead && lookahead <= 'v') - ADVANCE(87); + ADVANCE(129); if (lookahead == '{') - ADVANCE(64); + ADVANCE(63); if (lookahead == '}') - ADVANCE(88); + ADVANCE(84); LEX_ERROR(); default: LEX_PANIC(); @@ -1388,353 +1314,353 @@ LEX_FN() { } LEX_STATES = { - [0] = 130, - [1] = 104, - [2] = 132, - [3] = 105, - [4] = 100, + [0] = 124, + [1] = 100, + [2] = 126, + [3] = 101, + [4] = 96, [5] = 0, - [6] = 70, - [7] = 104, - [8] = 132, - [9] = 91, - [10] = 65, + [6] = 69, + [7] = 100, + [8] = 126, + [9] = 87, + [10] = 64, [11] = 5, [12] = 5, - [13] = 89, + [13] = 85, [14] = 5, [15] = 0, [16] = 0, [17] = 0, - [18] = 115, - [19] = 105, - [20] = 100, - [21] = 66, - [22] = 70, - [23] = 104, + [18] = 111, + [19] = 101, + [20] = 96, + [21] = 65, + [22] = 69, + [23] = 100, [24] = 5, - [25] = 105, - [26] = 100, - [27] = 69, - [28] = 70, - [29] = 91, - [30] = 65, - [31] = 70, - [32] = 70, - [33] = 89, + [25] = 101, + [26] = 96, + [27] = 68, + [28] = 69, + [29] = 87, + [30] = 64, + [31] = 69, + [32] = 69, + [33] = 85, [34] = 0, - [35] = 70, - [36] = 91, + [35] = 69, + [36] = 87, [37] = 0, - [38] = 70, - [39] = 118, + [38] = 69, + [39] = 114, [40] = 5, [41] = 0, - [42] = 111, - [43] = 109, + [42] = 107, + [43] = 105, [44] = 5, - [45] = 105, - [46] = 100, - [47] = 92, - [48] = 70, - [49] = 70, - [50] = 93, - [51] = 70, - [52] = 94, - [53] = 96, - [54] = 93, - [55] = 70, + [45] = 101, + [46] = 96, + [47] = 88, + [48] = 69, + [49] = 69, + [50] = 89, + [51] = 69, + [52] = 90, + [53] = 92, + [54] = 89, + [55] = 69, [56] = 0, - [57] = 108, - [58] = 105, - [59] = 100, - [60] = 97, - [61] = 70, - [62] = 93, - [63] = 97, - [64] = 99, - [65] = 104, - [66] = 100, - [67] = 97, - [68] = 103, - [69] = 102, - [70] = 101, - [71] = 100, - [72] = 91, - [73] = 102, - [74] = 101, - [75] = 100, - [76] = 97, - [77] = 97, - [78] = 97, - [79] = 106, + [57] = 104, + [58] = 101, + [59] = 96, + [60] = 93, + [61] = 69, + [62] = 89, + [63] = 93, + [64] = 95, + [65] = 100, + [66] = 96, + [67] = 93, + [68] = 99, + [69] = 98, + [70] = 97, + [71] = 96, + [72] = 87, + [73] = 98, + [74] = 97, + [75] = 96, + [76] = 93, + [77] = 93, + [78] = 93, + [79] = 102, [80] = 0, - [81] = 115, - [82] = 66, - [83] = 66, - [84] = 66, - [85] = 101, - [86] = 97, - [87] = 115, - [88] = 66, - [89] = 101, - [90] = 66, + [81] = 111, + [82] = 65, + [83] = 65, + [84] = 65, + [85] = 97, + [86] = 93, + [87] = 111, + [88] = 65, + [89] = 97, + [90] = 65, [91] = 5, - [92] = 66, - [93] = 101, - [94] = 91, - [95] = 66, - [96] = 116, + [92] = 65, + [93] = 97, + [94] = 87, + [95] = 65, + [96] = 112, [97] = 5, - [98] = 66, - [99] = 111, - [100] = 109, + [98] = 65, + [99] = 107, + [100] = 105, [101] = 5, - [102] = 92, - [103] = 92, - [104] = 92, - [105] = 93, - [106] = 66, - [107] = 115, - [108] = 66, - [109] = 101, - [110] = 92, - [111] = 92, - [112] = 108, - [113] = 97, - [114] = 106, - [115] = 66, + [102] = 88, + [103] = 88, + [104] = 88, + [105] = 89, + [106] = 65, + [107] = 111, + [108] = 65, + [109] = 97, + [110] = 88, + [111] = 88, + [112] = 104, + [113] = 93, + [114] = 102, + [115] = 65, [116] = 5, - [117] = 97, - [118] = 106, - [119] = 91, - [120] = 97, - [121] = 114, + [117] = 93, + [118] = 102, + [119] = 87, + [120] = 93, + [121] = 110, [122] = 5, - [123] = 97, - [124] = 111, - [125] = 109, + [123] = 93, + [124] = 107, + [125] = 105, [126] = 5, - [127] = 92, - [128] = 93, - [129] = 97, - [130] = 113, - [131] = 109, + [127] = 88, + [128] = 89, + [129] = 93, + [130] = 109, + [131] = 105, [132] = 5, - [133] = 92, - [134] = 93, - [135] = 91, - [136] = 92, - [137] = 112, + [133] = 88, + [134] = 89, + [135] = 87, + [136] = 88, + [137] = 108, [138] = 5, - [139] = 92, - [140] = 111, - [141] = 109, + [139] = 88, + [140] = 107, + [141] = 105, [142] = 5, - [143] = 92, - [144] = 93, - [145] = 92, - [146] = 108, - [147] = 97, - [148] = 106, - [149] = 92, - [150] = 92, - [151] = 108, - [152] = 97, - [153] = 106, - [154] = 97, - [155] = 97, - [156] = 107, - [157] = 107, - [158] = 92, - [159] = 110, - [160] = 93, - [161] = 92, - [162] = 110, - [163] = 93, - [164] = 97, - [165] = 110, - [166] = 93, - [167] = 97, - [168] = 107, - [169] = 66, - [170] = 107, - [171] = 66, - [172] = 110, - [173] = 93, - [174] = 66, - [175] = 66, - [176] = 97, + [143] = 88, + [144] = 89, + [145] = 88, + [146] = 104, + [147] = 93, + [148] = 102, + [149] = 88, + [150] = 88, + [151] = 104, + [152] = 93, + [153] = 102, + [154] = 93, + [155] = 93, + [156] = 103, + [157] = 103, + [158] = 88, + [159] = 106, + [160] = 89, + [161] = 88, + [162] = 106, + [163] = 89, + [164] = 93, + [165] = 106, + [166] = 89, + [167] = 93, + [168] = 103, + [169] = 65, + [170] = 103, + [171] = 65, + [172] = 106, + [173] = 89, + [174] = 65, + [175] = 65, + [176] = 93, [177] = 0, - [178] = 107, - [179] = 117, - [180] = 93, + [178] = 103, + [179] = 113, + [180] = 89, [181] = 0, - [182] = 65, - [183] = 93, - [184] = 92, - [185] = 99, - [186] = 104, - [187] = 100, - [188] = 92, - [189] = 92, - [190] = 93, + [182] = 64, + [183] = 89, + [184] = 88, + [185] = 95, + [186] = 100, + [187] = 96, + [188] = 88, + [189] = 88, + [190] = 89, [191] = 0, - [192] = 110, - [193] = 93, - [194] = 69, - [195] = 99, - [196] = 104, - [197] = 100, - [198] = 69, - [199] = 69, - [200] = 69, - [201] = 69, - [202] = 115, - [203] = 66, - [204] = 101, - [205] = 69, - [206] = 69, - [207] = 130, - [208] = 104, - [209] = 132, + [192] = 106, + [193] = 89, + [194] = 68, + [195] = 95, + [196] = 100, + [197] = 96, + [198] = 68, + [199] = 68, + [200] = 68, + [201] = 68, + [202] = 111, + [203] = 65, + [204] = 97, + [205] = 68, + [206] = 68, + [207] = 124, + [208] = 100, + [209] = 126, [210] = 0, [211] = 5, [212] = 5, [213] = 5, - [214] = 69, - [215] = 130, - [216] = 104, + [214] = 68, + [215] = 124, + [216] = 100, [217] = 5, - [218] = 69, - [219] = 130, - [220] = 91, - [221] = 65, - [222] = 119, - [223] = 119, - [224] = 89, + [218] = 68, + [219] = 124, + [220] = 87, + [221] = 64, + [222] = 115, + [223] = 115, + [224] = 85, [225] = 0, - [226] = 119, - [227] = 119, - [228] = 119, - [229] = 130, - [230] = 119, - [231] = 70, - [232] = 93, - [233] = 119, - [234] = 117, - [235] = 65, - [236] = 91, - [237] = 69, - [238] = 131, + [226] = 115, + [227] = 115, + [228] = 115, + [229] = 124, + [230] = 115, + [231] = 69, + [232] = 89, + [233] = 115, + [234] = 113, + [235] = 64, + [236] = 87, + [237] = 68, + [238] = 125, [239] = 5, - [240] = 69, - [241] = 111, - [242] = 109, + [240] = 68, + [241] = 107, + [242] = 105, [243] = 5, - [244] = 92, - [245] = 93, - [246] = 69, - [247] = 69, - [248] = 110, - [249] = 93, - [250] = 69, - [251] = 108, - [252] = 97, - [253] = 106, - [254] = 69, - [255] = 69, - [256] = 107, - [257] = 101, - [258] = 119, - [259] = 101, - [260] = 65, - [261] = 119, - [262] = 130, - [263] = 70, - [264] = 101, - [265] = 93, - [266] = 66, - [267] = 99, - [268] = 104, - [269] = 100, - [270] = 66, - [271] = 66, - [272] = 101, + [244] = 88, + [245] = 89, + [246] = 68, + [247] = 68, + [248] = 106, + [249] = 89, + [250] = 68, + [251] = 104, + [252] = 93, + [253] = 102, + [254] = 68, + [255] = 68, + [256] = 103, + [257] = 97, + [258] = 115, + [259] = 97, + [260] = 64, + [261] = 115, + [262] = 124, + [263] = 69, + [264] = 97, + [265] = 89, + [266] = 65, + [267] = 95, + [268] = 100, + [269] = 96, + [270] = 65, + [271] = 65, + [272] = 97, [273] = 0, [274] = 0, [275] = 5, [276] = 5, - [277] = 69, - [278] = 130, - [279] = 70, - [280] = 101, - [281] = 93, + [277] = 68, + [278] = 124, + [279] = 69, + [280] = 97, + [281] = 89, [282] = 0, - [283] = 99, - [284] = 104, - [285] = 100, + [283] = 95, + [284] = 100, + [285] = 96, [286] = 0, [287] = 5, [288] = 5, - [289] = 69, - [290] = 130, - [291] = 104, + [289] = 68, + [290] = 124, + [291] = 100, [292] = 5, - [293] = 69, - [294] = 130, - [295] = 104, - [296] = 132, + [293] = 68, + [294] = 124, + [295] = 100, + [296] = 126, [297] = 5, [298] = 5, - [299] = 69, - [300] = 130, - [301] = 104, + [299] = 68, + [300] = 124, + [301] = 100, [302] = 5, - [303] = 69, - [304] = 130, - [305] = 91, - [306] = 65, - [307] = 133, - [308] = 133, - [309] = 89, + [303] = 68, + [304] = 124, + [305] = 87, + [306] = 64, + [307] = 130, + [308] = 130, + [309] = 85, [310] = 0, - [311] = 133, - [312] = 133, - [313] = 133, - [314] = 130, - [315] = 133, - [316] = 70, - [317] = 93, - [318] = 133, - [319] = 117, - [320] = 65, - [321] = 101, - [322] = 133, - [323] = 101, - [324] = 133, - [325] = 130, - [326] = 91, - [327] = 65, - [328] = 130, - [329] = 130, - [330] = 89, + [311] = 130, + [312] = 130, + [313] = 130, + [314] = 124, + [315] = 130, + [316] = 69, + [317] = 89, + [318] = 130, + [319] = 113, + [320] = 64, + [321] = 97, + [322] = 130, + [323] = 97, + [324] = 130, + [325] = 124, + [326] = 87, + [327] = 64, + [328] = 124, + [329] = 124, + [330] = 85, [331] = 0, - [332] = 130, - [333] = 130, - [334] = 130, - [335] = 70, - [336] = 93, - [337] = 130, - [338] = 117, - [339] = 65, - [340] = 101, - [341] = 130, - [342] = 101, - [343] = 134, - [344] = 130, - [345] = 134, - [346] = 134, + [332] = 124, + [333] = 124, + [334] = 124, + [335] = 69, + [336] = 89, + [337] = 124, + [338] = 113, + [339] = 64, + [340] = 97, + [341] = 124, + [342] = 97, + [343] = 131, + [344] = 124, + [345] = 131, + [346] = 131, }; PARSE_TABLE = { diff --git a/spec/compiler/build_tables/build_tables_spec.cc b/spec/compiler/build_tables/build_tables_spec.cc index b7e2adde..280509bb 100644 --- a/spec/compiler/build_tables/build_tables_spec.cc +++ b/spec/compiler/build_tables/build_tables_spec.cc @@ -36,7 +36,7 @@ describe("building parse and lex tables", []() { PreparedGrammar lex_grammar({ { "plus", str("+") }, - { "variable", pattern("\\w+") }, + { "variable", pattern("\\a+") }, { "number", pattern("\\d+") }, { "left-paren", str("(") }, { "right-paren", str(")") } @@ -71,7 +71,7 @@ describe("building parse and lex tables", []() { AssertThat(lex_state(0).expected_inputs(), Equals(set({ CharacterSet({ '(' }), - CharacterSet({ CharacterRange('0', '9') }), + CharacterSet({ {'0', '9'} }), CharacterSet({ {'a', 'z'}, {'A', 'Z'} }), }))); }); diff --git a/spec/compiler/compile_examples.cc b/spec/compiler/compile_examples.cc index 68cfe1a9..7e53d5df 100644 --- a/spec/compiler/compile_examples.cc +++ b/spec/compiler/compile_examples.cc @@ -11,6 +11,7 @@ namespace tree_sitter_examples { extern const Grammar arithmetic; extern const Grammar javascript; extern const Grammar json; + extern const Grammar golang; } START_TEST @@ -29,6 +30,7 @@ describe("compiling the example grammars", []() { compile_grammar(tree_sitter_examples::arithmetic, "arithmetic"); compile_grammar(tree_sitter_examples::json, "json"); compile_grammar(tree_sitter_examples::javascript, "javascript"); + compile_grammar(tree_sitter_examples::golang, "golang"); }); END_TEST diff --git a/spec/compiler/rules/pattern_spec.cc b/spec/compiler/rules/pattern_spec.cc index 9a56a3f1..2a0add4f 100644 --- a/spec/compiler/rules/pattern_spec.cc +++ b/spec/compiler/rules/pattern_spec.cc @@ -23,7 +23,7 @@ describe("parsing pattern rules", []() { AssertThat( rule.to_rule_tree(), EqualsPointer(seq({ - character({ {'a', 'z'}, {'A', 'Z'} }), + character({ {'a', 'z'}, {'A', 'Z'}, {'0', '9'} }), character({ '-' }), character({ {'0', '9'} }) }))); diff --git a/spec/runtime/language_specs.cc b/spec/runtime/language_specs.cc index dfbf7d1f..9c6a08fa 100644 --- a/spec/runtime/language_specs.cc +++ b/spec/runtime/language_specs.cc @@ -4,6 +4,7 @@ extern "C" ts_parser ts_parser_javascript(); extern "C" ts_parser ts_parser_json(); extern "C" ts_parser ts_parser_arithmetic(); +extern "C" ts_parser ts_parser_golang(); START_TEST @@ -18,38 +19,25 @@ describe("Languages", [&]() { ts_document_free(doc); }); - auto run_tests_for_language = [&](string language) { - for (auto &entry : test_entries_for_language(language)) { - it(entry.description.c_str(), [&]() { - ts_document_set_input_string(doc, entry.input.c_str()); - AssertThat(ts_document_string(doc), Equals(entry.tree_string.c_str())); + auto run_tests_for_language = [&](string language, ts_parser parser) { + describe(language.c_str(), [&]() { + before_each([&]() { + ts_document_set_parser(doc, parser); }); - } + + for (auto &entry : test_entries_for_language(language)) { + it(entry.description.c_str(), [&]() { + ts_document_set_input_string(doc, entry.input.c_str()); + AssertThat(ts_document_string(doc), Equals(entry.tree_string.c_str())); + }); + } + }); }; - describe("json", [&]() { - before_each([&]() { - ts_document_set_parser(doc, ts_parser_json()); - }); - - run_tests_for_language("json"); - }); - - describe("arithmetic", [&]() { - before_each([&]() { - ts_document_set_parser(doc, ts_parser_arithmetic()); - }); - - run_tests_for_language("arithmetic"); - }); - - describe("javascript", [&]() { - before_each([&]() { - ts_document_set_parser(doc, ts_parser_javascript()); - }); - - run_tests_for_language("javascript"); - }); + run_tests_for_language("json", ts_parser_json()); + run_tests_for_language("arithmetic", ts_parser_arithmetic()); + run_tests_for_language("javascript", ts_parser_javascript()); + run_tests_for_language("golang", ts_parser_golang()); }); END_TEST \ No newline at end of file diff --git a/spec/runtime/languages/golang/main.txt b/spec/runtime/languages/golang/main.txt new file mode 100644 index 00000000..999d49fb --- /dev/null +++ b/spec/runtime/languages/golang/main.txt @@ -0,0 +1,77 @@ +========================================== +parses trivial programs +========================================== +package trivial + +type x int64 +var y = 0 +func z() {} +--- +(program + (package_directive (package_name)) + (type_declaration (type_name) (type_name)) + (var_declaration (var_name) (number)) + (func_declaration (var_name) (statement_block))) + +========================================== +parses complex types +========================================== +package trivial + +type x *struct { + field1 []int64 + field2 map[string]interface{ + DoStuff() + } +} +--- +(program + (package_directive (package_name)) + (type_declaration + (type_name) + (pointer_type (struct_type + (var_name) (slice_type (type_name)) + (var_name) (map_type (type_name) (interface_type (var_name))))))) + +============================================ +parses functions arguments +============================================ +package main +func oneArg(arg1 interface{}) {} +func argsOfSameType(arg1, arg2 string) {} +func argsOfDifferentTypes() (arg1 string, arg2 int64) {} +--- +(program + (package_directive (package_name)) + (func_declaration (var_name) (var_name) (interface_type) (statement_block)) + (func_declaration (var_name) (var_name) (var_name) (type_name) (statement_block)) + (func_declaration (var_name) (var_name) (type_name) (var_name) (type_name) (statement_block))) + +============================================ +parses functions with unnamed return values +============================================ +package main +func oneReturnValue() string {} +func multipleReturnValues() (string, int64, error) {} +--- +(program + (package_directive (package_name)) + (func_declaration (var_name) (type_name) + (statement_block)) + (func_declaration (var_name) (type_name) (type_name) (type_name) + (statement_block))) + +============================================ +parses functions with named return values +============================================ +package main +func oneReturnValue() (result string) {} +func multipleReturnValues() (result string, count int64, err error) {} +--- +(program + (package_directive (package_name)) + (func_declaration (var_name) (var_name) (type_name) + (statement_block)) + (func_declaration (var_name) (var_name) (type_name) (var_name) (type_name) (var_name) (type_name) + (statement_block))) + diff --git a/src/compiler/rules/pattern.cc b/src/compiler/rules/pattern.cc index abba641b..696955e4 100644 --- a/src/compiler/rules/pattern.cc +++ b/src/compiler/rules/pattern.cc @@ -133,10 +133,12 @@ namespace tree_sitter { case '(': case ')': return CharacterSet({ value }); + case 'a': + return CharacterSet({ {'a', 'z'}, {'A', 'Z'} }); case 'w': - return CharacterSet({{'a', 'z'}, {'A', 'Z'}}); + return CharacterSet({ {'a', 'z'}, {'A', 'Z'}, {'0', '9'}}); case 'd': - return CharacterSet({CharacterRange('0', '9')}); + return CharacterSet({ {'0', '9'} }); default: error = "unrecognized escape sequence"; return CharacterSet();