1#include <tree_sitter/parser.h>
2
3#if defined(__GNUC__) || defined(__clang__)
4#pragma GCC diagnostic push
5#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
6#endif
7
8#define LANGUAGE_VERSION 13
9#define STATE_COUNT 18
10#define LARGE_STATE_COUNT 6
11#define SYMBOL_COUNT 17
12#define ALIAS_COUNT 0
13#define TOKEN_COUNT 9
14#define EXTERNAL_TOKEN_COUNT 0
15#define FIELD_COUNT 3
16#define MAX_ALIAS_SEQUENCE_LENGTH 3
17#define PRODUCTION_ID_COUNT 3
18
19enum {
20 sym_identifier = 1,
21 anon_sym_BANG = 2,
22 anon_sym_AMP_AMP = 3,
23 anon_sym_PIPE_PIPE = 4,
24 anon_sym_EQ_EQ = 5,
25 anon_sym_BANG_EQ = 6,
26 anon_sym_LPAREN = 7,
27 anon_sym_RPAREN = 8,
28 sym_source = 9,
29 sym__expression = 10,
30 sym_not = 11,
31 sym_and = 12,
32 sym_or = 13,
33 sym_equal = 14,
34 sym_not_equal = 15,
35 sym_parenthesized = 16,
36};
37
38static const char *const ts_symbol_names[] = {
39 [ts_builtin_sym_end] = "end",
40 [sym_identifier] = "identifier",
41 [anon_sym_BANG] = "!",
42 [anon_sym_AMP_AMP] = "&&",
43 [anon_sym_PIPE_PIPE] = "||",
44 [anon_sym_EQ_EQ] = "==",
45 [anon_sym_BANG_EQ] = "!=",
46 [anon_sym_LPAREN] = "(",
47 [anon_sym_RPAREN] = ")",
48 [sym_source] = "source",
49 [sym__expression] = "_expression",
50 [sym_not] = "not",
51 [sym_and] = "and",
52 [sym_or] = "or",
53 [sym_equal] = "equal",
54 [sym_not_equal] = "not_equal",
55 [sym_parenthesized] = "parenthesized",
56};
57
58static const TSSymbol ts_symbol_map[] = {
59 [ts_builtin_sym_end] = ts_builtin_sym_end,
60 [sym_identifier] = sym_identifier,
61 [anon_sym_BANG] = anon_sym_BANG,
62 [anon_sym_AMP_AMP] = anon_sym_AMP_AMP,
63 [anon_sym_PIPE_PIPE] = anon_sym_PIPE_PIPE,
64 [anon_sym_EQ_EQ] = anon_sym_EQ_EQ,
65 [anon_sym_BANG_EQ] = anon_sym_BANG_EQ,
66 [anon_sym_LPAREN] = anon_sym_LPAREN,
67 [anon_sym_RPAREN] = anon_sym_RPAREN,
68 [sym_source] = sym_source,
69 [sym__expression] = sym__expression,
70 [sym_not] = sym_not,
71 [sym_and] = sym_and,
72 [sym_or] = sym_or,
73 [sym_equal] = sym_equal,
74 [sym_not_equal] = sym_not_equal,
75 [sym_parenthesized] = sym_parenthesized,
76};
77
78static const TSSymbolMetadata ts_symbol_metadata[] = {
79 [ts_builtin_sym_end] =
80 {
81 .visible = false,
82 .named = true,
83 },
84 [sym_identifier] =
85 {
86 .visible = true,
87 .named = true,
88 },
89 [anon_sym_BANG] =
90 {
91 .visible = true,
92 .named = false,
93 },
94 [anon_sym_AMP_AMP] =
95 {
96 .visible = true,
97 .named = false,
98 },
99 [anon_sym_PIPE_PIPE] =
100 {
101 .visible = true,
102 .named = false,
103 },
104 [anon_sym_EQ_EQ] =
105 {
106 .visible = true,
107 .named = false,
108 },
109 [anon_sym_BANG_EQ] =
110 {
111 .visible = true,
112 .named = false,
113 },
114 [anon_sym_LPAREN] =
115 {
116 .visible = true,
117 .named = false,
118 },
119 [anon_sym_RPAREN] =
120 {
121 .visible = true,
122 .named = false,
123 },
124 [sym_source] =
125 {
126 .visible = true,
127 .named = true,
128 },
129 [sym__expression] =
130 {
131 .visible = false,
132 .named = true,
133 },
134 [sym_not] =
135 {
136 .visible = true,
137 .named = true,
138 },
139 [sym_and] =
140 {
141 .visible = true,
142 .named = true,
143 },
144 [sym_or] =
145 {
146 .visible = true,
147 .named = true,
148 },
149 [sym_equal] =
150 {
151 .visible = true,
152 .named = true,
153 },
154 [sym_not_equal] =
155 {
156 .visible = true,
157 .named = true,
158 },
159 [sym_parenthesized] =
160 {
161 .visible = true,
162 .named = true,
163 },
164};
165
166enum {
167 field_expression = 1,
168 field_left = 2,
169 field_right = 3,
170};
171
172static const char *const ts_field_names[] = {
173 [0] = NULL,
174 [field_expression] = "expression",
175 [field_left] = "left",
176 [field_right] = "right",
177};
178
179static const TSFieldMapSlice ts_field_map_slices[PRODUCTION_ID_COUNT] = {
180 [1] = {.index = 0, .length = 1},
181 [2] = {.index = 1, .length = 2},
182};
183
184static const TSFieldMapEntry ts_field_map_entries[] = {
185 [0] = {field_expression, 1},
186 [1] = {field_left, 0},
187 {field_right, 2},
188};
189
190static const TSSymbol ts_alias_sequences[PRODUCTION_ID_COUNT]
191 [MAX_ALIAS_SEQUENCE_LENGTH] = {
192 [0] = {0},
193};
194
195static const uint16_t ts_non_terminal_alias_map[] = {
196 0,
197};
198
199static bool ts_lex(TSLexer *lexer, TSStateId state) {
200 START_LEXER();
201 eof = lexer->eof(lexer);
202 switch (state) {
203 case 0:
204 if (eof)
205 ADVANCE(7);
206 if (lookahead == '!')
207 ADVANCE(10);
208 if (lookahead == '&')
209 ADVANCE(2);
210 if (lookahead == '(')
211 ADVANCE(15);
212 if (lookahead == ')')
213 ADVANCE(16);
214 if (lookahead == '=')
215 ADVANCE(4);
216 if (lookahead == '|')
217 ADVANCE(5);
218 if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' ||
219 lookahead == ' ')
220 SKIP(0)
221 if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') ||
222 ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' ||
223 ('a' <= lookahead && lookahead <= 'z'))
224 ADVANCE(8);
225 END_STATE();
226 case 1:
227 if (lookahead == '!')
228 ADVANCE(9);
229 if (lookahead == '(')
230 ADVANCE(15);
231 if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' ||
232 lookahead == ' ')
233 SKIP(1)
234 if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') ||
235 ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' ||
236 ('a' <= lookahead && lookahead <= 'z'))
237 ADVANCE(8);
238 END_STATE();
239 case 2:
240 if (lookahead == '&')
241 ADVANCE(11);
242 END_STATE();
243 case 3:
244 if (lookahead == '=')
245 ADVANCE(14);
246 END_STATE();
247 case 4:
248 if (lookahead == '=')
249 ADVANCE(13);
250 END_STATE();
251 case 5:
252 if (lookahead == '|')
253 ADVANCE(12);
254 END_STATE();
255 case 6:
256 if (eof)
257 ADVANCE(7);
258 if (lookahead == '!')
259 ADVANCE(3);
260 if (lookahead == '&')
261 ADVANCE(2);
262 if (lookahead == ')')
263 ADVANCE(16);
264 if (lookahead == '=')
265 ADVANCE(4);
266 if (lookahead == '|')
267 ADVANCE(5);
268 if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' ||
269 lookahead == ' ')
270 SKIP(6)
271 END_STATE();
272 case 7:
273 ACCEPT_TOKEN(ts_builtin_sym_end);
274 END_STATE();
275 case 8:
276 ACCEPT_TOKEN(sym_identifier);
277 if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') ||
278 ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' ||
279 ('a' <= lookahead && lookahead <= 'z'))
280 ADVANCE(8);
281 END_STATE();
282 case 9:
283 ACCEPT_TOKEN(anon_sym_BANG);
284 END_STATE();
285 case 10:
286 ACCEPT_TOKEN(anon_sym_BANG);
287 if (lookahead == '=')
288 ADVANCE(14);
289 END_STATE();
290 case 11:
291 ACCEPT_TOKEN(anon_sym_AMP_AMP);
292 END_STATE();
293 case 12:
294 ACCEPT_TOKEN(anon_sym_PIPE_PIPE);
295 END_STATE();
296 case 13:
297 ACCEPT_TOKEN(anon_sym_EQ_EQ);
298 END_STATE();
299 case 14:
300 ACCEPT_TOKEN(anon_sym_BANG_EQ);
301 END_STATE();
302 case 15:
303 ACCEPT_TOKEN(anon_sym_LPAREN);
304 END_STATE();
305 case 16:
306 ACCEPT_TOKEN(anon_sym_RPAREN);
307 END_STATE();
308 default:
309 return false;
310 }
311}
312
313static const TSLexMode ts_lex_modes[STATE_COUNT] = {
314 [0] = {.lex_state = 0}, [1] = {.lex_state = 1}, [2] = {.lex_state = 1},
315 [3] = {.lex_state = 1}, [4] = {.lex_state = 1}, [5] = {.lex_state = 1},
316 [6] = {.lex_state = 6}, [7] = {.lex_state = 0}, [8] = {.lex_state = 0},
317 [9] = {.lex_state = 0}, [10] = {.lex_state = 0}, [11] = {.lex_state = 0},
318 [12] = {.lex_state = 0}, [13] = {.lex_state = 0}, [14] = {.lex_state = 0},
319 [15] = {.lex_state = 0}, [16] = {.lex_state = 0}, [17] = {.lex_state = 0},
320};
321
322static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
323 [0] =
324 {
325 [ts_builtin_sym_end] = ACTIONS(1),
326 [sym_identifier] = ACTIONS(1),
327 [anon_sym_BANG] = ACTIONS(1),
328 [anon_sym_AMP_AMP] = ACTIONS(1),
329 [anon_sym_PIPE_PIPE] = ACTIONS(1),
330 [anon_sym_EQ_EQ] = ACTIONS(1),
331 [anon_sym_BANG_EQ] = ACTIONS(1),
332 [anon_sym_LPAREN] = ACTIONS(1),
333 [anon_sym_RPAREN] = ACTIONS(1),
334 },
335 [1] =
336 {
337 [sym_source] = STATE(15),
338 [sym__expression] = STATE(13),
339 [sym_not] = STATE(13),
340 [sym_and] = STATE(13),
341 [sym_or] = STATE(13),
342 [sym_equal] = STATE(13),
343 [sym_not_equal] = STATE(13),
344 [sym_parenthesized] = STATE(13),
345 [sym_identifier] = ACTIONS(3),
346 [anon_sym_BANG] = ACTIONS(5),
347 [anon_sym_LPAREN] = ACTIONS(7),
348 },
349 [2] =
350 {
351 [sym__expression] = STATE(7),
352 [sym_not] = STATE(7),
353 [sym_and] = STATE(7),
354 [sym_or] = STATE(7),
355 [sym_equal] = STATE(7),
356 [sym_not_equal] = STATE(7),
357 [sym_parenthesized] = STATE(7),
358 [sym_identifier] = ACTIONS(3),
359 [anon_sym_BANG] = ACTIONS(5),
360 [anon_sym_LPAREN] = ACTIONS(7),
361 },
362 [3] =
363 {
364 [sym__expression] = STATE(14),
365 [sym_not] = STATE(14),
366 [sym_and] = STATE(14),
367 [sym_or] = STATE(14),
368 [sym_equal] = STATE(14),
369 [sym_not_equal] = STATE(14),
370 [sym_parenthesized] = STATE(14),
371 [sym_identifier] = ACTIONS(3),
372 [anon_sym_BANG] = ACTIONS(5),
373 [anon_sym_LPAREN] = ACTIONS(7),
374 },
375 [4] =
376 {
377 [sym__expression] = STATE(11),
378 [sym_not] = STATE(11),
379 [sym_and] = STATE(11),
380 [sym_or] = STATE(11),
381 [sym_equal] = STATE(11),
382 [sym_not_equal] = STATE(11),
383 [sym_parenthesized] = STATE(11),
384 [sym_identifier] = ACTIONS(3),
385 [anon_sym_BANG] = ACTIONS(5),
386 [anon_sym_LPAREN] = ACTIONS(7),
387 },
388 [5] =
389 {
390 [sym__expression] = STATE(12),
391 [sym_not] = STATE(12),
392 [sym_and] = STATE(12),
393 [sym_or] = STATE(12),
394 [sym_equal] = STATE(12),
395 [sym_not_equal] = STATE(12),
396 [sym_parenthesized] = STATE(12),
397 [sym_identifier] = ACTIONS(3),
398 [anon_sym_BANG] = ACTIONS(5),
399 [anon_sym_LPAREN] = ACTIONS(7),
400 },
401};
402
403static const uint16_t ts_small_parse_table[] = {
404 [0] = 3,
405 ACTIONS(11),
406 1,
407 anon_sym_EQ_EQ,
408 ACTIONS(13),
409 1,
410 anon_sym_BANG_EQ,
411 ACTIONS(9),
412 4,
413 ts_builtin_sym_end,
414 anon_sym_AMP_AMP,
415 anon_sym_PIPE_PIPE,
416 anon_sym_RPAREN,
417 [13] = 1,
418 ACTIONS(15),
419 4,
420 ts_builtin_sym_end,
421 anon_sym_AMP_AMP,
422 anon_sym_PIPE_PIPE,
423 anon_sym_RPAREN,
424 [20] = 1,
425 ACTIONS(17),
426 4,
427 ts_builtin_sym_end,
428 anon_sym_AMP_AMP,
429 anon_sym_PIPE_PIPE,
430 anon_sym_RPAREN,
431 [27] = 1,
432 ACTIONS(19),
433 4,
434 ts_builtin_sym_end,
435 anon_sym_AMP_AMP,
436 anon_sym_PIPE_PIPE,
437 anon_sym_RPAREN,
438 [34] = 1,
439 ACTIONS(21),
440 4,
441 ts_builtin_sym_end,
442 anon_sym_AMP_AMP,
443 anon_sym_PIPE_PIPE,
444 anon_sym_RPAREN,
445 [41] = 1,
446 ACTIONS(23),
447 4,
448 ts_builtin_sym_end,
449 anon_sym_AMP_AMP,
450 anon_sym_PIPE_PIPE,
451 anon_sym_RPAREN,
452 [48] = 2,
453 ACTIONS(27),
454 1,
455 anon_sym_AMP_AMP,
456 ACTIONS(25),
457 3,
458 ts_builtin_sym_end,
459 anon_sym_PIPE_PIPE,
460 anon_sym_RPAREN,
461 [57] = 3,
462 ACTIONS(27),
463 1,
464 anon_sym_AMP_AMP,
465 ACTIONS(29),
466 1,
467 ts_builtin_sym_end,
468 ACTIONS(31),
469 1,
470 anon_sym_PIPE_PIPE,
471 [67] = 3,
472 ACTIONS(27),
473 1,
474 anon_sym_AMP_AMP,
475 ACTIONS(31),
476 1,
477 anon_sym_PIPE_PIPE,
478 ACTIONS(33),
479 1,
480 anon_sym_RPAREN,
481 [77] = 1,
482 ACTIONS(35),
483 1,
484 ts_builtin_sym_end,
485 [81] = 1,
486 ACTIONS(37),
487 1,
488 sym_identifier,
489 [85] = 1,
490 ACTIONS(39),
491 1,
492 sym_identifier,
493};
494
495static const uint32_t ts_small_parse_table_map[] = {
496 [SMALL_STATE(6)] = 0, [SMALL_STATE(7)] = 13, [SMALL_STATE(8)] = 20,
497 [SMALL_STATE(9)] = 27, [SMALL_STATE(10)] = 34, [SMALL_STATE(11)] = 41,
498 [SMALL_STATE(12)] = 48, [SMALL_STATE(13)] = 57, [SMALL_STATE(14)] = 67,
499 [SMALL_STATE(15)] = 77, [SMALL_STATE(16)] = 81, [SMALL_STATE(17)] = 85,
500};
501
502static const TSParseActionEntry ts_parse_actions[] = {
503 [0] = {.entry = {.count = 0, .reusable = false}},
504 [1] = {.entry = {.count = 1, .reusable = false}},
505 RECOVER(),
506 [3] = {.entry = {.count = 1, .reusable = true}},
507 SHIFT(6),
508 [5] = {.entry = {.count = 1, .reusable = true}},
509 SHIFT(2),
510 [7] = {.entry = {.count = 1, .reusable = true}},
511 SHIFT(3),
512 [9] = {.entry = {.count = 1, .reusable = true}},
513 REDUCE(sym__expression, 1),
514 [11] = {.entry = {.count = 1, .reusable = true}},
515 SHIFT(16),
516 [13] = {.entry = {.count = 1, .reusable = true}},
517 SHIFT(17),
518 [15] = {.entry = {.count = 1, .reusable = true}},
519 REDUCE(sym_not, 2, .production_id = 1),
520 [17] = {.entry = {.count = 1, .reusable = true}},
521 REDUCE(sym_equal, 3, .production_id = 2),
522 [19] = {.entry = {.count = 1, .reusable = true}},
523 REDUCE(sym_not_equal, 3, .production_id = 2),
524 [21] = {.entry = {.count = 1, .reusable = true}},
525 REDUCE(sym_parenthesized, 3, .production_id = 1),
526 [23] = {.entry = {.count = 1, .reusable = true}},
527 REDUCE(sym_and, 3, .production_id = 2),
528 [25] = {.entry = {.count = 1, .reusable = true}},
529 REDUCE(sym_or, 3, .production_id = 2),
530 [27] = {.entry = {.count = 1, .reusable = true}},
531 SHIFT(4),
532 [29] = {.entry = {.count = 1, .reusable = true}},
533 REDUCE(sym_source, 1),
534 [31] = {.entry = {.count = 1, .reusable = true}},
535 SHIFT(5),
536 [33] = {.entry = {.count = 1, .reusable = true}},
537 SHIFT(10),
538 [35] = {.entry = {.count = 1, .reusable = true}},
539 ACCEPT_INPUT(),
540 [37] = {.entry = {.count = 1, .reusable = true}},
541 SHIFT(8),
542 [39] = {.entry = {.count = 1, .reusable = true}},
543 SHIFT(9),
544};
545
546#ifdef __cplusplus
547extern "C" {
548#endif
549#ifdef _WIN32
550#define extern __declspec(dllexport)
551#endif
552
553extern const TSLanguage *tree_sitter_context_predicate(void) {
554 static const TSLanguage language = {
555 .version = LANGUAGE_VERSION,
556 .symbol_count = SYMBOL_COUNT,
557 .alias_count = ALIAS_COUNT,
558 .token_count = TOKEN_COUNT,
559 .external_token_count = EXTERNAL_TOKEN_COUNT,
560 .state_count = STATE_COUNT,
561 .large_state_count = LARGE_STATE_COUNT,
562 .production_id_count = PRODUCTION_ID_COUNT,
563 .field_count = FIELD_COUNT,
564 .max_alias_sequence_length = MAX_ALIAS_SEQUENCE_LENGTH,
565 .parse_table = &ts_parse_table[0][0],
566 .small_parse_table = ts_small_parse_table,
567 .small_parse_table_map = ts_small_parse_table_map,
568 .parse_actions = ts_parse_actions,
569 .symbol_names = ts_symbol_names,
570 .field_names = ts_field_names,
571 .field_map_slices = ts_field_map_slices,
572 .field_map_entries = ts_field_map_entries,
573 .symbol_metadata = ts_symbol_metadata,
574 .public_symbol_map = ts_symbol_map,
575 .alias_map = ts_non_terminal_alias_map,
576 .alias_sequences = &ts_alias_sequences[0][0],
577 .lex_modes = ts_lex_modes,
578 .lex_fn = ts_lex,
579 };
580 return &language;
581}
582#ifdef __cplusplus
583}
584#endif