diff options
| author | Ruben Beltran del Rio <ruben@unlimited.pizza> | 2023-10-04 13:39:56 +0200 |
|---|---|---|
| committer | Ruben Beltran del Rio <ruben@unlimited.pizza> | 2023-10-04 13:39:56 +0200 |
| commit | dc87cd894bad9ad0202dcd4a89e7d0af47c53fc9 (patch) | |
| tree | 19fbc45b90d717b2e150f6ab711b234d9102e423 /src | |
Initial Commit
Diffstat (limited to 'src')
| -rw-r--r-- | src/grammar.json | 431 | ||||
| -rw-r--r-- | src/node-types.json | 263 | ||||
| -rw-r--r-- | src/parser.c | 2579 | ||||
| -rw-r--r-- | src/tree_sitter/parser.h | 224 |
4 files changed, 3497 insertions, 0 deletions
diff --git a/src/grammar.json b/src/grammar.json new file mode 100644 index 0000000..1d2d121 --- /dev/null +++ b/src/grammar.json @@ -0,0 +1,431 @@ +{ + "name": "apinotation", + "rules": { + "source_file": { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "definition" + }, + { + "type": "SYMBOL", + "name": "comment" + } + ] + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "_newline" + } + } + ] + } + }, + "definition": { + "type": "PREC_RIGHT", + "value": 0, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "entry" + }, + { + "type": "SYMBOL", + "name": "_newline" + }, + { + "type": "REPEAT", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "member" + }, + { + "type": "SYMBOL", + "name": "comment" + } + ] + } + } + ] + } + }, + "entry": { + "type": "PREC_RIGHT", + "value": 0, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "TOKEN", + "content": { + "type": "STRING", + "value": "." + } + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] + } + } + ] + } + }, + "member": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "member_type" + }, + { + "type": "SYMBOL", + "name": "_label" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "type_annotation" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "parameter_list" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "return_statement" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "throw_statement" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "SYMBOL", + "name": "_newline" + } + ] + }, + "member_type": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "::" + }, + { + "type": "STRING", + "value": "->" + }, + { + "type": "STRING", + "value": "<-" + }, + { + "type": "STRING", + "value": "~>" + }, + { + "type": "STRING", + "value": "<~" + }, + { + "type": "STRING", + "value": "+>" + }, + { + "type": "STRING", + "value": "<+" + }, + { + "type": "STRING", + "value": "#" + }, + { + "type": "STRING", + "value": "+" + }, + { + "type": "STRING", + "value": "-" + } + ] + }, + "parameter_list": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "(" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_identifier_list" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + "return_statement": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "=>" + }, + { + "type": "SYMBOL", + "name": "entry" + } + ] + }, + "throw_statement": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "#>" + }, + { + "type": "SYMBOL", + "name": "_entry_list" + } + ] + }, + "_entry_list": { + "type": "PREC_LEFT", + "value": 0, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "entry" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "entry" + } + ] + } + } + ] + } + }, + "_identifier_list": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] + } + } + ] + }, + "identifier": { + "type": "PREC_LEFT", + "value": 0, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "_label" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "type_annotation" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "parameter_list" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "return_statement" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "throw_statement" + }, + { + "type": "BLANK" + } + ] + } + ] + } + }, + "type_annotation": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "<" + }, + { + "type": "SYMBOL", + "name": "_entry_list" + }, + { + "type": "STRING", + "value": ">" + } + ] + }, + "comment": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "//" + }, + { + "type": "PATTERN", + "value": "[^\\n]*" + }, + { + "type": "SYMBOL", + "name": "_newline" + } + ] + }, + "_label": { + "type": "PATTERN", + "value": "[a-zA-Z0-9][a-zA-Z0-9_-]*" + }, + "_newline": { + "type": "TOKEN", + "content": { + "type": "STRING", + "value": "\n" + } + } + }, + "extras": [ + { + "type": "PATTERN", + "value": "\\s" + } + ], + "conflicts": [], + "precedences": [], + "externals": [], + "inline": [], + "supertypes": [] +} + diff --git a/src/node-types.json b/src/node-types.json new file mode 100644 index 0000000..95b68ab --- /dev/null +++ b/src/node-types.json @@ -0,0 +1,263 @@ +[ + { + "type": "comment", + "named": true, + "fields": {} + }, + { + "type": "definition", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "comment", + "named": true + }, + { + "type": "entry", + "named": true + }, + { + "type": "member", + "named": true + } + ] + } + }, + { + "type": "entry", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + } + ] + } + }, + { + "type": "identifier", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "parameter_list", + "named": true + }, + { + "type": "return_statement", + "named": true + }, + { + "type": "throw_statement", + "named": true + }, + { + "type": "type_annotation", + "named": true + } + ] + } + }, + { + "type": "member", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "member_type", + "named": true + }, + { + "type": "parameter_list", + "named": true + }, + { + "type": "return_statement", + "named": true + }, + { + "type": "throw_statement", + "named": true + }, + { + "type": "type_annotation", + "named": true + } + ] + } + }, + { + "type": "member_type", + "named": true, + "fields": {} + }, + { + "type": "parameter_list", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "identifier", + "named": true + } + ] + } + }, + { + "type": "return_statement", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "entry", + "named": true + } + ] + } + }, + { + "type": "source_file", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "comment", + "named": true + }, + { + "type": "definition", + "named": true + } + ] + } + }, + { + "type": "throw_statement", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "entry", + "named": true + } + ] + } + }, + { + "type": "type_annotation", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "entry", + "named": true + } + ] + } + }, + { + "type": "#", + "named": false + }, + { + "type": "#>", + "named": false + }, + { + "type": "(", + "named": false + }, + { + "type": ")", + "named": false + }, + { + "type": "+", + "named": false + }, + { + "type": "+>", + "named": false + }, + { + "type": ",", + "named": false + }, + { + "type": "-", + "named": false + }, + { + "type": "->", + "named": false + }, + { + "type": ".", + "named": false + }, + { + "type": "//", + "named": false + }, + { + "type": "::", + "named": false + }, + { + "type": "<", + "named": false + }, + { + "type": "<+", + "named": false + }, + { + "type": "<-", + "named": false + }, + { + "type": "<~", + "named": false + }, + { + "type": "=>", + "named": false + }, + { + "type": ">", + "named": false + }, + { + "type": "~>", + "named": false + } +]
\ No newline at end of file diff --git a/src/parser.c b/src/parser.c new file mode 100644 index 0000000..aae9ba2 --- /dev/null +++ b/src/parser.c @@ -0,0 +1,2579 @@ +#include <tree_sitter/parser.h> + +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wmissing-field-initializers" +#endif + +#define LANGUAGE_VERSION 14 +#define STATE_COUNT 146 +#define LARGE_STATE_COUNT 2 +#define SYMBOL_COUNT 42 +#define ALIAS_COUNT 0 +#define TOKEN_COUNT 23 +#define EXTERNAL_TOKEN_COUNT 0 +#define FIELD_COUNT 0 +#define MAX_ALIAS_SEQUENCE_LENGTH 7 +#define PRODUCTION_ID_COUNT 1 + +enum { + anon_sym_DOT = 1, + anon_sym_COLON_COLON = 2, + anon_sym_DASH_GT = 3, + anon_sym_LT_DASH = 4, + anon_sym_TILDE_GT = 5, + anon_sym_LT_TILDE = 6, + anon_sym_PLUS_GT = 7, + anon_sym_LT_PLUS = 8, + anon_sym_POUND = 9, + anon_sym_PLUS = 10, + anon_sym_DASH = 11, + anon_sym_LPAREN = 12, + anon_sym_RPAREN = 13, + anon_sym_EQ_GT = 14, + anon_sym_POUND_GT = 15, + anon_sym_COMMA = 16, + anon_sym_LT = 17, + anon_sym_GT = 18, + anon_sym_SLASH_SLASH = 19, + aux_sym_comment_token1 = 20, + sym__label = 21, + sym__newline = 22, + sym_source_file = 23, + sym_definition = 24, + sym_entry = 25, + sym_member = 26, + sym_member_type = 27, + sym_parameter_list = 28, + sym_return_statement = 29, + sym_throw_statement = 30, + sym__entry_list = 31, + sym__identifier_list = 32, + sym_identifier = 33, + sym_type_annotation = 34, + sym_comment = 35, + aux_sym_source_file_repeat1 = 36, + aux_sym_source_file_repeat2 = 37, + aux_sym_definition_repeat1 = 38, + aux_sym_entry_repeat1 = 39, + aux_sym__entry_list_repeat1 = 40, + aux_sym__identifier_list_repeat1 = 41, +}; + +static const char * const ts_symbol_names[] = { + [ts_builtin_sym_end] = "end", + [anon_sym_DOT] = ".", + [anon_sym_COLON_COLON] = "::", + [anon_sym_DASH_GT] = "->", + [anon_sym_LT_DASH] = "<-", + [anon_sym_TILDE_GT] = "~>", + [anon_sym_LT_TILDE] = "<~", + [anon_sym_PLUS_GT] = "+>", + [anon_sym_LT_PLUS] = "<+", + [anon_sym_POUND] = "#", + [anon_sym_PLUS] = "+", + [anon_sym_DASH] = "-", + [anon_sym_LPAREN] = "(", + [anon_sym_RPAREN] = ")", + [anon_sym_EQ_GT] = "=>", + [anon_sym_POUND_GT] = "#>", + [anon_sym_COMMA] = ",", + [anon_sym_LT] = "<", + [anon_sym_GT] = ">", + [anon_sym_SLASH_SLASH] = "//", + [aux_sym_comment_token1] = "comment_token1", + [sym__label] = "_label", + [sym__newline] = "_newline", + [sym_source_file] = "source_file", + [sym_definition] = "definition", + [sym_entry] = "entry", + [sym_member] = "member", + [sym_member_type] = "member_type", + [sym_parameter_list] = "parameter_list", + [sym_return_statement] = "return_statement", + [sym_throw_statement] = "throw_statement", + [sym__entry_list] = "_entry_list", + [sym__identifier_list] = "_identifier_list", + [sym_identifier] = "identifier", + [sym_type_annotation] = "type_annotation", + [sym_comment] = "comment", + [aux_sym_source_file_repeat1] = "source_file_repeat1", + [aux_sym_source_file_repeat2] = "source_file_repeat2", + [aux_sym_definition_repeat1] = "definition_repeat1", + [aux_sym_entry_repeat1] = "entry_repeat1", + [aux_sym__entry_list_repeat1] = "_entry_list_repeat1", + [aux_sym__identifier_list_repeat1] = "_identifier_list_repeat1", +}; + +static const TSSymbol ts_symbol_map[] = { + [ts_builtin_sym_end] = ts_builtin_sym_end, + [anon_sym_DOT] = anon_sym_DOT, + [anon_sym_COLON_COLON] = anon_sym_COLON_COLON, + [anon_sym_DASH_GT] = anon_sym_DASH_GT, + [anon_sym_LT_DASH] = anon_sym_LT_DASH, + [anon_sym_TILDE_GT] = anon_sym_TILDE_GT, + [anon_sym_LT_TILDE] = anon_sym_LT_TILDE, + [anon_sym_PLUS_GT] = anon_sym_PLUS_GT, + [anon_sym_LT_PLUS] = anon_sym_LT_PLUS, + [anon_sym_POUND] = anon_sym_POUND, + [anon_sym_PLUS] = anon_sym_PLUS, + [anon_sym_DASH] = anon_sym_DASH, + [anon_sym_LPAREN] = anon_sym_LPAREN, + [anon_sym_RPAREN] = anon_sym_RPAREN, + [anon_sym_EQ_GT] = anon_sym_EQ_GT, + [anon_sym_POUND_GT] = anon_sym_POUND_GT, + [anon_sym_COMMA] = anon_sym_COMMA, + [anon_sym_LT] = anon_sym_LT, + [anon_sym_GT] = anon_sym_GT, + [anon_sym_SLASH_SLASH] = anon_sym_SLASH_SLASH, + [aux_sym_comment_token1] = aux_sym_comment_token1, + [sym__label] = sym__label, + [sym__newline] = sym__newline, + [sym_source_file] = sym_source_file, + [sym_definition] = sym_definition, + [sym_entry] = sym_entry, + [sym_member] = sym_member, + [sym_member_type] = sym_member_type, + [sym_parameter_list] = sym_parameter_list, + [sym_return_statement] = sym_return_statement, + [sym_throw_statement] = sym_throw_statement, + [sym__entry_list] = sym__entry_list, + [sym__identifier_list] = sym__identifier_list, + [sym_identifier] = sym_identifier, + [sym_type_annotation] = sym_type_annotation, + [sym_comment] = sym_comment, + [aux_sym_source_file_repeat1] = aux_sym_source_file_repeat1, + [aux_sym_source_file_repeat2] = aux_sym_source_file_repeat2, + [aux_sym_definition_repeat1] = aux_sym_definition_repeat1, + [aux_sym_entry_repeat1] = aux_sym_entry_repeat1, + [aux_sym__entry_list_repeat1] = aux_sym__entry_list_repeat1, + [aux_sym__identifier_list_repeat1] = aux_sym__identifier_list_repeat1, +}; + +static const TSSymbolMetadata ts_symbol_metadata[] = { + [ts_builtin_sym_end] = { + .visible = false, + .named = true, + }, + [anon_sym_DOT] = { + .visible = true, + .named = false, + }, + [anon_sym_COLON_COLON] = { + .visible = true, + .named = false, + }, + [anon_sym_DASH_GT] = { + .visible = true, + .named = false, + }, + [anon_sym_LT_DASH] = { + .visible = true, + .named = false, + }, + [anon_sym_TILDE_GT] = { + .visible = true, + .named = false, + }, + [anon_sym_LT_TILDE] = { + .visible = true, + .named = false, + }, + [anon_sym_PLUS_GT] = { + .visible = true, + .named = false, + }, + [anon_sym_LT_PLUS] = { + .visible = true, + .named = false, + }, + [anon_sym_POUND] = { + .visible = true, + .named = false, + }, + [anon_sym_PLUS] = { + .visible = true, + .named = false, + }, + [anon_sym_DASH] = { + .visible = true, + .named = false, + }, + [anon_sym_LPAREN] = { + .visible = true, + .named = false, + }, + [anon_sym_RPAREN] = { + .visible = true, + .named = false, + }, + [anon_sym_EQ_GT] = { + .visible = true, + .named = false, + }, + [anon_sym_POUND_GT] = { + .visible = true, + .named = false, + }, + [anon_sym_COMMA] = { + .visible = true, + .named = false, + }, + [anon_sym_LT] = { + .visible = true, + .named = false, + }, + [anon_sym_GT] = { + .visible = true, + .named = false, + }, + [anon_sym_SLASH_SLASH] = { + .visible = true, + .named = false, + }, + [aux_sym_comment_token1] = { + .visible = false, + .named = false, + }, + [sym__label] = { + .visible = false, + .named = true, + }, + [sym__newline] = { + .visible = false, + .named = true, + }, + [sym_source_file] = { + .visible = true, + .named = true, + }, + [sym_definition] = { + .visible = true, + .named = true, + }, + [sym_entry] = { + .visible = true, + .named = true, + }, + [sym_member] = { + .visible = true, + .named = true, + }, + [sym_member_type] = { + .visible = true, + .named = true, + }, + [sym_parameter_list] = { + .visible = true, + .named = true, + }, + [sym_return_statement] = { + .visible = true, + .named = true, + }, + [sym_throw_statement] = { + .visible = true, + .named = true, + }, + [sym__entry_list] = { + .visible = false, + .named = true, + }, + [sym__identifier_list] = { + .visible = false, + .named = true, + }, + [sym_identifier] = { + .visible = true, + .named = true, + }, + [sym_type_annotation] = { + .visible = true, + .named = true, + }, + [sym_comment] = { + .visible = true, + .named = true, + }, + [aux_sym_source_file_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_source_file_repeat2] = { + .visible = false, + .named = false, + }, + [aux_sym_definition_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_entry_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__entry_list_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__identifier_list_repeat1] = { + .visible = false, + .named = false, + }, +}; + +static const TSSymbol ts_alias_sequences[PRODUCTION_ID_COUNT][MAX_ALIAS_SEQUENCE_LENGTH] = { + [0] = {0}, +}; + +static const uint16_t ts_non_terminal_alias_map[] = { + 0, +}; + +static const TSStateId ts_primary_state_ids[STATE_COUNT] = { + [0] = 0, + [1] = 1, + [2] = 2, + [3] = 3, + [4] = 4, + [5] = 5, + [6] = 6, + [7] = 7, + [8] = 8, + [9] = 9, + [10] = 10, + [11] = 11, + [12] = 11, + [13] = 11, + [14] = 11, + [15] = 15, + [16] = 15, + [17] = 11, + [18] = 18, + [19] = 15, + [20] = 15, + [21] = 21, + [22] = 22, + [23] = 23, + [24] = 15, + [25] = 25, + [26] = 25, + [27] = 23, + [28] = 25, + [29] = 25, + [30] = 30, + [31] = 23, + [32] = 32, + [33] = 23, + [34] = 34, + [35] = 35, + [36] = 36, + [37] = 37, + [38] = 25, + [39] = 39, + [40] = 34, + [41] = 41, + [42] = 39, + [43] = 43, + [44] = 35, + [45] = 32, + [46] = 23, + [47] = 47, + [48] = 48, + [49] = 49, + [50] = 34, + [51] = 48, + [52] = 41, + [53] = 53, + [54] = 34, + [55] = 35, + [56] = 56, + [57] = 39, + [58] = 49, + [59] = 41, + [60] = 60, + [61] = 36, + [62] = 62, + [63] = 48, + [64] = 41, + [65] = 47, + [66] = 35, + [67] = 67, + [68] = 43, + [69] = 39, + [70] = 70, + [71] = 49, + [72] = 72, + [73] = 73, + [74] = 37, + [75] = 75, + [76] = 76, + [77] = 47, + [78] = 43, + [79] = 79, + [80] = 80, + [81] = 81, + [82] = 82, + [83] = 82, + [84] = 80, + [85] = 49, + [86] = 86, + [87] = 47, + [88] = 76, + [89] = 73, + [90] = 43, + [91] = 91, + [92] = 41, + [93] = 93, + [94] = 72, + [95] = 35, + [96] = 48, + [97] = 91, + [98] = 93, + [99] = 41, + [100] = 56, + [101] = 81, + [102] = 39, + [103] = 75, + [104] = 70, + [105] = 34, + [106] = 93, + [107] = 86, + [108] = 108, + [109] = 109, + [110] = 110, + [111] = 111, + [112] = 43, + [113] = 113, + [114] = 114, + [115] = 49, + [116] = 116, + [117] = 113, + [118] = 113, + [119] = 119, + [120] = 41, + [121] = 114, + [122] = 113, + [123] = 56, + [124] = 47, + [125] = 125, + [126] = 126, + [127] = 127, + [128] = 126, + [129] = 126, + [130] = 126, + [131] = 126, + [132] = 132, + [133] = 133, + [134] = 134, + [135] = 133, + [136] = 136, + [137] = 137, + [138] = 138, + [139] = 139, + [140] = 140, + [141] = 141, + [142] = 142, + [143] = 136, + [144] = 144, + [145] = 145, +}; + +static bool ts_lex(TSLexer *lexer, TSStateId state) { + START_LEXER(); + eof = lexer->eof(lexer); + switch (state) { + case 0: + if (eof) ADVANCE(10); + if (lookahead == '#') ADVANCE(20); + if (lookahead == '(') ADVANCE(23); + if (lookahead == ')') ADVANCE(24); + if (lookahead == '+') ADVANCE(21); + if (lookahead == ',') ADVANCE(27); + if (lookahead == '-') ADVANCE(22); + if (lookahead == '.') ADVANCE(11); + if (lookahead == '/') ADVANCE(4); + if (lookahead == ':') ADVANCE(5); + if (lookahead == '<') ADVANCE(29); + if (lookahead == '=') ADVANCE(7); + if (lookahead == '>') ADVANCE(30); + if (lookahead == '~') ADVANCE(8); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(0) + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(34); + END_STATE(); + case 1: + if (lookahead == '\n') ADVANCE(35); + if (lookahead == '#') ADVANCE(6); + if (lookahead == '(') ADVANCE(23); + if (lookahead == ',') ADVANCE(27); + if (lookahead == '.') ADVANCE(11); + if (lookahead == '<') ADVANCE(28); + if (lookahead == '=') ADVANCE(7); + if (lookahead == '\t' || + lookahead == '\r' || + lookahead == ' ') SKIP(1) + END_STATE(); + case 2: + if (lookahead == '#') ADVANCE(6); + if (lookahead == '(') ADVANCE(23); + if (lookahead == ')') ADVANCE(24); + if (lookahead == ',') ADVANCE(27); + if (lookahead == '.') ADVANCE(11); + if (lookahead == '<') ADVANCE(28); + if (lookahead == '=') ADVANCE(7); + if (lookahead == '>') ADVANCE(30); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(2) + END_STATE(); + case 3: + if (lookahead == '+') ADVANCE(18); + if (lookahead == '-') ADVANCE(14); + if (lookahead == '~') ADVANCE(16); + END_STATE(); + case 4: + if (lookahead == '/') ADVANCE(31); + END_STATE(); + case 5: + if (lookahead == ':') ADVANCE(12); + END_STATE(); + case 6: + if (lookahead == '>') ADVANCE(26); + END_STATE(); + case 7: + if (lookahead == '>') ADVANCE(25); + END_STATE(); + case 8: + if (lookahead == '>') ADVANCE(15); + END_STATE(); + case 9: + if (eof) ADVANCE(10); + if (lookahead == '\n') ADVANCE(35); + if (lookahead == '#') ADVANCE(19); + if (lookahead == '+') ADVANCE(21); + if (lookahead == ',') ADVANCE(27); + if (lookahead == '-') ADVANCE(22); + if (lookahead == '.') ADVANCE(11); + if (lookahead == '/') ADVANCE(4); + if (lookahead == ':') ADVANCE(5); + if (lookahead == '<') ADVANCE(3); + if (lookahead == '~') ADVANCE(8); + if (lookahead == '\t' || + lookahead == '\r' || + lookahead == ' ') SKIP(9) + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(34); + END_STATE(); + case 10: + ACCEPT_TOKEN(ts_builtin_sym_end); + END_STATE(); + case 11: + ACCEPT_TOKEN(anon_sym_DOT); + END_STATE(); + case 12: + ACCEPT_TOKEN(anon_sym_COLON_COLON); + END_STATE(); + case 13: + ACCEPT_TOKEN(anon_sym_DASH_GT); + END_STATE(); + case 14: + ACCEPT_TOKEN(anon_sym_LT_DASH); + END_STATE(); + case 15: + ACCEPT_TOKEN(anon_sym_TILDE_GT); + END_STATE(); + case 16: + ACCEPT_TOKEN(anon_sym_LT_TILDE); + END_STATE(); + case 17: + ACCEPT_TOKEN(anon_sym_PLUS_GT); + END_STATE(); + case 18: + ACCEPT_TOKEN(anon_sym_LT_PLUS); + END_STATE(); + case 19: + ACCEPT_TOKEN(anon_sym_POUND); + END_STATE(); + case 20: + ACCEPT_TOKEN(anon_sym_POUND); + if (lookahead == '>') ADVANCE(26); + END_STATE(); + case 21: + ACCEPT_TOKEN(anon_sym_PLUS); + if (lookahead == '>') ADVANCE(17); + END_STATE(); + case 22: + ACCEPT_TOKEN(anon_sym_DASH); + if (lookahead == '>') ADVANCE(13); + END_STATE(); + case 23: + ACCEPT_TOKEN(anon_sym_LPAREN); + END_STATE(); + case 24: + ACCEPT_TOKEN(anon_sym_RPAREN); + END_STATE(); + case 25: + ACCEPT_TOKEN(anon_sym_EQ_GT); + END_STATE(); + case 26: + ACCEPT_TOKEN(anon_sym_POUND_GT); + END_STATE(); + case 27: + ACCEPT_TOKEN(anon_sym_COMMA); + END_STATE(); + case 28: + ACCEPT_TOKEN(anon_sym_LT); + END_STATE(); + case 29: + ACCEPT_TOKEN(anon_sym_LT); + if (lookahead == '+') ADVANCE(18); + if (lookahead == '-') ADVANCE(14); + if (lookahead == '~') ADVANCE(16); + END_STATE(); + case 30: + ACCEPT_TOKEN(anon_sym_GT); + END_STATE(); + case 31: + ACCEPT_TOKEN(anon_sym_SLASH_SLASH); + END_STATE(); + case 32: + ACCEPT_TOKEN(aux_sym_comment_token1); + if (lookahead == '\t' || + lookahead == '\r' || + lookahead == ' ') ADVANCE(32); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(33); + END_STATE(); + case 33: + ACCEPT_TOKEN(aux_sym_comment_token1); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(33); + END_STATE(); + case 34: + ACCEPT_TOKEN(sym__label); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(34); + END_STATE(); + case 35: + ACCEPT_TOKEN(sym__newline); + if (lookahead == '\n') ADVANCE(35); + END_STATE(); + default: + return false; + } +} + +static const TSLexMode ts_lex_modes[STATE_COUNT] = { + [0] = {.lex_state = 0}, + [1] = {.lex_state = 0}, + [2] = {.lex_state = 9}, + [3] = {.lex_state = 9}, + [4] = {.lex_state = 9}, + [5] = {.lex_state = 9}, + [6] = {.lex_state = 9}, + [7] = {.lex_state = 9}, + [8] = {.lex_state = 9}, + [9] = {.lex_state = 9}, + [10] = {.lex_state = 9}, + [11] = {.lex_state = 2}, + [12] = {.lex_state = 2}, + [13] = {.lex_state = 1}, + [14] = {.lex_state = 1}, + [15] = {.lex_state = 2}, + [16] = {.lex_state = 2}, + [17] = {.lex_state = 1}, + [18] = {.lex_state = 1}, + [19] = {.lex_state = 1}, + [20] = {.lex_state = 1}, + [21] = {.lex_state = 0}, + [22] = {.lex_state = 0}, + [23] = {.lex_state = 2}, + [24] = {.lex_state = 1}, + [25] = {.lex_state = 2}, + [26] = {.lex_state = 2}, + [27] = {.lex_state = 2}, + [28] = {.lex_state = 1}, + [29] = {.lex_state = 1}, + [30] = {.lex_state = 1}, + [31] = {.lex_state = 1}, + [32] = {.lex_state = 2}, + [33] = {.lex_state = 1}, + [34] = {.lex_state = 2}, + [35] = {.lex_state = 2}, + [36] = {.lex_state = 2}, + [37] = {.lex_state = 2}, + [38] = {.lex_state = 1}, + [39] = {.lex_state = 2}, + [40] = {.lex_state = 2}, + [41] = {.lex_state = 2}, + [42] = {.lex_state = 2}, + [43] = {.lex_state = 2}, + [44] = {.lex_state = 2}, + [45] = {.lex_state = 1}, + [46] = {.lex_state = 1}, + [47] = {.lex_state = 2}, + [48] = {.lex_state = 2}, + [49] = {.lex_state = 2}, + [50] = {.lex_state = 1}, + [51] = {.lex_state = 0}, + [52] = {.lex_state = 1}, + [53] = {.lex_state = 9}, + [54] = {.lex_state = 1}, + [55] = {.lex_state = 1}, + [56] = {.lex_state = 1}, + [57] = {.lex_state = 1}, + [58] = {.lex_state = 1}, + [59] = {.lex_state = 1}, + [60] = {.lex_state = 9}, + [61] = {.lex_state = 1}, + [62] = {.lex_state = 1}, + [63] = {.lex_state = 1}, + [64] = {.lex_state = 0}, + [65] = {.lex_state = 0}, + [66] = {.lex_state = 1}, + [67] = {.lex_state = 1}, + [68] = {.lex_state = 0}, + [69] = {.lex_state = 1}, + [70] = {.lex_state = 2}, + [71] = {.lex_state = 0}, + [72] = {.lex_state = 2}, + [73] = {.lex_state = 2}, + [74] = {.lex_state = 1}, + [75] = {.lex_state = 2}, + [76] = {.lex_state = 2}, + [77] = {.lex_state = 1}, + [78] = {.lex_state = 1}, + [79] = {.lex_state = 9}, + [80] = {.lex_state = 2}, + [81] = {.lex_state = 2}, + [82] = {.lex_state = 2}, + [83] = {.lex_state = 1}, + [84] = {.lex_state = 1}, + [85] = {.lex_state = 9}, + [86] = {.lex_state = 0}, + [87] = {.lex_state = 9}, + [88] = {.lex_state = 1}, + [89] = {.lex_state = 1}, + [90] = {.lex_state = 9}, + [91] = {.lex_state = 0}, + [92] = {.lex_state = 9}, + [93] = {.lex_state = 0}, + [94] = {.lex_state = 1}, + [95] = {.lex_state = 1}, + [96] = {.lex_state = 9}, + [97] = {.lex_state = 0}, + [98] = {.lex_state = 0}, + [99] = {.lex_state = 9}, + [100] = {.lex_state = 9}, + [101] = {.lex_state = 1}, + [102] = {.lex_state = 1}, + [103] = {.lex_state = 1}, + [104] = {.lex_state = 1}, + [105] = {.lex_state = 1}, + [106] = {.lex_state = 0}, + [107] = {.lex_state = 0}, + [108] = {.lex_state = 0}, + [109] = {.lex_state = 0}, + [110] = {.lex_state = 1}, + [111] = {.lex_state = 1}, + [112] = {.lex_state = 9}, + [113] = {.lex_state = 0}, + [114] = {.lex_state = 0}, + [115] = {.lex_state = 9}, + [116] = {.lex_state = 1}, + [117] = {.lex_state = 0}, + [118] = {.lex_state = 0}, + [119] = {.lex_state = 0}, + [120] = {.lex_state = 0}, + [121] = {.lex_state = 0}, + [122] = {.lex_state = 0}, + [123] = {.lex_state = 0}, + [124] = {.lex_state = 9}, + [125] = {.lex_state = 0}, + [126] = {.lex_state = 0}, + [127] = {.lex_state = 0}, + [128] = {.lex_state = 0}, + [129] = {.lex_state = 0}, + [130] = {.lex_state = 0}, + [131] = {.lex_state = 0}, + [132] = {.lex_state = 32}, + [133] = {.lex_state = 0}, + [134] = {.lex_state = 9}, + [135] = {.lex_state = 0}, + [136] = {.lex_state = 0}, + [137] = {.lex_state = 9}, + [138] = {.lex_state = 9}, + [139] = {.lex_state = 9}, + [140] = {.lex_state = 9}, + [141] = {.lex_state = 9}, + [142] = {.lex_state = 0}, + [143] = {.lex_state = 0}, + [144] = {.lex_state = 0}, + [145] = {.lex_state = 0}, +}; + +static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { + [0] = { + [ts_builtin_sym_end] = ACTIONS(1), + [anon_sym_DOT] = ACTIONS(1), + [anon_sym_COLON_COLON] = ACTIONS(1), + [anon_sym_DASH_GT] = ACTIONS(1), + [anon_sym_LT_DASH] = ACTIONS(1), + [anon_sym_TILDE_GT] = ACTIONS(1), + [anon_sym_LT_TILDE] = ACTIONS(1), + [anon_sym_PLUS_GT] = ACTIONS(1), + [anon_sym_LT_PLUS] = ACTIONS(1), + [anon_sym_POUND] = ACTIONS(1), + [anon_sym_PLUS] = ACTIONS(1), + [anon_sym_DASH] = ACTIONS(1), + [anon_sym_LPAREN] = ACTIONS(1), + [anon_sym_RPAREN] = ACTIONS(1), + [anon_sym_EQ_GT] = ACTIONS(1), + [anon_sym_POUND_GT] = ACTIONS(1), + [anon_sym_COMMA] = ACTIONS(1), + [anon_sym_LT] = ACTIONS(1), + [anon_sym_GT] = ACTIONS(1), + [anon_sym_SLASH_SLASH] = ACTIONS(1), + [sym__label] = ACTIONS(1), + }, + [1] = { + [sym_source_file] = STATE(142), + [sym_definition] = STATE(53), + [sym_entry] = STATE(140), + [sym_identifier] = STATE(115), + [sym_comment] = STATE(53), + [aux_sym_source_file_repeat2] = STATE(21), + [ts_builtin_sym_end] = ACTIONS(3), + [anon_sym_SLASH_SLASH] = ACTIONS(5), + [sym__label] = ACTIONS(7), + }, +}; + +static const uint16_t ts_small_parse_table[] = { + [0] = 6, + ACTIONS(13), 1, + anon_sym_SLASH_SLASH, + ACTIONS(15), 1, + sym__label, + STATE(145), 1, + sym_member_type, + ACTIONS(9), 2, + ts_builtin_sym_end, + sym__newline, + STATE(4), 3, + sym_member, + sym_comment, + aux_sym_definition_repeat1, + ACTIONS(11), 10, + anon_sym_COLON_COLON, + anon_sym_DASH_GT, + anon_sym_LT_DASH, + anon_sym_TILDE_GT, + anon_sym_LT_TILDE, + anon_sym_PLUS_GT, + anon_sym_LT_PLUS, + anon_sym_POUND, + anon_sym_PLUS, + anon_sym_DASH, + [31] = 6, + ACTIONS(13), 1, + anon_sym_SLASH_SLASH, + ACTIONS(19), 1, + sym__label, + STATE(145), 1, + sym_member_type, + ACTIONS(17), 2, + ts_builtin_sym_end, + sym__newline, + STATE(2), 3, + sym_member, + sym_comment, + aux_sym_definition_repeat1, + ACTIONS(11), 10, + anon_sym_COLON_COLON, + anon_sym_DASH_GT, + anon_sym_LT_DASH, + anon_sym_TILDE_GT, + anon_sym_LT_TILDE, + anon_sym_PLUS_GT, + anon_sym_LT_PLUS, + anon_sym_POUND, + anon_sym_PLUS, + anon_sym_DASH, + [62] = 6, + ACTIONS(26), 1, + anon_sym_SLASH_SLASH, + ACTIONS(29), 1, + sym__label, + STATE(145), 1, + sym_member_type, + ACTIONS(21), 2, + ts_builtin_sym_end, + sym__newline, + STATE(4), 3, + sym_member, + sym_comment, + aux_sym_definition_repeat1, + ACTIONS(23), 10, + anon_sym_COLON_COLON, + anon_sym_DASH_GT, + anon_sym_LT_DASH, + anon_sym_TILDE_GT, + anon_sym_LT_TILDE, + anon_sym_PLUS_GT, + anon_sym_LT_PLUS, + anon_sym_POUND, + anon_sym_PLUS, + anon_sym_DASH, + [93] = 2, + ACTIONS(31), 2, + ts_builtin_sym_end, + sym__newline, + ACTIONS(33), 12, + anon_sym_COLON_COLON, + anon_sym_DASH_GT, + anon_sym_LT_DASH, + anon_sym_TILDE_GT, + anon_sym_LT_TILDE, + anon_sym_PLUS_GT, + anon_sym_LT_PLUS, + anon_sym_POUND, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH_SLASH, + sym__label, + [112] = 2, + ACTIONS(35), 2, + ts_builtin_sym_end, + sym__newline, + ACTIONS(37), 12, + anon_sym_COLON_COLON, + anon_sym_DASH_GT, + anon_sym_LT_DASH, + anon_sym_TILDE_GT, + anon_sym_LT_TILDE, + anon_sym_PLUS_GT, + anon_sym_LT_PLUS, + anon_sym_POUND, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH_SLASH, + sym__label, + [131] = 2, + ACTIONS(39), 2, + ts_builtin_sym_end, + sym__newline, + ACTIONS(41), 12, + anon_sym_COLON_COLON, + anon_sym_DASH_GT, + anon_sym_LT_DASH, + anon_sym_TILDE_GT, + anon_sym_LT_TILDE, + anon_sym_PLUS_GT, + anon_sym_LT_PLUS, + anon_sym_POUND, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH_SLASH, + sym__label, + [150] = 2, + ACTIONS(43), 2, + ts_builtin_sym_end, + sym__newline, + ACTIONS(45), 12, + anon_sym_COLON_COLON, + anon_sym_DASH_GT, + anon_sym_LT_DASH, + anon_sym_TILDE_GT, + anon_sym_LT_TILDE, + anon_sym_PLUS_GT, + anon_sym_LT_PLUS, + anon_sym_POUND, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH_SLASH, + sym__label, + [169] = 2, + ACTIONS(47), 2, + ts_builtin_sym_end, + sym__newline, + ACTIONS(49), 12, + anon_sym_COLON_COLON, + anon_sym_DASH_GT, + anon_sym_LT_DASH, + anon_sym_TILDE_GT, + anon_sym_LT_TILDE, + anon_sym_PLUS_GT, + anon_sym_LT_PLUS, + anon_sym_POUND, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH_SLASH, + sym__label, + [188] = 2, + ACTIONS(51), 2, + ts_builtin_sym_end, + sym__newline, + ACTIONS(53), 12, + anon_sym_COLON_COLON, + anon_sym_DASH_GT, + anon_sym_LT_DASH, + anon_sym_TILDE_GT, + anon_sym_LT_TILDE, + anon_sym_PLUS_GT, + anon_sym_LT_PLUS, + anon_sym_POUND, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH_SLASH, + sym__label, + [207] = 9, + ACTIONS(57), 1, + anon_sym_LPAREN, + ACTIONS(59), 1, + anon_sym_EQ_GT, + ACTIONS(61), 1, + anon_sym_POUND_GT, + ACTIONS(63), 1, + anon_sym_LT, + STATE(15), 1, + sym_type_annotation, + STATE(27), 1, + sym_parameter_list, + STATE(39), 1, + sym_return_statement, + STATE(75), 1, + sym_throw_statement, + ACTIONS(55), 4, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_COMMA, + anon_sym_GT, + [238] = 8, + ACTIONS(57), 1, + anon_sym_LPAREN, + ACTIONS(59), 1, + anon_sym_EQ_GT, + ACTIONS(63), 1, + anon_sym_LT, + STATE(16), 1, + sym_type_annotation, + STATE(23), 1, + sym_parameter_list, + STATE(42), 1, + sym_return_statement, + STATE(75), 1, + sym_throw_statement, + ACTIONS(55), 5, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_POUND_GT, + anon_sym_COMMA, + anon_sym_GT, + [267] = 9, + ACTIONS(55), 1, + sym__newline, + ACTIONS(67), 1, + anon_sym_LPAREN, + ACTIONS(69), 1, + anon_sym_EQ_GT, + ACTIONS(71), 1, + anon_sym_LT, + STATE(20), 1, + sym_type_annotation, + STATE(31), 1, + sym_parameter_list, + STATE(69), 1, + sym_return_statement, + STATE(103), 1, + sym_throw_statement, + ACTIONS(65), 3, + anon_sym_DOT, + anon_sym_POUND_GT, + anon_sym_COMMA, + [297] = 10, + ACTIONS(55), 1, + sym__newline, + ACTIONS(67), 1, + anon_sym_LPAREN, + ACTIONS(69), 1, + anon_sym_EQ_GT, + ACTIONS(71), 1, + anon_sym_LT, + ACTIONS(73), 1, + anon_sym_POUND_GT, + STATE(19), 1, + sym_type_annotation, + STATE(33), 1, + sym_parameter_list, + STATE(57), 1, + sym_return_statement, + STATE(103), 1, + sym_throw_statement, + ACTIONS(65), 2, + anon_sym_DOT, + anon_sym_COMMA, + [329] = 7, + ACTIONS(57), 1, + anon_sym_LPAREN, + ACTIONS(59), 1, + anon_sym_EQ_GT, + ACTIONS(61), 1, + anon_sym_POUND_GT, + STATE(26), 1, + sym_parameter_list, + STATE(35), 1, + sym_return_statement, + STATE(72), 1, + sym_throw_statement, + ACTIONS(75), 4, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_COMMA, + anon_sym_GT, + [354] = 6, + ACTIONS(57), 1, + anon_sym_LPAREN, + ACTIONS(59), 1, + anon_sym_EQ_GT, + STATE(25), 1, + sym_parameter_list, + STATE(44), 1, + sym_return_statement, + STATE(72), 1, + sym_throw_statement, + ACTIONS(75), 5, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_POUND_GT, + anon_sym_COMMA, + anon_sym_GT, + [377] = 10, + ACTIONS(55), 1, + sym__newline, + ACTIONS(65), 1, + anon_sym_DOT, + ACTIONS(67), 1, + anon_sym_LPAREN, + ACTIONS(69), 1, + anon_sym_EQ_GT, + ACTIONS(71), 1, + anon_sym_LT, + ACTIONS(77), 1, + anon_sym_POUND_GT, + STATE(24), 1, + sym_type_annotation, + STATE(46), 1, + sym_parameter_list, + STATE(102), 1, + sym_return_statement, + STATE(103), 1, + sym_throw_statement, + [408] = 9, + ACTIONS(67), 1, + anon_sym_LPAREN, + ACTIONS(69), 1, + anon_sym_EQ_GT, + ACTIONS(71), 1, + anon_sym_LT, + ACTIONS(77), 1, + anon_sym_POUND_GT, + ACTIONS(79), 1, + sym__newline, + STATE(30), 1, + sym_type_annotation, + STATE(62), 1, + sym_parameter_list, + STATE(111), 1, + sym_return_statement, + STATE(137), 1, + sym_throw_statement, + [436] = 8, + ACTIONS(67), 1, + anon_sym_LPAREN, + ACTIONS(69), 1, + anon_sym_EQ_GT, + ACTIONS(73), 1, + anon_sym_POUND_GT, + ACTIONS(75), 1, + sym__newline, + STATE(28), 1, + sym_parameter_list, + STATE(55), 1, + sym_return_statement, + STATE(94), 1, + sym_throw_statement, + ACTIONS(81), 2, + anon_sym_DOT, + anon_sym_COMMA, + [462] = 7, + ACTIONS(67), 1, + anon_sym_LPAREN, + ACTIONS(69), 1, + anon_sym_EQ_GT, + ACTIONS(75), 1, + sym__newline, + STATE(29), 1, + sym_parameter_list, + STATE(66), 1, + sym_return_statement, + STATE(94), 1, + sym_throw_statement, + ACTIONS(81), 3, + anon_sym_DOT, + anon_sym_POUND_GT, + anon_sym_COMMA, + [486] = 7, + ACTIONS(5), 1, + anon_sym_SLASH_SLASH, + ACTIONS(7), 1, + sym__label, + ACTIONS(83), 1, + ts_builtin_sym_end, + STATE(22), 1, + aux_sym_source_file_repeat2, + STATE(115), 1, + sym_identifier, + STATE(140), 1, + sym_entry, + STATE(53), 2, + sym_definition, + sym_comment, + [509] = 7, + ACTIONS(85), 1, + ts_builtin_sym_end, + ACTIONS(87), 1, + anon_sym_SLASH_SLASH, + ACTIONS(90), 1, + sym__label, + STATE(22), 1, + aux_sym_source_file_repeat2, + STATE(115), 1, + sym_identifier, + STATE(140), 1, + sym_entry, + STATE(53), 2, + sym_definition, + sym_comment, + [532] = 4, + ACTIONS(59), 1, + anon_sym_EQ_GT, + STATE(44), 1, + sym_return_statement, + STATE(72), 1, + sym_throw_statement, + ACTIONS(75), 5, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_POUND_GT, + anon_sym_COMMA, + anon_sym_GT, + [549] = 8, + ACTIONS(67), 1, + anon_sym_LPAREN, + ACTIONS(69), 1, + anon_sym_EQ_GT, + ACTIONS(75), 1, + sym__newline, + ACTIONS(77), 1, + anon_sym_POUND_GT, + ACTIONS(81), 1, + anon_sym_DOT, + STATE(38), 1, + sym_parameter_list, + STATE(94), 1, + sym_throw_statement, + STATE(95), 1, + sym_return_statement, + [574] = 4, + ACTIONS(59), 1, + anon_sym_EQ_GT, + STATE(34), 1, + sym_return_statement, + STATE(81), 1, + sym_throw_statement, + ACTIONS(93), 5, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_POUND_GT, + anon_sym_COMMA, + anon_sym_GT, + [591] = 5, + ACTIONS(59), 1, + anon_sym_EQ_GT, + ACTIONS(61), 1, + anon_sym_POUND_GT, + STATE(40), 1, + sym_return_statement, + STATE(81), 1, + sym_throw_statement, + ACTIONS(93), 4, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_COMMA, + anon_sym_GT, + [610] = 5, + ACTIONS(59), 1, + anon_sym_EQ_GT, + ACTIONS(61), 1, + anon_sym_POUND_GT, + STATE(35), 1, + sym_return_statement, + STATE(72), 1, + sym_throw_statement, + ACTIONS(75), 4, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_COMMA, + anon_sym_GT, + [629] = 6, + ACTIONS(69), 1, + anon_sym_EQ_GT, + ACTIONS(73), 1, + anon_sym_POUND_GT, + ACTIONS(93), 1, + sym__newline, + STATE(54), 1, + sym_return_statement, + STATE(101), 1, + sym_throw_statement, + ACTIONS(95), 2, + anon_sym_DOT, + anon_sym_COMMA, + [649] = 5, + ACTIONS(69), 1, + anon_sym_EQ_GT, + ACTIONS(93), 1, + sym__newline, + STATE(50), 1, + sym_return_statement, + STATE(101), 1, + sym_throw_statement, + ACTIONS(95), 3, + anon_sym_DOT, + anon_sym_POUND_GT, + anon_sym_COMMA, + [667] = 7, + ACTIONS(67), 1, + anon_sym_LPAREN, + ACTIONS(69), 1, + anon_sym_EQ_GT, + ACTIONS(77), 1, + anon_sym_POUND_GT, + ACTIONS(97), 1, + sym__newline, + STATE(67), 1, + sym_parameter_list, + STATE(110), 1, + sym_return_statement, + STATE(138), 1, + sym_throw_statement, + [689] = 5, + ACTIONS(69), 1, + anon_sym_EQ_GT, + ACTIONS(75), 1, + sym__newline, + STATE(66), 1, + sym_return_statement, + STATE(94), 1, + sym_throw_statement, + ACTIONS(81), 3, + anon_sym_DOT, + anon_sym_POUND_GT, + anon_sym_COMMA, + [707] = 1, + ACTIONS(99), 7, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_POUND_GT, + anon_sym_COMMA, + anon_sym_GT, + [717] = 6, + ACTIONS(69), 1, + anon_sym_EQ_GT, + ACTIONS(73), 1, + anon_sym_POUND_GT, + ACTIONS(75), 1, + sym__newline, + STATE(55), 1, + sym_return_statement, + STATE(94), 1, + sym_throw_statement, + ACTIONS(81), 2, + anon_sym_DOT, + anon_sym_COMMA, + [737] = 2, + STATE(70), 1, + sym_throw_statement, + ACTIONS(101), 5, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_POUND_GT, + anon_sym_COMMA, + anon_sym_GT, + [748] = 3, + ACTIONS(61), 1, + anon_sym_POUND_GT, + STATE(81), 1, + sym_throw_statement, + ACTIONS(93), 4, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_COMMA, + anon_sym_GT, + [761] = 1, + ACTIONS(103), 6, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_POUND_GT, + anon_sym_COMMA, + anon_sym_GT, + [770] = 1, + ACTIONS(105), 6, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_POUND_GT, + anon_sym_COMMA, + anon_sym_GT, + [779] = 6, + ACTIONS(69), 1, + anon_sym_EQ_GT, + ACTIONS(77), 1, + anon_sym_POUND_GT, + ACTIONS(93), 1, + sym__newline, + ACTIONS(95), 1, + anon_sym_DOT, + STATE(101), 1, + sym_throw_statement, + STATE(105), 1, + sym_return_statement, + [798] = 3, + ACTIONS(61), 1, + anon_sym_POUND_GT, + STATE(72), 1, + sym_throw_statement, + ACTIONS(75), 4, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_COMMA, + anon_sym_GT, + [811] = 3, + ACTIONS(61), 1, + anon_sym_POUND_GT, + STATE(70), 1, + sym_throw_statement, + ACTIONS(101), 4, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_COMMA, + anon_sym_GT, + [824] = 2, + STATE(48), 1, + aux_sym__entry_list_repeat1, + ACTIONS(107), 5, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_POUND_GT, + anon_sym_COMMA, + anon_sym_GT, + [835] = 2, + STATE(72), 1, + sym_throw_statement, + ACTIONS(75), 5, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_POUND_GT, + anon_sym_COMMA, + anon_sym_GT, + [846] = 3, + ACTIONS(109), 1, + anon_sym_DOT, + STATE(47), 1, + aux_sym_entry_repeat1, + ACTIONS(111), 4, + anon_sym_RPAREN, + anon_sym_POUND_GT, + anon_sym_COMMA, + anon_sym_GT, + [859] = 2, + STATE(81), 1, + sym_throw_statement, + ACTIONS(93), 5, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_POUND_GT, + anon_sym_COMMA, + anon_sym_GT, + [870] = 2, + ACTIONS(99), 1, + sym__newline, + ACTIONS(113), 5, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_EQ_GT, + anon_sym_POUND_GT, + anon_sym_COMMA, + [881] = 6, + ACTIONS(69), 1, + anon_sym_EQ_GT, + ACTIONS(75), 1, + sym__newline, + ACTIONS(77), 1, + anon_sym_POUND_GT, + ACTIONS(81), 1, + anon_sym_DOT, + STATE(94), 1, + sym_throw_statement, + STATE(95), 1, + sym_return_statement, + [900] = 3, + ACTIONS(115), 1, + anon_sym_DOT, + STATE(47), 1, + aux_sym_entry_repeat1, + ACTIONS(118), 4, + anon_sym_RPAREN, + anon_sym_POUND_GT, + anon_sym_COMMA, + anon_sym_GT, + [913] = 3, + ACTIONS(122), 1, + anon_sym_COMMA, + STATE(48), 1, + aux_sym__entry_list_repeat1, + ACTIONS(120), 4, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_POUND_GT, + anon_sym_GT, + [926] = 3, + ACTIONS(109), 1, + anon_sym_DOT, + STATE(43), 1, + aux_sym_entry_repeat1, + ACTIONS(125), 4, + anon_sym_RPAREN, + anon_sym_POUND_GT, + anon_sym_COMMA, + anon_sym_GT, + [939] = 3, + ACTIONS(101), 1, + sym__newline, + STATE(104), 1, + sym_throw_statement, + ACTIONS(127), 3, + anon_sym_DOT, + anon_sym_POUND_GT, + anon_sym_COMMA, + [951] = 3, + ACTIONS(129), 1, + anon_sym_COMMA, + STATE(51), 1, + aux_sym__entry_list_repeat1, + ACTIONS(120), 3, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_GT, + [963] = 3, + ACTIONS(107), 1, + sym__newline, + STATE(63), 1, + aux_sym__entry_list_repeat1, + ACTIONS(132), 3, + anon_sym_DOT, + anon_sym_POUND_GT, + anon_sym_COMMA, + [975] = 4, + ACTIONS(134), 1, + ts_builtin_sym_end, + ACTIONS(138), 1, + sym__newline, + STATE(60), 1, + aux_sym_source_file_repeat1, + ACTIONS(136), 2, + anon_sym_SLASH_SLASH, + sym__label, + [989] = 4, + ACTIONS(73), 1, + anon_sym_POUND_GT, + ACTIONS(101), 1, + sym__newline, + STATE(104), 1, + sym_throw_statement, + ACTIONS(127), 2, + anon_sym_DOT, + anon_sym_COMMA, + [1003] = 4, + ACTIONS(73), 1, + anon_sym_POUND_GT, + ACTIONS(93), 1, + sym__newline, + STATE(101), 1, + sym_throw_statement, + ACTIONS(95), 2, + anon_sym_DOT, + anon_sym_COMMA, + [1017] = 4, + ACTIONS(142), 1, + anon_sym_COMMA, + ACTIONS(144), 1, + sym__newline, + STATE(59), 1, + aux_sym__entry_list_repeat1, + ACTIONS(140), 2, + anon_sym_DOT, + anon_sym_POUND_GT, + [1031] = 4, + ACTIONS(73), 1, + anon_sym_POUND_GT, + ACTIONS(75), 1, + sym__newline, + STATE(94), 1, + sym_throw_statement, + ACTIONS(81), 2, + anon_sym_DOT, + anon_sym_COMMA, + [1045] = 4, + ACTIONS(125), 1, + sym__newline, + ACTIONS(146), 1, + anon_sym_DOT, + STATE(78), 1, + aux_sym_entry_repeat1, + ACTIONS(148), 2, + anon_sym_POUND_GT, + anon_sym_COMMA, + [1059] = 4, + ACTIONS(107), 1, + sym__newline, + ACTIONS(142), 1, + anon_sym_COMMA, + STATE(63), 1, + aux_sym__entry_list_repeat1, + ACTIONS(132), 2, + anon_sym_DOT, + anon_sym_POUND_GT, + [1073] = 4, + ACTIONS(85), 1, + ts_builtin_sym_end, + ACTIONS(152), 1, + sym__newline, + STATE(79), 1, + aux_sym_source_file_repeat1, + ACTIONS(150), 2, + anon_sym_SLASH_SLASH, + sym__label, + [1087] = 2, + ACTIONS(103), 1, + sym__newline, + ACTIONS(154), 4, + anon_sym_DOT, + anon_sym_EQ_GT, + anon_sym_POUND_GT, + anon_sym_COMMA, + [1097] = 5, + ACTIONS(69), 1, + anon_sym_EQ_GT, + ACTIONS(77), 1, + anon_sym_POUND_GT, + ACTIONS(97), 1, + sym__newline, + STATE(110), 1, + sym_return_statement, + STATE(138), 1, + sym_throw_statement, + [1113] = 4, + ACTIONS(120), 1, + sym__newline, + ACTIONS(158), 1, + anon_sym_COMMA, + STATE(63), 1, + aux_sym__entry_list_repeat1, + ACTIONS(156), 2, + anon_sym_DOT, + anon_sym_POUND_GT, + [1127] = 2, + STATE(51), 1, + aux_sym__entry_list_repeat1, + ACTIONS(107), 4, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_COMMA, + anon_sym_GT, + [1137] = 3, + ACTIONS(161), 1, + anon_sym_DOT, + STATE(65), 1, + aux_sym_entry_repeat1, + ACTIONS(118), 3, + anon_sym_RPAREN, + anon_sym_COMMA, + anon_sym_GT, + [1149] = 3, + ACTIONS(93), 1, + sym__newline, + STATE(101), 1, + sym_throw_statement, + ACTIONS(95), 3, + anon_sym_DOT, + anon_sym_POUND_GT, + anon_sym_COMMA, + [1161] = 5, + ACTIONS(69), 1, + anon_sym_EQ_GT, + ACTIONS(77), 1, + anon_sym_POUND_GT, + ACTIONS(164), 1, + sym__newline, + STATE(116), 1, + sym_return_statement, + STATE(139), 1, + sym_throw_statement, + [1177] = 3, + ACTIONS(166), 1, + anon_sym_DOT, + STATE(65), 1, + aux_sym_entry_repeat1, + ACTIONS(111), 3, + anon_sym_RPAREN, + anon_sym_COMMA, + anon_sym_GT, + [1189] = 3, + ACTIONS(75), 1, + sym__newline, + STATE(94), 1, + sym_throw_statement, + ACTIONS(81), 3, + anon_sym_DOT, + anon_sym_POUND_GT, + anon_sym_COMMA, + [1201] = 1, + ACTIONS(168), 5, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_POUND_GT, + anon_sym_COMMA, + anon_sym_GT, + [1209] = 3, + ACTIONS(166), 1, + anon_sym_DOT, + STATE(68), 1, + aux_sym_entry_repeat1, + ACTIONS(125), 3, + anon_sym_RPAREN, + anon_sym_COMMA, + anon_sym_GT, + [1221] = 1, + ACTIONS(93), 5, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_POUND_GT, + anon_sym_COMMA, + anon_sym_GT, + [1229] = 1, + ACTIONS(120), 5, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_POUND_GT, + anon_sym_COMMA, + anon_sym_GT, + [1237] = 2, + ACTIONS(105), 1, + sym__newline, + ACTIONS(170), 4, + anon_sym_DOT, + anon_sym_EQ_GT, + anon_sym_POUND_GT, + anon_sym_COMMA, + [1247] = 1, + ACTIONS(75), 5, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_POUND_GT, + anon_sym_COMMA, + anon_sym_GT, + [1255] = 1, + ACTIONS(118), 5, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_POUND_GT, + anon_sym_COMMA, + anon_sym_GT, + [1263] = 4, + ACTIONS(118), 1, + sym__newline, + ACTIONS(172), 1, + anon_sym_DOT, + STATE(77), 1, + aux_sym_entry_repeat1, + ACTIONS(175), 2, + anon_sym_POUND_GT, + anon_sym_COMMA, + [1277] = 4, + ACTIONS(111), 1, + sym__newline, + ACTIONS(146), 1, + anon_sym_DOT, + STATE(77), 1, + aux_sym_entry_repeat1, + ACTIONS(177), 2, + anon_sym_POUND_GT, + anon_sym_COMMA, + [1291] = 4, + ACTIONS(179), 1, + ts_builtin_sym_end, + ACTIONS(183), 1, + sym__newline, + STATE(79), 1, + aux_sym_source_file_repeat1, + ACTIONS(181), 2, + anon_sym_SLASH_SLASH, + sym__label, + [1305] = 1, + ACTIONS(186), 5, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_POUND_GT, + anon_sym_COMMA, + anon_sym_GT, + [1313] = 1, + ACTIONS(101), 5, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_POUND_GT, + anon_sym_COMMA, + anon_sym_GT, + [1321] = 1, + ACTIONS(188), 5, + anon_sym_DOT, + anon_sym_RPAREN, + anon_sym_POUND_GT, + anon_sym_COMMA, + anon_sym_GT, + [1329] = 2, + ACTIONS(188), 1, + sym__newline, + ACTIONS(190), 3, + anon_sym_DOT, + anon_sym_POUND_GT, + anon_sym_COMMA, + [1338] = 2, + ACTIONS(186), 1, + sym__newline, + ACTIONS(192), 3, + anon_sym_DOT, + anon_sym_POUND_GT, + anon_sym_COMMA, + [1347] = 4, + ACTIONS(125), 1, + sym__newline, + ACTIONS(148), 1, + anon_sym_COMMA, + ACTIONS(194), 1, + anon_sym_DOT, + STATE(90), 1, + aux_sym_entry_repeat1, + [1360] = 4, + ACTIONS(196), 1, + anon_sym_RPAREN, + ACTIONS(198), 1, + sym__label, + STATE(108), 1, + sym_identifier, + STATE(135), 1, + sym__identifier_list, + [1373] = 4, + ACTIONS(118), 1, + sym__newline, + ACTIONS(175), 1, + anon_sym_COMMA, + ACTIONS(200), 1, + anon_sym_DOT, + STATE(87), 1, + aux_sym_entry_repeat1, + [1386] = 2, + ACTIONS(118), 1, + sym__newline, + ACTIONS(175), 3, + anon_sym_DOT, + anon_sym_POUND_GT, + anon_sym_COMMA, + [1395] = 2, + ACTIONS(120), 1, + sym__newline, + ACTIONS(156), 3, + anon_sym_DOT, + anon_sym_POUND_GT, + anon_sym_COMMA, + [1404] = 4, + ACTIONS(111), 1, + sym__newline, + ACTIONS(177), 1, + anon_sym_COMMA, + ACTIONS(194), 1, + anon_sym_DOT, + STATE(87), 1, + aux_sym_entry_repeat1, + [1417] = 4, + ACTIONS(198), 1, + sym__label, + STATE(71), 1, + sym_identifier, + STATE(123), 1, + sym_entry, + STATE(136), 1, + sym__entry_list, + [1430] = 3, + ACTIONS(107), 1, + sym__newline, + STATE(96), 1, + aux_sym__entry_list_repeat1, + ACTIONS(132), 2, + anon_sym_DOT, + anon_sym_COMMA, + [1441] = 4, + ACTIONS(203), 1, + sym__label, + STATE(83), 1, + sym__entry_list, + STATE(85), 1, + sym_identifier, + STATE(100), 1, + sym_entry, + [1454] = 2, + ACTIONS(93), 1, + sym__newline, + ACTIONS(95), 3, + anon_sym_DOT, + anon_sym_POUND_GT, + anon_sym_COMMA, + [1463] = 4, + ACTIONS(77), 1, + anon_sym_POUND_GT, + ACTIONS(93), 1, + sym__newline, + ACTIONS(95), 1, + anon_sym_DOT, + STATE(101), 1, + sym_throw_statement, + [1476] = 4, + ACTIONS(120), 1, + sym__newline, + ACTIONS(156), 1, + anon_sym_DOT, + ACTIONS(205), 1, + anon_sym_COMMA, + STATE(96), 1, + aux_sym__entry_list_repeat1, + [1489] = 4, + ACTIONS(198), 1, + sym__label, + STATE(71), 1, + sym_identifier, + STATE(123), 1, + sym_entry, + STATE(143), 1, + sym__entry_list, + [1502] = 3, + ACTIONS(198), 1, + sym__label, + STATE(71), 1, + sym_identifier, + STATE(82), 2, + sym_entry, + sym__entry_list, + [1513] = 4, + ACTIONS(107), 1, + sym__newline, + ACTIONS(132), 1, + anon_sym_DOT, + ACTIONS(208), 1, + anon_sym_COMMA, + STATE(96), 1, + aux_sym__entry_list_repeat1, + [1526] = 4, + ACTIONS(140), 1, + anon_sym_DOT, + ACTIONS(144), 1, + sym__newline, + ACTIONS(208), 1, + anon_sym_COMMA, + STATE(99), 1, + aux_sym__entry_list_repeat1, + [1539] = 2, + ACTIONS(101), 1, + sym__newline, + ACTIONS(127), 3, + anon_sym_DOT, + anon_sym_POUND_GT, + anon_sym_COMMA, + [1548] = 4, + ACTIONS(75), 1, + sym__newline, + ACTIONS(77), 1, + anon_sym_POUND_GT, + ACTIONS(81), 1, + anon_sym_DOT, + STATE(94), 1, + sym_throw_statement, + [1561] = 2, + ACTIONS(75), 1, + sym__newline, + ACTIONS(81), 3, + anon_sym_DOT, + anon_sym_POUND_GT, + anon_sym_COMMA, + [1570] = 2, + ACTIONS(168), 1, + sym__newline, + ACTIONS(210), 3, + anon_sym_DOT, + anon_sym_POUND_GT, + anon_sym_COMMA, + [1579] = 4, + ACTIONS(77), 1, + anon_sym_POUND_GT, + ACTIONS(101), 1, + sym__newline, + ACTIONS(127), 1, + anon_sym_DOT, + STATE(104), 1, + sym_throw_statement, + [1592] = 3, + ACTIONS(203), 1, + sym__label, + STATE(85), 1, + sym_identifier, + STATE(83), 2, + sym_entry, + sym__entry_list, + [1603] = 4, + ACTIONS(198), 1, + sym__label, + ACTIONS(212), 1, + anon_sym_RPAREN, + STATE(108), 1, + sym_identifier, + STATE(133), 1, + sym__identifier_list, + [1616] = 3, + ACTIONS(214), 1, + anon_sym_RPAREN, + ACTIONS(216), 1, + anon_sym_COMMA, + STATE(119), 1, + aux_sym__identifier_list_repeat1, + [1626] = 3, + ACTIONS(218), 1, + anon_sym_RPAREN, + ACTIONS(220), 1, + anon_sym_COMMA, + STATE(109), 1, + aux_sym__identifier_list_repeat1, + [1636] = 3, + ACTIONS(77), 1, + anon_sym_POUND_GT, + ACTIONS(164), 1, + sym__newline, + STATE(139), 1, + sym_throw_statement, + [1646] = 3, + ACTIONS(77), 1, + anon_sym_POUND_GT, + ACTIONS(97), 1, + sym__newline, + STATE(138), 1, + sym_throw_statement, + [1656] = 3, + ACTIONS(111), 1, + sym__newline, + ACTIONS(223), 1, + anon_sym_DOT, + STATE(124), 1, + aux_sym_entry_repeat1, + [1666] = 3, + ACTIONS(225), 1, + sym__label, + STATE(58), 1, + sym_identifier, + STATE(89), 1, + sym_entry, + [1676] = 3, + ACTIONS(227), 1, + sym__label, + STATE(49), 1, + sym_identifier, + STATE(80), 1, + sym_entry, + [1686] = 3, + ACTIONS(125), 1, + sym__newline, + ACTIONS(223), 1, + anon_sym_DOT, + STATE(112), 1, + aux_sym_entry_repeat1, + [1696] = 3, + ACTIONS(77), 1, + anon_sym_POUND_GT, + ACTIONS(229), 1, + sym__newline, + STATE(141), 1, + sym_throw_statement, + [1706] = 3, + ACTIONS(203), 1, + sym__label, + STATE(85), 1, + sym_identifier, + STATE(89), 1, + sym_entry, + [1716] = 3, + ACTIONS(227), 1, + sym__label, + STATE(49), 1, + sym_identifier, + STATE(73), 1, + sym_entry, + [1726] = 3, + ACTIONS(216), 1, + anon_sym_COMMA, + ACTIONS(231), 1, + anon_sym_RPAREN, + STATE(109), 1, + aux_sym__identifier_list_repeat1, + [1736] = 3, + ACTIONS(107), 1, + anon_sym_GT, + ACTIONS(233), 1, + anon_sym_COMMA, + STATE(51), 1, + aux_sym__entry_list_repeat1, + [1746] = 3, + ACTIONS(225), 1, + sym__label, + STATE(58), 1, + sym_identifier, + STATE(84), 1, + sym_entry, + [1756] = 3, + ACTIONS(198), 1, + sym__label, + STATE(71), 1, + sym_identifier, + STATE(73), 1, + sym_entry, + [1766] = 3, + ACTIONS(144), 1, + anon_sym_GT, + ACTIONS(233), 1, + anon_sym_COMMA, + STATE(120), 1, + aux_sym__entry_list_repeat1, + [1776] = 3, + ACTIONS(118), 1, + sym__newline, + ACTIONS(235), 1, + anon_sym_DOT, + STATE(124), 1, + aux_sym_entry_repeat1, + [1786] = 2, + ACTIONS(198), 1, + sym__label, + STATE(127), 1, + sym_identifier, + [1793] = 2, + ACTIONS(7), 1, + sym__label, + STATE(88), 1, + sym_identifier, + [1800] = 1, + ACTIONS(218), 2, + anon_sym_RPAREN, + anon_sym_COMMA, + [1805] = 2, + ACTIONS(227), 1, + sym__label, + STATE(76), 1, + sym_identifier, + [1812] = 2, + ACTIONS(198), 1, + sym__label, + STATE(76), 1, + sym_identifier, + [1819] = 2, + ACTIONS(203), 1, + sym__label, + STATE(88), 1, + sym_identifier, + [1826] = 2, + ACTIONS(225), 1, + sym__label, + STATE(88), 1, + sym_identifier, + [1833] = 1, + ACTIONS(238), 1, + aux_sym_comment_token1, + [1837] = 1, + ACTIONS(240), 1, + anon_sym_RPAREN, + [1841] = 1, + ACTIONS(242), 1, + sym__newline, + [1845] = 1, + ACTIONS(244), 1, + anon_sym_RPAREN, + [1849] = 1, + ACTIONS(246), 1, + anon_sym_GT, + [1853] = 1, + ACTIONS(97), 1, + sym__newline, + [1857] = 1, + ACTIONS(164), 1, + sym__newline, + [1861] = 1, + ACTIONS(229), 1, + sym__newline, + [1865] = 1, + ACTIONS(248), 1, + sym__newline, + [1869] = 1, + ACTIONS(250), 1, + sym__newline, + [1873] = 1, + ACTIONS(252), 1, + ts_builtin_sym_end, + [1877] = 1, + ACTIONS(254), 1, + anon_sym_GT, + [1881] = 1, + ACTIONS(256), 1, + sym__label, + [1885] = 1, + ACTIONS(258), 1, + sym__label, +}; + +static const uint32_t ts_small_parse_table_map[] = { + [SMALL_STATE(2)] = 0, + [SMALL_STATE(3)] = 31, + [SMALL_STATE(4)] = 62, + [SMALL_STATE(5)] = 93, + [SMALL_STATE(6)] = 112, + [SMALL_STATE(7)] = 131, + [SMALL_STATE(8)] = 150, + [SMALL_STATE(9)] = 169, + [SMALL_STATE(10)] = 188, + [SMALL_STATE(11)] = 207, + [SMALL_STATE(12)] = 238, + [SMALL_STATE(13)] = 267, + [SMALL_STATE(14)] = 297, + [SMALL_STATE(15)] = 329, + [SMALL_STATE(16)] = 354, + [SMALL_STATE(17)] = 377, + [SMALL_STATE(18)] = 408, + [SMALL_STATE(19)] = 436, + [SMALL_STATE(20)] = 462, + [SMALL_STATE(21)] = 486, + [SMALL_STATE(22)] = 509, + [SMALL_STATE(23)] = 532, + [SMALL_STATE(24)] = 549, + [SMALL_STATE(25)] = 574, + [SMALL_STATE(26)] = 591, + [SMALL_STATE(27)] = 610, + [SMALL_STATE(28)] = 629, + [SMALL_STATE(29)] = 649, + [SMALL_STATE(30)] = 667, + [SMALL_STATE(31)] = 689, + [SMALL_STATE(32)] = 707, + [SMALL_STATE(33)] = 717, + [SMALL_STATE(34)] = 737, + [SMALL_STATE(35)] = 748, + [SMALL_STATE(36)] = 761, + [SMALL_STATE(37)] = 770, + [SMALL_STATE(38)] = 779, + [SMALL_STATE(39)] = 798, + [SMALL_STATE(40)] = 811, + [SMALL_STATE(41)] = 824, + [SMALL_STATE(42)] = 835, + [SMALL_STATE(43)] = 846, + [SMALL_STATE(44)] = 859, + [SMALL_STATE(45)] = 870, + [SMALL_STATE(46)] = 881, + [SMALL_STATE(47)] = 900, + [SMALL_STATE(48)] = 913, + [SMALL_STATE(49)] = 926, + [SMALL_STATE(50)] = 939, + [SMALL_STATE(51)] = 951, + [SMALL_STATE(52)] = 963, + [SMALL_STATE(53)] = 975, + [SMALL_STATE(54)] = 989, + [SMALL_STATE(55)] = 1003, + [SMALL_STATE(56)] = 1017, + [SMALL_STATE(57)] = 1031, + [SMALL_STATE(58)] = 1045, + [SMALL_STATE(59)] = 1059, + [SMALL_STATE(60)] = 1073, + [SMALL_STATE(61)] = 1087, + [SMALL_STATE(62)] = 1097, + [SMALL_STATE(63)] = 1113, + [SMALL_STATE(64)] = 1127, + [SMALL_STATE(65)] = 1137, + [SMALL_STATE(66)] = 1149, + [SMALL_STATE(67)] = 1161, + [SMALL_STATE(68)] = 1177, + [SMALL_STATE(69)] = 1189, + [SMALL_STATE(70)] = 1201, + [SMALL_STATE(71)] = 1209, + [SMALL_STATE(72)] = 1221, + [SMALL_STATE(73)] = 1229, + [SMALL_STATE(74)] = 1237, + [SMALL_STATE(75)] = 1247, + [SMALL_STATE(76)] = 1255, + [SMALL_STATE(77)] = 1263, + [SMALL_STATE(78)] = 1277, + [SMALL_STATE(79)] = 1291, + [SMALL_STATE(80)] = 1305, + [SMALL_STATE(81)] = 1313, + [SMALL_STATE(82)] = 1321, + [SMALL_STATE(83)] = 1329, + [SMALL_STATE(84)] = 1338, + [SMALL_STATE(85)] = 1347, + [SMALL_STATE(86)] = 1360, + [SMALL_STATE(87)] = 1373, + [SMALL_STATE(88)] = 1386, + [SMALL_STATE(89)] = 1395, + [SMALL_STATE(90)] = 1404, + [SMALL_STATE(91)] = 1417, + [SMALL_STATE(92)] = 1430, + [SMALL_STATE(93)] = 1441, + [SMALL_STATE(94)] = 1454, + [SMALL_STATE(95)] = 1463, + [SMALL_STATE(96)] = 1476, + [SMALL_STATE(97)] = 1489, + [SMALL_STATE(98)] = 1502, + [SMALL_STATE(99)] = 1513, + [SMALL_STATE(100)] = 1526, + [SMALL_STATE(101)] = 1539, + [SMALL_STATE(102)] = 1548, + [SMALL_STATE(103)] = 1561, + [SMALL_STATE(104)] = 1570, + [SMALL_STATE(105)] = 1579, + [SMALL_STATE(106)] = 1592, + [SMALL_STATE(107)] = 1603, + [SMALL_STATE(108)] = 1616, + [SMALL_STATE(109)] = 1626, + [SMALL_STATE(110)] = 1636, + [SMALL_STATE(111)] = 1646, + [SMALL_STATE(112)] = 1656, + [SMALL_STATE(113)] = 1666, + [SMALL_STATE(114)] = 1676, + [SMALL_STATE(115)] = 1686, + [SMALL_STATE(116)] = 1696, + [SMALL_STATE(117)] = 1706, + [SMALL_STATE(118)] = 1716, + [SMALL_STATE(119)] = 1726, + [SMALL_STATE(120)] = 1736, + [SMALL_STATE(121)] = 1746, + [SMALL_STATE(122)] = 1756, + [SMALL_STATE(123)] = 1766, + [SMALL_STATE(124)] = 1776, + [SMALL_STATE(125)] = 1786, + [SMALL_STATE(126)] = 1793, + [SMALL_STATE(127)] = 1800, + [SMALL_STATE(128)] = 1805, + [SMALL_STATE(129)] = 1812, + [SMALL_STATE(130)] = 1819, + [SMALL_STATE(131)] = 1826, + [SMALL_STATE(132)] = 1833, + [SMALL_STATE(133)] = 1837, + [SMALL_STATE(134)] = 1841, + [SMALL_STATE(135)] = 1845, + [SMALL_STATE(136)] = 1849, + [SMALL_STATE(137)] = 1853, + [SMALL_STATE(138)] = 1857, + [SMALL_STATE(139)] = 1861, + [SMALL_STATE(140)] = 1865, + [SMALL_STATE(141)] = 1869, + [SMALL_STATE(142)] = 1873, + [SMALL_STATE(143)] = 1877, + [SMALL_STATE(144)] = 1881, + [SMALL_STATE(145)] = 1885, +}; + +static const TSParseActionEntry ts_parse_actions[] = { + [0] = {.entry = {.count = 0, .reusable = false}}, + [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(), + [3] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 0), + [5] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), + [7] = {.entry = {.count = 1, .reusable = true}}, SHIFT(17), + [9] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_definition, 3), + [11] = {.entry = {.count = 1, .reusable = false}}, SHIFT(144), + [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(132), + [15] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_definition, 3), + [17] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_definition, 2), + [19] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_definition, 2), + [21] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_definition_repeat1, 2), + [23] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_definition_repeat1, 2), SHIFT_REPEAT(144), + [26] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_definition_repeat1, 2), SHIFT_REPEAT(132), + [29] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_definition_repeat1, 2), + [31] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_member, 4), + [33] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_member, 4), + [35] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_member, 7), + [37] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_member, 7), + [39] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_member, 6), + [41] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_member, 6), + [43] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_member, 3), + [45] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_member, 3), + [47] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comment, 3), + [49] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_comment, 3), + [51] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_member, 5), + [53] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_member, 5), + [55] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier, 1), + [57] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), + [59] = {.entry = {.count = 1, .reusable = true}}, SHIFT(114), + [61] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), + [63] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91), + [65] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_identifier, 1), + [67] = {.entry = {.count = 1, .reusable = false}}, SHIFT(107), + [69] = {.entry = {.count = 1, .reusable = false}}, SHIFT(121), + [71] = {.entry = {.count = 1, .reusable = false}}, SHIFT(97), + [73] = {.entry = {.count = 1, .reusable = false}}, SHIFT(106), + [75] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier, 2), + [77] = {.entry = {.count = 1, .reusable = false}}, SHIFT(93), + [79] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8), + [81] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_identifier, 2), + [83] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 1), + [85] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_file_repeat2, 2), + [87] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat2, 2), SHIFT_REPEAT(132), + [90] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat2, 2), SHIFT_REPEAT(17), + [93] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier, 3), + [95] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_identifier, 3), + [97] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5), + [99] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_annotation, 3), + [101] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier, 4), + [103] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 2), + [105] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 3), + [107] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__entry_list, 2), + [109] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), + [111] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_entry, 2), + [113] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_annotation, 3), + [115] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_entry_repeat1, 2), SHIFT_REPEAT(128), + [118] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_entry_repeat1, 2), + [120] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__entry_list_repeat1, 2), + [122] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__entry_list_repeat1, 2), SHIFT_REPEAT(118), + [125] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_entry, 1), + [127] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_identifier, 4), + [129] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__entry_list_repeat1, 2), SHIFT_REPEAT(122), + [132] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__entry_list, 2), + [134] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_file_repeat2, 1), + [136] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_source_file_repeat2, 1), + [138] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), + [140] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__entry_list, 1), + [142] = {.entry = {.count = 1, .reusable = false}}, SHIFT(113), + [144] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__entry_list, 1), + [146] = {.entry = {.count = 1, .reusable = false}}, SHIFT(131), + [148] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_entry, 1), + [150] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_source_file_repeat2, 2), + [152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), + [154] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parameter_list, 2), + [156] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__entry_list_repeat1, 2), + [158] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__entry_list_repeat1, 2), SHIFT_REPEAT(113), + [161] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_entry_repeat1, 2), SHIFT_REPEAT(129), + [164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), + [166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), + [168] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier, 5), + [170] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parameter_list, 3), + [172] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_entry_repeat1, 2), SHIFT_REPEAT(131), + [175] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_entry_repeat1, 2), + [177] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_entry, 2), + [179] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2), + [181] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2), + [183] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2), SHIFT_REPEAT(79), + [186] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_return_statement, 2), + [188] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_throw_statement, 2), + [190] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_throw_statement, 2), + [192] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_return_statement, 2), + [194] = {.entry = {.count = 1, .reusable = false}}, SHIFT(130), + [196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), + [198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11), + [200] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_entry_repeat1, 2), SHIFT_REPEAT(130), + [203] = {.entry = {.count = 1, .reusable = true}}, SHIFT(14), + [205] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__entry_list_repeat1, 2), SHIFT_REPEAT(117), + [208] = {.entry = {.count = 1, .reusable = false}}, SHIFT(117), + [210] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_identifier, 5), + [212] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), + [214] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__identifier_list, 1), + [216] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125), + [218] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__identifier_list_repeat1, 2), + [220] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__identifier_list_repeat1, 2), SHIFT_REPEAT(125), + [223] = {.entry = {.count = 1, .reusable = false}}, SHIFT(126), + [225] = {.entry = {.count = 1, .reusable = true}}, SHIFT(13), + [227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(12), + [229] = {.entry = {.count = 1, .reusable = true}}, SHIFT(7), + [231] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__identifier_list, 2), + [233] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), + [235] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_entry_repeat1, 2), SHIFT_REPEAT(126), + [238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), + [240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), + [242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), + [244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), + [246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32), + [248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3), + [250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(6), + [252] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), + [254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), + [256] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_member_type, 1), + [258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18), +}; + +#ifdef __cplusplus +extern "C" { +#endif +#ifdef _WIN32 +#define extern __declspec(dllexport) +#endif + +extern const TSLanguage *tree_sitter_apinotation(void) { + static const TSLanguage language = { + .version = LANGUAGE_VERSION, + .symbol_count = SYMBOL_COUNT, + .alias_count = ALIAS_COUNT, + .token_count = TOKEN_COUNT, + .external_token_count = EXTERNAL_TOKEN_COUNT, + .state_count = STATE_COUNT, + .large_state_count = LARGE_STATE_COUNT, + .production_id_count = PRODUCTION_ID_COUNT, + .field_count = FIELD_COUNT, + .max_alias_sequence_length = MAX_ALIAS_SEQUENCE_LENGTH, + .parse_table = &ts_parse_table[0][0], + .small_parse_table = ts_small_parse_table, + .small_parse_table_map = ts_small_parse_table_map, + .parse_actions = ts_parse_actions, + .symbol_names = ts_symbol_names, + .symbol_metadata = ts_symbol_metadata, + .public_symbol_map = ts_symbol_map, + .alias_map = ts_non_terminal_alias_map, + .alias_sequences = &ts_alias_sequences[0][0], + .lex_modes = ts_lex_modes, + .lex_fn = ts_lex, + .primary_state_ids = ts_primary_state_ids, + }; + return &language; +} +#ifdef __cplusplus +} +#endif diff --git a/src/tree_sitter/parser.h b/src/tree_sitter/parser.h new file mode 100644 index 0000000..2b14ac1 --- /dev/null +++ b/src/tree_sitter/parser.h @@ -0,0 +1,224 @@ +#ifndef TREE_SITTER_PARSER_H_ +#define TREE_SITTER_PARSER_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include <stdbool.h> +#include <stdint.h> +#include <stdlib.h> + +#define ts_builtin_sym_error ((TSSymbol)-1) +#define ts_builtin_sym_end 0 +#define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024 + +typedef uint16_t TSStateId; + +#ifndef TREE_SITTER_API_H_ +typedef uint16_t TSSymbol; +typedef uint16_t TSFieldId; +typedef struct TSLanguage TSLanguage; +#endif + +typedef struct { + TSFieldId field_id; + uint8_t child_index; + bool inherited; +} TSFieldMapEntry; + +typedef struct { + uint16_t index; + uint16_t length; +} TSFieldMapSlice; + +typedef struct { + bool visible; + bool named; + bool supertype; +} TSSymbolMetadata; + +typedef struct TSLexer TSLexer; + +struct TSLexer { + int32_t lookahead; + TSSymbol result_symbol; + void (*advance)(TSLexer *, bool); + void (*mark_end)(TSLexer *); + uint32_t (*get_column)(TSLexer *); + bool (*is_at_included_range_start)(const TSLexer *); + bool (*eof)(const TSLexer *); +}; + +typedef enum { + TSParseActionTypeShift, + TSParseActionTypeReduce, + TSParseActionTypeAccept, + TSParseActionTypeRecover, +} TSParseActionType; + +typedef union { + struct { + uint8_t type; + TSStateId state; + bool extra; + bool repetition; + } shift; + struct { + uint8_t type; + uint8_t child_count; + TSSymbol symbol; + int16_t dynamic_precedence; + uint16_t production_id; + } reduce; + uint8_t type; +} TSParseAction; + +typedef struct { + uint16_t lex_state; + uint16_t external_lex_state; +} TSLexMode; + +typedef union { + TSParseAction action; + struct { + uint8_t count; + bool reusable; + } entry; +} TSParseActionEntry; + +struct TSLanguage { + uint32_t version; + uint32_t symbol_count; + uint32_t alias_count; + uint32_t token_count; + uint32_t external_token_count; + uint32_t state_count; + uint32_t large_state_count; + uint32_t production_id_count; + uint32_t field_count; + uint16_t max_alias_sequence_length; + const uint16_t *parse_table; + const uint16_t *small_parse_table; + const uint32_t *small_parse_table_map; + const TSParseActionEntry *parse_actions; + const char * const *symbol_names; + const char * const *field_names; + const TSFieldMapSlice *field_map_slices; + const TSFieldMapEntry *field_map_entries; + const TSSymbolMetadata *symbol_metadata; + const TSSymbol *public_symbol_map; + const uint16_t *alias_map; + const TSSymbol *alias_sequences; + const TSLexMode *lex_modes; + bool (*lex_fn)(TSLexer *, TSStateId); + bool (*keyword_lex_fn)(TSLexer *, TSStateId); + TSSymbol keyword_capture_token; + struct { + const bool *states; + const TSSymbol *symbol_map; + void *(*create)(void); + void (*destroy)(void *); + bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist); + unsigned (*serialize)(void *, char *); + void (*deserialize)(void *, const char *, unsigned); + } external_scanner; + const TSStateId *primary_state_ids; +}; + +/* + * Lexer Macros + */ + +#define START_LEXER() \ + bool result = false; \ + bool skip = false; \ + bool eof = false; \ + int32_t lookahead; \ + goto start; \ + next_state: \ + lexer->advance(lexer, skip); \ + start: \ + skip = false; \ + lookahead = lexer->lookahead; + +#define ADVANCE(state_value) \ + { \ + state = state_value; \ + goto next_state; \ + } + +#define SKIP(state_value) \ + { \ + skip = true; \ + state = state_value; \ + goto next_state; \ + } + +#define ACCEPT_TOKEN(symbol_value) \ + result = true; \ + lexer->result_symbol = symbol_value; \ + lexer->mark_end(lexer); + +#define END_STATE() return result; + +/* + * Parse Table Macros + */ + +#define SMALL_STATE(id) id - LARGE_STATE_COUNT + +#define STATE(id) id + +#define ACTIONS(id) id + +#define SHIFT(state_value) \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .state = state_value \ + } \ + }} + +#define SHIFT_REPEAT(state_value) \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .state = state_value, \ + .repetition = true \ + } \ + }} + +#define SHIFT_EXTRA() \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .extra = true \ + } \ + }} + +#define REDUCE(symbol_val, child_count_val, ...) \ + {{ \ + .reduce = { \ + .type = TSParseActionTypeReduce, \ + .symbol = symbol_val, \ + .child_count = child_count_val, \ + __VA_ARGS__ \ + }, \ + }} + +#define RECOVER() \ + {{ \ + .type = TSParseActionTypeRecover \ + }} + +#define ACCEPT_INPUT() \ + {{ \ + .type = TSParseActionTypeAccept \ + }} + +#ifdef __cplusplus +} +#endif + +#endif // TREE_SITTER_PARSER_H_ |