Coverage for src/pyensae/languages/RParser.py: 0%
2993 statements
« prev ^ index » next coverage.py v7.2.7, created at 2023-07-03 02:16 +0200
« prev ^ index » next coverage.py v7.2.7, created at 2023-07-03 02:16 +0200
1# Generated from \R.g4 by ANTLR 4.10.1
2# encoding: utf-8
3from antlr4 import *
4from io import StringIO
5import sys
6if sys.version_info[1] > 5:
7 from typing import TextIO
8else:
9 from typing.io import TextIO
12def serializedATN():
13 return [
14 4, 1, 70, 746, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7,
15 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13,
16 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20,
17 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26,
18 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33,
19 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39,
20 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46,
21 7, 46, 2, 47, 7, 47, 1, 0, 1, 0, 1, 0, 1, 0, 5, 0, 101, 8, 0, 10, 0, 12, 0, 104, 9, 0, 1, 0,
22 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 120, 8, 1,
23 10, 1, 12, 1, 123, 9, 1, 1, 1, 1, 1, 5, 1, 127, 8, 1, 10, 1, 12, 1, 130, 9, 1, 1, 1, 1, 1,
24 5, 1, 134, 8, 1, 10, 1, 12, 1, 137, 9, 1, 1, 1, 1, 1, 5, 1, 141, 8, 1, 10, 1, 12, 1, 144,
25 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 159,
26 8, 1, 10, 1, 12, 1, 162, 9, 1, 1, 1, 1, 1, 5, 1, 166, 8, 1, 10, 1, 12, 1, 169, 9, 1, 1, 1,
27 1, 1, 1, 1, 1, 1, 3, 1, 175, 8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 183, 8, 1, 10, 1,
28 12, 1, 186, 9, 1, 1, 1, 1, 1, 5, 1, 190, 8, 1, 10, 1, 12, 1, 193, 9, 1, 1, 1, 1, 1, 1, 1, 5,
29 1, 198, 8, 1, 10, 1, 12, 1, 201, 9, 1, 1, 1, 1, 1, 5, 1, 205, 8, 1, 10, 1, 12, 1, 208, 9,
30 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 214, 8, 1, 10, 1, 12, 1, 217, 9, 1, 1, 1, 1, 1, 5, 1, 221,
31 8, 1, 10, 1, 12, 1, 224, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 230, 8, 1, 10, 1, 12, 1, 233,
32 9, 1, 1, 1, 1, 1, 5, 1, 237, 8, 1, 10, 1, 12, 1, 240, 9, 1, 1, 1, 1, 1, 1, 1, 5, 1, 245, 8,
33 1, 10, 1, 12, 1, 248, 9, 1, 1, 1, 1, 1, 5, 1, 252, 8, 1, 10, 1, 12, 1, 255, 9, 1, 1, 1, 1,
34 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 273,
35 8, 1, 10, 1, 12, 1, 276, 9, 1, 1, 2, 1, 2, 5, 2, 280, 8, 2, 10, 2, 12, 2, 283, 9, 2, 1, 2,
36 1, 2, 5, 2, 287, 8, 2, 10, 2, 12, 2, 290, 9, 2, 1, 2, 1, 2, 5, 2, 294, 8, 2, 10, 2, 12, 2,
37 297, 9, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 5, 4, 307, 8, 4, 10, 4, 12, 4, 310,
38 9, 4, 1, 4, 3, 4, 313, 8, 4, 1, 4, 5, 4, 316, 8, 4, 10, 4, 12, 4, 319, 9, 4, 1, 4, 1, 4, 1,
39 5, 1, 5, 1, 5, 5, 5, 326, 8, 5, 10, 5, 12, 5, 329, 9, 5, 1, 5, 3, 5, 332, 8, 5, 1, 5, 5, 5,
40 335, 8, 5, 10, 5, 12, 5, 338, 9, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 3,
41 7, 349, 8, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 5, 9, 358, 8, 9, 10, 9, 12, 9, 361,
42 9, 9, 1, 10, 1, 10, 3, 10, 365, 8, 10, 1, 11, 1, 11, 3, 11, 369, 8, 11, 1, 11, 1, 11, 5,
43 11, 373, 8, 11, 10, 11, 12, 11, 376, 9, 11, 1, 11, 5, 11, 379, 8, 11, 10, 11, 12, 11,
44 382, 9, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 390, 8, 12, 1, 13, 1, 13, 1,
45 14, 1, 14, 5, 14, 396, 8, 14, 10, 14, 12, 14, 399, 9, 14, 1, 14, 1, 14, 5, 14, 403, 8,
46 14, 10, 14, 12, 14, 406, 9, 14, 1, 14, 1, 14, 3, 14, 410, 8, 14, 1, 14, 5, 14, 413, 8,
47 14, 10, 14, 12, 14, 416, 9, 14, 5, 14, 418, 8, 14, 10, 14, 12, 14, 421, 9, 14, 1, 15,
48 1, 15, 3, 15, 425, 8, 15, 1, 15, 1, 15, 3, 15, 429, 8, 15, 1, 15, 1, 15, 3, 15, 433, 8,
49 15, 5, 15, 435, 8, 15, 10, 15, 12, 15, 438, 9, 15, 1, 16, 1, 16, 3, 16, 442, 8, 16, 1,
50 17, 1, 17, 1, 17, 1, 17, 3, 17, 448, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1,
51 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 462, 8, 17, 1, 18, 1, 18, 3, 18, 466, 8, 18,
52 1, 19, 1, 19, 3, 19, 470, 8, 19, 1, 19, 1, 19, 1, 19, 3, 19, 475, 8, 19, 1, 20, 1, 20, 1,
53 20, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 3, 21, 485, 8, 21, 1, 22, 1, 22, 3, 22, 489, 8, 22,
54 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24,
55 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 3, 24, 510, 8, 24, 1, 25, 1, 25, 1, 26, 1, 26,
56 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 29,
57 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 5, 30, 538, 8, 30, 10, 30,
58 12, 30, 541, 9, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 5, 30, 549, 8, 30, 10, 30,
59 12, 30, 552, 9, 30, 1, 30, 1, 30, 5, 30, 556, 8, 30, 10, 30, 12, 30, 559, 9, 30, 5, 30,
60 561, 8, 30, 10, 30, 12, 30, 564, 9, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 5, 31, 571,
61 8, 31, 10, 31, 12, 31, 574, 9, 31, 1, 31, 1, 31, 5, 31, 578, 8, 31, 10, 31, 12, 31, 581,
62 9, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 5, 31, 588, 8, 31, 10, 31, 12, 31, 591, 9, 31,
63 1, 31, 1, 31, 5, 31, 595, 8, 31, 10, 31, 12, 31, 598, 9, 31, 5, 31, 600, 8, 31, 10, 31,
64 12, 31, 603, 9, 31, 1, 31, 1, 31, 5, 31, 607, 8, 31, 10, 31, 12, 31, 610, 9, 31, 1, 31,
65 1, 31, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34,
66 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 5, 34, 631, 8, 34, 10, 34, 12, 34, 634, 9, 34, 1, 34,
67 1, 34, 5, 34, 638, 8, 34, 10, 34, 12, 34, 641, 9, 34, 1, 34, 1, 34, 3, 34, 645, 8, 34,
68 1, 35, 5, 35, 648, 8, 35, 10, 35, 12, 35, 651, 9, 35, 1, 35, 1, 35, 5, 35, 655, 8, 35,
69 10, 35, 12, 35, 658, 9, 35, 1, 35, 1, 35, 5, 35, 662, 8, 35, 10, 35, 12, 35, 665, 9, 35,
70 1, 35, 1, 35, 5, 35, 669, 8, 35, 10, 35, 12, 35, 672, 9, 35, 1, 36, 1, 36, 1, 36, 3, 36,
71 677, 8, 36, 1, 37, 3, 37, 680, 8, 37, 1, 37, 1, 37, 1, 37, 3, 37, 685, 8, 37, 1, 38, 1,
72 38, 1, 38, 1, 38, 1, 38, 1, 38, 5, 38, 693, 8, 38, 10, 38, 12, 38, 696, 9, 38, 1, 38, 1,
73 38, 1, 38, 5, 38, 701, 8, 38, 10, 38, 12, 38, 704, 9, 38, 1, 38, 5, 38, 707, 8, 38, 10,
74 38, 12, 38, 710, 9, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 718, 8, 38, 1,
75 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 728, 8, 39, 1, 40, 1, 40, 1,
76 41, 1, 41, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 45, 1, 45, 1, 46, 1, 46, 1, 47, 1,
77 47, 1, 47, 0, 1, 2, 48, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34,
78 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78,
79 80, 82, 84, 86, 88, 90, 92, 94, 0, 10, 2, 0, 1, 1, 69, 69, 1, 0, 5, 6, 1, 0, 8, 9, 1, 0, 10,
80 11, 1, 0, 28, 29, 2, 0, 20, 20, 39, 43, 2, 0, 23, 23, 46, 47, 1, 0, 48, 49, 3, 0, 5, 6, 24,
81 24, 50, 54, 1, 0, 55, 60, 821, 0, 102, 1, 0, 0, 0, 2, 174, 1, 0, 0, 0, 4, 277, 1, 0, 0, 0,
82 6, 300, 1, 0, 0, 0, 8, 303, 1, 0, 0, 0, 10, 322, 1, 0, 0, 0, 12, 341, 1, 0, 0, 0, 14, 346,
83 1, 0, 0, 0, 16, 352, 1, 0, 0, 0, 18, 355, 1, 0, 0, 0, 20, 362, 1, 0, 0, 0, 22, 366, 1, 0,
84 0, 0, 24, 389, 1, 0, 0, 0, 26, 391, 1, 0, 0, 0, 28, 393, 1, 0, 0, 0, 30, 422, 1, 0, 0, 0,
85 32, 441, 1, 0, 0, 0, 34, 461, 1, 0, 0, 0, 36, 465, 1, 0, 0, 0, 38, 469, 1, 0, 0, 0, 40, 476,
86 1, 0, 0, 0, 42, 484, 1, 0, 0, 0, 44, 488, 1, 0, 0, 0, 46, 493, 1, 0, 0, 0, 48, 509, 1, 0,
87 0, 0, 50, 511, 1, 0, 0, 0, 52, 513, 1, 0, 0, 0, 54, 515, 1, 0, 0, 0, 56, 518, 1, 0, 0, 0,
88 58, 524, 1, 0, 0, 0, 60, 532, 1, 0, 0, 0, 62, 565, 1, 0, 0, 0, 64, 613, 1, 0, 0, 0, 66, 616,
89 1, 0, 0, 0, 68, 621, 1, 0, 0, 0, 70, 649, 1, 0, 0, 0, 72, 676, 1, 0, 0, 0, 74, 679, 1, 0,
90 0, 0, 76, 686, 1, 0, 0, 0, 78, 721, 1, 0, 0, 0, 80, 729, 1, 0, 0, 0, 82, 731, 1, 0, 0, 0,
91 84, 733, 1, 0, 0, 0, 86, 735, 1, 0, 0, 0, 88, 737, 1, 0, 0, 0, 90, 739, 1, 0, 0, 0, 92, 741,
92 1, 0, 0, 0, 94, 743, 1, 0, 0, 0, 96, 97, 3, 2, 1, 0, 97, 98, 7, 0, 0, 0, 98, 101, 1, 0, 0,
93 0, 99, 101, 5, 69, 0, 0, 100, 96, 1, 0, 0, 0, 100, 99, 1, 0, 0, 0, 101, 104, 1, 0, 0, 0,
94 102, 100, 1, 0, 0, 0, 102, 103, 1, 0, 0, 0, 103, 105, 1, 0, 0, 0, 104, 102, 1, 0, 0, 0,
95 105, 106, 5, 0, 0, 1, 106, 1, 1, 0, 0, 0, 107, 108, 6, 1, -
96 1, 0, 108, 175, 3, 36, 18, 0,
97 109, 175, 3, 42, 21, 0, 110, 111, 7, 1, 0, 0, 111, 175, 3, 2, 1, 27, 112, 113, 5, 7, 0,
98 0, 113, 175, 3, 2, 1, 21, 114, 175, 3, 72, 36, 0, 115, 175, 3, 4, 2, 0, 116, 175, 3, 6,
99 3, 0, 117, 175, 3, 68, 34, 0, 118, 120, 5, 69, 0, 0, 119, 118, 1, 0, 0, 0, 120, 123, 1,
100 0, 0, 0, 121, 119, 1, 0, 0, 0, 121, 122, 1, 0, 0, 0, 122, 124, 1, 0, 0, 0, 123, 121, 1,
101 0, 0, 0, 124, 128, 5, 12, 0, 0, 125, 127, 5, 69, 0, 0, 126, 125, 1, 0, 0, 0, 127, 130,
102 1, 0, 0, 0, 128, 126, 1, 0, 0, 0, 128, 129, 1, 0, 0, 0, 129, 131, 1, 0, 0, 0, 130, 128,
103 1, 0, 0, 0, 131, 135, 3, 18, 9, 0, 132, 134, 5, 69, 0, 0, 133, 132, 1, 0, 0, 0, 134, 137,
104 1, 0, 0, 0, 135, 133, 1, 0, 0, 0, 135, 136, 1, 0, 0, 0, 136, 138, 1, 0, 0, 0, 137, 135,
105 1, 0, 0, 0, 138, 142, 5, 13, 0, 0, 139, 141, 5, 69, 0, 0, 140, 139, 1, 0, 0, 0, 141, 144,
106 1, 0, 0, 0, 142, 140, 1, 0, 0, 0, 142, 143, 1, 0, 0, 0, 143, 175, 1, 0, 0, 0, 144, 142,
107 1, 0, 0, 0, 145, 175, 3, 66, 33, 0, 146, 175, 3, 62, 31, 0, 147, 175, 3, 60, 30, 0, 148,
108 175, 3, 58, 29, 0, 149, 175, 3, 56, 28, 0, 150, 175, 3, 54, 27, 0, 151, 152, 5, 14, 0,
109 0, 152, 175, 3, 2, 1, 7, 153, 175, 3, 12, 6, 0, 154, 175, 3, 52, 26, 0, 155, 175, 5, 15,
110 0, 0, 156, 160, 5, 16, 0, 0, 157, 159, 5, 69, 0, 0, 158, 157, 1, 0, 0, 0, 159, 162, 1,
111 0, 0, 0, 160, 158, 1, 0, 0, 0, 160, 161, 1, 0, 0, 0, 161, 163, 1, 0, 0, 0, 162, 160, 1,
112 0, 0, 0, 163, 167, 3, 2, 1, 0, 164, 166, 5, 69, 0, 0, 165, 164, 1, 0, 0, 0, 166, 169, 1,
113 0, 0, 0, 167, 165, 1, 0, 0, 0, 167, 168, 1, 0, 0, 0, 168, 170, 1, 0, 0, 0, 169, 167, 1,
114 0, 0, 0, 170, 171, 5, 17, 0, 0, 171, 175, 1, 0, 0, 0, 172, 175, 3, 48, 24, 0, 173, 175,
115 3, 84, 42, 0, 174, 107, 1, 0, 0, 0, 174, 109, 1, 0, 0, 0, 174, 110, 1, 0, 0, 0, 174, 112,
116 1, 0, 0, 0, 174, 114, 1, 0, 0, 0, 174, 115, 1, 0, 0, 0, 174, 116, 1, 0, 0, 0, 174, 117,
117 1, 0, 0, 0, 174, 121, 1, 0, 0, 0, 174, 145, 1, 0, 0, 0, 174, 146, 1, 0, 0, 0, 174, 147,
118 1, 0, 0, 0, 174, 148, 1, 0, 0, 0, 174, 149, 1, 0, 0, 0, 174, 150, 1, 0, 0, 0, 174, 151,
119 1, 0, 0, 0, 174, 153, 1, 0, 0, 0, 174, 154, 1, 0, 0, 0, 174, 155, 1, 0, 0, 0, 174, 156,
120 1, 0, 0, 0, 174, 172, 1, 0, 0, 0, 174, 173, 1, 0, 0, 0, 175, 274, 1, 0, 0, 0, 176, 177,
121 10, 28, 0, 0, 177, 178, 3, 90, 45, 0, 178, 179, 3, 2, 1, 29, 179, 273, 1, 0, 0, 0, 180,
122 184, 10, 24, 0, 0, 181, 183, 5, 69, 0, 0, 182, 181, 1, 0, 0, 0, 183, 186, 1, 0, 0, 0, 184,
123 182, 1, 0, 0, 0, 184, 185, 1, 0, 0, 0, 185, 187, 1, 0, 0, 0, 186, 184, 1, 0, 0, 0, 187,
124 191, 5, 68, 0, 0, 188, 190, 5, 69, 0, 0, 189, 188, 1, 0, 0, 0, 190, 193, 1, 0, 0, 0, 191,
125 189, 1, 0, 0, 0, 191, 192, 1, 0, 0, 0, 192, 194, 1, 0, 0, 0, 193, 191, 1, 0, 0, 0, 194,
126 273, 3, 2, 1, 24, 195, 199, 10, 23, 0, 0, 196, 198, 5, 69, 0, 0, 197, 196, 1, 0, 0, 0,
127 198, 201, 1, 0, 0, 0, 199, 197, 1, 0, 0, 0, 199, 200, 1, 0, 0, 0, 200, 202, 1, 0, 0, 0,
128 201, 199, 1, 0, 0, 0, 202, 206, 3, 92, 46, 0, 203, 205, 5, 69, 0, 0, 204, 203, 1, 0, 0,
129 0, 205, 208, 1, 0, 0, 0, 206, 204, 1, 0, 0, 0, 206, 207, 1, 0, 0, 0, 207, 209, 1, 0, 0,
130 0, 208, 206, 1, 0, 0, 0, 209, 210, 3, 2, 1, 23, 210, 273, 1, 0, 0, 0, 211, 215, 10, 22,
131 0, 0, 212, 214, 5, 69, 0, 0, 213, 212, 1, 0, 0, 0, 214, 217, 1, 0, 0, 0, 215, 213, 1, 0,
132 0, 0, 215, 216, 1, 0, 0, 0, 216, 218, 1, 0, 0, 0, 217, 215, 1, 0, 0, 0, 218, 222, 3, 94,
133 47, 0, 219, 221, 5, 69, 0, 0, 220, 219, 1, 0, 0, 0, 221, 224, 1, 0, 0, 0, 222, 220, 1,
134 0, 0, 0, 222, 223, 1, 0, 0, 0, 223, 225, 1, 0, 0, 0, 224, 222, 1, 0, 0, 0, 225, 226, 3,
135 2, 1, 22, 226, 273, 1, 0, 0, 0, 227, 231, 10, 20, 0, 0, 228, 230, 5, 69, 0, 0, 229, 228,
136 1, 0, 0, 0, 230, 233, 1, 0, 0, 0, 231, 229, 1, 0, 0, 0, 231, 232, 1, 0, 0, 0, 232, 234,
137 1, 0, 0, 0, 233, 231, 1, 0, 0, 0, 234, 238, 7, 2, 0, 0, 235, 237, 5, 69, 0, 0, 236, 235,
138 1, 0, 0, 0, 237, 240, 1, 0, 0, 0, 238, 236, 1, 0, 0, 0, 238, 239, 1, 0, 0, 0, 239, 241,
139 1, 0, 0, 0, 240, 238, 1, 0, 0, 0, 241, 273, 3, 2, 1, 21, 242, 246, 10, 19, 0, 0, 243, 245,
140 5, 69, 0, 0, 244, 243, 1, 0, 0, 0, 245, 248, 1, 0, 0, 0, 246, 244, 1, 0, 0, 0, 246, 247,
141 1, 0, 0, 0, 247, 249, 1, 0, 0, 0, 248, 246, 1, 0, 0, 0, 249, 253, 7, 3, 0, 0, 250, 252,
142 5, 69, 0, 0, 251, 250, 1, 0, 0, 0, 252, 255, 1, 0, 0, 0, 253, 251, 1, 0, 0, 0, 253, 254,
143 1, 0, 0, 0, 254, 256, 1, 0, 0, 0, 255, 253, 1, 0, 0, 0, 256, 273, 3, 2, 1, 20, 257, 258,
144 10, 30, 0, 0, 258, 259, 5, 2, 0, 0, 259, 260, 3, 28, 14, 0, 260, 261, 5, 3, 0, 0, 261,
145 262, 5, 3, 0, 0, 262, 273, 1, 0, 0, 0, 263, 264, 10, 29, 0, 0, 264, 265, 5, 4, 0, 0, 265,
146 266, 3, 28, 14, 0, 266, 267, 5, 3, 0, 0, 267, 273, 1, 0, 0, 0, 268, 269, 10, 26, 0, 0,
147 269, 273, 3, 14, 7, 0, 270, 271, 10, 25, 0, 0, 271, 273, 3, 16, 8, 0, 272, 176, 1, 0,
148 0, 0, 272, 180, 1, 0, 0, 0, 272, 195, 1, 0, 0, 0, 272, 211, 1, 0, 0, 0, 272, 227, 1, 0,
149 0, 0, 272, 242, 1, 0, 0, 0, 272, 257, 1, 0, 0, 0, 272, 263, 1, 0, 0, 0, 272, 268, 1, 0,
150 0, 0, 272, 270, 1, 0, 0, 0, 273, 276, 1, 0, 0, 0, 274, 272, 1, 0, 0, 0, 274, 275, 1, 0,
151 0, 0, 275, 3, 1, 0, 0, 0, 276, 274, 1, 0, 0, 0, 277, 281, 3, 10, 5, 0, 278, 280, 5, 69,
152 0, 0, 279, 278, 1, 0, 0, 0, 280, 283, 1, 0, 0, 0, 281, 279, 1, 0, 0, 0, 281, 282, 1, 0,
153 0, 0, 282, 284, 1, 0, 0, 0, 283, 281, 1, 0, 0, 0, 284, 288, 5, 12, 0, 0, 285, 287, 5, 69,
154 0, 0, 286, 285, 1, 0, 0, 0, 287, 290, 1, 0, 0, 0, 288, 286, 1, 0, 0, 0, 288, 289, 1, 0,
155 0, 0, 289, 291, 1, 0, 0, 0, 290, 288, 1, 0, 0, 0, 291, 295, 3, 18, 9, 0, 292, 294, 5, 69,
156 0, 0, 293, 292, 1, 0, 0, 0, 294, 297, 1, 0, 0, 0, 295, 293, 1, 0, 0, 0, 295, 296, 1, 0,
157 0, 0, 296, 298, 1, 0, 0, 0, 297, 295, 1, 0, 0, 0, 298, 299, 5, 13, 0, 0, 299, 5, 1, 0, 0,
158 0, 300, 301, 3, 8, 4, 0, 301, 302, 3, 2, 1, 0, 302, 7, 1, 0, 0, 0, 303, 304, 3, 82, 41,
159 0, 304, 308, 5, 16, 0, 0, 305, 307, 5, 69, 0, 0, 306, 305, 1, 0, 0, 0, 307, 310, 1, 0,
160 0, 0, 308, 306, 1, 0, 0, 0, 308, 309, 1, 0, 0, 0, 309, 312, 1, 0, 0, 0, 310, 308, 1, 0,
161 0, 0, 311, 313, 3, 22, 11, 0, 312, 311, 1, 0, 0, 0, 312, 313, 1, 0, 0, 0, 313, 317, 1,
162 0, 0, 0, 314, 316, 5, 69, 0, 0, 315, 314, 1, 0, 0, 0, 316, 319, 1, 0, 0, 0, 317, 315, 1,
163 0, 0, 0, 317, 318, 1, 0, 0, 0, 318, 320, 1, 0, 0, 0, 319, 317, 1, 0, 0, 0, 320, 321, 5,
164 17, 0, 0, 321, 9, 1, 0, 0, 0, 322, 323, 3, 82, 41, 0, 323, 327, 5, 16, 0, 0, 324, 326,
165 5, 69, 0, 0, 325, 324, 1, 0, 0, 0, 326, 329, 1, 0, 0, 0, 327, 325, 1, 0, 0, 0, 327, 328,
166 1, 0, 0, 0, 328, 331, 1, 0, 0, 0, 329, 327, 1, 0, 0, 0, 330, 332, 3, 22, 11, 0, 331, 330,
167 1, 0, 0, 0, 331, 332, 1, 0, 0, 0, 332, 336, 1, 0, 0, 0, 333, 335, 5, 69, 0, 0, 334, 333,
168 1, 0, 0, 0, 335, 338, 1, 0, 0, 0, 336, 334, 1, 0, 0, 0, 336, 337, 1, 0, 0, 0, 337, 339,
169 1, 0, 0, 0, 338, 336, 1, 0, 0, 0, 339, 340, 5, 17, 0, 0, 340, 11, 1, 0, 0, 0, 341, 342,
170 5, 18, 0, 0, 342, 343, 5, 16, 0, 0, 343, 344, 3, 84, 42, 0, 344, 345, 5, 17, 0, 0, 345,
171 13, 1, 0, 0, 0, 346, 348, 3, 80, 40, 0, 347, 349, 5, 69, 0, 0, 348, 347, 1, 0, 0, 0, 348,
172 349, 1, 0, 0, 0, 349, 350, 1, 0, 0, 0, 350, 351, 3, 2, 1, 0, 351, 15, 1, 0, 0, 0, 352, 353,
173 3, 88, 44, 0, 353, 354, 3, 2, 1, 0, 354, 17, 1, 0, 0, 0, 355, 359, 3, 2, 1, 0, 356, 358,
174 3, 20, 10, 0, 357, 356, 1, 0, 0, 0, 358, 361, 1, 0, 0, 0, 359, 357, 1, 0, 0, 0, 359, 360,
175 1, 0, 0, 0, 360, 19, 1, 0, 0, 0, 361, 359, 1, 0, 0, 0, 362, 364, 7, 0, 0, 0, 363, 365, 3,
176 2, 1, 0, 364, 363, 1, 0, 0, 0, 364, 365, 1, 0, 0, 0, 365, 21, 1, 0, 0, 0, 366, 380, 3, 24,
177 12, 0, 367, 369, 5, 69, 0, 0, 368, 367, 1, 0, 0, 0, 368, 369, 1, 0, 0, 0, 369, 370, 1,
178 0, 0, 0, 370, 374, 5, 19, 0, 0, 371, 373, 5, 69, 0, 0, 372, 371, 1, 0, 0, 0, 373, 376,
179 1, 0, 0, 0, 374, 372, 1, 0, 0, 0, 374, 375, 1, 0, 0, 0, 375, 377, 1, 0, 0, 0, 376, 374,
180 1, 0, 0, 0, 377, 379, 3, 24, 12, 0, 378, 368, 1, 0, 0, 0, 379, 382, 1, 0, 0, 0, 380, 378,
181 1, 0, 0, 0, 380, 381, 1, 0, 0, 0, 381, 23, 1, 0, 0, 0, 382, 380, 1, 0, 0, 0, 383, 390, 3,
182 26, 13, 0, 384, 385, 3, 26, 13, 0, 385, 386, 5, 20, 0, 0, 386, 387, 3, 2, 1, 0, 387, 390,
183 1, 0, 0, 0, 388, 390, 5, 21, 0, 0, 389, 383, 1, 0, 0, 0, 389, 384, 1, 0, 0, 0, 389, 388,
184 1, 0, 0, 0, 390, 25, 1, 0, 0, 0, 391, 392, 5, 67, 0, 0, 392, 27, 1, 0, 0, 0, 393, 419, 3,
185 32, 16, 0, 394, 396, 5, 69, 0, 0, 395, 394, 1, 0, 0, 0, 396, 399, 1, 0, 0, 0, 397, 395,
186 1, 0, 0, 0, 397, 398, 1, 0, 0, 0, 398, 400, 1, 0, 0, 0, 399, 397, 1, 0, 0, 0, 400, 404,
187 5, 19, 0, 0, 401, 403, 5, 69, 0, 0, 402, 401, 1, 0, 0, 0, 403, 406, 1, 0, 0, 0, 404, 402,
188 1, 0, 0, 0, 404, 405, 1, 0, 0, 0, 405, 409, 1, 0, 0, 0, 406, 404, 1, 0, 0, 0, 407, 410,
189 3, 70, 35, 0, 408, 410, 3, 32, 16, 0, 409, 407, 1, 0, 0, 0, 409, 408, 1, 0, 0, 0, 410,
190 414, 1, 0, 0, 0, 411, 413, 5, 69, 0, 0, 412, 411, 1, 0, 0, 0, 413, 416, 1, 0, 0, 0, 414,
191 412, 1, 0, 0, 0, 414, 415, 1, 0, 0, 0, 415, 418, 1, 0, 0, 0, 416, 414, 1, 0, 0, 0, 417,
192 397, 1, 0, 0, 0, 418, 421, 1, 0, 0, 0, 419, 417, 1, 0, 0, 0, 419, 420, 1, 0, 0, 0, 420,
193 29, 1, 0, 0, 0, 421, 419, 1, 0, 0, 0, 422, 436, 3, 84, 42, 0, 423, 425, 5, 69, 0, 0, 424,
194 423, 1, 0, 0, 0, 424, 425, 1, 0, 0, 0, 425, 426, 1, 0, 0, 0, 426, 428, 5, 6, 0, 0, 427,
195 429, 5, 69, 0, 0, 428, 427, 1, 0, 0, 0, 428, 429, 1, 0, 0, 0, 429, 430, 1, 0, 0, 0, 430,
196 432, 3, 84, 42, 0, 431, 433, 5, 69, 0, 0, 432, 431, 1, 0, 0, 0, 432, 433, 1, 0, 0, 0, 433,
197 435, 1, 0, 0, 0, 434, 424, 1, 0, 0, 0, 435, 438, 1, 0, 0, 0, 436, 434, 1, 0, 0, 0, 436,
198 437, 1, 0, 0, 0, 437, 31, 1, 0, 0, 0, 438, 436, 1, 0, 0, 0, 439, 442, 3, 34, 17, 0, 440,
199 442, 3, 2, 1, 0, 441, 439, 1, 0, 0, 0, 441, 440, 1, 0, 0, 0, 442, 33, 1, 0, 0, 0, 443, 444,
200 3, 84, 42, 0, 444, 447, 5, 20, 0, 0, 445, 448, 3, 70, 35, 0, 446, 448, 3, 2, 1, 0, 447,
201 445, 1, 0, 0, 0, 447, 446, 1, 0, 0, 0, 448, 462, 1, 0, 0, 0, 449, 450, 5, 66, 0, 0, 450,
202 462, 5, 20, 0, 0, 451, 452, 5, 66, 0, 0, 452, 453, 5, 20, 0, 0, 453, 462, 3, 2, 1, 0, 454,
203 455, 5, 22, 0, 0, 455, 462, 5, 20, 0, 0, 456, 457, 5, 22, 0, 0, 457, 458, 5, 20, 0, 0,
204 458, 462, 3, 2, 1, 0, 459, 462, 5, 21, 0, 0, 460, 462, 5, 23, 0, 0, 461, 443, 1, 0, 0,
205 0, 461, 449, 1, 0, 0, 0, 461, 451, 1, 0, 0, 0, 461, 454, 1, 0, 0, 0, 461, 456, 1, 0, 0,
206 0, 461, 459, 1, 0, 0, 0, 461, 460, 1, 0, 0, 0, 462, 35, 1, 0, 0, 0, 463, 466, 3, 38, 19,
207 0, 464, 466, 3, 40, 20, 0, 465, 463, 1, 0, 0, 0, 465, 464, 1, 0, 0, 0, 466, 37, 1, 0, 0,
208 0, 467, 470, 3, 84, 42, 0, 468, 470, 5, 63, 0, 0, 469, 467, 1, 0, 0, 0, 469, 468, 1, 0,
209 0, 0, 470, 471, 1, 0, 0, 0, 471, 474, 5, 23, 0, 0, 472, 475, 3, 84, 42, 0, 473, 475, 5,
210 63, 0, 0, 474, 472, 1, 0, 0, 0, 474, 473, 1, 0, 0, 0, 475, 39, 1, 0, 0, 0, 476, 477, 5,
211 16, 0, 0, 477, 478, 3, 2, 1, 0, 478, 479, 5, 17, 0, 0, 479, 480, 5, 23, 0, 0, 480, 481,
212 3, 2, 1, 0, 481, 41, 1, 0, 0, 0, 482, 485, 3, 44, 22, 0, 483, 485, 3, 46, 23, 0, 484, 482,
213 1, 0, 0, 0, 484, 483, 1, 0, 0, 0, 485, 43, 1, 0, 0, 0, 486, 489, 3, 84, 42, 0, 487, 489,
214 3, 48, 24, 0, 488, 486, 1, 0, 0, 0, 488, 487, 1, 0, 0, 0, 489, 490, 1, 0, 0, 0, 490, 491,
215 5, 24, 0, 0, 491, 492, 3, 2, 1, 0, 492, 45, 1, 0, 0, 0, 493, 494, 5, 16, 0, 0, 494, 495,
216 3, 2, 1, 0, 495, 496, 5, 17, 0, 0, 496, 497, 5, 24, 0, 0, 497, 498, 3, 2, 1, 0, 498, 47,
217 1, 0, 0, 0, 499, 510, 5, 66, 0, 0, 500, 510, 5, 62, 0, 0, 501, 510, 5, 63, 0, 0, 502, 510,
218 5, 64, 0, 0, 503, 510, 5, 65, 0, 0, 504, 510, 5, 22, 0, 0, 505, 510, 5, 25, 0, 0, 506,
219 510, 5, 26, 0, 0, 507, 510, 5, 27, 0, 0, 508, 510, 3, 50, 25, 0, 509, 499, 1, 0, 0, 0,
220 509, 500, 1, 0, 0, 0, 509, 501, 1, 0, 0, 0, 509, 502, 1, 0, 0, 0, 509, 503, 1, 0, 0, 0,
221 509, 504, 1, 0, 0, 0, 509, 505, 1, 0, 0, 0, 509, 506, 1, 0, 0, 0, 509, 507, 1, 0, 0, 0,
222 509, 508, 1, 0, 0, 0, 510, 49, 1, 0, 0, 0, 511, 512, 7, 4, 0, 0, 512, 51, 1, 0, 0, 0, 513,
223 514, 5, 30, 0, 0, 514, 53, 1, 0, 0, 0, 515, 516, 5, 31, 0, 0, 516, 517, 3, 2, 1, 0, 517,
224 55, 1, 0, 0, 0, 518, 519, 5, 32, 0, 0, 519, 520, 5, 16, 0, 0, 520, 521, 3, 2, 1, 0, 521,
225 522, 5, 17, 0, 0, 522, 523, 3, 2, 1, 0, 523, 57, 1, 0, 0, 0, 524, 525, 5, 33, 0, 0, 525,
226 526, 5, 16, 0, 0, 526, 527, 3, 84, 42, 0, 527, 528, 5, 34, 0, 0, 528, 529, 3, 2, 1, 0,
227 529, 530, 5, 17, 0, 0, 530, 531, 3, 2, 1, 0, 531, 59, 1, 0, 0, 0, 532, 533, 5, 35, 0, 0,
228 533, 534, 5, 16, 0, 0, 534, 535, 3, 2, 1, 0, 535, 539, 5, 17, 0, 0, 536, 538, 5, 69, 0,
229 0, 537, 536, 1, 0, 0, 0, 538, 541, 1, 0, 0, 0, 539, 537, 1, 0, 0, 0, 539, 540, 1, 0, 0,
230 0, 540, 542, 1, 0, 0, 0, 541, 539, 1, 0, 0, 0, 542, 562, 3, 2, 1, 0, 543, 544, 3, 64, 32,
231 0, 544, 545, 5, 16, 0, 0, 545, 546, 3, 2, 1, 0, 546, 550, 5, 17, 0, 0, 547, 549, 5, 69,
232 0, 0, 548, 547, 1, 0, 0, 0, 549, 552, 1, 0, 0, 0, 550, 548, 1, 0, 0, 0, 550, 551, 1, 0,
233 0, 0, 551, 553, 1, 0, 0, 0, 552, 550, 1, 0, 0, 0, 553, 557, 3, 2, 1, 0, 554, 556, 5, 69,
234 0, 0, 555, 554, 1, 0, 0, 0, 556, 559, 1, 0, 0, 0, 557, 555, 1, 0, 0, 0, 557, 558, 1, 0,
235 0, 0, 558, 561, 1, 0, 0, 0, 559, 557, 1, 0, 0, 0, 560, 543, 1, 0, 0, 0, 561, 564, 1, 0,
236 0, 0, 562, 560, 1, 0, 0, 0, 562, 563, 1, 0, 0, 0, 563, 61, 1, 0, 0, 0, 564, 562, 1, 0, 0,
237 0, 565, 566, 5, 35, 0, 0, 566, 567, 5, 16, 0, 0, 567, 568, 3, 2, 1, 0, 568, 572, 5, 17,
238 0, 0, 569, 571, 5, 69, 0, 0, 570, 569, 1, 0, 0, 0, 571, 574, 1, 0, 0, 0, 572, 570, 1, 0,
239 0, 0, 572, 573, 1, 0, 0, 0, 573, 575, 1, 0, 0, 0, 574, 572, 1, 0, 0, 0, 575, 579, 3, 2,
240 1, 0, 576, 578, 5, 69, 0, 0, 577, 576, 1, 0, 0, 0, 578, 581, 1, 0, 0, 0, 579, 577, 1, 0,
241 0, 0, 579, 580, 1, 0, 0, 0, 580, 601, 1, 0, 0, 0, 581, 579, 1, 0, 0, 0, 582, 583, 3, 64,
242 32, 0, 583, 584, 5, 16, 0, 0, 584, 585, 3, 2, 1, 0, 585, 589, 5, 17, 0, 0, 586, 588, 5,
243 69, 0, 0, 587, 586, 1, 0, 0, 0, 588, 591, 1, 0, 0, 0, 589, 587, 1, 0, 0, 0, 589, 590, 1,
244 0, 0, 0, 590, 592, 1, 0, 0, 0, 591, 589, 1, 0, 0, 0, 592, 596, 3, 2, 1, 0, 593, 595, 5,
245 69, 0, 0, 594, 593, 1, 0, 0, 0, 595, 598, 1, 0, 0, 0, 596, 594, 1, 0, 0, 0, 596, 597, 1,
246 0, 0, 0, 597, 600, 1, 0, 0, 0, 598, 596, 1, 0, 0, 0, 599, 582, 1, 0, 0, 0, 600, 603, 1,
247 0, 0, 0, 601, 599, 1, 0, 0, 0, 601, 602, 1, 0, 0, 0, 602, 604, 1, 0, 0, 0, 603, 601, 1,
248 0, 0, 0, 604, 608, 5, 36, 0, 0, 605, 607, 5, 69, 0, 0, 606, 605, 1, 0, 0, 0, 607, 610,
249 1, 0, 0, 0, 608, 606, 1, 0, 0, 0, 608, 609, 1, 0, 0, 0, 609, 611, 1, 0, 0, 0, 610, 608,
250 1, 0, 0, 0, 611, 612, 3, 2, 1, 0, 612, 63, 1, 0, 0, 0, 613, 614, 5, 36, 0, 0, 614, 615,
251 5, 35, 0, 0, 615, 65, 1, 0, 0, 0, 616, 617, 5, 37, 0, 0, 617, 618, 5, 16, 0, 0, 618, 619,
252 3, 2, 1, 0, 619, 620, 5, 17, 0, 0, 620, 67, 1, 0, 0, 0, 621, 644, 3, 84, 42, 0, 622, 623,
253 5, 16, 0, 0, 623, 645, 5, 17, 0, 0, 624, 625, 5, 16, 0, 0, 625, 626, 3, 70, 35, 0, 626,
254 627, 5, 17, 0, 0, 627, 645, 1, 0, 0, 0, 628, 632, 5, 16, 0, 0, 629, 631, 5, 69, 0, 0, 630,
255 629, 1, 0, 0, 0, 631, 634, 1, 0, 0, 0, 632, 630, 1, 0, 0, 0, 632, 633, 1, 0, 0, 0, 633,
256 635, 1, 0, 0, 0, 634, 632, 1, 0, 0, 0, 635, 639, 3, 28, 14, 0, 636, 638, 5, 69, 0, 0, 637,
257 636, 1, 0, 0, 0, 638, 641, 1, 0, 0, 0, 639, 637, 1, 0, 0, 0, 639, 640, 1, 0, 0, 0, 640,
258 642, 1, 0, 0, 0, 641, 639, 1, 0, 0, 0, 642, 643, 5, 17, 0, 0, 643, 645, 1, 0, 0, 0, 644,
259 622, 1, 0, 0, 0, 644, 624, 1, 0, 0, 0, 644, 628, 1, 0, 0, 0, 645, 69, 1, 0, 0, 0, 646, 648,
260 5, 69, 0, 0, 647, 646, 1, 0, 0, 0, 648, 651, 1, 0, 0, 0, 649, 647, 1, 0, 0, 0, 649, 650,
261 1, 0, 0, 0, 650, 652, 1, 0, 0, 0, 651, 649, 1, 0, 0, 0, 652, 656, 5, 12, 0, 0, 653, 655,
262 5, 69, 0, 0, 654, 653, 1, 0, 0, 0, 655, 658, 1, 0, 0, 0, 656, 654, 1, 0, 0, 0, 656, 657,
263 1, 0, 0, 0, 657, 659, 1, 0, 0, 0, 658, 656, 1, 0, 0, 0, 659, 663, 3, 18, 9, 0, 660, 662,
264 5, 69, 0, 0, 661, 660, 1, 0, 0, 0, 662, 665, 1, 0, 0, 0, 663, 661, 1, 0, 0, 0, 663, 664,
265 1, 0, 0, 0, 664, 666, 1, 0, 0, 0, 665, 663, 1, 0, 0, 0, 666, 670, 5, 13, 0, 0, 667, 669,
266 5, 69, 0, 0, 668, 667, 1, 0, 0, 0, 669, 672, 1, 0, 0, 0, 670, 668, 1, 0, 0, 0, 670, 671,
267 1, 0, 0, 0, 671, 71, 1, 0, 0, 0, 672, 670, 1, 0, 0, 0, 673, 677, 3, 76, 38, 0, 674, 677,
268 3, 74, 37, 0, 675, 677, 3, 78, 39, 0, 676, 673, 1, 0, 0, 0, 676, 674, 1, 0, 0, 0, 676,
269 675, 1, 0, 0, 0, 677, 73, 1, 0, 0, 0, 678, 680, 3, 84, 42, 0, 679, 678, 1, 0, 0, 0, 679,
270 680, 1, 0, 0, 0, 680, 681, 1, 0, 0, 0, 681, 684, 3, 86, 43, 0, 682, 685, 3, 30, 15, 0,
271 683, 685, 5, 18, 0, 0, 684, 682, 1, 0, 0, 0, 684, 683, 1, 0, 0, 0, 685, 75, 1, 0, 0, 0,
272 686, 687, 5, 38, 0, 0, 687, 688, 5, 16, 0, 0, 688, 689, 3, 84, 42, 0, 689, 717, 5, 19,
273 0, 0, 690, 694, 5, 12, 0, 0, 691, 693, 5, 69, 0, 0, 692, 691, 1, 0, 0, 0, 693, 696, 1,
274 0, 0, 0, 694, 692, 1, 0, 0, 0, 694, 695, 1, 0, 0, 0, 695, 697, 1, 0, 0, 0, 696, 694, 1,
275 0, 0, 0, 697, 702, 3, 2, 1, 0, 698, 699, 5, 1, 0, 0, 699, 701, 3, 2, 1, 0, 700, 698, 1,
276 0, 0, 0, 701, 704, 1, 0, 0, 0, 702, 700, 1, 0, 0, 0, 702, 703, 1, 0, 0, 0, 703, 708, 1,
277 0, 0, 0, 704, 702, 1, 0, 0, 0, 705, 707, 5, 69, 0, 0, 706, 705, 1, 0, 0, 0, 707, 710, 1,
278 0, 0, 0, 708, 706, 1, 0, 0, 0, 708, 709, 1, 0, 0, 0, 709, 711, 1, 0, 0, 0, 710, 708, 1,
279 0, 0, 0, 711, 712, 5, 13, 0, 0, 712, 718, 1, 0, 0, 0, 713, 714, 3, 84, 42, 0, 714, 715,
280 3, 80, 40, 0, 715, 716, 3, 2, 1, 0, 716, 718, 1, 0, 0, 0, 717, 690, 1, 0, 0, 0, 717, 713,
281 1, 0, 0, 0, 718, 719, 1, 0, 0, 0, 719, 720, 5, 17, 0, 0, 720, 77, 1, 0, 0, 0, 721, 722,
282 5, 16, 0, 0, 722, 723, 3, 2, 1, 0, 723, 724, 5, 17, 0, 0, 724, 727, 3, 86, 43, 0, 725,
283 728, 3, 30, 15, 0, 726, 728, 5, 18, 0, 0, 727, 725, 1, 0, 0, 0, 727, 726, 1, 0, 0, 0, 728,
284 79, 1, 0, 0, 0, 729, 730, 7, 5, 0, 0, 730, 81, 1, 0, 0, 0, 731, 732, 5, 44, 0, 0, 732, 83,
285 1, 0, 0, 0, 733, 734, 5, 67, 0, 0, 734, 85, 1, 0, 0, 0, 735, 736, 5, 45, 0, 0, 736, 87,
286 1, 0, 0, 0, 737, 738, 7, 6, 0, 0, 738, 89, 1, 0, 0, 0, 739, 740, 7, 7, 0, 0, 740, 91, 1,
287 0, 0, 0, 741, 742, 7, 8, 0, 0, 742, 93, 1, 0, 0, 0, 743, 744, 7, 9, 0, 0, 744, 95, 1, 0,
288 0, 0, 80, 100, 102, 121, 128, 135, 142, 160, 167, 174, 184, 191, 199, 206, 215, 222,
289 231, 238, 246, 253, 272, 274, 281, 288, 295, 308, 312, 317, 327, 331, 336, 348,
290 359, 364, 368, 374, 380, 389, 397, 404, 409, 414, 419, 424, 428, 432, 436, 441,
291 447, 461, 465, 469, 474, 484, 488, 509, 539, 550, 557, 562, 572, 579, 589, 596,
292 601, 608, 632, 639, 644, 649, 656, 663, 670, 676, 679, 684, 694, 702, 708, 717,
293 727
294 ]
297class RParser (Parser):
299 grammarFileName = "R.g4"
301 atn = ATNDeserializer().deserialize(serializedATN())
303 decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)]
305 sharedContextCache = PredictionContextCache()
307 literalNames = ["<INVALID>", "';'", "'[['", "']'", "'['", "'-'", "'+'",
308 "'!'", "'&'", "'&&'", "'|'", "'||'", "'{'", "'}'",
309 "'?'", "'break'", "'('", "')'", "'.'", "','", "'='",
310 "'...'", "'NULL'", "':'", "'%in%'", "'NA'", "'Inf'",
311 "'NaN'", "'TRUE'", "'FALSE'", "'next'", "'repeat'",
312 "'while'", "'for'", "'in'", "'if'", "'else'", "'return'",
313 "'within'", "'<-'", "'<<-'", "'->'", "'->>'", "':='",
314 "'function'", "'~'", "'::'", "':::'", "'$'", "'@'",
315 "'*'", "'/'", "'%'", "'^'", "'%%'", "'>'", "'>='",
316 "'<'", "'<='", "'=='", "'!='"]
318 symbolicNames = ["<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
319 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
320 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
321 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
322 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
323 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
324 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
325 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
326 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
327 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
328 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
329 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
330 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
331 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
332 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
333 "<INVALID>", "PARENTHESIS", "HEX", "INT", "FLOAT",
334 "COMPLEX", "STRING", "ID", "USER_OP", "NL", "WS"]
336 RULE_parse = 0
337 RULE_expr = 1
338 RULE_functiondefbody = 2
339 RULE_functiondeflambda = 3
340 RULE_functiondefargslambda = 4
341 RULE_functiondefargs = 5
342 RULE_implicit_column_name = 6
343 RULE_affectation = 7
344 RULE_rangeopexpr = 8
345 RULE_exprlist = 9
346 RULE_rightexpr = 10
347 RULE_formlist = 11
348 RULE_form = 12
349 RULE_argumentname = 13
350 RULE_sublist = 14
351 RULE_sublistadd = 15
352 RULE_sub = 16
353 RULE_subnobracket = 17
354 RULE_ranges = 18
355 RULE_range_simple = 19
356 RULE_range_complexe = 20
357 RULE_intersections = 21
358 RULE_intersection_simple = 22
359 RULE_intersection_complexe = 23
360 RULE_constant = 24
361 RULE_boolean = 25
362 RULE_nextexpr = 26
363 RULE_repeatexpr = 27
364 RULE_whileexpr = 28
365 RULE_forexpr = 29
366 RULE_ifexpr = 30
367 RULE_ifelseexpr = 31
368 RULE_elseif = 32
369 RULE_returnexpr = 33
370 RULE_functioncall = 34
371 RULE_inlinefunction = 35
372 RULE_formula_simple = 36
373 RULE_formula_simple_A = 37
374 RULE_formula_simple_B = 38
375 RULE_formula_simple_C = 39
376 RULE_affectop = 40
377 RULE_functiondef = 41
378 RULE_identifier = 42
379 RULE_formop = 43
380 RULE_rangeop = 44
381 RULE_dotop = 45
382 RULE_operator = 46
383 RULE_comparison = 47
385 ruleNames = ["parse", "expr", "functiondefbody", "functiondeflambda",
386 "functiondefargslambda", "functiondefargs", "implicit_column_name",
387 "affectation", "rangeopexpr", "exprlist", "rightexpr",
388 "formlist", "form", "argumentname", "sublist", "sublistadd",
389 "sub", "subnobracket", "ranges", "range_simple", "range_complexe",
390 "intersections", "intersection_simple", "intersection_complexe",
391 "constant", "boolean", "nextexpr", "repeatexpr", "whileexpr",
392 "forexpr", "ifexpr", "ifelseexpr", "elseif", "returnexpr",
393 "functioncall", "inlinefunction", "formula_simple", "formula_simple_A",
394 "formula_simple_B", "formula_simple_C", "affectop", "functiondef",
395 "identifier", "formop", "rangeop", "dotop", "operator",
396 "comparison"]
398 EOF = Token.EOF
399 T__0 = 1
400 T__1 = 2
401 T__2 = 3
402 T__3 = 4
403 T__4 = 5
404 T__5 = 6
405 T__6 = 7
406 T__7 = 8
407 T__8 = 9
408 T__9 = 10
409 T__10 = 11
410 T__11 = 12
411 T__12 = 13
412 T__13 = 14
413 T__14 = 15
414 T__15 = 16
415 T__16 = 17
416 T__17 = 18
417 T__18 = 19
418 T__19 = 20
419 T__20 = 21
420 T__21 = 22
421 T__22 = 23
422 T__23 = 24
423 T__24 = 25
424 T__25 = 26
425 T__26 = 27
426 T__27 = 28
427 T__28 = 29
428 T__29 = 30
429 T__30 = 31
430 T__31 = 32
431 T__32 = 33
432 T__33 = 34
433 T__34 = 35
434 T__35 = 36
435 T__36 = 37
436 T__37 = 38
437 T__38 = 39
438 T__39 = 40
439 T__40 = 41
440 T__41 = 42
441 T__42 = 43
442 T__43 = 44
443 T__44 = 45
444 T__45 = 46
445 T__46 = 47
446 T__47 = 48
447 T__48 = 49
448 T__49 = 50
449 T__50 = 51
450 T__51 = 52
451 T__52 = 53
452 T__53 = 54
453 T__54 = 55
454 T__55 = 56
455 T__56 = 57
456 T__57 = 58
457 T__58 = 59
458 T__59 = 60
459 PARENTHESIS = 61
460 HEX = 62
461 INT = 63
462 FLOAT = 64
463 COMPLEX = 65
464 STRING = 66
465 ID = 67
466 USER_OP = 68
467 NL = 69
468 WS = 70
470 def __init__(self, input: TokenStream, output: TextIO = sys.stdout):
471 super().__init__(input, output)
472 self.checkVersion("4.10.1")
473 self._interp = ParserATNSimulator(
474 self, self.atn, self.decisionsToDFA, self.sharedContextCache)
475 self._predicates = None
477 class ParseContext(ParserRuleContext):
478 __slots__ = 'parser'
480 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
481 super().__init__(parent, invokingState)
482 self.parser = parser
484 def EOF(self):
485 return self.getToken(RParser.EOF, 0)
487 def expr(self, i: int = None):
488 if i is None:
489 return self.getTypedRuleContexts(RParser.ExprContext)
490 else:
491 return self.getTypedRuleContext(RParser.ExprContext, i)
493 def NL(self, i: int = None):
494 if i is None:
495 return self.getTokens(RParser.NL)
496 else:
497 return self.getToken(RParser.NL, i)
499 def getRuleIndex(self):
500 return RParser.RULE_parse
502 def enterRule(self, listener: ParseTreeListener):
503 if hasattr(listener, "enterParse"):
504 listener.enterParse(self)
506 def exitRule(self, listener: ParseTreeListener):
507 if hasattr(listener, "exitParse"):
508 listener.exitParse(self)
510 def parse(self):
512 localctx = RParser.ParseContext(self, self._ctx, self.state)
513 self.enterRule(localctx, 0, self.RULE_parse)
514 self._la = 0 # Token type
515 try:
516 self.enterOuterAlt(localctx, 1)
517 self.state = 102
518 self._errHandler.sync(self)
519 _la = self._input.LA(1)
520 while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RParser.T__4) | (1 << RParser.T__5) | (1 << RParser.T__6) | (1 << RParser.T__11) | (1 << RParser.T__13) | (1 << RParser.T__14) | (1 << RParser.T__15) | (1 << RParser.T__17) | (1 << RParser.T__21) | (1 << RParser.T__24) | (1 << RParser.T__25) | (1 << RParser.T__26) | (1 << RParser.T__27) | (1 << RParser.T__28) | (1 << RParser.T__29) | (1 << RParser.T__30) | (1 << RParser.T__31) | (1 << RParser.T__32) | (1 << RParser.T__34) | (1 << RParser.T__36) | (1 << RParser.T__37) | (1 << RParser.T__43) | (1 << RParser.T__44) | (1 << RParser.HEX) | (1 << RParser.INT))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (RParser.FLOAT - 64)) | (1 << (RParser.COMPLEX - 64)) | (1 << (RParser.STRING - 64)) | (1 << (RParser.ID - 64)) | (1 << (RParser.NL - 64)))) != 0):
521 self.state = 100
522 self._errHandler.sync(self)
523 la_ = self._interp.adaptivePredict(self._input, 0, self._ctx)
524 if la_ == 1:
525 self.state = 96
526 self.expr(0)
527 self.state = 97
528 _la = self._input.LA(1)
529 if not (_la == RParser.T__0 or _la == RParser.NL):
530 self._errHandler.recoverInline(self)
531 else:
532 self._errHandler.reportMatch(self)
533 self.consume()
534 pass
536 elif la_ == 2:
537 self.state = 99
538 self.match(RParser.NL)
539 pass
541 self.state = 104
542 self._errHandler.sync(self)
543 _la = self._input.LA(1)
545 self.state = 105
546 self.match(RParser.EOF)
547 except RecognitionException as re:
548 localctx.exception = re
549 self._errHandler.reportError(self, re)
550 self._errHandler.recover(self, re)
551 finally:
552 self.exitRule()
553 return localctx
555 class ExprContext(ParserRuleContext):
556 __slots__ = 'parser'
558 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
559 super().__init__(parent, invokingState)
560 self.parser = parser
562 def ranges(self):
563 return self.getTypedRuleContext(RParser.RangesContext, 0)
565 def intersections(self):
566 return self.getTypedRuleContext(RParser.IntersectionsContext, 0)
568 def expr(self, i: int = None):
569 if i is None:
570 return self.getTypedRuleContexts(RParser.ExprContext)
571 else:
572 return self.getTypedRuleContext(RParser.ExprContext, i)
574 def formula_simple(self):
575 return self.getTypedRuleContext(RParser.Formula_simpleContext, 0)
577 def functiondefbody(self):
578 return self.getTypedRuleContext(RParser.FunctiondefbodyContext, 0)
580 def functiondeflambda(self):
581 return self.getTypedRuleContext(RParser.FunctiondeflambdaContext, 0)
583 def functioncall(self):
584 return self.getTypedRuleContext(RParser.FunctioncallContext, 0)
586 def exprlist(self):
587 return self.getTypedRuleContext(RParser.ExprlistContext, 0)
589 def NL(self, i: int = None):
590 if i is None:
591 return self.getTokens(RParser.NL)
592 else:
593 return self.getToken(RParser.NL, i)
595 def returnexpr(self):
596 return self.getTypedRuleContext(RParser.ReturnexprContext, 0)
598 def ifelseexpr(self):
599 return self.getTypedRuleContext(RParser.IfelseexprContext, 0)
601 def ifexpr(self):
602 return self.getTypedRuleContext(RParser.IfexprContext, 0)
604 def forexpr(self):
605 return self.getTypedRuleContext(RParser.ForexprContext, 0)
607 def whileexpr(self):
608 return self.getTypedRuleContext(RParser.WhileexprContext, 0)
610 def repeatexpr(self):
611 return self.getTypedRuleContext(RParser.RepeatexprContext, 0)
613 def implicit_column_name(self):
614 return self.getTypedRuleContext(RParser.Implicit_column_nameContext, 0)
616 def nextexpr(self):
617 return self.getTypedRuleContext(RParser.NextexprContext, 0)
619 def constant(self):
620 return self.getTypedRuleContext(RParser.ConstantContext, 0)
622 def identifier(self):
623 return self.getTypedRuleContext(RParser.IdentifierContext, 0)
625 def dotop(self):
626 return self.getTypedRuleContext(RParser.DotopContext, 0)
628 def USER_OP(self):
629 return self.getToken(RParser.USER_OP, 0)
631 def operator(self):
632 return self.getTypedRuleContext(RParser.OperatorContext, 0)
634 def comparison(self):
635 return self.getTypedRuleContext(RParser.ComparisonContext, 0)
637 def sublist(self):
638 return self.getTypedRuleContext(RParser.SublistContext, 0)
640 def affectation(self):
641 return self.getTypedRuleContext(RParser.AffectationContext, 0)
643 def rangeopexpr(self):
644 return self.getTypedRuleContext(RParser.RangeopexprContext, 0)
646 def getRuleIndex(self):
647 return RParser.RULE_expr
649 def enterRule(self, listener: ParseTreeListener):
650 if hasattr(listener, "enterExpr"):
651 listener.enterExpr(self)
653 def exitRule(self, listener: ParseTreeListener):
654 if hasattr(listener, "exitExpr"):
655 listener.exitExpr(self)
657 def expr(self, _p: int = 0):
658 _parentctx = self._ctx
659 _parentState = self.state
660 localctx = RParser.ExprContext(self, self._ctx, _parentState)
661 _prevctx = localctx
662 _startState = 2
663 self.enterRecursionRule(localctx, 2, self.RULE_expr, _p)
664 self._la = 0 # Token type
665 try:
666 self.enterOuterAlt(localctx, 1)
667 self.state = 174
668 self._errHandler.sync(self)
669 la_ = self._interp.adaptivePredict(self._input, 8, self._ctx)
670 if la_ == 1:
671 self.state = 108
672 self.ranges()
673 pass
675 elif la_ == 2:
676 self.state = 109
677 self.intersections()
678 pass
680 elif la_ == 3:
681 self.state = 110
682 _la = self._input.LA(1)
683 if not (_la == RParser.T__4 or _la == RParser.T__5):
684 self._errHandler.recoverInline(self)
685 else:
686 self._errHandler.reportMatch(self)
687 self.consume()
688 self.state = 111
689 self.expr(27)
690 pass
692 elif la_ == 4:
693 self.state = 112
694 self.match(RParser.T__6)
695 self.state = 113
696 self.expr(21)
697 pass
699 elif la_ == 5:
700 self.state = 114
701 self.formula_simple()
702 pass
704 elif la_ == 6:
705 self.state = 115
706 self.functiondefbody()
707 pass
709 elif la_ == 7:
710 self.state = 116
711 self.functiondeflambda()
712 pass
714 elif la_ == 8:
715 self.state = 117
716 self.functioncall()
717 pass
719 elif la_ == 9:
720 self.state = 121
721 self._errHandler.sync(self)
722 _la = self._input.LA(1)
723 while _la == RParser.NL:
724 self.state = 118
725 self.match(RParser.NL)
726 self.state = 123
727 self._errHandler.sync(self)
728 _la = self._input.LA(1)
730 self.state = 124
731 self.match(RParser.T__11)
732 self.state = 128
733 self._errHandler.sync(self)
734 _alt = self._interp.adaptivePredict(self._input, 3, self._ctx)
735 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
736 if _alt == 1:
737 self.state = 125
738 self.match(RParser.NL)
739 self.state = 130
740 self._errHandler.sync(self)
741 _alt = self._interp.adaptivePredict(
742 self._input, 3, self._ctx)
744 self.state = 131
745 self.exprlist()
746 self.state = 135
747 self._errHandler.sync(self)
748 _la = self._input.LA(1)
749 while _la == RParser.NL:
750 self.state = 132
751 self.match(RParser.NL)
752 self.state = 137
753 self._errHandler.sync(self)
754 _la = self._input.LA(1)
756 self.state = 138
757 self.match(RParser.T__12)
758 self.state = 142
759 self._errHandler.sync(self)
760 _alt = self._interp.adaptivePredict(self._input, 5, self._ctx)
761 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
762 if _alt == 1:
763 self.state = 139
764 self.match(RParser.NL)
765 self.state = 144
766 self._errHandler.sync(self)
767 _alt = self._interp.adaptivePredict(
768 self._input, 5, self._ctx)
770 pass
772 elif la_ == 10:
773 self.state = 145
774 self.returnexpr()
775 pass
777 elif la_ == 11:
778 self.state = 146
779 self.ifelseexpr()
780 pass
782 elif la_ == 12:
783 self.state = 147
784 self.ifexpr()
785 pass
787 elif la_ == 13:
788 self.state = 148
789 self.forexpr()
790 pass
792 elif la_ == 14:
793 self.state = 149
794 self.whileexpr()
795 pass
797 elif la_ == 15:
798 self.state = 150
799 self.repeatexpr()
800 pass
802 elif la_ == 16:
803 self.state = 151
804 self.match(RParser.T__13)
805 self.state = 152
806 self.expr(7)
807 pass
809 elif la_ == 17:
810 self.state = 153
811 self.implicit_column_name()
812 pass
814 elif la_ == 18:
815 self.state = 154
816 self.nextexpr()
817 pass
819 elif la_ == 19:
820 self.state = 155
821 self.match(RParser.T__14)
822 pass
824 elif la_ == 20:
825 self.state = 156
826 self.match(RParser.T__15)
827 self.state = 160
828 self._errHandler.sync(self)
829 _alt = self._interp.adaptivePredict(self._input, 6, self._ctx)
830 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
831 if _alt == 1:
832 self.state = 157
833 self.match(RParser.NL)
834 self.state = 162
835 self._errHandler.sync(self)
836 _alt = self._interp.adaptivePredict(
837 self._input, 6, self._ctx)
839 self.state = 163
840 self.expr(0)
841 self.state = 167
842 self._errHandler.sync(self)
843 _la = self._input.LA(1)
844 while _la == RParser.NL:
845 self.state = 164
846 self.match(RParser.NL)
847 self.state = 169
848 self._errHandler.sync(self)
849 _la = self._input.LA(1)
851 self.state = 170
852 self.match(RParser.T__16)
853 pass
855 elif la_ == 21:
856 self.state = 172
857 self.constant()
858 pass
860 elif la_ == 22:
861 self.state = 173
862 self.identifier()
863 pass
865 self._ctx.stop = self._input.LT(-1)
866 self.state = 274
867 self._errHandler.sync(self)
868 _alt = self._interp.adaptivePredict(self._input, 20, self._ctx)
869 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
870 if _alt == 1:
871 if self._parseListeners is not None:
872 self.triggerExitRuleEvent()
873 _prevctx = localctx
874 self.state = 272
875 self._errHandler.sync(self)
876 la_ = self._interp.adaptivePredict(
877 self._input, 19, self._ctx)
878 if la_ == 1:
879 localctx = RParser.ExprContext(
880 self, _parentctx, _parentState)
881 self.pushNewRecursionContext(
882 localctx, _startState, self.RULE_expr)
883 self.state = 176
884 if not self.precpred(self._ctx, 28):
885 from antlr4.error.Errors import FailedPredicateException
886 raise FailedPredicateException(
887 self, "self.precpred(self._ctx, 28)")
888 self.state = 177
889 self.dotop()
890 self.state = 178
891 self.expr(29)
892 pass
894 elif la_ == 2:
895 localctx = RParser.ExprContext(
896 self, _parentctx, _parentState)
897 self.pushNewRecursionContext(
898 localctx, _startState, self.RULE_expr)
899 self.state = 180
900 if not self.precpred(self._ctx, 24):
901 from antlr4.error.Errors import FailedPredicateException
902 raise FailedPredicateException(
903 self, "self.precpred(self._ctx, 24)")
904 self.state = 184
905 self._errHandler.sync(self)
906 _la = self._input.LA(1)
907 while _la == RParser.NL:
908 self.state = 181
909 self.match(RParser.NL)
910 self.state = 186
911 self._errHandler.sync(self)
912 _la = self._input.LA(1)
914 self.state = 187
915 self.match(RParser.USER_OP)
916 self.state = 191
917 self._errHandler.sync(self)
918 _alt = self._interp.adaptivePredict(
919 self._input, 10, self._ctx)
920 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
921 if _alt == 1:
922 self.state = 188
923 self.match(RParser.NL)
924 self.state = 193
925 self._errHandler.sync(self)
926 _alt = self._interp.adaptivePredict(
927 self._input, 10, self._ctx)
929 self.state = 194
930 self.expr(24)
931 pass
933 elif la_ == 3:
934 localctx = RParser.ExprContext(
935 self, _parentctx, _parentState)
936 self.pushNewRecursionContext(
937 localctx, _startState, self.RULE_expr)
938 self.state = 195
939 if not self.precpred(self._ctx, 23):
940 from antlr4.error.Errors import FailedPredicateException
941 raise FailedPredicateException(
942 self, "self.precpred(self._ctx, 23)")
943 self.state = 199
944 self._errHandler.sync(self)
945 _la = self._input.LA(1)
946 while _la == RParser.NL:
947 self.state = 196
948 self.match(RParser.NL)
949 self.state = 201
950 self._errHandler.sync(self)
951 _la = self._input.LA(1)
953 self.state = 202
954 self.operator()
955 self.state = 206
956 self._errHandler.sync(self)
957 _alt = self._interp.adaptivePredict(
958 self._input, 12, self._ctx)
959 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
960 if _alt == 1:
961 self.state = 203
962 self.match(RParser.NL)
963 self.state = 208
964 self._errHandler.sync(self)
965 _alt = self._interp.adaptivePredict(
966 self._input, 12, self._ctx)
968 self.state = 209
969 self.expr(23)
970 pass
972 elif la_ == 4:
973 localctx = RParser.ExprContext(
974 self, _parentctx, _parentState)
975 self.pushNewRecursionContext(
976 localctx, _startState, self.RULE_expr)
977 self.state = 211
978 if not self.precpred(self._ctx, 22):
979 from antlr4.error.Errors import FailedPredicateException
980 raise FailedPredicateException(
981 self, "self.precpred(self._ctx, 22)")
982 self.state = 215
983 self._errHandler.sync(self)
984 _la = self._input.LA(1)
985 while _la == RParser.NL:
986 self.state = 212
987 self.match(RParser.NL)
988 self.state = 217
989 self._errHandler.sync(self)
990 _la = self._input.LA(1)
992 self.state = 218
993 self.comparison()
994 self.state = 222
995 self._errHandler.sync(self)
996 _alt = self._interp.adaptivePredict(
997 self._input, 14, self._ctx)
998 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
999 if _alt == 1:
1000 self.state = 219
1001 self.match(RParser.NL)
1002 self.state = 224
1003 self._errHandler.sync(self)
1004 _alt = self._interp.adaptivePredict(
1005 self._input, 14, self._ctx)
1007 self.state = 225
1008 self.expr(22)
1009 pass
1011 elif la_ == 5:
1012 localctx = RParser.ExprContext(
1013 self, _parentctx, _parentState)
1014 self.pushNewRecursionContext(
1015 localctx, _startState, self.RULE_expr)
1016 self.state = 227
1017 if not self.precpred(self._ctx, 20):
1018 from antlr4.error.Errors import FailedPredicateException
1019 raise FailedPredicateException(
1020 self, "self.precpred(self._ctx, 20)")
1021 self.state = 231
1022 self._errHandler.sync(self)
1023 _la = self._input.LA(1)
1024 while _la == RParser.NL:
1025 self.state = 228
1026 self.match(RParser.NL)
1027 self.state = 233
1028 self._errHandler.sync(self)
1029 _la = self._input.LA(1)
1031 self.state = 234
1032 _la = self._input.LA(1)
1033 if not (_la == RParser.T__7 or _la == RParser.T__8):
1034 self._errHandler.recoverInline(self)
1035 else:
1036 self._errHandler.reportMatch(self)
1037 self.consume()
1038 self.state = 238
1039 self._errHandler.sync(self)
1040 _alt = self._interp.adaptivePredict(
1041 self._input, 16, self._ctx)
1042 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
1043 if _alt == 1:
1044 self.state = 235
1045 self.match(RParser.NL)
1046 self.state = 240
1047 self._errHandler.sync(self)
1048 _alt = self._interp.adaptivePredict(
1049 self._input, 16, self._ctx)
1051 self.state = 241
1052 self.expr(21)
1053 pass
1055 elif la_ == 6:
1056 localctx = RParser.ExprContext(
1057 self, _parentctx, _parentState)
1058 self.pushNewRecursionContext(
1059 localctx, _startState, self.RULE_expr)
1060 self.state = 242
1061 if not self.precpred(self._ctx, 19):
1062 from antlr4.error.Errors import FailedPredicateException
1063 raise FailedPredicateException(
1064 self, "self.precpred(self._ctx, 19)")
1065 self.state = 246
1066 self._errHandler.sync(self)
1067 _la = self._input.LA(1)
1068 while _la == RParser.NL:
1069 self.state = 243
1070 self.match(RParser.NL)
1071 self.state = 248
1072 self._errHandler.sync(self)
1073 _la = self._input.LA(1)
1075 self.state = 249
1076 _la = self._input.LA(1)
1077 if not (_la == RParser.T__9 or _la == RParser.T__10):
1078 self._errHandler.recoverInline(self)
1079 else:
1080 self._errHandler.reportMatch(self)
1081 self.consume()
1082 self.state = 253
1083 self._errHandler.sync(self)
1084 _alt = self._interp.adaptivePredict(
1085 self._input, 18, self._ctx)
1086 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
1087 if _alt == 1:
1088 self.state = 250
1089 self.match(RParser.NL)
1090 self.state = 255
1091 self._errHandler.sync(self)
1092 _alt = self._interp.adaptivePredict(
1093 self._input, 18, self._ctx)
1095 self.state = 256
1096 self.expr(20)
1097 pass
1099 elif la_ == 7:
1100 localctx = RParser.ExprContext(
1101 self, _parentctx, _parentState)
1102 self.pushNewRecursionContext(
1103 localctx, _startState, self.RULE_expr)
1104 self.state = 257
1105 if not self.precpred(self._ctx, 30):
1106 from antlr4.error.Errors import FailedPredicateException
1107 raise FailedPredicateException(
1108 self, "self.precpred(self._ctx, 30)")
1109 self.state = 258
1110 self.match(RParser.T__1)
1111 self.state = 259
1112 self.sublist()
1113 self.state = 260
1114 self.match(RParser.T__2)
1115 self.state = 261
1116 self.match(RParser.T__2)
1117 pass
1119 elif la_ == 8:
1120 localctx = RParser.ExprContext(
1121 self, _parentctx, _parentState)
1122 self.pushNewRecursionContext(
1123 localctx, _startState, self.RULE_expr)
1124 self.state = 263
1125 if not self.precpred(self._ctx, 29):
1126 from antlr4.error.Errors import FailedPredicateException
1127 raise FailedPredicateException(
1128 self, "self.precpred(self._ctx, 29)")
1129 self.state = 264
1130 self.match(RParser.T__3)
1131 self.state = 265
1132 self.sublist()
1133 self.state = 266
1134 self.match(RParser.T__2)
1135 pass
1137 elif la_ == 9:
1138 localctx = RParser.ExprContext(
1139 self, _parentctx, _parentState)
1140 self.pushNewRecursionContext(
1141 localctx, _startState, self.RULE_expr)
1142 self.state = 268
1143 if not self.precpred(self._ctx, 26):
1144 from antlr4.error.Errors import FailedPredicateException
1145 raise FailedPredicateException(
1146 self, "self.precpred(self._ctx, 26)")
1147 self.state = 269
1148 self.affectation()
1149 pass
1151 elif la_ == 10:
1152 localctx = RParser.ExprContext(
1153 self, _parentctx, _parentState)
1154 self.pushNewRecursionContext(
1155 localctx, _startState, self.RULE_expr)
1156 self.state = 270
1157 if not self.precpred(self._ctx, 25):
1158 from antlr4.error.Errors import FailedPredicateException
1159 raise FailedPredicateException(
1160 self, "self.precpred(self._ctx, 25)")
1161 self.state = 271
1162 self.rangeopexpr()
1163 pass
1165 self.state = 276
1166 self._errHandler.sync(self)
1167 _alt = self._interp.adaptivePredict(self._input, 20, self._ctx)
1169 except RecognitionException as re:
1170 localctx.exception = re
1171 self._errHandler.reportError(self, re)
1172 self._errHandler.recover(self, re)
1173 finally:
1174 self.unrollRecursionContexts(_parentctx)
1175 return localctx
1177 class FunctiondefbodyContext(ParserRuleContext):
1178 __slots__ = 'parser'
1180 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1181 super().__init__(parent, invokingState)
1182 self.parser = parser
1184 def functiondefargs(self):
1185 return self.getTypedRuleContext(RParser.FunctiondefargsContext, 0)
1187 def exprlist(self):
1188 return self.getTypedRuleContext(RParser.ExprlistContext, 0)
1190 def NL(self, i: int = None):
1191 if i is None:
1192 return self.getTokens(RParser.NL)
1193 else:
1194 return self.getToken(RParser.NL, i)
1196 def getRuleIndex(self):
1197 return RParser.RULE_functiondefbody
1199 def enterRule(self, listener: ParseTreeListener):
1200 if hasattr(listener, "enterFunctiondefbody"):
1201 listener.enterFunctiondefbody(self)
1203 def exitRule(self, listener: ParseTreeListener):
1204 if hasattr(listener, "exitFunctiondefbody"):
1205 listener.exitFunctiondefbody(self)
1207 def functiondefbody(self):
1209 localctx = RParser.FunctiondefbodyContext(self, self._ctx, self.state)
1210 self.enterRule(localctx, 4, self.RULE_functiondefbody)
1211 self._la = 0 # Token type
1212 try:
1213 self.enterOuterAlt(localctx, 1)
1214 self.state = 277
1215 self.functiondefargs()
1216 self.state = 281
1217 self._errHandler.sync(self)
1218 _la = self._input.LA(1)
1219 while _la == RParser.NL:
1220 self.state = 278
1221 self.match(RParser.NL)
1222 self.state = 283
1223 self._errHandler.sync(self)
1224 _la = self._input.LA(1)
1226 self.state = 284
1227 self.match(RParser.T__11)
1228 self.state = 288
1229 self._errHandler.sync(self)
1230 _alt = self._interp.adaptivePredict(self._input, 22, self._ctx)
1231 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
1232 if _alt == 1:
1233 self.state = 285
1234 self.match(RParser.NL)
1235 self.state = 290
1236 self._errHandler.sync(self)
1237 _alt = self._interp.adaptivePredict(self._input, 22, self._ctx)
1239 self.state = 291
1240 self.exprlist()
1241 self.state = 295
1242 self._errHandler.sync(self)
1243 _la = self._input.LA(1)
1244 while _la == RParser.NL:
1245 self.state = 292
1246 self.match(RParser.NL)
1247 self.state = 297
1248 self._errHandler.sync(self)
1249 _la = self._input.LA(1)
1251 self.state = 298
1252 self.match(RParser.T__12)
1253 except RecognitionException as re:
1254 localctx.exception = re
1255 self._errHandler.reportError(self, re)
1256 self._errHandler.recover(self, re)
1257 finally:
1258 self.exitRule()
1259 return localctx
1261 class FunctiondeflambdaContext(ParserRuleContext):
1262 __slots__ = 'parser'
1264 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1265 super().__init__(parent, invokingState)
1266 self.parser = parser
1268 def functiondefargslambda(self):
1269 return self.getTypedRuleContext(RParser.FunctiondefargslambdaContext, 0)
1271 def expr(self):
1272 return self.getTypedRuleContext(RParser.ExprContext, 0)
1274 def getRuleIndex(self):
1275 return RParser.RULE_functiondeflambda
1277 def enterRule(self, listener: ParseTreeListener):
1278 if hasattr(listener, "enterFunctiondeflambda"):
1279 listener.enterFunctiondeflambda(self)
1281 def exitRule(self, listener: ParseTreeListener):
1282 if hasattr(listener, "exitFunctiondeflambda"):
1283 listener.exitFunctiondeflambda(self)
1285 def functiondeflambda(self):
1287 localctx = RParser.FunctiondeflambdaContext(
1288 self, self._ctx, self.state)
1289 self.enterRule(localctx, 6, self.RULE_functiondeflambda)
1290 try:
1291 self.enterOuterAlt(localctx, 1)
1292 self.state = 300
1293 self.functiondefargslambda()
1294 self.state = 301
1295 self.expr(0)
1296 except RecognitionException as re:
1297 localctx.exception = re
1298 self._errHandler.reportError(self, re)
1299 self._errHandler.recover(self, re)
1300 finally:
1301 self.exitRule()
1302 return localctx
1304 class FunctiondefargslambdaContext(ParserRuleContext):
1305 __slots__ = 'parser'
1307 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1308 super().__init__(parent, invokingState)
1309 self.parser = parser
1311 def functiondef(self):
1312 return self.getTypedRuleContext(RParser.FunctiondefContext, 0)
1314 def NL(self, i: int = None):
1315 if i is None:
1316 return self.getTokens(RParser.NL)
1317 else:
1318 return self.getToken(RParser.NL, i)
1320 def formlist(self):
1321 return self.getTypedRuleContext(RParser.FormlistContext, 0)
1323 def getRuleIndex(self):
1324 return RParser.RULE_functiondefargslambda
1326 def enterRule(self, listener: ParseTreeListener):
1327 if hasattr(listener, "enterFunctiondefargslambda"):
1328 listener.enterFunctiondefargslambda(self)
1330 def exitRule(self, listener: ParseTreeListener):
1331 if hasattr(listener, "exitFunctiondefargslambda"):
1332 listener.exitFunctiondefargslambda(self)
1334 def functiondefargslambda(self):
1336 localctx = RParser.FunctiondefargslambdaContext(
1337 self, self._ctx, self.state)
1338 self.enterRule(localctx, 8, self.RULE_functiondefargslambda)
1339 self._la = 0 # Token type
1340 try:
1341 self.enterOuterAlt(localctx, 1)
1342 self.state = 303
1343 self.functiondef()
1344 self.state = 304
1345 self.match(RParser.T__15)
1346 self.state = 308
1347 self._errHandler.sync(self)
1348 _alt = self._interp.adaptivePredict(self._input, 24, self._ctx)
1349 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
1350 if _alt == 1:
1351 self.state = 305
1352 self.match(RParser.NL)
1353 self.state = 310
1354 self._errHandler.sync(self)
1355 _alt = self._interp.adaptivePredict(self._input, 24, self._ctx)
1357 self.state = 312
1358 self._errHandler.sync(self)
1359 _la = self._input.LA(1)
1360 if _la == RParser.T__20 or _la == RParser.ID:
1361 self.state = 311
1362 self.formlist()
1364 self.state = 317
1365 self._errHandler.sync(self)
1366 _la = self._input.LA(1)
1367 while _la == RParser.NL:
1368 self.state = 314
1369 self.match(RParser.NL)
1370 self.state = 319
1371 self._errHandler.sync(self)
1372 _la = self._input.LA(1)
1374 self.state = 320
1375 self.match(RParser.T__16)
1376 except RecognitionException as re:
1377 localctx.exception = re
1378 self._errHandler.reportError(self, re)
1379 self._errHandler.recover(self, re)
1380 finally:
1381 self.exitRule()
1382 return localctx
1384 class FunctiondefargsContext(ParserRuleContext):
1385 __slots__ = 'parser'
1387 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1388 super().__init__(parent, invokingState)
1389 self.parser = parser
1391 def functiondef(self):
1392 return self.getTypedRuleContext(RParser.FunctiondefContext, 0)
1394 def NL(self, i: int = None):
1395 if i is None:
1396 return self.getTokens(RParser.NL)
1397 else:
1398 return self.getToken(RParser.NL, i)
1400 def formlist(self):
1401 return self.getTypedRuleContext(RParser.FormlistContext, 0)
1403 def getRuleIndex(self):
1404 return RParser.RULE_functiondefargs
1406 def enterRule(self, listener: ParseTreeListener):
1407 if hasattr(listener, "enterFunctiondefargs"):
1408 listener.enterFunctiondefargs(self)
1410 def exitRule(self, listener: ParseTreeListener):
1411 if hasattr(listener, "exitFunctiondefargs"):
1412 listener.exitFunctiondefargs(self)
1414 def functiondefargs(self):
1416 localctx = RParser.FunctiondefargsContext(self, self._ctx, self.state)
1417 self.enterRule(localctx, 10, self.RULE_functiondefargs)
1418 self._la = 0 # Token type
1419 try:
1420 self.enterOuterAlt(localctx, 1)
1421 self.state = 322
1422 self.functiondef()
1423 self.state = 323
1424 self.match(RParser.T__15)
1425 self.state = 327
1426 self._errHandler.sync(self)
1427 _alt = self._interp.adaptivePredict(self._input, 27, self._ctx)
1428 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
1429 if _alt == 1:
1430 self.state = 324
1431 self.match(RParser.NL)
1432 self.state = 329
1433 self._errHandler.sync(self)
1434 _alt = self._interp.adaptivePredict(self._input, 27, self._ctx)
1436 self.state = 331
1437 self._errHandler.sync(self)
1438 _la = self._input.LA(1)
1439 if _la == RParser.T__20 or _la == RParser.ID:
1440 self.state = 330
1441 self.formlist()
1443 self.state = 336
1444 self._errHandler.sync(self)
1445 _la = self._input.LA(1)
1446 while _la == RParser.NL:
1447 self.state = 333
1448 self.match(RParser.NL)
1449 self.state = 338
1450 self._errHandler.sync(self)
1451 _la = self._input.LA(1)
1453 self.state = 339
1454 self.match(RParser.T__16)
1455 except RecognitionException as re:
1456 localctx.exception = re
1457 self._errHandler.reportError(self, re)
1458 self._errHandler.recover(self, re)
1459 finally:
1460 self.exitRule()
1461 return localctx
1463 class Implicit_column_nameContext(ParserRuleContext):
1464 __slots__ = 'parser'
1466 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1467 super().__init__(parent, invokingState)
1468 self.parser = parser
1470 def identifier(self):
1471 return self.getTypedRuleContext(RParser.IdentifierContext, 0)
1473 def getRuleIndex(self):
1474 return RParser.RULE_implicit_column_name
1476 def enterRule(self, listener: ParseTreeListener):
1477 if hasattr(listener, "enterImplicit_column_name"):
1478 listener.enterImplicit_column_name(self)
1480 def exitRule(self, listener: ParseTreeListener):
1481 if hasattr(listener, "exitImplicit_column_name"):
1482 listener.exitImplicit_column_name(self)
1484 def implicit_column_name(self):
1486 localctx = RParser.Implicit_column_nameContext(
1487 self, self._ctx, self.state)
1488 self.enterRule(localctx, 12, self.RULE_implicit_column_name)
1489 try:
1490 self.enterOuterAlt(localctx, 1)
1491 self.state = 341
1492 self.match(RParser.T__17)
1493 self.state = 342
1494 self.match(RParser.T__15)
1495 self.state = 343
1496 self.identifier()
1497 self.state = 344
1498 self.match(RParser.T__16)
1499 except RecognitionException as re:
1500 localctx.exception = re
1501 self._errHandler.reportError(self, re)
1502 self._errHandler.recover(self, re)
1503 finally:
1504 self.exitRule()
1505 return localctx
1507 class AffectationContext(ParserRuleContext):
1508 __slots__ = 'parser'
1510 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1511 super().__init__(parent, invokingState)
1512 self.parser = parser
1514 def affectop(self):
1515 return self.getTypedRuleContext(RParser.AffectopContext, 0)
1517 def expr(self):
1518 return self.getTypedRuleContext(RParser.ExprContext, 0)
1520 def NL(self):
1521 return self.getToken(RParser.NL, 0)
1523 def getRuleIndex(self):
1524 return RParser.RULE_affectation
1526 def enterRule(self, listener: ParseTreeListener):
1527 if hasattr(listener, "enterAffectation"):
1528 listener.enterAffectation(self)
1530 def exitRule(self, listener: ParseTreeListener):
1531 if hasattr(listener, "exitAffectation"):
1532 listener.exitAffectation(self)
1534 def affectation(self):
1536 localctx = RParser.AffectationContext(self, self._ctx, self.state)
1537 self.enterRule(localctx, 14, self.RULE_affectation)
1538 try:
1539 self.enterOuterAlt(localctx, 1)
1540 self.state = 346
1541 self.affectop()
1542 self.state = 348
1543 self._errHandler.sync(self)
1544 la_ = self._interp.adaptivePredict(self._input, 30, self._ctx)
1545 if la_ == 1:
1546 self.state = 347
1547 self.match(RParser.NL)
1549 self.state = 350
1550 self.expr(0)
1551 except RecognitionException as re:
1552 localctx.exception = re
1553 self._errHandler.reportError(self, re)
1554 self._errHandler.recover(self, re)
1555 finally:
1556 self.exitRule()
1557 return localctx
1559 class RangeopexprContext(ParserRuleContext):
1560 __slots__ = 'parser'
1562 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1563 super().__init__(parent, invokingState)
1564 self.parser = parser
1566 def rangeop(self):
1567 return self.getTypedRuleContext(RParser.RangeopContext, 0)
1569 def expr(self):
1570 return self.getTypedRuleContext(RParser.ExprContext, 0)
1572 def getRuleIndex(self):
1573 return RParser.RULE_rangeopexpr
1575 def enterRule(self, listener: ParseTreeListener):
1576 if hasattr(listener, "enterRangeopexpr"):
1577 listener.enterRangeopexpr(self)
1579 def exitRule(self, listener: ParseTreeListener):
1580 if hasattr(listener, "exitRangeopexpr"):
1581 listener.exitRangeopexpr(self)
1583 def rangeopexpr(self):
1585 localctx = RParser.RangeopexprContext(self, self._ctx, self.state)
1586 self.enterRule(localctx, 16, self.RULE_rangeopexpr)
1587 try:
1588 self.enterOuterAlt(localctx, 1)
1589 self.state = 352
1590 self.rangeop()
1591 self.state = 353
1592 self.expr(0)
1593 except RecognitionException as re:
1594 localctx.exception = re
1595 self._errHandler.reportError(self, re)
1596 self._errHandler.recover(self, re)
1597 finally:
1598 self.exitRule()
1599 return localctx
1601 class ExprlistContext(ParserRuleContext):
1602 __slots__ = 'parser'
1604 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1605 super().__init__(parent, invokingState)
1606 self.parser = parser
1608 def expr(self):
1609 return self.getTypedRuleContext(RParser.ExprContext, 0)
1611 def rightexpr(self, i: int = None):
1612 if i is None:
1613 return self.getTypedRuleContexts(RParser.RightexprContext)
1614 else:
1615 return self.getTypedRuleContext(RParser.RightexprContext, i)
1617 def getRuleIndex(self):
1618 return RParser.RULE_exprlist
1620 def enterRule(self, listener: ParseTreeListener):
1621 if hasattr(listener, "enterExprlist"):
1622 listener.enterExprlist(self)
1624 def exitRule(self, listener: ParseTreeListener):
1625 if hasattr(listener, "exitExprlist"):
1626 listener.exitExprlist(self)
1628 def exprlist(self):
1630 localctx = RParser.ExprlistContext(self, self._ctx, self.state)
1631 self.enterRule(localctx, 18, self.RULE_exprlist)
1632 try:
1633 self.enterOuterAlt(localctx, 1)
1634 self.state = 355
1635 self.expr(0)
1636 self.state = 359
1637 self._errHandler.sync(self)
1638 _alt = self._interp.adaptivePredict(self._input, 31, self._ctx)
1639 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
1640 if _alt == 1:
1641 self.state = 356
1642 self.rightexpr()
1643 self.state = 361
1644 self._errHandler.sync(self)
1645 _alt = self._interp.adaptivePredict(self._input, 31, self._ctx)
1647 except RecognitionException as re:
1648 localctx.exception = re
1649 self._errHandler.reportError(self, re)
1650 self._errHandler.recover(self, re)
1651 finally:
1652 self.exitRule()
1653 return localctx
1655 class RightexprContext(ParserRuleContext):
1656 __slots__ = 'parser'
1658 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1659 super().__init__(parent, invokingState)
1660 self.parser = parser
1662 def NL(self):
1663 return self.getToken(RParser.NL, 0)
1665 def expr(self):
1666 return self.getTypedRuleContext(RParser.ExprContext, 0)
1668 def getRuleIndex(self):
1669 return RParser.RULE_rightexpr
1671 def enterRule(self, listener: ParseTreeListener):
1672 if hasattr(listener, "enterRightexpr"):
1673 listener.enterRightexpr(self)
1675 def exitRule(self, listener: ParseTreeListener):
1676 if hasattr(listener, "exitRightexpr"):
1677 listener.exitRightexpr(self)
1679 def rightexpr(self):
1681 localctx = RParser.RightexprContext(self, self._ctx, self.state)
1682 self.enterRule(localctx, 20, self.RULE_rightexpr)
1683 self._la = 0 # Token type
1684 try:
1685 self.enterOuterAlt(localctx, 1)
1686 self.state = 362
1687 _la = self._input.LA(1)
1688 if not (_la == RParser.T__0 or _la == RParser.NL):
1689 self._errHandler.recoverInline(self)
1690 else:
1691 self._errHandler.reportMatch(self)
1692 self.consume()
1693 self.state = 364
1694 self._errHandler.sync(self)
1695 la_ = self._interp.adaptivePredict(self._input, 32, self._ctx)
1696 if la_ == 1:
1697 self.state = 363
1698 self.expr(0)
1700 except RecognitionException as re:
1701 localctx.exception = re
1702 self._errHandler.reportError(self, re)
1703 self._errHandler.recover(self, re)
1704 finally:
1705 self.exitRule()
1706 return localctx
1708 class FormlistContext(ParserRuleContext):
1709 __slots__ = 'parser'
1711 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1712 super().__init__(parent, invokingState)
1713 self.parser = parser
1715 def form(self, i: int = None):
1716 if i is None:
1717 return self.getTypedRuleContexts(RParser.FormContext)
1718 else:
1719 return self.getTypedRuleContext(RParser.FormContext, i)
1721 def NL(self, i: int = None):
1722 if i is None:
1723 return self.getTokens(RParser.NL)
1724 else:
1725 return self.getToken(RParser.NL, i)
1727 def getRuleIndex(self):
1728 return RParser.RULE_formlist
1730 def enterRule(self, listener: ParseTreeListener):
1731 if hasattr(listener, "enterFormlist"):
1732 listener.enterFormlist(self)
1734 def exitRule(self, listener: ParseTreeListener):
1735 if hasattr(listener, "exitFormlist"):
1736 listener.exitFormlist(self)
1738 def formlist(self):
1740 localctx = RParser.FormlistContext(self, self._ctx, self.state)
1741 self.enterRule(localctx, 22, self.RULE_formlist)
1742 self._la = 0 # Token type
1743 try:
1744 self.enterOuterAlt(localctx, 1)
1745 self.state = 366
1746 self.form()
1747 self.state = 380
1748 self._errHandler.sync(self)
1749 _alt = self._interp.adaptivePredict(self._input, 35, self._ctx)
1750 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
1751 if _alt == 1:
1752 self.state = 368
1753 self._errHandler.sync(self)
1754 _la = self._input.LA(1)
1755 if _la == RParser.NL:
1756 self.state = 367
1757 self.match(RParser.NL)
1759 self.state = 370
1760 self.match(RParser.T__18)
1761 self.state = 374
1762 self._errHandler.sync(self)
1763 _la = self._input.LA(1)
1764 while _la == RParser.NL:
1765 self.state = 371
1766 self.match(RParser.NL)
1767 self.state = 376
1768 self._errHandler.sync(self)
1769 _la = self._input.LA(1)
1771 self.state = 377
1772 self.form()
1773 self.state = 382
1774 self._errHandler.sync(self)
1775 _alt = self._interp.adaptivePredict(self._input, 35, self._ctx)
1777 except RecognitionException as re:
1778 localctx.exception = re
1779 self._errHandler.reportError(self, re)
1780 self._errHandler.recover(self, re)
1781 finally:
1782 self.exitRule()
1783 return localctx
1785 class FormContext(ParserRuleContext):
1786 __slots__ = 'parser'
1788 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1789 super().__init__(parent, invokingState)
1790 self.parser = parser
1792 def argumentname(self):
1793 return self.getTypedRuleContext(RParser.ArgumentnameContext, 0)
1795 def expr(self):
1796 return self.getTypedRuleContext(RParser.ExprContext, 0)
1798 def getRuleIndex(self):
1799 return RParser.RULE_form
1801 def enterRule(self, listener: ParseTreeListener):
1802 if hasattr(listener, "enterForm"):
1803 listener.enterForm(self)
1805 def exitRule(self, listener: ParseTreeListener):
1806 if hasattr(listener, "exitForm"):
1807 listener.exitForm(self)
1809 def form(self):
1811 localctx = RParser.FormContext(self, self._ctx, self.state)
1812 self.enterRule(localctx, 24, self.RULE_form)
1813 try:
1814 self.state = 389
1815 self._errHandler.sync(self)
1816 la_ = self._interp.adaptivePredict(self._input, 36, self._ctx)
1817 if la_ == 1:
1818 self.enterOuterAlt(localctx, 1)
1819 self.state = 383
1820 self.argumentname()
1821 pass
1823 elif la_ == 2:
1824 self.enterOuterAlt(localctx, 2)
1825 self.state = 384
1826 self.argumentname()
1827 self.state = 385
1828 self.match(RParser.T__19)
1829 self.state = 386
1830 self.expr(0)
1831 pass
1833 elif la_ == 3:
1834 self.enterOuterAlt(localctx, 3)
1835 self.state = 388
1836 self.match(RParser.T__20)
1837 pass
1839 except RecognitionException as re:
1840 localctx.exception = re
1841 self._errHandler.reportError(self, re)
1842 self._errHandler.recover(self, re)
1843 finally:
1844 self.exitRule()
1845 return localctx
1847 class ArgumentnameContext(ParserRuleContext):
1848 __slots__ = 'parser'
1850 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1851 super().__init__(parent, invokingState)
1852 self.parser = parser
1854 def ID(self):
1855 return self.getToken(RParser.ID, 0)
1857 def getRuleIndex(self):
1858 return RParser.RULE_argumentname
1860 def enterRule(self, listener: ParseTreeListener):
1861 if hasattr(listener, "enterArgumentname"):
1862 listener.enterArgumentname(self)
1864 def exitRule(self, listener: ParseTreeListener):
1865 if hasattr(listener, "exitArgumentname"):
1866 listener.exitArgumentname(self)
1868 def argumentname(self):
1870 localctx = RParser.ArgumentnameContext(self, self._ctx, self.state)
1871 self.enterRule(localctx, 26, self.RULE_argumentname)
1872 try:
1873 self.enterOuterAlt(localctx, 1)
1874 self.state = 391
1875 self.match(RParser.ID)
1876 except RecognitionException as re:
1877 localctx.exception = re
1878 self._errHandler.reportError(self, re)
1879 self._errHandler.recover(self, re)
1880 finally:
1881 self.exitRule()
1882 return localctx
1884 class SublistContext(ParserRuleContext):
1885 __slots__ = 'parser'
1887 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
1888 super().__init__(parent, invokingState)
1889 self.parser = parser
1891 def sub(self, i: int = None):
1892 if i is None:
1893 return self.getTypedRuleContexts(RParser.SubContext)
1894 else:
1895 return self.getTypedRuleContext(RParser.SubContext, i)
1897 def inlinefunction(self, i: int = None):
1898 if i is None:
1899 return self.getTypedRuleContexts(RParser.InlinefunctionContext)
1900 else:
1901 return self.getTypedRuleContext(RParser.InlinefunctionContext, i)
1903 def NL(self, i: int = None):
1904 if i is None:
1905 return self.getTokens(RParser.NL)
1906 else:
1907 return self.getToken(RParser.NL, i)
1909 def getRuleIndex(self):
1910 return RParser.RULE_sublist
1912 def enterRule(self, listener: ParseTreeListener):
1913 if hasattr(listener, "enterSublist"):
1914 listener.enterSublist(self)
1916 def exitRule(self, listener: ParseTreeListener):
1917 if hasattr(listener, "exitSublist"):
1918 listener.exitSublist(self)
1920 def sublist(self):
1922 localctx = RParser.SublistContext(self, self._ctx, self.state)
1923 self.enterRule(localctx, 28, self.RULE_sublist)
1924 self._la = 0 # Token type
1925 try:
1926 self.enterOuterAlt(localctx, 1)
1927 self.state = 393
1928 self.sub()
1929 self.state = 419
1930 self._errHandler.sync(self)
1931 _alt = self._interp.adaptivePredict(self._input, 41, self._ctx)
1932 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
1933 if _alt == 1:
1934 self.state = 397
1935 self._errHandler.sync(self)
1936 _la = self._input.LA(1)
1937 while _la == RParser.NL:
1938 self.state = 394
1939 self.match(RParser.NL)
1940 self.state = 399
1941 self._errHandler.sync(self)
1942 _la = self._input.LA(1)
1944 self.state = 400
1945 self.match(RParser.T__18)
1946 self.state = 404
1947 self._errHandler.sync(self)
1948 _alt = self._interp.adaptivePredict(
1949 self._input, 38, self._ctx)
1950 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
1951 if _alt == 1:
1952 self.state = 401
1953 self.match(RParser.NL)
1954 self.state = 406
1955 self._errHandler.sync(self)
1956 _alt = self._interp.adaptivePredict(
1957 self._input, 38, self._ctx)
1959 self.state = 409
1960 self._errHandler.sync(self)
1961 la_ = self._interp.adaptivePredict(
1962 self._input, 39, self._ctx)
1963 if la_ == 1:
1964 self.state = 407
1965 self.inlinefunction()
1966 pass
1968 elif la_ == 2:
1969 self.state = 408
1970 self.sub()
1971 pass
1973 self.state = 414
1974 self._errHandler.sync(self)
1975 _alt = self._interp.adaptivePredict(
1976 self._input, 40, self._ctx)
1977 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
1978 if _alt == 1:
1979 self.state = 411
1980 self.match(RParser.NL)
1981 self.state = 416
1982 self._errHandler.sync(self)
1983 _alt = self._interp.adaptivePredict(
1984 self._input, 40, self._ctx)
1986 self.state = 421
1987 self._errHandler.sync(self)
1988 _alt = self._interp.adaptivePredict(self._input, 41, self._ctx)
1990 except RecognitionException as re:
1991 localctx.exception = re
1992 self._errHandler.reportError(self, re)
1993 self._errHandler.recover(self, re)
1994 finally:
1995 self.exitRule()
1996 return localctx
1998 class SublistaddContext(ParserRuleContext):
1999 __slots__ = 'parser'
2001 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2002 super().__init__(parent, invokingState)
2003 self.parser = parser
2005 def identifier(self, i: int = None):
2006 if i is None:
2007 return self.getTypedRuleContexts(RParser.IdentifierContext)
2008 else:
2009 return self.getTypedRuleContext(RParser.IdentifierContext, i)
2011 def NL(self, i: int = None):
2012 if i is None:
2013 return self.getTokens(RParser.NL)
2014 else:
2015 return self.getToken(RParser.NL, i)
2017 def getRuleIndex(self):
2018 return RParser.RULE_sublistadd
2020 def enterRule(self, listener: ParseTreeListener):
2021 if hasattr(listener, "enterSublistadd"):
2022 listener.enterSublistadd(self)
2024 def exitRule(self, listener: ParseTreeListener):
2025 if hasattr(listener, "exitSublistadd"):
2026 listener.exitSublistadd(self)
2028 def sublistadd(self):
2030 localctx = RParser.SublistaddContext(self, self._ctx, self.state)
2031 self.enterRule(localctx, 30, self.RULE_sublistadd)
2032 self._la = 0 # Token type
2033 try:
2034 self.enterOuterAlt(localctx, 1)
2035 self.state = 422
2036 self.identifier()
2037 self.state = 436
2038 self._errHandler.sync(self)
2039 _alt = self._interp.adaptivePredict(self._input, 45, self._ctx)
2040 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
2041 if _alt == 1:
2042 self.state = 424
2043 self._errHandler.sync(self)
2044 _la = self._input.LA(1)
2045 if _la == RParser.NL:
2046 self.state = 423
2047 self.match(RParser.NL)
2049 self.state = 426
2050 self.match(RParser.T__5)
2051 self.state = 428
2052 self._errHandler.sync(self)
2053 _la = self._input.LA(1)
2054 if _la == RParser.NL:
2055 self.state = 427
2056 self.match(RParser.NL)
2058 self.state = 430
2059 self.identifier()
2060 self.state = 432
2061 self._errHandler.sync(self)
2062 la_ = self._interp.adaptivePredict(
2063 self._input, 44, self._ctx)
2064 if la_ == 1:
2065 self.state = 431
2066 self.match(RParser.NL)
2068 self.state = 438
2069 self._errHandler.sync(self)
2070 _alt = self._interp.adaptivePredict(self._input, 45, self._ctx)
2072 except RecognitionException as re:
2073 localctx.exception = re
2074 self._errHandler.reportError(self, re)
2075 self._errHandler.recover(self, re)
2076 finally:
2077 self.exitRule()
2078 return localctx
2080 class SubContext(ParserRuleContext):
2081 __slots__ = 'parser'
2083 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2084 super().__init__(parent, invokingState)
2085 self.parser = parser
2087 def subnobracket(self):
2088 return self.getTypedRuleContext(RParser.SubnobracketContext, 0)
2090 def expr(self):
2091 return self.getTypedRuleContext(RParser.ExprContext, 0)
2093 def getRuleIndex(self):
2094 return RParser.RULE_sub
2096 def enterRule(self, listener: ParseTreeListener):
2097 if hasattr(listener, "enterSub"):
2098 listener.enterSub(self)
2100 def exitRule(self, listener: ParseTreeListener):
2101 if hasattr(listener, "exitSub"):
2102 listener.exitSub(self)
2104 def sub(self):
2106 localctx = RParser.SubContext(self, self._ctx, self.state)
2107 self.enterRule(localctx, 32, self.RULE_sub)
2108 try:
2109 self.state = 441
2110 self._errHandler.sync(self)
2111 la_ = self._interp.adaptivePredict(self._input, 46, self._ctx)
2112 if la_ == 1:
2113 self.enterOuterAlt(localctx, 1)
2114 self.state = 439
2115 self.subnobracket()
2116 pass
2118 elif la_ == 2:
2119 self.enterOuterAlt(localctx, 2)
2120 self.state = 440
2121 self.expr(0)
2122 pass
2124 except RecognitionException as re:
2125 localctx.exception = re
2126 self._errHandler.reportError(self, re)
2127 self._errHandler.recover(self, re)
2128 finally:
2129 self.exitRule()
2130 return localctx
2132 class SubnobracketContext(ParserRuleContext):
2133 __slots__ = 'parser'
2135 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2136 super().__init__(parent, invokingState)
2137 self.parser = parser
2139 def identifier(self):
2140 return self.getTypedRuleContext(RParser.IdentifierContext, 0)
2142 def inlinefunction(self):
2143 return self.getTypedRuleContext(RParser.InlinefunctionContext, 0)
2145 def expr(self):
2146 return self.getTypedRuleContext(RParser.ExprContext, 0)
2148 def STRING(self):
2149 return self.getToken(RParser.STRING, 0)
2151 def getRuleIndex(self):
2152 return RParser.RULE_subnobracket
2154 def enterRule(self, listener: ParseTreeListener):
2155 if hasattr(listener, "enterSubnobracket"):
2156 listener.enterSubnobracket(self)
2158 def exitRule(self, listener: ParseTreeListener):
2159 if hasattr(listener, "exitSubnobracket"):
2160 listener.exitSubnobracket(self)
2162 def subnobracket(self):
2164 localctx = RParser.SubnobracketContext(self, self._ctx, self.state)
2165 self.enterRule(localctx, 34, self.RULE_subnobracket)
2166 try:
2167 self.state = 461
2168 self._errHandler.sync(self)
2169 la_ = self._interp.adaptivePredict(self._input, 48, self._ctx)
2170 if la_ == 1:
2171 self.enterOuterAlt(localctx, 1)
2172 self.state = 443
2173 self.identifier()
2174 self.state = 444
2175 self.match(RParser.T__19)
2176 self.state = 447
2177 self._errHandler.sync(self)
2178 la_ = self._interp.adaptivePredict(self._input, 47, self._ctx)
2179 if la_ == 1:
2180 self.state = 445
2181 self.inlinefunction()
2182 pass
2184 elif la_ == 2:
2185 self.state = 446
2186 self.expr(0)
2187 pass
2189 pass
2191 elif la_ == 2:
2192 self.enterOuterAlt(localctx, 2)
2193 self.state = 449
2194 self.match(RParser.STRING)
2195 self.state = 450
2196 self.match(RParser.T__19)
2197 pass
2199 elif la_ == 3:
2200 self.enterOuterAlt(localctx, 3)
2201 self.state = 451
2202 self.match(RParser.STRING)
2203 self.state = 452
2204 self.match(RParser.T__19)
2205 self.state = 453
2206 self.expr(0)
2207 pass
2209 elif la_ == 4:
2210 self.enterOuterAlt(localctx, 4)
2211 self.state = 454
2212 self.match(RParser.T__21)
2213 self.state = 455
2214 self.match(RParser.T__19)
2215 pass
2217 elif la_ == 5:
2218 self.enterOuterAlt(localctx, 5)
2219 self.state = 456
2220 self.match(RParser.T__21)
2221 self.state = 457
2222 self.match(RParser.T__19)
2223 self.state = 458
2224 self.expr(0)
2225 pass
2227 elif la_ == 6:
2228 self.enterOuterAlt(localctx, 6)
2229 self.state = 459
2230 self.match(RParser.T__20)
2231 pass
2233 elif la_ == 7:
2234 self.enterOuterAlt(localctx, 7)
2235 self.state = 460
2236 self.match(RParser.T__22)
2237 pass
2239 except RecognitionException as re:
2240 localctx.exception = re
2241 self._errHandler.reportError(self, re)
2242 self._errHandler.recover(self, re)
2243 finally:
2244 self.exitRule()
2245 return localctx
2247 class RangesContext(ParserRuleContext):
2248 __slots__ = 'parser'
2250 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2251 super().__init__(parent, invokingState)
2252 self.parser = parser
2254 def range_simple(self):
2255 return self.getTypedRuleContext(RParser.Range_simpleContext, 0)
2257 def range_complexe(self):
2258 return self.getTypedRuleContext(RParser.Range_complexeContext, 0)
2260 def getRuleIndex(self):
2261 return RParser.RULE_ranges
2263 def enterRule(self, listener: ParseTreeListener):
2264 if hasattr(listener, "enterRanges"):
2265 listener.enterRanges(self)
2267 def exitRule(self, listener: ParseTreeListener):
2268 if hasattr(listener, "exitRanges"):
2269 listener.exitRanges(self)
2271 def ranges(self):
2273 localctx = RParser.RangesContext(self, self._ctx, self.state)
2274 self.enterRule(localctx, 36, self.RULE_ranges)
2275 try:
2276 self.state = 465
2277 self._errHandler.sync(self)
2278 token = self._input.LA(1)
2279 if token in [RParser.INT, RParser.ID]:
2280 self.enterOuterAlt(localctx, 1)
2281 self.state = 463
2282 self.range_simple()
2283 pass
2284 elif token in [RParser.T__15]:
2285 self.enterOuterAlt(localctx, 2)
2286 self.state = 464
2287 self.range_complexe()
2288 pass
2289 else:
2290 raise NoViableAltException(self)
2292 except RecognitionException as re:
2293 localctx.exception = re
2294 self._errHandler.reportError(self, re)
2295 self._errHandler.recover(self, re)
2296 finally:
2297 self.exitRule()
2298 return localctx
2300 class Range_simpleContext(ParserRuleContext):
2301 __slots__ = 'parser'
2303 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2304 super().__init__(parent, invokingState)
2305 self.parser = parser
2307 def identifier(self, i: int = None):
2308 if i is None:
2309 return self.getTypedRuleContexts(RParser.IdentifierContext)
2310 else:
2311 return self.getTypedRuleContext(RParser.IdentifierContext, i)
2313 def INT(self, i: int = None):
2314 if i is None:
2315 return self.getTokens(RParser.INT)
2316 else:
2317 return self.getToken(RParser.INT, i)
2319 def getRuleIndex(self):
2320 return RParser.RULE_range_simple
2322 def enterRule(self, listener: ParseTreeListener):
2323 if hasattr(listener, "enterRange_simple"):
2324 listener.enterRange_simple(self)
2326 def exitRule(self, listener: ParseTreeListener):
2327 if hasattr(listener, "exitRange_simple"):
2328 listener.exitRange_simple(self)
2330 def range_simple(self):
2332 localctx = RParser.Range_simpleContext(self, self._ctx, self.state)
2333 self.enterRule(localctx, 38, self.RULE_range_simple)
2334 try:
2335 self.enterOuterAlt(localctx, 1)
2336 self.state = 469
2337 self._errHandler.sync(self)
2338 token = self._input.LA(1)
2339 if token in [RParser.ID]:
2340 self.state = 467
2341 self.identifier()
2342 pass
2343 elif token in [RParser.INT]:
2344 self.state = 468
2345 self.match(RParser.INT)
2346 pass
2347 else:
2348 raise NoViableAltException(self)
2350 self.state = 471
2351 self.match(RParser.T__22)
2352 self.state = 474
2353 self._errHandler.sync(self)
2354 token = self._input.LA(1)
2355 if token in [RParser.ID]:
2356 self.state = 472
2357 self.identifier()
2358 pass
2359 elif token in [RParser.INT]:
2360 self.state = 473
2361 self.match(RParser.INT)
2362 pass
2363 else:
2364 raise NoViableAltException(self)
2366 except RecognitionException as re:
2367 localctx.exception = re
2368 self._errHandler.reportError(self, re)
2369 self._errHandler.recover(self, re)
2370 finally:
2371 self.exitRule()
2372 return localctx
2374 class Range_complexeContext(ParserRuleContext):
2375 __slots__ = 'parser'
2377 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2378 super().__init__(parent, invokingState)
2379 self.parser = parser
2381 def expr(self, i: int = None):
2382 if i is None:
2383 return self.getTypedRuleContexts(RParser.ExprContext)
2384 else:
2385 return self.getTypedRuleContext(RParser.ExprContext, i)
2387 def getRuleIndex(self):
2388 return RParser.RULE_range_complexe
2390 def enterRule(self, listener: ParseTreeListener):
2391 if hasattr(listener, "enterRange_complexe"):
2392 listener.enterRange_complexe(self)
2394 def exitRule(self, listener: ParseTreeListener):
2395 if hasattr(listener, "exitRange_complexe"):
2396 listener.exitRange_complexe(self)
2398 def range_complexe(self):
2400 localctx = RParser.Range_complexeContext(self, self._ctx, self.state)
2401 self.enterRule(localctx, 40, self.RULE_range_complexe)
2402 try:
2403 self.enterOuterAlt(localctx, 1)
2404 self.state = 476
2405 self.match(RParser.T__15)
2406 self.state = 477
2407 self.expr(0)
2408 self.state = 478
2409 self.match(RParser.T__16)
2410 self.state = 479
2411 self.match(RParser.T__22)
2412 self.state = 480
2413 self.expr(0)
2414 except RecognitionException as re:
2415 localctx.exception = re
2416 self._errHandler.reportError(self, re)
2417 self._errHandler.recover(self, re)
2418 finally:
2419 self.exitRule()
2420 return localctx
2422 class IntersectionsContext(ParserRuleContext):
2423 __slots__ = 'parser'
2425 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2426 super().__init__(parent, invokingState)
2427 self.parser = parser
2429 def intersection_simple(self):
2430 return self.getTypedRuleContext(RParser.Intersection_simpleContext, 0)
2432 def intersection_complexe(self):
2433 return self.getTypedRuleContext(RParser.Intersection_complexeContext, 0)
2435 def getRuleIndex(self):
2436 return RParser.RULE_intersections
2438 def enterRule(self, listener: ParseTreeListener):
2439 if hasattr(listener, "enterIntersections"):
2440 listener.enterIntersections(self)
2442 def exitRule(self, listener: ParseTreeListener):
2443 if hasattr(listener, "exitIntersections"):
2444 listener.exitIntersections(self)
2446 def intersections(self):
2448 localctx = RParser.IntersectionsContext(self, self._ctx, self.state)
2449 self.enterRule(localctx, 42, self.RULE_intersections)
2450 try:
2451 self.state = 484
2452 self._errHandler.sync(self)
2453 token = self._input.LA(1)
2454 if token in [RParser.T__21, RParser.T__24, RParser.T__25, RParser.T__26, RParser.T__27, RParser.T__28, RParser.HEX, RParser.INT, RParser.FLOAT, RParser.COMPLEX, RParser.STRING, RParser.ID]:
2455 self.enterOuterAlt(localctx, 1)
2456 self.state = 482
2457 self.intersection_simple()
2458 pass
2459 elif token in [RParser.T__15]:
2460 self.enterOuterAlt(localctx, 2)
2461 self.state = 483
2462 self.intersection_complexe()
2463 pass
2464 else:
2465 raise NoViableAltException(self)
2467 except RecognitionException as re:
2468 localctx.exception = re
2469 self._errHandler.reportError(self, re)
2470 self._errHandler.recover(self, re)
2471 finally:
2472 self.exitRule()
2473 return localctx
2475 class Intersection_simpleContext(ParserRuleContext):
2476 __slots__ = 'parser'
2478 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2479 super().__init__(parent, invokingState)
2480 self.parser = parser
2482 def expr(self):
2483 return self.getTypedRuleContext(RParser.ExprContext, 0)
2485 def identifier(self):
2486 return self.getTypedRuleContext(RParser.IdentifierContext, 0)
2488 def constant(self):
2489 return self.getTypedRuleContext(RParser.ConstantContext, 0)
2491 def getRuleIndex(self):
2492 return RParser.RULE_intersection_simple
2494 def enterRule(self, listener: ParseTreeListener):
2495 if hasattr(listener, "enterIntersection_simple"):
2496 listener.enterIntersection_simple(self)
2498 def exitRule(self, listener: ParseTreeListener):
2499 if hasattr(listener, "exitIntersection_simple"):
2500 listener.exitIntersection_simple(self)
2502 def intersection_simple(self):
2504 localctx = RParser.Intersection_simpleContext(
2505 self, self._ctx, self.state)
2506 self.enterRule(localctx, 44, self.RULE_intersection_simple)
2507 try:
2508 self.enterOuterAlt(localctx, 1)
2509 self.state = 488
2510 self._errHandler.sync(self)
2511 token = self._input.LA(1)
2512 if token in [RParser.ID]:
2513 self.state = 486
2514 self.identifier()
2515 pass
2516 elif token in [RParser.T__21, RParser.T__24, RParser.T__25, RParser.T__26, RParser.T__27, RParser.T__28, RParser.HEX, RParser.INT, RParser.FLOAT, RParser.COMPLEX, RParser.STRING]:
2517 self.state = 487
2518 self.constant()
2519 pass
2520 else:
2521 raise NoViableAltException(self)
2523 self.state = 490
2524 self.match(RParser.T__23)
2525 self.state = 491
2526 self.expr(0)
2527 except RecognitionException as re:
2528 localctx.exception = re
2529 self._errHandler.reportError(self, re)
2530 self._errHandler.recover(self, re)
2531 finally:
2532 self.exitRule()
2533 return localctx
2535 class Intersection_complexeContext(ParserRuleContext):
2536 __slots__ = 'parser'
2538 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2539 super().__init__(parent, invokingState)
2540 self.parser = parser
2542 def expr(self, i: int = None):
2543 if i is None:
2544 return self.getTypedRuleContexts(RParser.ExprContext)
2545 else:
2546 return self.getTypedRuleContext(RParser.ExprContext, i)
2548 def getRuleIndex(self):
2549 return RParser.RULE_intersection_complexe
2551 def enterRule(self, listener: ParseTreeListener):
2552 if hasattr(listener, "enterIntersection_complexe"):
2553 listener.enterIntersection_complexe(self)
2555 def exitRule(self, listener: ParseTreeListener):
2556 if hasattr(listener, "exitIntersection_complexe"):
2557 listener.exitIntersection_complexe(self)
2559 def intersection_complexe(self):
2561 localctx = RParser.Intersection_complexeContext(
2562 self, self._ctx, self.state)
2563 self.enterRule(localctx, 46, self.RULE_intersection_complexe)
2564 try:
2565 self.enterOuterAlt(localctx, 1)
2566 self.state = 493
2567 self.match(RParser.T__15)
2568 self.state = 494
2569 self.expr(0)
2570 self.state = 495
2571 self.match(RParser.T__16)
2572 self.state = 496
2573 self.match(RParser.T__23)
2574 self.state = 497
2575 self.expr(0)
2576 except RecognitionException as re:
2577 localctx.exception = re
2578 self._errHandler.reportError(self, re)
2579 self._errHandler.recover(self, re)
2580 finally:
2581 self.exitRule()
2582 return localctx
2584 class ConstantContext(ParserRuleContext):
2585 __slots__ = 'parser'
2587 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2588 super().__init__(parent, invokingState)
2589 self.parser = parser
2591 def STRING(self):
2592 return self.getToken(RParser.STRING, 0)
2594 def HEX(self):
2595 return self.getToken(RParser.HEX, 0)
2597 def INT(self):
2598 return self.getToken(RParser.INT, 0)
2600 def FLOAT(self):
2601 return self.getToken(RParser.FLOAT, 0)
2603 def COMPLEX(self):
2604 return self.getToken(RParser.COMPLEX, 0)
2606 def boolean(self):
2607 return self.getTypedRuleContext(RParser.BooleanContext, 0)
2609 def getRuleIndex(self):
2610 return RParser.RULE_constant
2612 def enterRule(self, listener: ParseTreeListener):
2613 if hasattr(listener, "enterConstant"):
2614 listener.enterConstant(self)
2616 def exitRule(self, listener: ParseTreeListener):
2617 if hasattr(listener, "exitConstant"):
2618 listener.exitConstant(self)
2620 def constant(self):
2622 localctx = RParser.ConstantContext(self, self._ctx, self.state)
2623 self.enterRule(localctx, 48, self.RULE_constant)
2624 try:
2625 self.state = 509
2626 self._errHandler.sync(self)
2627 token = self._input.LA(1)
2628 if token in [RParser.STRING]:
2629 self.enterOuterAlt(localctx, 1)
2630 self.state = 499
2631 self.match(RParser.STRING)
2632 pass
2633 elif token in [RParser.HEX]:
2634 self.enterOuterAlt(localctx, 2)
2635 self.state = 500
2636 self.match(RParser.HEX)
2637 pass
2638 elif token in [RParser.INT]:
2639 self.enterOuterAlt(localctx, 3)
2640 self.state = 501
2641 self.match(RParser.INT)
2642 pass
2643 elif token in [RParser.FLOAT]:
2644 self.enterOuterAlt(localctx, 4)
2645 self.state = 502
2646 self.match(RParser.FLOAT)
2647 pass
2648 elif token in [RParser.COMPLEX]:
2649 self.enterOuterAlt(localctx, 5)
2650 self.state = 503
2651 self.match(RParser.COMPLEX)
2652 pass
2653 elif token in [RParser.T__21]:
2654 self.enterOuterAlt(localctx, 6)
2655 self.state = 504
2656 self.match(RParser.T__21)
2657 pass
2658 elif token in [RParser.T__24]:
2659 self.enterOuterAlt(localctx, 7)
2660 self.state = 505
2661 self.match(RParser.T__24)
2662 pass
2663 elif token in [RParser.T__25]:
2664 self.enterOuterAlt(localctx, 8)
2665 self.state = 506
2666 self.match(RParser.T__25)
2667 pass
2668 elif token in [RParser.T__26]:
2669 self.enterOuterAlt(localctx, 9)
2670 self.state = 507
2671 self.match(RParser.T__26)
2672 pass
2673 elif token in [RParser.T__27, RParser.T__28]:
2674 self.enterOuterAlt(localctx, 10)
2675 self.state = 508
2676 self.boolean()
2677 pass
2678 else:
2679 raise NoViableAltException(self)
2681 except RecognitionException as re:
2682 localctx.exception = re
2683 self._errHandler.reportError(self, re)
2684 self._errHandler.recover(self, re)
2685 finally:
2686 self.exitRule()
2687 return localctx
2689 class BooleanContext(ParserRuleContext):
2690 __slots__ = 'parser'
2692 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2693 super().__init__(parent, invokingState)
2694 self.parser = parser
2696 def getRuleIndex(self):
2697 return RParser.RULE_boolean
2699 def enterRule(self, listener: ParseTreeListener):
2700 if hasattr(listener, "enterBoolean"):
2701 listener.enterBoolean(self)
2703 def exitRule(self, listener: ParseTreeListener):
2704 if hasattr(listener, "exitBoolean"):
2705 listener.exitBoolean(self)
2707 def boolean(self):
2709 localctx = RParser.BooleanContext(self, self._ctx, self.state)
2710 self.enterRule(localctx, 50, self.RULE_boolean)
2711 self._la = 0 # Token type
2712 try:
2713 self.enterOuterAlt(localctx, 1)
2714 self.state = 511
2715 _la = self._input.LA(1)
2716 if not (_la == RParser.T__27 or _la == RParser.T__28):
2717 self._errHandler.recoverInline(self)
2718 else:
2719 self._errHandler.reportMatch(self)
2720 self.consume()
2721 except RecognitionException as re:
2722 localctx.exception = re
2723 self._errHandler.reportError(self, re)
2724 self._errHandler.recover(self, re)
2725 finally:
2726 self.exitRule()
2727 return localctx
2729 class NextexprContext(ParserRuleContext):
2730 __slots__ = 'parser'
2732 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2733 super().__init__(parent, invokingState)
2734 self.parser = parser
2736 def getRuleIndex(self):
2737 return RParser.RULE_nextexpr
2739 def enterRule(self, listener: ParseTreeListener):
2740 if hasattr(listener, "enterNextexpr"):
2741 listener.enterNextexpr(self)
2743 def exitRule(self, listener: ParseTreeListener):
2744 if hasattr(listener, "exitNextexpr"):
2745 listener.exitNextexpr(self)
2747 def nextexpr(self):
2749 localctx = RParser.NextexprContext(self, self._ctx, self.state)
2750 self.enterRule(localctx, 52, self.RULE_nextexpr)
2751 try:
2752 self.enterOuterAlt(localctx, 1)
2753 self.state = 513
2754 self.match(RParser.T__29)
2755 except RecognitionException as re:
2756 localctx.exception = re
2757 self._errHandler.reportError(self, re)
2758 self._errHandler.recover(self, re)
2759 finally:
2760 self.exitRule()
2761 return localctx
2763 class RepeatexprContext(ParserRuleContext):
2764 __slots__ = 'parser'
2766 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2767 super().__init__(parent, invokingState)
2768 self.parser = parser
2770 def expr(self):
2771 return self.getTypedRuleContext(RParser.ExprContext, 0)
2773 def getRuleIndex(self):
2774 return RParser.RULE_repeatexpr
2776 def enterRule(self, listener: ParseTreeListener):
2777 if hasattr(listener, "enterRepeatexpr"):
2778 listener.enterRepeatexpr(self)
2780 def exitRule(self, listener: ParseTreeListener):
2781 if hasattr(listener, "exitRepeatexpr"):
2782 listener.exitRepeatexpr(self)
2784 def repeatexpr(self):
2786 localctx = RParser.RepeatexprContext(self, self._ctx, self.state)
2787 self.enterRule(localctx, 54, self.RULE_repeatexpr)
2788 try:
2789 self.enterOuterAlt(localctx, 1)
2790 self.state = 515
2791 self.match(RParser.T__30)
2792 self.state = 516
2793 self.expr(0)
2794 except RecognitionException as re:
2795 localctx.exception = re
2796 self._errHandler.reportError(self, re)
2797 self._errHandler.recover(self, re)
2798 finally:
2799 self.exitRule()
2800 return localctx
2802 class WhileexprContext(ParserRuleContext):
2803 __slots__ = 'parser'
2805 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2806 super().__init__(parent, invokingState)
2807 self.parser = parser
2809 def expr(self, i: int = None):
2810 if i is None:
2811 return self.getTypedRuleContexts(RParser.ExprContext)
2812 else:
2813 return self.getTypedRuleContext(RParser.ExprContext, i)
2815 def getRuleIndex(self):
2816 return RParser.RULE_whileexpr
2818 def enterRule(self, listener: ParseTreeListener):
2819 if hasattr(listener, "enterWhileexpr"):
2820 listener.enterWhileexpr(self)
2822 def exitRule(self, listener: ParseTreeListener):
2823 if hasattr(listener, "exitWhileexpr"):
2824 listener.exitWhileexpr(self)
2826 def whileexpr(self):
2828 localctx = RParser.WhileexprContext(self, self._ctx, self.state)
2829 self.enterRule(localctx, 56, self.RULE_whileexpr)
2830 try:
2831 self.enterOuterAlt(localctx, 1)
2832 self.state = 518
2833 self.match(RParser.T__31)
2834 self.state = 519
2835 self.match(RParser.T__15)
2836 self.state = 520
2837 self.expr(0)
2838 self.state = 521
2839 self.match(RParser.T__16)
2840 self.state = 522
2841 self.expr(0)
2842 except RecognitionException as re:
2843 localctx.exception = re
2844 self._errHandler.reportError(self, re)
2845 self._errHandler.recover(self, re)
2846 finally:
2847 self.exitRule()
2848 return localctx
2850 class ForexprContext(ParserRuleContext):
2851 __slots__ = 'parser'
2853 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2854 super().__init__(parent, invokingState)
2855 self.parser = parser
2857 def identifier(self):
2858 return self.getTypedRuleContext(RParser.IdentifierContext, 0)
2860 def expr(self, i: int = None):
2861 if i is None:
2862 return self.getTypedRuleContexts(RParser.ExprContext)
2863 else:
2864 return self.getTypedRuleContext(RParser.ExprContext, i)
2866 def getRuleIndex(self):
2867 return RParser.RULE_forexpr
2869 def enterRule(self, listener: ParseTreeListener):
2870 if hasattr(listener, "enterForexpr"):
2871 listener.enterForexpr(self)
2873 def exitRule(self, listener: ParseTreeListener):
2874 if hasattr(listener, "exitForexpr"):
2875 listener.exitForexpr(self)
2877 def forexpr(self):
2879 localctx = RParser.ForexprContext(self, self._ctx, self.state)
2880 self.enterRule(localctx, 58, self.RULE_forexpr)
2881 try:
2882 self.enterOuterAlt(localctx, 1)
2883 self.state = 524
2884 self.match(RParser.T__32)
2885 self.state = 525
2886 self.match(RParser.T__15)
2887 self.state = 526
2888 self.identifier()
2889 self.state = 527
2890 self.match(RParser.T__33)
2891 self.state = 528
2892 self.expr(0)
2893 self.state = 529
2894 self.match(RParser.T__16)
2895 self.state = 530
2896 self.expr(0)
2897 except RecognitionException as re:
2898 localctx.exception = re
2899 self._errHandler.reportError(self, re)
2900 self._errHandler.recover(self, re)
2901 finally:
2902 self.exitRule()
2903 return localctx
2905 class IfexprContext(ParserRuleContext):
2906 __slots__ = 'parser'
2908 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
2909 super().__init__(parent, invokingState)
2910 self.parser = parser
2912 def expr(self, i: int = None):
2913 if i is None:
2914 return self.getTypedRuleContexts(RParser.ExprContext)
2915 else:
2916 return self.getTypedRuleContext(RParser.ExprContext, i)
2918 def NL(self, i: int = None):
2919 if i is None:
2920 return self.getTokens(RParser.NL)
2921 else:
2922 return self.getToken(RParser.NL, i)
2924 def elseif(self, i: int = None):
2925 if i is None:
2926 return self.getTypedRuleContexts(RParser.ElseifContext)
2927 else:
2928 return self.getTypedRuleContext(RParser.ElseifContext, i)
2930 def getRuleIndex(self):
2931 return RParser.RULE_ifexpr
2933 def enterRule(self, listener: ParseTreeListener):
2934 if hasattr(listener, "enterIfexpr"):
2935 listener.enterIfexpr(self)
2937 def exitRule(self, listener: ParseTreeListener):
2938 if hasattr(listener, "exitIfexpr"):
2939 listener.exitIfexpr(self)
2941 def ifexpr(self):
2943 localctx = RParser.IfexprContext(self, self._ctx, self.state)
2944 self.enterRule(localctx, 60, self.RULE_ifexpr)
2945 try:
2946 self.enterOuterAlt(localctx, 1)
2947 self.state = 532
2948 self.match(RParser.T__34)
2949 self.state = 533
2950 self.match(RParser.T__15)
2951 self.state = 534
2952 self.expr(0)
2953 self.state = 535
2954 self.match(RParser.T__16)
2955 self.state = 539
2956 self._errHandler.sync(self)
2957 _alt = self._interp.adaptivePredict(self._input, 55, self._ctx)
2958 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
2959 if _alt == 1:
2960 self.state = 536
2961 self.match(RParser.NL)
2962 self.state = 541
2963 self._errHandler.sync(self)
2964 _alt = self._interp.adaptivePredict(self._input, 55, self._ctx)
2966 self.state = 542
2967 self.expr(0)
2968 self.state = 562
2969 self._errHandler.sync(self)
2970 _alt = self._interp.adaptivePredict(self._input, 58, self._ctx)
2971 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
2972 if _alt == 1:
2973 self.state = 543
2974 self.elseif()
2975 self.state = 544
2976 self.match(RParser.T__15)
2977 self.state = 545
2978 self.expr(0)
2979 self.state = 546
2980 self.match(RParser.T__16)
2981 self.state = 550
2982 self._errHandler.sync(self)
2983 _alt = self._interp.adaptivePredict(
2984 self._input, 56, self._ctx)
2985 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
2986 if _alt == 1:
2987 self.state = 547
2988 self.match(RParser.NL)
2989 self.state = 552
2990 self._errHandler.sync(self)
2991 _alt = self._interp.adaptivePredict(
2992 self._input, 56, self._ctx)
2994 self.state = 553
2995 self.expr(0)
2996 self.state = 557
2997 self._errHandler.sync(self)
2998 _alt = self._interp.adaptivePredict(
2999 self._input, 57, self._ctx)
3000 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
3001 if _alt == 1:
3002 self.state = 554
3003 self.match(RParser.NL)
3004 self.state = 559
3005 self._errHandler.sync(self)
3006 _alt = self._interp.adaptivePredict(
3007 self._input, 57, self._ctx)
3009 self.state = 564
3010 self._errHandler.sync(self)
3011 _alt = self._interp.adaptivePredict(self._input, 58, self._ctx)
3013 except RecognitionException as re:
3014 localctx.exception = re
3015 self._errHandler.reportError(self, re)
3016 self._errHandler.recover(self, re)
3017 finally:
3018 self.exitRule()
3019 return localctx
3021 class IfelseexprContext(ParserRuleContext):
3022 __slots__ = 'parser'
3024 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3025 super().__init__(parent, invokingState)
3026 self.parser = parser
3028 def expr(self, i: int = None):
3029 if i is None:
3030 return self.getTypedRuleContexts(RParser.ExprContext)
3031 else:
3032 return self.getTypedRuleContext(RParser.ExprContext, i)
3034 def NL(self, i: int = None):
3035 if i is None:
3036 return self.getTokens(RParser.NL)
3037 else:
3038 return self.getToken(RParser.NL, i)
3040 def elseif(self, i: int = None):
3041 if i is None:
3042 return self.getTypedRuleContexts(RParser.ElseifContext)
3043 else:
3044 return self.getTypedRuleContext(RParser.ElseifContext, i)
3046 def getRuleIndex(self):
3047 return RParser.RULE_ifelseexpr
3049 def enterRule(self, listener: ParseTreeListener):
3050 if hasattr(listener, "enterIfelseexpr"):
3051 listener.enterIfelseexpr(self)
3053 def exitRule(self, listener: ParseTreeListener):
3054 if hasattr(listener, "exitIfelseexpr"):
3055 listener.exitIfelseexpr(self)
3057 def ifelseexpr(self):
3059 localctx = RParser.IfelseexprContext(self, self._ctx, self.state)
3060 self.enterRule(localctx, 62, self.RULE_ifelseexpr)
3061 self._la = 0 # Token type
3062 try:
3063 self.enterOuterAlt(localctx, 1)
3064 self.state = 565
3065 self.match(RParser.T__34)
3066 self.state = 566
3067 self.match(RParser.T__15)
3068 self.state = 567
3069 self.expr(0)
3070 self.state = 568
3071 self.match(RParser.T__16)
3072 self.state = 572
3073 self._errHandler.sync(self)
3074 _alt = self._interp.adaptivePredict(self._input, 59, self._ctx)
3075 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
3076 if _alt == 1:
3077 self.state = 569
3078 self.match(RParser.NL)
3079 self.state = 574
3080 self._errHandler.sync(self)
3081 _alt = self._interp.adaptivePredict(self._input, 59, self._ctx)
3083 self.state = 575
3084 self.expr(0)
3085 self.state = 579
3086 self._errHandler.sync(self)
3087 _la = self._input.LA(1)
3088 while _la == RParser.NL:
3089 self.state = 576
3090 self.match(RParser.NL)
3091 self.state = 581
3092 self._errHandler.sync(self)
3093 _la = self._input.LA(1)
3095 self.state = 601
3096 self._errHandler.sync(self)
3097 _alt = self._interp.adaptivePredict(self._input, 63, self._ctx)
3098 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
3099 if _alt == 1:
3100 self.state = 582
3101 self.elseif()
3102 self.state = 583
3103 self.match(RParser.T__15)
3104 self.state = 584
3105 self.expr(0)
3106 self.state = 585
3107 self.match(RParser.T__16)
3108 self.state = 589
3109 self._errHandler.sync(self)
3110 _alt = self._interp.adaptivePredict(
3111 self._input, 61, self._ctx)
3112 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
3113 if _alt == 1:
3114 self.state = 586
3115 self.match(RParser.NL)
3116 self.state = 591
3117 self._errHandler.sync(self)
3118 _alt = self._interp.adaptivePredict(
3119 self._input, 61, self._ctx)
3121 self.state = 592
3122 self.expr(0)
3123 self.state = 596
3124 self._errHandler.sync(self)
3125 _la = self._input.LA(1)
3126 while _la == RParser.NL:
3127 self.state = 593
3128 self.match(RParser.NL)
3129 self.state = 598
3130 self._errHandler.sync(self)
3131 _la = self._input.LA(1)
3133 self.state = 603
3134 self._errHandler.sync(self)
3135 _alt = self._interp.adaptivePredict(self._input, 63, self._ctx)
3137 self.state = 604
3138 self.match(RParser.T__35)
3139 self.state = 608
3140 self._errHandler.sync(self)
3141 _alt = self._interp.adaptivePredict(self._input, 64, self._ctx)
3142 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
3143 if _alt == 1:
3144 self.state = 605
3145 self.match(RParser.NL)
3146 self.state = 610
3147 self._errHandler.sync(self)
3148 _alt = self._interp.adaptivePredict(self._input, 64, self._ctx)
3150 self.state = 611
3151 self.expr(0)
3152 except RecognitionException as re:
3153 localctx.exception = re
3154 self._errHandler.reportError(self, re)
3155 self._errHandler.recover(self, re)
3156 finally:
3157 self.exitRule()
3158 return localctx
3160 class ElseifContext(ParserRuleContext):
3161 __slots__ = 'parser'
3163 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3164 super().__init__(parent, invokingState)
3165 self.parser = parser
3167 def getRuleIndex(self):
3168 return RParser.RULE_elseif
3170 def enterRule(self, listener: ParseTreeListener):
3171 if hasattr(listener, "enterElseif"):
3172 listener.enterElseif(self)
3174 def exitRule(self, listener: ParseTreeListener):
3175 if hasattr(listener, "exitElseif"):
3176 listener.exitElseif(self)
3178 def elseif(self):
3180 localctx = RParser.ElseifContext(self, self._ctx, self.state)
3181 self.enterRule(localctx, 64, self.RULE_elseif)
3182 try:
3183 self.enterOuterAlt(localctx, 1)
3184 self.state = 613
3185 self.match(RParser.T__35)
3186 self.state = 614
3187 self.match(RParser.T__34)
3188 except RecognitionException as re:
3189 localctx.exception = re
3190 self._errHandler.reportError(self, re)
3191 self._errHandler.recover(self, re)
3192 finally:
3193 self.exitRule()
3194 return localctx
3196 class ReturnexprContext(ParserRuleContext):
3197 __slots__ = 'parser'
3199 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3200 super().__init__(parent, invokingState)
3201 self.parser = parser
3203 def expr(self):
3204 return self.getTypedRuleContext(RParser.ExprContext, 0)
3206 def getRuleIndex(self):
3207 return RParser.RULE_returnexpr
3209 def enterRule(self, listener: ParseTreeListener):
3210 if hasattr(listener, "enterReturnexpr"):
3211 listener.enterReturnexpr(self)
3213 def exitRule(self, listener: ParseTreeListener):
3214 if hasattr(listener, "exitReturnexpr"):
3215 listener.exitReturnexpr(self)
3217 def returnexpr(self):
3219 localctx = RParser.ReturnexprContext(self, self._ctx, self.state)
3220 self.enterRule(localctx, 66, self.RULE_returnexpr)
3221 try:
3222 self.enterOuterAlt(localctx, 1)
3223 self.state = 616
3224 self.match(RParser.T__36)
3225 self.state = 617
3226 self.match(RParser.T__15)
3227 self.state = 618
3228 self.expr(0)
3229 self.state = 619
3230 self.match(RParser.T__16)
3231 except RecognitionException as re:
3232 localctx.exception = re
3233 self._errHandler.reportError(self, re)
3234 self._errHandler.recover(self, re)
3235 finally:
3236 self.exitRule()
3237 return localctx
3239 class FunctioncallContext(ParserRuleContext):
3240 __slots__ = 'parser'
3242 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3243 super().__init__(parent, invokingState)
3244 self.parser = parser
3246 def identifier(self):
3247 return self.getTypedRuleContext(RParser.IdentifierContext, 0)
3249 def inlinefunction(self):
3250 return self.getTypedRuleContext(RParser.InlinefunctionContext, 0)
3252 def sublist(self):
3253 return self.getTypedRuleContext(RParser.SublistContext, 0)
3255 def NL(self, i: int = None):
3256 if i is None:
3257 return self.getTokens(RParser.NL)
3258 else:
3259 return self.getToken(RParser.NL, i)
3261 def getRuleIndex(self):
3262 return RParser.RULE_functioncall
3264 def enterRule(self, listener: ParseTreeListener):
3265 if hasattr(listener, "enterFunctioncall"):
3266 listener.enterFunctioncall(self)
3268 def exitRule(self, listener: ParseTreeListener):
3269 if hasattr(listener, "exitFunctioncall"):
3270 listener.exitFunctioncall(self)
3272 def functioncall(self):
3274 localctx = RParser.FunctioncallContext(self, self._ctx, self.state)
3275 self.enterRule(localctx, 68, self.RULE_functioncall)
3276 self._la = 0 # Token type
3277 try:
3278 self.enterOuterAlt(localctx, 1)
3279 self.state = 621
3280 self.identifier()
3281 self.state = 644
3282 self._errHandler.sync(self)
3283 la_ = self._interp.adaptivePredict(self._input, 67, self._ctx)
3284 if la_ == 1:
3285 self.state = 622
3286 self.match(RParser.T__15)
3287 self.state = 623
3288 self.match(RParser.T__16)
3289 pass
3291 elif la_ == 2:
3292 self.state = 624
3293 self.match(RParser.T__15)
3294 self.state = 625
3295 self.inlinefunction()
3296 self.state = 626
3297 self.match(RParser.T__16)
3298 pass
3300 elif la_ == 3:
3301 self.state = 628
3302 self.match(RParser.T__15)
3303 self.state = 632
3304 self._errHandler.sync(self)
3305 _alt = self._interp.adaptivePredict(self._input, 65, self._ctx)
3306 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
3307 if _alt == 1:
3308 self.state = 629
3309 self.match(RParser.NL)
3310 self.state = 634
3311 self._errHandler.sync(self)
3312 _alt = self._interp.adaptivePredict(
3313 self._input, 65, self._ctx)
3315 self.state = 635
3316 self.sublist()
3317 self.state = 639
3318 self._errHandler.sync(self)
3319 _la = self._input.LA(1)
3320 while _la == RParser.NL:
3321 self.state = 636
3322 self.match(RParser.NL)
3323 self.state = 641
3324 self._errHandler.sync(self)
3325 _la = self._input.LA(1)
3327 self.state = 642
3328 self.match(RParser.T__16)
3329 pass
3331 except RecognitionException as re:
3332 localctx.exception = re
3333 self._errHandler.reportError(self, re)
3334 self._errHandler.recover(self, re)
3335 finally:
3336 self.exitRule()
3337 return localctx
3339 class InlinefunctionContext(ParserRuleContext):
3340 __slots__ = 'parser'
3342 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3343 super().__init__(parent, invokingState)
3344 self.parser = parser
3346 def exprlist(self):
3347 return self.getTypedRuleContext(RParser.ExprlistContext, 0)
3349 def NL(self, i: int = None):
3350 if i is None:
3351 return self.getTokens(RParser.NL)
3352 else:
3353 return self.getToken(RParser.NL, i)
3355 def getRuleIndex(self):
3356 return RParser.RULE_inlinefunction
3358 def enterRule(self, listener: ParseTreeListener):
3359 if hasattr(listener, "enterInlinefunction"):
3360 listener.enterInlinefunction(self)
3362 def exitRule(self, listener: ParseTreeListener):
3363 if hasattr(listener, "exitInlinefunction"):
3364 listener.exitInlinefunction(self)
3366 def inlinefunction(self):
3368 localctx = RParser.InlinefunctionContext(self, self._ctx, self.state)
3369 self.enterRule(localctx, 70, self.RULE_inlinefunction)
3370 self._la = 0 # Token type
3371 try:
3372 self.enterOuterAlt(localctx, 1)
3373 self.state = 649
3374 self._errHandler.sync(self)
3375 _la = self._input.LA(1)
3376 while _la == RParser.NL:
3377 self.state = 646
3378 self.match(RParser.NL)
3379 self.state = 651
3380 self._errHandler.sync(self)
3381 _la = self._input.LA(1)
3383 self.state = 652
3384 self.match(RParser.T__11)
3385 self.state = 656
3386 self._errHandler.sync(self)
3387 _alt = self._interp.adaptivePredict(self._input, 69, self._ctx)
3388 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
3389 if _alt == 1:
3390 self.state = 653
3391 self.match(RParser.NL)
3392 self.state = 658
3393 self._errHandler.sync(self)
3394 _alt = self._interp.adaptivePredict(self._input, 69, self._ctx)
3396 self.state = 659
3397 self.exprlist()
3398 self.state = 663
3399 self._errHandler.sync(self)
3400 _la = self._input.LA(1)
3401 while _la == RParser.NL:
3402 self.state = 660
3403 self.match(RParser.NL)
3404 self.state = 665
3405 self._errHandler.sync(self)
3406 _la = self._input.LA(1)
3408 self.state = 666
3409 self.match(RParser.T__12)
3410 self.state = 670
3411 self._errHandler.sync(self)
3412 _alt = self._interp.adaptivePredict(self._input, 71, self._ctx)
3413 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
3414 if _alt == 1:
3415 self.state = 667
3416 self.match(RParser.NL)
3417 self.state = 672
3418 self._errHandler.sync(self)
3419 _alt = self._interp.adaptivePredict(self._input, 71, self._ctx)
3421 except RecognitionException as re:
3422 localctx.exception = re
3423 self._errHandler.reportError(self, re)
3424 self._errHandler.recover(self, re)
3425 finally:
3426 self.exitRule()
3427 return localctx
3429 class Formula_simpleContext(ParserRuleContext):
3430 __slots__ = 'parser'
3432 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3433 super().__init__(parent, invokingState)
3434 self.parser = parser
3436 def formula_simple_B(self):
3437 return self.getTypedRuleContext(RParser.Formula_simple_BContext, 0)
3439 def formula_simple_A(self):
3440 return self.getTypedRuleContext(RParser.Formula_simple_AContext, 0)
3442 def formula_simple_C(self):
3443 return self.getTypedRuleContext(RParser.Formula_simple_CContext, 0)
3445 def getRuleIndex(self):
3446 return RParser.RULE_formula_simple
3448 def enterRule(self, listener: ParseTreeListener):
3449 if hasattr(listener, "enterFormula_simple"):
3450 listener.enterFormula_simple(self)
3452 def exitRule(self, listener: ParseTreeListener):
3453 if hasattr(listener, "exitFormula_simple"):
3454 listener.exitFormula_simple(self)
3456 def formula_simple(self):
3458 localctx = RParser.Formula_simpleContext(self, self._ctx, self.state)
3459 self.enterRule(localctx, 72, self.RULE_formula_simple)
3460 try:
3461 self.state = 676
3462 self._errHandler.sync(self)
3463 token = self._input.LA(1)
3464 if token in [RParser.T__37]:
3465 self.enterOuterAlt(localctx, 1)
3466 self.state = 673
3467 self.formula_simple_B()
3468 pass
3469 elif token in [RParser.T__44, RParser.ID]:
3470 self.enterOuterAlt(localctx, 2)
3471 self.state = 674
3472 self.formula_simple_A()
3473 pass
3474 elif token in [RParser.T__15]:
3475 self.enterOuterAlt(localctx, 3)
3476 self.state = 675
3477 self.formula_simple_C()
3478 pass
3479 else:
3480 raise NoViableAltException(self)
3482 except RecognitionException as re:
3483 localctx.exception = re
3484 self._errHandler.reportError(self, re)
3485 self._errHandler.recover(self, re)
3486 finally:
3487 self.exitRule()
3488 return localctx
3490 class Formula_simple_AContext(ParserRuleContext):
3491 __slots__ = 'parser'
3493 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3494 super().__init__(parent, invokingState)
3495 self.parser = parser
3497 def formop(self):
3498 return self.getTypedRuleContext(RParser.FormopContext, 0)
3500 def sublistadd(self):
3501 return self.getTypedRuleContext(RParser.SublistaddContext, 0)
3503 def identifier(self):
3504 return self.getTypedRuleContext(RParser.IdentifierContext, 0)
3506 def getRuleIndex(self):
3507 return RParser.RULE_formula_simple_A
3509 def enterRule(self, listener: ParseTreeListener):
3510 if hasattr(listener, "enterFormula_simple_A"):
3511 listener.enterFormula_simple_A(self)
3513 def exitRule(self, listener: ParseTreeListener):
3514 if hasattr(listener, "exitFormula_simple_A"):
3515 listener.exitFormula_simple_A(self)
3517 def formula_simple_A(self):
3519 localctx = RParser.Formula_simple_AContext(self, self._ctx, self.state)
3520 self.enterRule(localctx, 74, self.RULE_formula_simple_A)
3521 self._la = 0 # Token type
3522 try:
3523 self.enterOuterAlt(localctx, 1)
3524 self.state = 679
3525 self._errHandler.sync(self)
3526 _la = self._input.LA(1)
3527 if _la == RParser.ID:
3528 self.state = 678
3529 self.identifier()
3531 self.state = 681
3532 self.formop()
3533 self.state = 684
3534 self._errHandler.sync(self)
3535 token = self._input.LA(1)
3536 if token in [RParser.ID]:
3537 self.state = 682
3538 self.sublistadd()
3539 pass
3540 elif token in [RParser.T__17]:
3541 self.state = 683
3542 self.match(RParser.T__17)
3543 pass
3544 else:
3545 raise NoViableAltException(self)
3547 except RecognitionException as re:
3548 localctx.exception = re
3549 self._errHandler.reportError(self, re)
3550 self._errHandler.recover(self, re)
3551 finally:
3552 self.exitRule()
3553 return localctx
3555 class Formula_simple_BContext(ParserRuleContext):
3556 __slots__ = 'parser'
3558 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3559 super().__init__(parent, invokingState)
3560 self.parser = parser
3562 def identifier(self, i: int = None):
3563 if i is None:
3564 return self.getTypedRuleContexts(RParser.IdentifierContext)
3565 else:
3566 return self.getTypedRuleContext(RParser.IdentifierContext, i)
3568 def expr(self, i: int = None):
3569 if i is None:
3570 return self.getTypedRuleContexts(RParser.ExprContext)
3571 else:
3572 return self.getTypedRuleContext(RParser.ExprContext, i)
3574 def affectop(self):
3575 return self.getTypedRuleContext(RParser.AffectopContext, 0)
3577 def NL(self, i: int = None):
3578 if i is None:
3579 return self.getTokens(RParser.NL)
3580 else:
3581 return self.getToken(RParser.NL, i)
3583 def getRuleIndex(self):
3584 return RParser.RULE_formula_simple_B
3586 def enterRule(self, listener: ParseTreeListener):
3587 if hasattr(listener, "enterFormula_simple_B"):
3588 listener.enterFormula_simple_B(self)
3590 def exitRule(self, listener: ParseTreeListener):
3591 if hasattr(listener, "exitFormula_simple_B"):
3592 listener.exitFormula_simple_B(self)
3594 def formula_simple_B(self):
3596 localctx = RParser.Formula_simple_BContext(self, self._ctx, self.state)
3597 self.enterRule(localctx, 76, self.RULE_formula_simple_B)
3598 self._la = 0 # Token type
3599 try:
3600 self.enterOuterAlt(localctx, 1)
3601 self.state = 686
3602 self.match(RParser.T__37)
3603 self.state = 687
3604 self.match(RParser.T__15)
3605 self.state = 688
3606 self.identifier()
3607 self.state = 689
3608 self.match(RParser.T__18)
3609 self.state = 717
3610 self._errHandler.sync(self)
3611 token = self._input.LA(1)
3612 if token in [RParser.T__11]:
3613 self.state = 690
3614 self.match(RParser.T__11)
3615 self.state = 694
3616 self._errHandler.sync(self)
3617 _alt = self._interp.adaptivePredict(self._input, 75, self._ctx)
3618 while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
3619 if _alt == 1:
3620 self.state = 691
3621 self.match(RParser.NL)
3622 self.state = 696
3623 self._errHandler.sync(self)
3624 _alt = self._interp.adaptivePredict(
3625 self._input, 75, self._ctx)
3627 self.state = 697
3628 self.expr(0)
3629 self.state = 702
3630 self._errHandler.sync(self)
3631 _la = self._input.LA(1)
3632 while _la == RParser.T__0:
3633 self.state = 698
3634 self.match(RParser.T__0)
3635 self.state = 699
3636 self.expr(0)
3637 self.state = 704
3638 self._errHandler.sync(self)
3639 _la = self._input.LA(1)
3641 self.state = 708
3642 self._errHandler.sync(self)
3643 _la = self._input.LA(1)
3644 while _la == RParser.NL:
3645 self.state = 705
3646 self.match(RParser.NL)
3647 self.state = 710
3648 self._errHandler.sync(self)
3649 _la = self._input.LA(1)
3651 self.state = 711
3652 self.match(RParser.T__12)
3653 pass
3654 elif token in [RParser.ID]:
3655 self.state = 713
3656 self.identifier()
3657 self.state = 714
3658 self.affectop()
3659 self.state = 715
3660 self.expr(0)
3661 pass
3662 else:
3663 raise NoViableAltException(self)
3665 self.state = 719
3666 self.match(RParser.T__16)
3667 except RecognitionException as re:
3668 localctx.exception = re
3669 self._errHandler.reportError(self, re)
3670 self._errHandler.recover(self, re)
3671 finally:
3672 self.exitRule()
3673 return localctx
3675 class Formula_simple_CContext(ParserRuleContext):
3676 __slots__ = 'parser'
3678 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3679 super().__init__(parent, invokingState)
3680 self.parser = parser
3682 def expr(self):
3683 return self.getTypedRuleContext(RParser.ExprContext, 0)
3685 def formop(self):
3686 return self.getTypedRuleContext(RParser.FormopContext, 0)
3688 def sublistadd(self):
3689 return self.getTypedRuleContext(RParser.SublistaddContext, 0)
3691 def getRuleIndex(self):
3692 return RParser.RULE_formula_simple_C
3694 def enterRule(self, listener: ParseTreeListener):
3695 if hasattr(listener, "enterFormula_simple_C"):
3696 listener.enterFormula_simple_C(self)
3698 def exitRule(self, listener: ParseTreeListener):
3699 if hasattr(listener, "exitFormula_simple_C"):
3700 listener.exitFormula_simple_C(self)
3702 def formula_simple_C(self):
3704 localctx = RParser.Formula_simple_CContext(self, self._ctx, self.state)
3705 self.enterRule(localctx, 78, self.RULE_formula_simple_C)
3706 try:
3707 self.enterOuterAlt(localctx, 1)
3708 self.state = 721
3709 self.match(RParser.T__15)
3710 self.state = 722
3711 self.expr(0)
3712 self.state = 723
3713 self.match(RParser.T__16)
3714 self.state = 724
3715 self.formop()
3716 self.state = 727
3717 self._errHandler.sync(self)
3718 token = self._input.LA(1)
3719 if token in [RParser.ID]:
3720 self.state = 725
3721 self.sublistadd()
3722 pass
3723 elif token in [RParser.T__17]:
3724 self.state = 726
3725 self.match(RParser.T__17)
3726 pass
3727 else:
3728 raise NoViableAltException(self)
3730 except RecognitionException as re:
3731 localctx.exception = re
3732 self._errHandler.reportError(self, re)
3733 self._errHandler.recover(self, re)
3734 finally:
3735 self.exitRule()
3736 return localctx
3738 class AffectopContext(ParserRuleContext):
3739 __slots__ = 'parser'
3741 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3742 super().__init__(parent, invokingState)
3743 self.parser = parser
3745 def getRuleIndex(self):
3746 return RParser.RULE_affectop
3748 def enterRule(self, listener: ParseTreeListener):
3749 if hasattr(listener, "enterAffectop"):
3750 listener.enterAffectop(self)
3752 def exitRule(self, listener: ParseTreeListener):
3753 if hasattr(listener, "exitAffectop"):
3754 listener.exitAffectop(self)
3756 def affectop(self):
3758 localctx = RParser.AffectopContext(self, self._ctx, self.state)
3759 self.enterRule(localctx, 80, self.RULE_affectop)
3760 self._la = 0 # Token type
3761 try:
3762 self.enterOuterAlt(localctx, 1)
3763 self.state = 729
3764 _la = self._input.LA(1)
3765 if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RParser.T__19) | (1 << RParser.T__38) | (1 << RParser.T__39) | (1 << RParser.T__40) | (1 << RParser.T__41) | (1 << RParser.T__42))) != 0)):
3766 self._errHandler.recoverInline(self)
3767 else:
3768 self._errHandler.reportMatch(self)
3769 self.consume()
3770 except RecognitionException as re:
3771 localctx.exception = re
3772 self._errHandler.reportError(self, re)
3773 self._errHandler.recover(self, re)
3774 finally:
3775 self.exitRule()
3776 return localctx
3778 class FunctiondefContext(ParserRuleContext):
3779 __slots__ = 'parser'
3781 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3782 super().__init__(parent, invokingState)
3783 self.parser = parser
3785 def getRuleIndex(self):
3786 return RParser.RULE_functiondef
3788 def enterRule(self, listener: ParseTreeListener):
3789 if hasattr(listener, "enterFunctiondef"):
3790 listener.enterFunctiondef(self)
3792 def exitRule(self, listener: ParseTreeListener):
3793 if hasattr(listener, "exitFunctiondef"):
3794 listener.exitFunctiondef(self)
3796 def functiondef(self):
3798 localctx = RParser.FunctiondefContext(self, self._ctx, self.state)
3799 self.enterRule(localctx, 82, self.RULE_functiondef)
3800 try:
3801 self.enterOuterAlt(localctx, 1)
3802 self.state = 731
3803 self.match(RParser.T__43)
3804 except RecognitionException as re:
3805 localctx.exception = re
3806 self._errHandler.reportError(self, re)
3807 self._errHandler.recover(self, re)
3808 finally:
3809 self.exitRule()
3810 return localctx
3812 class IdentifierContext(ParserRuleContext):
3813 __slots__ = 'parser'
3815 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3816 super().__init__(parent, invokingState)
3817 self.parser = parser
3819 def ID(self):
3820 return self.getToken(RParser.ID, 0)
3822 def getRuleIndex(self):
3823 return RParser.RULE_identifier
3825 def enterRule(self, listener: ParseTreeListener):
3826 if hasattr(listener, "enterIdentifier"):
3827 listener.enterIdentifier(self)
3829 def exitRule(self, listener: ParseTreeListener):
3830 if hasattr(listener, "exitIdentifier"):
3831 listener.exitIdentifier(self)
3833 def identifier(self):
3835 localctx = RParser.IdentifierContext(self, self._ctx, self.state)
3836 self.enterRule(localctx, 84, self.RULE_identifier)
3837 try:
3838 self.enterOuterAlt(localctx, 1)
3839 self.state = 733
3840 self.match(RParser.ID)
3841 except RecognitionException as re:
3842 localctx.exception = re
3843 self._errHandler.reportError(self, re)
3844 self._errHandler.recover(self, re)
3845 finally:
3846 self.exitRule()
3847 return localctx
3849 class FormopContext(ParserRuleContext):
3850 __slots__ = 'parser'
3852 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3853 super().__init__(parent, invokingState)
3854 self.parser = parser
3856 def getRuleIndex(self):
3857 return RParser.RULE_formop
3859 def enterRule(self, listener: ParseTreeListener):
3860 if hasattr(listener, "enterFormop"):
3861 listener.enterFormop(self)
3863 def exitRule(self, listener: ParseTreeListener):
3864 if hasattr(listener, "exitFormop"):
3865 listener.exitFormop(self)
3867 def formop(self):
3869 localctx = RParser.FormopContext(self, self._ctx, self.state)
3870 self.enterRule(localctx, 86, self.RULE_formop)
3871 try:
3872 self.enterOuterAlt(localctx, 1)
3873 self.state = 735
3874 self.match(RParser.T__44)
3875 except RecognitionException as re:
3876 localctx.exception = re
3877 self._errHandler.reportError(self, re)
3878 self._errHandler.recover(self, re)
3879 finally:
3880 self.exitRule()
3881 return localctx
3883 class RangeopContext(ParserRuleContext):
3884 __slots__ = 'parser'
3886 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3887 super().__init__(parent, invokingState)
3888 self.parser = parser
3890 def getRuleIndex(self):
3891 return RParser.RULE_rangeop
3893 def enterRule(self, listener: ParseTreeListener):
3894 if hasattr(listener, "enterRangeop"):
3895 listener.enterRangeop(self)
3897 def exitRule(self, listener: ParseTreeListener):
3898 if hasattr(listener, "exitRangeop"):
3899 listener.exitRangeop(self)
3901 def rangeop(self):
3903 localctx = RParser.RangeopContext(self, self._ctx, self.state)
3904 self.enterRule(localctx, 88, self.RULE_rangeop)
3905 self._la = 0 # Token type
3906 try:
3907 self.enterOuterAlt(localctx, 1)
3908 self.state = 737
3909 _la = self._input.LA(1)
3910 if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RParser.T__22) | (1 << RParser.T__45) | (1 << RParser.T__46))) != 0)):
3911 self._errHandler.recoverInline(self)
3912 else:
3913 self._errHandler.reportMatch(self)
3914 self.consume()
3915 except RecognitionException as re:
3916 localctx.exception = re
3917 self._errHandler.reportError(self, re)
3918 self._errHandler.recover(self, re)
3919 finally:
3920 self.exitRule()
3921 return localctx
3923 class DotopContext(ParserRuleContext):
3924 __slots__ = 'parser'
3926 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3927 super().__init__(parent, invokingState)
3928 self.parser = parser
3930 def getRuleIndex(self):
3931 return RParser.RULE_dotop
3933 def enterRule(self, listener: ParseTreeListener):
3934 if hasattr(listener, "enterDotop"):
3935 listener.enterDotop(self)
3937 def exitRule(self, listener: ParseTreeListener):
3938 if hasattr(listener, "exitDotop"):
3939 listener.exitDotop(self)
3941 def dotop(self):
3943 localctx = RParser.DotopContext(self, self._ctx, self.state)
3944 self.enterRule(localctx, 90, self.RULE_dotop)
3945 self._la = 0 # Token type
3946 try:
3947 self.enterOuterAlt(localctx, 1)
3948 self.state = 739
3949 _la = self._input.LA(1)
3950 if not (_la == RParser.T__47 or _la == RParser.T__48):
3951 self._errHandler.recoverInline(self)
3952 else:
3953 self._errHandler.reportMatch(self)
3954 self.consume()
3955 except RecognitionException as re:
3956 localctx.exception = re
3957 self._errHandler.reportError(self, re)
3958 self._errHandler.recover(self, re)
3959 finally:
3960 self.exitRule()
3961 return localctx
3963 class OperatorContext(ParserRuleContext):
3964 __slots__ = 'parser'
3966 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
3967 super().__init__(parent, invokingState)
3968 self.parser = parser
3970 def getRuleIndex(self):
3971 return RParser.RULE_operator
3973 def enterRule(self, listener: ParseTreeListener):
3974 if hasattr(listener, "enterOperator"):
3975 listener.enterOperator(self)
3977 def exitRule(self, listener: ParseTreeListener):
3978 if hasattr(listener, "exitOperator"):
3979 listener.exitOperator(self)
3981 def operator(self):
3983 localctx = RParser.OperatorContext(self, self._ctx, self.state)
3984 self.enterRule(localctx, 92, self.RULE_operator)
3985 self._la = 0 # Token type
3986 try:
3987 self.enterOuterAlt(localctx, 1)
3988 self.state = 741
3989 _la = self._input.LA(1)
3990 if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RParser.T__4) | (1 << RParser.T__5) | (1 << RParser.T__23) | (1 << RParser.T__49) | (1 << RParser.T__50) | (1 << RParser.T__51) | (1 << RParser.T__52) | (1 << RParser.T__53))) != 0)):
3991 self._errHandler.recoverInline(self)
3992 else:
3993 self._errHandler.reportMatch(self)
3994 self.consume()
3995 except RecognitionException as re:
3996 localctx.exception = re
3997 self._errHandler.reportError(self, re)
3998 self._errHandler.recover(self, re)
3999 finally:
4000 self.exitRule()
4001 return localctx
4003 class ComparisonContext(ParserRuleContext):
4004 __slots__ = 'parser'
4006 def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
4007 super().__init__(parent, invokingState)
4008 self.parser = parser
4010 def getRuleIndex(self):
4011 return RParser.RULE_comparison
4013 def enterRule(self, listener: ParseTreeListener):
4014 if hasattr(listener, "enterComparison"):
4015 listener.enterComparison(self)
4017 def exitRule(self, listener: ParseTreeListener):
4018 if hasattr(listener, "exitComparison"):
4019 listener.exitComparison(self)
4021 def comparison(self):
4023 localctx = RParser.ComparisonContext(self, self._ctx, self.state)
4024 self.enterRule(localctx, 94, self.RULE_comparison)
4025 self._la = 0 # Token type
4026 try:
4027 self.enterOuterAlt(localctx, 1)
4028 self.state = 743
4029 _la = self._input.LA(1)
4030 if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RParser.T__54) | (1 << RParser.T__55) | (1 << RParser.T__56) | (1 << RParser.T__57) | (1 << RParser.T__58) | (1 << RParser.T__59))) != 0)):
4031 self._errHandler.recoverInline(self)
4032 else:
4033 self._errHandler.reportMatch(self)
4034 self.consume()
4035 except RecognitionException as re:
4036 localctx.exception = re
4037 self._errHandler.reportError(self, re)
4038 self._errHandler.recover(self, re)
4039 finally:
4040 self.exitRule()
4041 return localctx
4043 def sempred(self, localctx: RuleContext, ruleIndex: int, predIndex: int):
4044 if self._predicates == None:
4045 self._predicates = dict()
4046 self._predicates[1] = self.expr_sempred
4047 pred = self._predicates.get(ruleIndex, None)
4048 if pred is None:
4049 raise Exception("No predicate with index:" + str(ruleIndex))
4050 else:
4051 return pred(localctx, predIndex)
4053 def expr_sempred(self, localctx: ExprContext, predIndex: int):
4054 if predIndex == 0:
4055 return self.precpred(self._ctx, 28)
4057 if predIndex == 1:
4058 return self.precpred(self._ctx, 24)
4060 if predIndex == 2:
4061 return self.precpred(self._ctx, 23)
4063 if predIndex == 3:
4064 return self.precpred(self._ctx, 22)
4066 if predIndex == 4:
4067 return self.precpred(self._ctx, 20)
4069 if predIndex == 5:
4070 return self.precpred(self._ctx, 19)
4072 if predIndex == 6:
4073 return self.precpred(self._ctx, 30)
4075 if predIndex == 7:
4076 return self.precpred(self._ctx, 29)
4078 if predIndex == 8:
4079 return self.precpred(self._ctx, 26)
4081 if predIndex == 9:
4082 return self.precpred(self._ctx, 25)