Coverage for src/pyensae/languages/Python3Parser.py: 0%
5233 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 \Python3.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
11def serializedATN():
12 return [
13 4,1,99,1104,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,
14 7,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,
15 13,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,
16 20,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,
17 26,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,
18 33,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,
19 39,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,
20 46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,52,7,
21 52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,58,2,
22 59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,65,7,
23 65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,71,2,
24 72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,78,7,
25 78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,84,2,
26 85,7,85,1,0,1,0,1,0,1,0,1,0,3,0,178,8,0,1,1,1,1,5,1,182,8,1,10,1,
27 12,1,185,9,1,1,1,1,1,1,2,1,2,5,2,191,8,2,10,2,12,2,194,9,2,1,2,1,
28 2,1,3,1,3,1,3,1,3,3,3,202,8,3,1,3,3,3,205,8,3,1,3,1,3,1,4,4,4,210,
29 8,4,11,4,12,4,211,1,5,1,5,1,5,1,5,3,5,218,8,5,1,6,1,6,1,6,1,7,1,
30 7,1,7,1,7,1,7,3,7,228,8,7,1,7,1,7,1,7,1,8,1,8,3,8,235,8,8,1,8,1,
31 8,1,9,1,9,1,9,3,9,242,8,9,1,9,1,9,1,9,1,9,3,9,248,8,9,5,9,250,8,
32 9,10,9,12,9,253,9,9,1,9,1,9,1,9,3,9,258,8,9,1,9,1,9,1,9,1,9,3,9,
33 264,8,9,5,9,266,8,9,10,9,12,9,269,9,9,1,9,1,9,1,9,1,9,3,9,275,8,
34 9,3,9,277,8,9,3,9,279,8,9,1,9,1,9,1,9,3,9,284,8,9,3,9,286,8,9,3,
35 9,288,8,9,1,9,1,9,3,9,292,8,9,1,9,1,9,1,9,1,9,3,9,298,8,9,5,9,300,
36 8,9,10,9,12,9,303,9,9,1,9,1,9,1,9,1,9,3,9,309,8,9,3,9,311,8,9,3,
37 9,313,8,9,1,9,1,9,1,9,3,9,318,8,9,3,9,320,8,9,1,10,1,10,1,10,3,10,
38 325,8,10,1,11,1,11,1,11,3,11,330,8,11,1,11,1,11,1,11,1,11,3,11,336,
39 8,11,5,11,338,8,11,10,11,12,11,341,9,11,1,11,1,11,1,11,3,11,346,
40 8,11,1,11,1,11,1,11,1,11,3,11,352,8,11,5,11,354,8,11,10,11,12,11,
41 357,9,11,1,11,1,11,1,11,1,11,3,11,363,8,11,3,11,365,8,11,3,11,367,
42 8,11,1,11,1,11,1,11,3,11,372,8,11,3,11,374,8,11,3,11,376,8,11,1,
43 11,1,11,3,11,380,8,11,1,11,1,11,1,11,1,11,3,11,386,8,11,5,11,388,
44 8,11,10,11,12,11,391,9,11,1,11,1,11,1,11,1,11,3,11,397,8,11,3,11,
45 399,8,11,3,11,401,8,11,1,11,1,11,1,11,3,11,406,8,11,3,11,408,8,11,
46 1,12,1,12,1,13,1,13,3,13,414,8,13,1,14,1,14,1,14,5,14,419,8,14,10,
47 14,12,14,422,9,14,1,14,3,14,425,8,14,1,14,1,14,1,15,1,15,1,15,1,
48 15,1,15,1,15,1,15,1,15,3,15,437,8,15,1,16,1,16,1,16,1,16,1,16,3,
49 16,444,8,16,1,16,1,16,1,16,3,16,449,8,16,5,16,451,8,16,10,16,12,
50 16,454,9,16,3,16,456,8,16,1,17,1,17,1,17,1,17,3,17,462,8,17,1,18,
51 1,18,3,18,466,8,18,1,18,1,18,1,18,3,18,471,8,18,5,18,473,8,18,10,
52 18,12,18,476,9,18,1,18,3,18,479,8,18,1,19,1,19,1,20,1,20,1,20,1,
53 21,1,21,1,22,1,22,1,22,1,22,1,22,3,22,493,8,22,1,23,1,23,1,24,1,
54 24,1,25,1,25,3,25,501,8,25,1,26,1,26,1,27,1,27,1,27,1,27,3,27,509,
55 8,27,3,27,511,8,27,1,28,1,28,3,28,515,8,28,1,29,1,29,1,29,1,30,1,
56 30,5,30,522,8,30,10,30,12,30,525,9,30,1,30,1,30,4,30,529,8,30,11,
57 30,12,30,530,3,30,533,8,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,3,
58 30,542,8,30,1,31,1,31,1,31,3,31,547,8,31,1,32,1,32,1,32,3,32,552,
59 8,32,1,33,1,33,1,33,5,33,557,8,33,10,33,12,33,560,9,33,1,33,3,33,
60 563,8,33,1,34,1,34,1,34,5,34,568,8,34,10,34,12,34,571,9,34,1,35,
61 1,35,1,35,5,35,576,8,35,10,35,12,35,579,9,35,1,36,1,36,1,36,1,36,
62 5,36,585,8,36,10,36,12,36,588,9,36,1,37,1,37,1,37,1,37,5,37,594,
63 8,37,10,37,12,37,597,9,37,1,38,1,38,1,38,1,38,3,38,603,8,38,1,39,
64 1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,3,39,614,8,39,1,40,1,40,
65 1,40,1,40,3,40,620,8,40,1,41,1,41,1,41,1,41,1,41,1,41,1,41,1,41,
66 1,41,5,41,631,8,41,10,41,12,41,634,9,41,1,41,1,41,1,41,3,41,639,
67 8,41,1,42,1,42,1,42,1,42,1,42,1,42,1,42,3,42,648,8,42,1,43,1,43,
68 1,43,1,43,1,43,1,43,1,43,1,43,1,43,3,43,659,8,43,1,44,1,44,1,44,
69 1,44,1,44,1,44,1,44,4,44,668,8,44,11,44,12,44,669,1,44,1,44,1,44,
70 3,44,675,8,44,1,44,1,44,1,44,3,44,680,8,44,1,44,1,44,1,44,3,44,685,
71 8,44,1,45,1,45,1,45,1,45,5,45,691,8,45,10,45,12,45,694,9,45,1,45,
72 1,45,1,45,1,46,1,46,1,46,3,46,702,8,46,1,47,1,47,1,47,1,47,3,47,
73 708,8,47,3,47,710,8,47,1,48,1,48,1,48,1,48,4,48,716,8,48,11,48,12,
74 48,717,1,48,1,48,3,48,722,8,48,1,49,1,49,1,49,1,49,1,49,1,49,3,49,
75 730,8,49,1,49,3,49,733,8,49,1,50,1,50,3,50,737,8,50,1,51,1,51,3,
76 51,741,8,51,1,51,1,51,1,51,1,52,1,52,3,52,748,8,52,1,52,1,52,1,52,
77 1,53,1,53,1,53,5,53,756,8,53,10,53,12,53,759,9,53,1,54,1,54,1,54,
78 5,54,764,8,54,10,54,12,54,767,9,54,1,55,1,55,1,55,3,55,772,8,55,
79 1,56,1,56,1,56,1,56,5,56,778,8,56,10,56,12,56,781,9,56,1,57,1,57,
80 1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,3,57,796,
81 8,57,1,58,1,58,1,58,1,59,1,59,1,59,5,59,804,8,59,10,59,12,59,807,
82 9,59,1,60,1,60,1,60,5,60,812,8,60,10,60,12,60,815,9,60,1,61,1,61,
83 1,61,5,61,820,8,61,10,61,12,61,823,9,61,1,62,1,62,1,62,5,62,828,
84 8,62,10,62,12,62,831,9,62,1,63,1,63,1,63,5,63,836,8,63,10,63,12,
85 63,839,9,63,1,64,1,64,1,64,5,64,844,8,64,10,64,12,64,847,9,64,1,
86 65,1,65,1,65,3,65,852,8,65,1,66,1,66,1,66,3,66,857,8,66,1,67,3,67,
87 860,8,67,1,67,1,67,5,67,864,8,67,10,67,12,67,867,9,67,1,68,1,68,
88 1,68,3,68,872,8,68,1,68,1,68,1,68,3,68,877,8,68,1,68,1,68,1,68,3,
89 68,882,8,68,1,68,1,68,1,68,1,68,4,68,888,8,68,11,68,12,68,889,1,
90 68,1,68,1,68,1,68,3,68,896,8,68,1,69,1,69,3,69,900,8,69,1,69,1,69,
91 1,69,1,69,3,69,906,8,69,5,69,908,8,69,10,69,12,69,911,9,69,1,69,
92 3,69,914,8,69,3,69,916,8,69,1,70,1,70,3,70,920,8,70,1,70,1,70,1,
93 70,1,70,1,70,1,70,1,70,3,70,929,8,70,1,71,1,71,1,71,5,71,934,8,71,
94 10,71,12,71,937,9,71,1,71,3,71,940,8,71,1,72,1,72,3,72,944,8,72,
95 1,72,1,72,3,72,948,8,72,1,72,3,72,951,8,72,3,72,953,8,72,1,73,1,
96 73,3,73,957,8,73,1,74,1,74,3,74,961,8,74,1,74,1,74,1,74,3,74,966,
97 8,74,5,74,968,8,74,10,74,12,74,971,9,74,1,74,3,74,974,8,74,1,75,
98 1,75,1,75,5,75,979,8,75,10,75,12,75,982,9,75,1,75,3,75,985,8,75,
99 1,76,1,76,1,76,1,76,1,76,1,76,3,76,993,8,76,1,76,1,76,1,76,1,76,
100 1,76,1,76,1,76,1,76,3,76,1003,8,76,5,76,1005,8,76,10,76,12,76,1008,
101 9,76,1,76,3,76,1011,8,76,3,76,1013,8,76,1,76,1,76,3,76,1017,8,76,
102 1,76,1,76,1,76,1,76,3,76,1023,8,76,5,76,1025,8,76,10,76,12,76,1028,
103 9,76,1,76,3,76,1031,8,76,3,76,1033,8,76,3,76,1035,8,76,1,77,1,77,
104 1,77,1,77,3,77,1041,8,77,1,77,3,77,1044,8,77,1,77,1,77,1,77,1,78,
105 1,78,1,78,5,78,1052,8,78,10,78,12,78,1055,9,78,1,78,3,78,1058,8,
106 78,1,79,1,79,3,79,1062,8,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,
107 79,3,79,1072,8,79,1,80,1,80,3,80,1076,8,80,1,81,3,81,1079,8,81,1,
108 81,1,81,1,81,1,81,1,81,3,81,1086,8,81,1,82,1,82,1,82,3,82,1091,8,
109 82,1,83,1,83,1,84,1,84,3,84,1097,8,84,1,85,1,85,1,85,3,85,1102,8,
110 85,1,85,0,0,86,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,
111 36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,
112 80,82,84,86,88,90,92,94,96,98,100,102,104,106,108,110,112,114,116,
113 118,120,122,124,126,128,130,132,134,136,138,140,142,144,146,148,
114 150,152,154,156,158,160,162,164,166,168,170,0,6,1,0,83,95,1,0,49,
115 50,1,0,64,65,1,0,66,67,3,0,51,51,68,70,81,81,2,0,66,67,71,71,1229,
116 0,177,1,0,0,0,2,183,1,0,0,0,4,188,1,0,0,0,6,197,1,0,0,0,8,209,1,
117 0,0,0,10,213,1,0,0,0,12,219,1,0,0,0,14,222,1,0,0,0,16,232,1,0,0,
118 0,18,319,1,0,0,0,20,321,1,0,0,0,22,407,1,0,0,0,24,409,1,0,0,0,26,
119 413,1,0,0,0,28,415,1,0,0,0,30,436,1,0,0,0,32,438,1,0,0,0,34,457,
120 1,0,0,0,36,465,1,0,0,0,38,480,1,0,0,0,40,482,1,0,0,0,42,485,1,0,
121 0,0,44,492,1,0,0,0,46,494,1,0,0,0,48,496,1,0,0,0,50,498,1,0,0,0,
122 52,502,1,0,0,0,54,504,1,0,0,0,56,514,1,0,0,0,58,516,1,0,0,0,60,519,
123 1,0,0,0,62,543,1,0,0,0,64,548,1,0,0,0,66,553,1,0,0,0,68,564,1,0,
124 0,0,70,572,1,0,0,0,72,580,1,0,0,0,74,589,1,0,0,0,76,598,1,0,0,0,
125 78,613,1,0,0,0,80,615,1,0,0,0,82,621,1,0,0,0,84,640,1,0,0,0,86,649,
126 1,0,0,0,88,660,1,0,0,0,90,686,1,0,0,0,92,698,1,0,0,0,94,703,1,0,
127 0,0,96,721,1,0,0,0,98,732,1,0,0,0,100,736,1,0,0,0,102,738,1,0,0,
128 0,104,745,1,0,0,0,106,752,1,0,0,0,108,760,1,0,0,0,110,771,1,0,0,
129 0,112,773,1,0,0,0,114,795,1,0,0,0,116,797,1,0,0,0,118,800,1,0,0,
130 0,120,808,1,0,0,0,122,816,1,0,0,0,124,824,1,0,0,0,126,832,1,0,0,
131 0,128,840,1,0,0,0,130,851,1,0,0,0,132,853,1,0,0,0,134,859,1,0,0,
132 0,136,895,1,0,0,0,138,899,1,0,0,0,140,928,1,0,0,0,142,930,1,0,0,
133 0,144,952,1,0,0,0,146,954,1,0,0,0,148,960,1,0,0,0,150,975,1,0,0,
134 0,152,1034,1,0,0,0,154,1036,1,0,0,0,156,1048,1,0,0,0,158,1071,1,
135 0,0,0,160,1075,1,0,0,0,162,1078,1,0,0,0,164,1087,1,0,0,0,166,1092,
136 1,0,0,0,168,1094,1,0,0,0,170,1101,1,0,0,0,172,178,5,39,0,0,173,178,
137 3,28,14,0,174,175,3,78,39,0,175,176,5,39,0,0,176,178,1,0,0,0,177,
138 172,1,0,0,0,177,173,1,0,0,0,177,174,1,0,0,0,178,1,1,0,0,0,179,182,
139 5,39,0,0,180,182,3,26,13,0,181,179,1,0,0,0,181,180,1,0,0,0,182,185,
140 1,0,0,0,183,181,1,0,0,0,183,184,1,0,0,0,184,186,1,0,0,0,185,183,
141 1,0,0,0,186,187,5,0,0,1,187,3,1,0,0,0,188,192,3,150,75,0,189,191,
142 5,39,0,0,190,189,1,0,0,0,191,194,1,0,0,0,192,190,1,0,0,0,192,193,
143 1,0,0,0,193,195,1,0,0,0,194,192,1,0,0,0,195,196,5,0,0,1,196,5,1,
144 0,0,0,197,198,5,81,0,0,198,204,3,70,35,0,199,201,5,52,0,0,200,202,
145 3,156,78,0,201,200,1,0,0,0,201,202,1,0,0,0,202,203,1,0,0,0,203,205,
146 5,53,0,0,204,199,1,0,0,0,204,205,1,0,0,0,205,206,1,0,0,0,206,207,
147 5,39,0,0,207,7,1,0,0,0,208,210,3,6,3,0,209,208,1,0,0,0,210,211,1,
148 0,0,0,211,209,1,0,0,0,211,212,1,0,0,0,212,9,1,0,0,0,213,217,3,8,
149 4,0,214,218,3,154,77,0,215,218,3,14,7,0,216,218,3,12,6,0,217,214,
150 1,0,0,0,217,215,1,0,0,0,217,216,1,0,0,0,218,11,1,0,0,0,219,220,5,
151 37,0,0,220,221,3,14,7,0,221,13,1,0,0,0,222,223,5,4,0,0,223,224,5,
152 40,0,0,224,227,3,16,8,0,225,226,5,82,0,0,226,228,3,98,49,0,227,225,
153 1,0,0,0,227,228,1,0,0,0,228,229,1,0,0,0,229,230,5,55,0,0,230,231,
154 3,96,48,0,231,15,1,0,0,0,232,234,5,52,0,0,233,235,3,18,9,0,234,233,
155 1,0,0,0,234,235,1,0,0,0,235,236,1,0,0,0,236,237,5,53,0,0,237,17,
156 1,0,0,0,238,241,3,20,10,0,239,240,5,58,0,0,240,242,3,98,49,0,241,
157 239,1,0,0,0,241,242,1,0,0,0,242,251,1,0,0,0,243,244,5,54,0,0,244,
158 247,3,20,10,0,245,246,5,58,0,0,246,248,3,98,49,0,247,245,1,0,0,0,
159 247,248,1,0,0,0,248,250,1,0,0,0,249,243,1,0,0,0,250,253,1,0,0,0,
160 251,249,1,0,0,0,251,252,1,0,0,0,252,287,1,0,0,0,253,251,1,0,0,0,
161 254,285,5,54,0,0,255,257,5,51,0,0,256,258,3,20,10,0,257,256,1,0,
162 0,0,257,258,1,0,0,0,258,267,1,0,0,0,259,260,5,54,0,0,260,263,3,20,
163 10,0,261,262,5,58,0,0,262,264,3,98,49,0,263,261,1,0,0,0,263,264,
164 1,0,0,0,264,266,1,0,0,0,265,259,1,0,0,0,266,269,1,0,0,0,267,265,
165 1,0,0,0,267,268,1,0,0,0,268,278,1,0,0,0,269,267,1,0,0,0,270,276,
166 5,54,0,0,271,272,5,57,0,0,272,274,3,20,10,0,273,275,5,54,0,0,274,
167 273,1,0,0,0,274,275,1,0,0,0,275,277,1,0,0,0,276,271,1,0,0,0,276,
168 277,1,0,0,0,277,279,1,0,0,0,278,270,1,0,0,0,278,279,1,0,0,0,279,
169 286,1,0,0,0,280,281,5,57,0,0,281,283,3,20,10,0,282,284,5,54,0,0,
170 283,282,1,0,0,0,283,284,1,0,0,0,284,286,1,0,0,0,285,255,1,0,0,0,
171 285,280,1,0,0,0,285,286,1,0,0,0,286,288,1,0,0,0,287,254,1,0,0,0,
172 287,288,1,0,0,0,288,320,1,0,0,0,289,291,5,51,0,0,290,292,3,20,10,
173 0,291,290,1,0,0,0,291,292,1,0,0,0,292,301,1,0,0,0,293,294,5,54,0,
174 0,294,297,3,20,10,0,295,296,5,58,0,0,296,298,3,98,49,0,297,295,1,
175 0,0,0,297,298,1,0,0,0,298,300,1,0,0,0,299,293,1,0,0,0,300,303,1,
176 0,0,0,301,299,1,0,0,0,301,302,1,0,0,0,302,312,1,0,0,0,303,301,1,
177 0,0,0,304,310,5,54,0,0,305,306,5,57,0,0,306,308,3,20,10,0,307,309,
178 5,54,0,0,308,307,1,0,0,0,308,309,1,0,0,0,309,311,1,0,0,0,310,305,
179 1,0,0,0,310,311,1,0,0,0,311,313,1,0,0,0,312,304,1,0,0,0,312,313,
180 1,0,0,0,313,320,1,0,0,0,314,315,5,57,0,0,315,317,3,20,10,0,316,318,
181 5,54,0,0,317,316,1,0,0,0,317,318,1,0,0,0,318,320,1,0,0,0,319,238,
182 1,0,0,0,319,289,1,0,0,0,319,314,1,0,0,0,320,19,1,0,0,0,321,324,5,
183 40,0,0,322,323,5,55,0,0,323,325,3,98,49,0,324,322,1,0,0,0,324,325,
184 1,0,0,0,325,21,1,0,0,0,326,329,3,24,12,0,327,328,5,58,0,0,328,330,
185 3,98,49,0,329,327,1,0,0,0,329,330,1,0,0,0,330,339,1,0,0,0,331,332,
186 5,54,0,0,332,335,3,24,12,0,333,334,5,58,0,0,334,336,3,98,49,0,335,
187 333,1,0,0,0,335,336,1,0,0,0,336,338,1,0,0,0,337,331,1,0,0,0,338,
188 341,1,0,0,0,339,337,1,0,0,0,339,340,1,0,0,0,340,375,1,0,0,0,341,
189 339,1,0,0,0,342,373,5,54,0,0,343,345,5,51,0,0,344,346,3,24,12,0,
190 345,344,1,0,0,0,345,346,1,0,0,0,346,355,1,0,0,0,347,348,5,54,0,0,
191 348,351,3,24,12,0,349,350,5,58,0,0,350,352,3,98,49,0,351,349,1,0,
192 0,0,351,352,1,0,0,0,352,354,1,0,0,0,353,347,1,0,0,0,354,357,1,0,
193 0,0,355,353,1,0,0,0,355,356,1,0,0,0,356,366,1,0,0,0,357,355,1,0,
194 0,0,358,364,5,54,0,0,359,360,5,57,0,0,360,362,3,24,12,0,361,363,
195 5,54,0,0,362,361,1,0,0,0,362,363,1,0,0,0,363,365,1,0,0,0,364,359,
196 1,0,0,0,364,365,1,0,0,0,365,367,1,0,0,0,366,358,1,0,0,0,366,367,
197 1,0,0,0,367,374,1,0,0,0,368,369,5,57,0,0,369,371,3,24,12,0,370,372,
198 5,54,0,0,371,370,1,0,0,0,371,372,1,0,0,0,372,374,1,0,0,0,373,343,
199 1,0,0,0,373,368,1,0,0,0,373,374,1,0,0,0,374,376,1,0,0,0,375,342,
200 1,0,0,0,375,376,1,0,0,0,376,408,1,0,0,0,377,379,5,51,0,0,378,380,
201 3,24,12,0,379,378,1,0,0,0,379,380,1,0,0,0,380,389,1,0,0,0,381,382,
202 5,54,0,0,382,385,3,24,12,0,383,384,5,58,0,0,384,386,3,98,49,0,385,
203 383,1,0,0,0,385,386,1,0,0,0,386,388,1,0,0,0,387,381,1,0,0,0,388,
204 391,1,0,0,0,389,387,1,0,0,0,389,390,1,0,0,0,390,400,1,0,0,0,391,
205 389,1,0,0,0,392,398,5,54,0,0,393,394,5,57,0,0,394,396,3,24,12,0,
206 395,397,5,54,0,0,396,395,1,0,0,0,396,397,1,0,0,0,397,399,1,0,0,0,
207 398,393,1,0,0,0,398,399,1,0,0,0,399,401,1,0,0,0,400,392,1,0,0,0,
208 400,401,1,0,0,0,401,408,1,0,0,0,402,403,5,57,0,0,403,405,3,24,12,
209 0,404,406,5,54,0,0,405,404,1,0,0,0,405,406,1,0,0,0,406,408,1,0,0,
210 0,407,326,1,0,0,0,407,377,1,0,0,0,407,402,1,0,0,0,408,23,1,0,0,0,
211 409,410,5,40,0,0,410,25,1,0,0,0,411,414,3,28,14,0,412,414,3,78,39,
212 0,413,411,1,0,0,0,413,412,1,0,0,0,414,27,1,0,0,0,415,420,3,30,15,
213 0,416,417,5,56,0,0,417,419,3,30,15,0,418,416,1,0,0,0,419,422,1,0,
214 0,0,420,418,1,0,0,0,420,421,1,0,0,0,421,424,1,0,0,0,422,420,1,0,
215 0,0,423,425,5,56,0,0,424,423,1,0,0,0,424,425,1,0,0,0,425,426,1,0,
216 0,0,426,427,5,39,0,0,427,29,1,0,0,0,428,437,3,32,16,0,429,437,3,
217 40,20,0,430,437,3,42,21,0,431,437,3,44,22,0,432,437,3,56,28,0,433,
218 437,3,72,36,0,434,437,3,74,37,0,435,437,3,76,38,0,436,428,1,0,0,
219 0,436,429,1,0,0,0,436,430,1,0,0,0,436,431,1,0,0,0,436,432,1,0,0,
220 0,436,433,1,0,0,0,436,434,1,0,0,0,436,435,1,0,0,0,437,31,1,0,0,0,
221 438,455,3,36,18,0,439,456,3,34,17,0,440,443,3,38,19,0,441,444,3,
222 168,84,0,442,444,3,150,75,0,443,441,1,0,0,0,443,442,1,0,0,0,444,
223 456,1,0,0,0,445,448,5,58,0,0,446,449,3,168,84,0,447,449,3,36,18,
224 0,448,446,1,0,0,0,448,447,1,0,0,0,449,451,1,0,0,0,450,445,1,0,0,
225 0,451,454,1,0,0,0,452,450,1,0,0,0,452,453,1,0,0,0,453,456,1,0,0,
226 0,454,452,1,0,0,0,455,439,1,0,0,0,455,440,1,0,0,0,455,452,1,0,0,
227 0,456,33,1,0,0,0,457,458,5,55,0,0,458,461,3,98,49,0,459,460,5,58,
228 0,0,460,462,3,98,49,0,461,459,1,0,0,0,461,462,1,0,0,0,462,35,1,0,
229 0,0,463,466,3,98,49,0,464,466,3,116,58,0,465,463,1,0,0,0,465,464,
230 1,0,0,0,466,474,1,0,0,0,467,470,5,54,0,0,468,471,3,98,49,0,469,471,
231 3,116,58,0,470,468,1,0,0,0,470,469,1,0,0,0,471,473,1,0,0,0,472,467,
232 1,0,0,0,473,476,1,0,0,0,474,472,1,0,0,0,474,475,1,0,0,0,475,478,
233 1,0,0,0,476,474,1,0,0,0,477,479,5,54,0,0,478,477,1,0,0,0,478,479,
234 1,0,0,0,479,37,1,0,0,0,480,481,7,0,0,0,481,39,1,0,0,0,482,483,5,
235 33,0,0,483,484,3,148,74,0,484,41,1,0,0,0,485,486,5,34,0,0,486,43,
236 1,0,0,0,487,493,3,46,23,0,488,493,3,48,24,0,489,493,3,50,25,0,490,
237 493,3,54,27,0,491,493,3,52,26,0,492,487,1,0,0,0,492,488,1,0,0,0,
238 492,489,1,0,0,0,492,490,1,0,0,0,492,491,1,0,0,0,493,45,1,0,0,0,494,
239 495,5,36,0,0,495,47,1,0,0,0,496,497,5,35,0,0,497,49,1,0,0,0,498,
240 500,5,5,0,0,499,501,3,150,75,0,500,499,1,0,0,0,500,501,1,0,0,0,501,
241 51,1,0,0,0,502,503,3,168,84,0,503,53,1,0,0,0,504,510,5,6,0,0,505,
242 508,3,98,49,0,506,507,5,7,0,0,507,509,3,98,49,0,508,506,1,0,0,0,
243 508,509,1,0,0,0,509,511,1,0,0,0,510,505,1,0,0,0,510,511,1,0,0,0,
244 511,55,1,0,0,0,512,515,3,58,29,0,513,515,3,60,30,0,514,512,1,0,0,
245 0,514,513,1,0,0,0,515,57,1,0,0,0,516,517,5,8,0,0,517,518,3,68,34,
246 0,518,59,1,0,0,0,519,532,5,7,0,0,520,522,7,1,0,0,521,520,1,0,0,0,
247 522,525,1,0,0,0,523,521,1,0,0,0,523,524,1,0,0,0,524,526,1,0,0,0,
248 525,523,1,0,0,0,526,533,3,70,35,0,527,529,7,1,0,0,528,527,1,0,0,
249 0,529,530,1,0,0,0,530,528,1,0,0,0,530,531,1,0,0,0,531,533,1,0,0,
250 0,532,523,1,0,0,0,532,528,1,0,0,0,533,534,1,0,0,0,534,541,5,8,0,
251 0,535,542,5,51,0,0,536,537,5,52,0,0,537,538,3,66,33,0,538,539,5,
252 53,0,0,539,542,1,0,0,0,540,542,3,66,33,0,541,535,1,0,0,0,541,536,
253 1,0,0,0,541,540,1,0,0,0,542,61,1,0,0,0,543,546,5,40,0,0,544,545,
254 5,9,0,0,545,547,5,40,0,0,546,544,1,0,0,0,546,547,1,0,0,0,547,63,
255 1,0,0,0,548,551,3,70,35,0,549,550,5,9,0,0,550,552,5,40,0,0,551,549,
256 1,0,0,0,551,552,1,0,0,0,552,65,1,0,0,0,553,558,3,62,31,0,554,555,
257 5,54,0,0,555,557,3,62,31,0,556,554,1,0,0,0,557,560,1,0,0,0,558,556,
258 1,0,0,0,558,559,1,0,0,0,559,562,1,0,0,0,560,558,1,0,0,0,561,563,
259 5,54,0,0,562,561,1,0,0,0,562,563,1,0,0,0,563,67,1,0,0,0,564,569,
260 3,64,32,0,565,566,5,54,0,0,566,568,3,64,32,0,567,565,1,0,0,0,568,
261 571,1,0,0,0,569,567,1,0,0,0,569,570,1,0,0,0,570,69,1,0,0,0,571,569,
262 1,0,0,0,572,577,5,40,0,0,573,574,5,49,0,0,574,576,5,40,0,0,575,573,
263 1,0,0,0,576,579,1,0,0,0,577,575,1,0,0,0,577,578,1,0,0,0,578,71,1,
264 0,0,0,579,577,1,0,0,0,580,581,5,10,0,0,581,586,5,40,0,0,582,583,
265 5,54,0,0,583,585,5,40,0,0,584,582,1,0,0,0,585,588,1,0,0,0,586,584,
266 1,0,0,0,586,587,1,0,0,0,587,73,1,0,0,0,588,586,1,0,0,0,589,590,5,
267 11,0,0,590,595,5,40,0,0,591,592,5,54,0,0,592,594,5,40,0,0,593,591,
268 1,0,0,0,594,597,1,0,0,0,595,593,1,0,0,0,595,596,1,0,0,0,596,75,1,
269 0,0,0,597,595,1,0,0,0,598,599,5,12,0,0,599,602,3,98,49,0,600,601,
270 5,54,0,0,601,603,3,98,49,0,602,600,1,0,0,0,602,603,1,0,0,0,603,77,
271 1,0,0,0,604,614,3,82,41,0,605,614,3,84,42,0,606,614,3,86,43,0,607,
272 614,3,88,44,0,608,614,3,90,45,0,609,614,3,14,7,0,610,614,3,154,77,
273 0,611,614,3,10,5,0,612,614,3,80,40,0,613,604,1,0,0,0,613,605,1,0,
274 0,0,613,606,1,0,0,0,613,607,1,0,0,0,613,608,1,0,0,0,613,609,1,0,
275 0,0,613,610,1,0,0,0,613,611,1,0,0,0,613,612,1,0,0,0,614,79,1,0,0,
276 0,615,619,5,37,0,0,616,620,3,14,7,0,617,620,3,90,45,0,618,620,3,
277 86,43,0,619,616,1,0,0,0,619,617,1,0,0,0,619,618,1,0,0,0,620,81,1,
278 0,0,0,621,622,5,13,0,0,622,623,3,98,49,0,623,624,5,55,0,0,624,632,
279 3,96,48,0,625,626,5,14,0,0,626,627,3,98,49,0,627,628,5,55,0,0,628,
280 629,3,96,48,0,629,631,1,0,0,0,630,625,1,0,0,0,631,634,1,0,0,0,632,
281 630,1,0,0,0,632,633,1,0,0,0,633,638,1,0,0,0,634,632,1,0,0,0,635,
282 636,5,15,0,0,636,637,5,55,0,0,637,639,3,96,48,0,638,635,1,0,0,0,
283 638,639,1,0,0,0,639,83,1,0,0,0,640,641,5,16,0,0,641,642,3,98,49,
284 0,642,643,5,55,0,0,643,647,3,96,48,0,644,645,5,15,0,0,645,646,5,
285 55,0,0,646,648,3,96,48,0,647,644,1,0,0,0,647,648,1,0,0,0,648,85,
286 1,0,0,0,649,650,5,17,0,0,650,651,3,148,74,0,651,652,5,18,0,0,652,
287 653,3,150,75,0,653,654,5,55,0,0,654,658,3,96,48,0,655,656,5,15,0,
288 0,656,657,5,55,0,0,657,659,3,96,48,0,658,655,1,0,0,0,658,659,1,0,
289 0,0,659,87,1,0,0,0,660,661,5,19,0,0,661,662,5,55,0,0,662,684,3,96,
290 48,0,663,664,3,94,47,0,664,665,5,55,0,0,665,666,3,96,48,0,666,668,
291 1,0,0,0,667,663,1,0,0,0,668,669,1,0,0,0,669,667,1,0,0,0,669,670,
292 1,0,0,0,670,674,1,0,0,0,671,672,5,15,0,0,672,673,5,55,0,0,673,675,
293 3,96,48,0,674,671,1,0,0,0,674,675,1,0,0,0,675,679,1,0,0,0,676,677,
294 5,20,0,0,677,678,5,55,0,0,678,680,3,96,48,0,679,676,1,0,0,0,679,
295 680,1,0,0,0,680,685,1,0,0,0,681,682,5,20,0,0,682,683,5,55,0,0,683,
296 685,3,96,48,0,684,667,1,0,0,0,684,681,1,0,0,0,685,89,1,0,0,0,686,
297 687,5,21,0,0,687,692,3,92,46,0,688,689,5,54,0,0,689,691,3,92,46,
298 0,690,688,1,0,0,0,691,694,1,0,0,0,692,690,1,0,0,0,692,693,1,0,0,
299 0,693,695,1,0,0,0,694,692,1,0,0,0,695,696,5,55,0,0,696,697,3,96,
300 48,0,697,91,1,0,0,0,698,701,3,98,49,0,699,700,5,9,0,0,700,702,3,
301 118,59,0,701,699,1,0,0,0,701,702,1,0,0,0,702,93,1,0,0,0,703,709,
302 5,22,0,0,704,707,3,98,49,0,705,706,5,9,0,0,706,708,5,40,0,0,707,
303 705,1,0,0,0,707,708,1,0,0,0,708,710,1,0,0,0,709,704,1,0,0,0,709,
304 710,1,0,0,0,710,95,1,0,0,0,711,722,3,28,14,0,712,713,5,39,0,0,713,
305 715,5,98,0,0,714,716,3,26,13,0,715,714,1,0,0,0,716,717,1,0,0,0,717,
306 715,1,0,0,0,717,718,1,0,0,0,718,719,1,0,0,0,719,720,5,99,0,0,720,
307 722,1,0,0,0,721,711,1,0,0,0,721,712,1,0,0,0,722,97,1,0,0,0,723,729,
308 3,106,53,0,724,725,5,13,0,0,725,726,3,106,53,0,726,727,5,15,0,0,
309 727,728,3,98,49,0,728,730,1,0,0,0,729,724,1,0,0,0,729,730,1,0,0,
310 0,730,733,1,0,0,0,731,733,3,102,51,0,732,723,1,0,0,0,732,731,1,0,
311 0,0,733,99,1,0,0,0,734,737,3,106,53,0,735,737,3,104,52,0,736,734,
312 1,0,0,0,736,735,1,0,0,0,737,101,1,0,0,0,738,740,5,23,0,0,739,741,
313 3,22,11,0,740,739,1,0,0,0,740,741,1,0,0,0,741,742,1,0,0,0,742,743,
314 5,55,0,0,743,744,3,98,49,0,744,103,1,0,0,0,745,747,5,23,0,0,746,
315 748,3,22,11,0,747,746,1,0,0,0,747,748,1,0,0,0,748,749,1,0,0,0,749,
316 750,5,55,0,0,750,751,3,100,50,0,751,105,1,0,0,0,752,757,3,108,54,
317 0,753,754,5,24,0,0,754,756,3,108,54,0,755,753,1,0,0,0,756,759,1,
318 0,0,0,757,755,1,0,0,0,757,758,1,0,0,0,758,107,1,0,0,0,759,757,1,
319 0,0,0,760,765,3,110,55,0,761,762,5,25,0,0,762,764,3,110,55,0,763,
320 761,1,0,0,0,764,767,1,0,0,0,765,763,1,0,0,0,765,766,1,0,0,0,766,
321 109,1,0,0,0,767,765,1,0,0,0,768,769,5,26,0,0,769,772,3,110,55,0,
322 770,772,3,112,56,0,771,768,1,0,0,0,771,770,1,0,0,0,772,111,1,0,0,
323 0,773,779,3,118,59,0,774,775,3,114,57,0,775,776,3,118,59,0,776,778,
324 1,0,0,0,777,774,1,0,0,0,778,781,1,0,0,0,779,777,1,0,0,0,779,780,
325 1,0,0,0,780,113,1,0,0,0,781,779,1,0,0,0,782,796,5,74,0,0,783,796,
326 5,75,0,0,784,796,5,76,0,0,785,796,5,77,0,0,786,796,5,78,0,0,787,
327 796,5,79,0,0,788,796,5,80,0,0,789,796,5,18,0,0,790,791,5,26,0,0,
328 791,796,5,18,0,0,792,796,5,27,0,0,793,794,5,27,0,0,794,796,5,26,
329 0,0,795,782,1,0,0,0,795,783,1,0,0,0,795,784,1,0,0,0,795,785,1,0,
330 0,0,795,786,1,0,0,0,795,787,1,0,0,0,795,788,1,0,0,0,795,789,1,0,
331 0,0,795,790,1,0,0,0,795,792,1,0,0,0,795,793,1,0,0,0,796,115,1,0,
332 0,0,797,798,5,51,0,0,798,799,3,118,59,0,799,117,1,0,0,0,800,805,
333 3,120,60,0,801,802,5,61,0,0,802,804,3,120,60,0,803,801,1,0,0,0,804,
334 807,1,0,0,0,805,803,1,0,0,0,805,806,1,0,0,0,806,119,1,0,0,0,807,
335 805,1,0,0,0,808,813,3,122,61,0,809,810,5,62,0,0,810,812,3,122,61,
336 0,811,809,1,0,0,0,812,815,1,0,0,0,813,811,1,0,0,0,813,814,1,0,0,
337 0,814,121,1,0,0,0,815,813,1,0,0,0,816,821,3,124,62,0,817,818,5,63,
338 0,0,818,820,3,124,62,0,819,817,1,0,0,0,820,823,1,0,0,0,821,819,1,
339 0,0,0,821,822,1,0,0,0,822,123,1,0,0,0,823,821,1,0,0,0,824,829,3,
340 126,63,0,825,826,7,2,0,0,826,828,3,126,63,0,827,825,1,0,0,0,828,
341 831,1,0,0,0,829,827,1,0,0,0,829,830,1,0,0,0,830,125,1,0,0,0,831,
342 829,1,0,0,0,832,837,3,128,64,0,833,834,7,3,0,0,834,836,3,128,64,
343 0,835,833,1,0,0,0,836,839,1,0,0,0,837,835,1,0,0,0,837,838,1,0,0,
344 0,838,127,1,0,0,0,839,837,1,0,0,0,840,845,3,130,65,0,841,842,7,4,
345 0,0,842,844,3,130,65,0,843,841,1,0,0,0,844,847,1,0,0,0,845,843,1,
346 0,0,0,845,846,1,0,0,0,846,129,1,0,0,0,847,845,1,0,0,0,848,849,7,
347 5,0,0,849,852,3,130,65,0,850,852,3,132,66,0,851,848,1,0,0,0,851,
348 850,1,0,0,0,852,131,1,0,0,0,853,856,3,134,67,0,854,855,5,57,0,0,
349 855,857,3,130,65,0,856,854,1,0,0,0,856,857,1,0,0,0,857,133,1,0,0,
350 0,858,860,5,38,0,0,859,858,1,0,0,0,859,860,1,0,0,0,860,861,1,0,0,
351 0,861,865,3,136,68,0,862,864,3,140,70,0,863,862,1,0,0,0,864,867,
352 1,0,0,0,865,863,1,0,0,0,865,866,1,0,0,0,866,135,1,0,0,0,867,865,
353 1,0,0,0,868,871,5,52,0,0,869,872,3,168,84,0,870,872,3,138,69,0,871,
354 869,1,0,0,0,871,870,1,0,0,0,871,872,1,0,0,0,872,873,1,0,0,0,873,
355 896,5,53,0,0,874,876,5,59,0,0,875,877,3,138,69,0,876,875,1,0,0,0,
356 876,877,1,0,0,0,877,878,1,0,0,0,878,896,5,60,0,0,879,881,5,72,0,
357 0,880,882,3,152,76,0,881,880,1,0,0,0,881,882,1,0,0,0,882,883,1,0,
358 0,0,883,896,5,73,0,0,884,896,5,40,0,0,885,896,5,2,0,0,886,888,5,
359 1,0,0,887,886,1,0,0,0,888,889,1,0,0,0,889,887,1,0,0,0,889,890,1,
360 0,0,0,890,896,1,0,0,0,891,896,5,50,0,0,892,896,5,28,0,0,893,896,
361 5,29,0,0,894,896,5,30,0,0,895,868,1,0,0,0,895,874,1,0,0,0,895,879,
362 1,0,0,0,895,884,1,0,0,0,895,885,1,0,0,0,895,887,1,0,0,0,895,891,
363 1,0,0,0,895,892,1,0,0,0,895,893,1,0,0,0,895,894,1,0,0,0,896,137,
364 1,0,0,0,897,900,3,98,49,0,898,900,3,116,58,0,899,897,1,0,0,0,899,
365 898,1,0,0,0,900,915,1,0,0,0,901,916,3,162,81,0,902,905,5,54,0,0,
366 903,906,3,98,49,0,904,906,3,116,58,0,905,903,1,0,0,0,905,904,1,0,
367 0,0,906,908,1,0,0,0,907,902,1,0,0,0,908,911,1,0,0,0,909,907,1,0,
368 0,0,909,910,1,0,0,0,910,913,1,0,0,0,911,909,1,0,0,0,912,914,5,54,
369 0,0,913,912,1,0,0,0,913,914,1,0,0,0,914,916,1,0,0,0,915,901,1,0,
370 0,0,915,909,1,0,0,0,916,139,1,0,0,0,917,919,5,52,0,0,918,920,3,156,
371 78,0,919,918,1,0,0,0,919,920,1,0,0,0,920,921,1,0,0,0,921,929,5,53,
372 0,0,922,923,5,59,0,0,923,924,3,142,71,0,924,925,5,60,0,0,925,929,
373 1,0,0,0,926,927,5,49,0,0,927,929,5,40,0,0,928,917,1,0,0,0,928,922,
374 1,0,0,0,928,926,1,0,0,0,929,141,1,0,0,0,930,935,3,144,72,0,931,932,
375 5,54,0,0,932,934,3,144,72,0,933,931,1,0,0,0,934,937,1,0,0,0,935,
376 933,1,0,0,0,935,936,1,0,0,0,936,939,1,0,0,0,937,935,1,0,0,0,938,
377 940,5,54,0,0,939,938,1,0,0,0,939,940,1,0,0,0,940,143,1,0,0,0,941,
378 953,3,98,49,0,942,944,3,98,49,0,943,942,1,0,0,0,943,944,1,0,0,0,
379 944,945,1,0,0,0,945,947,5,55,0,0,946,948,3,98,49,0,947,946,1,0,0,
380 0,947,948,1,0,0,0,948,950,1,0,0,0,949,951,3,146,73,0,950,949,1,0,
381 0,0,950,951,1,0,0,0,951,953,1,0,0,0,952,941,1,0,0,0,952,943,1,0,
382 0,0,953,145,1,0,0,0,954,956,5,55,0,0,955,957,3,98,49,0,956,955,1,
383 0,0,0,956,957,1,0,0,0,957,147,1,0,0,0,958,961,3,118,59,0,959,961,
384 3,116,58,0,960,958,1,0,0,0,960,959,1,0,0,0,961,969,1,0,0,0,962,965,
385 5,54,0,0,963,966,3,118,59,0,964,966,3,116,58,0,965,963,1,0,0,0,965,
386 964,1,0,0,0,966,968,1,0,0,0,967,962,1,0,0,0,968,971,1,0,0,0,969,
387 967,1,0,0,0,969,970,1,0,0,0,970,973,1,0,0,0,971,969,1,0,0,0,972,
388 974,5,54,0,0,973,972,1,0,0,0,973,974,1,0,0,0,974,149,1,0,0,0,975,
389 980,3,98,49,0,976,977,5,54,0,0,977,979,3,98,49,0,978,976,1,0,0,0,
390 979,982,1,0,0,0,980,978,1,0,0,0,980,981,1,0,0,0,981,984,1,0,0,0,
391 982,980,1,0,0,0,983,985,5,54,0,0,984,983,1,0,0,0,984,985,1,0,0,0,
392 985,151,1,0,0,0,986,987,3,98,49,0,987,988,5,55,0,0,988,989,3,98,
393 49,0,989,993,1,0,0,0,990,991,5,57,0,0,991,993,3,118,59,0,992,986,
394 1,0,0,0,992,990,1,0,0,0,993,1012,1,0,0,0,994,1013,3,162,81,0,995,
395 1002,5,54,0,0,996,997,3,98,49,0,997,998,5,55,0,0,998,999,3,98,49,
396 0,999,1003,1,0,0,0,1000,1001,5,57,0,0,1001,1003,3,118,59,0,1002,
397 996,1,0,0,0,1002,1000,1,0,0,0,1003,1005,1,0,0,0,1004,995,1,0,0,0,
398 1005,1008,1,0,0,0,1006,1004,1,0,0,0,1006,1007,1,0,0,0,1007,1010,
399 1,0,0,0,1008,1006,1,0,0,0,1009,1011,5,54,0,0,1010,1009,1,0,0,0,1010,
400 1011,1,0,0,0,1011,1013,1,0,0,0,1012,994,1,0,0,0,1012,1006,1,0,0,
401 0,1013,1035,1,0,0,0,1014,1017,3,98,49,0,1015,1017,3,116,58,0,1016,
402 1014,1,0,0,0,1016,1015,1,0,0,0,1017,1032,1,0,0,0,1018,1033,3,162,
403 81,0,1019,1022,5,54,0,0,1020,1023,3,98,49,0,1021,1023,3,116,58,0,
404 1022,1020,1,0,0,0,1022,1021,1,0,0,0,1023,1025,1,0,0,0,1024,1019,
405 1,0,0,0,1025,1028,1,0,0,0,1026,1024,1,0,0,0,1026,1027,1,0,0,0,1027,
406 1030,1,0,0,0,1028,1026,1,0,0,0,1029,1031,5,54,0,0,1030,1029,1,0,
407 0,0,1030,1031,1,0,0,0,1031,1033,1,0,0,0,1032,1018,1,0,0,0,1032,1026,
408 1,0,0,0,1033,1035,1,0,0,0,1034,992,1,0,0,0,1034,1016,1,0,0,0,1035,
409 153,1,0,0,0,1036,1037,5,31,0,0,1037,1043,5,40,0,0,1038,1040,5,52,
410 0,0,1039,1041,3,156,78,0,1040,1039,1,0,0,0,1040,1041,1,0,0,0,1041,
411 1042,1,0,0,0,1042,1044,5,53,0,0,1043,1038,1,0,0,0,1043,1044,1,0,
412 0,0,1044,1045,1,0,0,0,1045,1046,5,55,0,0,1046,1047,3,96,48,0,1047,
413 155,1,0,0,0,1048,1053,3,158,79,0,1049,1050,5,54,0,0,1050,1052,3,
414 158,79,0,1051,1049,1,0,0,0,1052,1055,1,0,0,0,1053,1051,1,0,0,0,1053,
415 1054,1,0,0,0,1054,1057,1,0,0,0,1055,1053,1,0,0,0,1056,1058,5,54,
416 0,0,1057,1056,1,0,0,0,1057,1058,1,0,0,0,1058,157,1,0,0,0,1059,1061,
417 3,98,49,0,1060,1062,3,162,81,0,1061,1060,1,0,0,0,1061,1062,1,0,0,
418 0,1062,1072,1,0,0,0,1063,1064,3,98,49,0,1064,1065,5,58,0,0,1065,
419 1066,3,98,49,0,1066,1072,1,0,0,0,1067,1068,5,57,0,0,1068,1072,3,
420 98,49,0,1069,1070,5,51,0,0,1070,1072,3,98,49,0,1071,1059,1,0,0,0,
421 1071,1063,1,0,0,0,1071,1067,1,0,0,0,1071,1069,1,0,0,0,1072,159,1,
422 0,0,0,1073,1076,3,162,81,0,1074,1076,3,164,82,0,1075,1073,1,0,0,
423 0,1075,1074,1,0,0,0,1076,161,1,0,0,0,1077,1079,5,37,0,0,1078,1077,
424 1,0,0,0,1078,1079,1,0,0,0,1079,1080,1,0,0,0,1080,1081,5,17,0,0,1081,
425 1082,3,148,74,0,1082,1083,5,18,0,0,1083,1085,3,106,53,0,1084,1086,
426 3,160,80,0,1085,1084,1,0,0,0,1085,1086,1,0,0,0,1086,163,1,0,0,0,
427 1087,1088,5,13,0,0,1088,1090,3,100,50,0,1089,1091,3,160,80,0,1090,
428 1089,1,0,0,0,1090,1091,1,0,0,0,1091,165,1,0,0,0,1092,1093,5,40,0,
429 0,1093,167,1,0,0,0,1094,1096,5,32,0,0,1095,1097,3,170,85,0,1096,
430 1095,1,0,0,0,1096,1097,1,0,0,0,1097,169,1,0,0,0,1098,1099,5,7,0,
431 0,1099,1102,3,98,49,0,1100,1102,3,150,75,0,1101,1098,1,0,0,0,1101,
432 1100,1,0,0,0,1102,171,1,0,0,0,166,177,181,183,192,201,204,211,217,
433 227,234,241,247,251,257,263,267,274,276,278,283,285,287,291,297,
434 301,308,310,312,317,319,324,329,335,339,345,351,355,362,364,366,
435 371,373,375,379,385,389,396,398,400,405,407,413,420,424,436,443,
436 448,452,455,461,465,470,474,478,492,500,508,510,514,523,530,532,
437 541,546,551,558,562,569,577,586,595,602,613,619,632,638,647,658,
438 669,674,679,684,692,701,707,709,717,721,729,732,736,740,747,757,
439 765,771,779,795,805,813,821,829,837,845,851,856,859,865,871,876,
440 881,889,895,899,905,909,913,915,919,928,935,939,943,947,950,952,
441 956,960,965,969,973,980,984,992,1002,1006,1010,1012,1016,1022,1026,
442 1030,1032,1034,1040,1043,1053,1057,1061,1071,1075,1078,1085,1090,
443 1096,1101
444 ]
446class Python3Parser ( Parser ):
448 grammarFileName = "Python3.g4"
450 atn = ATNDeserializer().deserialize(serializedATN())
452 decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
454 sharedContextCache = PredictionContextCache()
456 literalNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
457 "'def'", "'return'", "'raise'", "'from'", "'import'",
458 "'as'", "'global'", "'nonlocal'", "'assert'", "'if'",
459 "'elif'", "'else'", "'while'", "'for'", "'in'", "'try'",
460 "'finally'", "'with'", "'except'", "'lambda'", "'or'",
461 "'and'", "'not'", "'is'", "'None'", "'True'", "'False'",
462 "'class'", "'yield'", "'del'", "'pass'", "'continue'",
463 "'break'", "'async'", "'await'", "<INVALID>", "<INVALID>",
464 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
465 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
466 "'.'", "'...'", "'*'", "'('", "')'", "','", "':'",
467 "';'", "'**'", "'='", "'['", "']'", "'|'", "'^'", "'&'",
468 "'<<'", "'>>'", "'+'", "'-'", "'/'", "'%'", "'//'",
469 "'~'", "'{'", "'}'", "'<'", "'>'", "'=='", "'>='",
470 "'<='", "'<>'", "'!='", "'@'", "'->'", "'+='", "'-='",
471 "'*='", "'@='", "'/='", "'%='", "'&='", "'|='", "'^='",
472 "'<<='", "'>>='", "'**='", "'//='" ]
474 symbolicNames = [ "<INVALID>", "STRING", "NUMBER", "INTEGER", "DEF",
475 "RETURN", "RAISE", "FROM", "IMPORT", "AS", "GLOBAL",
476 "NONLOCAL", "ASSERT", "IF", "ELIF", "ELSE", "WHILE",
477 "FOR", "IN", "TRY", "FINALLY", "WITH", "EXCEPT", "LAMBDA",
478 "OR", "AND", "NOT", "IS", "NONE", "TRUE", "FALSE",
479 "CLASS", "YIELD", "DEL", "PASS", "CONTINUE", "BREAK",
480 "ASYNC", "AWAIT", "NEWLINE", "NAME", "STRING_LITERAL",
481 "BYTES_LITERAL", "DECIMAL_INTEGER", "OCT_INTEGER",
482 "HEX_INTEGER", "BIN_INTEGER", "FLOAT_NUMBER", "IMAG_NUMBER",
483 "DOT", "ELLIPSIS", "STAR", "OPEN_PAREN", "CLOSE_PAREN",
484 "COMMA", "COLON", "SEMI_COLON", "POWER", "ASSIGN",
485 "OPEN_BRACK", "CLOSE_BRACK", "OR_OP", "XOR", "AND_OP",
486 "LEFT_SHIFT", "RIGHT_SHIFT", "ADD", "MINUS", "DIV",
487 "MOD", "IDIV", "NOT_OP", "OPEN_BRACE", "CLOSE_BRACE",
488 "LESS_THAN", "GREATER_THAN", "EQUALS", "GT_EQ", "LT_EQ",
489 "NOT_EQ_1", "NOT_EQ_2", "AT", "ARROW", "ADD_ASSIGN",
490 "SUB_ASSIGN", "MULT_ASSIGN", "AT_ASSIGN", "DIV_ASSIGN",
491 "MOD_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN",
492 "LEFT_SHIFT_ASSIGN", "RIGHT_SHIFT_ASSIGN", "POWER_ASSIGN",
493 "IDIV_ASSIGN", "SKIP_", "UNKNOWN_CHAR", "INDENT",
494 "DEDENT" ]
496 RULE_single_input = 0
497 RULE_file_input = 1
498 RULE_eval_input = 2
499 RULE_decorator = 3
500 RULE_decorators = 4
501 RULE_decorated = 5
502 RULE_async_funcdef = 6
503 RULE_funcdef = 7
504 RULE_parameters = 8
505 RULE_typedargslist = 9
506 RULE_tfpdef = 10
507 RULE_varargslist = 11
508 RULE_vfpdef = 12
509 RULE_stmt = 13
510 RULE_simple_stmt = 14
511 RULE_small_stmt = 15
512 RULE_expr_stmt = 16
513 RULE_annassign = 17
514 RULE_testlist_star_expr = 18
515 RULE_augassign = 19
516 RULE_del_stmt = 20
517 RULE_pass_stmt = 21
518 RULE_flow_stmt = 22
519 RULE_break_stmt = 23
520 RULE_continue_stmt = 24
521 RULE_return_stmt = 25
522 RULE_yield_stmt = 26
523 RULE_raise_stmt = 27
524 RULE_import_stmt = 28
525 RULE_import_name = 29
526 RULE_import_from = 30
527 RULE_import_as_name = 31
528 RULE_dotted_as_name = 32
529 RULE_import_as_names = 33
530 RULE_dotted_as_names = 34
531 RULE_dotted_name = 35
532 RULE_global_stmt = 36
533 RULE_nonlocal_stmt = 37
534 RULE_assert_stmt = 38
535 RULE_compound_stmt = 39
536 RULE_async_stmt = 40
537 RULE_if_stmt = 41
538 RULE_while_stmt = 42
539 RULE_for_stmt = 43
540 RULE_try_stmt = 44
541 RULE_with_stmt = 45
542 RULE_with_item = 46
543 RULE_except_clause = 47
544 RULE_suite = 48
545 RULE_test = 49
546 RULE_test_nocond = 50
547 RULE_lambdef = 51
548 RULE_lambdef_nocond = 52
549 RULE_or_test = 53
550 RULE_and_test = 54
551 RULE_not_test = 55
552 RULE_comparison = 56
553 RULE_comp_op = 57
554 RULE_star_expr = 58
555 RULE_expr = 59
556 RULE_xor_expr = 60
557 RULE_and_expr = 61
558 RULE_shift_expr = 62
559 RULE_arith_expr = 63
560 RULE_term = 64
561 RULE_factor = 65
562 RULE_power = 66
563 RULE_atom_expr = 67
564 RULE_atom = 68
565 RULE_testlist_comp = 69
566 RULE_trailer = 70
567 RULE_subscriptlist = 71
568 RULE_subscript = 72
569 RULE_sliceop = 73
570 RULE_exprlist = 74
571 RULE_testlist = 75
572 RULE_dictorsetmaker = 76
573 RULE_classdef = 77
574 RULE_arglist = 78
575 RULE_argument = 79
576 RULE_comp_iter = 80
577 RULE_comp_for = 81
578 RULE_comp_if = 82
579 RULE_encoding_decl = 83
580 RULE_yield_expr = 84
581 RULE_yield_arg = 85
583 ruleNames = [ "single_input", "file_input", "eval_input", "decorator",
584 "decorators", "decorated", "async_funcdef", "funcdef",
585 "parameters", "typedargslist", "tfpdef", "varargslist",
586 "vfpdef", "stmt", "simple_stmt", "small_stmt", "expr_stmt",
587 "annassign", "testlist_star_expr", "augassign", "del_stmt",
588 "pass_stmt", "flow_stmt", "break_stmt", "continue_stmt",
589 "return_stmt", "yield_stmt", "raise_stmt", "import_stmt",
590 "import_name", "import_from", "import_as_name", "dotted_as_name",
591 "import_as_names", "dotted_as_names", "dotted_name",
592 "global_stmt", "nonlocal_stmt", "assert_stmt", "compound_stmt",
593 "async_stmt", "if_stmt", "while_stmt", "for_stmt", "try_stmt",
594 "with_stmt", "with_item", "except_clause", "suite", "test",
595 "test_nocond", "lambdef", "lambdef_nocond", "or_test",
596 "and_test", "not_test", "comparison", "comp_op", "star_expr",
597 "expr", "xor_expr", "and_expr", "shift_expr", "arith_expr",
598 "term", "factor", "power", "atom_expr", "atom", "testlist_comp",
599 "trailer", "subscriptlist", "subscript", "sliceop", "exprlist",
600 "testlist", "dictorsetmaker", "classdef", "arglist",
601 "argument", "comp_iter", "comp_for", "comp_if", "encoding_decl",
602 "yield_expr", "yield_arg" ]
604 EOF = Token.EOF
605 STRING=1
606 NUMBER=2
607 INTEGER=3
608 DEF=4
609 RETURN=5
610 RAISE=6
611 FROM=7
612 IMPORT=8
613 AS=9
614 GLOBAL=10
615 NONLOCAL=11
616 ASSERT=12
617 IF=13
618 ELIF=14
619 ELSE=15
620 WHILE=16
621 FOR=17
622 IN=18
623 TRY=19
624 FINALLY=20
625 WITH=21
626 EXCEPT=22
627 LAMBDA=23
628 OR=24
629 AND=25
630 NOT=26
631 IS=27
632 NONE=28
633 TRUE=29
634 FALSE=30
635 CLASS=31
636 YIELD=32
637 DEL=33
638 PASS=34
639 CONTINUE=35
640 BREAK=36
641 ASYNC=37
642 AWAIT=38
643 NEWLINE=39
644 NAME=40
645 STRING_LITERAL=41
646 BYTES_LITERAL=42
647 DECIMAL_INTEGER=43
648 OCT_INTEGER=44
649 HEX_INTEGER=45
650 BIN_INTEGER=46
651 FLOAT_NUMBER=47
652 IMAG_NUMBER=48
653 DOT=49
654 ELLIPSIS=50
655 STAR=51
656 OPEN_PAREN=52
657 CLOSE_PAREN=53
658 COMMA=54
659 COLON=55
660 SEMI_COLON=56
661 POWER=57
662 ASSIGN=58
663 OPEN_BRACK=59
664 CLOSE_BRACK=60
665 OR_OP=61
666 XOR=62
667 AND_OP=63
668 LEFT_SHIFT=64
669 RIGHT_SHIFT=65
670 ADD=66
671 MINUS=67
672 DIV=68
673 MOD=69
674 IDIV=70
675 NOT_OP=71
676 OPEN_BRACE=72
677 CLOSE_BRACE=73
678 LESS_THAN=74
679 GREATER_THAN=75
680 EQUALS=76
681 GT_EQ=77
682 LT_EQ=78
683 NOT_EQ_1=79
684 NOT_EQ_2=80
685 AT=81
686 ARROW=82
687 ADD_ASSIGN=83
688 SUB_ASSIGN=84
689 MULT_ASSIGN=85
690 AT_ASSIGN=86
691 DIV_ASSIGN=87
692 MOD_ASSIGN=88
693 AND_ASSIGN=89
694 OR_ASSIGN=90
695 XOR_ASSIGN=91
696 LEFT_SHIFT_ASSIGN=92
697 RIGHT_SHIFT_ASSIGN=93
698 POWER_ASSIGN=94
699 IDIV_ASSIGN=95
700 SKIP_=96
701 UNKNOWN_CHAR=97
702 INDENT=98
703 DEDENT=99
705 def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
706 super().__init__(input, output)
707 self.checkVersion("4.10.1")
708 self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
709 self._predicates = None
714 class Single_inputContext(ParserRuleContext):
715 __slots__ = 'parser'
717 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
718 super().__init__(parent, invokingState)
719 self.parser = parser
721 def NEWLINE(self):
722 return self.getToken(Python3Parser.NEWLINE, 0)
724 def simple_stmt(self):
725 return self.getTypedRuleContext(Python3Parser.Simple_stmtContext,0)
728 def compound_stmt(self):
729 return self.getTypedRuleContext(Python3Parser.Compound_stmtContext,0)
732 def getRuleIndex(self):
733 return Python3Parser.RULE_single_input
735 def enterRule(self, listener:ParseTreeListener):
736 if hasattr( listener, "enterSingle_input" ):
737 listener.enterSingle_input(self)
739 def exitRule(self, listener:ParseTreeListener):
740 if hasattr( listener, "exitSingle_input" ):
741 listener.exitSingle_input(self)
746 def single_input(self):
748 localctx = Python3Parser.Single_inputContext(self, self._ctx, self.state)
749 self.enterRule(localctx, 0, self.RULE_single_input)
750 try:
751 self.state = 177
752 self._errHandler.sync(self)
753 token = self._input.LA(1)
754 if token in [Python3Parser.NEWLINE]:
755 self.enterOuterAlt(localctx, 1)
756 self.state = 172
757 self.match(Python3Parser.NEWLINE)
758 pass
759 elif token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.RETURN, Python3Parser.RAISE, Python3Parser.FROM, Python3Parser.IMPORT, Python3Parser.GLOBAL, Python3Parser.NONLOCAL, Python3Parser.ASSERT, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.YIELD, Python3Parser.DEL, Python3Parser.PASS, Python3Parser.CONTINUE, Python3Parser.BREAK, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.STAR, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]:
760 self.enterOuterAlt(localctx, 2)
761 self.state = 173
762 self.simple_stmt()
763 pass
764 elif token in [Python3Parser.DEF, Python3Parser.IF, Python3Parser.WHILE, Python3Parser.FOR, Python3Parser.TRY, Python3Parser.WITH, Python3Parser.CLASS, Python3Parser.ASYNC, Python3Parser.AT]:
765 self.enterOuterAlt(localctx, 3)
766 self.state = 174
767 self.compound_stmt()
768 self.state = 175
769 self.match(Python3Parser.NEWLINE)
770 pass
771 else:
772 raise NoViableAltException(self)
774 except RecognitionException as re:
775 localctx.exception = re
776 self._errHandler.reportError(self, re)
777 self._errHandler.recover(self, re)
778 finally:
779 self.exitRule()
780 return localctx
783 class File_inputContext(ParserRuleContext):
784 __slots__ = 'parser'
786 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
787 super().__init__(parent, invokingState)
788 self.parser = parser
790 def EOF(self):
791 return self.getToken(Python3Parser.EOF, 0)
793 def NEWLINE(self, i:int=None):
794 if i is None:
795 return self.getTokens(Python3Parser.NEWLINE)
796 else:
797 return self.getToken(Python3Parser.NEWLINE, i)
799 def stmt(self, i:int=None):
800 if i is None:
801 return self.getTypedRuleContexts(Python3Parser.StmtContext)
802 else:
803 return self.getTypedRuleContext(Python3Parser.StmtContext,i)
806 def getRuleIndex(self):
807 return Python3Parser.RULE_file_input
809 def enterRule(self, listener:ParseTreeListener):
810 if hasattr( listener, "enterFile_input" ):
811 listener.enterFile_input(self)
813 def exitRule(self, listener:ParseTreeListener):
814 if hasattr( listener, "exitFile_input" ):
815 listener.exitFile_input(self)
820 def file_input(self):
822 localctx = Python3Parser.File_inputContext(self, self._ctx, self.state)
823 self.enterRule(localctx, 2, self.RULE_file_input)
824 self._la = 0 # Token type
825 try:
826 self.enterOuterAlt(localctx, 1)
827 self.state = 183
828 self._errHandler.sync(self)
829 _la = self._input.LA(1)
830 while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.DEF) | (1 << Python3Parser.RETURN) | (1 << Python3Parser.RAISE) | (1 << Python3Parser.FROM) | (1 << Python3Parser.IMPORT) | (1 << Python3Parser.GLOBAL) | (1 << Python3Parser.NONLOCAL) | (1 << Python3Parser.ASSERT) | (1 << Python3Parser.IF) | (1 << Python3Parser.WHILE) | (1 << Python3Parser.FOR) | (1 << Python3Parser.TRY) | (1 << Python3Parser.WITH) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.CLASS) | (1 << Python3Parser.YIELD) | (1 << Python3Parser.DEL) | (1 << Python3Parser.PASS) | (1 << Python3Parser.CONTINUE) | (1 << Python3Parser.BREAK) | (1 << Python3Parser.ASYNC) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NEWLINE) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.STAR) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)) | (1 << (Python3Parser.AT - 66)))) != 0):
831 self.state = 181
832 self._errHandler.sync(self)
833 token = self._input.LA(1)
834 if token in [Python3Parser.NEWLINE]:
835 self.state = 179
836 self.match(Python3Parser.NEWLINE)
837 pass
838 elif token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.DEF, Python3Parser.RETURN, Python3Parser.RAISE, Python3Parser.FROM, Python3Parser.IMPORT, Python3Parser.GLOBAL, Python3Parser.NONLOCAL, Python3Parser.ASSERT, Python3Parser.IF, Python3Parser.WHILE, Python3Parser.FOR, Python3Parser.TRY, Python3Parser.WITH, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.CLASS, Python3Parser.YIELD, Python3Parser.DEL, Python3Parser.PASS, Python3Parser.CONTINUE, Python3Parser.BREAK, Python3Parser.ASYNC, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.STAR, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE, Python3Parser.AT]:
839 self.state = 180
840 self.stmt()
841 pass
842 else:
843 raise NoViableAltException(self)
845 self.state = 185
846 self._errHandler.sync(self)
847 _la = self._input.LA(1)
849 self.state = 186
850 self.match(Python3Parser.EOF)
851 except RecognitionException as re:
852 localctx.exception = re
853 self._errHandler.reportError(self, re)
854 self._errHandler.recover(self, re)
855 finally:
856 self.exitRule()
857 return localctx
860 class Eval_inputContext(ParserRuleContext):
861 __slots__ = 'parser'
863 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
864 super().__init__(parent, invokingState)
865 self.parser = parser
867 def testlist(self):
868 return self.getTypedRuleContext(Python3Parser.TestlistContext,0)
871 def EOF(self):
872 return self.getToken(Python3Parser.EOF, 0)
874 def NEWLINE(self, i:int=None):
875 if i is None:
876 return self.getTokens(Python3Parser.NEWLINE)
877 else:
878 return self.getToken(Python3Parser.NEWLINE, i)
880 def getRuleIndex(self):
881 return Python3Parser.RULE_eval_input
883 def enterRule(self, listener:ParseTreeListener):
884 if hasattr( listener, "enterEval_input" ):
885 listener.enterEval_input(self)
887 def exitRule(self, listener:ParseTreeListener):
888 if hasattr( listener, "exitEval_input" ):
889 listener.exitEval_input(self)
894 def eval_input(self):
896 localctx = Python3Parser.Eval_inputContext(self, self._ctx, self.state)
897 self.enterRule(localctx, 4, self.RULE_eval_input)
898 self._la = 0 # Token type
899 try:
900 self.enterOuterAlt(localctx, 1)
901 self.state = 188
902 self.testlist()
903 self.state = 192
904 self._errHandler.sync(self)
905 _la = self._input.LA(1)
906 while _la==Python3Parser.NEWLINE:
907 self.state = 189
908 self.match(Python3Parser.NEWLINE)
909 self.state = 194
910 self._errHandler.sync(self)
911 _la = self._input.LA(1)
913 self.state = 195
914 self.match(Python3Parser.EOF)
915 except RecognitionException as re:
916 localctx.exception = re
917 self._errHandler.reportError(self, re)
918 self._errHandler.recover(self, re)
919 finally:
920 self.exitRule()
921 return localctx
924 class DecoratorContext(ParserRuleContext):
925 __slots__ = 'parser'
927 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
928 super().__init__(parent, invokingState)
929 self.parser = parser
931 def AT(self):
932 return self.getToken(Python3Parser.AT, 0)
934 def dotted_name(self):
935 return self.getTypedRuleContext(Python3Parser.Dotted_nameContext,0)
938 def NEWLINE(self):
939 return self.getToken(Python3Parser.NEWLINE, 0)
941 def OPEN_PAREN(self):
942 return self.getToken(Python3Parser.OPEN_PAREN, 0)
944 def CLOSE_PAREN(self):
945 return self.getToken(Python3Parser.CLOSE_PAREN, 0)
947 def arglist(self):
948 return self.getTypedRuleContext(Python3Parser.ArglistContext,0)
951 def getRuleIndex(self):
952 return Python3Parser.RULE_decorator
954 def enterRule(self, listener:ParseTreeListener):
955 if hasattr( listener, "enterDecorator" ):
956 listener.enterDecorator(self)
958 def exitRule(self, listener:ParseTreeListener):
959 if hasattr( listener, "exitDecorator" ):
960 listener.exitDecorator(self)
965 def decorator(self):
967 localctx = Python3Parser.DecoratorContext(self, self._ctx, self.state)
968 self.enterRule(localctx, 6, self.RULE_decorator)
969 self._la = 0 # Token type
970 try:
971 self.enterOuterAlt(localctx, 1)
972 self.state = 197
973 self.match(Python3Parser.AT)
974 self.state = 198
975 self.dotted_name()
976 self.state = 204
977 self._errHandler.sync(self)
978 _la = self._input.LA(1)
979 if _la==Python3Parser.OPEN_PAREN:
980 self.state = 199
981 self.match(Python3Parser.OPEN_PAREN)
982 self.state = 201
983 self._errHandler.sync(self)
984 _la = self._input.LA(1)
985 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.STAR) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.POWER) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0):
986 self.state = 200
987 self.arglist()
990 self.state = 203
991 self.match(Python3Parser.CLOSE_PAREN)
994 self.state = 206
995 self.match(Python3Parser.NEWLINE)
996 except RecognitionException as re:
997 localctx.exception = re
998 self._errHandler.reportError(self, re)
999 self._errHandler.recover(self, re)
1000 finally:
1001 self.exitRule()
1002 return localctx
1005 class DecoratorsContext(ParserRuleContext):
1006 __slots__ = 'parser'
1008 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1009 super().__init__(parent, invokingState)
1010 self.parser = parser
1012 def decorator(self, i:int=None):
1013 if i is None:
1014 return self.getTypedRuleContexts(Python3Parser.DecoratorContext)
1015 else:
1016 return self.getTypedRuleContext(Python3Parser.DecoratorContext,i)
1019 def getRuleIndex(self):
1020 return Python3Parser.RULE_decorators
1022 def enterRule(self, listener:ParseTreeListener):
1023 if hasattr( listener, "enterDecorators" ):
1024 listener.enterDecorators(self)
1026 def exitRule(self, listener:ParseTreeListener):
1027 if hasattr( listener, "exitDecorators" ):
1028 listener.exitDecorators(self)
1033 def decorators(self):
1035 localctx = Python3Parser.DecoratorsContext(self, self._ctx, self.state)
1036 self.enterRule(localctx, 8, self.RULE_decorators)
1037 self._la = 0 # Token type
1038 try:
1039 self.enterOuterAlt(localctx, 1)
1040 self.state = 209
1041 self._errHandler.sync(self)
1042 _la = self._input.LA(1)
1043 while True:
1044 self.state = 208
1045 self.decorator()
1046 self.state = 211
1047 self._errHandler.sync(self)
1048 _la = self._input.LA(1)
1049 if not (_la==Python3Parser.AT):
1050 break
1052 except RecognitionException as re:
1053 localctx.exception = re
1054 self._errHandler.reportError(self, re)
1055 self._errHandler.recover(self, re)
1056 finally:
1057 self.exitRule()
1058 return localctx
1061 class DecoratedContext(ParserRuleContext):
1062 __slots__ = 'parser'
1064 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1065 super().__init__(parent, invokingState)
1066 self.parser = parser
1068 def decorators(self):
1069 return self.getTypedRuleContext(Python3Parser.DecoratorsContext,0)
1072 def classdef(self):
1073 return self.getTypedRuleContext(Python3Parser.ClassdefContext,0)
1076 def funcdef(self):
1077 return self.getTypedRuleContext(Python3Parser.FuncdefContext,0)
1080 def async_funcdef(self):
1081 return self.getTypedRuleContext(Python3Parser.Async_funcdefContext,0)
1084 def getRuleIndex(self):
1085 return Python3Parser.RULE_decorated
1087 def enterRule(self, listener:ParseTreeListener):
1088 if hasattr( listener, "enterDecorated" ):
1089 listener.enterDecorated(self)
1091 def exitRule(self, listener:ParseTreeListener):
1092 if hasattr( listener, "exitDecorated" ):
1093 listener.exitDecorated(self)
1098 def decorated(self):
1100 localctx = Python3Parser.DecoratedContext(self, self._ctx, self.state)
1101 self.enterRule(localctx, 10, self.RULE_decorated)
1102 try:
1103 self.enterOuterAlt(localctx, 1)
1104 self.state = 213
1105 self.decorators()
1106 self.state = 217
1107 self._errHandler.sync(self)
1108 token = self._input.LA(1)
1109 if token in [Python3Parser.CLASS]:
1110 self.state = 214
1111 self.classdef()
1112 pass
1113 elif token in [Python3Parser.DEF]:
1114 self.state = 215
1115 self.funcdef()
1116 pass
1117 elif token in [Python3Parser.ASYNC]:
1118 self.state = 216
1119 self.async_funcdef()
1120 pass
1121 else:
1122 raise NoViableAltException(self)
1124 except RecognitionException as re:
1125 localctx.exception = re
1126 self._errHandler.reportError(self, re)
1127 self._errHandler.recover(self, re)
1128 finally:
1129 self.exitRule()
1130 return localctx
1133 class Async_funcdefContext(ParserRuleContext):
1134 __slots__ = 'parser'
1136 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1137 super().__init__(parent, invokingState)
1138 self.parser = parser
1140 def ASYNC(self):
1141 return self.getToken(Python3Parser.ASYNC, 0)
1143 def funcdef(self):
1144 return self.getTypedRuleContext(Python3Parser.FuncdefContext,0)
1147 def getRuleIndex(self):
1148 return Python3Parser.RULE_async_funcdef
1150 def enterRule(self, listener:ParseTreeListener):
1151 if hasattr( listener, "enterAsync_funcdef" ):
1152 listener.enterAsync_funcdef(self)
1154 def exitRule(self, listener:ParseTreeListener):
1155 if hasattr( listener, "exitAsync_funcdef" ):
1156 listener.exitAsync_funcdef(self)
1161 def async_funcdef(self):
1163 localctx = Python3Parser.Async_funcdefContext(self, self._ctx, self.state)
1164 self.enterRule(localctx, 12, self.RULE_async_funcdef)
1165 try:
1166 self.enterOuterAlt(localctx, 1)
1167 self.state = 219
1168 self.match(Python3Parser.ASYNC)
1169 self.state = 220
1170 self.funcdef()
1171 except RecognitionException as re:
1172 localctx.exception = re
1173 self._errHandler.reportError(self, re)
1174 self._errHandler.recover(self, re)
1175 finally:
1176 self.exitRule()
1177 return localctx
1180 class FuncdefContext(ParserRuleContext):
1181 __slots__ = 'parser'
1183 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1184 super().__init__(parent, invokingState)
1185 self.parser = parser
1187 def DEF(self):
1188 return self.getToken(Python3Parser.DEF, 0)
1190 def NAME(self):
1191 return self.getToken(Python3Parser.NAME, 0)
1193 def parameters(self):
1194 return self.getTypedRuleContext(Python3Parser.ParametersContext,0)
1197 def COLON(self):
1198 return self.getToken(Python3Parser.COLON, 0)
1200 def suite(self):
1201 return self.getTypedRuleContext(Python3Parser.SuiteContext,0)
1204 def ARROW(self):
1205 return self.getToken(Python3Parser.ARROW, 0)
1207 def test(self):
1208 return self.getTypedRuleContext(Python3Parser.TestContext,0)
1211 def getRuleIndex(self):
1212 return Python3Parser.RULE_funcdef
1214 def enterRule(self, listener:ParseTreeListener):
1215 if hasattr( listener, "enterFuncdef" ):
1216 listener.enterFuncdef(self)
1218 def exitRule(self, listener:ParseTreeListener):
1219 if hasattr( listener, "exitFuncdef" ):
1220 listener.exitFuncdef(self)
1225 def funcdef(self):
1227 localctx = Python3Parser.FuncdefContext(self, self._ctx, self.state)
1228 self.enterRule(localctx, 14, self.RULE_funcdef)
1229 self._la = 0 # Token type
1230 try:
1231 self.enterOuterAlt(localctx, 1)
1232 self.state = 222
1233 self.match(Python3Parser.DEF)
1234 self.state = 223
1235 self.match(Python3Parser.NAME)
1236 self.state = 224
1237 self.parameters()
1238 self.state = 227
1239 self._errHandler.sync(self)
1240 _la = self._input.LA(1)
1241 if _la==Python3Parser.ARROW:
1242 self.state = 225
1243 self.match(Python3Parser.ARROW)
1244 self.state = 226
1245 self.test()
1248 self.state = 229
1249 self.match(Python3Parser.COLON)
1250 self.state = 230
1251 self.suite()
1252 except RecognitionException as re:
1253 localctx.exception = re
1254 self._errHandler.reportError(self, re)
1255 self._errHandler.recover(self, re)
1256 finally:
1257 self.exitRule()
1258 return localctx
1261 class ParametersContext(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 OPEN_PAREN(self):
1269 return self.getToken(Python3Parser.OPEN_PAREN, 0)
1271 def CLOSE_PAREN(self):
1272 return self.getToken(Python3Parser.CLOSE_PAREN, 0)
1274 def typedargslist(self):
1275 return self.getTypedRuleContext(Python3Parser.TypedargslistContext,0)
1278 def getRuleIndex(self):
1279 return Python3Parser.RULE_parameters
1281 def enterRule(self, listener:ParseTreeListener):
1282 if hasattr( listener, "enterParameters" ):
1283 listener.enterParameters(self)
1285 def exitRule(self, listener:ParseTreeListener):
1286 if hasattr( listener, "exitParameters" ):
1287 listener.exitParameters(self)
1292 def parameters(self):
1294 localctx = Python3Parser.ParametersContext(self, self._ctx, self.state)
1295 self.enterRule(localctx, 16, self.RULE_parameters)
1296 self._la = 0 # Token type
1297 try:
1298 self.enterOuterAlt(localctx, 1)
1299 self.state = 232
1300 self.match(Python3Parser.OPEN_PAREN)
1301 self.state = 234
1302 self._errHandler.sync(self)
1303 _la = self._input.LA(1)
1304 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.NAME) | (1 << Python3Parser.STAR) | (1 << Python3Parser.POWER))) != 0):
1305 self.state = 233
1306 self.typedargslist()
1309 self.state = 236
1310 self.match(Python3Parser.CLOSE_PAREN)
1311 except RecognitionException as re:
1312 localctx.exception = re
1313 self._errHandler.reportError(self, re)
1314 self._errHandler.recover(self, re)
1315 finally:
1316 self.exitRule()
1317 return localctx
1320 class TypedargslistContext(ParserRuleContext):
1321 __slots__ = 'parser'
1323 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1324 super().__init__(parent, invokingState)
1325 self.parser = parser
1327 def tfpdef(self, i:int=None):
1328 if i is None:
1329 return self.getTypedRuleContexts(Python3Parser.TfpdefContext)
1330 else:
1331 return self.getTypedRuleContext(Python3Parser.TfpdefContext,i)
1334 def STAR(self):
1335 return self.getToken(Python3Parser.STAR, 0)
1337 def POWER(self):
1338 return self.getToken(Python3Parser.POWER, 0)
1340 def ASSIGN(self, i:int=None):
1341 if i is None:
1342 return self.getTokens(Python3Parser.ASSIGN)
1343 else:
1344 return self.getToken(Python3Parser.ASSIGN, i)
1346 def test(self, i:int=None):
1347 if i is None:
1348 return self.getTypedRuleContexts(Python3Parser.TestContext)
1349 else:
1350 return self.getTypedRuleContext(Python3Parser.TestContext,i)
1353 def COMMA(self, i:int=None):
1354 if i is None:
1355 return self.getTokens(Python3Parser.COMMA)
1356 else:
1357 return self.getToken(Python3Parser.COMMA, i)
1359 def getRuleIndex(self):
1360 return Python3Parser.RULE_typedargslist
1362 def enterRule(self, listener:ParseTreeListener):
1363 if hasattr( listener, "enterTypedargslist" ):
1364 listener.enterTypedargslist(self)
1366 def exitRule(self, listener:ParseTreeListener):
1367 if hasattr( listener, "exitTypedargslist" ):
1368 listener.exitTypedargslist(self)
1373 def typedargslist(self):
1375 localctx = Python3Parser.TypedargslistContext(self, self._ctx, self.state)
1376 self.enterRule(localctx, 18, self.RULE_typedargslist)
1377 self._la = 0 # Token type
1378 try:
1379 self.enterOuterAlt(localctx, 1)
1380 self.state = 319
1381 self._errHandler.sync(self)
1382 token = self._input.LA(1)
1383 if token in [Python3Parser.NAME]:
1384 self.state = 238
1385 self.tfpdef()
1386 self.state = 241
1387 self._errHandler.sync(self)
1388 _la = self._input.LA(1)
1389 if _la==Python3Parser.ASSIGN:
1390 self.state = 239
1391 self.match(Python3Parser.ASSIGN)
1392 self.state = 240
1393 self.test()
1396 self.state = 251
1397 self._errHandler.sync(self)
1398 _alt = self._interp.adaptivePredict(self._input,12,self._ctx)
1399 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
1400 if _alt==1:
1401 self.state = 243
1402 self.match(Python3Parser.COMMA)
1403 self.state = 244
1404 self.tfpdef()
1405 self.state = 247
1406 self._errHandler.sync(self)
1407 _la = self._input.LA(1)
1408 if _la==Python3Parser.ASSIGN:
1409 self.state = 245
1410 self.match(Python3Parser.ASSIGN)
1411 self.state = 246
1412 self.test()
1415 self.state = 253
1416 self._errHandler.sync(self)
1417 _alt = self._interp.adaptivePredict(self._input,12,self._ctx)
1419 self.state = 287
1420 self._errHandler.sync(self)
1421 _la = self._input.LA(1)
1422 if _la==Python3Parser.COMMA:
1423 self.state = 254
1424 self.match(Python3Parser.COMMA)
1425 self.state = 285
1426 self._errHandler.sync(self)
1427 token = self._input.LA(1)
1428 if token in [Python3Parser.STAR]:
1429 self.state = 255
1430 self.match(Python3Parser.STAR)
1431 self.state = 257
1432 self._errHandler.sync(self)
1433 _la = self._input.LA(1)
1434 if _la==Python3Parser.NAME:
1435 self.state = 256
1436 self.tfpdef()
1439 self.state = 267
1440 self._errHandler.sync(self)
1441 _alt = self._interp.adaptivePredict(self._input,15,self._ctx)
1442 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
1443 if _alt==1:
1444 self.state = 259
1445 self.match(Python3Parser.COMMA)
1446 self.state = 260
1447 self.tfpdef()
1448 self.state = 263
1449 self._errHandler.sync(self)
1450 _la = self._input.LA(1)
1451 if _la==Python3Parser.ASSIGN:
1452 self.state = 261
1453 self.match(Python3Parser.ASSIGN)
1454 self.state = 262
1455 self.test()
1458 self.state = 269
1459 self._errHandler.sync(self)
1460 _alt = self._interp.adaptivePredict(self._input,15,self._ctx)
1462 self.state = 278
1463 self._errHandler.sync(self)
1464 _la = self._input.LA(1)
1465 if _la==Python3Parser.COMMA:
1466 self.state = 270
1467 self.match(Python3Parser.COMMA)
1468 self.state = 276
1469 self._errHandler.sync(self)
1470 _la = self._input.LA(1)
1471 if _la==Python3Parser.POWER:
1472 self.state = 271
1473 self.match(Python3Parser.POWER)
1474 self.state = 272
1475 self.tfpdef()
1476 self.state = 274
1477 self._errHandler.sync(self)
1478 _la = self._input.LA(1)
1479 if _la==Python3Parser.COMMA:
1480 self.state = 273
1481 self.match(Python3Parser.COMMA)
1488 pass
1489 elif token in [Python3Parser.POWER]:
1490 self.state = 280
1491 self.match(Python3Parser.POWER)
1492 self.state = 281
1493 self.tfpdef()
1494 self.state = 283
1495 self._errHandler.sync(self)
1496 _la = self._input.LA(1)
1497 if _la==Python3Parser.COMMA:
1498 self.state = 282
1499 self.match(Python3Parser.COMMA)
1502 pass
1503 elif token in [Python3Parser.CLOSE_PAREN]:
1504 pass
1505 else:
1506 pass
1509 pass
1510 elif token in [Python3Parser.STAR]:
1511 self.state = 289
1512 self.match(Python3Parser.STAR)
1513 self.state = 291
1514 self._errHandler.sync(self)
1515 _la = self._input.LA(1)
1516 if _la==Python3Parser.NAME:
1517 self.state = 290
1518 self.tfpdef()
1521 self.state = 301
1522 self._errHandler.sync(self)
1523 _alt = self._interp.adaptivePredict(self._input,24,self._ctx)
1524 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
1525 if _alt==1:
1526 self.state = 293
1527 self.match(Python3Parser.COMMA)
1528 self.state = 294
1529 self.tfpdef()
1530 self.state = 297
1531 self._errHandler.sync(self)
1532 _la = self._input.LA(1)
1533 if _la==Python3Parser.ASSIGN:
1534 self.state = 295
1535 self.match(Python3Parser.ASSIGN)
1536 self.state = 296
1537 self.test()
1540 self.state = 303
1541 self._errHandler.sync(self)
1542 _alt = self._interp.adaptivePredict(self._input,24,self._ctx)
1544 self.state = 312
1545 self._errHandler.sync(self)
1546 _la = self._input.LA(1)
1547 if _la==Python3Parser.COMMA:
1548 self.state = 304
1549 self.match(Python3Parser.COMMA)
1550 self.state = 310
1551 self._errHandler.sync(self)
1552 _la = self._input.LA(1)
1553 if _la==Python3Parser.POWER:
1554 self.state = 305
1555 self.match(Python3Parser.POWER)
1556 self.state = 306
1557 self.tfpdef()
1558 self.state = 308
1559 self._errHandler.sync(self)
1560 _la = self._input.LA(1)
1561 if _la==Python3Parser.COMMA:
1562 self.state = 307
1563 self.match(Python3Parser.COMMA)
1570 pass
1571 elif token in [Python3Parser.POWER]:
1572 self.state = 314
1573 self.match(Python3Parser.POWER)
1574 self.state = 315
1575 self.tfpdef()
1576 self.state = 317
1577 self._errHandler.sync(self)
1578 _la = self._input.LA(1)
1579 if _la==Python3Parser.COMMA:
1580 self.state = 316
1581 self.match(Python3Parser.COMMA)
1584 pass
1585 else:
1586 raise NoViableAltException(self)
1588 except RecognitionException as re:
1589 localctx.exception = re
1590 self._errHandler.reportError(self, re)
1591 self._errHandler.recover(self, re)
1592 finally:
1593 self.exitRule()
1594 return localctx
1597 class TfpdefContext(ParserRuleContext):
1598 __slots__ = 'parser'
1600 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1601 super().__init__(parent, invokingState)
1602 self.parser = parser
1604 def NAME(self):
1605 return self.getToken(Python3Parser.NAME, 0)
1607 def COLON(self):
1608 return self.getToken(Python3Parser.COLON, 0)
1610 def test(self):
1611 return self.getTypedRuleContext(Python3Parser.TestContext,0)
1614 def getRuleIndex(self):
1615 return Python3Parser.RULE_tfpdef
1617 def enterRule(self, listener:ParseTreeListener):
1618 if hasattr( listener, "enterTfpdef" ):
1619 listener.enterTfpdef(self)
1621 def exitRule(self, listener:ParseTreeListener):
1622 if hasattr( listener, "exitTfpdef" ):
1623 listener.exitTfpdef(self)
1628 def tfpdef(self):
1630 localctx = Python3Parser.TfpdefContext(self, self._ctx, self.state)
1631 self.enterRule(localctx, 20, self.RULE_tfpdef)
1632 self._la = 0 # Token type
1633 try:
1634 self.enterOuterAlt(localctx, 1)
1635 self.state = 321
1636 self.match(Python3Parser.NAME)
1637 self.state = 324
1638 self._errHandler.sync(self)
1639 _la = self._input.LA(1)
1640 if _la==Python3Parser.COLON:
1641 self.state = 322
1642 self.match(Python3Parser.COLON)
1643 self.state = 323
1644 self.test()
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
1656 class VarargslistContext(ParserRuleContext):
1657 __slots__ = 'parser'
1659 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1660 super().__init__(parent, invokingState)
1661 self.parser = parser
1663 def vfpdef(self, i:int=None):
1664 if i is None:
1665 return self.getTypedRuleContexts(Python3Parser.VfpdefContext)
1666 else:
1667 return self.getTypedRuleContext(Python3Parser.VfpdefContext,i)
1670 def STAR(self):
1671 return self.getToken(Python3Parser.STAR, 0)
1673 def POWER(self):
1674 return self.getToken(Python3Parser.POWER, 0)
1676 def ASSIGN(self, i:int=None):
1677 if i is None:
1678 return self.getTokens(Python3Parser.ASSIGN)
1679 else:
1680 return self.getToken(Python3Parser.ASSIGN, i)
1682 def test(self, i:int=None):
1683 if i is None:
1684 return self.getTypedRuleContexts(Python3Parser.TestContext)
1685 else:
1686 return self.getTypedRuleContext(Python3Parser.TestContext,i)
1689 def COMMA(self, i:int=None):
1690 if i is None:
1691 return self.getTokens(Python3Parser.COMMA)
1692 else:
1693 return self.getToken(Python3Parser.COMMA, i)
1695 def getRuleIndex(self):
1696 return Python3Parser.RULE_varargslist
1698 def enterRule(self, listener:ParseTreeListener):
1699 if hasattr( listener, "enterVarargslist" ):
1700 listener.enterVarargslist(self)
1702 def exitRule(self, listener:ParseTreeListener):
1703 if hasattr( listener, "exitVarargslist" ):
1704 listener.exitVarargslist(self)
1709 def varargslist(self):
1711 localctx = Python3Parser.VarargslistContext(self, self._ctx, self.state)
1712 self.enterRule(localctx, 22, self.RULE_varargslist)
1713 self._la = 0 # Token type
1714 try:
1715 self.enterOuterAlt(localctx, 1)
1716 self.state = 407
1717 self._errHandler.sync(self)
1718 token = self._input.LA(1)
1719 if token in [Python3Parser.NAME]:
1720 self.state = 326
1721 self.vfpdef()
1722 self.state = 329
1723 self._errHandler.sync(self)
1724 _la = self._input.LA(1)
1725 if _la==Python3Parser.ASSIGN:
1726 self.state = 327
1727 self.match(Python3Parser.ASSIGN)
1728 self.state = 328
1729 self.test()
1732 self.state = 339
1733 self._errHandler.sync(self)
1734 _alt = self._interp.adaptivePredict(self._input,33,self._ctx)
1735 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
1736 if _alt==1:
1737 self.state = 331
1738 self.match(Python3Parser.COMMA)
1739 self.state = 332
1740 self.vfpdef()
1741 self.state = 335
1742 self._errHandler.sync(self)
1743 _la = self._input.LA(1)
1744 if _la==Python3Parser.ASSIGN:
1745 self.state = 333
1746 self.match(Python3Parser.ASSIGN)
1747 self.state = 334
1748 self.test()
1751 self.state = 341
1752 self._errHandler.sync(self)
1753 _alt = self._interp.adaptivePredict(self._input,33,self._ctx)
1755 self.state = 375
1756 self._errHandler.sync(self)
1757 _la = self._input.LA(1)
1758 if _la==Python3Parser.COMMA:
1759 self.state = 342
1760 self.match(Python3Parser.COMMA)
1761 self.state = 373
1762 self._errHandler.sync(self)
1763 token = self._input.LA(1)
1764 if token in [Python3Parser.STAR]:
1765 self.state = 343
1766 self.match(Python3Parser.STAR)
1767 self.state = 345
1768 self._errHandler.sync(self)
1769 _la = self._input.LA(1)
1770 if _la==Python3Parser.NAME:
1771 self.state = 344
1772 self.vfpdef()
1775 self.state = 355
1776 self._errHandler.sync(self)
1777 _alt = self._interp.adaptivePredict(self._input,36,self._ctx)
1778 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
1779 if _alt==1:
1780 self.state = 347
1781 self.match(Python3Parser.COMMA)
1782 self.state = 348
1783 self.vfpdef()
1784 self.state = 351
1785 self._errHandler.sync(self)
1786 _la = self._input.LA(1)
1787 if _la==Python3Parser.ASSIGN:
1788 self.state = 349
1789 self.match(Python3Parser.ASSIGN)
1790 self.state = 350
1791 self.test()
1794 self.state = 357
1795 self._errHandler.sync(self)
1796 _alt = self._interp.adaptivePredict(self._input,36,self._ctx)
1798 self.state = 366
1799 self._errHandler.sync(self)
1800 _la = self._input.LA(1)
1801 if _la==Python3Parser.COMMA:
1802 self.state = 358
1803 self.match(Python3Parser.COMMA)
1804 self.state = 364
1805 self._errHandler.sync(self)
1806 _la = self._input.LA(1)
1807 if _la==Python3Parser.POWER:
1808 self.state = 359
1809 self.match(Python3Parser.POWER)
1810 self.state = 360
1811 self.vfpdef()
1812 self.state = 362
1813 self._errHandler.sync(self)
1814 _la = self._input.LA(1)
1815 if _la==Python3Parser.COMMA:
1816 self.state = 361
1817 self.match(Python3Parser.COMMA)
1824 pass
1825 elif token in [Python3Parser.POWER]:
1826 self.state = 368
1827 self.match(Python3Parser.POWER)
1828 self.state = 369
1829 self.vfpdef()
1830 self.state = 371
1831 self._errHandler.sync(self)
1832 _la = self._input.LA(1)
1833 if _la==Python3Parser.COMMA:
1834 self.state = 370
1835 self.match(Python3Parser.COMMA)
1838 pass
1839 elif token in [Python3Parser.COLON]:
1840 pass
1841 else:
1842 pass
1845 pass
1846 elif token in [Python3Parser.STAR]:
1847 self.state = 377
1848 self.match(Python3Parser.STAR)
1849 self.state = 379
1850 self._errHandler.sync(self)
1851 _la = self._input.LA(1)
1852 if _la==Python3Parser.NAME:
1853 self.state = 378
1854 self.vfpdef()
1857 self.state = 389
1858 self._errHandler.sync(self)
1859 _alt = self._interp.adaptivePredict(self._input,45,self._ctx)
1860 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
1861 if _alt==1:
1862 self.state = 381
1863 self.match(Python3Parser.COMMA)
1864 self.state = 382
1865 self.vfpdef()
1866 self.state = 385
1867 self._errHandler.sync(self)
1868 _la = self._input.LA(1)
1869 if _la==Python3Parser.ASSIGN:
1870 self.state = 383
1871 self.match(Python3Parser.ASSIGN)
1872 self.state = 384
1873 self.test()
1876 self.state = 391
1877 self._errHandler.sync(self)
1878 _alt = self._interp.adaptivePredict(self._input,45,self._ctx)
1880 self.state = 400
1881 self._errHandler.sync(self)
1882 _la = self._input.LA(1)
1883 if _la==Python3Parser.COMMA:
1884 self.state = 392
1885 self.match(Python3Parser.COMMA)
1886 self.state = 398
1887 self._errHandler.sync(self)
1888 _la = self._input.LA(1)
1889 if _la==Python3Parser.POWER:
1890 self.state = 393
1891 self.match(Python3Parser.POWER)
1892 self.state = 394
1893 self.vfpdef()
1894 self.state = 396
1895 self._errHandler.sync(self)
1896 _la = self._input.LA(1)
1897 if _la==Python3Parser.COMMA:
1898 self.state = 395
1899 self.match(Python3Parser.COMMA)
1906 pass
1907 elif token in [Python3Parser.POWER]:
1908 self.state = 402
1909 self.match(Python3Parser.POWER)
1910 self.state = 403
1911 self.vfpdef()
1912 self.state = 405
1913 self._errHandler.sync(self)
1914 _la = self._input.LA(1)
1915 if _la==Python3Parser.COMMA:
1916 self.state = 404
1917 self.match(Python3Parser.COMMA)
1920 pass
1921 else:
1922 raise NoViableAltException(self)
1924 except RecognitionException as re:
1925 localctx.exception = re
1926 self._errHandler.reportError(self, re)
1927 self._errHandler.recover(self, re)
1928 finally:
1929 self.exitRule()
1930 return localctx
1933 class VfpdefContext(ParserRuleContext):
1934 __slots__ = 'parser'
1936 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1937 super().__init__(parent, invokingState)
1938 self.parser = parser
1940 def NAME(self):
1941 return self.getToken(Python3Parser.NAME, 0)
1943 def getRuleIndex(self):
1944 return Python3Parser.RULE_vfpdef
1946 def enterRule(self, listener:ParseTreeListener):
1947 if hasattr( listener, "enterVfpdef" ):
1948 listener.enterVfpdef(self)
1950 def exitRule(self, listener:ParseTreeListener):
1951 if hasattr( listener, "exitVfpdef" ):
1952 listener.exitVfpdef(self)
1957 def vfpdef(self):
1959 localctx = Python3Parser.VfpdefContext(self, self._ctx, self.state)
1960 self.enterRule(localctx, 24, self.RULE_vfpdef)
1961 try:
1962 self.enterOuterAlt(localctx, 1)
1963 self.state = 409
1964 self.match(Python3Parser.NAME)
1965 except RecognitionException as re:
1966 localctx.exception = re
1967 self._errHandler.reportError(self, re)
1968 self._errHandler.recover(self, re)
1969 finally:
1970 self.exitRule()
1971 return localctx
1974 class StmtContext(ParserRuleContext):
1975 __slots__ = 'parser'
1977 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1978 super().__init__(parent, invokingState)
1979 self.parser = parser
1981 def simple_stmt(self):
1982 return self.getTypedRuleContext(Python3Parser.Simple_stmtContext,0)
1985 def compound_stmt(self):
1986 return self.getTypedRuleContext(Python3Parser.Compound_stmtContext,0)
1989 def getRuleIndex(self):
1990 return Python3Parser.RULE_stmt
1992 def enterRule(self, listener:ParseTreeListener):
1993 if hasattr( listener, "enterStmt" ):
1994 listener.enterStmt(self)
1996 def exitRule(self, listener:ParseTreeListener):
1997 if hasattr( listener, "exitStmt" ):
1998 listener.exitStmt(self)
2003 def stmt(self):
2005 localctx = Python3Parser.StmtContext(self, self._ctx, self.state)
2006 self.enterRule(localctx, 26, self.RULE_stmt)
2007 try:
2008 self.state = 413
2009 self._errHandler.sync(self)
2010 token = self._input.LA(1)
2011 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.RETURN, Python3Parser.RAISE, Python3Parser.FROM, Python3Parser.IMPORT, Python3Parser.GLOBAL, Python3Parser.NONLOCAL, Python3Parser.ASSERT, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.YIELD, Python3Parser.DEL, Python3Parser.PASS, Python3Parser.CONTINUE, Python3Parser.BREAK, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.STAR, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]:
2012 self.enterOuterAlt(localctx, 1)
2013 self.state = 411
2014 self.simple_stmt()
2015 pass
2016 elif token in [Python3Parser.DEF, Python3Parser.IF, Python3Parser.WHILE, Python3Parser.FOR, Python3Parser.TRY, Python3Parser.WITH, Python3Parser.CLASS, Python3Parser.ASYNC, Python3Parser.AT]:
2017 self.enterOuterAlt(localctx, 2)
2018 self.state = 412
2019 self.compound_stmt()
2020 pass
2021 else:
2022 raise NoViableAltException(self)
2024 except RecognitionException as re:
2025 localctx.exception = re
2026 self._errHandler.reportError(self, re)
2027 self._errHandler.recover(self, re)
2028 finally:
2029 self.exitRule()
2030 return localctx
2033 class Simple_stmtContext(ParserRuleContext):
2034 __slots__ = 'parser'
2036 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2037 super().__init__(parent, invokingState)
2038 self.parser = parser
2040 def small_stmt(self, i:int=None):
2041 if i is None:
2042 return self.getTypedRuleContexts(Python3Parser.Small_stmtContext)
2043 else:
2044 return self.getTypedRuleContext(Python3Parser.Small_stmtContext,i)
2047 def NEWLINE(self):
2048 return self.getToken(Python3Parser.NEWLINE, 0)
2050 def SEMI_COLON(self, i:int=None):
2051 if i is None:
2052 return self.getTokens(Python3Parser.SEMI_COLON)
2053 else:
2054 return self.getToken(Python3Parser.SEMI_COLON, i)
2056 def getRuleIndex(self):
2057 return Python3Parser.RULE_simple_stmt
2059 def enterRule(self, listener:ParseTreeListener):
2060 if hasattr( listener, "enterSimple_stmt" ):
2061 listener.enterSimple_stmt(self)
2063 def exitRule(self, listener:ParseTreeListener):
2064 if hasattr( listener, "exitSimple_stmt" ):
2065 listener.exitSimple_stmt(self)
2070 def simple_stmt(self):
2072 localctx = Python3Parser.Simple_stmtContext(self, self._ctx, self.state)
2073 self.enterRule(localctx, 28, self.RULE_simple_stmt)
2074 self._la = 0 # Token type
2075 try:
2076 self.enterOuterAlt(localctx, 1)
2077 self.state = 415
2078 self.small_stmt()
2079 self.state = 420
2080 self._errHandler.sync(self)
2081 _alt = self._interp.adaptivePredict(self._input,52,self._ctx)
2082 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
2083 if _alt==1:
2084 self.state = 416
2085 self.match(Python3Parser.SEMI_COLON)
2086 self.state = 417
2087 self.small_stmt()
2088 self.state = 422
2089 self._errHandler.sync(self)
2090 _alt = self._interp.adaptivePredict(self._input,52,self._ctx)
2092 self.state = 424
2093 self._errHandler.sync(self)
2094 _la = self._input.LA(1)
2095 if _la==Python3Parser.SEMI_COLON:
2096 self.state = 423
2097 self.match(Python3Parser.SEMI_COLON)
2100 self.state = 426
2101 self.match(Python3Parser.NEWLINE)
2102 except RecognitionException as re:
2103 localctx.exception = re
2104 self._errHandler.reportError(self, re)
2105 self._errHandler.recover(self, re)
2106 finally:
2107 self.exitRule()
2108 return localctx
2111 class Small_stmtContext(ParserRuleContext):
2112 __slots__ = 'parser'
2114 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2115 super().__init__(parent, invokingState)
2116 self.parser = parser
2118 def expr_stmt(self):
2119 return self.getTypedRuleContext(Python3Parser.Expr_stmtContext,0)
2122 def del_stmt(self):
2123 return self.getTypedRuleContext(Python3Parser.Del_stmtContext,0)
2126 def pass_stmt(self):
2127 return self.getTypedRuleContext(Python3Parser.Pass_stmtContext,0)
2130 def flow_stmt(self):
2131 return self.getTypedRuleContext(Python3Parser.Flow_stmtContext,0)
2134 def import_stmt(self):
2135 return self.getTypedRuleContext(Python3Parser.Import_stmtContext,0)
2138 def global_stmt(self):
2139 return self.getTypedRuleContext(Python3Parser.Global_stmtContext,0)
2142 def nonlocal_stmt(self):
2143 return self.getTypedRuleContext(Python3Parser.Nonlocal_stmtContext,0)
2146 def assert_stmt(self):
2147 return self.getTypedRuleContext(Python3Parser.Assert_stmtContext,0)
2150 def getRuleIndex(self):
2151 return Python3Parser.RULE_small_stmt
2153 def enterRule(self, listener:ParseTreeListener):
2154 if hasattr( listener, "enterSmall_stmt" ):
2155 listener.enterSmall_stmt(self)
2157 def exitRule(self, listener:ParseTreeListener):
2158 if hasattr( listener, "exitSmall_stmt" ):
2159 listener.exitSmall_stmt(self)
2164 def small_stmt(self):
2166 localctx = Python3Parser.Small_stmtContext(self, self._ctx, self.state)
2167 self.enterRule(localctx, 30, self.RULE_small_stmt)
2168 try:
2169 self.enterOuterAlt(localctx, 1)
2170 self.state = 436
2171 self._errHandler.sync(self)
2172 token = self._input.LA(1)
2173 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.STAR, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]:
2174 self.state = 428
2175 self.expr_stmt()
2176 pass
2177 elif token in [Python3Parser.DEL]:
2178 self.state = 429
2179 self.del_stmt()
2180 pass
2181 elif token in [Python3Parser.PASS]:
2182 self.state = 430
2183 self.pass_stmt()
2184 pass
2185 elif token in [Python3Parser.RETURN, Python3Parser.RAISE, Python3Parser.YIELD, Python3Parser.CONTINUE, Python3Parser.BREAK]:
2186 self.state = 431
2187 self.flow_stmt()
2188 pass
2189 elif token in [Python3Parser.FROM, Python3Parser.IMPORT]:
2190 self.state = 432
2191 self.import_stmt()
2192 pass
2193 elif token in [Python3Parser.GLOBAL]:
2194 self.state = 433
2195 self.global_stmt()
2196 pass
2197 elif token in [Python3Parser.NONLOCAL]:
2198 self.state = 434
2199 self.nonlocal_stmt()
2200 pass
2201 elif token in [Python3Parser.ASSERT]:
2202 self.state = 435
2203 self.assert_stmt()
2204 pass
2205 else:
2206 raise NoViableAltException(self)
2208 except RecognitionException as re:
2209 localctx.exception = re
2210 self._errHandler.reportError(self, re)
2211 self._errHandler.recover(self, re)
2212 finally:
2213 self.exitRule()
2214 return localctx
2217 class Expr_stmtContext(ParserRuleContext):
2218 __slots__ = 'parser'
2220 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2221 super().__init__(parent, invokingState)
2222 self.parser = parser
2224 def testlist_star_expr(self, i:int=None):
2225 if i is None:
2226 return self.getTypedRuleContexts(Python3Parser.Testlist_star_exprContext)
2227 else:
2228 return self.getTypedRuleContext(Python3Parser.Testlist_star_exprContext,i)
2231 def annassign(self):
2232 return self.getTypedRuleContext(Python3Parser.AnnassignContext,0)
2235 def augassign(self):
2236 return self.getTypedRuleContext(Python3Parser.AugassignContext,0)
2239 def yield_expr(self, i:int=None):
2240 if i is None:
2241 return self.getTypedRuleContexts(Python3Parser.Yield_exprContext)
2242 else:
2243 return self.getTypedRuleContext(Python3Parser.Yield_exprContext,i)
2246 def testlist(self):
2247 return self.getTypedRuleContext(Python3Parser.TestlistContext,0)
2250 def ASSIGN(self, i:int=None):
2251 if i is None:
2252 return self.getTokens(Python3Parser.ASSIGN)
2253 else:
2254 return self.getToken(Python3Parser.ASSIGN, i)
2256 def getRuleIndex(self):
2257 return Python3Parser.RULE_expr_stmt
2259 def enterRule(self, listener:ParseTreeListener):
2260 if hasattr( listener, "enterExpr_stmt" ):
2261 listener.enterExpr_stmt(self)
2263 def exitRule(self, listener:ParseTreeListener):
2264 if hasattr( listener, "exitExpr_stmt" ):
2265 listener.exitExpr_stmt(self)
2270 def expr_stmt(self):
2272 localctx = Python3Parser.Expr_stmtContext(self, self._ctx, self.state)
2273 self.enterRule(localctx, 32, self.RULE_expr_stmt)
2274 self._la = 0 # Token type
2275 try:
2276 self.enterOuterAlt(localctx, 1)
2277 self.state = 438
2278 self.testlist_star_expr()
2279 self.state = 455
2280 self._errHandler.sync(self)
2281 token = self._input.LA(1)
2282 if token in [Python3Parser.COLON]:
2283 self.state = 439
2284 self.annassign()
2285 pass
2286 elif token in [Python3Parser.ADD_ASSIGN, Python3Parser.SUB_ASSIGN, Python3Parser.MULT_ASSIGN, Python3Parser.AT_ASSIGN, Python3Parser.DIV_ASSIGN, Python3Parser.MOD_ASSIGN, Python3Parser.AND_ASSIGN, Python3Parser.OR_ASSIGN, Python3Parser.XOR_ASSIGN, Python3Parser.LEFT_SHIFT_ASSIGN, Python3Parser.RIGHT_SHIFT_ASSIGN, Python3Parser.POWER_ASSIGN, Python3Parser.IDIV_ASSIGN]:
2287 self.state = 440
2288 self.augassign()
2289 self.state = 443
2290 self._errHandler.sync(self)
2291 token = self._input.LA(1)
2292 if token in [Python3Parser.YIELD]:
2293 self.state = 441
2294 self.yield_expr()
2295 pass
2296 elif token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]:
2297 self.state = 442
2298 self.testlist()
2299 pass
2300 else:
2301 raise NoViableAltException(self)
2303 pass
2304 elif token in [Python3Parser.NEWLINE, Python3Parser.SEMI_COLON, Python3Parser.ASSIGN]:
2305 self.state = 452
2306 self._errHandler.sync(self)
2307 _la = self._input.LA(1)
2308 while _la==Python3Parser.ASSIGN:
2309 self.state = 445
2310 self.match(Python3Parser.ASSIGN)
2311 self.state = 448
2312 self._errHandler.sync(self)
2313 token = self._input.LA(1)
2314 if token in [Python3Parser.YIELD]:
2315 self.state = 446
2316 self.yield_expr()
2317 pass
2318 elif token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.STAR, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]:
2319 self.state = 447
2320 self.testlist_star_expr()
2321 pass
2322 else:
2323 raise NoViableAltException(self)
2325 self.state = 454
2326 self._errHandler.sync(self)
2327 _la = self._input.LA(1)
2329 pass
2330 else:
2331 raise NoViableAltException(self)
2333 except RecognitionException as re:
2334 localctx.exception = re
2335 self._errHandler.reportError(self, re)
2336 self._errHandler.recover(self, re)
2337 finally:
2338 self.exitRule()
2339 return localctx
2342 class AnnassignContext(ParserRuleContext):
2343 __slots__ = 'parser'
2345 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2346 super().__init__(parent, invokingState)
2347 self.parser = parser
2349 def COLON(self):
2350 return self.getToken(Python3Parser.COLON, 0)
2352 def test(self, i:int=None):
2353 if i is None:
2354 return self.getTypedRuleContexts(Python3Parser.TestContext)
2355 else:
2356 return self.getTypedRuleContext(Python3Parser.TestContext,i)
2359 def ASSIGN(self):
2360 return self.getToken(Python3Parser.ASSIGN, 0)
2362 def getRuleIndex(self):
2363 return Python3Parser.RULE_annassign
2365 def enterRule(self, listener:ParseTreeListener):
2366 if hasattr( listener, "enterAnnassign" ):
2367 listener.enterAnnassign(self)
2369 def exitRule(self, listener:ParseTreeListener):
2370 if hasattr( listener, "exitAnnassign" ):
2371 listener.exitAnnassign(self)
2376 def annassign(self):
2378 localctx = Python3Parser.AnnassignContext(self, self._ctx, self.state)
2379 self.enterRule(localctx, 34, self.RULE_annassign)
2380 self._la = 0 # Token type
2381 try:
2382 self.enterOuterAlt(localctx, 1)
2383 self.state = 457
2384 self.match(Python3Parser.COLON)
2385 self.state = 458
2386 self.test()
2387 self.state = 461
2388 self._errHandler.sync(self)
2389 _la = self._input.LA(1)
2390 if _la==Python3Parser.ASSIGN:
2391 self.state = 459
2392 self.match(Python3Parser.ASSIGN)
2393 self.state = 460
2394 self.test()
2397 except RecognitionException as re:
2398 localctx.exception = re
2399 self._errHandler.reportError(self, re)
2400 self._errHandler.recover(self, re)
2401 finally:
2402 self.exitRule()
2403 return localctx
2406 class Testlist_star_exprContext(ParserRuleContext):
2407 __slots__ = 'parser'
2409 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2410 super().__init__(parent, invokingState)
2411 self.parser = parser
2413 def test(self, i:int=None):
2414 if i is None:
2415 return self.getTypedRuleContexts(Python3Parser.TestContext)
2416 else:
2417 return self.getTypedRuleContext(Python3Parser.TestContext,i)
2420 def star_expr(self, i:int=None):
2421 if i is None:
2422 return self.getTypedRuleContexts(Python3Parser.Star_exprContext)
2423 else:
2424 return self.getTypedRuleContext(Python3Parser.Star_exprContext,i)
2427 def COMMA(self, i:int=None):
2428 if i is None:
2429 return self.getTokens(Python3Parser.COMMA)
2430 else:
2431 return self.getToken(Python3Parser.COMMA, i)
2433 def getRuleIndex(self):
2434 return Python3Parser.RULE_testlist_star_expr
2436 def enterRule(self, listener:ParseTreeListener):
2437 if hasattr( listener, "enterTestlist_star_expr" ):
2438 listener.enterTestlist_star_expr(self)
2440 def exitRule(self, listener:ParseTreeListener):
2441 if hasattr( listener, "exitTestlist_star_expr" ):
2442 listener.exitTestlist_star_expr(self)
2447 def testlist_star_expr(self):
2449 localctx = Python3Parser.Testlist_star_exprContext(self, self._ctx, self.state)
2450 self.enterRule(localctx, 36, self.RULE_testlist_star_expr)
2451 self._la = 0 # Token type
2452 try:
2453 self.enterOuterAlt(localctx, 1)
2454 self.state = 465
2455 self._errHandler.sync(self)
2456 token = self._input.LA(1)
2457 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]:
2458 self.state = 463
2459 self.test()
2460 pass
2461 elif token in [Python3Parser.STAR]:
2462 self.state = 464
2463 self.star_expr()
2464 pass
2465 else:
2466 raise NoViableAltException(self)
2468 self.state = 474
2469 self._errHandler.sync(self)
2470 _alt = self._interp.adaptivePredict(self._input,62,self._ctx)
2471 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
2472 if _alt==1:
2473 self.state = 467
2474 self.match(Python3Parser.COMMA)
2475 self.state = 470
2476 self._errHandler.sync(self)
2477 token = self._input.LA(1)
2478 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]:
2479 self.state = 468
2480 self.test()
2481 pass
2482 elif token in [Python3Parser.STAR]:
2483 self.state = 469
2484 self.star_expr()
2485 pass
2486 else:
2487 raise NoViableAltException(self)
2489 self.state = 476
2490 self._errHandler.sync(self)
2491 _alt = self._interp.adaptivePredict(self._input,62,self._ctx)
2493 self.state = 478
2494 self._errHandler.sync(self)
2495 _la = self._input.LA(1)
2496 if _la==Python3Parser.COMMA:
2497 self.state = 477
2498 self.match(Python3Parser.COMMA)
2501 except RecognitionException as re:
2502 localctx.exception = re
2503 self._errHandler.reportError(self, re)
2504 self._errHandler.recover(self, re)
2505 finally:
2506 self.exitRule()
2507 return localctx
2510 class AugassignContext(ParserRuleContext):
2511 __slots__ = 'parser'
2513 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2514 super().__init__(parent, invokingState)
2515 self.parser = parser
2517 def ADD_ASSIGN(self):
2518 return self.getToken(Python3Parser.ADD_ASSIGN, 0)
2520 def SUB_ASSIGN(self):
2521 return self.getToken(Python3Parser.SUB_ASSIGN, 0)
2523 def MULT_ASSIGN(self):
2524 return self.getToken(Python3Parser.MULT_ASSIGN, 0)
2526 def AT_ASSIGN(self):
2527 return self.getToken(Python3Parser.AT_ASSIGN, 0)
2529 def DIV_ASSIGN(self):
2530 return self.getToken(Python3Parser.DIV_ASSIGN, 0)
2532 def MOD_ASSIGN(self):
2533 return self.getToken(Python3Parser.MOD_ASSIGN, 0)
2535 def AND_ASSIGN(self):
2536 return self.getToken(Python3Parser.AND_ASSIGN, 0)
2538 def OR_ASSIGN(self):
2539 return self.getToken(Python3Parser.OR_ASSIGN, 0)
2541 def XOR_ASSIGN(self):
2542 return self.getToken(Python3Parser.XOR_ASSIGN, 0)
2544 def LEFT_SHIFT_ASSIGN(self):
2545 return self.getToken(Python3Parser.LEFT_SHIFT_ASSIGN, 0)
2547 def RIGHT_SHIFT_ASSIGN(self):
2548 return self.getToken(Python3Parser.RIGHT_SHIFT_ASSIGN, 0)
2550 def POWER_ASSIGN(self):
2551 return self.getToken(Python3Parser.POWER_ASSIGN, 0)
2553 def IDIV_ASSIGN(self):
2554 return self.getToken(Python3Parser.IDIV_ASSIGN, 0)
2556 def getRuleIndex(self):
2557 return Python3Parser.RULE_augassign
2559 def enterRule(self, listener:ParseTreeListener):
2560 if hasattr( listener, "enterAugassign" ):
2561 listener.enterAugassign(self)
2563 def exitRule(self, listener:ParseTreeListener):
2564 if hasattr( listener, "exitAugassign" ):
2565 listener.exitAugassign(self)
2570 def augassign(self):
2572 localctx = Python3Parser.AugassignContext(self, self._ctx, self.state)
2573 self.enterRule(localctx, 38, self.RULE_augassign)
2574 self._la = 0 # Token type
2575 try:
2576 self.enterOuterAlt(localctx, 1)
2577 self.state = 480
2578 _la = self._input.LA(1)
2579 if not(((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (Python3Parser.ADD_ASSIGN - 83)) | (1 << (Python3Parser.SUB_ASSIGN - 83)) | (1 << (Python3Parser.MULT_ASSIGN - 83)) | (1 << (Python3Parser.AT_ASSIGN - 83)) | (1 << (Python3Parser.DIV_ASSIGN - 83)) | (1 << (Python3Parser.MOD_ASSIGN - 83)) | (1 << (Python3Parser.AND_ASSIGN - 83)) | (1 << (Python3Parser.OR_ASSIGN - 83)) | (1 << (Python3Parser.XOR_ASSIGN - 83)) | (1 << (Python3Parser.LEFT_SHIFT_ASSIGN - 83)) | (1 << (Python3Parser.RIGHT_SHIFT_ASSIGN - 83)) | (1 << (Python3Parser.POWER_ASSIGN - 83)) | (1 << (Python3Parser.IDIV_ASSIGN - 83)))) != 0)):
2580 self._errHandler.recoverInline(self)
2581 else:
2582 self._errHandler.reportMatch(self)
2583 self.consume()
2584 except RecognitionException as re:
2585 localctx.exception = re
2586 self._errHandler.reportError(self, re)
2587 self._errHandler.recover(self, re)
2588 finally:
2589 self.exitRule()
2590 return localctx
2593 class Del_stmtContext(ParserRuleContext):
2594 __slots__ = 'parser'
2596 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2597 super().__init__(parent, invokingState)
2598 self.parser = parser
2600 def DEL(self):
2601 return self.getToken(Python3Parser.DEL, 0)
2603 def exprlist(self):
2604 return self.getTypedRuleContext(Python3Parser.ExprlistContext,0)
2607 def getRuleIndex(self):
2608 return Python3Parser.RULE_del_stmt
2610 def enterRule(self, listener:ParseTreeListener):
2611 if hasattr( listener, "enterDel_stmt" ):
2612 listener.enterDel_stmt(self)
2614 def exitRule(self, listener:ParseTreeListener):
2615 if hasattr( listener, "exitDel_stmt" ):
2616 listener.exitDel_stmt(self)
2621 def del_stmt(self):
2623 localctx = Python3Parser.Del_stmtContext(self, self._ctx, self.state)
2624 self.enterRule(localctx, 40, self.RULE_del_stmt)
2625 try:
2626 self.enterOuterAlt(localctx, 1)
2627 self.state = 482
2628 self.match(Python3Parser.DEL)
2629 self.state = 483
2630 self.exprlist()
2631 except RecognitionException as re:
2632 localctx.exception = re
2633 self._errHandler.reportError(self, re)
2634 self._errHandler.recover(self, re)
2635 finally:
2636 self.exitRule()
2637 return localctx
2640 class Pass_stmtContext(ParserRuleContext):
2641 __slots__ = 'parser'
2643 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2644 super().__init__(parent, invokingState)
2645 self.parser = parser
2647 def PASS(self):
2648 return self.getToken(Python3Parser.PASS, 0)
2650 def getRuleIndex(self):
2651 return Python3Parser.RULE_pass_stmt
2653 def enterRule(self, listener:ParseTreeListener):
2654 if hasattr( listener, "enterPass_stmt" ):
2655 listener.enterPass_stmt(self)
2657 def exitRule(self, listener:ParseTreeListener):
2658 if hasattr( listener, "exitPass_stmt" ):
2659 listener.exitPass_stmt(self)
2664 def pass_stmt(self):
2666 localctx = Python3Parser.Pass_stmtContext(self, self._ctx, self.state)
2667 self.enterRule(localctx, 42, self.RULE_pass_stmt)
2668 try:
2669 self.enterOuterAlt(localctx, 1)
2670 self.state = 485
2671 self.match(Python3Parser.PASS)
2672 except RecognitionException as re:
2673 localctx.exception = re
2674 self._errHandler.reportError(self, re)
2675 self._errHandler.recover(self, re)
2676 finally:
2677 self.exitRule()
2678 return localctx
2681 class Flow_stmtContext(ParserRuleContext):
2682 __slots__ = 'parser'
2684 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2685 super().__init__(parent, invokingState)
2686 self.parser = parser
2688 def break_stmt(self):
2689 return self.getTypedRuleContext(Python3Parser.Break_stmtContext,0)
2692 def continue_stmt(self):
2693 return self.getTypedRuleContext(Python3Parser.Continue_stmtContext,0)
2696 def return_stmt(self):
2697 return self.getTypedRuleContext(Python3Parser.Return_stmtContext,0)
2700 def raise_stmt(self):
2701 return self.getTypedRuleContext(Python3Parser.Raise_stmtContext,0)
2704 def yield_stmt(self):
2705 return self.getTypedRuleContext(Python3Parser.Yield_stmtContext,0)
2708 def getRuleIndex(self):
2709 return Python3Parser.RULE_flow_stmt
2711 def enterRule(self, listener:ParseTreeListener):
2712 if hasattr( listener, "enterFlow_stmt" ):
2713 listener.enterFlow_stmt(self)
2715 def exitRule(self, listener:ParseTreeListener):
2716 if hasattr( listener, "exitFlow_stmt" ):
2717 listener.exitFlow_stmt(self)
2722 def flow_stmt(self):
2724 localctx = Python3Parser.Flow_stmtContext(self, self._ctx, self.state)
2725 self.enterRule(localctx, 44, self.RULE_flow_stmt)
2726 try:
2727 self.state = 492
2728 self._errHandler.sync(self)
2729 token = self._input.LA(1)
2730 if token in [Python3Parser.BREAK]:
2731 self.enterOuterAlt(localctx, 1)
2732 self.state = 487
2733 self.break_stmt()
2734 pass
2735 elif token in [Python3Parser.CONTINUE]:
2736 self.enterOuterAlt(localctx, 2)
2737 self.state = 488
2738 self.continue_stmt()
2739 pass
2740 elif token in [Python3Parser.RETURN]:
2741 self.enterOuterAlt(localctx, 3)
2742 self.state = 489
2743 self.return_stmt()
2744 pass
2745 elif token in [Python3Parser.RAISE]:
2746 self.enterOuterAlt(localctx, 4)
2747 self.state = 490
2748 self.raise_stmt()
2749 pass
2750 elif token in [Python3Parser.YIELD]:
2751 self.enterOuterAlt(localctx, 5)
2752 self.state = 491
2753 self.yield_stmt()
2754 pass
2755 else:
2756 raise NoViableAltException(self)
2758 except RecognitionException as re:
2759 localctx.exception = re
2760 self._errHandler.reportError(self, re)
2761 self._errHandler.recover(self, re)
2762 finally:
2763 self.exitRule()
2764 return localctx
2767 class Break_stmtContext(ParserRuleContext):
2768 __slots__ = 'parser'
2770 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2771 super().__init__(parent, invokingState)
2772 self.parser = parser
2774 def BREAK(self):
2775 return self.getToken(Python3Parser.BREAK, 0)
2777 def getRuleIndex(self):
2778 return Python3Parser.RULE_break_stmt
2780 def enterRule(self, listener:ParseTreeListener):
2781 if hasattr( listener, "enterBreak_stmt" ):
2782 listener.enterBreak_stmt(self)
2784 def exitRule(self, listener:ParseTreeListener):
2785 if hasattr( listener, "exitBreak_stmt" ):
2786 listener.exitBreak_stmt(self)
2791 def break_stmt(self):
2793 localctx = Python3Parser.Break_stmtContext(self, self._ctx, self.state)
2794 self.enterRule(localctx, 46, self.RULE_break_stmt)
2795 try:
2796 self.enterOuterAlt(localctx, 1)
2797 self.state = 494
2798 self.match(Python3Parser.BREAK)
2799 except RecognitionException as re:
2800 localctx.exception = re
2801 self._errHandler.reportError(self, re)
2802 self._errHandler.recover(self, re)
2803 finally:
2804 self.exitRule()
2805 return localctx
2808 class Continue_stmtContext(ParserRuleContext):
2809 __slots__ = 'parser'
2811 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2812 super().__init__(parent, invokingState)
2813 self.parser = parser
2815 def CONTINUE(self):
2816 return self.getToken(Python3Parser.CONTINUE, 0)
2818 def getRuleIndex(self):
2819 return Python3Parser.RULE_continue_stmt
2821 def enterRule(self, listener:ParseTreeListener):
2822 if hasattr( listener, "enterContinue_stmt" ):
2823 listener.enterContinue_stmt(self)
2825 def exitRule(self, listener:ParseTreeListener):
2826 if hasattr( listener, "exitContinue_stmt" ):
2827 listener.exitContinue_stmt(self)
2832 def continue_stmt(self):
2834 localctx = Python3Parser.Continue_stmtContext(self, self._ctx, self.state)
2835 self.enterRule(localctx, 48, self.RULE_continue_stmt)
2836 try:
2837 self.enterOuterAlt(localctx, 1)
2838 self.state = 496
2839 self.match(Python3Parser.CONTINUE)
2840 except RecognitionException as re:
2841 localctx.exception = re
2842 self._errHandler.reportError(self, re)
2843 self._errHandler.recover(self, re)
2844 finally:
2845 self.exitRule()
2846 return localctx
2849 class Return_stmtContext(ParserRuleContext):
2850 __slots__ = 'parser'
2852 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2853 super().__init__(parent, invokingState)
2854 self.parser = parser
2856 def RETURN(self):
2857 return self.getToken(Python3Parser.RETURN, 0)
2859 def testlist(self):
2860 return self.getTypedRuleContext(Python3Parser.TestlistContext,0)
2863 def getRuleIndex(self):
2864 return Python3Parser.RULE_return_stmt
2866 def enterRule(self, listener:ParseTreeListener):
2867 if hasattr( listener, "enterReturn_stmt" ):
2868 listener.enterReturn_stmt(self)
2870 def exitRule(self, listener:ParseTreeListener):
2871 if hasattr( listener, "exitReturn_stmt" ):
2872 listener.exitReturn_stmt(self)
2877 def return_stmt(self):
2879 localctx = Python3Parser.Return_stmtContext(self, self._ctx, self.state)
2880 self.enterRule(localctx, 50, self.RULE_return_stmt)
2881 self._la = 0 # Token type
2882 try:
2883 self.enterOuterAlt(localctx, 1)
2884 self.state = 498
2885 self.match(Python3Parser.RETURN)
2886 self.state = 500
2887 self._errHandler.sync(self)
2888 _la = self._input.LA(1)
2889 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0):
2890 self.state = 499
2891 self.testlist()
2894 except RecognitionException as re:
2895 localctx.exception = re
2896 self._errHandler.reportError(self, re)
2897 self._errHandler.recover(self, re)
2898 finally:
2899 self.exitRule()
2900 return localctx
2903 class Yield_stmtContext(ParserRuleContext):
2904 __slots__ = 'parser'
2906 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2907 super().__init__(parent, invokingState)
2908 self.parser = parser
2910 def yield_expr(self):
2911 return self.getTypedRuleContext(Python3Parser.Yield_exprContext,0)
2914 def getRuleIndex(self):
2915 return Python3Parser.RULE_yield_stmt
2917 def enterRule(self, listener:ParseTreeListener):
2918 if hasattr( listener, "enterYield_stmt" ):
2919 listener.enterYield_stmt(self)
2921 def exitRule(self, listener:ParseTreeListener):
2922 if hasattr( listener, "exitYield_stmt" ):
2923 listener.exitYield_stmt(self)
2928 def yield_stmt(self):
2930 localctx = Python3Parser.Yield_stmtContext(self, self._ctx, self.state)
2931 self.enterRule(localctx, 52, self.RULE_yield_stmt)
2932 try:
2933 self.enterOuterAlt(localctx, 1)
2934 self.state = 502
2935 self.yield_expr()
2936 except RecognitionException as re:
2937 localctx.exception = re
2938 self._errHandler.reportError(self, re)
2939 self._errHandler.recover(self, re)
2940 finally:
2941 self.exitRule()
2942 return localctx
2945 class Raise_stmtContext(ParserRuleContext):
2946 __slots__ = 'parser'
2948 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2949 super().__init__(parent, invokingState)
2950 self.parser = parser
2952 def RAISE(self):
2953 return self.getToken(Python3Parser.RAISE, 0)
2955 def test(self, i:int=None):
2956 if i is None:
2957 return self.getTypedRuleContexts(Python3Parser.TestContext)
2958 else:
2959 return self.getTypedRuleContext(Python3Parser.TestContext,i)
2962 def FROM(self):
2963 return self.getToken(Python3Parser.FROM, 0)
2965 def getRuleIndex(self):
2966 return Python3Parser.RULE_raise_stmt
2968 def enterRule(self, listener:ParseTreeListener):
2969 if hasattr( listener, "enterRaise_stmt" ):
2970 listener.enterRaise_stmt(self)
2972 def exitRule(self, listener:ParseTreeListener):
2973 if hasattr( listener, "exitRaise_stmt" ):
2974 listener.exitRaise_stmt(self)
2979 def raise_stmt(self):
2981 localctx = Python3Parser.Raise_stmtContext(self, self._ctx, self.state)
2982 self.enterRule(localctx, 54, self.RULE_raise_stmt)
2983 self._la = 0 # Token type
2984 try:
2985 self.enterOuterAlt(localctx, 1)
2986 self.state = 504
2987 self.match(Python3Parser.RAISE)
2988 self.state = 510
2989 self._errHandler.sync(self)
2990 _la = self._input.LA(1)
2991 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0):
2992 self.state = 505
2993 self.test()
2994 self.state = 508
2995 self._errHandler.sync(self)
2996 _la = self._input.LA(1)
2997 if _la==Python3Parser.FROM:
2998 self.state = 506
2999 self.match(Python3Parser.FROM)
3000 self.state = 507
3001 self.test()
3006 except RecognitionException as re:
3007 localctx.exception = re
3008 self._errHandler.reportError(self, re)
3009 self._errHandler.recover(self, re)
3010 finally:
3011 self.exitRule()
3012 return localctx
3015 class Import_stmtContext(ParserRuleContext):
3016 __slots__ = 'parser'
3018 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3019 super().__init__(parent, invokingState)
3020 self.parser = parser
3022 def import_name(self):
3023 return self.getTypedRuleContext(Python3Parser.Import_nameContext,0)
3026 def import_from(self):
3027 return self.getTypedRuleContext(Python3Parser.Import_fromContext,0)
3030 def getRuleIndex(self):
3031 return Python3Parser.RULE_import_stmt
3033 def enterRule(self, listener:ParseTreeListener):
3034 if hasattr( listener, "enterImport_stmt" ):
3035 listener.enterImport_stmt(self)
3037 def exitRule(self, listener:ParseTreeListener):
3038 if hasattr( listener, "exitImport_stmt" ):
3039 listener.exitImport_stmt(self)
3044 def import_stmt(self):
3046 localctx = Python3Parser.Import_stmtContext(self, self._ctx, self.state)
3047 self.enterRule(localctx, 56, self.RULE_import_stmt)
3048 try:
3049 self.state = 514
3050 self._errHandler.sync(self)
3051 token = self._input.LA(1)
3052 if token in [Python3Parser.IMPORT]:
3053 self.enterOuterAlt(localctx, 1)
3054 self.state = 512
3055 self.import_name()
3056 pass
3057 elif token in [Python3Parser.FROM]:
3058 self.enterOuterAlt(localctx, 2)
3059 self.state = 513
3060 self.import_from()
3061 pass
3062 else:
3063 raise NoViableAltException(self)
3065 except RecognitionException as re:
3066 localctx.exception = re
3067 self._errHandler.reportError(self, re)
3068 self._errHandler.recover(self, re)
3069 finally:
3070 self.exitRule()
3071 return localctx
3074 class Import_nameContext(ParserRuleContext):
3075 __slots__ = 'parser'
3077 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3078 super().__init__(parent, invokingState)
3079 self.parser = parser
3081 def IMPORT(self):
3082 return self.getToken(Python3Parser.IMPORT, 0)
3084 def dotted_as_names(self):
3085 return self.getTypedRuleContext(Python3Parser.Dotted_as_namesContext,0)
3088 def getRuleIndex(self):
3089 return Python3Parser.RULE_import_name
3091 def enterRule(self, listener:ParseTreeListener):
3092 if hasattr( listener, "enterImport_name" ):
3093 listener.enterImport_name(self)
3095 def exitRule(self, listener:ParseTreeListener):
3096 if hasattr( listener, "exitImport_name" ):
3097 listener.exitImport_name(self)
3102 def import_name(self):
3104 localctx = Python3Parser.Import_nameContext(self, self._ctx, self.state)
3105 self.enterRule(localctx, 58, self.RULE_import_name)
3106 try:
3107 self.enterOuterAlt(localctx, 1)
3108 self.state = 516
3109 self.match(Python3Parser.IMPORT)
3110 self.state = 517
3111 self.dotted_as_names()
3112 except RecognitionException as re:
3113 localctx.exception = re
3114 self._errHandler.reportError(self, re)
3115 self._errHandler.recover(self, re)
3116 finally:
3117 self.exitRule()
3118 return localctx
3121 class Import_fromContext(ParserRuleContext):
3122 __slots__ = 'parser'
3124 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3125 super().__init__(parent, invokingState)
3126 self.parser = parser
3128 def FROM(self):
3129 return self.getToken(Python3Parser.FROM, 0)
3131 def IMPORT(self):
3132 return self.getToken(Python3Parser.IMPORT, 0)
3134 def dotted_name(self):
3135 return self.getTypedRuleContext(Python3Parser.Dotted_nameContext,0)
3138 def STAR(self):
3139 return self.getToken(Python3Parser.STAR, 0)
3141 def OPEN_PAREN(self):
3142 return self.getToken(Python3Parser.OPEN_PAREN, 0)
3144 def import_as_names(self):
3145 return self.getTypedRuleContext(Python3Parser.Import_as_namesContext,0)
3148 def CLOSE_PAREN(self):
3149 return self.getToken(Python3Parser.CLOSE_PAREN, 0)
3151 def DOT(self, i:int=None):
3152 if i is None:
3153 return self.getTokens(Python3Parser.DOT)
3154 else:
3155 return self.getToken(Python3Parser.DOT, i)
3157 def ELLIPSIS(self, i:int=None):
3158 if i is None:
3159 return self.getTokens(Python3Parser.ELLIPSIS)
3160 else:
3161 return self.getToken(Python3Parser.ELLIPSIS, i)
3163 def getRuleIndex(self):
3164 return Python3Parser.RULE_import_from
3166 def enterRule(self, listener:ParseTreeListener):
3167 if hasattr( listener, "enterImport_from" ):
3168 listener.enterImport_from(self)
3170 def exitRule(self, listener:ParseTreeListener):
3171 if hasattr( listener, "exitImport_from" ):
3172 listener.exitImport_from(self)
3177 def import_from(self):
3179 localctx = Python3Parser.Import_fromContext(self, self._ctx, self.state)
3180 self.enterRule(localctx, 60, self.RULE_import_from)
3181 self._la = 0 # Token type
3182 try:
3183 self.enterOuterAlt(localctx, 1)
3184 self.state = 519
3185 self.match(Python3Parser.FROM)
3186 self.state = 532
3187 self._errHandler.sync(self)
3188 la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
3189 if la_ == 1:
3190 self.state = 523
3191 self._errHandler.sync(self)
3192 _la = self._input.LA(1)
3193 while _la==Python3Parser.DOT or _la==Python3Parser.ELLIPSIS:
3194 self.state = 520
3195 _la = self._input.LA(1)
3196 if not(_la==Python3Parser.DOT or _la==Python3Parser.ELLIPSIS):
3197 self._errHandler.recoverInline(self)
3198 else:
3199 self._errHandler.reportMatch(self)
3200 self.consume()
3201 self.state = 525
3202 self._errHandler.sync(self)
3203 _la = self._input.LA(1)
3205 self.state = 526
3206 self.dotted_name()
3207 pass
3209 elif la_ == 2:
3210 self.state = 528
3211 self._errHandler.sync(self)
3212 _la = self._input.LA(1)
3213 while True:
3214 self.state = 527
3215 _la = self._input.LA(1)
3216 if not(_la==Python3Parser.DOT or _la==Python3Parser.ELLIPSIS):
3217 self._errHandler.recoverInline(self)
3218 else:
3219 self._errHandler.reportMatch(self)
3220 self.consume()
3221 self.state = 530
3222 self._errHandler.sync(self)
3223 _la = self._input.LA(1)
3224 if not (_la==Python3Parser.DOT or _la==Python3Parser.ELLIPSIS):
3225 break
3227 pass
3230 self.state = 534
3231 self.match(Python3Parser.IMPORT)
3232 self.state = 541
3233 self._errHandler.sync(self)
3234 token = self._input.LA(1)
3235 if token in [Python3Parser.STAR]:
3236 self.state = 535
3237 self.match(Python3Parser.STAR)
3238 pass
3239 elif token in [Python3Parser.OPEN_PAREN]:
3240 self.state = 536
3241 self.match(Python3Parser.OPEN_PAREN)
3242 self.state = 537
3243 self.import_as_names()
3244 self.state = 538
3245 self.match(Python3Parser.CLOSE_PAREN)
3246 pass
3247 elif token in [Python3Parser.NAME]:
3248 self.state = 540
3249 self.import_as_names()
3250 pass
3251 else:
3252 raise NoViableAltException(self)
3254 except RecognitionException as re:
3255 localctx.exception = re
3256 self._errHandler.reportError(self, re)
3257 self._errHandler.recover(self, re)
3258 finally:
3259 self.exitRule()
3260 return localctx
3263 class Import_as_nameContext(ParserRuleContext):
3264 __slots__ = 'parser'
3266 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3267 super().__init__(parent, invokingState)
3268 self.parser = parser
3270 def NAME(self, i:int=None):
3271 if i is None:
3272 return self.getTokens(Python3Parser.NAME)
3273 else:
3274 return self.getToken(Python3Parser.NAME, i)
3276 def AS(self):
3277 return self.getToken(Python3Parser.AS, 0)
3279 def getRuleIndex(self):
3280 return Python3Parser.RULE_import_as_name
3282 def enterRule(self, listener:ParseTreeListener):
3283 if hasattr( listener, "enterImport_as_name" ):
3284 listener.enterImport_as_name(self)
3286 def exitRule(self, listener:ParseTreeListener):
3287 if hasattr( listener, "exitImport_as_name" ):
3288 listener.exitImport_as_name(self)
3293 def import_as_name(self):
3295 localctx = Python3Parser.Import_as_nameContext(self, self._ctx, self.state)
3296 self.enterRule(localctx, 62, self.RULE_import_as_name)
3297 self._la = 0 # Token type
3298 try:
3299 self.enterOuterAlt(localctx, 1)
3300 self.state = 543
3301 self.match(Python3Parser.NAME)
3302 self.state = 546
3303 self._errHandler.sync(self)
3304 _la = self._input.LA(1)
3305 if _la==Python3Parser.AS:
3306 self.state = 544
3307 self.match(Python3Parser.AS)
3308 self.state = 545
3309 self.match(Python3Parser.NAME)
3312 except RecognitionException as re:
3313 localctx.exception = re
3314 self._errHandler.reportError(self, re)
3315 self._errHandler.recover(self, re)
3316 finally:
3317 self.exitRule()
3318 return localctx
3321 class Dotted_as_nameContext(ParserRuleContext):
3322 __slots__ = 'parser'
3324 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3325 super().__init__(parent, invokingState)
3326 self.parser = parser
3328 def dotted_name(self):
3329 return self.getTypedRuleContext(Python3Parser.Dotted_nameContext,0)
3332 def AS(self):
3333 return self.getToken(Python3Parser.AS, 0)
3335 def NAME(self):
3336 return self.getToken(Python3Parser.NAME, 0)
3338 def getRuleIndex(self):
3339 return Python3Parser.RULE_dotted_as_name
3341 def enterRule(self, listener:ParseTreeListener):
3342 if hasattr( listener, "enterDotted_as_name" ):
3343 listener.enterDotted_as_name(self)
3345 def exitRule(self, listener:ParseTreeListener):
3346 if hasattr( listener, "exitDotted_as_name" ):
3347 listener.exitDotted_as_name(self)
3352 def dotted_as_name(self):
3354 localctx = Python3Parser.Dotted_as_nameContext(self, self._ctx, self.state)
3355 self.enterRule(localctx, 64, self.RULE_dotted_as_name)
3356 self._la = 0 # Token type
3357 try:
3358 self.enterOuterAlt(localctx, 1)
3359 self.state = 548
3360 self.dotted_name()
3361 self.state = 551
3362 self._errHandler.sync(self)
3363 _la = self._input.LA(1)
3364 if _la==Python3Parser.AS:
3365 self.state = 549
3366 self.match(Python3Parser.AS)
3367 self.state = 550
3368 self.match(Python3Parser.NAME)
3371 except RecognitionException as re:
3372 localctx.exception = re
3373 self._errHandler.reportError(self, re)
3374 self._errHandler.recover(self, re)
3375 finally:
3376 self.exitRule()
3377 return localctx
3380 class Import_as_namesContext(ParserRuleContext):
3381 __slots__ = 'parser'
3383 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3384 super().__init__(parent, invokingState)
3385 self.parser = parser
3387 def import_as_name(self, i:int=None):
3388 if i is None:
3389 return self.getTypedRuleContexts(Python3Parser.Import_as_nameContext)
3390 else:
3391 return self.getTypedRuleContext(Python3Parser.Import_as_nameContext,i)
3394 def COMMA(self, i:int=None):
3395 if i is None:
3396 return self.getTokens(Python3Parser.COMMA)
3397 else:
3398 return self.getToken(Python3Parser.COMMA, i)
3400 def getRuleIndex(self):
3401 return Python3Parser.RULE_import_as_names
3403 def enterRule(self, listener:ParseTreeListener):
3404 if hasattr( listener, "enterImport_as_names" ):
3405 listener.enterImport_as_names(self)
3407 def exitRule(self, listener:ParseTreeListener):
3408 if hasattr( listener, "exitImport_as_names" ):
3409 listener.exitImport_as_names(self)
3414 def import_as_names(self):
3416 localctx = Python3Parser.Import_as_namesContext(self, self._ctx, self.state)
3417 self.enterRule(localctx, 66, self.RULE_import_as_names)
3418 self._la = 0 # Token type
3419 try:
3420 self.enterOuterAlt(localctx, 1)
3421 self.state = 553
3422 self.import_as_name()
3423 self.state = 558
3424 self._errHandler.sync(self)
3425 _alt = self._interp.adaptivePredict(self._input,75,self._ctx)
3426 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
3427 if _alt==1:
3428 self.state = 554
3429 self.match(Python3Parser.COMMA)
3430 self.state = 555
3431 self.import_as_name()
3432 self.state = 560
3433 self._errHandler.sync(self)
3434 _alt = self._interp.adaptivePredict(self._input,75,self._ctx)
3436 self.state = 562
3437 self._errHandler.sync(self)
3438 _la = self._input.LA(1)
3439 if _la==Python3Parser.COMMA:
3440 self.state = 561
3441 self.match(Python3Parser.COMMA)
3444 except RecognitionException as re:
3445 localctx.exception = re
3446 self._errHandler.reportError(self, re)
3447 self._errHandler.recover(self, re)
3448 finally:
3449 self.exitRule()
3450 return localctx
3453 class Dotted_as_namesContext(ParserRuleContext):
3454 __slots__ = 'parser'
3456 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3457 super().__init__(parent, invokingState)
3458 self.parser = parser
3460 def dotted_as_name(self, i:int=None):
3461 if i is None:
3462 return self.getTypedRuleContexts(Python3Parser.Dotted_as_nameContext)
3463 else:
3464 return self.getTypedRuleContext(Python3Parser.Dotted_as_nameContext,i)
3467 def COMMA(self, i:int=None):
3468 if i is None:
3469 return self.getTokens(Python3Parser.COMMA)
3470 else:
3471 return self.getToken(Python3Parser.COMMA, i)
3473 def getRuleIndex(self):
3474 return Python3Parser.RULE_dotted_as_names
3476 def enterRule(self, listener:ParseTreeListener):
3477 if hasattr( listener, "enterDotted_as_names" ):
3478 listener.enterDotted_as_names(self)
3480 def exitRule(self, listener:ParseTreeListener):
3481 if hasattr( listener, "exitDotted_as_names" ):
3482 listener.exitDotted_as_names(self)
3487 def dotted_as_names(self):
3489 localctx = Python3Parser.Dotted_as_namesContext(self, self._ctx, self.state)
3490 self.enterRule(localctx, 68, self.RULE_dotted_as_names)
3491 self._la = 0 # Token type
3492 try:
3493 self.enterOuterAlt(localctx, 1)
3494 self.state = 564
3495 self.dotted_as_name()
3496 self.state = 569
3497 self._errHandler.sync(self)
3498 _la = self._input.LA(1)
3499 while _la==Python3Parser.COMMA:
3500 self.state = 565
3501 self.match(Python3Parser.COMMA)
3502 self.state = 566
3503 self.dotted_as_name()
3504 self.state = 571
3505 self._errHandler.sync(self)
3506 _la = self._input.LA(1)
3508 except RecognitionException as re:
3509 localctx.exception = re
3510 self._errHandler.reportError(self, re)
3511 self._errHandler.recover(self, re)
3512 finally:
3513 self.exitRule()
3514 return localctx
3517 class Dotted_nameContext(ParserRuleContext):
3518 __slots__ = 'parser'
3520 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3521 super().__init__(parent, invokingState)
3522 self.parser = parser
3524 def NAME(self, i:int=None):
3525 if i is None:
3526 return self.getTokens(Python3Parser.NAME)
3527 else:
3528 return self.getToken(Python3Parser.NAME, i)
3530 def DOT(self, i:int=None):
3531 if i is None:
3532 return self.getTokens(Python3Parser.DOT)
3533 else:
3534 return self.getToken(Python3Parser.DOT, i)
3536 def getRuleIndex(self):
3537 return Python3Parser.RULE_dotted_name
3539 def enterRule(self, listener:ParseTreeListener):
3540 if hasattr( listener, "enterDotted_name" ):
3541 listener.enterDotted_name(self)
3543 def exitRule(self, listener:ParseTreeListener):
3544 if hasattr( listener, "exitDotted_name" ):
3545 listener.exitDotted_name(self)
3550 def dotted_name(self):
3552 localctx = Python3Parser.Dotted_nameContext(self, self._ctx, self.state)
3553 self.enterRule(localctx, 70, self.RULE_dotted_name)
3554 self._la = 0 # Token type
3555 try:
3556 self.enterOuterAlt(localctx, 1)
3557 self.state = 572
3558 self.match(Python3Parser.NAME)
3559 self.state = 577
3560 self._errHandler.sync(self)
3561 _la = self._input.LA(1)
3562 while _la==Python3Parser.DOT:
3563 self.state = 573
3564 self.match(Python3Parser.DOT)
3565 self.state = 574
3566 self.match(Python3Parser.NAME)
3567 self.state = 579
3568 self._errHandler.sync(self)
3569 _la = self._input.LA(1)
3571 except RecognitionException as re:
3572 localctx.exception = re
3573 self._errHandler.reportError(self, re)
3574 self._errHandler.recover(self, re)
3575 finally:
3576 self.exitRule()
3577 return localctx
3580 class Global_stmtContext(ParserRuleContext):
3581 __slots__ = 'parser'
3583 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3584 super().__init__(parent, invokingState)
3585 self.parser = parser
3587 def GLOBAL(self):
3588 return self.getToken(Python3Parser.GLOBAL, 0)
3590 def NAME(self, i:int=None):
3591 if i is None:
3592 return self.getTokens(Python3Parser.NAME)
3593 else:
3594 return self.getToken(Python3Parser.NAME, i)
3596 def COMMA(self, i:int=None):
3597 if i is None:
3598 return self.getTokens(Python3Parser.COMMA)
3599 else:
3600 return self.getToken(Python3Parser.COMMA, i)
3602 def getRuleIndex(self):
3603 return Python3Parser.RULE_global_stmt
3605 def enterRule(self, listener:ParseTreeListener):
3606 if hasattr( listener, "enterGlobal_stmt" ):
3607 listener.enterGlobal_stmt(self)
3609 def exitRule(self, listener:ParseTreeListener):
3610 if hasattr( listener, "exitGlobal_stmt" ):
3611 listener.exitGlobal_stmt(self)
3616 def global_stmt(self):
3618 localctx = Python3Parser.Global_stmtContext(self, self._ctx, self.state)
3619 self.enterRule(localctx, 72, self.RULE_global_stmt)
3620 self._la = 0 # Token type
3621 try:
3622 self.enterOuterAlt(localctx, 1)
3623 self.state = 580
3624 self.match(Python3Parser.GLOBAL)
3625 self.state = 581
3626 self.match(Python3Parser.NAME)
3627 self.state = 586
3628 self._errHandler.sync(self)
3629 _la = self._input.LA(1)
3630 while _la==Python3Parser.COMMA:
3631 self.state = 582
3632 self.match(Python3Parser.COMMA)
3633 self.state = 583
3634 self.match(Python3Parser.NAME)
3635 self.state = 588
3636 self._errHandler.sync(self)
3637 _la = self._input.LA(1)
3639 except RecognitionException as re:
3640 localctx.exception = re
3641 self._errHandler.reportError(self, re)
3642 self._errHandler.recover(self, re)
3643 finally:
3644 self.exitRule()
3645 return localctx
3648 class Nonlocal_stmtContext(ParserRuleContext):
3649 __slots__ = 'parser'
3651 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3652 super().__init__(parent, invokingState)
3653 self.parser = parser
3655 def NONLOCAL(self):
3656 return self.getToken(Python3Parser.NONLOCAL, 0)
3658 def NAME(self, i:int=None):
3659 if i is None:
3660 return self.getTokens(Python3Parser.NAME)
3661 else:
3662 return self.getToken(Python3Parser.NAME, i)
3664 def COMMA(self, i:int=None):
3665 if i is None:
3666 return self.getTokens(Python3Parser.COMMA)
3667 else:
3668 return self.getToken(Python3Parser.COMMA, i)
3670 def getRuleIndex(self):
3671 return Python3Parser.RULE_nonlocal_stmt
3673 def enterRule(self, listener:ParseTreeListener):
3674 if hasattr( listener, "enterNonlocal_stmt" ):
3675 listener.enterNonlocal_stmt(self)
3677 def exitRule(self, listener:ParseTreeListener):
3678 if hasattr( listener, "exitNonlocal_stmt" ):
3679 listener.exitNonlocal_stmt(self)
3684 def nonlocal_stmt(self):
3686 localctx = Python3Parser.Nonlocal_stmtContext(self, self._ctx, self.state)
3687 self.enterRule(localctx, 74, self.RULE_nonlocal_stmt)
3688 self._la = 0 # Token type
3689 try:
3690 self.enterOuterAlt(localctx, 1)
3691 self.state = 589
3692 self.match(Python3Parser.NONLOCAL)
3693 self.state = 590
3694 self.match(Python3Parser.NAME)
3695 self.state = 595
3696 self._errHandler.sync(self)
3697 _la = self._input.LA(1)
3698 while _la==Python3Parser.COMMA:
3699 self.state = 591
3700 self.match(Python3Parser.COMMA)
3701 self.state = 592
3702 self.match(Python3Parser.NAME)
3703 self.state = 597
3704 self._errHandler.sync(self)
3705 _la = self._input.LA(1)
3707 except RecognitionException as re:
3708 localctx.exception = re
3709 self._errHandler.reportError(self, re)
3710 self._errHandler.recover(self, re)
3711 finally:
3712 self.exitRule()
3713 return localctx
3716 class Assert_stmtContext(ParserRuleContext):
3717 __slots__ = 'parser'
3719 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3720 super().__init__(parent, invokingState)
3721 self.parser = parser
3723 def ASSERT(self):
3724 return self.getToken(Python3Parser.ASSERT, 0)
3726 def test(self, i:int=None):
3727 if i is None:
3728 return self.getTypedRuleContexts(Python3Parser.TestContext)
3729 else:
3730 return self.getTypedRuleContext(Python3Parser.TestContext,i)
3733 def COMMA(self):
3734 return self.getToken(Python3Parser.COMMA, 0)
3736 def getRuleIndex(self):
3737 return Python3Parser.RULE_assert_stmt
3739 def enterRule(self, listener:ParseTreeListener):
3740 if hasattr( listener, "enterAssert_stmt" ):
3741 listener.enterAssert_stmt(self)
3743 def exitRule(self, listener:ParseTreeListener):
3744 if hasattr( listener, "exitAssert_stmt" ):
3745 listener.exitAssert_stmt(self)
3750 def assert_stmt(self):
3752 localctx = Python3Parser.Assert_stmtContext(self, self._ctx, self.state)
3753 self.enterRule(localctx, 76, self.RULE_assert_stmt)
3754 self._la = 0 # Token type
3755 try:
3756 self.enterOuterAlt(localctx, 1)
3757 self.state = 598
3758 self.match(Python3Parser.ASSERT)
3759 self.state = 599
3760 self.test()
3761 self.state = 602
3762 self._errHandler.sync(self)
3763 _la = self._input.LA(1)
3764 if _la==Python3Parser.COMMA:
3765 self.state = 600
3766 self.match(Python3Parser.COMMA)
3767 self.state = 601
3768 self.test()
3771 except RecognitionException as re:
3772 localctx.exception = re
3773 self._errHandler.reportError(self, re)
3774 self._errHandler.recover(self, re)
3775 finally:
3776 self.exitRule()
3777 return localctx
3780 class Compound_stmtContext(ParserRuleContext):
3781 __slots__ = 'parser'
3783 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3784 super().__init__(parent, invokingState)
3785 self.parser = parser
3787 def if_stmt(self):
3788 return self.getTypedRuleContext(Python3Parser.If_stmtContext,0)
3791 def while_stmt(self):
3792 return self.getTypedRuleContext(Python3Parser.While_stmtContext,0)
3795 def for_stmt(self):
3796 return self.getTypedRuleContext(Python3Parser.For_stmtContext,0)
3799 def try_stmt(self):
3800 return self.getTypedRuleContext(Python3Parser.Try_stmtContext,0)
3803 def with_stmt(self):
3804 return self.getTypedRuleContext(Python3Parser.With_stmtContext,0)
3807 def funcdef(self):
3808 return self.getTypedRuleContext(Python3Parser.FuncdefContext,0)
3811 def classdef(self):
3812 return self.getTypedRuleContext(Python3Parser.ClassdefContext,0)
3815 def decorated(self):
3816 return self.getTypedRuleContext(Python3Parser.DecoratedContext,0)
3819 def async_stmt(self):
3820 return self.getTypedRuleContext(Python3Parser.Async_stmtContext,0)
3823 def getRuleIndex(self):
3824 return Python3Parser.RULE_compound_stmt
3826 def enterRule(self, listener:ParseTreeListener):
3827 if hasattr( listener, "enterCompound_stmt" ):
3828 listener.enterCompound_stmt(self)
3830 def exitRule(self, listener:ParseTreeListener):
3831 if hasattr( listener, "exitCompound_stmt" ):
3832 listener.exitCompound_stmt(self)
3837 def compound_stmt(self):
3839 localctx = Python3Parser.Compound_stmtContext(self, self._ctx, self.state)
3840 self.enterRule(localctx, 78, self.RULE_compound_stmt)
3841 try:
3842 self.state = 613
3843 self._errHandler.sync(self)
3844 token = self._input.LA(1)
3845 if token in [Python3Parser.IF]:
3846 self.enterOuterAlt(localctx, 1)
3847 self.state = 604
3848 self.if_stmt()
3849 pass
3850 elif token in [Python3Parser.WHILE]:
3851 self.enterOuterAlt(localctx, 2)
3852 self.state = 605
3853 self.while_stmt()
3854 pass
3855 elif token in [Python3Parser.FOR]:
3856 self.enterOuterAlt(localctx, 3)
3857 self.state = 606
3858 self.for_stmt()
3859 pass
3860 elif token in [Python3Parser.TRY]:
3861 self.enterOuterAlt(localctx, 4)
3862 self.state = 607
3863 self.try_stmt()
3864 pass
3865 elif token in [Python3Parser.WITH]:
3866 self.enterOuterAlt(localctx, 5)
3867 self.state = 608
3868 self.with_stmt()
3869 pass
3870 elif token in [Python3Parser.DEF]:
3871 self.enterOuterAlt(localctx, 6)
3872 self.state = 609
3873 self.funcdef()
3874 pass
3875 elif token in [Python3Parser.CLASS]:
3876 self.enterOuterAlt(localctx, 7)
3877 self.state = 610
3878 self.classdef()
3879 pass
3880 elif token in [Python3Parser.AT]:
3881 self.enterOuterAlt(localctx, 8)
3882 self.state = 611
3883 self.decorated()
3884 pass
3885 elif token in [Python3Parser.ASYNC]:
3886 self.enterOuterAlt(localctx, 9)
3887 self.state = 612
3888 self.async_stmt()
3889 pass
3890 else:
3891 raise NoViableAltException(self)
3893 except RecognitionException as re:
3894 localctx.exception = re
3895 self._errHandler.reportError(self, re)
3896 self._errHandler.recover(self, re)
3897 finally:
3898 self.exitRule()
3899 return localctx
3902 class Async_stmtContext(ParserRuleContext):
3903 __slots__ = 'parser'
3905 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3906 super().__init__(parent, invokingState)
3907 self.parser = parser
3909 def ASYNC(self):
3910 return self.getToken(Python3Parser.ASYNC, 0)
3912 def funcdef(self):
3913 return self.getTypedRuleContext(Python3Parser.FuncdefContext,0)
3916 def with_stmt(self):
3917 return self.getTypedRuleContext(Python3Parser.With_stmtContext,0)
3920 def for_stmt(self):
3921 return self.getTypedRuleContext(Python3Parser.For_stmtContext,0)
3924 def getRuleIndex(self):
3925 return Python3Parser.RULE_async_stmt
3927 def enterRule(self, listener:ParseTreeListener):
3928 if hasattr( listener, "enterAsync_stmt" ):
3929 listener.enterAsync_stmt(self)
3931 def exitRule(self, listener:ParseTreeListener):
3932 if hasattr( listener, "exitAsync_stmt" ):
3933 listener.exitAsync_stmt(self)
3938 def async_stmt(self):
3940 localctx = Python3Parser.Async_stmtContext(self, self._ctx, self.state)
3941 self.enterRule(localctx, 80, self.RULE_async_stmt)
3942 try:
3943 self.enterOuterAlt(localctx, 1)
3944 self.state = 615
3945 self.match(Python3Parser.ASYNC)
3946 self.state = 619
3947 self._errHandler.sync(self)
3948 token = self._input.LA(1)
3949 if token in [Python3Parser.DEF]:
3950 self.state = 616
3951 self.funcdef()
3952 pass
3953 elif token in [Python3Parser.WITH]:
3954 self.state = 617
3955 self.with_stmt()
3956 pass
3957 elif token in [Python3Parser.FOR]:
3958 self.state = 618
3959 self.for_stmt()
3960 pass
3961 else:
3962 raise NoViableAltException(self)
3964 except RecognitionException as re:
3965 localctx.exception = re
3966 self._errHandler.reportError(self, re)
3967 self._errHandler.recover(self, re)
3968 finally:
3969 self.exitRule()
3970 return localctx
3973 class If_stmtContext(ParserRuleContext):
3974 __slots__ = 'parser'
3976 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3977 super().__init__(parent, invokingState)
3978 self.parser = parser
3980 def IF(self):
3981 return self.getToken(Python3Parser.IF, 0)
3983 def test(self, i:int=None):
3984 if i is None:
3985 return self.getTypedRuleContexts(Python3Parser.TestContext)
3986 else:
3987 return self.getTypedRuleContext(Python3Parser.TestContext,i)
3990 def COLON(self, i:int=None):
3991 if i is None:
3992 return self.getTokens(Python3Parser.COLON)
3993 else:
3994 return self.getToken(Python3Parser.COLON, i)
3996 def suite(self, i:int=None):
3997 if i is None:
3998 return self.getTypedRuleContexts(Python3Parser.SuiteContext)
3999 else:
4000 return self.getTypedRuleContext(Python3Parser.SuiteContext,i)
4003 def ELIF(self, i:int=None):
4004 if i is None:
4005 return self.getTokens(Python3Parser.ELIF)
4006 else:
4007 return self.getToken(Python3Parser.ELIF, i)
4009 def ELSE(self):
4010 return self.getToken(Python3Parser.ELSE, 0)
4012 def getRuleIndex(self):
4013 return Python3Parser.RULE_if_stmt
4015 def enterRule(self, listener:ParseTreeListener):
4016 if hasattr( listener, "enterIf_stmt" ):
4017 listener.enterIf_stmt(self)
4019 def exitRule(self, listener:ParseTreeListener):
4020 if hasattr( listener, "exitIf_stmt" ):
4021 listener.exitIf_stmt(self)
4026 def if_stmt(self):
4028 localctx = Python3Parser.If_stmtContext(self, self._ctx, self.state)
4029 self.enterRule(localctx, 82, self.RULE_if_stmt)
4030 self._la = 0 # Token type
4031 try:
4032 self.enterOuterAlt(localctx, 1)
4033 self.state = 621
4034 self.match(Python3Parser.IF)
4035 self.state = 622
4036 self.test()
4037 self.state = 623
4038 self.match(Python3Parser.COLON)
4039 self.state = 624
4040 self.suite()
4041 self.state = 632
4042 self._errHandler.sync(self)
4043 _la = self._input.LA(1)
4044 while _la==Python3Parser.ELIF:
4045 self.state = 625
4046 self.match(Python3Parser.ELIF)
4047 self.state = 626
4048 self.test()
4049 self.state = 627
4050 self.match(Python3Parser.COLON)
4051 self.state = 628
4052 self.suite()
4053 self.state = 634
4054 self._errHandler.sync(self)
4055 _la = self._input.LA(1)
4057 self.state = 638
4058 self._errHandler.sync(self)
4059 _la = self._input.LA(1)
4060 if _la==Python3Parser.ELSE:
4061 self.state = 635
4062 self.match(Python3Parser.ELSE)
4063 self.state = 636
4064 self.match(Python3Parser.COLON)
4065 self.state = 637
4066 self.suite()
4069 except RecognitionException as re:
4070 localctx.exception = re
4071 self._errHandler.reportError(self, re)
4072 self._errHandler.recover(self, re)
4073 finally:
4074 self.exitRule()
4075 return localctx
4078 class While_stmtContext(ParserRuleContext):
4079 __slots__ = 'parser'
4081 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4082 super().__init__(parent, invokingState)
4083 self.parser = parser
4085 def WHILE(self):
4086 return self.getToken(Python3Parser.WHILE, 0)
4088 def test(self):
4089 return self.getTypedRuleContext(Python3Parser.TestContext,0)
4092 def COLON(self, i:int=None):
4093 if i is None:
4094 return self.getTokens(Python3Parser.COLON)
4095 else:
4096 return self.getToken(Python3Parser.COLON, i)
4098 def suite(self, i:int=None):
4099 if i is None:
4100 return self.getTypedRuleContexts(Python3Parser.SuiteContext)
4101 else:
4102 return self.getTypedRuleContext(Python3Parser.SuiteContext,i)
4105 def ELSE(self):
4106 return self.getToken(Python3Parser.ELSE, 0)
4108 def getRuleIndex(self):
4109 return Python3Parser.RULE_while_stmt
4111 def enterRule(self, listener:ParseTreeListener):
4112 if hasattr( listener, "enterWhile_stmt" ):
4113 listener.enterWhile_stmt(self)
4115 def exitRule(self, listener:ParseTreeListener):
4116 if hasattr( listener, "exitWhile_stmt" ):
4117 listener.exitWhile_stmt(self)
4122 def while_stmt(self):
4124 localctx = Python3Parser.While_stmtContext(self, self._ctx, self.state)
4125 self.enterRule(localctx, 84, self.RULE_while_stmt)
4126 self._la = 0 # Token type
4127 try:
4128 self.enterOuterAlt(localctx, 1)
4129 self.state = 640
4130 self.match(Python3Parser.WHILE)
4131 self.state = 641
4132 self.test()
4133 self.state = 642
4134 self.match(Python3Parser.COLON)
4135 self.state = 643
4136 self.suite()
4137 self.state = 647
4138 self._errHandler.sync(self)
4139 _la = self._input.LA(1)
4140 if _la==Python3Parser.ELSE:
4141 self.state = 644
4142 self.match(Python3Parser.ELSE)
4143 self.state = 645
4144 self.match(Python3Parser.COLON)
4145 self.state = 646
4146 self.suite()
4149 except RecognitionException as re:
4150 localctx.exception = re
4151 self._errHandler.reportError(self, re)
4152 self._errHandler.recover(self, re)
4153 finally:
4154 self.exitRule()
4155 return localctx
4158 class For_stmtContext(ParserRuleContext):
4159 __slots__ = 'parser'
4161 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4162 super().__init__(parent, invokingState)
4163 self.parser = parser
4165 def FOR(self):
4166 return self.getToken(Python3Parser.FOR, 0)
4168 def exprlist(self):
4169 return self.getTypedRuleContext(Python3Parser.ExprlistContext,0)
4172 def IN(self):
4173 return self.getToken(Python3Parser.IN, 0)
4175 def testlist(self):
4176 return self.getTypedRuleContext(Python3Parser.TestlistContext,0)
4179 def COLON(self, i:int=None):
4180 if i is None:
4181 return self.getTokens(Python3Parser.COLON)
4182 else:
4183 return self.getToken(Python3Parser.COLON, i)
4185 def suite(self, i:int=None):
4186 if i is None:
4187 return self.getTypedRuleContexts(Python3Parser.SuiteContext)
4188 else:
4189 return self.getTypedRuleContext(Python3Parser.SuiteContext,i)
4192 def ELSE(self):
4193 return self.getToken(Python3Parser.ELSE, 0)
4195 def getRuleIndex(self):
4196 return Python3Parser.RULE_for_stmt
4198 def enterRule(self, listener:ParseTreeListener):
4199 if hasattr( listener, "enterFor_stmt" ):
4200 listener.enterFor_stmt(self)
4202 def exitRule(self, listener:ParseTreeListener):
4203 if hasattr( listener, "exitFor_stmt" ):
4204 listener.exitFor_stmt(self)
4209 def for_stmt(self):
4211 localctx = Python3Parser.For_stmtContext(self, self._ctx, self.state)
4212 self.enterRule(localctx, 86, self.RULE_for_stmt)
4213 self._la = 0 # Token type
4214 try:
4215 self.enterOuterAlt(localctx, 1)
4216 self.state = 649
4217 self.match(Python3Parser.FOR)
4218 self.state = 650
4219 self.exprlist()
4220 self.state = 651
4221 self.match(Python3Parser.IN)
4222 self.state = 652
4223 self.testlist()
4224 self.state = 653
4225 self.match(Python3Parser.COLON)
4226 self.state = 654
4227 self.suite()
4228 self.state = 658
4229 self._errHandler.sync(self)
4230 _la = self._input.LA(1)
4231 if _la==Python3Parser.ELSE:
4232 self.state = 655
4233 self.match(Python3Parser.ELSE)
4234 self.state = 656
4235 self.match(Python3Parser.COLON)
4236 self.state = 657
4237 self.suite()
4240 except RecognitionException as re:
4241 localctx.exception = re
4242 self._errHandler.reportError(self, re)
4243 self._errHandler.recover(self, re)
4244 finally:
4245 self.exitRule()
4246 return localctx
4249 class Try_stmtContext(ParserRuleContext):
4250 __slots__ = 'parser'
4252 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4253 super().__init__(parent, invokingState)
4254 self.parser = parser
4256 def TRY(self):
4257 return self.getToken(Python3Parser.TRY, 0)
4259 def COLON(self, i:int=None):
4260 if i is None:
4261 return self.getTokens(Python3Parser.COLON)
4262 else:
4263 return self.getToken(Python3Parser.COLON, i)
4265 def suite(self, i:int=None):
4266 if i is None:
4267 return self.getTypedRuleContexts(Python3Parser.SuiteContext)
4268 else:
4269 return self.getTypedRuleContext(Python3Parser.SuiteContext,i)
4272 def FINALLY(self):
4273 return self.getToken(Python3Parser.FINALLY, 0)
4275 def except_clause(self, i:int=None):
4276 if i is None:
4277 return self.getTypedRuleContexts(Python3Parser.Except_clauseContext)
4278 else:
4279 return self.getTypedRuleContext(Python3Parser.Except_clauseContext,i)
4282 def ELSE(self):
4283 return self.getToken(Python3Parser.ELSE, 0)
4285 def getRuleIndex(self):
4286 return Python3Parser.RULE_try_stmt
4288 def enterRule(self, listener:ParseTreeListener):
4289 if hasattr( listener, "enterTry_stmt" ):
4290 listener.enterTry_stmt(self)
4292 def exitRule(self, listener:ParseTreeListener):
4293 if hasattr( listener, "exitTry_stmt" ):
4294 listener.exitTry_stmt(self)
4299 def try_stmt(self):
4301 localctx = Python3Parser.Try_stmtContext(self, self._ctx, self.state)
4302 self.enterRule(localctx, 88, self.RULE_try_stmt)
4303 self._la = 0 # Token type
4304 try:
4305 self.enterOuterAlt(localctx, 1)
4306 self.state = 660
4307 self.match(Python3Parser.TRY)
4308 self.state = 661
4309 self.match(Python3Parser.COLON)
4310 self.state = 662
4311 self.suite()
4312 self.state = 684
4313 self._errHandler.sync(self)
4314 token = self._input.LA(1)
4315 if token in [Python3Parser.EXCEPT]:
4316 self.state = 667
4317 self._errHandler.sync(self)
4318 _la = self._input.LA(1)
4319 while True:
4320 self.state = 663
4321 self.except_clause()
4322 self.state = 664
4323 self.match(Python3Parser.COLON)
4324 self.state = 665
4325 self.suite()
4326 self.state = 669
4327 self._errHandler.sync(self)
4328 _la = self._input.LA(1)
4329 if not (_la==Python3Parser.EXCEPT):
4330 break
4332 self.state = 674
4333 self._errHandler.sync(self)
4334 _la = self._input.LA(1)
4335 if _la==Python3Parser.ELSE:
4336 self.state = 671
4337 self.match(Python3Parser.ELSE)
4338 self.state = 672
4339 self.match(Python3Parser.COLON)
4340 self.state = 673
4341 self.suite()
4344 self.state = 679
4345 self._errHandler.sync(self)
4346 _la = self._input.LA(1)
4347 if _la==Python3Parser.FINALLY:
4348 self.state = 676
4349 self.match(Python3Parser.FINALLY)
4350 self.state = 677
4351 self.match(Python3Parser.COLON)
4352 self.state = 678
4353 self.suite()
4356 pass
4357 elif token in [Python3Parser.FINALLY]:
4358 self.state = 681
4359 self.match(Python3Parser.FINALLY)
4360 self.state = 682
4361 self.match(Python3Parser.COLON)
4362 self.state = 683
4363 self.suite()
4364 pass
4365 else:
4366 raise NoViableAltException(self)
4368 except RecognitionException as re:
4369 localctx.exception = re
4370 self._errHandler.reportError(self, re)
4371 self._errHandler.recover(self, re)
4372 finally:
4373 self.exitRule()
4374 return localctx
4377 class With_stmtContext(ParserRuleContext):
4378 __slots__ = 'parser'
4380 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4381 super().__init__(parent, invokingState)
4382 self.parser = parser
4384 def WITH(self):
4385 return self.getToken(Python3Parser.WITH, 0)
4387 def with_item(self, i:int=None):
4388 if i is None:
4389 return self.getTypedRuleContexts(Python3Parser.With_itemContext)
4390 else:
4391 return self.getTypedRuleContext(Python3Parser.With_itemContext,i)
4394 def COLON(self):
4395 return self.getToken(Python3Parser.COLON, 0)
4397 def suite(self):
4398 return self.getTypedRuleContext(Python3Parser.SuiteContext,0)
4401 def COMMA(self, i:int=None):
4402 if i is None:
4403 return self.getTokens(Python3Parser.COMMA)
4404 else:
4405 return self.getToken(Python3Parser.COMMA, i)
4407 def getRuleIndex(self):
4408 return Python3Parser.RULE_with_stmt
4410 def enterRule(self, listener:ParseTreeListener):
4411 if hasattr( listener, "enterWith_stmt" ):
4412 listener.enterWith_stmt(self)
4414 def exitRule(self, listener:ParseTreeListener):
4415 if hasattr( listener, "exitWith_stmt" ):
4416 listener.exitWith_stmt(self)
4421 def with_stmt(self):
4423 localctx = Python3Parser.With_stmtContext(self, self._ctx, self.state)
4424 self.enterRule(localctx, 90, self.RULE_with_stmt)
4425 self._la = 0 # Token type
4426 try:
4427 self.enterOuterAlt(localctx, 1)
4428 self.state = 686
4429 self.match(Python3Parser.WITH)
4430 self.state = 687
4431 self.with_item()
4432 self.state = 692
4433 self._errHandler.sync(self)
4434 _la = self._input.LA(1)
4435 while _la==Python3Parser.COMMA:
4436 self.state = 688
4437 self.match(Python3Parser.COMMA)
4438 self.state = 689
4439 self.with_item()
4440 self.state = 694
4441 self._errHandler.sync(self)
4442 _la = self._input.LA(1)
4444 self.state = 695
4445 self.match(Python3Parser.COLON)
4446 self.state = 696
4447 self.suite()
4448 except RecognitionException as re:
4449 localctx.exception = re
4450 self._errHandler.reportError(self, re)
4451 self._errHandler.recover(self, re)
4452 finally:
4453 self.exitRule()
4454 return localctx
4457 class With_itemContext(ParserRuleContext):
4458 __slots__ = 'parser'
4460 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4461 super().__init__(parent, invokingState)
4462 self.parser = parser
4464 def test(self):
4465 return self.getTypedRuleContext(Python3Parser.TestContext,0)
4468 def AS(self):
4469 return self.getToken(Python3Parser.AS, 0)
4471 def expr(self):
4472 return self.getTypedRuleContext(Python3Parser.ExprContext,0)
4475 def getRuleIndex(self):
4476 return Python3Parser.RULE_with_item
4478 def enterRule(self, listener:ParseTreeListener):
4479 if hasattr( listener, "enterWith_item" ):
4480 listener.enterWith_item(self)
4482 def exitRule(self, listener:ParseTreeListener):
4483 if hasattr( listener, "exitWith_item" ):
4484 listener.exitWith_item(self)
4489 def with_item(self):
4491 localctx = Python3Parser.With_itemContext(self, self._ctx, self.state)
4492 self.enterRule(localctx, 92, self.RULE_with_item)
4493 self._la = 0 # Token type
4494 try:
4495 self.enterOuterAlt(localctx, 1)
4496 self.state = 698
4497 self.test()
4498 self.state = 701
4499 self._errHandler.sync(self)
4500 _la = self._input.LA(1)
4501 if _la==Python3Parser.AS:
4502 self.state = 699
4503 self.match(Python3Parser.AS)
4504 self.state = 700
4505 self.expr()
4508 except RecognitionException as re:
4509 localctx.exception = re
4510 self._errHandler.reportError(self, re)
4511 self._errHandler.recover(self, re)
4512 finally:
4513 self.exitRule()
4514 return localctx
4517 class Except_clauseContext(ParserRuleContext):
4518 __slots__ = 'parser'
4520 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4521 super().__init__(parent, invokingState)
4522 self.parser = parser
4524 def EXCEPT(self):
4525 return self.getToken(Python3Parser.EXCEPT, 0)
4527 def test(self):
4528 return self.getTypedRuleContext(Python3Parser.TestContext,0)
4531 def AS(self):
4532 return self.getToken(Python3Parser.AS, 0)
4534 def NAME(self):
4535 return self.getToken(Python3Parser.NAME, 0)
4537 def getRuleIndex(self):
4538 return Python3Parser.RULE_except_clause
4540 def enterRule(self, listener:ParseTreeListener):
4541 if hasattr( listener, "enterExcept_clause" ):
4542 listener.enterExcept_clause(self)
4544 def exitRule(self, listener:ParseTreeListener):
4545 if hasattr( listener, "exitExcept_clause" ):
4546 listener.exitExcept_clause(self)
4551 def except_clause(self):
4553 localctx = Python3Parser.Except_clauseContext(self, self._ctx, self.state)
4554 self.enterRule(localctx, 94, self.RULE_except_clause)
4555 self._la = 0 # Token type
4556 try:
4557 self.enterOuterAlt(localctx, 1)
4558 self.state = 703
4559 self.match(Python3Parser.EXCEPT)
4560 self.state = 709
4561 self._errHandler.sync(self)
4562 _la = self._input.LA(1)
4563 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0):
4564 self.state = 704
4565 self.test()
4566 self.state = 707
4567 self._errHandler.sync(self)
4568 _la = self._input.LA(1)
4569 if _la==Python3Parser.AS:
4570 self.state = 705
4571 self.match(Python3Parser.AS)
4572 self.state = 706
4573 self.match(Python3Parser.NAME)
4578 except RecognitionException as re:
4579 localctx.exception = re
4580 self._errHandler.reportError(self, re)
4581 self._errHandler.recover(self, re)
4582 finally:
4583 self.exitRule()
4584 return localctx
4587 class SuiteContext(ParserRuleContext):
4588 __slots__ = 'parser'
4590 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4591 super().__init__(parent, invokingState)
4592 self.parser = parser
4594 def simple_stmt(self):
4595 return self.getTypedRuleContext(Python3Parser.Simple_stmtContext,0)
4598 def NEWLINE(self):
4599 return self.getToken(Python3Parser.NEWLINE, 0)
4601 def INDENT(self):
4602 return self.getToken(Python3Parser.INDENT, 0)
4604 def DEDENT(self):
4605 return self.getToken(Python3Parser.DEDENT, 0)
4607 def stmt(self, i:int=None):
4608 if i is None:
4609 return self.getTypedRuleContexts(Python3Parser.StmtContext)
4610 else:
4611 return self.getTypedRuleContext(Python3Parser.StmtContext,i)
4614 def getRuleIndex(self):
4615 return Python3Parser.RULE_suite
4617 def enterRule(self, listener:ParseTreeListener):
4618 if hasattr( listener, "enterSuite" ):
4619 listener.enterSuite(self)
4621 def exitRule(self, listener:ParseTreeListener):
4622 if hasattr( listener, "exitSuite" ):
4623 listener.exitSuite(self)
4628 def suite(self):
4630 localctx = Python3Parser.SuiteContext(self, self._ctx, self.state)
4631 self.enterRule(localctx, 96, self.RULE_suite)
4632 self._la = 0 # Token type
4633 try:
4634 self.state = 721
4635 self._errHandler.sync(self)
4636 token = self._input.LA(1)
4637 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.RETURN, Python3Parser.RAISE, Python3Parser.FROM, Python3Parser.IMPORT, Python3Parser.GLOBAL, Python3Parser.NONLOCAL, Python3Parser.ASSERT, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.YIELD, Python3Parser.DEL, Python3Parser.PASS, Python3Parser.CONTINUE, Python3Parser.BREAK, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.STAR, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]:
4638 self.enterOuterAlt(localctx, 1)
4639 self.state = 711
4640 self.simple_stmt()
4641 pass
4642 elif token in [Python3Parser.NEWLINE]:
4643 self.enterOuterAlt(localctx, 2)
4644 self.state = 712
4645 self.match(Python3Parser.NEWLINE)
4646 self.state = 713
4647 self.match(Python3Parser.INDENT)
4648 self.state = 715
4649 self._errHandler.sync(self)
4650 _la = self._input.LA(1)
4651 while True:
4652 self.state = 714
4653 self.stmt()
4654 self.state = 717
4655 self._errHandler.sync(self)
4656 _la = self._input.LA(1)
4657 if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.DEF) | (1 << Python3Parser.RETURN) | (1 << Python3Parser.RAISE) | (1 << Python3Parser.FROM) | (1 << Python3Parser.IMPORT) | (1 << Python3Parser.GLOBAL) | (1 << Python3Parser.NONLOCAL) | (1 << Python3Parser.ASSERT) | (1 << Python3Parser.IF) | (1 << Python3Parser.WHILE) | (1 << Python3Parser.FOR) | (1 << Python3Parser.TRY) | (1 << Python3Parser.WITH) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.CLASS) | (1 << Python3Parser.YIELD) | (1 << Python3Parser.DEL) | (1 << Python3Parser.PASS) | (1 << Python3Parser.CONTINUE) | (1 << Python3Parser.BREAK) | (1 << Python3Parser.ASYNC) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.STAR) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)) | (1 << (Python3Parser.AT - 66)))) != 0)):
4658 break
4660 self.state = 719
4661 self.match(Python3Parser.DEDENT)
4662 pass
4663 else:
4664 raise NoViableAltException(self)
4666 except RecognitionException as re:
4667 localctx.exception = re
4668 self._errHandler.reportError(self, re)
4669 self._errHandler.recover(self, re)
4670 finally:
4671 self.exitRule()
4672 return localctx
4675 class TestContext(ParserRuleContext):
4676 __slots__ = 'parser'
4678 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4679 super().__init__(parent, invokingState)
4680 self.parser = parser
4682 def or_test(self, i:int=None):
4683 if i is None:
4684 return self.getTypedRuleContexts(Python3Parser.Or_testContext)
4685 else:
4686 return self.getTypedRuleContext(Python3Parser.Or_testContext,i)
4689 def IF(self):
4690 return self.getToken(Python3Parser.IF, 0)
4692 def ELSE(self):
4693 return self.getToken(Python3Parser.ELSE, 0)
4695 def test(self):
4696 return self.getTypedRuleContext(Python3Parser.TestContext,0)
4699 def lambdef(self):
4700 return self.getTypedRuleContext(Python3Parser.LambdefContext,0)
4703 def getRuleIndex(self):
4704 return Python3Parser.RULE_test
4706 def enterRule(self, listener:ParseTreeListener):
4707 if hasattr( listener, "enterTest" ):
4708 listener.enterTest(self)
4710 def exitRule(self, listener:ParseTreeListener):
4711 if hasattr( listener, "exitTest" ):
4712 listener.exitTest(self)
4717 def test(self):
4719 localctx = Python3Parser.TestContext(self, self._ctx, self.state)
4720 self.enterRule(localctx, 98, self.RULE_test)
4721 self._la = 0 # Token type
4722 try:
4723 self.state = 732
4724 self._errHandler.sync(self)
4725 token = self._input.LA(1)
4726 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]:
4727 self.enterOuterAlt(localctx, 1)
4728 self.state = 723
4729 self.or_test()
4730 self.state = 729
4731 self._errHandler.sync(self)
4732 _la = self._input.LA(1)
4733 if _la==Python3Parser.IF:
4734 self.state = 724
4735 self.match(Python3Parser.IF)
4736 self.state = 725
4737 self.or_test()
4738 self.state = 726
4739 self.match(Python3Parser.ELSE)
4740 self.state = 727
4741 self.test()
4744 pass
4745 elif token in [Python3Parser.LAMBDA]:
4746 self.enterOuterAlt(localctx, 2)
4747 self.state = 731
4748 self.lambdef()
4749 pass
4750 else:
4751 raise NoViableAltException(self)
4753 except RecognitionException as re:
4754 localctx.exception = re
4755 self._errHandler.reportError(self, re)
4756 self._errHandler.recover(self, re)
4757 finally:
4758 self.exitRule()
4759 return localctx
4762 class Test_nocondContext(ParserRuleContext):
4763 __slots__ = 'parser'
4765 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4766 super().__init__(parent, invokingState)
4767 self.parser = parser
4769 def or_test(self):
4770 return self.getTypedRuleContext(Python3Parser.Or_testContext,0)
4773 def lambdef_nocond(self):
4774 return self.getTypedRuleContext(Python3Parser.Lambdef_nocondContext,0)
4777 def getRuleIndex(self):
4778 return Python3Parser.RULE_test_nocond
4780 def enterRule(self, listener:ParseTreeListener):
4781 if hasattr( listener, "enterTest_nocond" ):
4782 listener.enterTest_nocond(self)
4784 def exitRule(self, listener:ParseTreeListener):
4785 if hasattr( listener, "exitTest_nocond" ):
4786 listener.exitTest_nocond(self)
4791 def test_nocond(self):
4793 localctx = Python3Parser.Test_nocondContext(self, self._ctx, self.state)
4794 self.enterRule(localctx, 100, self.RULE_test_nocond)
4795 try:
4796 self.state = 736
4797 self._errHandler.sync(self)
4798 token = self._input.LA(1)
4799 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]:
4800 self.enterOuterAlt(localctx, 1)
4801 self.state = 734
4802 self.or_test()
4803 pass
4804 elif token in [Python3Parser.LAMBDA]:
4805 self.enterOuterAlt(localctx, 2)
4806 self.state = 735
4807 self.lambdef_nocond()
4808 pass
4809 else:
4810 raise NoViableAltException(self)
4812 except RecognitionException as re:
4813 localctx.exception = re
4814 self._errHandler.reportError(self, re)
4815 self._errHandler.recover(self, re)
4816 finally:
4817 self.exitRule()
4818 return localctx
4821 class LambdefContext(ParserRuleContext):
4822 __slots__ = 'parser'
4824 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4825 super().__init__(parent, invokingState)
4826 self.parser = parser
4828 def LAMBDA(self):
4829 return self.getToken(Python3Parser.LAMBDA, 0)
4831 def COLON(self):
4832 return self.getToken(Python3Parser.COLON, 0)
4834 def test(self):
4835 return self.getTypedRuleContext(Python3Parser.TestContext,0)
4838 def varargslist(self):
4839 return self.getTypedRuleContext(Python3Parser.VarargslistContext,0)
4842 def getRuleIndex(self):
4843 return Python3Parser.RULE_lambdef
4845 def enterRule(self, listener:ParseTreeListener):
4846 if hasattr( listener, "enterLambdef" ):
4847 listener.enterLambdef(self)
4849 def exitRule(self, listener:ParseTreeListener):
4850 if hasattr( listener, "exitLambdef" ):
4851 listener.exitLambdef(self)
4856 def lambdef(self):
4858 localctx = Python3Parser.LambdefContext(self, self._ctx, self.state)
4859 self.enterRule(localctx, 102, self.RULE_lambdef)
4860 self._la = 0 # Token type
4861 try:
4862 self.enterOuterAlt(localctx, 1)
4863 self.state = 738
4864 self.match(Python3Parser.LAMBDA)
4865 self.state = 740
4866 self._errHandler.sync(self)
4867 _la = self._input.LA(1)
4868 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.NAME) | (1 << Python3Parser.STAR) | (1 << Python3Parser.POWER))) != 0):
4869 self.state = 739
4870 self.varargslist()
4873 self.state = 742
4874 self.match(Python3Parser.COLON)
4875 self.state = 743
4876 self.test()
4877 except RecognitionException as re:
4878 localctx.exception = re
4879 self._errHandler.reportError(self, re)
4880 self._errHandler.recover(self, re)
4881 finally:
4882 self.exitRule()
4883 return localctx
4886 class Lambdef_nocondContext(ParserRuleContext):
4887 __slots__ = 'parser'
4889 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4890 super().__init__(parent, invokingState)
4891 self.parser = parser
4893 def LAMBDA(self):
4894 return self.getToken(Python3Parser.LAMBDA, 0)
4896 def COLON(self):
4897 return self.getToken(Python3Parser.COLON, 0)
4899 def test_nocond(self):
4900 return self.getTypedRuleContext(Python3Parser.Test_nocondContext,0)
4903 def varargslist(self):
4904 return self.getTypedRuleContext(Python3Parser.VarargslistContext,0)
4907 def getRuleIndex(self):
4908 return Python3Parser.RULE_lambdef_nocond
4910 def enterRule(self, listener:ParseTreeListener):
4911 if hasattr( listener, "enterLambdef_nocond" ):
4912 listener.enterLambdef_nocond(self)
4914 def exitRule(self, listener:ParseTreeListener):
4915 if hasattr( listener, "exitLambdef_nocond" ):
4916 listener.exitLambdef_nocond(self)
4921 def lambdef_nocond(self):
4923 localctx = Python3Parser.Lambdef_nocondContext(self, self._ctx, self.state)
4924 self.enterRule(localctx, 104, self.RULE_lambdef_nocond)
4925 self._la = 0 # Token type
4926 try:
4927 self.enterOuterAlt(localctx, 1)
4928 self.state = 745
4929 self.match(Python3Parser.LAMBDA)
4930 self.state = 747
4931 self._errHandler.sync(self)
4932 _la = self._input.LA(1)
4933 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.NAME) | (1 << Python3Parser.STAR) | (1 << Python3Parser.POWER))) != 0):
4934 self.state = 746
4935 self.varargslist()
4938 self.state = 749
4939 self.match(Python3Parser.COLON)
4940 self.state = 750
4941 self.test_nocond()
4942 except RecognitionException as re:
4943 localctx.exception = re
4944 self._errHandler.reportError(self, re)
4945 self._errHandler.recover(self, re)
4946 finally:
4947 self.exitRule()
4948 return localctx
4951 class Or_testContext(ParserRuleContext):
4952 __slots__ = 'parser'
4954 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4955 super().__init__(parent, invokingState)
4956 self.parser = parser
4958 def and_test(self, i:int=None):
4959 if i is None:
4960 return self.getTypedRuleContexts(Python3Parser.And_testContext)
4961 else:
4962 return self.getTypedRuleContext(Python3Parser.And_testContext,i)
4965 def OR(self, i:int=None):
4966 if i is None:
4967 return self.getTokens(Python3Parser.OR)
4968 else:
4969 return self.getToken(Python3Parser.OR, i)
4971 def getRuleIndex(self):
4972 return Python3Parser.RULE_or_test
4974 def enterRule(self, listener:ParseTreeListener):
4975 if hasattr( listener, "enterOr_test" ):
4976 listener.enterOr_test(self)
4978 def exitRule(self, listener:ParseTreeListener):
4979 if hasattr( listener, "exitOr_test" ):
4980 listener.exitOr_test(self)
4985 def or_test(self):
4987 localctx = Python3Parser.Or_testContext(self, self._ctx, self.state)
4988 self.enterRule(localctx, 106, self.RULE_or_test)
4989 self._la = 0 # Token type
4990 try:
4991 self.enterOuterAlt(localctx, 1)
4992 self.state = 752
4993 self.and_test()
4994 self.state = 757
4995 self._errHandler.sync(self)
4996 _la = self._input.LA(1)
4997 while _la==Python3Parser.OR:
4998 self.state = 753
4999 self.match(Python3Parser.OR)
5000 self.state = 754
5001 self.and_test()
5002 self.state = 759
5003 self._errHandler.sync(self)
5004 _la = self._input.LA(1)
5006 except RecognitionException as re:
5007 localctx.exception = re
5008 self._errHandler.reportError(self, re)
5009 self._errHandler.recover(self, re)
5010 finally:
5011 self.exitRule()
5012 return localctx
5015 class And_testContext(ParserRuleContext):
5016 __slots__ = 'parser'
5018 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5019 super().__init__(parent, invokingState)
5020 self.parser = parser
5022 def not_test(self, i:int=None):
5023 if i is None:
5024 return self.getTypedRuleContexts(Python3Parser.Not_testContext)
5025 else:
5026 return self.getTypedRuleContext(Python3Parser.Not_testContext,i)
5029 def AND(self, i:int=None):
5030 if i is None:
5031 return self.getTokens(Python3Parser.AND)
5032 else:
5033 return self.getToken(Python3Parser.AND, i)
5035 def getRuleIndex(self):
5036 return Python3Parser.RULE_and_test
5038 def enterRule(self, listener:ParseTreeListener):
5039 if hasattr( listener, "enterAnd_test" ):
5040 listener.enterAnd_test(self)
5042 def exitRule(self, listener:ParseTreeListener):
5043 if hasattr( listener, "exitAnd_test" ):
5044 listener.exitAnd_test(self)
5049 def and_test(self):
5051 localctx = Python3Parser.And_testContext(self, self._ctx, self.state)
5052 self.enterRule(localctx, 108, self.RULE_and_test)
5053 self._la = 0 # Token type
5054 try:
5055 self.enterOuterAlt(localctx, 1)
5056 self.state = 760
5057 self.not_test()
5058 self.state = 765
5059 self._errHandler.sync(self)
5060 _la = self._input.LA(1)
5061 while _la==Python3Parser.AND:
5062 self.state = 761
5063 self.match(Python3Parser.AND)
5064 self.state = 762
5065 self.not_test()
5066 self.state = 767
5067 self._errHandler.sync(self)
5068 _la = self._input.LA(1)
5070 except RecognitionException as re:
5071 localctx.exception = re
5072 self._errHandler.reportError(self, re)
5073 self._errHandler.recover(self, re)
5074 finally:
5075 self.exitRule()
5076 return localctx
5079 class Not_testContext(ParserRuleContext):
5080 __slots__ = 'parser'
5082 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5083 super().__init__(parent, invokingState)
5084 self.parser = parser
5086 def NOT(self):
5087 return self.getToken(Python3Parser.NOT, 0)
5089 def not_test(self):
5090 return self.getTypedRuleContext(Python3Parser.Not_testContext,0)
5093 def comparison(self):
5094 return self.getTypedRuleContext(Python3Parser.ComparisonContext,0)
5097 def getRuleIndex(self):
5098 return Python3Parser.RULE_not_test
5100 def enterRule(self, listener:ParseTreeListener):
5101 if hasattr( listener, "enterNot_test" ):
5102 listener.enterNot_test(self)
5104 def exitRule(self, listener:ParseTreeListener):
5105 if hasattr( listener, "exitNot_test" ):
5106 listener.exitNot_test(self)
5111 def not_test(self):
5113 localctx = Python3Parser.Not_testContext(self, self._ctx, self.state)
5114 self.enterRule(localctx, 110, self.RULE_not_test)
5115 try:
5116 self.state = 771
5117 self._errHandler.sync(self)
5118 token = self._input.LA(1)
5119 if token in [Python3Parser.NOT]:
5120 self.enterOuterAlt(localctx, 1)
5121 self.state = 768
5122 self.match(Python3Parser.NOT)
5123 self.state = 769
5124 self.not_test()
5125 pass
5126 elif token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]:
5127 self.enterOuterAlt(localctx, 2)
5128 self.state = 770
5129 self.comparison()
5130 pass
5131 else:
5132 raise NoViableAltException(self)
5134 except RecognitionException as re:
5135 localctx.exception = re
5136 self._errHandler.reportError(self, re)
5137 self._errHandler.recover(self, re)
5138 finally:
5139 self.exitRule()
5140 return localctx
5143 class ComparisonContext(ParserRuleContext):
5144 __slots__ = 'parser'
5146 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5147 super().__init__(parent, invokingState)
5148 self.parser = parser
5150 def expr(self, i:int=None):
5151 if i is None:
5152 return self.getTypedRuleContexts(Python3Parser.ExprContext)
5153 else:
5154 return self.getTypedRuleContext(Python3Parser.ExprContext,i)
5157 def comp_op(self, i:int=None):
5158 if i is None:
5159 return self.getTypedRuleContexts(Python3Parser.Comp_opContext)
5160 else:
5161 return self.getTypedRuleContext(Python3Parser.Comp_opContext,i)
5164 def getRuleIndex(self):
5165 return Python3Parser.RULE_comparison
5167 def enterRule(self, listener:ParseTreeListener):
5168 if hasattr( listener, "enterComparison" ):
5169 listener.enterComparison(self)
5171 def exitRule(self, listener:ParseTreeListener):
5172 if hasattr( listener, "exitComparison" ):
5173 listener.exitComparison(self)
5178 def comparison(self):
5180 localctx = Python3Parser.ComparisonContext(self, self._ctx, self.state)
5181 self.enterRule(localctx, 112, self.RULE_comparison)
5182 self._la = 0 # Token type
5183 try:
5184 self.enterOuterAlt(localctx, 1)
5185 self.state = 773
5186 self.expr()
5187 self.state = 779
5188 self._errHandler.sync(self)
5189 _la = self._input.LA(1)
5190 while ((((_la - 18)) & ~0x3f) == 0 and ((1 << (_la - 18)) & ((1 << (Python3Parser.IN - 18)) | (1 << (Python3Parser.NOT - 18)) | (1 << (Python3Parser.IS - 18)) | (1 << (Python3Parser.LESS_THAN - 18)) | (1 << (Python3Parser.GREATER_THAN - 18)) | (1 << (Python3Parser.EQUALS - 18)) | (1 << (Python3Parser.GT_EQ - 18)) | (1 << (Python3Parser.LT_EQ - 18)) | (1 << (Python3Parser.NOT_EQ_1 - 18)) | (1 << (Python3Parser.NOT_EQ_2 - 18)))) != 0):
5191 self.state = 774
5192 self.comp_op()
5193 self.state = 775
5194 self.expr()
5195 self.state = 781
5196 self._errHandler.sync(self)
5197 _la = self._input.LA(1)
5199 except RecognitionException as re:
5200 localctx.exception = re
5201 self._errHandler.reportError(self, re)
5202 self._errHandler.recover(self, re)
5203 finally:
5204 self.exitRule()
5205 return localctx
5208 class Comp_opContext(ParserRuleContext):
5209 __slots__ = 'parser'
5211 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5212 super().__init__(parent, invokingState)
5213 self.parser = parser
5215 def LESS_THAN(self):
5216 return self.getToken(Python3Parser.LESS_THAN, 0)
5218 def GREATER_THAN(self):
5219 return self.getToken(Python3Parser.GREATER_THAN, 0)
5221 def EQUALS(self):
5222 return self.getToken(Python3Parser.EQUALS, 0)
5224 def GT_EQ(self):
5225 return self.getToken(Python3Parser.GT_EQ, 0)
5227 def LT_EQ(self):
5228 return self.getToken(Python3Parser.LT_EQ, 0)
5230 def NOT_EQ_1(self):
5231 return self.getToken(Python3Parser.NOT_EQ_1, 0)
5233 def NOT_EQ_2(self):
5234 return self.getToken(Python3Parser.NOT_EQ_2, 0)
5236 def IN(self):
5237 return self.getToken(Python3Parser.IN, 0)
5239 def NOT(self):
5240 return self.getToken(Python3Parser.NOT, 0)
5242 def IS(self):
5243 return self.getToken(Python3Parser.IS, 0)
5245 def getRuleIndex(self):
5246 return Python3Parser.RULE_comp_op
5248 def enterRule(self, listener:ParseTreeListener):
5249 if hasattr( listener, "enterComp_op" ):
5250 listener.enterComp_op(self)
5252 def exitRule(self, listener:ParseTreeListener):
5253 if hasattr( listener, "exitComp_op" ):
5254 listener.exitComp_op(self)
5259 def comp_op(self):
5261 localctx = Python3Parser.Comp_opContext(self, self._ctx, self.state)
5262 self.enterRule(localctx, 114, self.RULE_comp_op)
5263 try:
5264 self.state = 795
5265 self._errHandler.sync(self)
5266 la_ = self._interp.adaptivePredict(self._input,107,self._ctx)
5267 if la_ == 1:
5268 self.enterOuterAlt(localctx, 1)
5269 self.state = 782
5270 self.match(Python3Parser.LESS_THAN)
5271 pass
5273 elif la_ == 2:
5274 self.enterOuterAlt(localctx, 2)
5275 self.state = 783
5276 self.match(Python3Parser.GREATER_THAN)
5277 pass
5279 elif la_ == 3:
5280 self.enterOuterAlt(localctx, 3)
5281 self.state = 784
5282 self.match(Python3Parser.EQUALS)
5283 pass
5285 elif la_ == 4:
5286 self.enterOuterAlt(localctx, 4)
5287 self.state = 785
5288 self.match(Python3Parser.GT_EQ)
5289 pass
5291 elif la_ == 5:
5292 self.enterOuterAlt(localctx, 5)
5293 self.state = 786
5294 self.match(Python3Parser.LT_EQ)
5295 pass
5297 elif la_ == 6:
5298 self.enterOuterAlt(localctx, 6)
5299 self.state = 787
5300 self.match(Python3Parser.NOT_EQ_1)
5301 pass
5303 elif la_ == 7:
5304 self.enterOuterAlt(localctx, 7)
5305 self.state = 788
5306 self.match(Python3Parser.NOT_EQ_2)
5307 pass
5309 elif la_ == 8:
5310 self.enterOuterAlt(localctx, 8)
5311 self.state = 789
5312 self.match(Python3Parser.IN)
5313 pass
5315 elif la_ == 9:
5316 self.enterOuterAlt(localctx, 9)
5317 self.state = 790
5318 self.match(Python3Parser.NOT)
5319 self.state = 791
5320 self.match(Python3Parser.IN)
5321 pass
5323 elif la_ == 10:
5324 self.enterOuterAlt(localctx, 10)
5325 self.state = 792
5326 self.match(Python3Parser.IS)
5327 pass
5329 elif la_ == 11:
5330 self.enterOuterAlt(localctx, 11)
5331 self.state = 793
5332 self.match(Python3Parser.IS)
5333 self.state = 794
5334 self.match(Python3Parser.NOT)
5335 pass
5338 except RecognitionException as re:
5339 localctx.exception = re
5340 self._errHandler.reportError(self, re)
5341 self._errHandler.recover(self, re)
5342 finally:
5343 self.exitRule()
5344 return localctx
5347 class Star_exprContext(ParserRuleContext):
5348 __slots__ = 'parser'
5350 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5351 super().__init__(parent, invokingState)
5352 self.parser = parser
5354 def STAR(self):
5355 return self.getToken(Python3Parser.STAR, 0)
5357 def expr(self):
5358 return self.getTypedRuleContext(Python3Parser.ExprContext,0)
5361 def getRuleIndex(self):
5362 return Python3Parser.RULE_star_expr
5364 def enterRule(self, listener:ParseTreeListener):
5365 if hasattr( listener, "enterStar_expr" ):
5366 listener.enterStar_expr(self)
5368 def exitRule(self, listener:ParseTreeListener):
5369 if hasattr( listener, "exitStar_expr" ):
5370 listener.exitStar_expr(self)
5375 def star_expr(self):
5377 localctx = Python3Parser.Star_exprContext(self, self._ctx, self.state)
5378 self.enterRule(localctx, 116, self.RULE_star_expr)
5379 try:
5380 self.enterOuterAlt(localctx, 1)
5381 self.state = 797
5382 self.match(Python3Parser.STAR)
5383 self.state = 798
5384 self.expr()
5385 except RecognitionException as re:
5386 localctx.exception = re
5387 self._errHandler.reportError(self, re)
5388 self._errHandler.recover(self, re)
5389 finally:
5390 self.exitRule()
5391 return localctx
5394 class ExprContext(ParserRuleContext):
5395 __slots__ = 'parser'
5397 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5398 super().__init__(parent, invokingState)
5399 self.parser = parser
5401 def xor_expr(self, i:int=None):
5402 if i is None:
5403 return self.getTypedRuleContexts(Python3Parser.Xor_exprContext)
5404 else:
5405 return self.getTypedRuleContext(Python3Parser.Xor_exprContext,i)
5408 def OR_OP(self, i:int=None):
5409 if i is None:
5410 return self.getTokens(Python3Parser.OR_OP)
5411 else:
5412 return self.getToken(Python3Parser.OR_OP, i)
5414 def getRuleIndex(self):
5415 return Python3Parser.RULE_expr
5417 def enterRule(self, listener:ParseTreeListener):
5418 if hasattr( listener, "enterExpr" ):
5419 listener.enterExpr(self)
5421 def exitRule(self, listener:ParseTreeListener):
5422 if hasattr( listener, "exitExpr" ):
5423 listener.exitExpr(self)
5428 def expr(self):
5430 localctx = Python3Parser.ExprContext(self, self._ctx, self.state)
5431 self.enterRule(localctx, 118, self.RULE_expr)
5432 self._la = 0 # Token type
5433 try:
5434 self.enterOuterAlt(localctx, 1)
5435 self.state = 800
5436 self.xor_expr()
5437 self.state = 805
5438 self._errHandler.sync(self)
5439 _la = self._input.LA(1)
5440 while _la==Python3Parser.OR_OP:
5441 self.state = 801
5442 self.match(Python3Parser.OR_OP)
5443 self.state = 802
5444 self.xor_expr()
5445 self.state = 807
5446 self._errHandler.sync(self)
5447 _la = self._input.LA(1)
5449 except RecognitionException as re:
5450 localctx.exception = re
5451 self._errHandler.reportError(self, re)
5452 self._errHandler.recover(self, re)
5453 finally:
5454 self.exitRule()
5455 return localctx
5458 class Xor_exprContext(ParserRuleContext):
5459 __slots__ = 'parser'
5461 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5462 super().__init__(parent, invokingState)
5463 self.parser = parser
5465 def and_expr(self, i:int=None):
5466 if i is None:
5467 return self.getTypedRuleContexts(Python3Parser.And_exprContext)
5468 else:
5469 return self.getTypedRuleContext(Python3Parser.And_exprContext,i)
5472 def XOR(self, i:int=None):
5473 if i is None:
5474 return self.getTokens(Python3Parser.XOR)
5475 else:
5476 return self.getToken(Python3Parser.XOR, i)
5478 def getRuleIndex(self):
5479 return Python3Parser.RULE_xor_expr
5481 def enterRule(self, listener:ParseTreeListener):
5482 if hasattr( listener, "enterXor_expr" ):
5483 listener.enterXor_expr(self)
5485 def exitRule(self, listener:ParseTreeListener):
5486 if hasattr( listener, "exitXor_expr" ):
5487 listener.exitXor_expr(self)
5492 def xor_expr(self):
5494 localctx = Python3Parser.Xor_exprContext(self, self._ctx, self.state)
5495 self.enterRule(localctx, 120, self.RULE_xor_expr)
5496 self._la = 0 # Token type
5497 try:
5498 self.enterOuterAlt(localctx, 1)
5499 self.state = 808
5500 self.and_expr()
5501 self.state = 813
5502 self._errHandler.sync(self)
5503 _la = self._input.LA(1)
5504 while _la==Python3Parser.XOR:
5505 self.state = 809
5506 self.match(Python3Parser.XOR)
5507 self.state = 810
5508 self.and_expr()
5509 self.state = 815
5510 self._errHandler.sync(self)
5511 _la = self._input.LA(1)
5513 except RecognitionException as re:
5514 localctx.exception = re
5515 self._errHandler.reportError(self, re)
5516 self._errHandler.recover(self, re)
5517 finally:
5518 self.exitRule()
5519 return localctx
5522 class And_exprContext(ParserRuleContext):
5523 __slots__ = 'parser'
5525 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5526 super().__init__(parent, invokingState)
5527 self.parser = parser
5529 def shift_expr(self, i:int=None):
5530 if i is None:
5531 return self.getTypedRuleContexts(Python3Parser.Shift_exprContext)
5532 else:
5533 return self.getTypedRuleContext(Python3Parser.Shift_exprContext,i)
5536 def AND_OP(self, i:int=None):
5537 if i is None:
5538 return self.getTokens(Python3Parser.AND_OP)
5539 else:
5540 return self.getToken(Python3Parser.AND_OP, i)
5542 def getRuleIndex(self):
5543 return Python3Parser.RULE_and_expr
5545 def enterRule(self, listener:ParseTreeListener):
5546 if hasattr( listener, "enterAnd_expr" ):
5547 listener.enterAnd_expr(self)
5549 def exitRule(self, listener:ParseTreeListener):
5550 if hasattr( listener, "exitAnd_expr" ):
5551 listener.exitAnd_expr(self)
5556 def and_expr(self):
5558 localctx = Python3Parser.And_exprContext(self, self._ctx, self.state)
5559 self.enterRule(localctx, 122, self.RULE_and_expr)
5560 self._la = 0 # Token type
5561 try:
5562 self.enterOuterAlt(localctx, 1)
5563 self.state = 816
5564 self.shift_expr()
5565 self.state = 821
5566 self._errHandler.sync(self)
5567 _la = self._input.LA(1)
5568 while _la==Python3Parser.AND_OP:
5569 self.state = 817
5570 self.match(Python3Parser.AND_OP)
5571 self.state = 818
5572 self.shift_expr()
5573 self.state = 823
5574 self._errHandler.sync(self)
5575 _la = self._input.LA(1)
5577 except RecognitionException as re:
5578 localctx.exception = re
5579 self._errHandler.reportError(self, re)
5580 self._errHandler.recover(self, re)
5581 finally:
5582 self.exitRule()
5583 return localctx
5586 class Shift_exprContext(ParserRuleContext):
5587 __slots__ = 'parser'
5589 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5590 super().__init__(parent, invokingState)
5591 self.parser = parser
5593 def arith_expr(self, i:int=None):
5594 if i is None:
5595 return self.getTypedRuleContexts(Python3Parser.Arith_exprContext)
5596 else:
5597 return self.getTypedRuleContext(Python3Parser.Arith_exprContext,i)
5600 def LEFT_SHIFT(self, i:int=None):
5601 if i is None:
5602 return self.getTokens(Python3Parser.LEFT_SHIFT)
5603 else:
5604 return self.getToken(Python3Parser.LEFT_SHIFT, i)
5606 def RIGHT_SHIFT(self, i:int=None):
5607 if i is None:
5608 return self.getTokens(Python3Parser.RIGHT_SHIFT)
5609 else:
5610 return self.getToken(Python3Parser.RIGHT_SHIFT, i)
5612 def getRuleIndex(self):
5613 return Python3Parser.RULE_shift_expr
5615 def enterRule(self, listener:ParseTreeListener):
5616 if hasattr( listener, "enterShift_expr" ):
5617 listener.enterShift_expr(self)
5619 def exitRule(self, listener:ParseTreeListener):
5620 if hasattr( listener, "exitShift_expr" ):
5621 listener.exitShift_expr(self)
5626 def shift_expr(self):
5628 localctx = Python3Parser.Shift_exprContext(self, self._ctx, self.state)
5629 self.enterRule(localctx, 124, self.RULE_shift_expr)
5630 self._la = 0 # Token type
5631 try:
5632 self.enterOuterAlt(localctx, 1)
5633 self.state = 824
5634 self.arith_expr()
5635 self.state = 829
5636 self._errHandler.sync(self)
5637 _la = self._input.LA(1)
5638 while _la==Python3Parser.LEFT_SHIFT or _la==Python3Parser.RIGHT_SHIFT:
5639 self.state = 825
5640 _la = self._input.LA(1)
5641 if not(_la==Python3Parser.LEFT_SHIFT or _la==Python3Parser.RIGHT_SHIFT):
5642 self._errHandler.recoverInline(self)
5643 else:
5644 self._errHandler.reportMatch(self)
5645 self.consume()
5646 self.state = 826
5647 self.arith_expr()
5648 self.state = 831
5649 self._errHandler.sync(self)
5650 _la = self._input.LA(1)
5652 except RecognitionException as re:
5653 localctx.exception = re
5654 self._errHandler.reportError(self, re)
5655 self._errHandler.recover(self, re)
5656 finally:
5657 self.exitRule()
5658 return localctx
5661 class Arith_exprContext(ParserRuleContext):
5662 __slots__ = 'parser'
5664 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5665 super().__init__(parent, invokingState)
5666 self.parser = parser
5668 def term(self, i:int=None):
5669 if i is None:
5670 return self.getTypedRuleContexts(Python3Parser.TermContext)
5671 else:
5672 return self.getTypedRuleContext(Python3Parser.TermContext,i)
5675 def ADD(self, i:int=None):
5676 if i is None:
5677 return self.getTokens(Python3Parser.ADD)
5678 else:
5679 return self.getToken(Python3Parser.ADD, i)
5681 def MINUS(self, i:int=None):
5682 if i is None:
5683 return self.getTokens(Python3Parser.MINUS)
5684 else:
5685 return self.getToken(Python3Parser.MINUS, i)
5687 def getRuleIndex(self):
5688 return Python3Parser.RULE_arith_expr
5690 def enterRule(self, listener:ParseTreeListener):
5691 if hasattr( listener, "enterArith_expr" ):
5692 listener.enterArith_expr(self)
5694 def exitRule(self, listener:ParseTreeListener):
5695 if hasattr( listener, "exitArith_expr" ):
5696 listener.exitArith_expr(self)
5701 def arith_expr(self):
5703 localctx = Python3Parser.Arith_exprContext(self, self._ctx, self.state)
5704 self.enterRule(localctx, 126, self.RULE_arith_expr)
5705 self._la = 0 # Token type
5706 try:
5707 self.enterOuterAlt(localctx, 1)
5708 self.state = 832
5709 self.term()
5710 self.state = 837
5711 self._errHandler.sync(self)
5712 _la = self._input.LA(1)
5713 while _la==Python3Parser.ADD or _la==Python3Parser.MINUS:
5714 self.state = 833
5715 _la = self._input.LA(1)
5716 if not(_la==Python3Parser.ADD or _la==Python3Parser.MINUS):
5717 self._errHandler.recoverInline(self)
5718 else:
5719 self._errHandler.reportMatch(self)
5720 self.consume()
5721 self.state = 834
5722 self.term()
5723 self.state = 839
5724 self._errHandler.sync(self)
5725 _la = self._input.LA(1)
5727 except RecognitionException as re:
5728 localctx.exception = re
5729 self._errHandler.reportError(self, re)
5730 self._errHandler.recover(self, re)
5731 finally:
5732 self.exitRule()
5733 return localctx
5736 class TermContext(ParserRuleContext):
5737 __slots__ = 'parser'
5739 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5740 super().__init__(parent, invokingState)
5741 self.parser = parser
5743 def factor(self, i:int=None):
5744 if i is None:
5745 return self.getTypedRuleContexts(Python3Parser.FactorContext)
5746 else:
5747 return self.getTypedRuleContext(Python3Parser.FactorContext,i)
5750 def STAR(self, i:int=None):
5751 if i is None:
5752 return self.getTokens(Python3Parser.STAR)
5753 else:
5754 return self.getToken(Python3Parser.STAR, i)
5756 def AT(self, i:int=None):
5757 if i is None:
5758 return self.getTokens(Python3Parser.AT)
5759 else:
5760 return self.getToken(Python3Parser.AT, i)
5762 def DIV(self, i:int=None):
5763 if i is None:
5764 return self.getTokens(Python3Parser.DIV)
5765 else:
5766 return self.getToken(Python3Parser.DIV, i)
5768 def MOD(self, i:int=None):
5769 if i is None:
5770 return self.getTokens(Python3Parser.MOD)
5771 else:
5772 return self.getToken(Python3Parser.MOD, i)
5774 def IDIV(self, i:int=None):
5775 if i is None:
5776 return self.getTokens(Python3Parser.IDIV)
5777 else:
5778 return self.getToken(Python3Parser.IDIV, i)
5780 def getRuleIndex(self):
5781 return Python3Parser.RULE_term
5783 def enterRule(self, listener:ParseTreeListener):
5784 if hasattr( listener, "enterTerm" ):
5785 listener.enterTerm(self)
5787 def exitRule(self, listener:ParseTreeListener):
5788 if hasattr( listener, "exitTerm" ):
5789 listener.exitTerm(self)
5794 def term(self):
5796 localctx = Python3Parser.TermContext(self, self._ctx, self.state)
5797 self.enterRule(localctx, 128, self.RULE_term)
5798 self._la = 0 # Token type
5799 try:
5800 self.enterOuterAlt(localctx, 1)
5801 self.state = 840
5802 self.factor()
5803 self.state = 845
5804 self._errHandler.sync(self)
5805 _la = self._input.LA(1)
5806 while ((((_la - 51)) & ~0x3f) == 0 and ((1 << (_la - 51)) & ((1 << (Python3Parser.STAR - 51)) | (1 << (Python3Parser.DIV - 51)) | (1 << (Python3Parser.MOD - 51)) | (1 << (Python3Parser.IDIV - 51)) | (1 << (Python3Parser.AT - 51)))) != 0):
5807 self.state = 841
5808 _la = self._input.LA(1)
5809 if not(((((_la - 51)) & ~0x3f) == 0 and ((1 << (_la - 51)) & ((1 << (Python3Parser.STAR - 51)) | (1 << (Python3Parser.DIV - 51)) | (1 << (Python3Parser.MOD - 51)) | (1 << (Python3Parser.IDIV - 51)) | (1 << (Python3Parser.AT - 51)))) != 0)):
5810 self._errHandler.recoverInline(self)
5811 else:
5812 self._errHandler.reportMatch(self)
5813 self.consume()
5814 self.state = 842
5815 self.factor()
5816 self.state = 847
5817 self._errHandler.sync(self)
5818 _la = self._input.LA(1)
5820 except RecognitionException as re:
5821 localctx.exception = re
5822 self._errHandler.reportError(self, re)
5823 self._errHandler.recover(self, re)
5824 finally:
5825 self.exitRule()
5826 return localctx
5829 class FactorContext(ParserRuleContext):
5830 __slots__ = 'parser'
5832 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5833 super().__init__(parent, invokingState)
5834 self.parser = parser
5836 def factor(self):
5837 return self.getTypedRuleContext(Python3Parser.FactorContext,0)
5840 def ADD(self):
5841 return self.getToken(Python3Parser.ADD, 0)
5843 def MINUS(self):
5844 return self.getToken(Python3Parser.MINUS, 0)
5846 def NOT_OP(self):
5847 return self.getToken(Python3Parser.NOT_OP, 0)
5849 def power(self):
5850 return self.getTypedRuleContext(Python3Parser.PowerContext,0)
5853 def getRuleIndex(self):
5854 return Python3Parser.RULE_factor
5856 def enterRule(self, listener:ParseTreeListener):
5857 if hasattr( listener, "enterFactor" ):
5858 listener.enterFactor(self)
5860 def exitRule(self, listener:ParseTreeListener):
5861 if hasattr( listener, "exitFactor" ):
5862 listener.exitFactor(self)
5867 def factor(self):
5869 localctx = Python3Parser.FactorContext(self, self._ctx, self.state)
5870 self.enterRule(localctx, 130, self.RULE_factor)
5871 self._la = 0 # Token type
5872 try:
5873 self.state = 851
5874 self._errHandler.sync(self)
5875 token = self._input.LA(1)
5876 if token in [Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP]:
5877 self.enterOuterAlt(localctx, 1)
5878 self.state = 848
5879 _la = self._input.LA(1)
5880 if not(((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)))) != 0)):
5881 self._errHandler.recoverInline(self)
5882 else:
5883 self._errHandler.reportMatch(self)
5884 self.consume()
5885 self.state = 849
5886 self.factor()
5887 pass
5888 elif token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.OPEN_BRACE]:
5889 self.enterOuterAlt(localctx, 2)
5890 self.state = 850
5891 self.power()
5892 pass
5893 else:
5894 raise NoViableAltException(self)
5896 except RecognitionException as re:
5897 localctx.exception = re
5898 self._errHandler.reportError(self, re)
5899 self._errHandler.recover(self, re)
5900 finally:
5901 self.exitRule()
5902 return localctx
5905 class PowerContext(ParserRuleContext):
5906 __slots__ = 'parser'
5908 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5909 super().__init__(parent, invokingState)
5910 self.parser = parser
5912 def atom_expr(self):
5913 return self.getTypedRuleContext(Python3Parser.Atom_exprContext,0)
5916 def POWER(self):
5917 return self.getToken(Python3Parser.POWER, 0)
5919 def factor(self):
5920 return self.getTypedRuleContext(Python3Parser.FactorContext,0)
5923 def getRuleIndex(self):
5924 return Python3Parser.RULE_power
5926 def enterRule(self, listener:ParseTreeListener):
5927 if hasattr( listener, "enterPower" ):
5928 listener.enterPower(self)
5930 def exitRule(self, listener:ParseTreeListener):
5931 if hasattr( listener, "exitPower" ):
5932 listener.exitPower(self)
5937 def power(self):
5939 localctx = Python3Parser.PowerContext(self, self._ctx, self.state)
5940 self.enterRule(localctx, 132, self.RULE_power)
5941 self._la = 0 # Token type
5942 try:
5943 self.enterOuterAlt(localctx, 1)
5944 self.state = 853
5945 self.atom_expr()
5946 self.state = 856
5947 self._errHandler.sync(self)
5948 _la = self._input.LA(1)
5949 if _la==Python3Parser.POWER:
5950 self.state = 854
5951 self.match(Python3Parser.POWER)
5952 self.state = 855
5953 self.factor()
5956 except RecognitionException as re:
5957 localctx.exception = re
5958 self._errHandler.reportError(self, re)
5959 self._errHandler.recover(self, re)
5960 finally:
5961 self.exitRule()
5962 return localctx
5965 class Atom_exprContext(ParserRuleContext):
5966 __slots__ = 'parser'
5968 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5969 super().__init__(parent, invokingState)
5970 self.parser = parser
5972 def atom(self):
5973 return self.getTypedRuleContext(Python3Parser.AtomContext,0)
5976 def AWAIT(self):
5977 return self.getToken(Python3Parser.AWAIT, 0)
5979 def trailer(self, i:int=None):
5980 if i is None:
5981 return self.getTypedRuleContexts(Python3Parser.TrailerContext)
5982 else:
5983 return self.getTypedRuleContext(Python3Parser.TrailerContext,i)
5986 def getRuleIndex(self):
5987 return Python3Parser.RULE_atom_expr
5989 def enterRule(self, listener:ParseTreeListener):
5990 if hasattr( listener, "enterAtom_expr" ):
5991 listener.enterAtom_expr(self)
5993 def exitRule(self, listener:ParseTreeListener):
5994 if hasattr( listener, "exitAtom_expr" ):
5995 listener.exitAtom_expr(self)
6000 def atom_expr(self):
6002 localctx = Python3Parser.Atom_exprContext(self, self._ctx, self.state)
6003 self.enterRule(localctx, 134, self.RULE_atom_expr)
6004 self._la = 0 # Token type
6005 try:
6006 self.enterOuterAlt(localctx, 1)
6007 self.state = 859
6008 self._errHandler.sync(self)
6009 _la = self._input.LA(1)
6010 if _la==Python3Parser.AWAIT:
6011 self.state = 858
6012 self.match(Python3Parser.AWAIT)
6015 self.state = 861
6016 self.atom()
6017 self.state = 865
6018 self._errHandler.sync(self)
6019 _la = self._input.LA(1)
6020 while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.DOT) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.OPEN_BRACK))) != 0):
6021 self.state = 862
6022 self.trailer()
6023 self.state = 867
6024 self._errHandler.sync(self)
6025 _la = self._input.LA(1)
6027 except RecognitionException as re:
6028 localctx.exception = re
6029 self._errHandler.reportError(self, re)
6030 self._errHandler.recover(self, re)
6031 finally:
6032 self.exitRule()
6033 return localctx
6036 class AtomContext(ParserRuleContext):
6037 __slots__ = 'parser'
6039 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
6040 super().__init__(parent, invokingState)
6041 self.parser = parser
6043 def OPEN_PAREN(self):
6044 return self.getToken(Python3Parser.OPEN_PAREN, 0)
6046 def CLOSE_PAREN(self):
6047 return self.getToken(Python3Parser.CLOSE_PAREN, 0)
6049 def OPEN_BRACK(self):
6050 return self.getToken(Python3Parser.OPEN_BRACK, 0)
6052 def CLOSE_BRACK(self):
6053 return self.getToken(Python3Parser.CLOSE_BRACK, 0)
6055 def OPEN_BRACE(self):
6056 return self.getToken(Python3Parser.OPEN_BRACE, 0)
6058 def CLOSE_BRACE(self):
6059 return self.getToken(Python3Parser.CLOSE_BRACE, 0)
6061 def NAME(self):
6062 return self.getToken(Python3Parser.NAME, 0)
6064 def NUMBER(self):
6065 return self.getToken(Python3Parser.NUMBER, 0)
6067 def ELLIPSIS(self):
6068 return self.getToken(Python3Parser.ELLIPSIS, 0)
6070 def NONE(self):
6071 return self.getToken(Python3Parser.NONE, 0)
6073 def TRUE(self):
6074 return self.getToken(Python3Parser.TRUE, 0)
6076 def FALSE(self):
6077 return self.getToken(Python3Parser.FALSE, 0)
6079 def yield_expr(self):
6080 return self.getTypedRuleContext(Python3Parser.Yield_exprContext,0)
6083 def testlist_comp(self):
6084 return self.getTypedRuleContext(Python3Parser.Testlist_compContext,0)
6087 def dictorsetmaker(self):
6088 return self.getTypedRuleContext(Python3Parser.DictorsetmakerContext,0)
6091 def STRING(self, i:int=None):
6092 if i is None:
6093 return self.getTokens(Python3Parser.STRING)
6094 else:
6095 return self.getToken(Python3Parser.STRING, i)
6097 def getRuleIndex(self):
6098 return Python3Parser.RULE_atom
6100 def enterRule(self, listener:ParseTreeListener):
6101 if hasattr( listener, "enterAtom" ):
6102 listener.enterAtom(self)
6104 def exitRule(self, listener:ParseTreeListener):
6105 if hasattr( listener, "exitAtom" ):
6106 listener.exitAtom(self)
6111 def atom(self):
6113 localctx = Python3Parser.AtomContext(self, self._ctx, self.state)
6114 self.enterRule(localctx, 136, self.RULE_atom)
6115 self._la = 0 # Token type
6116 try:
6117 self.enterOuterAlt(localctx, 1)
6118 self.state = 895
6119 self._errHandler.sync(self)
6120 token = self._input.LA(1)
6121 if token in [Python3Parser.OPEN_PAREN]:
6122 self.state = 868
6123 self.match(Python3Parser.OPEN_PAREN)
6124 self.state = 871
6125 self._errHandler.sync(self)
6126 token = self._input.LA(1)
6127 if token in [Python3Parser.YIELD]:
6128 self.state = 869
6129 self.yield_expr()
6130 pass
6131 elif token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.STAR, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]:
6132 self.state = 870
6133 self.testlist_comp()
6134 pass
6135 elif token in [Python3Parser.CLOSE_PAREN]:
6136 pass
6137 else:
6138 pass
6139 self.state = 873
6140 self.match(Python3Parser.CLOSE_PAREN)
6141 pass
6142 elif token in [Python3Parser.OPEN_BRACK]:
6143 self.state = 874
6144 self.match(Python3Parser.OPEN_BRACK)
6145 self.state = 876
6146 self._errHandler.sync(self)
6147 _la = self._input.LA(1)
6148 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.STAR) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0):
6149 self.state = 875
6150 self.testlist_comp()
6153 self.state = 878
6154 self.match(Python3Parser.CLOSE_BRACK)
6155 pass
6156 elif token in [Python3Parser.OPEN_BRACE]:
6157 self.state = 879
6158 self.match(Python3Parser.OPEN_BRACE)
6159 self.state = 881
6160 self._errHandler.sync(self)
6161 _la = self._input.LA(1)
6162 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.STAR) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.POWER) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0):
6163 self.state = 880
6164 self.dictorsetmaker()
6167 self.state = 883
6168 self.match(Python3Parser.CLOSE_BRACE)
6169 pass
6170 elif token in [Python3Parser.NAME]:
6171 self.state = 884
6172 self.match(Python3Parser.NAME)
6173 pass
6174 elif token in [Python3Parser.NUMBER]:
6175 self.state = 885
6176 self.match(Python3Parser.NUMBER)
6177 pass
6178 elif token in [Python3Parser.STRING]:
6179 self.state = 887
6180 self._errHandler.sync(self)
6181 _la = self._input.LA(1)
6182 while True:
6183 self.state = 886
6184 self.match(Python3Parser.STRING)
6185 self.state = 889
6186 self._errHandler.sync(self)
6187 _la = self._input.LA(1)
6188 if not (_la==Python3Parser.STRING):
6189 break
6191 pass
6192 elif token in [Python3Parser.ELLIPSIS]:
6193 self.state = 891
6194 self.match(Python3Parser.ELLIPSIS)
6195 pass
6196 elif token in [Python3Parser.NONE]:
6197 self.state = 892
6198 self.match(Python3Parser.NONE)
6199 pass
6200 elif token in [Python3Parser.TRUE]:
6201 self.state = 893
6202 self.match(Python3Parser.TRUE)
6203 pass
6204 elif token in [Python3Parser.FALSE]:
6205 self.state = 894
6206 self.match(Python3Parser.FALSE)
6207 pass
6208 else:
6209 raise NoViableAltException(self)
6211 except RecognitionException as re:
6212 localctx.exception = re
6213 self._errHandler.reportError(self, re)
6214 self._errHandler.recover(self, re)
6215 finally:
6216 self.exitRule()
6217 return localctx
6220 class Testlist_compContext(ParserRuleContext):
6221 __slots__ = 'parser'
6223 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
6224 super().__init__(parent, invokingState)
6225 self.parser = parser
6227 def test(self, i:int=None):
6228 if i is None:
6229 return self.getTypedRuleContexts(Python3Parser.TestContext)
6230 else:
6231 return self.getTypedRuleContext(Python3Parser.TestContext,i)
6234 def star_expr(self, i:int=None):
6235 if i is None:
6236 return self.getTypedRuleContexts(Python3Parser.Star_exprContext)
6237 else:
6238 return self.getTypedRuleContext(Python3Parser.Star_exprContext,i)
6241 def comp_for(self):
6242 return self.getTypedRuleContext(Python3Parser.Comp_forContext,0)
6245 def COMMA(self, i:int=None):
6246 if i is None:
6247 return self.getTokens(Python3Parser.COMMA)
6248 else:
6249 return self.getToken(Python3Parser.COMMA, i)
6251 def getRuleIndex(self):
6252 return Python3Parser.RULE_testlist_comp
6254 def enterRule(self, listener:ParseTreeListener):
6255 if hasattr( listener, "enterTestlist_comp" ):
6256 listener.enterTestlist_comp(self)
6258 def exitRule(self, listener:ParseTreeListener):
6259 if hasattr( listener, "exitTestlist_comp" ):
6260 listener.exitTestlist_comp(self)
6265 def testlist_comp(self):
6267 localctx = Python3Parser.Testlist_compContext(self, self._ctx, self.state)
6268 self.enterRule(localctx, 138, self.RULE_testlist_comp)
6269 self._la = 0 # Token type
6270 try:
6271 self.enterOuterAlt(localctx, 1)
6272 self.state = 899
6273 self._errHandler.sync(self)
6274 token = self._input.LA(1)
6275 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]:
6276 self.state = 897
6277 self.test()
6278 pass
6279 elif token in [Python3Parser.STAR]:
6280 self.state = 898
6281 self.star_expr()
6282 pass
6283 else:
6284 raise NoViableAltException(self)
6286 self.state = 915
6287 self._errHandler.sync(self)
6288 token = self._input.LA(1)
6289 if token in [Python3Parser.FOR, Python3Parser.ASYNC]:
6290 self.state = 901
6291 self.comp_for()
6292 pass
6293 elif token in [Python3Parser.CLOSE_PAREN, Python3Parser.COMMA, Python3Parser.CLOSE_BRACK]:
6294 self.state = 909
6295 self._errHandler.sync(self)
6296 _alt = self._interp.adaptivePredict(self._input,125,self._ctx)
6297 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
6298 if _alt==1:
6299 self.state = 902
6300 self.match(Python3Parser.COMMA)
6301 self.state = 905
6302 self._errHandler.sync(self)
6303 token = self._input.LA(1)
6304 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]:
6305 self.state = 903
6306 self.test()
6307 pass
6308 elif token in [Python3Parser.STAR]:
6309 self.state = 904
6310 self.star_expr()
6311 pass
6312 else:
6313 raise NoViableAltException(self)
6315 self.state = 911
6316 self._errHandler.sync(self)
6317 _alt = self._interp.adaptivePredict(self._input,125,self._ctx)
6319 self.state = 913
6320 self._errHandler.sync(self)
6321 _la = self._input.LA(1)
6322 if _la==Python3Parser.COMMA:
6323 self.state = 912
6324 self.match(Python3Parser.COMMA)
6327 pass
6328 else:
6329 raise NoViableAltException(self)
6331 except RecognitionException as re:
6332 localctx.exception = re
6333 self._errHandler.reportError(self, re)
6334 self._errHandler.recover(self, re)
6335 finally:
6336 self.exitRule()
6337 return localctx
6340 class TrailerContext(ParserRuleContext):
6341 __slots__ = 'parser'
6343 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
6344 super().__init__(parent, invokingState)
6345 self.parser = parser
6347 def OPEN_PAREN(self):
6348 return self.getToken(Python3Parser.OPEN_PAREN, 0)
6350 def CLOSE_PAREN(self):
6351 return self.getToken(Python3Parser.CLOSE_PAREN, 0)
6353 def arglist(self):
6354 return self.getTypedRuleContext(Python3Parser.ArglistContext,0)
6357 def OPEN_BRACK(self):
6358 return self.getToken(Python3Parser.OPEN_BRACK, 0)
6360 def subscriptlist(self):
6361 return self.getTypedRuleContext(Python3Parser.SubscriptlistContext,0)
6364 def CLOSE_BRACK(self):
6365 return self.getToken(Python3Parser.CLOSE_BRACK, 0)
6367 def DOT(self):
6368 return self.getToken(Python3Parser.DOT, 0)
6370 def NAME(self):
6371 return self.getToken(Python3Parser.NAME, 0)
6373 def getRuleIndex(self):
6374 return Python3Parser.RULE_trailer
6376 def enterRule(self, listener:ParseTreeListener):
6377 if hasattr( listener, "enterTrailer" ):
6378 listener.enterTrailer(self)
6380 def exitRule(self, listener:ParseTreeListener):
6381 if hasattr( listener, "exitTrailer" ):
6382 listener.exitTrailer(self)
6387 def trailer(self):
6389 localctx = Python3Parser.TrailerContext(self, self._ctx, self.state)
6390 self.enterRule(localctx, 140, self.RULE_trailer)
6391 self._la = 0 # Token type
6392 try:
6393 self.state = 928
6394 self._errHandler.sync(self)
6395 token = self._input.LA(1)
6396 if token in [Python3Parser.OPEN_PAREN]:
6397 self.enterOuterAlt(localctx, 1)
6398 self.state = 917
6399 self.match(Python3Parser.OPEN_PAREN)
6400 self.state = 919
6401 self._errHandler.sync(self)
6402 _la = self._input.LA(1)
6403 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.STAR) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.POWER) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0):
6404 self.state = 918
6405 self.arglist()
6408 self.state = 921
6409 self.match(Python3Parser.CLOSE_PAREN)
6410 pass
6411 elif token in [Python3Parser.OPEN_BRACK]:
6412 self.enterOuterAlt(localctx, 2)
6413 self.state = 922
6414 self.match(Python3Parser.OPEN_BRACK)
6415 self.state = 923
6416 self.subscriptlist()
6417 self.state = 924
6418 self.match(Python3Parser.CLOSE_BRACK)
6419 pass
6420 elif token in [Python3Parser.DOT]:
6421 self.enterOuterAlt(localctx, 3)
6422 self.state = 926
6423 self.match(Python3Parser.DOT)
6424 self.state = 927
6425 self.match(Python3Parser.NAME)
6426 pass
6427 else:
6428 raise NoViableAltException(self)
6430 except RecognitionException as re:
6431 localctx.exception = re
6432 self._errHandler.reportError(self, re)
6433 self._errHandler.recover(self, re)
6434 finally:
6435 self.exitRule()
6436 return localctx
6439 class SubscriptlistContext(ParserRuleContext):
6440 __slots__ = 'parser'
6442 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
6443 super().__init__(parent, invokingState)
6444 self.parser = parser
6446 def subscript(self, i:int=None):
6447 if i is None:
6448 return self.getTypedRuleContexts(Python3Parser.SubscriptContext)
6449 else:
6450 return self.getTypedRuleContext(Python3Parser.SubscriptContext,i)
6453 def COMMA(self, i:int=None):
6454 if i is None:
6455 return self.getTokens(Python3Parser.COMMA)
6456 else:
6457 return self.getToken(Python3Parser.COMMA, i)
6459 def getRuleIndex(self):
6460 return Python3Parser.RULE_subscriptlist
6462 def enterRule(self, listener:ParseTreeListener):
6463 if hasattr( listener, "enterSubscriptlist" ):
6464 listener.enterSubscriptlist(self)
6466 def exitRule(self, listener:ParseTreeListener):
6467 if hasattr( listener, "exitSubscriptlist" ):
6468 listener.exitSubscriptlist(self)
6473 def subscriptlist(self):
6475 localctx = Python3Parser.SubscriptlistContext(self, self._ctx, self.state)
6476 self.enterRule(localctx, 142, self.RULE_subscriptlist)
6477 self._la = 0 # Token type
6478 try:
6479 self.enterOuterAlt(localctx, 1)
6480 self.state = 930
6481 self.subscript()
6482 self.state = 935
6483 self._errHandler.sync(self)
6484 _alt = self._interp.adaptivePredict(self._input,130,self._ctx)
6485 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
6486 if _alt==1:
6487 self.state = 931
6488 self.match(Python3Parser.COMMA)
6489 self.state = 932
6490 self.subscript()
6491 self.state = 937
6492 self._errHandler.sync(self)
6493 _alt = self._interp.adaptivePredict(self._input,130,self._ctx)
6495 self.state = 939
6496 self._errHandler.sync(self)
6497 _la = self._input.LA(1)
6498 if _la==Python3Parser.COMMA:
6499 self.state = 938
6500 self.match(Python3Parser.COMMA)
6503 except RecognitionException as re:
6504 localctx.exception = re
6505 self._errHandler.reportError(self, re)
6506 self._errHandler.recover(self, re)
6507 finally:
6508 self.exitRule()
6509 return localctx
6512 class SubscriptContext(ParserRuleContext):
6513 __slots__ = 'parser'
6515 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
6516 super().__init__(parent, invokingState)
6517 self.parser = parser
6519 def test(self, i:int=None):
6520 if i is None:
6521 return self.getTypedRuleContexts(Python3Parser.TestContext)
6522 else:
6523 return self.getTypedRuleContext(Python3Parser.TestContext,i)
6526 def COLON(self):
6527 return self.getToken(Python3Parser.COLON, 0)
6529 def sliceop(self):
6530 return self.getTypedRuleContext(Python3Parser.SliceopContext,0)
6533 def getRuleIndex(self):
6534 return Python3Parser.RULE_subscript
6536 def enterRule(self, listener:ParseTreeListener):
6537 if hasattr( listener, "enterSubscript" ):
6538 listener.enterSubscript(self)
6540 def exitRule(self, listener:ParseTreeListener):
6541 if hasattr( listener, "exitSubscript" ):
6542 listener.exitSubscript(self)
6547 def subscript(self):
6549 localctx = Python3Parser.SubscriptContext(self, self._ctx, self.state)
6550 self.enterRule(localctx, 144, self.RULE_subscript)
6551 self._la = 0 # Token type
6552 try:
6553 self.state = 952
6554 self._errHandler.sync(self)
6555 la_ = self._interp.adaptivePredict(self._input,135,self._ctx)
6556 if la_ == 1:
6557 self.enterOuterAlt(localctx, 1)
6558 self.state = 941
6559 self.test()
6560 pass
6562 elif la_ == 2:
6563 self.enterOuterAlt(localctx, 2)
6564 self.state = 943
6565 self._errHandler.sync(self)
6566 _la = self._input.LA(1)
6567 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0):
6568 self.state = 942
6569 self.test()
6572 self.state = 945
6573 self.match(Python3Parser.COLON)
6574 self.state = 947
6575 self._errHandler.sync(self)
6576 _la = self._input.LA(1)
6577 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0):
6578 self.state = 946
6579 self.test()
6582 self.state = 950
6583 self._errHandler.sync(self)
6584 _la = self._input.LA(1)
6585 if _la==Python3Parser.COLON:
6586 self.state = 949
6587 self.sliceop()
6590 pass
6593 except RecognitionException as re:
6594 localctx.exception = re
6595 self._errHandler.reportError(self, re)
6596 self._errHandler.recover(self, re)
6597 finally:
6598 self.exitRule()
6599 return localctx
6602 class SliceopContext(ParserRuleContext):
6603 __slots__ = 'parser'
6605 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
6606 super().__init__(parent, invokingState)
6607 self.parser = parser
6609 def COLON(self):
6610 return self.getToken(Python3Parser.COLON, 0)
6612 def test(self):
6613 return self.getTypedRuleContext(Python3Parser.TestContext,0)
6616 def getRuleIndex(self):
6617 return Python3Parser.RULE_sliceop
6619 def enterRule(self, listener:ParseTreeListener):
6620 if hasattr( listener, "enterSliceop" ):
6621 listener.enterSliceop(self)
6623 def exitRule(self, listener:ParseTreeListener):
6624 if hasattr( listener, "exitSliceop" ):
6625 listener.exitSliceop(self)
6630 def sliceop(self):
6632 localctx = Python3Parser.SliceopContext(self, self._ctx, self.state)
6633 self.enterRule(localctx, 146, self.RULE_sliceop)
6634 self._la = 0 # Token type
6635 try:
6636 self.enterOuterAlt(localctx, 1)
6637 self.state = 954
6638 self.match(Python3Parser.COLON)
6639 self.state = 956
6640 self._errHandler.sync(self)
6641 _la = self._input.LA(1)
6642 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0):
6643 self.state = 955
6644 self.test()
6647 except RecognitionException as re:
6648 localctx.exception = re
6649 self._errHandler.reportError(self, re)
6650 self._errHandler.recover(self, re)
6651 finally:
6652 self.exitRule()
6653 return localctx
6656 class ExprlistContext(ParserRuleContext):
6657 __slots__ = 'parser'
6659 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
6660 super().__init__(parent, invokingState)
6661 self.parser = parser
6663 def expr(self, i:int=None):
6664 if i is None:
6665 return self.getTypedRuleContexts(Python3Parser.ExprContext)
6666 else:
6667 return self.getTypedRuleContext(Python3Parser.ExprContext,i)
6670 def star_expr(self, i:int=None):
6671 if i is None:
6672 return self.getTypedRuleContexts(Python3Parser.Star_exprContext)
6673 else:
6674 return self.getTypedRuleContext(Python3Parser.Star_exprContext,i)
6677 def COMMA(self, i:int=None):
6678 if i is None:
6679 return self.getTokens(Python3Parser.COMMA)
6680 else:
6681 return self.getToken(Python3Parser.COMMA, i)
6683 def getRuleIndex(self):
6684 return Python3Parser.RULE_exprlist
6686 def enterRule(self, listener:ParseTreeListener):
6687 if hasattr( listener, "enterExprlist" ):
6688 listener.enterExprlist(self)
6690 def exitRule(self, listener:ParseTreeListener):
6691 if hasattr( listener, "exitExprlist" ):
6692 listener.exitExprlist(self)
6697 def exprlist(self):
6699 localctx = Python3Parser.ExprlistContext(self, self._ctx, self.state)
6700 self.enterRule(localctx, 148, self.RULE_exprlist)
6701 self._la = 0 # Token type
6702 try:
6703 self.enterOuterAlt(localctx, 1)
6704 self.state = 960
6705 self._errHandler.sync(self)
6706 token = self._input.LA(1)
6707 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]:
6708 self.state = 958
6709 self.expr()
6710 pass
6711 elif token in [Python3Parser.STAR]:
6712 self.state = 959
6713 self.star_expr()
6714 pass
6715 else:
6716 raise NoViableAltException(self)
6718 self.state = 969
6719 self._errHandler.sync(self)
6720 _alt = self._interp.adaptivePredict(self._input,139,self._ctx)
6721 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
6722 if _alt==1:
6723 self.state = 962
6724 self.match(Python3Parser.COMMA)
6725 self.state = 965
6726 self._errHandler.sync(self)
6727 token = self._input.LA(1)
6728 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]:
6729 self.state = 963
6730 self.expr()
6731 pass
6732 elif token in [Python3Parser.STAR]:
6733 self.state = 964
6734 self.star_expr()
6735 pass
6736 else:
6737 raise NoViableAltException(self)
6739 self.state = 971
6740 self._errHandler.sync(self)
6741 _alt = self._interp.adaptivePredict(self._input,139,self._ctx)
6743 self.state = 973
6744 self._errHandler.sync(self)
6745 _la = self._input.LA(1)
6746 if _la==Python3Parser.COMMA:
6747 self.state = 972
6748 self.match(Python3Parser.COMMA)
6751 except RecognitionException as re:
6752 localctx.exception = re
6753 self._errHandler.reportError(self, re)
6754 self._errHandler.recover(self, re)
6755 finally:
6756 self.exitRule()
6757 return localctx
6760 class TestlistContext(ParserRuleContext):
6761 __slots__ = 'parser'
6763 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
6764 super().__init__(parent, invokingState)
6765 self.parser = parser
6767 def test(self, i:int=None):
6768 if i is None:
6769 return self.getTypedRuleContexts(Python3Parser.TestContext)
6770 else:
6771 return self.getTypedRuleContext(Python3Parser.TestContext,i)
6774 def COMMA(self, i:int=None):
6775 if i is None:
6776 return self.getTokens(Python3Parser.COMMA)
6777 else:
6778 return self.getToken(Python3Parser.COMMA, i)
6780 def getRuleIndex(self):
6781 return Python3Parser.RULE_testlist
6783 def enterRule(self, listener:ParseTreeListener):
6784 if hasattr( listener, "enterTestlist" ):
6785 listener.enterTestlist(self)
6787 def exitRule(self, listener:ParseTreeListener):
6788 if hasattr( listener, "exitTestlist" ):
6789 listener.exitTestlist(self)
6794 def testlist(self):
6796 localctx = Python3Parser.TestlistContext(self, self._ctx, self.state)
6797 self.enterRule(localctx, 150, self.RULE_testlist)
6798 self._la = 0 # Token type
6799 try:
6800 self.enterOuterAlt(localctx, 1)
6801 self.state = 975
6802 self.test()
6803 self.state = 980
6804 self._errHandler.sync(self)
6805 _alt = self._interp.adaptivePredict(self._input,141,self._ctx)
6806 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
6807 if _alt==1:
6808 self.state = 976
6809 self.match(Python3Parser.COMMA)
6810 self.state = 977
6811 self.test()
6812 self.state = 982
6813 self._errHandler.sync(self)
6814 _alt = self._interp.adaptivePredict(self._input,141,self._ctx)
6816 self.state = 984
6817 self._errHandler.sync(self)
6818 _la = self._input.LA(1)
6819 if _la==Python3Parser.COMMA:
6820 self.state = 983
6821 self.match(Python3Parser.COMMA)
6824 except RecognitionException as re:
6825 localctx.exception = re
6826 self._errHandler.reportError(self, re)
6827 self._errHandler.recover(self, re)
6828 finally:
6829 self.exitRule()
6830 return localctx
6833 class DictorsetmakerContext(ParserRuleContext):
6834 __slots__ = 'parser'
6836 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
6837 super().__init__(parent, invokingState)
6838 self.parser = parser
6840 def test(self, i:int=None):
6841 if i is None:
6842 return self.getTypedRuleContexts(Python3Parser.TestContext)
6843 else:
6844 return self.getTypedRuleContext(Python3Parser.TestContext,i)
6847 def COLON(self, i:int=None):
6848 if i is None:
6849 return self.getTokens(Python3Parser.COLON)
6850 else:
6851 return self.getToken(Python3Parser.COLON, i)
6853 def POWER(self, i:int=None):
6854 if i is None:
6855 return self.getTokens(Python3Parser.POWER)
6856 else:
6857 return self.getToken(Python3Parser.POWER, i)
6859 def expr(self, i:int=None):
6860 if i is None:
6861 return self.getTypedRuleContexts(Python3Parser.ExprContext)
6862 else:
6863 return self.getTypedRuleContext(Python3Parser.ExprContext,i)
6866 def comp_for(self):
6867 return self.getTypedRuleContext(Python3Parser.Comp_forContext,0)
6870 def star_expr(self, i:int=None):
6871 if i is None:
6872 return self.getTypedRuleContexts(Python3Parser.Star_exprContext)
6873 else:
6874 return self.getTypedRuleContext(Python3Parser.Star_exprContext,i)
6877 def COMMA(self, i:int=None):
6878 if i is None:
6879 return self.getTokens(Python3Parser.COMMA)
6880 else:
6881 return self.getToken(Python3Parser.COMMA, i)
6883 def getRuleIndex(self):
6884 return Python3Parser.RULE_dictorsetmaker
6886 def enterRule(self, listener:ParseTreeListener):
6887 if hasattr( listener, "enterDictorsetmaker" ):
6888 listener.enterDictorsetmaker(self)
6890 def exitRule(self, listener:ParseTreeListener):
6891 if hasattr( listener, "exitDictorsetmaker" ):
6892 listener.exitDictorsetmaker(self)
6897 def dictorsetmaker(self):
6899 localctx = Python3Parser.DictorsetmakerContext(self, self._ctx, self.state)
6900 self.enterRule(localctx, 152, self.RULE_dictorsetmaker)
6901 self._la = 0 # Token type
6902 try:
6903 self.enterOuterAlt(localctx, 1)
6904 self.state = 1034
6905 self._errHandler.sync(self)
6906 la_ = self._interp.adaptivePredict(self._input,153,self._ctx)
6907 if la_ == 1:
6908 self.state = 992
6909 self._errHandler.sync(self)
6910 token = self._input.LA(1)
6911 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]:
6912 self.state = 986
6913 self.test()
6914 self.state = 987
6915 self.match(Python3Parser.COLON)
6916 self.state = 988
6917 self.test()
6918 pass
6919 elif token in [Python3Parser.POWER]:
6920 self.state = 990
6921 self.match(Python3Parser.POWER)
6922 self.state = 991
6923 self.expr()
6924 pass
6925 else:
6926 raise NoViableAltException(self)
6928 self.state = 1012
6929 self._errHandler.sync(self)
6930 token = self._input.LA(1)
6931 if token in [Python3Parser.FOR, Python3Parser.ASYNC]:
6932 self.state = 994
6933 self.comp_for()
6934 pass
6935 elif token in [Python3Parser.COMMA, Python3Parser.CLOSE_BRACE]:
6936 self.state = 1006
6937 self._errHandler.sync(self)
6938 _alt = self._interp.adaptivePredict(self._input,145,self._ctx)
6939 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
6940 if _alt==1:
6941 self.state = 995
6942 self.match(Python3Parser.COMMA)
6943 self.state = 1002
6944 self._errHandler.sync(self)
6945 token = self._input.LA(1)
6946 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]:
6947 self.state = 996
6948 self.test()
6949 self.state = 997
6950 self.match(Python3Parser.COLON)
6951 self.state = 998
6952 self.test()
6953 pass
6954 elif token in [Python3Parser.POWER]:
6955 self.state = 1000
6956 self.match(Python3Parser.POWER)
6957 self.state = 1001
6958 self.expr()
6959 pass
6960 else:
6961 raise NoViableAltException(self)
6963 self.state = 1008
6964 self._errHandler.sync(self)
6965 _alt = self._interp.adaptivePredict(self._input,145,self._ctx)
6967 self.state = 1010
6968 self._errHandler.sync(self)
6969 _la = self._input.LA(1)
6970 if _la==Python3Parser.COMMA:
6971 self.state = 1009
6972 self.match(Python3Parser.COMMA)
6975 pass
6976 else:
6977 raise NoViableAltException(self)
6979 pass
6981 elif la_ == 2:
6982 self.state = 1016
6983 self._errHandler.sync(self)
6984 token = self._input.LA(1)
6985 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]:
6986 self.state = 1014
6987 self.test()
6988 pass
6989 elif token in [Python3Parser.STAR]:
6990 self.state = 1015
6991 self.star_expr()
6992 pass
6993 else:
6994 raise NoViableAltException(self)
6996 self.state = 1032
6997 self._errHandler.sync(self)
6998 token = self._input.LA(1)
6999 if token in [Python3Parser.FOR, Python3Parser.ASYNC]:
7000 self.state = 1018
7001 self.comp_for()
7002 pass
7003 elif token in [Python3Parser.COMMA, Python3Parser.CLOSE_BRACE]:
7004 self.state = 1026
7005 self._errHandler.sync(self)
7006 _alt = self._interp.adaptivePredict(self._input,150,self._ctx)
7007 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
7008 if _alt==1:
7009 self.state = 1019
7010 self.match(Python3Parser.COMMA)
7011 self.state = 1022
7012 self._errHandler.sync(self)
7013 token = self._input.LA(1)
7014 if token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]:
7015 self.state = 1020
7016 self.test()
7017 pass
7018 elif token in [Python3Parser.STAR]:
7019 self.state = 1021
7020 self.star_expr()
7021 pass
7022 else:
7023 raise NoViableAltException(self)
7025 self.state = 1028
7026 self._errHandler.sync(self)
7027 _alt = self._interp.adaptivePredict(self._input,150,self._ctx)
7029 self.state = 1030
7030 self._errHandler.sync(self)
7031 _la = self._input.LA(1)
7032 if _la==Python3Parser.COMMA:
7033 self.state = 1029
7034 self.match(Python3Parser.COMMA)
7037 pass
7038 else:
7039 raise NoViableAltException(self)
7041 pass
7044 except RecognitionException as re:
7045 localctx.exception = re
7046 self._errHandler.reportError(self, re)
7047 self._errHandler.recover(self, re)
7048 finally:
7049 self.exitRule()
7050 return localctx
7053 class ClassdefContext(ParserRuleContext):
7054 __slots__ = 'parser'
7056 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
7057 super().__init__(parent, invokingState)
7058 self.parser = parser
7060 def CLASS(self):
7061 return self.getToken(Python3Parser.CLASS, 0)
7063 def NAME(self):
7064 return self.getToken(Python3Parser.NAME, 0)
7066 def COLON(self):
7067 return self.getToken(Python3Parser.COLON, 0)
7069 def suite(self):
7070 return self.getTypedRuleContext(Python3Parser.SuiteContext,0)
7073 def OPEN_PAREN(self):
7074 return self.getToken(Python3Parser.OPEN_PAREN, 0)
7076 def CLOSE_PAREN(self):
7077 return self.getToken(Python3Parser.CLOSE_PAREN, 0)
7079 def arglist(self):
7080 return self.getTypedRuleContext(Python3Parser.ArglistContext,0)
7083 def getRuleIndex(self):
7084 return Python3Parser.RULE_classdef
7086 def enterRule(self, listener:ParseTreeListener):
7087 if hasattr( listener, "enterClassdef" ):
7088 listener.enterClassdef(self)
7090 def exitRule(self, listener:ParseTreeListener):
7091 if hasattr( listener, "exitClassdef" ):
7092 listener.exitClassdef(self)
7097 def classdef(self):
7099 localctx = Python3Parser.ClassdefContext(self, self._ctx, self.state)
7100 self.enterRule(localctx, 154, self.RULE_classdef)
7101 self._la = 0 # Token type
7102 try:
7103 self.enterOuterAlt(localctx, 1)
7104 self.state = 1036
7105 self.match(Python3Parser.CLASS)
7106 self.state = 1037
7107 self.match(Python3Parser.NAME)
7108 self.state = 1043
7109 self._errHandler.sync(self)
7110 _la = self._input.LA(1)
7111 if _la==Python3Parser.OPEN_PAREN:
7112 self.state = 1038
7113 self.match(Python3Parser.OPEN_PAREN)
7114 self.state = 1040
7115 self._errHandler.sync(self)
7116 _la = self._input.LA(1)
7117 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.STAR) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.POWER) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0):
7118 self.state = 1039
7119 self.arglist()
7122 self.state = 1042
7123 self.match(Python3Parser.CLOSE_PAREN)
7126 self.state = 1045
7127 self.match(Python3Parser.COLON)
7128 self.state = 1046
7129 self.suite()
7130 except RecognitionException as re:
7131 localctx.exception = re
7132 self._errHandler.reportError(self, re)
7133 self._errHandler.recover(self, re)
7134 finally:
7135 self.exitRule()
7136 return localctx
7139 class ArglistContext(ParserRuleContext):
7140 __slots__ = 'parser'
7142 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
7143 super().__init__(parent, invokingState)
7144 self.parser = parser
7146 def argument(self, i:int=None):
7147 if i is None:
7148 return self.getTypedRuleContexts(Python3Parser.ArgumentContext)
7149 else:
7150 return self.getTypedRuleContext(Python3Parser.ArgumentContext,i)
7153 def COMMA(self, i:int=None):
7154 if i is None:
7155 return self.getTokens(Python3Parser.COMMA)
7156 else:
7157 return self.getToken(Python3Parser.COMMA, i)
7159 def getRuleIndex(self):
7160 return Python3Parser.RULE_arglist
7162 def enterRule(self, listener:ParseTreeListener):
7163 if hasattr( listener, "enterArglist" ):
7164 listener.enterArglist(self)
7166 def exitRule(self, listener:ParseTreeListener):
7167 if hasattr( listener, "exitArglist" ):
7168 listener.exitArglist(self)
7173 def arglist(self):
7175 localctx = Python3Parser.ArglistContext(self, self._ctx, self.state)
7176 self.enterRule(localctx, 156, self.RULE_arglist)
7177 self._la = 0 # Token type
7178 try:
7179 self.enterOuterAlt(localctx, 1)
7180 self.state = 1048
7181 self.argument()
7182 self.state = 1053
7183 self._errHandler.sync(self)
7184 _alt = self._interp.adaptivePredict(self._input,156,self._ctx)
7185 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
7186 if _alt==1:
7187 self.state = 1049
7188 self.match(Python3Parser.COMMA)
7189 self.state = 1050
7190 self.argument()
7191 self.state = 1055
7192 self._errHandler.sync(self)
7193 _alt = self._interp.adaptivePredict(self._input,156,self._ctx)
7195 self.state = 1057
7196 self._errHandler.sync(self)
7197 _la = self._input.LA(1)
7198 if _la==Python3Parser.COMMA:
7199 self.state = 1056
7200 self.match(Python3Parser.COMMA)
7203 except RecognitionException as re:
7204 localctx.exception = re
7205 self._errHandler.reportError(self, re)
7206 self._errHandler.recover(self, re)
7207 finally:
7208 self.exitRule()
7209 return localctx
7212 class ArgumentContext(ParserRuleContext):
7213 __slots__ = 'parser'
7215 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
7216 super().__init__(parent, invokingState)
7217 self.parser = parser
7219 def test(self, i:int=None):
7220 if i is None:
7221 return self.getTypedRuleContexts(Python3Parser.TestContext)
7222 else:
7223 return self.getTypedRuleContext(Python3Parser.TestContext,i)
7226 def ASSIGN(self):
7227 return self.getToken(Python3Parser.ASSIGN, 0)
7229 def POWER(self):
7230 return self.getToken(Python3Parser.POWER, 0)
7232 def STAR(self):
7233 return self.getToken(Python3Parser.STAR, 0)
7235 def comp_for(self):
7236 return self.getTypedRuleContext(Python3Parser.Comp_forContext,0)
7239 def getRuleIndex(self):
7240 return Python3Parser.RULE_argument
7242 def enterRule(self, listener:ParseTreeListener):
7243 if hasattr( listener, "enterArgument" ):
7244 listener.enterArgument(self)
7246 def exitRule(self, listener:ParseTreeListener):
7247 if hasattr( listener, "exitArgument" ):
7248 listener.exitArgument(self)
7253 def argument(self):
7255 localctx = Python3Parser.ArgumentContext(self, self._ctx, self.state)
7256 self.enterRule(localctx, 158, self.RULE_argument)
7257 self._la = 0 # Token type
7258 try:
7259 self.enterOuterAlt(localctx, 1)
7260 self.state = 1071
7261 self._errHandler.sync(self)
7262 la_ = self._interp.adaptivePredict(self._input,159,self._ctx)
7263 if la_ == 1:
7264 self.state = 1059
7265 self.test()
7266 self.state = 1061
7267 self._errHandler.sync(self)
7268 _la = self._input.LA(1)
7269 if _la==Python3Parser.FOR or _la==Python3Parser.ASYNC:
7270 self.state = 1060
7271 self.comp_for()
7274 pass
7276 elif la_ == 2:
7277 self.state = 1063
7278 self.test()
7279 self.state = 1064
7280 self.match(Python3Parser.ASSIGN)
7281 self.state = 1065
7282 self.test()
7283 pass
7285 elif la_ == 3:
7286 self.state = 1067
7287 self.match(Python3Parser.POWER)
7288 self.state = 1068
7289 self.test()
7290 pass
7292 elif la_ == 4:
7293 self.state = 1069
7294 self.match(Python3Parser.STAR)
7295 self.state = 1070
7296 self.test()
7297 pass
7300 except RecognitionException as re:
7301 localctx.exception = re
7302 self._errHandler.reportError(self, re)
7303 self._errHandler.recover(self, re)
7304 finally:
7305 self.exitRule()
7306 return localctx
7309 class Comp_iterContext(ParserRuleContext):
7310 __slots__ = 'parser'
7312 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
7313 super().__init__(parent, invokingState)
7314 self.parser = parser
7316 def comp_for(self):
7317 return self.getTypedRuleContext(Python3Parser.Comp_forContext,0)
7320 def comp_if(self):
7321 return self.getTypedRuleContext(Python3Parser.Comp_ifContext,0)
7324 def getRuleIndex(self):
7325 return Python3Parser.RULE_comp_iter
7327 def enterRule(self, listener:ParseTreeListener):
7328 if hasattr( listener, "enterComp_iter" ):
7329 listener.enterComp_iter(self)
7331 def exitRule(self, listener:ParseTreeListener):
7332 if hasattr( listener, "exitComp_iter" ):
7333 listener.exitComp_iter(self)
7338 def comp_iter(self):
7340 localctx = Python3Parser.Comp_iterContext(self, self._ctx, self.state)
7341 self.enterRule(localctx, 160, self.RULE_comp_iter)
7342 try:
7343 self.state = 1075
7344 self._errHandler.sync(self)
7345 token = self._input.LA(1)
7346 if token in [Python3Parser.FOR, Python3Parser.ASYNC]:
7347 self.enterOuterAlt(localctx, 1)
7348 self.state = 1073
7349 self.comp_for()
7350 pass
7351 elif token in [Python3Parser.IF]:
7352 self.enterOuterAlt(localctx, 2)
7353 self.state = 1074
7354 self.comp_if()
7355 pass
7356 else:
7357 raise NoViableAltException(self)
7359 except RecognitionException as re:
7360 localctx.exception = re
7361 self._errHandler.reportError(self, re)
7362 self._errHandler.recover(self, re)
7363 finally:
7364 self.exitRule()
7365 return localctx
7368 class Comp_forContext(ParserRuleContext):
7369 __slots__ = 'parser'
7371 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
7372 super().__init__(parent, invokingState)
7373 self.parser = parser
7375 def FOR(self):
7376 return self.getToken(Python3Parser.FOR, 0)
7378 def exprlist(self):
7379 return self.getTypedRuleContext(Python3Parser.ExprlistContext,0)
7382 def IN(self):
7383 return self.getToken(Python3Parser.IN, 0)
7385 def or_test(self):
7386 return self.getTypedRuleContext(Python3Parser.Or_testContext,0)
7389 def ASYNC(self):
7390 return self.getToken(Python3Parser.ASYNC, 0)
7392 def comp_iter(self):
7393 return self.getTypedRuleContext(Python3Parser.Comp_iterContext,0)
7396 def getRuleIndex(self):
7397 return Python3Parser.RULE_comp_for
7399 def enterRule(self, listener:ParseTreeListener):
7400 if hasattr( listener, "enterComp_for" ):
7401 listener.enterComp_for(self)
7403 def exitRule(self, listener:ParseTreeListener):
7404 if hasattr( listener, "exitComp_for" ):
7405 listener.exitComp_for(self)
7410 def comp_for(self):
7412 localctx = Python3Parser.Comp_forContext(self, self._ctx, self.state)
7413 self.enterRule(localctx, 162, self.RULE_comp_for)
7414 self._la = 0 # Token type
7415 try:
7416 self.enterOuterAlt(localctx, 1)
7417 self.state = 1078
7418 self._errHandler.sync(self)
7419 _la = self._input.LA(1)
7420 if _la==Python3Parser.ASYNC:
7421 self.state = 1077
7422 self.match(Python3Parser.ASYNC)
7425 self.state = 1080
7426 self.match(Python3Parser.FOR)
7427 self.state = 1081
7428 self.exprlist()
7429 self.state = 1082
7430 self.match(Python3Parser.IN)
7431 self.state = 1083
7432 self.or_test()
7433 self.state = 1085
7434 self._errHandler.sync(self)
7435 _la = self._input.LA(1)
7436 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.IF) | (1 << Python3Parser.FOR) | (1 << Python3Parser.ASYNC))) != 0):
7437 self.state = 1084
7438 self.comp_iter()
7441 except RecognitionException as re:
7442 localctx.exception = re
7443 self._errHandler.reportError(self, re)
7444 self._errHandler.recover(self, re)
7445 finally:
7446 self.exitRule()
7447 return localctx
7450 class Comp_ifContext(ParserRuleContext):
7451 __slots__ = 'parser'
7453 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
7454 super().__init__(parent, invokingState)
7455 self.parser = parser
7457 def IF(self):
7458 return self.getToken(Python3Parser.IF, 0)
7460 def test_nocond(self):
7461 return self.getTypedRuleContext(Python3Parser.Test_nocondContext,0)
7464 def comp_iter(self):
7465 return self.getTypedRuleContext(Python3Parser.Comp_iterContext,0)
7468 def getRuleIndex(self):
7469 return Python3Parser.RULE_comp_if
7471 def enterRule(self, listener:ParseTreeListener):
7472 if hasattr( listener, "enterComp_if" ):
7473 listener.enterComp_if(self)
7475 def exitRule(self, listener:ParseTreeListener):
7476 if hasattr( listener, "exitComp_if" ):
7477 listener.exitComp_if(self)
7482 def comp_if(self):
7484 localctx = Python3Parser.Comp_ifContext(self, self._ctx, self.state)
7485 self.enterRule(localctx, 164, self.RULE_comp_if)
7486 self._la = 0 # Token type
7487 try:
7488 self.enterOuterAlt(localctx, 1)
7489 self.state = 1087
7490 self.match(Python3Parser.IF)
7491 self.state = 1088
7492 self.test_nocond()
7493 self.state = 1090
7494 self._errHandler.sync(self)
7495 _la = self._input.LA(1)
7496 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.IF) | (1 << Python3Parser.FOR) | (1 << Python3Parser.ASYNC))) != 0):
7497 self.state = 1089
7498 self.comp_iter()
7501 except RecognitionException as re:
7502 localctx.exception = re
7503 self._errHandler.reportError(self, re)
7504 self._errHandler.recover(self, re)
7505 finally:
7506 self.exitRule()
7507 return localctx
7510 class Encoding_declContext(ParserRuleContext):
7511 __slots__ = 'parser'
7513 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
7514 super().__init__(parent, invokingState)
7515 self.parser = parser
7517 def NAME(self):
7518 return self.getToken(Python3Parser.NAME, 0)
7520 def getRuleIndex(self):
7521 return Python3Parser.RULE_encoding_decl
7523 def enterRule(self, listener:ParseTreeListener):
7524 if hasattr( listener, "enterEncoding_decl" ):
7525 listener.enterEncoding_decl(self)
7527 def exitRule(self, listener:ParseTreeListener):
7528 if hasattr( listener, "exitEncoding_decl" ):
7529 listener.exitEncoding_decl(self)
7534 def encoding_decl(self):
7536 localctx = Python3Parser.Encoding_declContext(self, self._ctx, self.state)
7537 self.enterRule(localctx, 166, self.RULE_encoding_decl)
7538 try:
7539 self.enterOuterAlt(localctx, 1)
7540 self.state = 1092
7541 self.match(Python3Parser.NAME)
7542 except RecognitionException as re:
7543 localctx.exception = re
7544 self._errHandler.reportError(self, re)
7545 self._errHandler.recover(self, re)
7546 finally:
7547 self.exitRule()
7548 return localctx
7551 class Yield_exprContext(ParserRuleContext):
7552 __slots__ = 'parser'
7554 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
7555 super().__init__(parent, invokingState)
7556 self.parser = parser
7558 def YIELD(self):
7559 return self.getToken(Python3Parser.YIELD, 0)
7561 def yield_arg(self):
7562 return self.getTypedRuleContext(Python3Parser.Yield_argContext,0)
7565 def getRuleIndex(self):
7566 return Python3Parser.RULE_yield_expr
7568 def enterRule(self, listener:ParseTreeListener):
7569 if hasattr( listener, "enterYield_expr" ):
7570 listener.enterYield_expr(self)
7572 def exitRule(self, listener:ParseTreeListener):
7573 if hasattr( listener, "exitYield_expr" ):
7574 listener.exitYield_expr(self)
7579 def yield_expr(self):
7581 localctx = Python3Parser.Yield_exprContext(self, self._ctx, self.state)
7582 self.enterRule(localctx, 168, self.RULE_yield_expr)
7583 self._la = 0 # Token type
7584 try:
7585 self.enterOuterAlt(localctx, 1)
7586 self.state = 1094
7587 self.match(Python3Parser.YIELD)
7588 self.state = 1096
7589 self._errHandler.sync(self)
7590 _la = self._input.LA(1)
7591 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.STRING) | (1 << Python3Parser.NUMBER) | (1 << Python3Parser.FROM) | (1 << Python3Parser.LAMBDA) | (1 << Python3Parser.NOT) | (1 << Python3Parser.NONE) | (1 << Python3Parser.TRUE) | (1 << Python3Parser.FALSE) | (1 << Python3Parser.AWAIT) | (1 << Python3Parser.NAME) | (1 << Python3Parser.ELLIPSIS) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.OPEN_BRACK))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)) | (1 << (Python3Parser.OPEN_BRACE - 66)))) != 0):
7592 self.state = 1095
7593 self.yield_arg()
7596 except RecognitionException as re:
7597 localctx.exception = re
7598 self._errHandler.reportError(self, re)
7599 self._errHandler.recover(self, re)
7600 finally:
7601 self.exitRule()
7602 return localctx
7605 class Yield_argContext(ParserRuleContext):
7606 __slots__ = 'parser'
7608 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
7609 super().__init__(parent, invokingState)
7610 self.parser = parser
7612 def FROM(self):
7613 return self.getToken(Python3Parser.FROM, 0)
7615 def test(self):
7616 return self.getTypedRuleContext(Python3Parser.TestContext,0)
7619 def testlist(self):
7620 return self.getTypedRuleContext(Python3Parser.TestlistContext,0)
7623 def getRuleIndex(self):
7624 return Python3Parser.RULE_yield_arg
7626 def enterRule(self, listener:ParseTreeListener):
7627 if hasattr( listener, "enterYield_arg" ):
7628 listener.enterYield_arg(self)
7630 def exitRule(self, listener:ParseTreeListener):
7631 if hasattr( listener, "exitYield_arg" ):
7632 listener.exitYield_arg(self)
7637 def yield_arg(self):
7639 localctx = Python3Parser.Yield_argContext(self, self._ctx, self.state)
7640 self.enterRule(localctx, 170, self.RULE_yield_arg)
7641 try:
7642 self.state = 1101
7643 self._errHandler.sync(self)
7644 token = self._input.LA(1)
7645 if token in [Python3Parser.FROM]:
7646 self.enterOuterAlt(localctx, 1)
7647 self.state = 1098
7648 self.match(Python3Parser.FROM)
7649 self.state = 1099
7650 self.test()
7651 pass
7652 elif token in [Python3Parser.STRING, Python3Parser.NUMBER, Python3Parser.LAMBDA, Python3Parser.NOT, Python3Parser.NONE, Python3Parser.TRUE, Python3Parser.FALSE, Python3Parser.AWAIT, Python3Parser.NAME, Python3Parser.ELLIPSIS, Python3Parser.OPEN_PAREN, Python3Parser.OPEN_BRACK, Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP, Python3Parser.OPEN_BRACE]:
7653 self.enterOuterAlt(localctx, 2)
7654 self.state = 1100
7655 self.testlist()
7656 pass
7657 else:
7658 raise NoViableAltException(self)
7660 except RecognitionException as re:
7661 localctx.exception = re
7662 self._errHandler.reportError(self, re)
7663 self._errHandler.recover(self, re)
7664 finally:
7665 self.exitRule()
7666 return localctx