Coverage for src/pyensae/languages/Python3Parser.py : 29%
Hot-keys on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
1# Generated from \Python3.g4 by ANTLR 4.9
2# encoding: utf-8
3from antlr4 import *
4from io import StringIO
5import sys
6if sys.version_info[1] > 5:
7 from typing import TextIO
8else:
9 from typing.io import TextIO
12def serializedATN():
13 with StringIO() as buf:
14 buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3e")
15 buf.write("\u0452\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
16 buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
17 buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
18 buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
19 buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
20 buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
21 buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
22 buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
23 buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
24 buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
25 buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t")
26 buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\t")
27 buf.write("V\4W\tW\3\2\3\2\3\2\3\2\3\2\5\2\u00b4\n\2\3\3\3\3\7\3")
28 buf.write("\u00b8\n\3\f\3\16\3\u00bb\13\3\3\3\3\3\3\4\3\4\7\4\u00c1")
29 buf.write("\n\4\f\4\16\4\u00c4\13\4\3\4\3\4\3\5\3\5\3\5\3\5\5\5\u00cc")
30 buf.write("\n\5\3\5\5\5\u00cf\n\5\3\5\3\5\3\6\6\6\u00d4\n\6\r\6\16")
31 buf.write("\6\u00d5\3\7\3\7\3\7\3\7\5\7\u00dc\n\7\3\b\3\b\3\b\3\t")
32 buf.write("\3\t\3\t\3\t\3\t\5\t\u00e6\n\t\3\t\3\t\3\t\3\n\3\n\5\n")
33 buf.write("\u00ed\n\n\3\n\3\n\3\13\3\13\3\13\5\13\u00f4\n\13\3\13")
34 buf.write("\3\13\3\13\3\13\5\13\u00fa\n\13\7\13\u00fc\n\13\f\13\16")
35 buf.write("\13\u00ff\13\13\3\13\3\13\3\13\5\13\u0104\n\13\3\13\3")
36 buf.write("\13\3\13\3\13\5\13\u010a\n\13\7\13\u010c\n\13\f\13\16")
37 buf.write("\13\u010f\13\13\3\13\3\13\3\13\3\13\5\13\u0115\n\13\5")
38 buf.write("\13\u0117\n\13\5\13\u0119\n\13\3\13\3\13\3\13\5\13\u011e")
39 buf.write("\n\13\5\13\u0120\n\13\5\13\u0122\n\13\3\13\3\13\5\13\u0126")
40 buf.write("\n\13\3\13\3\13\3\13\3\13\5\13\u012c\n\13\7\13\u012e\n")
41 buf.write("\13\f\13\16\13\u0131\13\13\3\13\3\13\3\13\3\13\5\13\u0137")
42 buf.write("\n\13\5\13\u0139\n\13\5\13\u013b\n\13\3\13\3\13\3\13\5")
43 buf.write("\13\u0140\n\13\5\13\u0142\n\13\3\f\3\f\3\f\5\f\u0147\n")
44 buf.write("\f\3\r\3\r\3\r\5\r\u014c\n\r\3\r\3\r\3\r\3\r\5\r\u0152")
45 buf.write("\n\r\7\r\u0154\n\r\f\r\16\r\u0157\13\r\3\r\3\r\3\r\5\r")
46 buf.write("\u015c\n\r\3\r\3\r\3\r\3\r\5\r\u0162\n\r\7\r\u0164\n\r")
47 buf.write("\f\r\16\r\u0167\13\r\3\r\3\r\3\r\3\r\5\r\u016d\n\r\5\r")
48 buf.write("\u016f\n\r\5\r\u0171\n\r\3\r\3\r\3\r\5\r\u0176\n\r\5\r")
49 buf.write("\u0178\n\r\5\r\u017a\n\r\3\r\3\r\5\r\u017e\n\r\3\r\3\r")
50 buf.write("\3\r\3\r\5\r\u0184\n\r\7\r\u0186\n\r\f\r\16\r\u0189\13")
51 buf.write("\r\3\r\3\r\3\r\3\r\5\r\u018f\n\r\5\r\u0191\n\r\5\r\u0193")
52 buf.write("\n\r\3\r\3\r\3\r\5\r\u0198\n\r\5\r\u019a\n\r\3\16\3\16")
53 buf.write("\3\17\3\17\5\17\u01a0\n\17\3\20\3\20\3\20\7\20\u01a5\n")
54 buf.write("\20\f\20\16\20\u01a8\13\20\3\20\5\20\u01ab\n\20\3\20\3")
55 buf.write("\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\5\21\u01b7")
56 buf.write("\n\21\3\22\3\22\3\22\3\22\3\22\5\22\u01be\n\22\3\22\3")
57 buf.write("\22\3\22\5\22\u01c3\n\22\7\22\u01c5\n\22\f\22\16\22\u01c8")
58 buf.write("\13\22\5\22\u01ca\n\22\3\23\3\23\3\23\3\23\5\23\u01d0")
59 buf.write("\n\23\3\24\3\24\5\24\u01d4\n\24\3\24\3\24\3\24\5\24\u01d9")
60 buf.write("\n\24\7\24\u01db\n\24\f\24\16\24\u01de\13\24\3\24\5\24")
61 buf.write("\u01e1\n\24\3\25\3\25\3\26\3\26\3\26\3\27\3\27\3\30\3")
62 buf.write("\30\3\30\3\30\3\30\5\30\u01ef\n\30\3\31\3\31\3\32\3\32")
63 buf.write("\3\33\3\33\5\33\u01f7\n\33\3\34\3\34\3\35\3\35\3\35\3")
64 buf.write("\35\5\35\u01ff\n\35\5\35\u0201\n\35\3\36\3\36\5\36\u0205")
65 buf.write("\n\36\3\37\3\37\3\37\3 \3 \7 \u020c\n \f \16 \u020f\13")
66 buf.write(" \3 \3 \6 \u0213\n \r \16 \u0214\5 \u0217\n \3 \3 \3 ")
67 buf.write("\3 \3 \3 \3 \5 \u0220\n \3!\3!\3!\5!\u0225\n!\3\"\3\"")
68 buf.write("\3\"\5\"\u022a\n\"\3#\3#\3#\7#\u022f\n#\f#\16#\u0232\13")
69 buf.write("#\3#\5#\u0235\n#\3$\3$\3$\7$\u023a\n$\f$\16$\u023d\13")
70 buf.write("$\3%\3%\3%\7%\u0242\n%\f%\16%\u0245\13%\3&\3&\3&\3&\7")
71 buf.write("&\u024b\n&\f&\16&\u024e\13&\3\'\3\'\3\'\3\'\7\'\u0254")
72 buf.write("\n\'\f\'\16\'\u0257\13\'\3(\3(\3(\3(\5(\u025d\n(\3)\3")
73 buf.write(")\3)\3)\3)\3)\3)\3)\3)\5)\u0268\n)\3*\3*\3*\3*\5*\u026e")
74 buf.write("\n*\3+\3+\3+\3+\3+\3+\3+\3+\3+\7+\u0279\n+\f+\16+\u027c")
75 buf.write("\13+\3+\3+\3+\5+\u0281\n+\3,\3,\3,\3,\3,\3,\3,\5,\u028a")
76 buf.write("\n,\3-\3-\3-\3-\3-\3-\3-\3-\3-\5-\u0295\n-\3.\3.\3.\3")
77 buf.write(".\3.\3.\3.\6.\u029e\n.\r.\16.\u029f\3.\3.\3.\5.\u02a5")
78 buf.write("\n.\3.\3.\3.\5.\u02aa\n.\3.\3.\3.\5.\u02af\n.\3/\3/\3")
79 buf.write("/\3/\7/\u02b5\n/\f/\16/\u02b8\13/\3/\3/\3/\3\60\3\60\3")
80 buf.write("\60\5\60\u02c0\n\60\3\61\3\61\3\61\3\61\5\61\u02c6\n\61")
81 buf.write("\5\61\u02c8\n\61\3\62\3\62\3\62\3\62\6\62\u02ce\n\62\r")
82 buf.write("\62\16\62\u02cf\3\62\3\62\5\62\u02d4\n\62\3\63\3\63\3")
83 buf.write("\63\3\63\3\63\3\63\5\63\u02dc\n\63\3\63\5\63\u02df\n\63")
84 buf.write("\3\64\3\64\5\64\u02e3\n\64\3\65\3\65\5\65\u02e7\n\65\3")
85 buf.write("\65\3\65\3\65\3\66\3\66\5\66\u02ee\n\66\3\66\3\66\3\66")
86 buf.write("\3\67\3\67\3\67\7\67\u02f6\n\67\f\67\16\67\u02f9\13\67")
87 buf.write("\38\38\38\78\u02fe\n8\f8\168\u0301\138\39\39\39\59\u0306")
88 buf.write("\n9\3:\3:\3:\3:\7:\u030c\n:\f:\16:\u030f\13:\3;\3;\3;")
89 buf.write("\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\5;\u031e\n;\3<\3<\3<\3")
90 buf.write("=\3=\3=\7=\u0326\n=\f=\16=\u0329\13=\3>\3>\3>\7>\u032e")
91 buf.write("\n>\f>\16>\u0331\13>\3?\3?\3?\7?\u0336\n?\f?\16?\u0339")
92 buf.write("\13?\3@\3@\3@\7@\u033e\n@\f@\16@\u0341\13@\3A\3A\3A\7")
93 buf.write("A\u0346\nA\fA\16A\u0349\13A\3B\3B\3B\7B\u034e\nB\fB\16")
94 buf.write("B\u0351\13B\3C\3C\3C\5C\u0356\nC\3D\3D\3D\5D\u035b\nD")
95 buf.write("\3E\5E\u035e\nE\3E\3E\7E\u0362\nE\fE\16E\u0365\13E\3F")
96 buf.write("\3F\3F\5F\u036a\nF\3F\3F\3F\5F\u036f\nF\3F\3F\3F\5F\u0374")
97 buf.write("\nF\3F\3F\3F\3F\6F\u037a\nF\rF\16F\u037b\3F\3F\3F\3F\5")
98 buf.write("F\u0382\nF\3G\3G\5G\u0386\nG\3G\3G\3G\3G\5G\u038c\nG\7")
99 buf.write("G\u038e\nG\fG\16G\u0391\13G\3G\5G\u0394\nG\5G\u0396\n")
100 buf.write("G\3H\3H\5H\u039a\nH\3H\3H\3H\3H\3H\3H\3H\5H\u03a3\nH\3")
101 buf.write("I\3I\3I\7I\u03a8\nI\fI\16I\u03ab\13I\3I\5I\u03ae\nI\3")
102 buf.write("J\3J\5J\u03b2\nJ\3J\3J\5J\u03b6\nJ\3J\5J\u03b9\nJ\5J\u03bb")
103 buf.write("\nJ\3K\3K\5K\u03bf\nK\3L\3L\5L\u03c3\nL\3L\3L\3L\5L\u03c8")
104 buf.write("\nL\7L\u03ca\nL\fL\16L\u03cd\13L\3L\5L\u03d0\nL\3M\3M")
105 buf.write("\3M\7M\u03d5\nM\fM\16M\u03d8\13M\3M\5M\u03db\nM\3N\3N")
106 buf.write("\3N\3N\3N\3N\5N\u03e3\nN\3N\3N\3N\3N\3N\3N\3N\3N\5N\u03ed")
107 buf.write("\nN\7N\u03ef\nN\fN\16N\u03f2\13N\3N\5N\u03f5\nN\5N\u03f7")
108 buf.write("\nN\3N\3N\5N\u03fb\nN\3N\3N\3N\3N\5N\u0401\nN\7N\u0403")
109 buf.write("\nN\fN\16N\u0406\13N\3N\5N\u0409\nN\5N\u040b\nN\5N\u040d")
110 buf.write("\nN\3O\3O\3O\3O\5O\u0413\nO\3O\5O\u0416\nO\3O\3O\3O\3")
111 buf.write("P\3P\3P\7P\u041e\nP\fP\16P\u0421\13P\3P\5P\u0424\nP\3")
112 buf.write("Q\3Q\5Q\u0428\nQ\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\5Q\u0432\nQ\3")
113 buf.write("R\3R\5R\u0436\nR\3S\5S\u0439\nS\3S\3S\3S\3S\3S\5S\u0440")
114 buf.write("\nS\3T\3T\3T\5T\u0445\nT\3U\3U\3V\3V\5V\u044b\nV\3W\3")
115 buf.write("W\3W\5W\u0450\nW\3W\2\2X\2\4\6\b\n\f\16\20\22\24\26\30")
116 buf.write("\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`b")
117 buf.write("dfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c")
118 buf.write("\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e")
119 buf.write("\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\2\b\3\2Ua\3")
120 buf.write("\2\63\64\3\2BC\3\2DE\5\2\65\65FHSS\4\2DEII\2\u04cf\2\u00b3")
121 buf.write("\3\2\2\2\4\u00b9\3\2\2\2\6\u00be\3\2\2\2\b\u00c7\3\2\2")
122 buf.write("\2\n\u00d3\3\2\2\2\f\u00d7\3\2\2\2\16\u00dd\3\2\2\2\20")
123 buf.write("\u00e0\3\2\2\2\22\u00ea\3\2\2\2\24\u0141\3\2\2\2\26\u0143")
124 buf.write("\3\2\2\2\30\u0199\3\2\2\2\32\u019b\3\2\2\2\34\u019f\3")
125 buf.write("\2\2\2\36\u01a1\3\2\2\2 \u01b6\3\2\2\2\"\u01b8\3\2\2\2")
126 buf.write("$\u01cb\3\2\2\2&\u01d3\3\2\2\2(\u01e2\3\2\2\2*\u01e4\3")
127 buf.write("\2\2\2,\u01e7\3\2\2\2.\u01ee\3\2\2\2\60\u01f0\3\2\2\2")
128 buf.write("\62\u01f2\3\2\2\2\64\u01f4\3\2\2\2\66\u01f8\3\2\2\28\u01fa")
129 buf.write("\3\2\2\2:\u0204\3\2\2\2<\u0206\3\2\2\2>\u0209\3\2\2\2")
130 buf.write("@\u0221\3\2\2\2B\u0226\3\2\2\2D\u022b\3\2\2\2F\u0236\3")
131 buf.write("\2\2\2H\u023e\3\2\2\2J\u0246\3\2\2\2L\u024f\3\2\2\2N\u0258")
132 buf.write("\3\2\2\2P\u0267\3\2\2\2R\u0269\3\2\2\2T\u026f\3\2\2\2")
133 buf.write("V\u0282\3\2\2\2X\u028b\3\2\2\2Z\u0296\3\2\2\2\\\u02b0")
134 buf.write("\3\2\2\2^\u02bc\3\2\2\2`\u02c1\3\2\2\2b\u02d3\3\2\2\2")
135 buf.write("d\u02de\3\2\2\2f\u02e2\3\2\2\2h\u02e4\3\2\2\2j\u02eb\3")
136 buf.write("\2\2\2l\u02f2\3\2\2\2n\u02fa\3\2\2\2p\u0305\3\2\2\2r\u0307")
137 buf.write("\3\2\2\2t\u031d\3\2\2\2v\u031f\3\2\2\2x\u0322\3\2\2\2")
138 buf.write("z\u032a\3\2\2\2|\u0332\3\2\2\2~\u033a\3\2\2\2\u0080\u0342")
139 buf.write("\3\2\2\2\u0082\u034a\3\2\2\2\u0084\u0355\3\2\2\2\u0086")
140 buf.write("\u0357\3\2\2\2\u0088\u035d\3\2\2\2\u008a\u0381\3\2\2\2")
141 buf.write("\u008c\u0385\3\2\2\2\u008e\u03a2\3\2\2\2\u0090\u03a4\3")
142 buf.write("\2\2\2\u0092\u03ba\3\2\2\2\u0094\u03bc\3\2\2\2\u0096\u03c2")
143 buf.write("\3\2\2\2\u0098\u03d1\3\2\2\2\u009a\u040c\3\2\2\2\u009c")
144 buf.write("\u040e\3\2\2\2\u009e\u041a\3\2\2\2\u00a0\u0431\3\2\2\2")
145 buf.write("\u00a2\u0435\3\2\2\2\u00a4\u0438\3\2\2\2\u00a6\u0441\3")
146 buf.write("\2\2\2\u00a8\u0446\3\2\2\2\u00aa\u0448\3\2\2\2\u00ac\u044f")
147 buf.write("\3\2\2\2\u00ae\u00b4\7)\2\2\u00af\u00b4\5\36\20\2\u00b0")
148 buf.write("\u00b1\5P)\2\u00b1\u00b2\7)\2\2\u00b2\u00b4\3\2\2\2\u00b3")
149 buf.write("\u00ae\3\2\2\2\u00b3\u00af\3\2\2\2\u00b3\u00b0\3\2\2\2")
150 buf.write("\u00b4\3\3\2\2\2\u00b5\u00b8\7)\2\2\u00b6\u00b8\5\34\17")
151 buf.write("\2\u00b7\u00b5\3\2\2\2\u00b7\u00b6\3\2\2\2\u00b8\u00bb")
152 buf.write("\3\2\2\2\u00b9\u00b7\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba")
153 buf.write("\u00bc\3\2\2\2\u00bb\u00b9\3\2\2\2\u00bc\u00bd\7\2\2\3")
154 buf.write("\u00bd\5\3\2\2\2\u00be\u00c2\5\u0098M\2\u00bf\u00c1\7")
155 buf.write(")\2\2\u00c0\u00bf\3\2\2\2\u00c1\u00c4\3\2\2\2\u00c2\u00c0")
156 buf.write("\3\2\2\2\u00c2\u00c3\3\2\2\2\u00c3\u00c5\3\2\2\2\u00c4")
157 buf.write("\u00c2\3\2\2\2\u00c5\u00c6\7\2\2\3\u00c6\7\3\2\2\2\u00c7")
158 buf.write("\u00c8\7S\2\2\u00c8\u00ce\5H%\2\u00c9\u00cb\7\66\2\2\u00ca")
159 buf.write("\u00cc\5\u009eP\2\u00cb\u00ca\3\2\2\2\u00cb\u00cc\3\2")
160 buf.write("\2\2\u00cc\u00cd\3\2\2\2\u00cd\u00cf\7\67\2\2\u00ce\u00c9")
161 buf.write("\3\2\2\2\u00ce\u00cf\3\2\2\2\u00cf\u00d0\3\2\2\2\u00d0")
162 buf.write("\u00d1\7)\2\2\u00d1\t\3\2\2\2\u00d2\u00d4\5\b\5\2\u00d3")
163 buf.write("\u00d2\3\2\2\2\u00d4\u00d5\3\2\2\2\u00d5\u00d3\3\2\2\2")
164 buf.write("\u00d5\u00d6\3\2\2\2\u00d6\13\3\2\2\2\u00d7\u00db\5\n")
165 buf.write("\6\2\u00d8\u00dc\5\u009cO\2\u00d9\u00dc\5\20\t\2\u00da")
166 buf.write("\u00dc\5\16\b\2\u00db\u00d8\3\2\2\2\u00db\u00d9\3\2\2")
167 buf.write("\2\u00db\u00da\3\2\2\2\u00dc\r\3\2\2\2\u00dd\u00de\7\'")
168 buf.write("\2\2\u00de\u00df\5\20\t\2\u00df\17\3\2\2\2\u00e0\u00e1")
169 buf.write("\7\6\2\2\u00e1\u00e2\7*\2\2\u00e2\u00e5\5\22\n\2\u00e3")
170 buf.write("\u00e4\7T\2\2\u00e4\u00e6\5d\63\2\u00e5\u00e3\3\2\2\2")
171 buf.write("\u00e5\u00e6\3\2\2\2\u00e6\u00e7\3\2\2\2\u00e7\u00e8\7")
172 buf.write("9\2\2\u00e8\u00e9\5b\62\2\u00e9\21\3\2\2\2\u00ea\u00ec")
173 buf.write("\7\66\2\2\u00eb\u00ed\5\24\13\2\u00ec\u00eb\3\2\2\2\u00ec")
174 buf.write("\u00ed\3\2\2\2\u00ed\u00ee\3\2\2\2\u00ee\u00ef\7\67\2")
175 buf.write("\2\u00ef\23\3\2\2\2\u00f0\u00f3\5\26\f\2\u00f1\u00f2\7")
176 buf.write("<\2\2\u00f2\u00f4\5d\63\2\u00f3\u00f1\3\2\2\2\u00f3\u00f4")
177 buf.write("\3\2\2\2\u00f4\u00fd\3\2\2\2\u00f5\u00f6\78\2\2\u00f6")
178 buf.write("\u00f9\5\26\f\2\u00f7\u00f8\7<\2\2\u00f8\u00fa\5d\63\2")
179 buf.write("\u00f9\u00f7\3\2\2\2\u00f9\u00fa\3\2\2\2\u00fa\u00fc\3")
180 buf.write("\2\2\2\u00fb\u00f5\3\2\2\2\u00fc\u00ff\3\2\2\2\u00fd\u00fb")
181 buf.write("\3\2\2\2\u00fd\u00fe\3\2\2\2\u00fe\u0121\3\2\2\2\u00ff")
182 buf.write("\u00fd\3\2\2\2\u0100\u011f\78\2\2\u0101\u0103\7\65\2\2")
183 buf.write("\u0102\u0104\5\26\f\2\u0103\u0102\3\2\2\2\u0103\u0104")
184 buf.write("\3\2\2\2\u0104\u010d\3\2\2\2\u0105\u0106\78\2\2\u0106")
185 buf.write("\u0109\5\26\f\2\u0107\u0108\7<\2\2\u0108\u010a\5d\63\2")
186 buf.write("\u0109\u0107\3\2\2\2\u0109\u010a\3\2\2\2\u010a\u010c\3")
187 buf.write("\2\2\2\u010b\u0105\3\2\2\2\u010c\u010f\3\2\2\2\u010d\u010b")
188 buf.write("\3\2\2\2\u010d\u010e\3\2\2\2\u010e\u0118\3\2\2\2\u010f")
189 buf.write("\u010d\3\2\2\2\u0110\u0116\78\2\2\u0111\u0112\7;\2\2\u0112")
190 buf.write("\u0114\5\26\f\2\u0113\u0115\78\2\2\u0114\u0113\3\2\2\2")
191 buf.write("\u0114\u0115\3\2\2\2\u0115\u0117\3\2\2\2\u0116\u0111\3")
192 buf.write("\2\2\2\u0116\u0117\3\2\2\2\u0117\u0119\3\2\2\2\u0118\u0110")
193 buf.write("\3\2\2\2\u0118\u0119\3\2\2\2\u0119\u0120\3\2\2\2\u011a")
194 buf.write("\u011b\7;\2\2\u011b\u011d\5\26\f\2\u011c\u011e\78\2\2")
195 buf.write("\u011d\u011c\3\2\2\2\u011d\u011e\3\2\2\2\u011e\u0120\3")
196 buf.write("\2\2\2\u011f\u0101\3\2\2\2\u011f\u011a\3\2\2\2\u011f\u0120")
197 buf.write("\3\2\2\2\u0120\u0122\3\2\2\2\u0121\u0100\3\2\2\2\u0121")
198 buf.write("\u0122\3\2\2\2\u0122\u0142\3\2\2\2\u0123\u0125\7\65\2")
199 buf.write("\2\u0124\u0126\5\26\f\2\u0125\u0124\3\2\2\2\u0125\u0126")
200 buf.write("\3\2\2\2\u0126\u012f\3\2\2\2\u0127\u0128\78\2\2\u0128")
201 buf.write("\u012b\5\26\f\2\u0129\u012a\7<\2\2\u012a\u012c\5d\63\2")
202 buf.write("\u012b\u0129\3\2\2\2\u012b\u012c\3\2\2\2\u012c\u012e\3")
203 buf.write("\2\2\2\u012d\u0127\3\2\2\2\u012e\u0131\3\2\2\2\u012f\u012d")
204 buf.write("\3\2\2\2\u012f\u0130\3\2\2\2\u0130\u013a\3\2\2\2\u0131")
205 buf.write("\u012f\3\2\2\2\u0132\u0138\78\2\2\u0133\u0134\7;\2\2\u0134")
206 buf.write("\u0136\5\26\f\2\u0135\u0137\78\2\2\u0136\u0135\3\2\2\2")
207 buf.write("\u0136\u0137\3\2\2\2\u0137\u0139\3\2\2\2\u0138\u0133\3")
208 buf.write("\2\2\2\u0138\u0139\3\2\2\2\u0139\u013b\3\2\2\2\u013a\u0132")
209 buf.write("\3\2\2\2\u013a\u013b\3\2\2\2\u013b\u0142\3\2\2\2\u013c")
210 buf.write("\u013d\7;\2\2\u013d\u013f\5\26\f\2\u013e\u0140\78\2\2")
211 buf.write("\u013f\u013e\3\2\2\2\u013f\u0140\3\2\2\2\u0140\u0142\3")
212 buf.write("\2\2\2\u0141\u00f0\3\2\2\2\u0141\u0123\3\2\2\2\u0141\u013c")
213 buf.write("\3\2\2\2\u0142\25\3\2\2\2\u0143\u0146\7*\2\2\u0144\u0145")
214 buf.write("\79\2\2\u0145\u0147\5d\63\2\u0146\u0144\3\2\2\2\u0146")
215 buf.write("\u0147\3\2\2\2\u0147\27\3\2\2\2\u0148\u014b\5\32\16\2")
216 buf.write("\u0149\u014a\7<\2\2\u014a\u014c\5d\63\2\u014b\u0149\3")
217 buf.write("\2\2\2\u014b\u014c\3\2\2\2\u014c\u0155\3\2\2\2\u014d\u014e")
218 buf.write("\78\2\2\u014e\u0151\5\32\16\2\u014f\u0150\7<\2\2\u0150")
219 buf.write("\u0152\5d\63\2\u0151\u014f\3\2\2\2\u0151\u0152\3\2\2\2")
220 buf.write("\u0152\u0154\3\2\2\2\u0153\u014d\3\2\2\2\u0154\u0157\3")
221 buf.write("\2\2\2\u0155\u0153\3\2\2\2\u0155\u0156\3\2\2\2\u0156\u0179")
222 buf.write("\3\2\2\2\u0157\u0155\3\2\2\2\u0158\u0177\78\2\2\u0159")
223 buf.write("\u015b\7\65\2\2\u015a\u015c\5\32\16\2\u015b\u015a\3\2")
224 buf.write("\2\2\u015b\u015c\3\2\2\2\u015c\u0165\3\2\2\2\u015d\u015e")
225 buf.write("\78\2\2\u015e\u0161\5\32\16\2\u015f\u0160\7<\2\2\u0160")
226 buf.write("\u0162\5d\63\2\u0161\u015f\3\2\2\2\u0161\u0162\3\2\2\2")
227 buf.write("\u0162\u0164\3\2\2\2\u0163\u015d\3\2\2\2\u0164\u0167\3")
228 buf.write("\2\2\2\u0165\u0163\3\2\2\2\u0165\u0166\3\2\2\2\u0166\u0170")
229 buf.write("\3\2\2\2\u0167\u0165\3\2\2\2\u0168\u016e\78\2\2\u0169")
230 buf.write("\u016a\7;\2\2\u016a\u016c\5\32\16\2\u016b\u016d\78\2\2")
231 buf.write("\u016c\u016b\3\2\2\2\u016c\u016d\3\2\2\2\u016d\u016f\3")
232 buf.write("\2\2\2\u016e\u0169\3\2\2\2\u016e\u016f\3\2\2\2\u016f\u0171")
233 buf.write("\3\2\2\2\u0170\u0168\3\2\2\2\u0170\u0171\3\2\2\2\u0171")
234 buf.write("\u0178\3\2\2\2\u0172\u0173\7;\2\2\u0173\u0175\5\32\16")
235 buf.write("\2\u0174\u0176\78\2\2\u0175\u0174\3\2\2\2\u0175\u0176")
236 buf.write("\3\2\2\2\u0176\u0178\3\2\2\2\u0177\u0159\3\2\2\2\u0177")
237 buf.write("\u0172\3\2\2\2\u0177\u0178\3\2\2\2\u0178\u017a\3\2\2\2")
238 buf.write("\u0179\u0158\3\2\2\2\u0179\u017a\3\2\2\2\u017a\u019a\3")
239 buf.write("\2\2\2\u017b\u017d\7\65\2\2\u017c\u017e\5\32\16\2\u017d")
240 buf.write("\u017c\3\2\2\2\u017d\u017e\3\2\2\2\u017e\u0187\3\2\2\2")
241 buf.write("\u017f\u0180\78\2\2\u0180\u0183\5\32\16\2\u0181\u0182")
242 buf.write("\7<\2\2\u0182\u0184\5d\63\2\u0183\u0181\3\2\2\2\u0183")
243 buf.write("\u0184\3\2\2\2\u0184\u0186\3\2\2\2\u0185\u017f\3\2\2\2")
244 buf.write("\u0186\u0189\3\2\2\2\u0187\u0185\3\2\2\2\u0187\u0188\3")
245 buf.write("\2\2\2\u0188\u0192\3\2\2\2\u0189\u0187\3\2\2\2\u018a\u0190")
246 buf.write("\78\2\2\u018b\u018c\7;\2\2\u018c\u018e\5\32\16\2\u018d")
247 buf.write("\u018f\78\2\2\u018e\u018d\3\2\2\2\u018e\u018f\3\2\2\2")
248 buf.write("\u018f\u0191\3\2\2\2\u0190\u018b\3\2\2\2\u0190\u0191\3")
249 buf.write("\2\2\2\u0191\u0193\3\2\2\2\u0192\u018a\3\2\2\2\u0192\u0193")
250 buf.write("\3\2\2\2\u0193\u019a\3\2\2\2\u0194\u0195\7;\2\2\u0195")
251 buf.write("\u0197\5\32\16\2\u0196\u0198\78\2\2\u0197\u0196\3\2\2")
252 buf.write("\2\u0197\u0198\3\2\2\2\u0198\u019a\3\2\2\2\u0199\u0148")
253 buf.write("\3\2\2\2\u0199\u017b\3\2\2\2\u0199\u0194\3\2\2\2\u019a")
254 buf.write("\31\3\2\2\2\u019b\u019c\7*\2\2\u019c\33\3\2\2\2\u019d")
255 buf.write("\u01a0\5\36\20\2\u019e\u01a0\5P)\2\u019f\u019d\3\2\2\2")
256 buf.write("\u019f\u019e\3\2\2\2\u01a0\35\3\2\2\2\u01a1\u01a6\5 \21")
257 buf.write("\2\u01a2\u01a3\7:\2\2\u01a3\u01a5\5 \21\2\u01a4\u01a2")
258 buf.write("\3\2\2\2\u01a5\u01a8\3\2\2\2\u01a6\u01a4\3\2\2\2\u01a6")
259 buf.write("\u01a7\3\2\2\2\u01a7\u01aa\3\2\2\2\u01a8\u01a6\3\2\2\2")
260 buf.write("\u01a9\u01ab\7:\2\2\u01aa\u01a9\3\2\2\2\u01aa\u01ab\3")
261 buf.write("\2\2\2\u01ab\u01ac\3\2\2\2\u01ac\u01ad\7)\2\2\u01ad\37")
262 buf.write("\3\2\2\2\u01ae\u01b7\5\"\22\2\u01af\u01b7\5*\26\2\u01b0")
263 buf.write("\u01b7\5,\27\2\u01b1\u01b7\5.\30\2\u01b2\u01b7\5:\36\2")
264 buf.write("\u01b3\u01b7\5J&\2\u01b4\u01b7\5L\'\2\u01b5\u01b7\5N(")
265 buf.write("\2\u01b6\u01ae\3\2\2\2\u01b6\u01af\3\2\2\2\u01b6\u01b0")
266 buf.write("\3\2\2\2\u01b6\u01b1\3\2\2\2\u01b6\u01b2\3\2\2\2\u01b6")
267 buf.write("\u01b3\3\2\2\2\u01b6\u01b4\3\2\2\2\u01b6\u01b5\3\2\2\2")
268 buf.write("\u01b7!\3\2\2\2\u01b8\u01c9\5&\24\2\u01b9\u01ca\5$\23")
269 buf.write("\2\u01ba\u01bd\5(\25\2\u01bb\u01be\5\u00aaV\2\u01bc\u01be")
270 buf.write("\5\u0098M\2\u01bd\u01bb\3\2\2\2\u01bd\u01bc\3\2\2\2\u01be")
271 buf.write("\u01ca\3\2\2\2\u01bf\u01c2\7<\2\2\u01c0\u01c3\5\u00aa")
272 buf.write("V\2\u01c1\u01c3\5&\24\2\u01c2\u01c0\3\2\2\2\u01c2\u01c1")
273 buf.write("\3\2\2\2\u01c3\u01c5\3\2\2\2\u01c4\u01bf\3\2\2\2\u01c5")
274 buf.write("\u01c8\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2\2\2")
275 buf.write("\u01c7\u01ca\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c9\u01b9\3")
276 buf.write("\2\2\2\u01c9\u01ba\3\2\2\2\u01c9\u01c6\3\2\2\2\u01ca#")
277 buf.write("\3\2\2\2\u01cb\u01cc\79\2\2\u01cc\u01cf\5d\63\2\u01cd")
278 buf.write("\u01ce\7<\2\2\u01ce\u01d0\5d\63\2\u01cf\u01cd\3\2\2\2")
279 buf.write("\u01cf\u01d0\3\2\2\2\u01d0%\3\2\2\2\u01d1\u01d4\5d\63")
280 buf.write("\2\u01d2\u01d4\5v<\2\u01d3\u01d1\3\2\2\2\u01d3\u01d2\3")
281 buf.write("\2\2\2\u01d4\u01dc\3\2\2\2\u01d5\u01d8\78\2\2\u01d6\u01d9")
282 buf.write("\5d\63\2\u01d7\u01d9\5v<\2\u01d8\u01d6\3\2\2\2\u01d8\u01d7")
283 buf.write("\3\2\2\2\u01d9\u01db\3\2\2\2\u01da\u01d5\3\2\2\2\u01db")
284 buf.write("\u01de\3\2\2\2\u01dc\u01da\3\2\2\2\u01dc\u01dd\3\2\2\2")
285 buf.write("\u01dd\u01e0\3\2\2\2\u01de\u01dc\3\2\2\2\u01df\u01e1\7")
286 buf.write("8\2\2\u01e0\u01df\3\2\2\2\u01e0\u01e1\3\2\2\2\u01e1\'")
287 buf.write("\3\2\2\2\u01e2\u01e3\t\2\2\2\u01e3)\3\2\2\2\u01e4\u01e5")
288 buf.write("\7#\2\2\u01e5\u01e6\5\u0096L\2\u01e6+\3\2\2\2\u01e7\u01e8")
289 buf.write("\7$\2\2\u01e8-\3\2\2\2\u01e9\u01ef\5\60\31\2\u01ea\u01ef")
290 buf.write("\5\62\32\2\u01eb\u01ef\5\64\33\2\u01ec\u01ef\58\35\2\u01ed")
291 buf.write("\u01ef\5\66\34\2\u01ee\u01e9\3\2\2\2\u01ee\u01ea\3\2\2")
292 buf.write("\2\u01ee\u01eb\3\2\2\2\u01ee\u01ec\3\2\2\2\u01ee\u01ed")
293 buf.write("\3\2\2\2\u01ef/\3\2\2\2\u01f0\u01f1\7&\2\2\u01f1\61\3")
294 buf.write("\2\2\2\u01f2\u01f3\7%\2\2\u01f3\63\3\2\2\2\u01f4\u01f6")
295 buf.write("\7\7\2\2\u01f5\u01f7\5\u0098M\2\u01f6\u01f5\3\2\2\2\u01f6")
296 buf.write("\u01f7\3\2\2\2\u01f7\65\3\2\2\2\u01f8\u01f9\5\u00aaV\2")
297 buf.write("\u01f9\67\3\2\2\2\u01fa\u0200\7\b\2\2\u01fb\u01fe\5d\63")
298 buf.write("\2\u01fc\u01fd\7\t\2\2\u01fd\u01ff\5d\63\2\u01fe\u01fc")
299 buf.write("\3\2\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0201\3\2\2\2\u0200")
300 buf.write("\u01fb\3\2\2\2\u0200\u0201\3\2\2\2\u02019\3\2\2\2\u0202")
301 buf.write("\u0205\5<\37\2\u0203\u0205\5> \2\u0204\u0202\3\2\2\2\u0204")
302 buf.write("\u0203\3\2\2\2\u0205;\3\2\2\2\u0206\u0207\7\n\2\2\u0207")
303 buf.write("\u0208\5F$\2\u0208=\3\2\2\2\u0209\u0216\7\t\2\2\u020a")
304 buf.write("\u020c\t\3\2\2\u020b\u020a\3\2\2\2\u020c\u020f\3\2\2\2")
305 buf.write("\u020d\u020b\3\2\2\2\u020d\u020e\3\2\2\2\u020e\u0210\3")
306 buf.write("\2\2\2\u020f\u020d\3\2\2\2\u0210\u0217\5H%\2\u0211\u0213")
307 buf.write("\t\3\2\2\u0212\u0211\3\2\2\2\u0213\u0214\3\2\2\2\u0214")
308 buf.write("\u0212\3\2\2\2\u0214\u0215\3\2\2\2\u0215\u0217\3\2\2\2")
309 buf.write("\u0216\u020d\3\2\2\2\u0216\u0212\3\2\2\2\u0217\u0218\3")
310 buf.write("\2\2\2\u0218\u021f\7\n\2\2\u0219\u0220\7\65\2\2\u021a")
311 buf.write("\u021b\7\66\2\2\u021b\u021c\5D#\2\u021c\u021d\7\67\2\2")
312 buf.write("\u021d\u0220\3\2\2\2\u021e\u0220\5D#\2\u021f\u0219\3\2")
313 buf.write("\2\2\u021f\u021a\3\2\2\2\u021f\u021e\3\2\2\2\u0220?\3")
314 buf.write("\2\2\2\u0221\u0224\7*\2\2\u0222\u0223\7\13\2\2\u0223\u0225")
315 buf.write("\7*\2\2\u0224\u0222\3\2\2\2\u0224\u0225\3\2\2\2\u0225")
316 buf.write("A\3\2\2\2\u0226\u0229\5H%\2\u0227\u0228\7\13\2\2\u0228")
317 buf.write("\u022a\7*\2\2\u0229\u0227\3\2\2\2\u0229\u022a\3\2\2\2")
318 buf.write("\u022aC\3\2\2\2\u022b\u0230\5@!\2\u022c\u022d\78\2\2\u022d")
319 buf.write("\u022f\5@!\2\u022e\u022c\3\2\2\2\u022f\u0232\3\2\2\2\u0230")
320 buf.write("\u022e\3\2\2\2\u0230\u0231\3\2\2\2\u0231\u0234\3\2\2\2")
321 buf.write("\u0232\u0230\3\2\2\2\u0233\u0235\78\2\2\u0234\u0233\3")
322 buf.write("\2\2\2\u0234\u0235\3\2\2\2\u0235E\3\2\2\2\u0236\u023b")
323 buf.write("\5B\"\2\u0237\u0238\78\2\2\u0238\u023a\5B\"\2\u0239\u0237")
324 buf.write("\3\2\2\2\u023a\u023d\3\2\2\2\u023b\u0239\3\2\2\2\u023b")
325 buf.write("\u023c\3\2\2\2\u023cG\3\2\2\2\u023d\u023b\3\2\2\2\u023e")
326 buf.write("\u0243\7*\2\2\u023f\u0240\7\63\2\2\u0240\u0242\7*\2\2")
327 buf.write("\u0241\u023f\3\2\2\2\u0242\u0245\3\2\2\2\u0243\u0241\3")
328 buf.write("\2\2\2\u0243\u0244\3\2\2\2\u0244I\3\2\2\2\u0245\u0243")
329 buf.write("\3\2\2\2\u0246\u0247\7\f\2\2\u0247\u024c\7*\2\2\u0248")
330 buf.write("\u0249\78\2\2\u0249\u024b\7*\2\2\u024a\u0248\3\2\2\2\u024b")
331 buf.write("\u024e\3\2\2\2\u024c\u024a\3\2\2\2\u024c\u024d\3\2\2\2")
332 buf.write("\u024dK\3\2\2\2\u024e\u024c\3\2\2\2\u024f\u0250\7\r\2")
333 buf.write("\2\u0250\u0255\7*\2\2\u0251\u0252\78\2\2\u0252\u0254\7")
334 buf.write("*\2\2\u0253\u0251\3\2\2\2\u0254\u0257\3\2\2\2\u0255\u0253")
335 buf.write("\3\2\2\2\u0255\u0256\3\2\2\2\u0256M\3\2\2\2\u0257\u0255")
336 buf.write("\3\2\2\2\u0258\u0259\7\16\2\2\u0259\u025c\5d\63\2\u025a")
337 buf.write("\u025b\78\2\2\u025b\u025d\5d\63\2\u025c\u025a\3\2\2\2")
338 buf.write("\u025c\u025d\3\2\2\2\u025dO\3\2\2\2\u025e\u0268\5T+\2")
339 buf.write("\u025f\u0268\5V,\2\u0260\u0268\5X-\2\u0261\u0268\5Z.\2")
340 buf.write("\u0262\u0268\5\\/\2\u0263\u0268\5\20\t\2\u0264\u0268\5")
341 buf.write("\u009cO\2\u0265\u0268\5\f\7\2\u0266\u0268\5R*\2\u0267")
342 buf.write("\u025e\3\2\2\2\u0267\u025f\3\2\2\2\u0267\u0260\3\2\2\2")
343 buf.write("\u0267\u0261\3\2\2\2\u0267\u0262\3\2\2\2\u0267\u0263\3")
344 buf.write("\2\2\2\u0267\u0264\3\2\2\2\u0267\u0265\3\2\2\2\u0267\u0266")
345 buf.write("\3\2\2\2\u0268Q\3\2\2\2\u0269\u026d\7\'\2\2\u026a\u026e")
346 buf.write("\5\20\t\2\u026b\u026e\5\\/\2\u026c\u026e\5X-\2\u026d\u026a")
347 buf.write("\3\2\2\2\u026d\u026b\3\2\2\2\u026d\u026c\3\2\2\2\u026e")
348 buf.write("S\3\2\2\2\u026f\u0270\7\17\2\2\u0270\u0271\5d\63\2\u0271")
349 buf.write("\u0272\79\2\2\u0272\u027a\5b\62\2\u0273\u0274\7\20\2\2")
350 buf.write("\u0274\u0275\5d\63\2\u0275\u0276\79\2\2\u0276\u0277\5")
351 buf.write("b\62\2\u0277\u0279\3\2\2\2\u0278\u0273\3\2\2\2\u0279\u027c")
352 buf.write("\3\2\2\2\u027a\u0278\3\2\2\2\u027a\u027b\3\2\2\2\u027b")
353 buf.write("\u0280\3\2\2\2\u027c\u027a\3\2\2\2\u027d\u027e\7\21\2")
354 buf.write("\2\u027e\u027f\79\2\2\u027f\u0281\5b\62\2\u0280\u027d")
355 buf.write("\3\2\2\2\u0280\u0281\3\2\2\2\u0281U\3\2\2\2\u0282\u0283")
356 buf.write("\7\22\2\2\u0283\u0284\5d\63\2\u0284\u0285\79\2\2\u0285")
357 buf.write("\u0289\5b\62\2\u0286\u0287\7\21\2\2\u0287\u0288\79\2\2")
358 buf.write("\u0288\u028a\5b\62\2\u0289\u0286\3\2\2\2\u0289\u028a\3")
359 buf.write("\2\2\2\u028aW\3\2\2\2\u028b\u028c\7\23\2\2\u028c\u028d")
360 buf.write("\5\u0096L\2\u028d\u028e\7\24\2\2\u028e\u028f\5\u0098M")
361 buf.write("\2\u028f\u0290\79\2\2\u0290\u0294\5b\62\2\u0291\u0292")
362 buf.write("\7\21\2\2\u0292\u0293\79\2\2\u0293\u0295\5b\62\2\u0294")
363 buf.write("\u0291\3\2\2\2\u0294\u0295\3\2\2\2\u0295Y\3\2\2\2\u0296")
364 buf.write("\u0297\7\25\2\2\u0297\u0298\79\2\2\u0298\u02ae\5b\62\2")
365 buf.write("\u0299\u029a\5`\61\2\u029a\u029b\79\2\2\u029b\u029c\5")
366 buf.write("b\62\2\u029c\u029e\3\2\2\2\u029d\u0299\3\2\2\2\u029e\u029f")
367 buf.write("\3\2\2\2\u029f\u029d\3\2\2\2\u029f\u02a0\3\2\2\2\u02a0")
368 buf.write("\u02a4\3\2\2\2\u02a1\u02a2\7\21\2\2\u02a2\u02a3\79\2\2")
369 buf.write("\u02a3\u02a5\5b\62\2\u02a4\u02a1\3\2\2\2\u02a4\u02a5\3")
370 buf.write("\2\2\2\u02a5\u02a9\3\2\2\2\u02a6\u02a7\7\26\2\2\u02a7")
371 buf.write("\u02a8\79\2\2\u02a8\u02aa\5b\62\2\u02a9\u02a6\3\2\2\2")
372 buf.write("\u02a9\u02aa\3\2\2\2\u02aa\u02af\3\2\2\2\u02ab\u02ac\7")
373 buf.write("\26\2\2\u02ac\u02ad\79\2\2\u02ad\u02af\5b\62\2\u02ae\u029d")
374 buf.write("\3\2\2\2\u02ae\u02ab\3\2\2\2\u02af[\3\2\2\2\u02b0\u02b1")
375 buf.write("\7\27\2\2\u02b1\u02b6\5^\60\2\u02b2\u02b3\78\2\2\u02b3")
376 buf.write("\u02b5\5^\60\2\u02b4\u02b2\3\2\2\2\u02b5\u02b8\3\2\2\2")
377 buf.write("\u02b6\u02b4\3\2\2\2\u02b6\u02b7\3\2\2\2\u02b7\u02b9\3")
378 buf.write("\2\2\2\u02b8\u02b6\3\2\2\2\u02b9\u02ba\79\2\2\u02ba\u02bb")
379 buf.write("\5b\62\2\u02bb]\3\2\2\2\u02bc\u02bf\5d\63\2\u02bd\u02be")
380 buf.write("\7\13\2\2\u02be\u02c0\5x=\2\u02bf\u02bd\3\2\2\2\u02bf")
381 buf.write("\u02c0\3\2\2\2\u02c0_\3\2\2\2\u02c1\u02c7\7\30\2\2\u02c2")
382 buf.write("\u02c5\5d\63\2\u02c3\u02c4\7\13\2\2\u02c4\u02c6\7*\2\2")
383 buf.write("\u02c5\u02c3\3\2\2\2\u02c5\u02c6\3\2\2\2\u02c6\u02c8\3")
384 buf.write("\2\2\2\u02c7\u02c2\3\2\2\2\u02c7\u02c8\3\2\2\2\u02c8a")
385 buf.write("\3\2\2\2\u02c9\u02d4\5\36\20\2\u02ca\u02cb\7)\2\2\u02cb")
386 buf.write("\u02cd\7d\2\2\u02cc\u02ce\5\34\17\2\u02cd\u02cc\3\2\2")
387 buf.write("\2\u02ce\u02cf\3\2\2\2\u02cf\u02cd\3\2\2\2\u02cf\u02d0")
388 buf.write("\3\2\2\2\u02d0\u02d1\3\2\2\2\u02d1\u02d2\7e\2\2\u02d2")
389 buf.write("\u02d4\3\2\2\2\u02d3\u02c9\3\2\2\2\u02d3\u02ca\3\2\2\2")
390 buf.write("\u02d4c\3\2\2\2\u02d5\u02db\5l\67\2\u02d6\u02d7\7\17\2")
391 buf.write("\2\u02d7\u02d8\5l\67\2\u02d8\u02d9\7\21\2\2\u02d9\u02da")
392 buf.write("\5d\63\2\u02da\u02dc\3\2\2\2\u02db\u02d6\3\2\2\2\u02db")
393 buf.write("\u02dc\3\2\2\2\u02dc\u02df\3\2\2\2\u02dd\u02df\5h\65\2")
394 buf.write("\u02de\u02d5\3\2\2\2\u02de\u02dd\3\2\2\2\u02dfe\3\2\2")
395 buf.write("\2\u02e0\u02e3\5l\67\2\u02e1\u02e3\5j\66\2\u02e2\u02e0")
396 buf.write("\3\2\2\2\u02e2\u02e1\3\2\2\2\u02e3g\3\2\2\2\u02e4\u02e6")
397 buf.write("\7\31\2\2\u02e5\u02e7\5\30\r\2\u02e6\u02e5\3\2\2\2\u02e6")
398 buf.write("\u02e7\3\2\2\2\u02e7\u02e8\3\2\2\2\u02e8\u02e9\79\2\2")
399 buf.write("\u02e9\u02ea\5d\63\2\u02eai\3\2\2\2\u02eb\u02ed\7\31\2")
400 buf.write("\2\u02ec\u02ee\5\30\r\2\u02ed\u02ec\3\2\2\2\u02ed\u02ee")
401 buf.write("\3\2\2\2\u02ee\u02ef\3\2\2\2\u02ef\u02f0\79\2\2\u02f0")
402 buf.write("\u02f1\5f\64\2\u02f1k\3\2\2\2\u02f2\u02f7\5n8\2\u02f3")
403 buf.write("\u02f4\7\32\2\2\u02f4\u02f6\5n8\2\u02f5\u02f3\3\2\2\2")
404 buf.write("\u02f6\u02f9\3\2\2\2\u02f7\u02f5\3\2\2\2\u02f7\u02f8\3")
405 buf.write("\2\2\2\u02f8m\3\2\2\2\u02f9\u02f7\3\2\2\2\u02fa\u02ff")
406 buf.write("\5p9\2\u02fb\u02fc\7\33\2\2\u02fc\u02fe\5p9\2\u02fd\u02fb")
407 buf.write("\3\2\2\2\u02fe\u0301\3\2\2\2\u02ff\u02fd\3\2\2\2\u02ff")
408 buf.write("\u0300\3\2\2\2\u0300o\3\2\2\2\u0301\u02ff\3\2\2\2\u0302")
409 buf.write("\u0303\7\34\2\2\u0303\u0306\5p9\2\u0304\u0306\5r:\2\u0305")
410 buf.write("\u0302\3\2\2\2\u0305\u0304\3\2\2\2\u0306q\3\2\2\2\u0307")
411 buf.write("\u030d\5x=\2\u0308\u0309\5t;\2\u0309\u030a\5x=\2\u030a")
412 buf.write("\u030c\3\2\2\2\u030b\u0308\3\2\2\2\u030c\u030f\3\2\2\2")
413 buf.write("\u030d\u030b\3\2\2\2\u030d\u030e\3\2\2\2\u030es\3\2\2")
414 buf.write("\2\u030f\u030d\3\2\2\2\u0310\u031e\7L\2\2\u0311\u031e")
415 buf.write("\7M\2\2\u0312\u031e\7N\2\2\u0313\u031e\7O\2\2\u0314\u031e")
416 buf.write("\7P\2\2\u0315\u031e\7Q\2\2\u0316\u031e\7R\2\2\u0317\u031e")
417 buf.write("\7\24\2\2\u0318\u0319\7\34\2\2\u0319\u031e\7\24\2\2\u031a")
418 buf.write("\u031e\7\35\2\2\u031b\u031c\7\35\2\2\u031c\u031e\7\34")
419 buf.write("\2\2\u031d\u0310\3\2\2\2\u031d\u0311\3\2\2\2\u031d\u0312")
420 buf.write("\3\2\2\2\u031d\u0313\3\2\2\2\u031d\u0314\3\2\2\2\u031d")
421 buf.write("\u0315\3\2\2\2\u031d\u0316\3\2\2\2\u031d\u0317\3\2\2\2")
422 buf.write("\u031d\u0318\3\2\2\2\u031d\u031a\3\2\2\2\u031d\u031b\3")
423 buf.write("\2\2\2\u031eu\3\2\2\2\u031f\u0320\7\65\2\2\u0320\u0321")
424 buf.write("\5x=\2\u0321w\3\2\2\2\u0322\u0327\5z>\2\u0323\u0324\7")
425 buf.write("?\2\2\u0324\u0326\5z>\2\u0325\u0323\3\2\2\2\u0326\u0329")
426 buf.write("\3\2\2\2\u0327\u0325\3\2\2\2\u0327\u0328\3\2\2\2\u0328")
427 buf.write("y\3\2\2\2\u0329\u0327\3\2\2\2\u032a\u032f\5|?\2\u032b")
428 buf.write("\u032c\7@\2\2\u032c\u032e\5|?\2\u032d\u032b\3\2\2\2\u032e")
429 buf.write("\u0331\3\2\2\2\u032f\u032d\3\2\2\2\u032f\u0330\3\2\2\2")
430 buf.write("\u0330{\3\2\2\2\u0331\u032f\3\2\2\2\u0332\u0337\5~@\2")
431 buf.write("\u0333\u0334\7A\2\2\u0334\u0336\5~@\2\u0335\u0333\3\2")
432 buf.write("\2\2\u0336\u0339\3\2\2\2\u0337\u0335\3\2\2\2\u0337\u0338")
433 buf.write("\3\2\2\2\u0338}\3\2\2\2\u0339\u0337\3\2\2\2\u033a\u033f")
434 buf.write("\5\u0080A\2\u033b\u033c\t\4\2\2\u033c\u033e\5\u0080A\2")
435 buf.write("\u033d\u033b\3\2\2\2\u033e\u0341\3\2\2\2\u033f\u033d\3")
436 buf.write("\2\2\2\u033f\u0340\3\2\2\2\u0340\177\3\2\2\2\u0341\u033f")
437 buf.write("\3\2\2\2\u0342\u0347\5\u0082B\2\u0343\u0344\t\5\2\2\u0344")
438 buf.write("\u0346\5\u0082B\2\u0345\u0343\3\2\2\2\u0346\u0349\3\2")
439 buf.write("\2\2\u0347\u0345\3\2\2\2\u0347\u0348\3\2\2\2\u0348\u0081")
440 buf.write("\3\2\2\2\u0349\u0347\3\2\2\2\u034a\u034f\5\u0084C\2\u034b")
441 buf.write("\u034c\t\6\2\2\u034c\u034e\5\u0084C\2\u034d\u034b\3\2")
442 buf.write("\2\2\u034e\u0351\3\2\2\2\u034f\u034d\3\2\2\2\u034f\u0350")
443 buf.write("\3\2\2\2\u0350\u0083\3\2\2\2\u0351\u034f\3\2\2\2\u0352")
444 buf.write("\u0353\t\7\2\2\u0353\u0356\5\u0084C\2\u0354\u0356\5\u0086")
445 buf.write("D\2\u0355\u0352\3\2\2\2\u0355\u0354\3\2\2\2\u0356\u0085")
446 buf.write("\3\2\2\2\u0357\u035a\5\u0088E\2\u0358\u0359\7;\2\2\u0359")
447 buf.write("\u035b\5\u0084C\2\u035a\u0358\3\2\2\2\u035a\u035b\3\2")
448 buf.write("\2\2\u035b\u0087\3\2\2\2\u035c\u035e\7(\2\2\u035d\u035c")
449 buf.write("\3\2\2\2\u035d\u035e\3\2\2\2\u035e\u035f\3\2\2\2\u035f")
450 buf.write("\u0363\5\u008aF\2\u0360\u0362\5\u008eH\2\u0361\u0360\3")
451 buf.write("\2\2\2\u0362\u0365\3\2\2\2\u0363\u0361\3\2\2\2\u0363\u0364")
452 buf.write("\3\2\2\2\u0364\u0089\3\2\2\2\u0365\u0363\3\2\2\2\u0366")
453 buf.write("\u0369\7\66\2\2\u0367\u036a\5\u00aaV\2\u0368\u036a\5\u008c")
454 buf.write("G\2\u0369\u0367\3\2\2\2\u0369\u0368\3\2\2\2\u0369\u036a")
455 buf.write("\3\2\2\2\u036a\u036b\3\2\2\2\u036b\u0382\7\67\2\2\u036c")
456 buf.write("\u036e\7=\2\2\u036d\u036f\5\u008cG\2\u036e\u036d\3\2\2")
457 buf.write("\2\u036e\u036f\3\2\2\2\u036f\u0370\3\2\2\2\u0370\u0382")
458 buf.write("\7>\2\2\u0371\u0373\7J\2\2\u0372\u0374\5\u009aN\2\u0373")
459 buf.write("\u0372\3\2\2\2\u0373\u0374\3\2\2\2\u0374\u0375\3\2\2\2")
460 buf.write("\u0375\u0382\7K\2\2\u0376\u0382\7*\2\2\u0377\u0382\7\4")
461 buf.write("\2\2\u0378\u037a\7\3\2\2\u0379\u0378\3\2\2\2\u037a\u037b")
462 buf.write("\3\2\2\2\u037b\u0379\3\2\2\2\u037b\u037c\3\2\2\2\u037c")
463 buf.write("\u0382\3\2\2\2\u037d\u0382\7\64\2\2\u037e\u0382\7\36\2")
464 buf.write("\2\u037f\u0382\7\37\2\2\u0380\u0382\7 \2\2\u0381\u0366")
465 buf.write("\3\2\2\2\u0381\u036c\3\2\2\2\u0381\u0371\3\2\2\2\u0381")
466 buf.write("\u0376\3\2\2\2\u0381\u0377\3\2\2\2\u0381\u0379\3\2\2\2")
467 buf.write("\u0381\u037d\3\2\2\2\u0381\u037e\3\2\2\2\u0381\u037f\3")
468 buf.write("\2\2\2\u0381\u0380\3\2\2\2\u0382\u008b\3\2\2\2\u0383\u0386")
469 buf.write("\5d\63\2\u0384\u0386\5v<\2\u0385\u0383\3\2\2\2\u0385\u0384")
470 buf.write("\3\2\2\2\u0386\u0395\3\2\2\2\u0387\u0396\5\u00a4S\2\u0388")
471 buf.write("\u038b\78\2\2\u0389\u038c\5d\63\2\u038a\u038c\5v<\2\u038b")
472 buf.write("\u0389\3\2\2\2\u038b\u038a\3\2\2\2\u038c\u038e\3\2\2\2")
473 buf.write("\u038d\u0388\3\2\2\2\u038e\u0391\3\2\2\2\u038f\u038d\3")
474 buf.write("\2\2\2\u038f\u0390\3\2\2\2\u0390\u0393\3\2\2\2\u0391\u038f")
475 buf.write("\3\2\2\2\u0392\u0394\78\2\2\u0393\u0392\3\2\2\2\u0393")
476 buf.write("\u0394\3\2\2\2\u0394\u0396\3\2\2\2\u0395\u0387\3\2\2\2")
477 buf.write("\u0395\u038f\3\2\2\2\u0396\u008d\3\2\2\2\u0397\u0399\7")
478 buf.write("\66\2\2\u0398\u039a\5\u009eP\2\u0399\u0398\3\2\2\2\u0399")
479 buf.write("\u039a\3\2\2\2\u039a\u039b\3\2\2\2\u039b\u03a3\7\67\2")
480 buf.write("\2\u039c\u039d\7=\2\2\u039d\u039e\5\u0090I\2\u039e\u039f")
481 buf.write("\7>\2\2\u039f\u03a3\3\2\2\2\u03a0\u03a1\7\63\2\2\u03a1")
482 buf.write("\u03a3\7*\2\2\u03a2\u0397\3\2\2\2\u03a2\u039c\3\2\2\2")
483 buf.write("\u03a2\u03a0\3\2\2\2\u03a3\u008f\3\2\2\2\u03a4\u03a9\5")
484 buf.write("\u0092J\2\u03a5\u03a6\78\2\2\u03a6\u03a8\5\u0092J\2\u03a7")
485 buf.write("\u03a5\3\2\2\2\u03a8\u03ab\3\2\2\2\u03a9\u03a7\3\2\2\2")
486 buf.write("\u03a9\u03aa\3\2\2\2\u03aa\u03ad\3\2\2\2\u03ab\u03a9\3")
487 buf.write("\2\2\2\u03ac\u03ae\78\2\2\u03ad\u03ac\3\2\2\2\u03ad\u03ae")
488 buf.write("\3\2\2\2\u03ae\u0091\3\2\2\2\u03af\u03bb\5d\63\2\u03b0")
489 buf.write("\u03b2\5d\63\2\u03b1\u03b0\3\2\2\2\u03b1\u03b2\3\2\2\2")
490 buf.write("\u03b2\u03b3\3\2\2\2\u03b3\u03b5\79\2\2\u03b4\u03b6\5")
491 buf.write("d\63\2\u03b5\u03b4\3\2\2\2\u03b5\u03b6\3\2\2\2\u03b6\u03b8")
492 buf.write("\3\2\2\2\u03b7\u03b9\5\u0094K\2\u03b8\u03b7\3\2\2\2\u03b8")
493 buf.write("\u03b9\3\2\2\2\u03b9\u03bb\3\2\2\2\u03ba\u03af\3\2\2\2")
494 buf.write("\u03ba\u03b1\3\2\2\2\u03bb\u0093\3\2\2\2\u03bc\u03be\7")
495 buf.write("9\2\2\u03bd\u03bf\5d\63\2\u03be\u03bd\3\2\2\2\u03be\u03bf")
496 buf.write("\3\2\2\2\u03bf\u0095\3\2\2\2\u03c0\u03c3\5x=\2\u03c1\u03c3")
497 buf.write("\5v<\2\u03c2\u03c0\3\2\2\2\u03c2\u03c1\3\2\2\2\u03c3\u03cb")
498 buf.write("\3\2\2\2\u03c4\u03c7\78\2\2\u03c5\u03c8\5x=\2\u03c6\u03c8")
499 buf.write("\5v<\2\u03c7\u03c5\3\2\2\2\u03c7\u03c6\3\2\2\2\u03c8\u03ca")
500 buf.write("\3\2\2\2\u03c9\u03c4\3\2\2\2\u03ca\u03cd\3\2\2\2\u03cb")
501 buf.write("\u03c9\3\2\2\2\u03cb\u03cc\3\2\2\2\u03cc\u03cf\3\2\2\2")
502 buf.write("\u03cd\u03cb\3\2\2\2\u03ce\u03d0\78\2\2\u03cf\u03ce\3")
503 buf.write("\2\2\2\u03cf\u03d0\3\2\2\2\u03d0\u0097\3\2\2\2\u03d1\u03d6")
504 buf.write("\5d\63\2\u03d2\u03d3\78\2\2\u03d3\u03d5\5d\63\2\u03d4")
505 buf.write("\u03d2\3\2\2\2\u03d5\u03d8\3\2\2\2\u03d6\u03d4\3\2\2\2")
506 buf.write("\u03d6\u03d7\3\2\2\2\u03d7\u03da\3\2\2\2\u03d8\u03d6\3")
507 buf.write("\2\2\2\u03d9\u03db\78\2\2\u03da\u03d9\3\2\2\2\u03da\u03db")
508 buf.write("\3\2\2\2\u03db\u0099\3\2\2\2\u03dc\u03dd\5d\63\2\u03dd")
509 buf.write("\u03de\79\2\2\u03de\u03df\5d\63\2\u03df\u03e3\3\2\2\2")
510 buf.write("\u03e0\u03e1\7;\2\2\u03e1\u03e3\5x=\2\u03e2\u03dc\3\2")
511 buf.write("\2\2\u03e2\u03e0\3\2\2\2\u03e3\u03f6\3\2\2\2\u03e4\u03f7")
512 buf.write("\5\u00a4S\2\u03e5\u03ec\78\2\2\u03e6\u03e7\5d\63\2\u03e7")
513 buf.write("\u03e8\79\2\2\u03e8\u03e9\5d\63\2\u03e9\u03ed\3\2\2\2")
514 buf.write("\u03ea\u03eb\7;\2\2\u03eb\u03ed\5x=\2\u03ec\u03e6\3\2")
515 buf.write("\2\2\u03ec\u03ea\3\2\2\2\u03ed\u03ef\3\2\2\2\u03ee\u03e5")
516 buf.write("\3\2\2\2\u03ef\u03f2\3\2\2\2\u03f0\u03ee\3\2\2\2\u03f0")
517 buf.write("\u03f1\3\2\2\2\u03f1\u03f4\3\2\2\2\u03f2\u03f0\3\2\2\2")
518 buf.write("\u03f3\u03f5\78\2\2\u03f4\u03f3\3\2\2\2\u03f4\u03f5\3")
519 buf.write("\2\2\2\u03f5\u03f7\3\2\2\2\u03f6\u03e4\3\2\2\2\u03f6\u03f0")
520 buf.write("\3\2\2\2\u03f7\u040d\3\2\2\2\u03f8\u03fb\5d\63\2\u03f9")
521 buf.write("\u03fb\5v<\2\u03fa\u03f8\3\2\2\2\u03fa\u03f9\3\2\2\2\u03fb")
522 buf.write("\u040a\3\2\2\2\u03fc\u040b\5\u00a4S\2\u03fd\u0400\78\2")
523 buf.write("\2\u03fe\u0401\5d\63\2\u03ff\u0401\5v<\2\u0400\u03fe\3")
524 buf.write("\2\2\2\u0400\u03ff\3\2\2\2\u0401\u0403\3\2\2\2\u0402\u03fd")
525 buf.write("\3\2\2\2\u0403\u0406\3\2\2\2\u0404\u0402\3\2\2\2\u0404")
526 buf.write("\u0405\3\2\2\2\u0405\u0408\3\2\2\2\u0406\u0404\3\2\2\2")
527 buf.write("\u0407\u0409\78\2\2\u0408\u0407\3\2\2\2\u0408\u0409\3")
528 buf.write("\2\2\2\u0409\u040b\3\2\2\2\u040a\u03fc\3\2\2\2\u040a\u0404")
529 buf.write("\3\2\2\2\u040b\u040d\3\2\2\2\u040c\u03e2\3\2\2\2\u040c")
530 buf.write("\u03fa\3\2\2\2\u040d\u009b\3\2\2\2\u040e\u040f\7!\2\2")
531 buf.write("\u040f\u0415\7*\2\2\u0410\u0412\7\66\2\2\u0411\u0413\5")
532 buf.write("\u009eP\2\u0412\u0411\3\2\2\2\u0412\u0413\3\2\2\2\u0413")
533 buf.write("\u0414\3\2\2\2\u0414\u0416\7\67\2\2\u0415\u0410\3\2\2")
534 buf.write("\2\u0415\u0416\3\2\2\2\u0416\u0417\3\2\2\2\u0417\u0418")
535 buf.write("\79\2\2\u0418\u0419\5b\62\2\u0419\u009d\3\2\2\2\u041a")
536 buf.write("\u041f\5\u00a0Q\2\u041b\u041c\78\2\2\u041c\u041e\5\u00a0")
537 buf.write("Q\2\u041d\u041b\3\2\2\2\u041e\u0421\3\2\2\2\u041f\u041d")
538 buf.write("\3\2\2\2\u041f\u0420\3\2\2\2\u0420\u0423\3\2\2\2\u0421")
539 buf.write("\u041f\3\2\2\2\u0422\u0424\78\2\2\u0423\u0422\3\2\2\2")
540 buf.write("\u0423\u0424\3\2\2\2\u0424\u009f\3\2\2\2\u0425\u0427\5")
541 buf.write("d\63\2\u0426\u0428\5\u00a4S\2\u0427\u0426\3\2\2\2\u0427")
542 buf.write("\u0428\3\2\2\2\u0428\u0432\3\2\2\2\u0429\u042a\5d\63\2")
543 buf.write("\u042a\u042b\7<\2\2\u042b\u042c\5d\63\2\u042c\u0432\3")
544 buf.write("\2\2\2\u042d\u042e\7;\2\2\u042e\u0432\5d\63\2\u042f\u0430")
545 buf.write("\7\65\2\2\u0430\u0432\5d\63\2\u0431\u0425\3\2\2\2\u0431")
546 buf.write("\u0429\3\2\2\2\u0431\u042d\3\2\2\2\u0431\u042f\3\2\2\2")
547 buf.write("\u0432\u00a1\3\2\2\2\u0433\u0436\5\u00a4S\2\u0434\u0436")
548 buf.write("\5\u00a6T\2\u0435\u0433\3\2\2\2\u0435\u0434\3\2\2\2\u0436")
549 buf.write("\u00a3\3\2\2\2\u0437\u0439\7\'\2\2\u0438\u0437\3\2\2\2")
550 buf.write("\u0438\u0439\3\2\2\2\u0439\u043a\3\2\2\2\u043a\u043b\7")
551 buf.write("\23\2\2\u043b\u043c\5\u0096L\2\u043c\u043d\7\24\2\2\u043d")
552 buf.write("\u043f\5l\67\2\u043e\u0440\5\u00a2R\2\u043f\u043e\3\2")
553 buf.write("\2\2\u043f\u0440\3\2\2\2\u0440\u00a5\3\2\2\2\u0441\u0442")
554 buf.write("\7\17\2\2\u0442\u0444\5f\64\2\u0443\u0445\5\u00a2R\2\u0444")
555 buf.write("\u0443\3\2\2\2\u0444\u0445\3\2\2\2\u0445\u00a7\3\2\2\2")
556 buf.write("\u0446\u0447\7*\2\2\u0447\u00a9\3\2\2\2\u0448\u044a\7")
557 buf.write("\"\2\2\u0449\u044b\5\u00acW\2\u044a\u0449\3\2\2\2\u044a")
558 buf.write("\u044b\3\2\2\2\u044b\u00ab\3\2\2\2\u044c\u044d\7\t\2\2")
559 buf.write("\u044d\u0450\5d\63\2\u044e\u0450\5\u0098M\2\u044f\u044c")
560 buf.write("\3\2\2\2\u044f\u044e\3\2\2\2\u0450\u00ad\3\2\2\2\u00a8")
561 buf.write("\u00b3\u00b7\u00b9\u00c2\u00cb\u00ce\u00d5\u00db\u00e5")
562 buf.write("\u00ec\u00f3\u00f9\u00fd\u0103\u0109\u010d\u0114\u0116")
563 buf.write("\u0118\u011d\u011f\u0121\u0125\u012b\u012f\u0136\u0138")
564 buf.write("\u013a\u013f\u0141\u0146\u014b\u0151\u0155\u015b\u0161")
565 buf.write("\u0165\u016c\u016e\u0170\u0175\u0177\u0179\u017d\u0183")
566 buf.write("\u0187\u018e\u0190\u0192\u0197\u0199\u019f\u01a6\u01aa")
567 buf.write("\u01b6\u01bd\u01c2\u01c6\u01c9\u01cf\u01d3\u01d8\u01dc")
568 buf.write("\u01e0\u01ee\u01f6\u01fe\u0200\u0204\u020d\u0214\u0216")
569 buf.write("\u021f\u0224\u0229\u0230\u0234\u023b\u0243\u024c\u0255")
570 buf.write("\u025c\u0267\u026d\u027a\u0280\u0289\u0294\u029f\u02a4")
571 buf.write("\u02a9\u02ae\u02b6\u02bf\u02c5\u02c7\u02cf\u02d3\u02db")
572 buf.write("\u02de\u02e2\u02e6\u02ed\u02f7\u02ff\u0305\u030d\u031d")
573 buf.write("\u0327\u032f\u0337\u033f\u0347\u034f\u0355\u035a\u035d")
574 buf.write("\u0363\u0369\u036e\u0373\u037b\u0381\u0385\u038b\u038f")
575 buf.write("\u0393\u0395\u0399\u03a2\u03a9\u03ad\u03b1\u03b5\u03b8")
576 buf.write("\u03ba\u03be\u03c2\u03c7\u03cb\u03cf\u03d6\u03da\u03e2")
577 buf.write("\u03ec\u03f0\u03f4\u03f6\u03fa\u0400\u0404\u0408\u040a")
578 buf.write("\u040c\u0412\u0415\u041f\u0423\u0427\u0431\u0435\u0438")
579 buf.write("\u043f\u0444\u044a\u044f")
580 return buf.getvalue()
583class Python3Parser ( Parser ):
585 grammarFileName = "Python3.g4"
587 atn = ATNDeserializer().deserialize(serializedATN())
589 decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
591 sharedContextCache = PredictionContextCache()
593 literalNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
594 "'def'", "'return'", "'raise'", "'from'", "'import'",
595 "'as'", "'global'", "'nonlocal'", "'assert'", "'if'",
596 "'elif'", "'else'", "'while'", "'for'", "'in'", "'try'",
597 "'finally'", "'with'", "'except'", "'lambda'", "'or'",
598 "'and'", "'not'", "'is'", "'None'", "'True'", "'False'",
599 "'class'", "'yield'", "'del'", "'pass'", "'continue'",
600 "'break'", "'async'", "'await'", "<INVALID>", "<INVALID>",
601 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
602 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
603 "'.'", "'...'", "'*'", "'('", "')'", "','", "':'",
604 "';'", "'**'", "'='", "'['", "']'", "'|'", "'^'", "'&'",
605 "'<<'", "'>>'", "'+'", "'-'", "'/'", "'%'", "'//'",
606 "'~'", "'{'", "'}'", "'<'", "'>'", "'=='", "'>='",
607 "'<='", "'<>'", "'!='", "'@'", "'->'", "'+='", "'-='",
608 "'*='", "'@='", "'/='", "'%='", "'&='", "'|='", "'^='",
609 "'<<='", "'>>='", "'**='", "'//='" ]
611 symbolicNames = [ "<INVALID>", "STRING", "NUMBER", "INTEGER", "DEF",
612 "RETURN", "RAISE", "FROM", "IMPORT", "AS", "GLOBAL",
613 "NONLOCAL", "ASSERT", "IF", "ELIF", "ELSE", "WHILE",
614 "FOR", "IN", "TRY", "FINALLY", "WITH", "EXCEPT", "LAMBDA",
615 "OR", "AND", "NOT", "IS", "NONE", "TRUE", "FALSE",
616 "CLASS", "YIELD", "DEL", "PASS", "CONTINUE", "BREAK",
617 "ASYNC", "AWAIT", "NEWLINE", "NAME", "STRING_LITERAL",
618 "BYTES_LITERAL", "DECIMAL_INTEGER", "OCT_INTEGER",
619 "HEX_INTEGER", "BIN_INTEGER", "FLOAT_NUMBER", "IMAG_NUMBER",
620 "DOT", "ELLIPSIS", "STAR", "OPEN_PAREN", "CLOSE_PAREN",
621 "COMMA", "COLON", "SEMI_COLON", "POWER", "ASSIGN",
622 "OPEN_BRACK", "CLOSE_BRACK", "OR_OP", "XOR", "AND_OP",
623 "LEFT_SHIFT", "RIGHT_SHIFT", "ADD", "MINUS", "DIV",
624 "MOD", "IDIV", "NOT_OP", "OPEN_BRACE", "CLOSE_BRACE",
625 "LESS_THAN", "GREATER_THAN", "EQUALS", "GT_EQ", "LT_EQ",
626 "NOT_EQ_1", "NOT_EQ_2", "AT", "ARROW", "ADD_ASSIGN",
627 "SUB_ASSIGN", "MULT_ASSIGN", "AT_ASSIGN", "DIV_ASSIGN",
628 "MOD_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN",
629 "LEFT_SHIFT_ASSIGN", "RIGHT_SHIFT_ASSIGN", "POWER_ASSIGN",
630 "IDIV_ASSIGN", "SKIP_", "UNKNOWN_CHAR", "INDENT",
631 "DEDENT" ]
633 RULE_single_input = 0
634 RULE_file_input = 1
635 RULE_eval_input = 2
636 RULE_decorator = 3
637 RULE_decorators = 4
638 RULE_decorated = 5
639 RULE_async_funcdef = 6
640 RULE_funcdef = 7
641 RULE_parameters = 8
642 RULE_typedargslist = 9
643 RULE_tfpdef = 10
644 RULE_varargslist = 11
645 RULE_vfpdef = 12
646 RULE_stmt = 13
647 RULE_simple_stmt = 14
648 RULE_small_stmt = 15
649 RULE_expr_stmt = 16
650 RULE_annassign = 17
651 RULE_testlist_star_expr = 18
652 RULE_augassign = 19
653 RULE_del_stmt = 20
654 RULE_pass_stmt = 21
655 RULE_flow_stmt = 22
656 RULE_break_stmt = 23
657 RULE_continue_stmt = 24
658 RULE_return_stmt = 25
659 RULE_yield_stmt = 26
660 RULE_raise_stmt = 27
661 RULE_import_stmt = 28
662 RULE_import_name = 29
663 RULE_import_from = 30
664 RULE_import_as_name = 31
665 RULE_dotted_as_name = 32
666 RULE_import_as_names = 33
667 RULE_dotted_as_names = 34
668 RULE_dotted_name = 35
669 RULE_global_stmt = 36
670 RULE_nonlocal_stmt = 37
671 RULE_assert_stmt = 38
672 RULE_compound_stmt = 39
673 RULE_async_stmt = 40
674 RULE_if_stmt = 41
675 RULE_while_stmt = 42
676 RULE_for_stmt = 43
677 RULE_try_stmt = 44
678 RULE_with_stmt = 45
679 RULE_with_item = 46
680 RULE_except_clause = 47
681 RULE_suite = 48
682 RULE_test = 49
683 RULE_test_nocond = 50
684 RULE_lambdef = 51
685 RULE_lambdef_nocond = 52
686 RULE_or_test = 53
687 RULE_and_test = 54
688 RULE_not_test = 55
689 RULE_comparison = 56
690 RULE_comp_op = 57
691 RULE_star_expr = 58
692 RULE_expr = 59
693 RULE_xor_expr = 60
694 RULE_and_expr = 61
695 RULE_shift_expr = 62
696 RULE_arith_expr = 63
697 RULE_term = 64
698 RULE_factor = 65
699 RULE_power = 66
700 RULE_atom_expr = 67
701 RULE_atom = 68
702 RULE_testlist_comp = 69
703 RULE_trailer = 70
704 RULE_subscriptlist = 71
705 RULE_subscript = 72
706 RULE_sliceop = 73
707 RULE_exprlist = 74
708 RULE_testlist = 75
709 RULE_dictorsetmaker = 76
710 RULE_classdef = 77
711 RULE_arglist = 78
712 RULE_argument = 79
713 RULE_comp_iter = 80
714 RULE_comp_for = 81
715 RULE_comp_if = 82
716 RULE_encoding_decl = 83
717 RULE_yield_expr = 84
718 RULE_yield_arg = 85
720 ruleNames = [ "single_input", "file_input", "eval_input", "decorator",
721 "decorators", "decorated", "async_funcdef", "funcdef",
722 "parameters", "typedargslist", "tfpdef", "varargslist",
723 "vfpdef", "stmt", "simple_stmt", "small_stmt", "expr_stmt",
724 "annassign", "testlist_star_expr", "augassign", "del_stmt",
725 "pass_stmt", "flow_stmt", "break_stmt", "continue_stmt",
726 "return_stmt", "yield_stmt", "raise_stmt", "import_stmt",
727 "import_name", "import_from", "import_as_name", "dotted_as_name",
728 "import_as_names", "dotted_as_names", "dotted_name",
729 "global_stmt", "nonlocal_stmt", "assert_stmt", "compound_stmt",
730 "async_stmt", "if_stmt", "while_stmt", "for_stmt", "try_stmt",
731 "with_stmt", "with_item", "except_clause", "suite", "test",
732 "test_nocond", "lambdef", "lambdef_nocond", "or_test",
733 "and_test", "not_test", "comparison", "comp_op", "star_expr",
734 "expr", "xor_expr", "and_expr", "shift_expr", "arith_expr",
735 "term", "factor", "power", "atom_expr", "atom", "testlist_comp",
736 "trailer", "subscriptlist", "subscript", "sliceop", "exprlist",
737 "testlist", "dictorsetmaker", "classdef", "arglist",
738 "argument", "comp_iter", "comp_for", "comp_if", "encoding_decl",
739 "yield_expr", "yield_arg" ]
741 EOF = Token.EOF
742 STRING=1
743 NUMBER=2
744 INTEGER=3
745 DEF=4
746 RETURN=5
747 RAISE=6
748 FROM=7
749 IMPORT=8
750 AS=9
751 GLOBAL=10
752 NONLOCAL=11
753 ASSERT=12
754 IF=13
755 ELIF=14
756 ELSE=15
757 WHILE=16
758 FOR=17
759 IN=18
760 TRY=19
761 FINALLY=20
762 WITH=21
763 EXCEPT=22
764 LAMBDA=23
765 OR=24
766 AND=25
767 NOT=26
768 IS=27
769 NONE=28
770 TRUE=29
771 FALSE=30
772 CLASS=31
773 YIELD=32
774 DEL=33
775 PASS=34
776 CONTINUE=35
777 BREAK=36
778 ASYNC=37
779 AWAIT=38
780 NEWLINE=39
781 NAME=40
782 STRING_LITERAL=41
783 BYTES_LITERAL=42
784 DECIMAL_INTEGER=43
785 OCT_INTEGER=44
786 HEX_INTEGER=45
787 BIN_INTEGER=46
788 FLOAT_NUMBER=47
789 IMAG_NUMBER=48
790 DOT=49
791 ELLIPSIS=50
792 STAR=51
793 OPEN_PAREN=52
794 CLOSE_PAREN=53
795 COMMA=54
796 COLON=55
797 SEMI_COLON=56
798 POWER=57
799 ASSIGN=58
800 OPEN_BRACK=59
801 CLOSE_BRACK=60
802 OR_OP=61
803 XOR=62
804 AND_OP=63
805 LEFT_SHIFT=64
806 RIGHT_SHIFT=65
807 ADD=66
808 MINUS=67
809 DIV=68
810 MOD=69
811 IDIV=70
812 NOT_OP=71
813 OPEN_BRACE=72
814 CLOSE_BRACE=73
815 LESS_THAN=74
816 GREATER_THAN=75
817 EQUALS=76
818 GT_EQ=77
819 LT_EQ=78
820 NOT_EQ_1=79
821 NOT_EQ_2=80
822 AT=81
823 ARROW=82
824 ADD_ASSIGN=83
825 SUB_ASSIGN=84
826 MULT_ASSIGN=85
827 AT_ASSIGN=86
828 DIV_ASSIGN=87
829 MOD_ASSIGN=88
830 AND_ASSIGN=89
831 OR_ASSIGN=90
832 XOR_ASSIGN=91
833 LEFT_SHIFT_ASSIGN=92
834 RIGHT_SHIFT_ASSIGN=93
835 POWER_ASSIGN=94
836 IDIV_ASSIGN=95
837 SKIP_=96
838 UNKNOWN_CHAR=97
839 INDENT=98
840 DEDENT=99
842 def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
843 super().__init__(input, output)
844 self.checkVersion("4.9")
845 self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
846 self._predicates = None
851 class Single_inputContext(ParserRuleContext):
853 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
854 super().__init__(parent, invokingState)
855 self.parser = parser
857 def NEWLINE(self):
858 return self.getToken(Python3Parser.NEWLINE, 0)
860 def simple_stmt(self):
861 return self.getTypedRuleContext(Python3Parser.Simple_stmtContext,0)
864 def compound_stmt(self):
865 return self.getTypedRuleContext(Python3Parser.Compound_stmtContext,0)
868 def getRuleIndex(self):
869 return Python3Parser.RULE_single_input
871 def enterRule(self, listener:ParseTreeListener):
872 if hasattr( listener, "enterSingle_input" ):
873 listener.enterSingle_input(self)
875 def exitRule(self, listener:ParseTreeListener):
876 if hasattr( listener, "exitSingle_input" ):
877 listener.exitSingle_input(self)
882 def single_input(self):
884 localctx = Python3Parser.Single_inputContext(self, self._ctx, self.state)
885 self.enterRule(localctx, 0, self.RULE_single_input)
886 try:
887 self.state = 177
888 self._errHandler.sync(self)
889 token = self._input.LA(1)
890 if token in [Python3Parser.NEWLINE]:
891 self.enterOuterAlt(localctx, 1)
892 self.state = 172
893 self.match(Python3Parser.NEWLINE)
894 pass
895 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]:
896 self.enterOuterAlt(localctx, 2)
897 self.state = 173
898 self.simple_stmt()
899 pass
900 elif token in [Python3Parser.DEF, Python3Parser.IF, Python3Parser.WHILE, Python3Parser.FOR, Python3Parser.TRY, Python3Parser.WITH, Python3Parser.CLASS, Python3Parser.ASYNC, Python3Parser.AT]:
901 self.enterOuterAlt(localctx, 3)
902 self.state = 174
903 self.compound_stmt()
904 self.state = 175
905 self.match(Python3Parser.NEWLINE)
906 pass
907 else:
908 raise NoViableAltException(self)
910 except RecognitionException as re:
911 localctx.exception = re
912 self._errHandler.reportError(self, re)
913 self._errHandler.recover(self, re)
914 finally:
915 self.exitRule()
916 return localctx
919 class File_inputContext(ParserRuleContext):
921 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
922 super().__init__(parent, invokingState)
923 self.parser = parser
925 def EOF(self):
926 return self.getToken(Python3Parser.EOF, 0)
928 def NEWLINE(self, i:int=None):
929 if i is None:
930 return self.getTokens(Python3Parser.NEWLINE)
931 else:
932 return self.getToken(Python3Parser.NEWLINE, i)
934 def stmt(self, i:int=None):
935 if i is None:
936 return self.getTypedRuleContexts(Python3Parser.StmtContext)
937 else:
938 return self.getTypedRuleContext(Python3Parser.StmtContext,i)
941 def getRuleIndex(self):
942 return Python3Parser.RULE_file_input
944 def enterRule(self, listener:ParseTreeListener):
945 if hasattr( listener, "enterFile_input" ):
946 listener.enterFile_input(self)
948 def exitRule(self, listener:ParseTreeListener):
949 if hasattr( listener, "exitFile_input" ):
950 listener.exitFile_input(self)
955 def file_input(self):
957 localctx = Python3Parser.File_inputContext(self, self._ctx, self.state)
958 self.enterRule(localctx, 2, self.RULE_file_input)
959 self._la = 0 # Token type
960 try:
961 self.enterOuterAlt(localctx, 1)
962 self.state = 183
963 self._errHandler.sync(self)
964 _la = self._input.LA(1)
965 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):
966 self.state = 181
967 self._errHandler.sync(self)
968 token = self._input.LA(1)
969 if token in [Python3Parser.NEWLINE]:
970 self.state = 179
971 self.match(Python3Parser.NEWLINE)
972 pass
973 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]:
974 self.state = 180
975 self.stmt()
976 pass
977 else:
978 raise NoViableAltException(self)
980 self.state = 185
981 self._errHandler.sync(self)
982 _la = self._input.LA(1)
984 self.state = 186
985 self.match(Python3Parser.EOF)
986 except RecognitionException as re:
987 localctx.exception = re
988 self._errHandler.reportError(self, re)
989 self._errHandler.recover(self, re)
990 finally:
991 self.exitRule()
992 return localctx
995 class Eval_inputContext(ParserRuleContext):
997 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
998 super().__init__(parent, invokingState)
999 self.parser = parser
1001 def testlist(self):
1002 return self.getTypedRuleContext(Python3Parser.TestlistContext,0)
1005 def EOF(self):
1006 return self.getToken(Python3Parser.EOF, 0)
1008 def NEWLINE(self, i:int=None):
1009 if i is None:
1010 return self.getTokens(Python3Parser.NEWLINE)
1011 else:
1012 return self.getToken(Python3Parser.NEWLINE, i)
1014 def getRuleIndex(self):
1015 return Python3Parser.RULE_eval_input
1017 def enterRule(self, listener:ParseTreeListener):
1018 if hasattr( listener, "enterEval_input" ):
1019 listener.enterEval_input(self)
1021 def exitRule(self, listener:ParseTreeListener):
1022 if hasattr( listener, "exitEval_input" ):
1023 listener.exitEval_input(self)
1028 def eval_input(self):
1030 localctx = Python3Parser.Eval_inputContext(self, self._ctx, self.state)
1031 self.enterRule(localctx, 4, self.RULE_eval_input)
1032 self._la = 0 # Token type
1033 try:
1034 self.enterOuterAlt(localctx, 1)
1035 self.state = 188
1036 self.testlist()
1037 self.state = 192
1038 self._errHandler.sync(self)
1039 _la = self._input.LA(1)
1040 while _la==Python3Parser.NEWLINE:
1041 self.state = 189
1042 self.match(Python3Parser.NEWLINE)
1043 self.state = 194
1044 self._errHandler.sync(self)
1045 _la = self._input.LA(1)
1047 self.state = 195
1048 self.match(Python3Parser.EOF)
1049 except RecognitionException as re:
1050 localctx.exception = re
1051 self._errHandler.reportError(self, re)
1052 self._errHandler.recover(self, re)
1053 finally:
1054 self.exitRule()
1055 return localctx
1058 class DecoratorContext(ParserRuleContext):
1060 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1061 super().__init__(parent, invokingState)
1062 self.parser = parser
1064 def AT(self):
1065 return self.getToken(Python3Parser.AT, 0)
1067 def dotted_name(self):
1068 return self.getTypedRuleContext(Python3Parser.Dotted_nameContext,0)
1071 def NEWLINE(self):
1072 return self.getToken(Python3Parser.NEWLINE, 0)
1074 def OPEN_PAREN(self):
1075 return self.getToken(Python3Parser.OPEN_PAREN, 0)
1077 def CLOSE_PAREN(self):
1078 return self.getToken(Python3Parser.CLOSE_PAREN, 0)
1080 def arglist(self):
1081 return self.getTypedRuleContext(Python3Parser.ArglistContext,0)
1084 def getRuleIndex(self):
1085 return Python3Parser.RULE_decorator
1087 def enterRule(self, listener:ParseTreeListener):
1088 if hasattr( listener, "enterDecorator" ):
1089 listener.enterDecorator(self)
1091 def exitRule(self, listener:ParseTreeListener):
1092 if hasattr( listener, "exitDecorator" ):
1093 listener.exitDecorator(self)
1098 def decorator(self):
1100 localctx = Python3Parser.DecoratorContext(self, self._ctx, self.state)
1101 self.enterRule(localctx, 6, self.RULE_decorator)
1102 self._la = 0 # Token type
1103 try:
1104 self.enterOuterAlt(localctx, 1)
1105 self.state = 197
1106 self.match(Python3Parser.AT)
1107 self.state = 198
1108 self.dotted_name()
1109 self.state = 204
1110 self._errHandler.sync(self)
1111 _la = self._input.LA(1)
1112 if _la==Python3Parser.OPEN_PAREN:
1113 self.state = 199
1114 self.match(Python3Parser.OPEN_PAREN)
1115 self.state = 201
1116 self._errHandler.sync(self)
1117 _la = self._input.LA(1)
1118 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):
1119 self.state = 200
1120 self.arglist()
1123 self.state = 203
1124 self.match(Python3Parser.CLOSE_PAREN)
1127 self.state = 206
1128 self.match(Python3Parser.NEWLINE)
1129 except RecognitionException as re:
1130 localctx.exception = re
1131 self._errHandler.reportError(self, re)
1132 self._errHandler.recover(self, re)
1133 finally:
1134 self.exitRule()
1135 return localctx
1138 class DecoratorsContext(ParserRuleContext):
1140 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1141 super().__init__(parent, invokingState)
1142 self.parser = parser
1144 def decorator(self, i:int=None):
1145 if i is None:
1146 return self.getTypedRuleContexts(Python3Parser.DecoratorContext)
1147 else:
1148 return self.getTypedRuleContext(Python3Parser.DecoratorContext,i)
1151 def getRuleIndex(self):
1152 return Python3Parser.RULE_decorators
1154 def enterRule(self, listener:ParseTreeListener):
1155 if hasattr( listener, "enterDecorators" ):
1156 listener.enterDecorators(self)
1158 def exitRule(self, listener:ParseTreeListener):
1159 if hasattr( listener, "exitDecorators" ):
1160 listener.exitDecorators(self)
1165 def decorators(self):
1167 localctx = Python3Parser.DecoratorsContext(self, self._ctx, self.state)
1168 self.enterRule(localctx, 8, self.RULE_decorators)
1169 self._la = 0 # Token type
1170 try:
1171 self.enterOuterAlt(localctx, 1)
1172 self.state = 209
1173 self._errHandler.sync(self)
1174 _la = self._input.LA(1)
1175 while True:
1176 self.state = 208
1177 self.decorator()
1178 self.state = 211
1179 self._errHandler.sync(self)
1180 _la = self._input.LA(1)
1181 if not (_la==Python3Parser.AT):
1182 break
1184 except RecognitionException as re:
1185 localctx.exception = re
1186 self._errHandler.reportError(self, re)
1187 self._errHandler.recover(self, re)
1188 finally:
1189 self.exitRule()
1190 return localctx
1193 class DecoratedContext(ParserRuleContext):
1195 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1196 super().__init__(parent, invokingState)
1197 self.parser = parser
1199 def decorators(self):
1200 return self.getTypedRuleContext(Python3Parser.DecoratorsContext,0)
1203 def classdef(self):
1204 return self.getTypedRuleContext(Python3Parser.ClassdefContext,0)
1207 def funcdef(self):
1208 return self.getTypedRuleContext(Python3Parser.FuncdefContext,0)
1211 def async_funcdef(self):
1212 return self.getTypedRuleContext(Python3Parser.Async_funcdefContext,0)
1215 def getRuleIndex(self):
1216 return Python3Parser.RULE_decorated
1218 def enterRule(self, listener:ParseTreeListener):
1219 if hasattr( listener, "enterDecorated" ):
1220 listener.enterDecorated(self)
1222 def exitRule(self, listener:ParseTreeListener):
1223 if hasattr( listener, "exitDecorated" ):
1224 listener.exitDecorated(self)
1229 def decorated(self):
1231 localctx = Python3Parser.DecoratedContext(self, self._ctx, self.state)
1232 self.enterRule(localctx, 10, self.RULE_decorated)
1233 try:
1234 self.enterOuterAlt(localctx, 1)
1235 self.state = 213
1236 self.decorators()
1237 self.state = 217
1238 self._errHandler.sync(self)
1239 token = self._input.LA(1)
1240 if token in [Python3Parser.CLASS]:
1241 self.state = 214
1242 self.classdef()
1243 pass
1244 elif token in [Python3Parser.DEF]:
1245 self.state = 215
1246 self.funcdef()
1247 pass
1248 elif token in [Python3Parser.ASYNC]:
1249 self.state = 216
1250 self.async_funcdef()
1251 pass
1252 else:
1253 raise NoViableAltException(self)
1255 except RecognitionException as re:
1256 localctx.exception = re
1257 self._errHandler.reportError(self, re)
1258 self._errHandler.recover(self, re)
1259 finally:
1260 self.exitRule()
1261 return localctx
1264 class Async_funcdefContext(ParserRuleContext):
1266 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1267 super().__init__(parent, invokingState)
1268 self.parser = parser
1270 def ASYNC(self):
1271 return self.getToken(Python3Parser.ASYNC, 0)
1273 def funcdef(self):
1274 return self.getTypedRuleContext(Python3Parser.FuncdefContext,0)
1277 def getRuleIndex(self):
1278 return Python3Parser.RULE_async_funcdef
1280 def enterRule(self, listener:ParseTreeListener):
1281 if hasattr( listener, "enterAsync_funcdef" ):
1282 listener.enterAsync_funcdef(self)
1284 def exitRule(self, listener:ParseTreeListener):
1285 if hasattr( listener, "exitAsync_funcdef" ):
1286 listener.exitAsync_funcdef(self)
1291 def async_funcdef(self):
1293 localctx = Python3Parser.Async_funcdefContext(self, self._ctx, self.state)
1294 self.enterRule(localctx, 12, self.RULE_async_funcdef)
1295 try:
1296 self.enterOuterAlt(localctx, 1)
1297 self.state = 219
1298 self.match(Python3Parser.ASYNC)
1299 self.state = 220
1300 self.funcdef()
1301 except RecognitionException as re:
1302 localctx.exception = re
1303 self._errHandler.reportError(self, re)
1304 self._errHandler.recover(self, re)
1305 finally:
1306 self.exitRule()
1307 return localctx
1310 class FuncdefContext(ParserRuleContext):
1312 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1313 super().__init__(parent, invokingState)
1314 self.parser = parser
1316 def DEF(self):
1317 return self.getToken(Python3Parser.DEF, 0)
1319 def NAME(self):
1320 return self.getToken(Python3Parser.NAME, 0)
1322 def parameters(self):
1323 return self.getTypedRuleContext(Python3Parser.ParametersContext,0)
1326 def COLON(self):
1327 return self.getToken(Python3Parser.COLON, 0)
1329 def suite(self):
1330 return self.getTypedRuleContext(Python3Parser.SuiteContext,0)
1333 def ARROW(self):
1334 return self.getToken(Python3Parser.ARROW, 0)
1336 def test(self):
1337 return self.getTypedRuleContext(Python3Parser.TestContext,0)
1340 def getRuleIndex(self):
1341 return Python3Parser.RULE_funcdef
1343 def enterRule(self, listener:ParseTreeListener):
1344 if hasattr( listener, "enterFuncdef" ):
1345 listener.enterFuncdef(self)
1347 def exitRule(self, listener:ParseTreeListener):
1348 if hasattr( listener, "exitFuncdef" ):
1349 listener.exitFuncdef(self)
1354 def funcdef(self):
1356 localctx = Python3Parser.FuncdefContext(self, self._ctx, self.state)
1357 self.enterRule(localctx, 14, self.RULE_funcdef)
1358 self._la = 0 # Token type
1359 try:
1360 self.enterOuterAlt(localctx, 1)
1361 self.state = 222
1362 self.match(Python3Parser.DEF)
1363 self.state = 223
1364 self.match(Python3Parser.NAME)
1365 self.state = 224
1366 self.parameters()
1367 self.state = 227
1368 self._errHandler.sync(self)
1369 _la = self._input.LA(1)
1370 if _la==Python3Parser.ARROW:
1371 self.state = 225
1372 self.match(Python3Parser.ARROW)
1373 self.state = 226
1374 self.test()
1377 self.state = 229
1378 self.match(Python3Parser.COLON)
1379 self.state = 230
1380 self.suite()
1381 except RecognitionException as re:
1382 localctx.exception = re
1383 self._errHandler.reportError(self, re)
1384 self._errHandler.recover(self, re)
1385 finally:
1386 self.exitRule()
1387 return localctx
1390 class ParametersContext(ParserRuleContext):
1392 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1393 super().__init__(parent, invokingState)
1394 self.parser = parser
1396 def OPEN_PAREN(self):
1397 return self.getToken(Python3Parser.OPEN_PAREN, 0)
1399 def CLOSE_PAREN(self):
1400 return self.getToken(Python3Parser.CLOSE_PAREN, 0)
1402 def typedargslist(self):
1403 return self.getTypedRuleContext(Python3Parser.TypedargslistContext,0)
1406 def getRuleIndex(self):
1407 return Python3Parser.RULE_parameters
1409 def enterRule(self, listener:ParseTreeListener):
1410 if hasattr( listener, "enterParameters" ):
1411 listener.enterParameters(self)
1413 def exitRule(self, listener:ParseTreeListener):
1414 if hasattr( listener, "exitParameters" ):
1415 listener.exitParameters(self)
1420 def parameters(self):
1422 localctx = Python3Parser.ParametersContext(self, self._ctx, self.state)
1423 self.enterRule(localctx, 16, self.RULE_parameters)
1424 self._la = 0 # Token type
1425 try:
1426 self.enterOuterAlt(localctx, 1)
1427 self.state = 232
1428 self.match(Python3Parser.OPEN_PAREN)
1429 self.state = 234
1430 self._errHandler.sync(self)
1431 _la = self._input.LA(1)
1432 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.NAME) | (1 << Python3Parser.STAR) | (1 << Python3Parser.POWER))) != 0):
1433 self.state = 233
1434 self.typedargslist()
1437 self.state = 236
1438 self.match(Python3Parser.CLOSE_PAREN)
1439 except RecognitionException as re:
1440 localctx.exception = re
1441 self._errHandler.reportError(self, re)
1442 self._errHandler.recover(self, re)
1443 finally:
1444 self.exitRule()
1445 return localctx
1448 class TypedargslistContext(ParserRuleContext):
1450 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1451 super().__init__(parent, invokingState)
1452 self.parser = parser
1454 def tfpdef(self, i:int=None):
1455 if i is None:
1456 return self.getTypedRuleContexts(Python3Parser.TfpdefContext)
1457 else:
1458 return self.getTypedRuleContext(Python3Parser.TfpdefContext,i)
1461 def STAR(self):
1462 return self.getToken(Python3Parser.STAR, 0)
1464 def POWER(self):
1465 return self.getToken(Python3Parser.POWER, 0)
1467 def ASSIGN(self, i:int=None):
1468 if i is None:
1469 return self.getTokens(Python3Parser.ASSIGN)
1470 else:
1471 return self.getToken(Python3Parser.ASSIGN, i)
1473 def test(self, i:int=None):
1474 if i is None:
1475 return self.getTypedRuleContexts(Python3Parser.TestContext)
1476 else:
1477 return self.getTypedRuleContext(Python3Parser.TestContext,i)
1480 def COMMA(self, i:int=None):
1481 if i is None:
1482 return self.getTokens(Python3Parser.COMMA)
1483 else:
1484 return self.getToken(Python3Parser.COMMA, i)
1486 def getRuleIndex(self):
1487 return Python3Parser.RULE_typedargslist
1489 def enterRule(self, listener:ParseTreeListener):
1490 if hasattr( listener, "enterTypedargslist" ):
1491 listener.enterTypedargslist(self)
1493 def exitRule(self, listener:ParseTreeListener):
1494 if hasattr( listener, "exitTypedargslist" ):
1495 listener.exitTypedargslist(self)
1500 def typedargslist(self):
1502 localctx = Python3Parser.TypedargslistContext(self, self._ctx, self.state)
1503 self.enterRule(localctx, 18, self.RULE_typedargslist)
1504 self._la = 0 # Token type
1505 try:
1506 self.enterOuterAlt(localctx, 1)
1507 self.state = 319
1508 self._errHandler.sync(self)
1509 token = self._input.LA(1)
1510 if token in [Python3Parser.NAME]:
1511 self.state = 238
1512 self.tfpdef()
1513 self.state = 241
1514 self._errHandler.sync(self)
1515 _la = self._input.LA(1)
1516 if _la==Python3Parser.ASSIGN:
1517 self.state = 239
1518 self.match(Python3Parser.ASSIGN)
1519 self.state = 240
1520 self.test()
1523 self.state = 251
1524 self._errHandler.sync(self)
1525 _alt = self._interp.adaptivePredict(self._input,12,self._ctx)
1526 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
1527 if _alt==1:
1528 self.state = 243
1529 self.match(Python3Parser.COMMA)
1530 self.state = 244
1531 self.tfpdef()
1532 self.state = 247
1533 self._errHandler.sync(self)
1534 _la = self._input.LA(1)
1535 if _la==Python3Parser.ASSIGN:
1536 self.state = 245
1537 self.match(Python3Parser.ASSIGN)
1538 self.state = 246
1539 self.test()
1542 self.state = 253
1543 self._errHandler.sync(self)
1544 _alt = self._interp.adaptivePredict(self._input,12,self._ctx)
1546 self.state = 287
1547 self._errHandler.sync(self)
1548 _la = self._input.LA(1)
1549 if _la==Python3Parser.COMMA:
1550 self.state = 254
1551 self.match(Python3Parser.COMMA)
1552 self.state = 285
1553 self._errHandler.sync(self)
1554 token = self._input.LA(1)
1555 if token in [Python3Parser.STAR]:
1556 self.state = 255
1557 self.match(Python3Parser.STAR)
1558 self.state = 257
1559 self._errHandler.sync(self)
1560 _la = self._input.LA(1)
1561 if _la==Python3Parser.NAME:
1562 self.state = 256
1563 self.tfpdef()
1566 self.state = 267
1567 self._errHandler.sync(self)
1568 _alt = self._interp.adaptivePredict(self._input,15,self._ctx)
1569 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
1570 if _alt==1:
1571 self.state = 259
1572 self.match(Python3Parser.COMMA)
1573 self.state = 260
1574 self.tfpdef()
1575 self.state = 263
1576 self._errHandler.sync(self)
1577 _la = self._input.LA(1)
1578 if _la==Python3Parser.ASSIGN:
1579 self.state = 261
1580 self.match(Python3Parser.ASSIGN)
1581 self.state = 262
1582 self.test()
1585 self.state = 269
1586 self._errHandler.sync(self)
1587 _alt = self._interp.adaptivePredict(self._input,15,self._ctx)
1589 self.state = 278
1590 self._errHandler.sync(self)
1591 _la = self._input.LA(1)
1592 if _la==Python3Parser.COMMA:
1593 self.state = 270
1594 self.match(Python3Parser.COMMA)
1595 self.state = 276
1596 self._errHandler.sync(self)
1597 _la = self._input.LA(1)
1598 if _la==Python3Parser.POWER:
1599 self.state = 271
1600 self.match(Python3Parser.POWER)
1601 self.state = 272
1602 self.tfpdef()
1603 self.state = 274
1604 self._errHandler.sync(self)
1605 _la = self._input.LA(1)
1606 if _la==Python3Parser.COMMA:
1607 self.state = 273
1608 self.match(Python3Parser.COMMA)
1615 pass
1616 elif token in [Python3Parser.POWER]:
1617 self.state = 280
1618 self.match(Python3Parser.POWER)
1619 self.state = 281
1620 self.tfpdef()
1621 self.state = 283
1622 self._errHandler.sync(self)
1623 _la = self._input.LA(1)
1624 if _la==Python3Parser.COMMA:
1625 self.state = 282
1626 self.match(Python3Parser.COMMA)
1629 pass
1630 elif token in [Python3Parser.CLOSE_PAREN]:
1631 pass
1632 else:
1633 pass
1636 pass
1637 elif token in [Python3Parser.STAR]:
1638 self.state = 289
1639 self.match(Python3Parser.STAR)
1640 self.state = 291
1641 self._errHandler.sync(self)
1642 _la = self._input.LA(1)
1643 if _la==Python3Parser.NAME:
1644 self.state = 290
1645 self.tfpdef()
1648 self.state = 301
1649 self._errHandler.sync(self)
1650 _alt = self._interp.adaptivePredict(self._input,24,self._ctx)
1651 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
1652 if _alt==1:
1653 self.state = 293
1654 self.match(Python3Parser.COMMA)
1655 self.state = 294
1656 self.tfpdef()
1657 self.state = 297
1658 self._errHandler.sync(self)
1659 _la = self._input.LA(1)
1660 if _la==Python3Parser.ASSIGN:
1661 self.state = 295
1662 self.match(Python3Parser.ASSIGN)
1663 self.state = 296
1664 self.test()
1667 self.state = 303
1668 self._errHandler.sync(self)
1669 _alt = self._interp.adaptivePredict(self._input,24,self._ctx)
1671 self.state = 312
1672 self._errHandler.sync(self)
1673 _la = self._input.LA(1)
1674 if _la==Python3Parser.COMMA:
1675 self.state = 304
1676 self.match(Python3Parser.COMMA)
1677 self.state = 310
1678 self._errHandler.sync(self)
1679 _la = self._input.LA(1)
1680 if _la==Python3Parser.POWER:
1681 self.state = 305
1682 self.match(Python3Parser.POWER)
1683 self.state = 306
1684 self.tfpdef()
1685 self.state = 308
1686 self._errHandler.sync(self)
1687 _la = self._input.LA(1)
1688 if _la==Python3Parser.COMMA:
1689 self.state = 307
1690 self.match(Python3Parser.COMMA)
1697 pass
1698 elif token in [Python3Parser.POWER]:
1699 self.state = 314
1700 self.match(Python3Parser.POWER)
1701 self.state = 315
1702 self.tfpdef()
1703 self.state = 317
1704 self._errHandler.sync(self)
1705 _la = self._input.LA(1)
1706 if _la==Python3Parser.COMMA:
1707 self.state = 316
1708 self.match(Python3Parser.COMMA)
1711 pass
1712 else:
1713 raise NoViableAltException(self)
1715 except RecognitionException as re:
1716 localctx.exception = re
1717 self._errHandler.reportError(self, re)
1718 self._errHandler.recover(self, re)
1719 finally:
1720 self.exitRule()
1721 return localctx
1724 class TfpdefContext(ParserRuleContext):
1726 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1727 super().__init__(parent, invokingState)
1728 self.parser = parser
1730 def NAME(self):
1731 return self.getToken(Python3Parser.NAME, 0)
1733 def COLON(self):
1734 return self.getToken(Python3Parser.COLON, 0)
1736 def test(self):
1737 return self.getTypedRuleContext(Python3Parser.TestContext,0)
1740 def getRuleIndex(self):
1741 return Python3Parser.RULE_tfpdef
1743 def enterRule(self, listener:ParseTreeListener):
1744 if hasattr( listener, "enterTfpdef" ):
1745 listener.enterTfpdef(self)
1747 def exitRule(self, listener:ParseTreeListener):
1748 if hasattr( listener, "exitTfpdef" ):
1749 listener.exitTfpdef(self)
1754 def tfpdef(self):
1756 localctx = Python3Parser.TfpdefContext(self, self._ctx, self.state)
1757 self.enterRule(localctx, 20, self.RULE_tfpdef)
1758 self._la = 0 # Token type
1759 try:
1760 self.enterOuterAlt(localctx, 1)
1761 self.state = 321
1762 self.match(Python3Parser.NAME)
1763 self.state = 324
1764 self._errHandler.sync(self)
1765 _la = self._input.LA(1)
1766 if _la==Python3Parser.COLON:
1767 self.state = 322
1768 self.match(Python3Parser.COLON)
1769 self.state = 323
1770 self.test()
1773 except RecognitionException as re:
1774 localctx.exception = re
1775 self._errHandler.reportError(self, re)
1776 self._errHandler.recover(self, re)
1777 finally:
1778 self.exitRule()
1779 return localctx
1782 class VarargslistContext(ParserRuleContext):
1784 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
1785 super().__init__(parent, invokingState)
1786 self.parser = parser
1788 def vfpdef(self, i:int=None):
1789 if i is None:
1790 return self.getTypedRuleContexts(Python3Parser.VfpdefContext)
1791 else:
1792 return self.getTypedRuleContext(Python3Parser.VfpdefContext,i)
1795 def STAR(self):
1796 return self.getToken(Python3Parser.STAR, 0)
1798 def POWER(self):
1799 return self.getToken(Python3Parser.POWER, 0)
1801 def ASSIGN(self, i:int=None):
1802 if i is None:
1803 return self.getTokens(Python3Parser.ASSIGN)
1804 else:
1805 return self.getToken(Python3Parser.ASSIGN, i)
1807 def test(self, i:int=None):
1808 if i is None:
1809 return self.getTypedRuleContexts(Python3Parser.TestContext)
1810 else:
1811 return self.getTypedRuleContext(Python3Parser.TestContext,i)
1814 def COMMA(self, i:int=None):
1815 if i is None:
1816 return self.getTokens(Python3Parser.COMMA)
1817 else:
1818 return self.getToken(Python3Parser.COMMA, i)
1820 def getRuleIndex(self):
1821 return Python3Parser.RULE_varargslist
1823 def enterRule(self, listener:ParseTreeListener):
1824 if hasattr( listener, "enterVarargslist" ):
1825 listener.enterVarargslist(self)
1827 def exitRule(self, listener:ParseTreeListener):
1828 if hasattr( listener, "exitVarargslist" ):
1829 listener.exitVarargslist(self)
1834 def varargslist(self):
1836 localctx = Python3Parser.VarargslistContext(self, self._ctx, self.state)
1837 self.enterRule(localctx, 22, self.RULE_varargslist)
1838 self._la = 0 # Token type
1839 try:
1840 self.enterOuterAlt(localctx, 1)
1841 self.state = 407
1842 self._errHandler.sync(self)
1843 token = self._input.LA(1)
1844 if token in [Python3Parser.NAME]:
1845 self.state = 326
1846 self.vfpdef()
1847 self.state = 329
1848 self._errHandler.sync(self)
1849 _la = self._input.LA(1)
1850 if _la==Python3Parser.ASSIGN:
1851 self.state = 327
1852 self.match(Python3Parser.ASSIGN)
1853 self.state = 328
1854 self.test()
1857 self.state = 339
1858 self._errHandler.sync(self)
1859 _alt = self._interp.adaptivePredict(self._input,33,self._ctx)
1860 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
1861 if _alt==1:
1862 self.state = 331
1863 self.match(Python3Parser.COMMA)
1864 self.state = 332
1865 self.vfpdef()
1866 self.state = 335
1867 self._errHandler.sync(self)
1868 _la = self._input.LA(1)
1869 if _la==Python3Parser.ASSIGN:
1870 self.state = 333
1871 self.match(Python3Parser.ASSIGN)
1872 self.state = 334
1873 self.test()
1876 self.state = 341
1877 self._errHandler.sync(self)
1878 _alt = self._interp.adaptivePredict(self._input,33,self._ctx)
1880 self.state = 375
1881 self._errHandler.sync(self)
1882 _la = self._input.LA(1)
1883 if _la==Python3Parser.COMMA:
1884 self.state = 342
1885 self.match(Python3Parser.COMMA)
1886 self.state = 373
1887 self._errHandler.sync(self)
1888 token = self._input.LA(1)
1889 if token in [Python3Parser.STAR]:
1890 self.state = 343
1891 self.match(Python3Parser.STAR)
1892 self.state = 345
1893 self._errHandler.sync(self)
1894 _la = self._input.LA(1)
1895 if _la==Python3Parser.NAME:
1896 self.state = 344
1897 self.vfpdef()
1900 self.state = 355
1901 self._errHandler.sync(self)
1902 _alt = self._interp.adaptivePredict(self._input,36,self._ctx)
1903 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
1904 if _alt==1:
1905 self.state = 347
1906 self.match(Python3Parser.COMMA)
1907 self.state = 348
1908 self.vfpdef()
1909 self.state = 351
1910 self._errHandler.sync(self)
1911 _la = self._input.LA(1)
1912 if _la==Python3Parser.ASSIGN:
1913 self.state = 349
1914 self.match(Python3Parser.ASSIGN)
1915 self.state = 350
1916 self.test()
1919 self.state = 357
1920 self._errHandler.sync(self)
1921 _alt = self._interp.adaptivePredict(self._input,36,self._ctx)
1923 self.state = 366
1924 self._errHandler.sync(self)
1925 _la = self._input.LA(1)
1926 if _la==Python3Parser.COMMA:
1927 self.state = 358
1928 self.match(Python3Parser.COMMA)
1929 self.state = 364
1930 self._errHandler.sync(self)
1931 _la = self._input.LA(1)
1932 if _la==Python3Parser.POWER:
1933 self.state = 359
1934 self.match(Python3Parser.POWER)
1935 self.state = 360
1936 self.vfpdef()
1937 self.state = 362
1938 self._errHandler.sync(self)
1939 _la = self._input.LA(1)
1940 if _la==Python3Parser.COMMA:
1941 self.state = 361
1942 self.match(Python3Parser.COMMA)
1949 pass
1950 elif token in [Python3Parser.POWER]:
1951 self.state = 368
1952 self.match(Python3Parser.POWER)
1953 self.state = 369
1954 self.vfpdef()
1955 self.state = 371
1956 self._errHandler.sync(self)
1957 _la = self._input.LA(1)
1958 if _la==Python3Parser.COMMA:
1959 self.state = 370
1960 self.match(Python3Parser.COMMA)
1963 pass
1964 elif token in [Python3Parser.COLON]:
1965 pass
1966 else:
1967 pass
1970 pass
1971 elif token in [Python3Parser.STAR]:
1972 self.state = 377
1973 self.match(Python3Parser.STAR)
1974 self.state = 379
1975 self._errHandler.sync(self)
1976 _la = self._input.LA(1)
1977 if _la==Python3Parser.NAME:
1978 self.state = 378
1979 self.vfpdef()
1982 self.state = 389
1983 self._errHandler.sync(self)
1984 _alt = self._interp.adaptivePredict(self._input,45,self._ctx)
1985 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
1986 if _alt==1:
1987 self.state = 381
1988 self.match(Python3Parser.COMMA)
1989 self.state = 382
1990 self.vfpdef()
1991 self.state = 385
1992 self._errHandler.sync(self)
1993 _la = self._input.LA(1)
1994 if _la==Python3Parser.ASSIGN:
1995 self.state = 383
1996 self.match(Python3Parser.ASSIGN)
1997 self.state = 384
1998 self.test()
2001 self.state = 391
2002 self._errHandler.sync(self)
2003 _alt = self._interp.adaptivePredict(self._input,45,self._ctx)
2005 self.state = 400
2006 self._errHandler.sync(self)
2007 _la = self._input.LA(1)
2008 if _la==Python3Parser.COMMA:
2009 self.state = 392
2010 self.match(Python3Parser.COMMA)
2011 self.state = 398
2012 self._errHandler.sync(self)
2013 _la = self._input.LA(1)
2014 if _la==Python3Parser.POWER:
2015 self.state = 393
2016 self.match(Python3Parser.POWER)
2017 self.state = 394
2018 self.vfpdef()
2019 self.state = 396
2020 self._errHandler.sync(self)
2021 _la = self._input.LA(1)
2022 if _la==Python3Parser.COMMA:
2023 self.state = 395
2024 self.match(Python3Parser.COMMA)
2031 pass
2032 elif token in [Python3Parser.POWER]:
2033 self.state = 402
2034 self.match(Python3Parser.POWER)
2035 self.state = 403
2036 self.vfpdef()
2037 self.state = 405
2038 self._errHandler.sync(self)
2039 _la = self._input.LA(1)
2040 if _la==Python3Parser.COMMA:
2041 self.state = 404
2042 self.match(Python3Parser.COMMA)
2045 pass
2046 else:
2047 raise NoViableAltException(self)
2049 except RecognitionException as re:
2050 localctx.exception = re
2051 self._errHandler.reportError(self, re)
2052 self._errHandler.recover(self, re)
2053 finally:
2054 self.exitRule()
2055 return localctx
2058 class VfpdefContext(ParserRuleContext):
2060 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2061 super().__init__(parent, invokingState)
2062 self.parser = parser
2064 def NAME(self):
2065 return self.getToken(Python3Parser.NAME, 0)
2067 def getRuleIndex(self):
2068 return Python3Parser.RULE_vfpdef
2070 def enterRule(self, listener:ParseTreeListener):
2071 if hasattr( listener, "enterVfpdef" ):
2072 listener.enterVfpdef(self)
2074 def exitRule(self, listener:ParseTreeListener):
2075 if hasattr( listener, "exitVfpdef" ):
2076 listener.exitVfpdef(self)
2081 def vfpdef(self):
2083 localctx = Python3Parser.VfpdefContext(self, self._ctx, self.state)
2084 self.enterRule(localctx, 24, self.RULE_vfpdef)
2085 try:
2086 self.enterOuterAlt(localctx, 1)
2087 self.state = 409
2088 self.match(Python3Parser.NAME)
2089 except RecognitionException as re:
2090 localctx.exception = re
2091 self._errHandler.reportError(self, re)
2092 self._errHandler.recover(self, re)
2093 finally:
2094 self.exitRule()
2095 return localctx
2098 class StmtContext(ParserRuleContext):
2100 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2101 super().__init__(parent, invokingState)
2102 self.parser = parser
2104 def simple_stmt(self):
2105 return self.getTypedRuleContext(Python3Parser.Simple_stmtContext,0)
2108 def compound_stmt(self):
2109 return self.getTypedRuleContext(Python3Parser.Compound_stmtContext,0)
2112 def getRuleIndex(self):
2113 return Python3Parser.RULE_stmt
2115 def enterRule(self, listener:ParseTreeListener):
2116 if hasattr( listener, "enterStmt" ):
2117 listener.enterStmt(self)
2119 def exitRule(self, listener:ParseTreeListener):
2120 if hasattr( listener, "exitStmt" ):
2121 listener.exitStmt(self)
2126 def stmt(self):
2128 localctx = Python3Parser.StmtContext(self, self._ctx, self.state)
2129 self.enterRule(localctx, 26, self.RULE_stmt)
2130 try:
2131 self.state = 413
2132 self._errHandler.sync(self)
2133 token = self._input.LA(1)
2134 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]:
2135 self.enterOuterAlt(localctx, 1)
2136 self.state = 411
2137 self.simple_stmt()
2138 pass
2139 elif token in [Python3Parser.DEF, Python3Parser.IF, Python3Parser.WHILE, Python3Parser.FOR, Python3Parser.TRY, Python3Parser.WITH, Python3Parser.CLASS, Python3Parser.ASYNC, Python3Parser.AT]:
2140 self.enterOuterAlt(localctx, 2)
2141 self.state = 412
2142 self.compound_stmt()
2143 pass
2144 else:
2145 raise NoViableAltException(self)
2147 except RecognitionException as re:
2148 localctx.exception = re
2149 self._errHandler.reportError(self, re)
2150 self._errHandler.recover(self, re)
2151 finally:
2152 self.exitRule()
2153 return localctx
2156 class Simple_stmtContext(ParserRuleContext):
2158 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2159 super().__init__(parent, invokingState)
2160 self.parser = parser
2162 def small_stmt(self, i:int=None):
2163 if i is None:
2164 return self.getTypedRuleContexts(Python3Parser.Small_stmtContext)
2165 else:
2166 return self.getTypedRuleContext(Python3Parser.Small_stmtContext,i)
2169 def NEWLINE(self):
2170 return self.getToken(Python3Parser.NEWLINE, 0)
2172 def SEMI_COLON(self, i:int=None):
2173 if i is None:
2174 return self.getTokens(Python3Parser.SEMI_COLON)
2175 else:
2176 return self.getToken(Python3Parser.SEMI_COLON, i)
2178 def getRuleIndex(self):
2179 return Python3Parser.RULE_simple_stmt
2181 def enterRule(self, listener:ParseTreeListener):
2182 if hasattr( listener, "enterSimple_stmt" ):
2183 listener.enterSimple_stmt(self)
2185 def exitRule(self, listener:ParseTreeListener):
2186 if hasattr( listener, "exitSimple_stmt" ):
2187 listener.exitSimple_stmt(self)
2192 def simple_stmt(self):
2194 localctx = Python3Parser.Simple_stmtContext(self, self._ctx, self.state)
2195 self.enterRule(localctx, 28, self.RULE_simple_stmt)
2196 self._la = 0 # Token type
2197 try:
2198 self.enterOuterAlt(localctx, 1)
2199 self.state = 415
2200 self.small_stmt()
2201 self.state = 420
2202 self._errHandler.sync(self)
2203 _alt = self._interp.adaptivePredict(self._input,52,self._ctx)
2204 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
2205 if _alt==1:
2206 self.state = 416
2207 self.match(Python3Parser.SEMI_COLON)
2208 self.state = 417
2209 self.small_stmt()
2210 self.state = 422
2211 self._errHandler.sync(self)
2212 _alt = self._interp.adaptivePredict(self._input,52,self._ctx)
2214 self.state = 424
2215 self._errHandler.sync(self)
2216 _la = self._input.LA(1)
2217 if _la==Python3Parser.SEMI_COLON:
2218 self.state = 423
2219 self.match(Python3Parser.SEMI_COLON)
2222 self.state = 426
2223 self.match(Python3Parser.NEWLINE)
2224 except RecognitionException as re:
2225 localctx.exception = re
2226 self._errHandler.reportError(self, re)
2227 self._errHandler.recover(self, re)
2228 finally:
2229 self.exitRule()
2230 return localctx
2233 class Small_stmtContext(ParserRuleContext):
2235 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2236 super().__init__(parent, invokingState)
2237 self.parser = parser
2239 def expr_stmt(self):
2240 return self.getTypedRuleContext(Python3Parser.Expr_stmtContext,0)
2243 def del_stmt(self):
2244 return self.getTypedRuleContext(Python3Parser.Del_stmtContext,0)
2247 def pass_stmt(self):
2248 return self.getTypedRuleContext(Python3Parser.Pass_stmtContext,0)
2251 def flow_stmt(self):
2252 return self.getTypedRuleContext(Python3Parser.Flow_stmtContext,0)
2255 def import_stmt(self):
2256 return self.getTypedRuleContext(Python3Parser.Import_stmtContext,0)
2259 def global_stmt(self):
2260 return self.getTypedRuleContext(Python3Parser.Global_stmtContext,0)
2263 def nonlocal_stmt(self):
2264 return self.getTypedRuleContext(Python3Parser.Nonlocal_stmtContext,0)
2267 def assert_stmt(self):
2268 return self.getTypedRuleContext(Python3Parser.Assert_stmtContext,0)
2271 def getRuleIndex(self):
2272 return Python3Parser.RULE_small_stmt
2274 def enterRule(self, listener:ParseTreeListener):
2275 if hasattr( listener, "enterSmall_stmt" ):
2276 listener.enterSmall_stmt(self)
2278 def exitRule(self, listener:ParseTreeListener):
2279 if hasattr( listener, "exitSmall_stmt" ):
2280 listener.exitSmall_stmt(self)
2285 def small_stmt(self):
2287 localctx = Python3Parser.Small_stmtContext(self, self._ctx, self.state)
2288 self.enterRule(localctx, 30, self.RULE_small_stmt)
2289 try:
2290 self.enterOuterAlt(localctx, 1)
2291 self.state = 436
2292 self._errHandler.sync(self)
2293 token = self._input.LA(1)
2294 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]:
2295 self.state = 428
2296 self.expr_stmt()
2297 pass
2298 elif token in [Python3Parser.DEL]:
2299 self.state = 429
2300 self.del_stmt()
2301 pass
2302 elif token in [Python3Parser.PASS]:
2303 self.state = 430
2304 self.pass_stmt()
2305 pass
2306 elif token in [Python3Parser.RETURN, Python3Parser.RAISE, Python3Parser.YIELD, Python3Parser.CONTINUE, Python3Parser.BREAK]:
2307 self.state = 431
2308 self.flow_stmt()
2309 pass
2310 elif token in [Python3Parser.FROM, Python3Parser.IMPORT]:
2311 self.state = 432
2312 self.import_stmt()
2313 pass
2314 elif token in [Python3Parser.GLOBAL]:
2315 self.state = 433
2316 self.global_stmt()
2317 pass
2318 elif token in [Python3Parser.NONLOCAL]:
2319 self.state = 434
2320 self.nonlocal_stmt()
2321 pass
2322 elif token in [Python3Parser.ASSERT]:
2323 self.state = 435
2324 self.assert_stmt()
2325 pass
2326 else:
2327 raise NoViableAltException(self)
2329 except RecognitionException as re:
2330 localctx.exception = re
2331 self._errHandler.reportError(self, re)
2332 self._errHandler.recover(self, re)
2333 finally:
2334 self.exitRule()
2335 return localctx
2338 class Expr_stmtContext(ParserRuleContext):
2340 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2341 super().__init__(parent, invokingState)
2342 self.parser = parser
2344 def testlist_star_expr(self, i:int=None):
2345 if i is None:
2346 return self.getTypedRuleContexts(Python3Parser.Testlist_star_exprContext)
2347 else:
2348 return self.getTypedRuleContext(Python3Parser.Testlist_star_exprContext,i)
2351 def annassign(self):
2352 return self.getTypedRuleContext(Python3Parser.AnnassignContext,0)
2355 def augassign(self):
2356 return self.getTypedRuleContext(Python3Parser.AugassignContext,0)
2359 def yield_expr(self, i:int=None):
2360 if i is None:
2361 return self.getTypedRuleContexts(Python3Parser.Yield_exprContext)
2362 else:
2363 return self.getTypedRuleContext(Python3Parser.Yield_exprContext,i)
2366 def testlist(self):
2367 return self.getTypedRuleContext(Python3Parser.TestlistContext,0)
2370 def ASSIGN(self, i:int=None):
2371 if i is None:
2372 return self.getTokens(Python3Parser.ASSIGN)
2373 else:
2374 return self.getToken(Python3Parser.ASSIGN, i)
2376 def getRuleIndex(self):
2377 return Python3Parser.RULE_expr_stmt
2379 def enterRule(self, listener:ParseTreeListener):
2380 if hasattr( listener, "enterExpr_stmt" ):
2381 listener.enterExpr_stmt(self)
2383 def exitRule(self, listener:ParseTreeListener):
2384 if hasattr( listener, "exitExpr_stmt" ):
2385 listener.exitExpr_stmt(self)
2390 def expr_stmt(self):
2392 localctx = Python3Parser.Expr_stmtContext(self, self._ctx, self.state)
2393 self.enterRule(localctx, 32, self.RULE_expr_stmt)
2394 self._la = 0 # Token type
2395 try:
2396 self.enterOuterAlt(localctx, 1)
2397 self.state = 438
2398 self.testlist_star_expr()
2399 self.state = 455
2400 self._errHandler.sync(self)
2401 token = self._input.LA(1)
2402 if token in [Python3Parser.COLON]:
2403 self.state = 439
2404 self.annassign()
2405 pass
2406 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]:
2407 self.state = 440
2408 self.augassign()
2409 self.state = 443
2410 self._errHandler.sync(self)
2411 token = self._input.LA(1)
2412 if token in [Python3Parser.YIELD]:
2413 self.state = 441
2414 self.yield_expr()
2415 pass
2416 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]:
2417 self.state = 442
2418 self.testlist()
2419 pass
2420 else:
2421 raise NoViableAltException(self)
2423 pass
2424 elif token in [Python3Parser.NEWLINE, Python3Parser.SEMI_COLON, Python3Parser.ASSIGN]:
2425 self.state = 452
2426 self._errHandler.sync(self)
2427 _la = self._input.LA(1)
2428 while _la==Python3Parser.ASSIGN:
2429 self.state = 445
2430 self.match(Python3Parser.ASSIGN)
2431 self.state = 448
2432 self._errHandler.sync(self)
2433 token = self._input.LA(1)
2434 if token in [Python3Parser.YIELD]:
2435 self.state = 446
2436 self.yield_expr()
2437 pass
2438 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]:
2439 self.state = 447
2440 self.testlist_star_expr()
2441 pass
2442 else:
2443 raise NoViableAltException(self)
2445 self.state = 454
2446 self._errHandler.sync(self)
2447 _la = self._input.LA(1)
2449 pass
2450 else:
2451 raise NoViableAltException(self)
2453 except RecognitionException as re:
2454 localctx.exception = re
2455 self._errHandler.reportError(self, re)
2456 self._errHandler.recover(self, re)
2457 finally:
2458 self.exitRule()
2459 return localctx
2462 class AnnassignContext(ParserRuleContext):
2464 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2465 super().__init__(parent, invokingState)
2466 self.parser = parser
2468 def COLON(self):
2469 return self.getToken(Python3Parser.COLON, 0)
2471 def test(self, i:int=None):
2472 if i is None:
2473 return self.getTypedRuleContexts(Python3Parser.TestContext)
2474 else:
2475 return self.getTypedRuleContext(Python3Parser.TestContext,i)
2478 def ASSIGN(self):
2479 return self.getToken(Python3Parser.ASSIGN, 0)
2481 def getRuleIndex(self):
2482 return Python3Parser.RULE_annassign
2484 def enterRule(self, listener:ParseTreeListener):
2485 if hasattr( listener, "enterAnnassign" ):
2486 listener.enterAnnassign(self)
2488 def exitRule(self, listener:ParseTreeListener):
2489 if hasattr( listener, "exitAnnassign" ):
2490 listener.exitAnnassign(self)
2495 def annassign(self):
2497 localctx = Python3Parser.AnnassignContext(self, self._ctx, self.state)
2498 self.enterRule(localctx, 34, self.RULE_annassign)
2499 self._la = 0 # Token type
2500 try:
2501 self.enterOuterAlt(localctx, 1)
2502 self.state = 457
2503 self.match(Python3Parser.COLON)
2504 self.state = 458
2505 self.test()
2506 self.state = 461
2507 self._errHandler.sync(self)
2508 _la = self._input.LA(1)
2509 if _la==Python3Parser.ASSIGN:
2510 self.state = 459
2511 self.match(Python3Parser.ASSIGN)
2512 self.state = 460
2513 self.test()
2516 except RecognitionException as re:
2517 localctx.exception = re
2518 self._errHandler.reportError(self, re)
2519 self._errHandler.recover(self, re)
2520 finally:
2521 self.exitRule()
2522 return localctx
2525 class Testlist_star_exprContext(ParserRuleContext):
2527 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2528 super().__init__(parent, invokingState)
2529 self.parser = parser
2531 def test(self, i:int=None):
2532 if i is None:
2533 return self.getTypedRuleContexts(Python3Parser.TestContext)
2534 else:
2535 return self.getTypedRuleContext(Python3Parser.TestContext,i)
2538 def star_expr(self, i:int=None):
2539 if i is None:
2540 return self.getTypedRuleContexts(Python3Parser.Star_exprContext)
2541 else:
2542 return self.getTypedRuleContext(Python3Parser.Star_exprContext,i)
2545 def COMMA(self, i:int=None):
2546 if i is None:
2547 return self.getTokens(Python3Parser.COMMA)
2548 else:
2549 return self.getToken(Python3Parser.COMMA, i)
2551 def getRuleIndex(self):
2552 return Python3Parser.RULE_testlist_star_expr
2554 def enterRule(self, listener:ParseTreeListener):
2555 if hasattr( listener, "enterTestlist_star_expr" ):
2556 listener.enterTestlist_star_expr(self)
2558 def exitRule(self, listener:ParseTreeListener):
2559 if hasattr( listener, "exitTestlist_star_expr" ):
2560 listener.exitTestlist_star_expr(self)
2565 def testlist_star_expr(self):
2567 localctx = Python3Parser.Testlist_star_exprContext(self, self._ctx, self.state)
2568 self.enterRule(localctx, 36, self.RULE_testlist_star_expr)
2569 self._la = 0 # Token type
2570 try:
2571 self.enterOuterAlt(localctx, 1)
2572 self.state = 465
2573 self._errHandler.sync(self)
2574 token = self._input.LA(1)
2575 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]:
2576 self.state = 463
2577 self.test()
2578 pass
2579 elif token in [Python3Parser.STAR]:
2580 self.state = 464
2581 self.star_expr()
2582 pass
2583 else:
2584 raise NoViableAltException(self)
2586 self.state = 474
2587 self._errHandler.sync(self)
2588 _alt = self._interp.adaptivePredict(self._input,62,self._ctx)
2589 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
2590 if _alt==1:
2591 self.state = 467
2592 self.match(Python3Parser.COMMA)
2593 self.state = 470
2594 self._errHandler.sync(self)
2595 token = self._input.LA(1)
2596 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]:
2597 self.state = 468
2598 self.test()
2599 pass
2600 elif token in [Python3Parser.STAR]:
2601 self.state = 469
2602 self.star_expr()
2603 pass
2604 else:
2605 raise NoViableAltException(self)
2607 self.state = 476
2608 self._errHandler.sync(self)
2609 _alt = self._interp.adaptivePredict(self._input,62,self._ctx)
2611 self.state = 478
2612 self._errHandler.sync(self)
2613 _la = self._input.LA(1)
2614 if _la==Python3Parser.COMMA:
2615 self.state = 477
2616 self.match(Python3Parser.COMMA)
2619 except RecognitionException as re:
2620 localctx.exception = re
2621 self._errHandler.reportError(self, re)
2622 self._errHandler.recover(self, re)
2623 finally:
2624 self.exitRule()
2625 return localctx
2628 class AugassignContext(ParserRuleContext):
2630 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2631 super().__init__(parent, invokingState)
2632 self.parser = parser
2634 def ADD_ASSIGN(self):
2635 return self.getToken(Python3Parser.ADD_ASSIGN, 0)
2637 def SUB_ASSIGN(self):
2638 return self.getToken(Python3Parser.SUB_ASSIGN, 0)
2640 def MULT_ASSIGN(self):
2641 return self.getToken(Python3Parser.MULT_ASSIGN, 0)
2643 def AT_ASSIGN(self):
2644 return self.getToken(Python3Parser.AT_ASSIGN, 0)
2646 def DIV_ASSIGN(self):
2647 return self.getToken(Python3Parser.DIV_ASSIGN, 0)
2649 def MOD_ASSIGN(self):
2650 return self.getToken(Python3Parser.MOD_ASSIGN, 0)
2652 def AND_ASSIGN(self):
2653 return self.getToken(Python3Parser.AND_ASSIGN, 0)
2655 def OR_ASSIGN(self):
2656 return self.getToken(Python3Parser.OR_ASSIGN, 0)
2658 def XOR_ASSIGN(self):
2659 return self.getToken(Python3Parser.XOR_ASSIGN, 0)
2661 def LEFT_SHIFT_ASSIGN(self):
2662 return self.getToken(Python3Parser.LEFT_SHIFT_ASSIGN, 0)
2664 def RIGHT_SHIFT_ASSIGN(self):
2665 return self.getToken(Python3Parser.RIGHT_SHIFT_ASSIGN, 0)
2667 def POWER_ASSIGN(self):
2668 return self.getToken(Python3Parser.POWER_ASSIGN, 0)
2670 def IDIV_ASSIGN(self):
2671 return self.getToken(Python3Parser.IDIV_ASSIGN, 0)
2673 def getRuleIndex(self):
2674 return Python3Parser.RULE_augassign
2676 def enterRule(self, listener:ParseTreeListener):
2677 if hasattr( listener, "enterAugassign" ):
2678 listener.enterAugassign(self)
2680 def exitRule(self, listener:ParseTreeListener):
2681 if hasattr( listener, "exitAugassign" ):
2682 listener.exitAugassign(self)
2687 def augassign(self):
2689 localctx = Python3Parser.AugassignContext(self, self._ctx, self.state)
2690 self.enterRule(localctx, 38, self.RULE_augassign)
2691 self._la = 0 # Token type
2692 try:
2693 self.enterOuterAlt(localctx, 1)
2694 self.state = 480
2695 _la = self._input.LA(1)
2696 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)):
2697 self._errHandler.recoverInline(self)
2698 else:
2699 self._errHandler.reportMatch(self)
2700 self.consume()
2701 except RecognitionException as re:
2702 localctx.exception = re
2703 self._errHandler.reportError(self, re)
2704 self._errHandler.recover(self, re)
2705 finally:
2706 self.exitRule()
2707 return localctx
2710 class Del_stmtContext(ParserRuleContext):
2712 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2713 super().__init__(parent, invokingState)
2714 self.parser = parser
2716 def DEL(self):
2717 return self.getToken(Python3Parser.DEL, 0)
2719 def exprlist(self):
2720 return self.getTypedRuleContext(Python3Parser.ExprlistContext,0)
2723 def getRuleIndex(self):
2724 return Python3Parser.RULE_del_stmt
2726 def enterRule(self, listener:ParseTreeListener):
2727 if hasattr( listener, "enterDel_stmt" ):
2728 listener.enterDel_stmt(self)
2730 def exitRule(self, listener:ParseTreeListener):
2731 if hasattr( listener, "exitDel_stmt" ):
2732 listener.exitDel_stmt(self)
2737 def del_stmt(self):
2739 localctx = Python3Parser.Del_stmtContext(self, self._ctx, self.state)
2740 self.enterRule(localctx, 40, self.RULE_del_stmt)
2741 try:
2742 self.enterOuterAlt(localctx, 1)
2743 self.state = 482
2744 self.match(Python3Parser.DEL)
2745 self.state = 483
2746 self.exprlist()
2747 except RecognitionException as re:
2748 localctx.exception = re
2749 self._errHandler.reportError(self, re)
2750 self._errHandler.recover(self, re)
2751 finally:
2752 self.exitRule()
2753 return localctx
2756 class Pass_stmtContext(ParserRuleContext):
2758 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2759 super().__init__(parent, invokingState)
2760 self.parser = parser
2762 def PASS(self):
2763 return self.getToken(Python3Parser.PASS, 0)
2765 def getRuleIndex(self):
2766 return Python3Parser.RULE_pass_stmt
2768 def enterRule(self, listener:ParseTreeListener):
2769 if hasattr( listener, "enterPass_stmt" ):
2770 listener.enterPass_stmt(self)
2772 def exitRule(self, listener:ParseTreeListener):
2773 if hasattr( listener, "exitPass_stmt" ):
2774 listener.exitPass_stmt(self)
2779 def pass_stmt(self):
2781 localctx = Python3Parser.Pass_stmtContext(self, self._ctx, self.state)
2782 self.enterRule(localctx, 42, self.RULE_pass_stmt)
2783 try:
2784 self.enterOuterAlt(localctx, 1)
2785 self.state = 485
2786 self.match(Python3Parser.PASS)
2787 except RecognitionException as re:
2788 localctx.exception = re
2789 self._errHandler.reportError(self, re)
2790 self._errHandler.recover(self, re)
2791 finally:
2792 self.exitRule()
2793 return localctx
2796 class Flow_stmtContext(ParserRuleContext):
2798 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2799 super().__init__(parent, invokingState)
2800 self.parser = parser
2802 def break_stmt(self):
2803 return self.getTypedRuleContext(Python3Parser.Break_stmtContext,0)
2806 def continue_stmt(self):
2807 return self.getTypedRuleContext(Python3Parser.Continue_stmtContext,0)
2810 def return_stmt(self):
2811 return self.getTypedRuleContext(Python3Parser.Return_stmtContext,0)
2814 def raise_stmt(self):
2815 return self.getTypedRuleContext(Python3Parser.Raise_stmtContext,0)
2818 def yield_stmt(self):
2819 return self.getTypedRuleContext(Python3Parser.Yield_stmtContext,0)
2822 def getRuleIndex(self):
2823 return Python3Parser.RULE_flow_stmt
2825 def enterRule(self, listener:ParseTreeListener):
2826 if hasattr( listener, "enterFlow_stmt" ):
2827 listener.enterFlow_stmt(self)
2829 def exitRule(self, listener:ParseTreeListener):
2830 if hasattr( listener, "exitFlow_stmt" ):
2831 listener.exitFlow_stmt(self)
2836 def flow_stmt(self):
2838 localctx = Python3Parser.Flow_stmtContext(self, self._ctx, self.state)
2839 self.enterRule(localctx, 44, self.RULE_flow_stmt)
2840 try:
2841 self.state = 492
2842 self._errHandler.sync(self)
2843 token = self._input.LA(1)
2844 if token in [Python3Parser.BREAK]:
2845 self.enterOuterAlt(localctx, 1)
2846 self.state = 487
2847 self.break_stmt()
2848 pass
2849 elif token in [Python3Parser.CONTINUE]:
2850 self.enterOuterAlt(localctx, 2)
2851 self.state = 488
2852 self.continue_stmt()
2853 pass
2854 elif token in [Python3Parser.RETURN]:
2855 self.enterOuterAlt(localctx, 3)
2856 self.state = 489
2857 self.return_stmt()
2858 pass
2859 elif token in [Python3Parser.RAISE]:
2860 self.enterOuterAlt(localctx, 4)
2861 self.state = 490
2862 self.raise_stmt()
2863 pass
2864 elif token in [Python3Parser.YIELD]:
2865 self.enterOuterAlt(localctx, 5)
2866 self.state = 491
2867 self.yield_stmt()
2868 pass
2869 else:
2870 raise NoViableAltException(self)
2872 except RecognitionException as re:
2873 localctx.exception = re
2874 self._errHandler.reportError(self, re)
2875 self._errHandler.recover(self, re)
2876 finally:
2877 self.exitRule()
2878 return localctx
2881 class Break_stmtContext(ParserRuleContext):
2883 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2884 super().__init__(parent, invokingState)
2885 self.parser = parser
2887 def BREAK(self):
2888 return self.getToken(Python3Parser.BREAK, 0)
2890 def getRuleIndex(self):
2891 return Python3Parser.RULE_break_stmt
2893 def enterRule(self, listener:ParseTreeListener):
2894 if hasattr( listener, "enterBreak_stmt" ):
2895 listener.enterBreak_stmt(self)
2897 def exitRule(self, listener:ParseTreeListener):
2898 if hasattr( listener, "exitBreak_stmt" ):
2899 listener.exitBreak_stmt(self)
2904 def break_stmt(self):
2906 localctx = Python3Parser.Break_stmtContext(self, self._ctx, self.state)
2907 self.enterRule(localctx, 46, self.RULE_break_stmt)
2908 try:
2909 self.enterOuterAlt(localctx, 1)
2910 self.state = 494
2911 self.match(Python3Parser.BREAK)
2912 except RecognitionException as re:
2913 localctx.exception = re
2914 self._errHandler.reportError(self, re)
2915 self._errHandler.recover(self, re)
2916 finally:
2917 self.exitRule()
2918 return localctx
2921 class Continue_stmtContext(ParserRuleContext):
2923 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2924 super().__init__(parent, invokingState)
2925 self.parser = parser
2927 def CONTINUE(self):
2928 return self.getToken(Python3Parser.CONTINUE, 0)
2930 def getRuleIndex(self):
2931 return Python3Parser.RULE_continue_stmt
2933 def enterRule(self, listener:ParseTreeListener):
2934 if hasattr( listener, "enterContinue_stmt" ):
2935 listener.enterContinue_stmt(self)
2937 def exitRule(self, listener:ParseTreeListener):
2938 if hasattr( listener, "exitContinue_stmt" ):
2939 listener.exitContinue_stmt(self)
2944 def continue_stmt(self):
2946 localctx = Python3Parser.Continue_stmtContext(self, self._ctx, self.state)
2947 self.enterRule(localctx, 48, self.RULE_continue_stmt)
2948 try:
2949 self.enterOuterAlt(localctx, 1)
2950 self.state = 496
2951 self.match(Python3Parser.CONTINUE)
2952 except RecognitionException as re:
2953 localctx.exception = re
2954 self._errHandler.reportError(self, re)
2955 self._errHandler.recover(self, re)
2956 finally:
2957 self.exitRule()
2958 return localctx
2961 class Return_stmtContext(ParserRuleContext):
2963 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
2964 super().__init__(parent, invokingState)
2965 self.parser = parser
2967 def RETURN(self):
2968 return self.getToken(Python3Parser.RETURN, 0)
2970 def testlist(self):
2971 return self.getTypedRuleContext(Python3Parser.TestlistContext,0)
2974 def getRuleIndex(self):
2975 return Python3Parser.RULE_return_stmt
2977 def enterRule(self, listener:ParseTreeListener):
2978 if hasattr( listener, "enterReturn_stmt" ):
2979 listener.enterReturn_stmt(self)
2981 def exitRule(self, listener:ParseTreeListener):
2982 if hasattr( listener, "exitReturn_stmt" ):
2983 listener.exitReturn_stmt(self)
2988 def return_stmt(self):
2990 localctx = Python3Parser.Return_stmtContext(self, self._ctx, self.state)
2991 self.enterRule(localctx, 50, self.RULE_return_stmt)
2992 self._la = 0 # Token type
2993 try:
2994 self.enterOuterAlt(localctx, 1)
2995 self.state = 498
2996 self.match(Python3Parser.RETURN)
2997 self.state = 500
2998 self._errHandler.sync(self)
2999 _la = self._input.LA(1)
3000 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):
3001 self.state = 499
3002 self.testlist()
3005 except RecognitionException as re:
3006 localctx.exception = re
3007 self._errHandler.reportError(self, re)
3008 self._errHandler.recover(self, re)
3009 finally:
3010 self.exitRule()
3011 return localctx
3014 class Yield_stmtContext(ParserRuleContext):
3016 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3017 super().__init__(parent, invokingState)
3018 self.parser = parser
3020 def yield_expr(self):
3021 return self.getTypedRuleContext(Python3Parser.Yield_exprContext,0)
3024 def getRuleIndex(self):
3025 return Python3Parser.RULE_yield_stmt
3027 def enterRule(self, listener:ParseTreeListener):
3028 if hasattr( listener, "enterYield_stmt" ):
3029 listener.enterYield_stmt(self)
3031 def exitRule(self, listener:ParseTreeListener):
3032 if hasattr( listener, "exitYield_stmt" ):
3033 listener.exitYield_stmt(self)
3038 def yield_stmt(self):
3040 localctx = Python3Parser.Yield_stmtContext(self, self._ctx, self.state)
3041 self.enterRule(localctx, 52, self.RULE_yield_stmt)
3042 try:
3043 self.enterOuterAlt(localctx, 1)
3044 self.state = 502
3045 self.yield_expr()
3046 except RecognitionException as re:
3047 localctx.exception = re
3048 self._errHandler.reportError(self, re)
3049 self._errHandler.recover(self, re)
3050 finally:
3051 self.exitRule()
3052 return localctx
3055 class Raise_stmtContext(ParserRuleContext):
3057 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3058 super().__init__(parent, invokingState)
3059 self.parser = parser
3061 def RAISE(self):
3062 return self.getToken(Python3Parser.RAISE, 0)
3064 def test(self, i:int=None):
3065 if i is None:
3066 return self.getTypedRuleContexts(Python3Parser.TestContext)
3067 else:
3068 return self.getTypedRuleContext(Python3Parser.TestContext,i)
3071 def FROM(self):
3072 return self.getToken(Python3Parser.FROM, 0)
3074 def getRuleIndex(self):
3075 return Python3Parser.RULE_raise_stmt
3077 def enterRule(self, listener:ParseTreeListener):
3078 if hasattr( listener, "enterRaise_stmt" ):
3079 listener.enterRaise_stmt(self)
3081 def exitRule(self, listener:ParseTreeListener):
3082 if hasattr( listener, "exitRaise_stmt" ):
3083 listener.exitRaise_stmt(self)
3088 def raise_stmt(self):
3090 localctx = Python3Parser.Raise_stmtContext(self, self._ctx, self.state)
3091 self.enterRule(localctx, 54, self.RULE_raise_stmt)
3092 self._la = 0 # Token type
3093 try:
3094 self.enterOuterAlt(localctx, 1)
3095 self.state = 504
3096 self.match(Python3Parser.RAISE)
3097 self.state = 510
3098 self._errHandler.sync(self)
3099 _la = self._input.LA(1)
3100 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):
3101 self.state = 505
3102 self.test()
3103 self.state = 508
3104 self._errHandler.sync(self)
3105 _la = self._input.LA(1)
3106 if _la==Python3Parser.FROM:
3107 self.state = 506
3108 self.match(Python3Parser.FROM)
3109 self.state = 507
3110 self.test()
3115 except RecognitionException as re:
3116 localctx.exception = re
3117 self._errHandler.reportError(self, re)
3118 self._errHandler.recover(self, re)
3119 finally:
3120 self.exitRule()
3121 return localctx
3124 class Import_stmtContext(ParserRuleContext):
3126 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3127 super().__init__(parent, invokingState)
3128 self.parser = parser
3130 def import_name(self):
3131 return self.getTypedRuleContext(Python3Parser.Import_nameContext,0)
3134 def import_from(self):
3135 return self.getTypedRuleContext(Python3Parser.Import_fromContext,0)
3138 def getRuleIndex(self):
3139 return Python3Parser.RULE_import_stmt
3141 def enterRule(self, listener:ParseTreeListener):
3142 if hasattr( listener, "enterImport_stmt" ):
3143 listener.enterImport_stmt(self)
3145 def exitRule(self, listener:ParseTreeListener):
3146 if hasattr( listener, "exitImport_stmt" ):
3147 listener.exitImport_stmt(self)
3152 def import_stmt(self):
3154 localctx = Python3Parser.Import_stmtContext(self, self._ctx, self.state)
3155 self.enterRule(localctx, 56, self.RULE_import_stmt)
3156 try:
3157 self.state = 514
3158 self._errHandler.sync(self)
3159 token = self._input.LA(1)
3160 if token in [Python3Parser.IMPORT]:
3161 self.enterOuterAlt(localctx, 1)
3162 self.state = 512
3163 self.import_name()
3164 pass
3165 elif token in [Python3Parser.FROM]:
3166 self.enterOuterAlt(localctx, 2)
3167 self.state = 513
3168 self.import_from()
3169 pass
3170 else:
3171 raise NoViableAltException(self)
3173 except RecognitionException as re:
3174 localctx.exception = re
3175 self._errHandler.reportError(self, re)
3176 self._errHandler.recover(self, re)
3177 finally:
3178 self.exitRule()
3179 return localctx
3182 class Import_nameContext(ParserRuleContext):
3184 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3185 super().__init__(parent, invokingState)
3186 self.parser = parser
3188 def IMPORT(self):
3189 return self.getToken(Python3Parser.IMPORT, 0)
3191 def dotted_as_names(self):
3192 return self.getTypedRuleContext(Python3Parser.Dotted_as_namesContext,0)
3195 def getRuleIndex(self):
3196 return Python3Parser.RULE_import_name
3198 def enterRule(self, listener:ParseTreeListener):
3199 if hasattr( listener, "enterImport_name" ):
3200 listener.enterImport_name(self)
3202 def exitRule(self, listener:ParseTreeListener):
3203 if hasattr( listener, "exitImport_name" ):
3204 listener.exitImport_name(self)
3209 def import_name(self):
3211 localctx = Python3Parser.Import_nameContext(self, self._ctx, self.state)
3212 self.enterRule(localctx, 58, self.RULE_import_name)
3213 try:
3214 self.enterOuterAlt(localctx, 1)
3215 self.state = 516
3216 self.match(Python3Parser.IMPORT)
3217 self.state = 517
3218 self.dotted_as_names()
3219 except RecognitionException as re:
3220 localctx.exception = re
3221 self._errHandler.reportError(self, re)
3222 self._errHandler.recover(self, re)
3223 finally:
3224 self.exitRule()
3225 return localctx
3228 class Import_fromContext(ParserRuleContext):
3230 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3231 super().__init__(parent, invokingState)
3232 self.parser = parser
3234 def FROM(self):
3235 return self.getToken(Python3Parser.FROM, 0)
3237 def IMPORT(self):
3238 return self.getToken(Python3Parser.IMPORT, 0)
3240 def dotted_name(self):
3241 return self.getTypedRuleContext(Python3Parser.Dotted_nameContext,0)
3244 def STAR(self):
3245 return self.getToken(Python3Parser.STAR, 0)
3247 def OPEN_PAREN(self):
3248 return self.getToken(Python3Parser.OPEN_PAREN, 0)
3250 def import_as_names(self):
3251 return self.getTypedRuleContext(Python3Parser.Import_as_namesContext,0)
3254 def CLOSE_PAREN(self):
3255 return self.getToken(Python3Parser.CLOSE_PAREN, 0)
3257 def DOT(self, i:int=None):
3258 if i is None:
3259 return self.getTokens(Python3Parser.DOT)
3260 else:
3261 return self.getToken(Python3Parser.DOT, i)
3263 def ELLIPSIS(self, i:int=None):
3264 if i is None:
3265 return self.getTokens(Python3Parser.ELLIPSIS)
3266 else:
3267 return self.getToken(Python3Parser.ELLIPSIS, i)
3269 def getRuleIndex(self):
3270 return Python3Parser.RULE_import_from
3272 def enterRule(self, listener:ParseTreeListener):
3273 if hasattr( listener, "enterImport_from" ):
3274 listener.enterImport_from(self)
3276 def exitRule(self, listener:ParseTreeListener):
3277 if hasattr( listener, "exitImport_from" ):
3278 listener.exitImport_from(self)
3283 def import_from(self):
3285 localctx = Python3Parser.Import_fromContext(self, self._ctx, self.state)
3286 self.enterRule(localctx, 60, self.RULE_import_from)
3287 self._la = 0 # Token type
3288 try:
3289 self.enterOuterAlt(localctx, 1)
3290 self.state = 519
3291 self.match(Python3Parser.FROM)
3292 self.state = 532
3293 self._errHandler.sync(self)
3294 la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
3295 if la_ == 1:
3296 self.state = 523
3297 self._errHandler.sync(self)
3298 _la = self._input.LA(1)
3299 while _la==Python3Parser.DOT or _la==Python3Parser.ELLIPSIS:
3300 self.state = 520
3301 _la = self._input.LA(1)
3302 if not(_la==Python3Parser.DOT or _la==Python3Parser.ELLIPSIS):
3303 self._errHandler.recoverInline(self)
3304 else:
3305 self._errHandler.reportMatch(self)
3306 self.consume()
3307 self.state = 525
3308 self._errHandler.sync(self)
3309 _la = self._input.LA(1)
3311 self.state = 526
3312 self.dotted_name()
3313 pass
3315 elif la_ == 2:
3316 self.state = 528
3317 self._errHandler.sync(self)
3318 _la = self._input.LA(1)
3319 while True:
3320 self.state = 527
3321 _la = self._input.LA(1)
3322 if not(_la==Python3Parser.DOT or _la==Python3Parser.ELLIPSIS):
3323 self._errHandler.recoverInline(self)
3324 else:
3325 self._errHandler.reportMatch(self)
3326 self.consume()
3327 self.state = 530
3328 self._errHandler.sync(self)
3329 _la = self._input.LA(1)
3330 if not (_la==Python3Parser.DOT or _la==Python3Parser.ELLIPSIS):
3331 break
3333 pass
3336 self.state = 534
3337 self.match(Python3Parser.IMPORT)
3338 self.state = 541
3339 self._errHandler.sync(self)
3340 token = self._input.LA(1)
3341 if token in [Python3Parser.STAR]:
3342 self.state = 535
3343 self.match(Python3Parser.STAR)
3344 pass
3345 elif token in [Python3Parser.OPEN_PAREN]:
3346 self.state = 536
3347 self.match(Python3Parser.OPEN_PAREN)
3348 self.state = 537
3349 self.import_as_names()
3350 self.state = 538
3351 self.match(Python3Parser.CLOSE_PAREN)
3352 pass
3353 elif token in [Python3Parser.NAME]:
3354 self.state = 540
3355 self.import_as_names()
3356 pass
3357 else:
3358 raise NoViableAltException(self)
3360 except RecognitionException as re:
3361 localctx.exception = re
3362 self._errHandler.reportError(self, re)
3363 self._errHandler.recover(self, re)
3364 finally:
3365 self.exitRule()
3366 return localctx
3369 class Import_as_nameContext(ParserRuleContext):
3371 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3372 super().__init__(parent, invokingState)
3373 self.parser = parser
3375 def NAME(self, i:int=None):
3376 if i is None:
3377 return self.getTokens(Python3Parser.NAME)
3378 else:
3379 return self.getToken(Python3Parser.NAME, i)
3381 def AS(self):
3382 return self.getToken(Python3Parser.AS, 0)
3384 def getRuleIndex(self):
3385 return Python3Parser.RULE_import_as_name
3387 def enterRule(self, listener:ParseTreeListener):
3388 if hasattr( listener, "enterImport_as_name" ):
3389 listener.enterImport_as_name(self)
3391 def exitRule(self, listener:ParseTreeListener):
3392 if hasattr( listener, "exitImport_as_name" ):
3393 listener.exitImport_as_name(self)
3398 def import_as_name(self):
3400 localctx = Python3Parser.Import_as_nameContext(self, self._ctx, self.state)
3401 self.enterRule(localctx, 62, self.RULE_import_as_name)
3402 self._la = 0 # Token type
3403 try:
3404 self.enterOuterAlt(localctx, 1)
3405 self.state = 543
3406 self.match(Python3Parser.NAME)
3407 self.state = 546
3408 self._errHandler.sync(self)
3409 _la = self._input.LA(1)
3410 if _la==Python3Parser.AS:
3411 self.state = 544
3412 self.match(Python3Parser.AS)
3413 self.state = 545
3414 self.match(Python3Parser.NAME)
3417 except RecognitionException as re:
3418 localctx.exception = re
3419 self._errHandler.reportError(self, re)
3420 self._errHandler.recover(self, re)
3421 finally:
3422 self.exitRule()
3423 return localctx
3426 class Dotted_as_nameContext(ParserRuleContext):
3428 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3429 super().__init__(parent, invokingState)
3430 self.parser = parser
3432 def dotted_name(self):
3433 return self.getTypedRuleContext(Python3Parser.Dotted_nameContext,0)
3436 def AS(self):
3437 return self.getToken(Python3Parser.AS, 0)
3439 def NAME(self):
3440 return self.getToken(Python3Parser.NAME, 0)
3442 def getRuleIndex(self):
3443 return Python3Parser.RULE_dotted_as_name
3445 def enterRule(self, listener:ParseTreeListener):
3446 if hasattr( listener, "enterDotted_as_name" ):
3447 listener.enterDotted_as_name(self)
3449 def exitRule(self, listener:ParseTreeListener):
3450 if hasattr( listener, "exitDotted_as_name" ):
3451 listener.exitDotted_as_name(self)
3456 def dotted_as_name(self):
3458 localctx = Python3Parser.Dotted_as_nameContext(self, self._ctx, self.state)
3459 self.enterRule(localctx, 64, self.RULE_dotted_as_name)
3460 self._la = 0 # Token type
3461 try:
3462 self.enterOuterAlt(localctx, 1)
3463 self.state = 548
3464 self.dotted_name()
3465 self.state = 551
3466 self._errHandler.sync(self)
3467 _la = self._input.LA(1)
3468 if _la==Python3Parser.AS:
3469 self.state = 549
3470 self.match(Python3Parser.AS)
3471 self.state = 550
3472 self.match(Python3Parser.NAME)
3475 except RecognitionException as re:
3476 localctx.exception = re
3477 self._errHandler.reportError(self, re)
3478 self._errHandler.recover(self, re)
3479 finally:
3480 self.exitRule()
3481 return localctx
3484 class Import_as_namesContext(ParserRuleContext):
3486 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3487 super().__init__(parent, invokingState)
3488 self.parser = parser
3490 def import_as_name(self, i:int=None):
3491 if i is None:
3492 return self.getTypedRuleContexts(Python3Parser.Import_as_nameContext)
3493 else:
3494 return self.getTypedRuleContext(Python3Parser.Import_as_nameContext,i)
3497 def COMMA(self, i:int=None):
3498 if i is None:
3499 return self.getTokens(Python3Parser.COMMA)
3500 else:
3501 return self.getToken(Python3Parser.COMMA, i)
3503 def getRuleIndex(self):
3504 return Python3Parser.RULE_import_as_names
3506 def enterRule(self, listener:ParseTreeListener):
3507 if hasattr( listener, "enterImport_as_names" ):
3508 listener.enterImport_as_names(self)
3510 def exitRule(self, listener:ParseTreeListener):
3511 if hasattr( listener, "exitImport_as_names" ):
3512 listener.exitImport_as_names(self)
3517 def import_as_names(self):
3519 localctx = Python3Parser.Import_as_namesContext(self, self._ctx, self.state)
3520 self.enterRule(localctx, 66, self.RULE_import_as_names)
3521 self._la = 0 # Token type
3522 try:
3523 self.enterOuterAlt(localctx, 1)
3524 self.state = 553
3525 self.import_as_name()
3526 self.state = 558
3527 self._errHandler.sync(self)
3528 _alt = self._interp.adaptivePredict(self._input,75,self._ctx)
3529 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
3530 if _alt==1:
3531 self.state = 554
3532 self.match(Python3Parser.COMMA)
3533 self.state = 555
3534 self.import_as_name()
3535 self.state = 560
3536 self._errHandler.sync(self)
3537 _alt = self._interp.adaptivePredict(self._input,75,self._ctx)
3539 self.state = 562
3540 self._errHandler.sync(self)
3541 _la = self._input.LA(1)
3542 if _la==Python3Parser.COMMA:
3543 self.state = 561
3544 self.match(Python3Parser.COMMA)
3547 except RecognitionException as re:
3548 localctx.exception = re
3549 self._errHandler.reportError(self, re)
3550 self._errHandler.recover(self, re)
3551 finally:
3552 self.exitRule()
3553 return localctx
3556 class Dotted_as_namesContext(ParserRuleContext):
3558 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3559 super().__init__(parent, invokingState)
3560 self.parser = parser
3562 def dotted_as_name(self, i:int=None):
3563 if i is None:
3564 return self.getTypedRuleContexts(Python3Parser.Dotted_as_nameContext)
3565 else:
3566 return self.getTypedRuleContext(Python3Parser.Dotted_as_nameContext,i)
3569 def COMMA(self, i:int=None):
3570 if i is None:
3571 return self.getTokens(Python3Parser.COMMA)
3572 else:
3573 return self.getToken(Python3Parser.COMMA, i)
3575 def getRuleIndex(self):
3576 return Python3Parser.RULE_dotted_as_names
3578 def enterRule(self, listener:ParseTreeListener):
3579 if hasattr( listener, "enterDotted_as_names" ):
3580 listener.enterDotted_as_names(self)
3582 def exitRule(self, listener:ParseTreeListener):
3583 if hasattr( listener, "exitDotted_as_names" ):
3584 listener.exitDotted_as_names(self)
3589 def dotted_as_names(self):
3591 localctx = Python3Parser.Dotted_as_namesContext(self, self._ctx, self.state)
3592 self.enterRule(localctx, 68, self.RULE_dotted_as_names)
3593 self._la = 0 # Token type
3594 try:
3595 self.enterOuterAlt(localctx, 1)
3596 self.state = 564
3597 self.dotted_as_name()
3598 self.state = 569
3599 self._errHandler.sync(self)
3600 _la = self._input.LA(1)
3601 while _la==Python3Parser.COMMA:
3602 self.state = 565
3603 self.match(Python3Parser.COMMA)
3604 self.state = 566
3605 self.dotted_as_name()
3606 self.state = 571
3607 self._errHandler.sync(self)
3608 _la = self._input.LA(1)
3610 except RecognitionException as re:
3611 localctx.exception = re
3612 self._errHandler.reportError(self, re)
3613 self._errHandler.recover(self, re)
3614 finally:
3615 self.exitRule()
3616 return localctx
3619 class Dotted_nameContext(ParserRuleContext):
3621 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3622 super().__init__(parent, invokingState)
3623 self.parser = parser
3625 def NAME(self, i:int=None):
3626 if i is None:
3627 return self.getTokens(Python3Parser.NAME)
3628 else:
3629 return self.getToken(Python3Parser.NAME, i)
3631 def DOT(self, i:int=None):
3632 if i is None:
3633 return self.getTokens(Python3Parser.DOT)
3634 else:
3635 return self.getToken(Python3Parser.DOT, i)
3637 def getRuleIndex(self):
3638 return Python3Parser.RULE_dotted_name
3640 def enterRule(self, listener:ParseTreeListener):
3641 if hasattr( listener, "enterDotted_name" ):
3642 listener.enterDotted_name(self)
3644 def exitRule(self, listener:ParseTreeListener):
3645 if hasattr( listener, "exitDotted_name" ):
3646 listener.exitDotted_name(self)
3651 def dotted_name(self):
3653 localctx = Python3Parser.Dotted_nameContext(self, self._ctx, self.state)
3654 self.enterRule(localctx, 70, self.RULE_dotted_name)
3655 self._la = 0 # Token type
3656 try:
3657 self.enterOuterAlt(localctx, 1)
3658 self.state = 572
3659 self.match(Python3Parser.NAME)
3660 self.state = 577
3661 self._errHandler.sync(self)
3662 _la = self._input.LA(1)
3663 while _la==Python3Parser.DOT:
3664 self.state = 573
3665 self.match(Python3Parser.DOT)
3666 self.state = 574
3667 self.match(Python3Parser.NAME)
3668 self.state = 579
3669 self._errHandler.sync(self)
3670 _la = self._input.LA(1)
3672 except RecognitionException as re:
3673 localctx.exception = re
3674 self._errHandler.reportError(self, re)
3675 self._errHandler.recover(self, re)
3676 finally:
3677 self.exitRule()
3678 return localctx
3681 class Global_stmtContext(ParserRuleContext):
3683 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3684 super().__init__(parent, invokingState)
3685 self.parser = parser
3687 def GLOBAL(self):
3688 return self.getToken(Python3Parser.GLOBAL, 0)
3690 def NAME(self, i:int=None):
3691 if i is None:
3692 return self.getTokens(Python3Parser.NAME)
3693 else:
3694 return self.getToken(Python3Parser.NAME, i)
3696 def COMMA(self, i:int=None):
3697 if i is None:
3698 return self.getTokens(Python3Parser.COMMA)
3699 else:
3700 return self.getToken(Python3Parser.COMMA, i)
3702 def getRuleIndex(self):
3703 return Python3Parser.RULE_global_stmt
3705 def enterRule(self, listener:ParseTreeListener):
3706 if hasattr( listener, "enterGlobal_stmt" ):
3707 listener.enterGlobal_stmt(self)
3709 def exitRule(self, listener:ParseTreeListener):
3710 if hasattr( listener, "exitGlobal_stmt" ):
3711 listener.exitGlobal_stmt(self)
3716 def global_stmt(self):
3718 localctx = Python3Parser.Global_stmtContext(self, self._ctx, self.state)
3719 self.enterRule(localctx, 72, self.RULE_global_stmt)
3720 self._la = 0 # Token type
3721 try:
3722 self.enterOuterAlt(localctx, 1)
3723 self.state = 580
3724 self.match(Python3Parser.GLOBAL)
3725 self.state = 581
3726 self.match(Python3Parser.NAME)
3727 self.state = 586
3728 self._errHandler.sync(self)
3729 _la = self._input.LA(1)
3730 while _la==Python3Parser.COMMA:
3731 self.state = 582
3732 self.match(Python3Parser.COMMA)
3733 self.state = 583
3734 self.match(Python3Parser.NAME)
3735 self.state = 588
3736 self._errHandler.sync(self)
3737 _la = self._input.LA(1)
3739 except RecognitionException as re:
3740 localctx.exception = re
3741 self._errHandler.reportError(self, re)
3742 self._errHandler.recover(self, re)
3743 finally:
3744 self.exitRule()
3745 return localctx
3748 class Nonlocal_stmtContext(ParserRuleContext):
3750 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3751 super().__init__(parent, invokingState)
3752 self.parser = parser
3754 def NONLOCAL(self):
3755 return self.getToken(Python3Parser.NONLOCAL, 0)
3757 def NAME(self, i:int=None):
3758 if i is None:
3759 return self.getTokens(Python3Parser.NAME)
3760 else:
3761 return self.getToken(Python3Parser.NAME, i)
3763 def COMMA(self, i:int=None):
3764 if i is None:
3765 return self.getTokens(Python3Parser.COMMA)
3766 else:
3767 return self.getToken(Python3Parser.COMMA, i)
3769 def getRuleIndex(self):
3770 return Python3Parser.RULE_nonlocal_stmt
3772 def enterRule(self, listener:ParseTreeListener):
3773 if hasattr( listener, "enterNonlocal_stmt" ):
3774 listener.enterNonlocal_stmt(self)
3776 def exitRule(self, listener:ParseTreeListener):
3777 if hasattr( listener, "exitNonlocal_stmt" ):
3778 listener.exitNonlocal_stmt(self)
3783 def nonlocal_stmt(self):
3785 localctx = Python3Parser.Nonlocal_stmtContext(self, self._ctx, self.state)
3786 self.enterRule(localctx, 74, self.RULE_nonlocal_stmt)
3787 self._la = 0 # Token type
3788 try:
3789 self.enterOuterAlt(localctx, 1)
3790 self.state = 589
3791 self.match(Python3Parser.NONLOCAL)
3792 self.state = 590
3793 self.match(Python3Parser.NAME)
3794 self.state = 595
3795 self._errHandler.sync(self)
3796 _la = self._input.LA(1)
3797 while _la==Python3Parser.COMMA:
3798 self.state = 591
3799 self.match(Python3Parser.COMMA)
3800 self.state = 592
3801 self.match(Python3Parser.NAME)
3802 self.state = 597
3803 self._errHandler.sync(self)
3804 _la = self._input.LA(1)
3806 except RecognitionException as re:
3807 localctx.exception = re
3808 self._errHandler.reportError(self, re)
3809 self._errHandler.recover(self, re)
3810 finally:
3811 self.exitRule()
3812 return localctx
3815 class Assert_stmtContext(ParserRuleContext):
3817 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3818 super().__init__(parent, invokingState)
3819 self.parser = parser
3821 def ASSERT(self):
3822 return self.getToken(Python3Parser.ASSERT, 0)
3824 def test(self, i:int=None):
3825 if i is None:
3826 return self.getTypedRuleContexts(Python3Parser.TestContext)
3827 else:
3828 return self.getTypedRuleContext(Python3Parser.TestContext,i)
3831 def COMMA(self):
3832 return self.getToken(Python3Parser.COMMA, 0)
3834 def getRuleIndex(self):
3835 return Python3Parser.RULE_assert_stmt
3837 def enterRule(self, listener:ParseTreeListener):
3838 if hasattr( listener, "enterAssert_stmt" ):
3839 listener.enterAssert_stmt(self)
3841 def exitRule(self, listener:ParseTreeListener):
3842 if hasattr( listener, "exitAssert_stmt" ):
3843 listener.exitAssert_stmt(self)
3848 def assert_stmt(self):
3850 localctx = Python3Parser.Assert_stmtContext(self, self._ctx, self.state)
3851 self.enterRule(localctx, 76, self.RULE_assert_stmt)
3852 self._la = 0 # Token type
3853 try:
3854 self.enterOuterAlt(localctx, 1)
3855 self.state = 598
3856 self.match(Python3Parser.ASSERT)
3857 self.state = 599
3858 self.test()
3859 self.state = 602
3860 self._errHandler.sync(self)
3861 _la = self._input.LA(1)
3862 if _la==Python3Parser.COMMA:
3863 self.state = 600
3864 self.match(Python3Parser.COMMA)
3865 self.state = 601
3866 self.test()
3869 except RecognitionException as re:
3870 localctx.exception = re
3871 self._errHandler.reportError(self, re)
3872 self._errHandler.recover(self, re)
3873 finally:
3874 self.exitRule()
3875 return localctx
3878 class Compound_stmtContext(ParserRuleContext):
3880 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
3881 super().__init__(parent, invokingState)
3882 self.parser = parser
3884 def if_stmt(self):
3885 return self.getTypedRuleContext(Python3Parser.If_stmtContext,0)
3888 def while_stmt(self):
3889 return self.getTypedRuleContext(Python3Parser.While_stmtContext,0)
3892 def for_stmt(self):
3893 return self.getTypedRuleContext(Python3Parser.For_stmtContext,0)
3896 def try_stmt(self):
3897 return self.getTypedRuleContext(Python3Parser.Try_stmtContext,0)
3900 def with_stmt(self):
3901 return self.getTypedRuleContext(Python3Parser.With_stmtContext,0)
3904 def funcdef(self):
3905 return self.getTypedRuleContext(Python3Parser.FuncdefContext,0)
3908 def classdef(self):
3909 return self.getTypedRuleContext(Python3Parser.ClassdefContext,0)
3912 def decorated(self):
3913 return self.getTypedRuleContext(Python3Parser.DecoratedContext,0)
3916 def async_stmt(self):
3917 return self.getTypedRuleContext(Python3Parser.Async_stmtContext,0)
3920 def getRuleIndex(self):
3921 return Python3Parser.RULE_compound_stmt
3923 def enterRule(self, listener:ParseTreeListener):
3924 if hasattr( listener, "enterCompound_stmt" ):
3925 listener.enterCompound_stmt(self)
3927 def exitRule(self, listener:ParseTreeListener):
3928 if hasattr( listener, "exitCompound_stmt" ):
3929 listener.exitCompound_stmt(self)
3934 def compound_stmt(self):
3936 localctx = Python3Parser.Compound_stmtContext(self, self._ctx, self.state)
3937 self.enterRule(localctx, 78, self.RULE_compound_stmt)
3938 try:
3939 self.state = 613
3940 self._errHandler.sync(self)
3941 token = self._input.LA(1)
3942 if token in [Python3Parser.IF]:
3943 self.enterOuterAlt(localctx, 1)
3944 self.state = 604
3945 self.if_stmt()
3946 pass
3947 elif token in [Python3Parser.WHILE]:
3948 self.enterOuterAlt(localctx, 2)
3949 self.state = 605
3950 self.while_stmt()
3951 pass
3952 elif token in [Python3Parser.FOR]:
3953 self.enterOuterAlt(localctx, 3)
3954 self.state = 606
3955 self.for_stmt()
3956 pass
3957 elif token in [Python3Parser.TRY]:
3958 self.enterOuterAlt(localctx, 4)
3959 self.state = 607
3960 self.try_stmt()
3961 pass
3962 elif token in [Python3Parser.WITH]:
3963 self.enterOuterAlt(localctx, 5)
3964 self.state = 608
3965 self.with_stmt()
3966 pass
3967 elif token in [Python3Parser.DEF]:
3968 self.enterOuterAlt(localctx, 6)
3969 self.state = 609
3970 self.funcdef()
3971 pass
3972 elif token in [Python3Parser.CLASS]:
3973 self.enterOuterAlt(localctx, 7)
3974 self.state = 610
3975 self.classdef()
3976 pass
3977 elif token in [Python3Parser.AT]:
3978 self.enterOuterAlt(localctx, 8)
3979 self.state = 611
3980 self.decorated()
3981 pass
3982 elif token in [Python3Parser.ASYNC]:
3983 self.enterOuterAlt(localctx, 9)
3984 self.state = 612
3985 self.async_stmt()
3986 pass
3987 else:
3988 raise NoViableAltException(self)
3990 except RecognitionException as re:
3991 localctx.exception = re
3992 self._errHandler.reportError(self, re)
3993 self._errHandler.recover(self, re)
3994 finally:
3995 self.exitRule()
3996 return localctx
3999 class Async_stmtContext(ParserRuleContext):
4001 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4002 super().__init__(parent, invokingState)
4003 self.parser = parser
4005 def ASYNC(self):
4006 return self.getToken(Python3Parser.ASYNC, 0)
4008 def funcdef(self):
4009 return self.getTypedRuleContext(Python3Parser.FuncdefContext,0)
4012 def with_stmt(self):
4013 return self.getTypedRuleContext(Python3Parser.With_stmtContext,0)
4016 def for_stmt(self):
4017 return self.getTypedRuleContext(Python3Parser.For_stmtContext,0)
4020 def getRuleIndex(self):
4021 return Python3Parser.RULE_async_stmt
4023 def enterRule(self, listener:ParseTreeListener):
4024 if hasattr( listener, "enterAsync_stmt" ):
4025 listener.enterAsync_stmt(self)
4027 def exitRule(self, listener:ParseTreeListener):
4028 if hasattr( listener, "exitAsync_stmt" ):
4029 listener.exitAsync_stmt(self)
4034 def async_stmt(self):
4036 localctx = Python3Parser.Async_stmtContext(self, self._ctx, self.state)
4037 self.enterRule(localctx, 80, self.RULE_async_stmt)
4038 try:
4039 self.enterOuterAlt(localctx, 1)
4040 self.state = 615
4041 self.match(Python3Parser.ASYNC)
4042 self.state = 619
4043 self._errHandler.sync(self)
4044 token = self._input.LA(1)
4045 if token in [Python3Parser.DEF]:
4046 self.state = 616
4047 self.funcdef()
4048 pass
4049 elif token in [Python3Parser.WITH]:
4050 self.state = 617
4051 self.with_stmt()
4052 pass
4053 elif token in [Python3Parser.FOR]:
4054 self.state = 618
4055 self.for_stmt()
4056 pass
4057 else:
4058 raise NoViableAltException(self)
4060 except RecognitionException as re:
4061 localctx.exception = re
4062 self._errHandler.reportError(self, re)
4063 self._errHandler.recover(self, re)
4064 finally:
4065 self.exitRule()
4066 return localctx
4069 class If_stmtContext(ParserRuleContext):
4071 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4072 super().__init__(parent, invokingState)
4073 self.parser = parser
4075 def IF(self):
4076 return self.getToken(Python3Parser.IF, 0)
4078 def test(self, i:int=None):
4079 if i is None:
4080 return self.getTypedRuleContexts(Python3Parser.TestContext)
4081 else:
4082 return self.getTypedRuleContext(Python3Parser.TestContext,i)
4085 def COLON(self, i:int=None):
4086 if i is None:
4087 return self.getTokens(Python3Parser.COLON)
4088 else:
4089 return self.getToken(Python3Parser.COLON, i)
4091 def suite(self, i:int=None):
4092 if i is None:
4093 return self.getTypedRuleContexts(Python3Parser.SuiteContext)
4094 else:
4095 return self.getTypedRuleContext(Python3Parser.SuiteContext,i)
4098 def ELIF(self, i:int=None):
4099 if i is None:
4100 return self.getTokens(Python3Parser.ELIF)
4101 else:
4102 return self.getToken(Python3Parser.ELIF, i)
4104 def ELSE(self):
4105 return self.getToken(Python3Parser.ELSE, 0)
4107 def getRuleIndex(self):
4108 return Python3Parser.RULE_if_stmt
4110 def enterRule(self, listener:ParseTreeListener):
4111 if hasattr( listener, "enterIf_stmt" ):
4112 listener.enterIf_stmt(self)
4114 def exitRule(self, listener:ParseTreeListener):
4115 if hasattr( listener, "exitIf_stmt" ):
4116 listener.exitIf_stmt(self)
4121 def if_stmt(self):
4123 localctx = Python3Parser.If_stmtContext(self, self._ctx, self.state)
4124 self.enterRule(localctx, 82, self.RULE_if_stmt)
4125 self._la = 0 # Token type
4126 try:
4127 self.enterOuterAlt(localctx, 1)
4128 self.state = 621
4129 self.match(Python3Parser.IF)
4130 self.state = 622
4131 self.test()
4132 self.state = 623
4133 self.match(Python3Parser.COLON)
4134 self.state = 624
4135 self.suite()
4136 self.state = 632
4137 self._errHandler.sync(self)
4138 _la = self._input.LA(1)
4139 while _la==Python3Parser.ELIF:
4140 self.state = 625
4141 self.match(Python3Parser.ELIF)
4142 self.state = 626
4143 self.test()
4144 self.state = 627
4145 self.match(Python3Parser.COLON)
4146 self.state = 628
4147 self.suite()
4148 self.state = 634
4149 self._errHandler.sync(self)
4150 _la = self._input.LA(1)
4152 self.state = 638
4153 self._errHandler.sync(self)
4154 _la = self._input.LA(1)
4155 if _la==Python3Parser.ELSE:
4156 self.state = 635
4157 self.match(Python3Parser.ELSE)
4158 self.state = 636
4159 self.match(Python3Parser.COLON)
4160 self.state = 637
4161 self.suite()
4164 except RecognitionException as re:
4165 localctx.exception = re
4166 self._errHandler.reportError(self, re)
4167 self._errHandler.recover(self, re)
4168 finally:
4169 self.exitRule()
4170 return localctx
4173 class While_stmtContext(ParserRuleContext):
4175 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4176 super().__init__(parent, invokingState)
4177 self.parser = parser
4179 def WHILE(self):
4180 return self.getToken(Python3Parser.WHILE, 0)
4182 def test(self):
4183 return self.getTypedRuleContext(Python3Parser.TestContext,0)
4186 def COLON(self, i:int=None):
4187 if i is None:
4188 return self.getTokens(Python3Parser.COLON)
4189 else:
4190 return self.getToken(Python3Parser.COLON, i)
4192 def suite(self, i:int=None):
4193 if i is None:
4194 return self.getTypedRuleContexts(Python3Parser.SuiteContext)
4195 else:
4196 return self.getTypedRuleContext(Python3Parser.SuiteContext,i)
4199 def ELSE(self):
4200 return self.getToken(Python3Parser.ELSE, 0)
4202 def getRuleIndex(self):
4203 return Python3Parser.RULE_while_stmt
4205 def enterRule(self, listener:ParseTreeListener):
4206 if hasattr( listener, "enterWhile_stmt" ):
4207 listener.enterWhile_stmt(self)
4209 def exitRule(self, listener:ParseTreeListener):
4210 if hasattr( listener, "exitWhile_stmt" ):
4211 listener.exitWhile_stmt(self)
4216 def while_stmt(self):
4218 localctx = Python3Parser.While_stmtContext(self, self._ctx, self.state)
4219 self.enterRule(localctx, 84, self.RULE_while_stmt)
4220 self._la = 0 # Token type
4221 try:
4222 self.enterOuterAlt(localctx, 1)
4223 self.state = 640
4224 self.match(Python3Parser.WHILE)
4225 self.state = 641
4226 self.test()
4227 self.state = 642
4228 self.match(Python3Parser.COLON)
4229 self.state = 643
4230 self.suite()
4231 self.state = 647
4232 self._errHandler.sync(self)
4233 _la = self._input.LA(1)
4234 if _la==Python3Parser.ELSE:
4235 self.state = 644
4236 self.match(Python3Parser.ELSE)
4237 self.state = 645
4238 self.match(Python3Parser.COLON)
4239 self.state = 646
4240 self.suite()
4243 except RecognitionException as re:
4244 localctx.exception = re
4245 self._errHandler.reportError(self, re)
4246 self._errHandler.recover(self, re)
4247 finally:
4248 self.exitRule()
4249 return localctx
4252 class For_stmtContext(ParserRuleContext):
4254 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4255 super().__init__(parent, invokingState)
4256 self.parser = parser
4258 def FOR(self):
4259 return self.getToken(Python3Parser.FOR, 0)
4261 def exprlist(self):
4262 return self.getTypedRuleContext(Python3Parser.ExprlistContext,0)
4265 def IN(self):
4266 return self.getToken(Python3Parser.IN, 0)
4268 def testlist(self):
4269 return self.getTypedRuleContext(Python3Parser.TestlistContext,0)
4272 def COLON(self, i:int=None):
4273 if i is None:
4274 return self.getTokens(Python3Parser.COLON)
4275 else:
4276 return self.getToken(Python3Parser.COLON, i)
4278 def suite(self, i:int=None):
4279 if i is None:
4280 return self.getTypedRuleContexts(Python3Parser.SuiteContext)
4281 else:
4282 return self.getTypedRuleContext(Python3Parser.SuiteContext,i)
4285 def ELSE(self):
4286 return self.getToken(Python3Parser.ELSE, 0)
4288 def getRuleIndex(self):
4289 return Python3Parser.RULE_for_stmt
4291 def enterRule(self, listener:ParseTreeListener):
4292 if hasattr( listener, "enterFor_stmt" ):
4293 listener.enterFor_stmt(self)
4295 def exitRule(self, listener:ParseTreeListener):
4296 if hasattr( listener, "exitFor_stmt" ):
4297 listener.exitFor_stmt(self)
4302 def for_stmt(self):
4304 localctx = Python3Parser.For_stmtContext(self, self._ctx, self.state)
4305 self.enterRule(localctx, 86, self.RULE_for_stmt)
4306 self._la = 0 # Token type
4307 try:
4308 self.enterOuterAlt(localctx, 1)
4309 self.state = 649
4310 self.match(Python3Parser.FOR)
4311 self.state = 650
4312 self.exprlist()
4313 self.state = 651
4314 self.match(Python3Parser.IN)
4315 self.state = 652
4316 self.testlist()
4317 self.state = 653
4318 self.match(Python3Parser.COLON)
4319 self.state = 654
4320 self.suite()
4321 self.state = 658
4322 self._errHandler.sync(self)
4323 _la = self._input.LA(1)
4324 if _la==Python3Parser.ELSE:
4325 self.state = 655
4326 self.match(Python3Parser.ELSE)
4327 self.state = 656
4328 self.match(Python3Parser.COLON)
4329 self.state = 657
4330 self.suite()
4333 except RecognitionException as re:
4334 localctx.exception = re
4335 self._errHandler.reportError(self, re)
4336 self._errHandler.recover(self, re)
4337 finally:
4338 self.exitRule()
4339 return localctx
4342 class Try_stmtContext(ParserRuleContext):
4344 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4345 super().__init__(parent, invokingState)
4346 self.parser = parser
4348 def TRY(self):
4349 return self.getToken(Python3Parser.TRY, 0)
4351 def COLON(self, i:int=None):
4352 if i is None:
4353 return self.getTokens(Python3Parser.COLON)
4354 else:
4355 return self.getToken(Python3Parser.COLON, i)
4357 def suite(self, i:int=None):
4358 if i is None:
4359 return self.getTypedRuleContexts(Python3Parser.SuiteContext)
4360 else:
4361 return self.getTypedRuleContext(Python3Parser.SuiteContext,i)
4364 def FINALLY(self):
4365 return self.getToken(Python3Parser.FINALLY, 0)
4367 def except_clause(self, i:int=None):
4368 if i is None:
4369 return self.getTypedRuleContexts(Python3Parser.Except_clauseContext)
4370 else:
4371 return self.getTypedRuleContext(Python3Parser.Except_clauseContext,i)
4374 def ELSE(self):
4375 return self.getToken(Python3Parser.ELSE, 0)
4377 def getRuleIndex(self):
4378 return Python3Parser.RULE_try_stmt
4380 def enterRule(self, listener:ParseTreeListener):
4381 if hasattr( listener, "enterTry_stmt" ):
4382 listener.enterTry_stmt(self)
4384 def exitRule(self, listener:ParseTreeListener):
4385 if hasattr( listener, "exitTry_stmt" ):
4386 listener.exitTry_stmt(self)
4391 def try_stmt(self):
4393 localctx = Python3Parser.Try_stmtContext(self, self._ctx, self.state)
4394 self.enterRule(localctx, 88, self.RULE_try_stmt)
4395 self._la = 0 # Token type
4396 try:
4397 self.enterOuterAlt(localctx, 1)
4398 self.state = 660
4399 self.match(Python3Parser.TRY)
4400 self.state = 661
4401 self.match(Python3Parser.COLON)
4402 self.state = 662
4403 self.suite()
4404 self.state = 684
4405 self._errHandler.sync(self)
4406 token = self._input.LA(1)
4407 if token in [Python3Parser.EXCEPT]:
4408 self.state = 667
4409 self._errHandler.sync(self)
4410 _la = self._input.LA(1)
4411 while True:
4412 self.state = 663
4413 self.except_clause()
4414 self.state = 664
4415 self.match(Python3Parser.COLON)
4416 self.state = 665
4417 self.suite()
4418 self.state = 669
4419 self._errHandler.sync(self)
4420 _la = self._input.LA(1)
4421 if not (_la==Python3Parser.EXCEPT):
4422 break
4424 self.state = 674
4425 self._errHandler.sync(self)
4426 _la = self._input.LA(1)
4427 if _la==Python3Parser.ELSE:
4428 self.state = 671
4429 self.match(Python3Parser.ELSE)
4430 self.state = 672
4431 self.match(Python3Parser.COLON)
4432 self.state = 673
4433 self.suite()
4436 self.state = 679
4437 self._errHandler.sync(self)
4438 _la = self._input.LA(1)
4439 if _la==Python3Parser.FINALLY:
4440 self.state = 676
4441 self.match(Python3Parser.FINALLY)
4442 self.state = 677
4443 self.match(Python3Parser.COLON)
4444 self.state = 678
4445 self.suite()
4448 pass
4449 elif token in [Python3Parser.FINALLY]:
4450 self.state = 681
4451 self.match(Python3Parser.FINALLY)
4452 self.state = 682
4453 self.match(Python3Parser.COLON)
4454 self.state = 683
4455 self.suite()
4456 pass
4457 else:
4458 raise NoViableAltException(self)
4460 except RecognitionException as re:
4461 localctx.exception = re
4462 self._errHandler.reportError(self, re)
4463 self._errHandler.recover(self, re)
4464 finally:
4465 self.exitRule()
4466 return localctx
4469 class With_stmtContext(ParserRuleContext):
4471 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4472 super().__init__(parent, invokingState)
4473 self.parser = parser
4475 def WITH(self):
4476 return self.getToken(Python3Parser.WITH, 0)
4478 def with_item(self, i:int=None):
4479 if i is None:
4480 return self.getTypedRuleContexts(Python3Parser.With_itemContext)
4481 else:
4482 return self.getTypedRuleContext(Python3Parser.With_itemContext,i)
4485 def COLON(self):
4486 return self.getToken(Python3Parser.COLON, 0)
4488 def suite(self):
4489 return self.getTypedRuleContext(Python3Parser.SuiteContext,0)
4492 def COMMA(self, i:int=None):
4493 if i is None:
4494 return self.getTokens(Python3Parser.COMMA)
4495 else:
4496 return self.getToken(Python3Parser.COMMA, i)
4498 def getRuleIndex(self):
4499 return Python3Parser.RULE_with_stmt
4501 def enterRule(self, listener:ParseTreeListener):
4502 if hasattr( listener, "enterWith_stmt" ):
4503 listener.enterWith_stmt(self)
4505 def exitRule(self, listener:ParseTreeListener):
4506 if hasattr( listener, "exitWith_stmt" ):
4507 listener.exitWith_stmt(self)
4512 def with_stmt(self):
4514 localctx = Python3Parser.With_stmtContext(self, self._ctx, self.state)
4515 self.enterRule(localctx, 90, self.RULE_with_stmt)
4516 self._la = 0 # Token type
4517 try:
4518 self.enterOuterAlt(localctx, 1)
4519 self.state = 686
4520 self.match(Python3Parser.WITH)
4521 self.state = 687
4522 self.with_item()
4523 self.state = 692
4524 self._errHandler.sync(self)
4525 _la = self._input.LA(1)
4526 while _la==Python3Parser.COMMA:
4527 self.state = 688
4528 self.match(Python3Parser.COMMA)
4529 self.state = 689
4530 self.with_item()
4531 self.state = 694
4532 self._errHandler.sync(self)
4533 _la = self._input.LA(1)
4535 self.state = 695
4536 self.match(Python3Parser.COLON)
4537 self.state = 696
4538 self.suite()
4539 except RecognitionException as re:
4540 localctx.exception = re
4541 self._errHandler.reportError(self, re)
4542 self._errHandler.recover(self, re)
4543 finally:
4544 self.exitRule()
4545 return localctx
4548 class With_itemContext(ParserRuleContext):
4550 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4551 super().__init__(parent, invokingState)
4552 self.parser = parser
4554 def test(self):
4555 return self.getTypedRuleContext(Python3Parser.TestContext,0)
4558 def AS(self):
4559 return self.getToken(Python3Parser.AS, 0)
4561 def expr(self):
4562 return self.getTypedRuleContext(Python3Parser.ExprContext,0)
4565 def getRuleIndex(self):
4566 return Python3Parser.RULE_with_item
4568 def enterRule(self, listener:ParseTreeListener):
4569 if hasattr( listener, "enterWith_item" ):
4570 listener.enterWith_item(self)
4572 def exitRule(self, listener:ParseTreeListener):
4573 if hasattr( listener, "exitWith_item" ):
4574 listener.exitWith_item(self)
4579 def with_item(self):
4581 localctx = Python3Parser.With_itemContext(self, self._ctx, self.state)
4582 self.enterRule(localctx, 92, self.RULE_with_item)
4583 self._la = 0 # Token type
4584 try:
4585 self.enterOuterAlt(localctx, 1)
4586 self.state = 698
4587 self.test()
4588 self.state = 701
4589 self._errHandler.sync(self)
4590 _la = self._input.LA(1)
4591 if _la==Python3Parser.AS:
4592 self.state = 699
4593 self.match(Python3Parser.AS)
4594 self.state = 700
4595 self.expr()
4598 except RecognitionException as re:
4599 localctx.exception = re
4600 self._errHandler.reportError(self, re)
4601 self._errHandler.recover(self, re)
4602 finally:
4603 self.exitRule()
4604 return localctx
4607 class Except_clauseContext(ParserRuleContext):
4609 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4610 super().__init__(parent, invokingState)
4611 self.parser = parser
4613 def EXCEPT(self):
4614 return self.getToken(Python3Parser.EXCEPT, 0)
4616 def test(self):
4617 return self.getTypedRuleContext(Python3Parser.TestContext,0)
4620 def AS(self):
4621 return self.getToken(Python3Parser.AS, 0)
4623 def NAME(self):
4624 return self.getToken(Python3Parser.NAME, 0)
4626 def getRuleIndex(self):
4627 return Python3Parser.RULE_except_clause
4629 def enterRule(self, listener:ParseTreeListener):
4630 if hasattr( listener, "enterExcept_clause" ):
4631 listener.enterExcept_clause(self)
4633 def exitRule(self, listener:ParseTreeListener):
4634 if hasattr( listener, "exitExcept_clause" ):
4635 listener.exitExcept_clause(self)
4640 def except_clause(self):
4642 localctx = Python3Parser.Except_clauseContext(self, self._ctx, self.state)
4643 self.enterRule(localctx, 94, self.RULE_except_clause)
4644 self._la = 0 # Token type
4645 try:
4646 self.enterOuterAlt(localctx, 1)
4647 self.state = 703
4648 self.match(Python3Parser.EXCEPT)
4649 self.state = 709
4650 self._errHandler.sync(self)
4651 _la = self._input.LA(1)
4652 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):
4653 self.state = 704
4654 self.test()
4655 self.state = 707
4656 self._errHandler.sync(self)
4657 _la = self._input.LA(1)
4658 if _la==Python3Parser.AS:
4659 self.state = 705
4660 self.match(Python3Parser.AS)
4661 self.state = 706
4662 self.match(Python3Parser.NAME)
4667 except RecognitionException as re:
4668 localctx.exception = re
4669 self._errHandler.reportError(self, re)
4670 self._errHandler.recover(self, re)
4671 finally:
4672 self.exitRule()
4673 return localctx
4676 class SuiteContext(ParserRuleContext):
4678 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4679 super().__init__(parent, invokingState)
4680 self.parser = parser
4682 def simple_stmt(self):
4683 return self.getTypedRuleContext(Python3Parser.Simple_stmtContext,0)
4686 def NEWLINE(self):
4687 return self.getToken(Python3Parser.NEWLINE, 0)
4689 def INDENT(self):
4690 return self.getToken(Python3Parser.INDENT, 0)
4692 def DEDENT(self):
4693 return self.getToken(Python3Parser.DEDENT, 0)
4695 def stmt(self, i:int=None):
4696 if i is None:
4697 return self.getTypedRuleContexts(Python3Parser.StmtContext)
4698 else:
4699 return self.getTypedRuleContext(Python3Parser.StmtContext,i)
4702 def getRuleIndex(self):
4703 return Python3Parser.RULE_suite
4705 def enterRule(self, listener:ParseTreeListener):
4706 if hasattr( listener, "enterSuite" ):
4707 listener.enterSuite(self)
4709 def exitRule(self, listener:ParseTreeListener):
4710 if hasattr( listener, "exitSuite" ):
4711 listener.exitSuite(self)
4716 def suite(self):
4718 localctx = Python3Parser.SuiteContext(self, self._ctx, self.state)
4719 self.enterRule(localctx, 96, self.RULE_suite)
4720 self._la = 0 # Token type
4721 try:
4722 self.state = 721
4723 self._errHandler.sync(self)
4724 token = self._input.LA(1)
4725 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]:
4726 self.enterOuterAlt(localctx, 1)
4727 self.state = 711
4728 self.simple_stmt()
4729 pass
4730 elif token in [Python3Parser.NEWLINE]:
4731 self.enterOuterAlt(localctx, 2)
4732 self.state = 712
4733 self.match(Python3Parser.NEWLINE)
4734 self.state = 713
4735 self.match(Python3Parser.INDENT)
4736 self.state = 715
4737 self._errHandler.sync(self)
4738 _la = self._input.LA(1)
4739 while True:
4740 self.state = 714
4741 self.stmt()
4742 self.state = 717
4743 self._errHandler.sync(self)
4744 _la = self._input.LA(1)
4745 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)):
4746 break
4748 self.state = 719
4749 self.match(Python3Parser.DEDENT)
4750 pass
4751 else:
4752 raise NoViableAltException(self)
4754 except RecognitionException as re:
4755 localctx.exception = re
4756 self._errHandler.reportError(self, re)
4757 self._errHandler.recover(self, re)
4758 finally:
4759 self.exitRule()
4760 return localctx
4763 class TestContext(ParserRuleContext):
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, i:int=None):
4770 if i is None:
4771 return self.getTypedRuleContexts(Python3Parser.Or_testContext)
4772 else:
4773 return self.getTypedRuleContext(Python3Parser.Or_testContext,i)
4776 def IF(self):
4777 return self.getToken(Python3Parser.IF, 0)
4779 def ELSE(self):
4780 return self.getToken(Python3Parser.ELSE, 0)
4782 def test(self):
4783 return self.getTypedRuleContext(Python3Parser.TestContext,0)
4786 def lambdef(self):
4787 return self.getTypedRuleContext(Python3Parser.LambdefContext,0)
4790 def getRuleIndex(self):
4791 return Python3Parser.RULE_test
4793 def enterRule(self, listener:ParseTreeListener):
4794 if hasattr( listener, "enterTest" ):
4795 listener.enterTest(self)
4797 def exitRule(self, listener:ParseTreeListener):
4798 if hasattr( listener, "exitTest" ):
4799 listener.exitTest(self)
4804 def test(self):
4806 localctx = Python3Parser.TestContext(self, self._ctx, self.state)
4807 self.enterRule(localctx, 98, self.RULE_test)
4808 self._la = 0 # Token type
4809 try:
4810 self.state = 732
4811 self._errHandler.sync(self)
4812 token = self._input.LA(1)
4813 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]:
4814 self.enterOuterAlt(localctx, 1)
4815 self.state = 723
4816 self.or_test()
4817 self.state = 729
4818 self._errHandler.sync(self)
4819 _la = self._input.LA(1)
4820 if _la==Python3Parser.IF:
4821 self.state = 724
4822 self.match(Python3Parser.IF)
4823 self.state = 725
4824 self.or_test()
4825 self.state = 726
4826 self.match(Python3Parser.ELSE)
4827 self.state = 727
4828 self.test()
4831 pass
4832 elif token in [Python3Parser.LAMBDA]:
4833 self.enterOuterAlt(localctx, 2)
4834 self.state = 731
4835 self.lambdef()
4836 pass
4837 else:
4838 raise NoViableAltException(self)
4840 except RecognitionException as re:
4841 localctx.exception = re
4842 self._errHandler.reportError(self, re)
4843 self._errHandler.recover(self, re)
4844 finally:
4845 self.exitRule()
4846 return localctx
4849 class Test_nocondContext(ParserRuleContext):
4851 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4852 super().__init__(parent, invokingState)
4853 self.parser = parser
4855 def or_test(self):
4856 return self.getTypedRuleContext(Python3Parser.Or_testContext,0)
4859 def lambdef_nocond(self):
4860 return self.getTypedRuleContext(Python3Parser.Lambdef_nocondContext,0)
4863 def getRuleIndex(self):
4864 return Python3Parser.RULE_test_nocond
4866 def enterRule(self, listener:ParseTreeListener):
4867 if hasattr( listener, "enterTest_nocond" ):
4868 listener.enterTest_nocond(self)
4870 def exitRule(self, listener:ParseTreeListener):
4871 if hasattr( listener, "exitTest_nocond" ):
4872 listener.exitTest_nocond(self)
4877 def test_nocond(self):
4879 localctx = Python3Parser.Test_nocondContext(self, self._ctx, self.state)
4880 self.enterRule(localctx, 100, self.RULE_test_nocond)
4881 try:
4882 self.state = 736
4883 self._errHandler.sync(self)
4884 token = self._input.LA(1)
4885 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]:
4886 self.enterOuterAlt(localctx, 1)
4887 self.state = 734
4888 self.or_test()
4889 pass
4890 elif token in [Python3Parser.LAMBDA]:
4891 self.enterOuterAlt(localctx, 2)
4892 self.state = 735
4893 self.lambdef_nocond()
4894 pass
4895 else:
4896 raise NoViableAltException(self)
4898 except RecognitionException as re:
4899 localctx.exception = re
4900 self._errHandler.reportError(self, re)
4901 self._errHandler.recover(self, re)
4902 finally:
4903 self.exitRule()
4904 return localctx
4907 class LambdefContext(ParserRuleContext):
4909 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4910 super().__init__(parent, invokingState)
4911 self.parser = parser
4913 def LAMBDA(self):
4914 return self.getToken(Python3Parser.LAMBDA, 0)
4916 def COLON(self):
4917 return self.getToken(Python3Parser.COLON, 0)
4919 def test(self):
4920 return self.getTypedRuleContext(Python3Parser.TestContext,0)
4923 def varargslist(self):
4924 return self.getTypedRuleContext(Python3Parser.VarargslistContext,0)
4927 def getRuleIndex(self):
4928 return Python3Parser.RULE_lambdef
4930 def enterRule(self, listener:ParseTreeListener):
4931 if hasattr( listener, "enterLambdef" ):
4932 listener.enterLambdef(self)
4934 def exitRule(self, listener:ParseTreeListener):
4935 if hasattr( listener, "exitLambdef" ):
4936 listener.exitLambdef(self)
4941 def lambdef(self):
4943 localctx = Python3Parser.LambdefContext(self, self._ctx, self.state)
4944 self.enterRule(localctx, 102, self.RULE_lambdef)
4945 self._la = 0 # Token type
4946 try:
4947 self.enterOuterAlt(localctx, 1)
4948 self.state = 738
4949 self.match(Python3Parser.LAMBDA)
4950 self.state = 740
4951 self._errHandler.sync(self)
4952 _la = self._input.LA(1)
4953 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.NAME) | (1 << Python3Parser.STAR) | (1 << Python3Parser.POWER))) != 0):
4954 self.state = 739
4955 self.varargslist()
4958 self.state = 742
4959 self.match(Python3Parser.COLON)
4960 self.state = 743
4961 self.test()
4962 except RecognitionException as re:
4963 localctx.exception = re
4964 self._errHandler.reportError(self, re)
4965 self._errHandler.recover(self, re)
4966 finally:
4967 self.exitRule()
4968 return localctx
4971 class Lambdef_nocondContext(ParserRuleContext):
4973 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
4974 super().__init__(parent, invokingState)
4975 self.parser = parser
4977 def LAMBDA(self):
4978 return self.getToken(Python3Parser.LAMBDA, 0)
4980 def COLON(self):
4981 return self.getToken(Python3Parser.COLON, 0)
4983 def test_nocond(self):
4984 return self.getTypedRuleContext(Python3Parser.Test_nocondContext,0)
4987 def varargslist(self):
4988 return self.getTypedRuleContext(Python3Parser.VarargslistContext,0)
4991 def getRuleIndex(self):
4992 return Python3Parser.RULE_lambdef_nocond
4994 def enterRule(self, listener:ParseTreeListener):
4995 if hasattr( listener, "enterLambdef_nocond" ):
4996 listener.enterLambdef_nocond(self)
4998 def exitRule(self, listener:ParseTreeListener):
4999 if hasattr( listener, "exitLambdef_nocond" ):
5000 listener.exitLambdef_nocond(self)
5005 def lambdef_nocond(self):
5007 localctx = Python3Parser.Lambdef_nocondContext(self, self._ctx, self.state)
5008 self.enterRule(localctx, 104, self.RULE_lambdef_nocond)
5009 self._la = 0 # Token type
5010 try:
5011 self.enterOuterAlt(localctx, 1)
5012 self.state = 745
5013 self.match(Python3Parser.LAMBDA)
5014 self.state = 747
5015 self._errHandler.sync(self)
5016 _la = self._input.LA(1)
5017 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.NAME) | (1 << Python3Parser.STAR) | (1 << Python3Parser.POWER))) != 0):
5018 self.state = 746
5019 self.varargslist()
5022 self.state = 749
5023 self.match(Python3Parser.COLON)
5024 self.state = 750
5025 self.test_nocond()
5026 except RecognitionException as re:
5027 localctx.exception = re
5028 self._errHandler.reportError(self, re)
5029 self._errHandler.recover(self, re)
5030 finally:
5031 self.exitRule()
5032 return localctx
5035 class Or_testContext(ParserRuleContext):
5037 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5038 super().__init__(parent, invokingState)
5039 self.parser = parser
5041 def and_test(self, i:int=None):
5042 if i is None:
5043 return self.getTypedRuleContexts(Python3Parser.And_testContext)
5044 else:
5045 return self.getTypedRuleContext(Python3Parser.And_testContext,i)
5048 def OR(self, i:int=None):
5049 if i is None:
5050 return self.getTokens(Python3Parser.OR)
5051 else:
5052 return self.getToken(Python3Parser.OR, i)
5054 def getRuleIndex(self):
5055 return Python3Parser.RULE_or_test
5057 def enterRule(self, listener:ParseTreeListener):
5058 if hasattr( listener, "enterOr_test" ):
5059 listener.enterOr_test(self)
5061 def exitRule(self, listener:ParseTreeListener):
5062 if hasattr( listener, "exitOr_test" ):
5063 listener.exitOr_test(self)
5068 def or_test(self):
5070 localctx = Python3Parser.Or_testContext(self, self._ctx, self.state)
5071 self.enterRule(localctx, 106, self.RULE_or_test)
5072 self._la = 0 # Token type
5073 try:
5074 self.enterOuterAlt(localctx, 1)
5075 self.state = 752
5076 self.and_test()
5077 self.state = 757
5078 self._errHandler.sync(self)
5079 _la = self._input.LA(1)
5080 while _la==Python3Parser.OR:
5081 self.state = 753
5082 self.match(Python3Parser.OR)
5083 self.state = 754
5084 self.and_test()
5085 self.state = 759
5086 self._errHandler.sync(self)
5087 _la = self._input.LA(1)
5089 except RecognitionException as re:
5090 localctx.exception = re
5091 self._errHandler.reportError(self, re)
5092 self._errHandler.recover(self, re)
5093 finally:
5094 self.exitRule()
5095 return localctx
5098 class And_testContext(ParserRuleContext):
5100 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5101 super().__init__(parent, invokingState)
5102 self.parser = parser
5104 def not_test(self, i:int=None):
5105 if i is None:
5106 return self.getTypedRuleContexts(Python3Parser.Not_testContext)
5107 else:
5108 return self.getTypedRuleContext(Python3Parser.Not_testContext,i)
5111 def AND(self, i:int=None):
5112 if i is None:
5113 return self.getTokens(Python3Parser.AND)
5114 else:
5115 return self.getToken(Python3Parser.AND, i)
5117 def getRuleIndex(self):
5118 return Python3Parser.RULE_and_test
5120 def enterRule(self, listener:ParseTreeListener):
5121 if hasattr( listener, "enterAnd_test" ):
5122 listener.enterAnd_test(self)
5124 def exitRule(self, listener:ParseTreeListener):
5125 if hasattr( listener, "exitAnd_test" ):
5126 listener.exitAnd_test(self)
5131 def and_test(self):
5133 localctx = Python3Parser.And_testContext(self, self._ctx, self.state)
5134 self.enterRule(localctx, 108, self.RULE_and_test)
5135 self._la = 0 # Token type
5136 try:
5137 self.enterOuterAlt(localctx, 1)
5138 self.state = 760
5139 self.not_test()
5140 self.state = 765
5141 self._errHandler.sync(self)
5142 _la = self._input.LA(1)
5143 while _la==Python3Parser.AND:
5144 self.state = 761
5145 self.match(Python3Parser.AND)
5146 self.state = 762
5147 self.not_test()
5148 self.state = 767
5149 self._errHandler.sync(self)
5150 _la = self._input.LA(1)
5152 except RecognitionException as re:
5153 localctx.exception = re
5154 self._errHandler.reportError(self, re)
5155 self._errHandler.recover(self, re)
5156 finally:
5157 self.exitRule()
5158 return localctx
5161 class Not_testContext(ParserRuleContext):
5163 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5164 super().__init__(parent, invokingState)
5165 self.parser = parser
5167 def NOT(self):
5168 return self.getToken(Python3Parser.NOT, 0)
5170 def not_test(self):
5171 return self.getTypedRuleContext(Python3Parser.Not_testContext,0)
5174 def comparison(self):
5175 return self.getTypedRuleContext(Python3Parser.ComparisonContext,0)
5178 def getRuleIndex(self):
5179 return Python3Parser.RULE_not_test
5181 def enterRule(self, listener:ParseTreeListener):
5182 if hasattr( listener, "enterNot_test" ):
5183 listener.enterNot_test(self)
5185 def exitRule(self, listener:ParseTreeListener):
5186 if hasattr( listener, "exitNot_test" ):
5187 listener.exitNot_test(self)
5192 def not_test(self):
5194 localctx = Python3Parser.Not_testContext(self, self._ctx, self.state)
5195 self.enterRule(localctx, 110, self.RULE_not_test)
5196 try:
5197 self.state = 771
5198 self._errHandler.sync(self)
5199 token = self._input.LA(1)
5200 if token in [Python3Parser.NOT]:
5201 self.enterOuterAlt(localctx, 1)
5202 self.state = 768
5203 self.match(Python3Parser.NOT)
5204 self.state = 769
5205 self.not_test()
5206 pass
5207 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]:
5208 self.enterOuterAlt(localctx, 2)
5209 self.state = 770
5210 self.comparison()
5211 pass
5212 else:
5213 raise NoViableAltException(self)
5215 except RecognitionException as re:
5216 localctx.exception = re
5217 self._errHandler.reportError(self, re)
5218 self._errHandler.recover(self, re)
5219 finally:
5220 self.exitRule()
5221 return localctx
5224 class ComparisonContext(ParserRuleContext):
5226 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5227 super().__init__(parent, invokingState)
5228 self.parser = parser
5230 def expr(self, i:int=None):
5231 if i is None:
5232 return self.getTypedRuleContexts(Python3Parser.ExprContext)
5233 else:
5234 return self.getTypedRuleContext(Python3Parser.ExprContext,i)
5237 def comp_op(self, i:int=None):
5238 if i is None:
5239 return self.getTypedRuleContexts(Python3Parser.Comp_opContext)
5240 else:
5241 return self.getTypedRuleContext(Python3Parser.Comp_opContext,i)
5244 def getRuleIndex(self):
5245 return Python3Parser.RULE_comparison
5247 def enterRule(self, listener:ParseTreeListener):
5248 if hasattr( listener, "enterComparison" ):
5249 listener.enterComparison(self)
5251 def exitRule(self, listener:ParseTreeListener):
5252 if hasattr( listener, "exitComparison" ):
5253 listener.exitComparison(self)
5258 def comparison(self):
5260 localctx = Python3Parser.ComparisonContext(self, self._ctx, self.state)
5261 self.enterRule(localctx, 112, self.RULE_comparison)
5262 self._la = 0 # Token type
5263 try:
5264 self.enterOuterAlt(localctx, 1)
5265 self.state = 773
5266 self.expr()
5267 self.state = 779
5268 self._errHandler.sync(self)
5269 _la = self._input.LA(1)
5270 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):
5271 self.state = 774
5272 self.comp_op()
5273 self.state = 775
5274 self.expr()
5275 self.state = 781
5276 self._errHandler.sync(self)
5277 _la = self._input.LA(1)
5279 except RecognitionException as re:
5280 localctx.exception = re
5281 self._errHandler.reportError(self, re)
5282 self._errHandler.recover(self, re)
5283 finally:
5284 self.exitRule()
5285 return localctx
5288 class Comp_opContext(ParserRuleContext):
5290 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5291 super().__init__(parent, invokingState)
5292 self.parser = parser
5294 def LESS_THAN(self):
5295 return self.getToken(Python3Parser.LESS_THAN, 0)
5297 def GREATER_THAN(self):
5298 return self.getToken(Python3Parser.GREATER_THAN, 0)
5300 def EQUALS(self):
5301 return self.getToken(Python3Parser.EQUALS, 0)
5303 def GT_EQ(self):
5304 return self.getToken(Python3Parser.GT_EQ, 0)
5306 def LT_EQ(self):
5307 return self.getToken(Python3Parser.LT_EQ, 0)
5309 def NOT_EQ_1(self):
5310 return self.getToken(Python3Parser.NOT_EQ_1, 0)
5312 def NOT_EQ_2(self):
5313 return self.getToken(Python3Parser.NOT_EQ_2, 0)
5315 def IN(self):
5316 return self.getToken(Python3Parser.IN, 0)
5318 def NOT(self):
5319 return self.getToken(Python3Parser.NOT, 0)
5321 def IS(self):
5322 return self.getToken(Python3Parser.IS, 0)
5324 def getRuleIndex(self):
5325 return Python3Parser.RULE_comp_op
5327 def enterRule(self, listener:ParseTreeListener):
5328 if hasattr( listener, "enterComp_op" ):
5329 listener.enterComp_op(self)
5331 def exitRule(self, listener:ParseTreeListener):
5332 if hasattr( listener, "exitComp_op" ):
5333 listener.exitComp_op(self)
5338 def comp_op(self):
5340 localctx = Python3Parser.Comp_opContext(self, self._ctx, self.state)
5341 self.enterRule(localctx, 114, self.RULE_comp_op)
5342 try:
5343 self.state = 795
5344 self._errHandler.sync(self)
5345 la_ = self._interp.adaptivePredict(self._input,107,self._ctx)
5346 if la_ == 1:
5347 self.enterOuterAlt(localctx, 1)
5348 self.state = 782
5349 self.match(Python3Parser.LESS_THAN)
5350 pass
5352 elif la_ == 2:
5353 self.enterOuterAlt(localctx, 2)
5354 self.state = 783
5355 self.match(Python3Parser.GREATER_THAN)
5356 pass
5358 elif la_ == 3:
5359 self.enterOuterAlt(localctx, 3)
5360 self.state = 784
5361 self.match(Python3Parser.EQUALS)
5362 pass
5364 elif la_ == 4:
5365 self.enterOuterAlt(localctx, 4)
5366 self.state = 785
5367 self.match(Python3Parser.GT_EQ)
5368 pass
5370 elif la_ == 5:
5371 self.enterOuterAlt(localctx, 5)
5372 self.state = 786
5373 self.match(Python3Parser.LT_EQ)
5374 pass
5376 elif la_ == 6:
5377 self.enterOuterAlt(localctx, 6)
5378 self.state = 787
5379 self.match(Python3Parser.NOT_EQ_1)
5380 pass
5382 elif la_ == 7:
5383 self.enterOuterAlt(localctx, 7)
5384 self.state = 788
5385 self.match(Python3Parser.NOT_EQ_2)
5386 pass
5388 elif la_ == 8:
5389 self.enterOuterAlt(localctx, 8)
5390 self.state = 789
5391 self.match(Python3Parser.IN)
5392 pass
5394 elif la_ == 9:
5395 self.enterOuterAlt(localctx, 9)
5396 self.state = 790
5397 self.match(Python3Parser.NOT)
5398 self.state = 791
5399 self.match(Python3Parser.IN)
5400 pass
5402 elif la_ == 10:
5403 self.enterOuterAlt(localctx, 10)
5404 self.state = 792
5405 self.match(Python3Parser.IS)
5406 pass
5408 elif la_ == 11:
5409 self.enterOuterAlt(localctx, 11)
5410 self.state = 793
5411 self.match(Python3Parser.IS)
5412 self.state = 794
5413 self.match(Python3Parser.NOT)
5414 pass
5417 except RecognitionException as re:
5418 localctx.exception = re
5419 self._errHandler.reportError(self, re)
5420 self._errHandler.recover(self, re)
5421 finally:
5422 self.exitRule()
5423 return localctx
5426 class Star_exprContext(ParserRuleContext):
5428 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5429 super().__init__(parent, invokingState)
5430 self.parser = parser
5432 def STAR(self):
5433 return self.getToken(Python3Parser.STAR, 0)
5435 def expr(self):
5436 return self.getTypedRuleContext(Python3Parser.ExprContext,0)
5439 def getRuleIndex(self):
5440 return Python3Parser.RULE_star_expr
5442 def enterRule(self, listener:ParseTreeListener):
5443 if hasattr( listener, "enterStar_expr" ):
5444 listener.enterStar_expr(self)
5446 def exitRule(self, listener:ParseTreeListener):
5447 if hasattr( listener, "exitStar_expr" ):
5448 listener.exitStar_expr(self)
5453 def star_expr(self):
5455 localctx = Python3Parser.Star_exprContext(self, self._ctx, self.state)
5456 self.enterRule(localctx, 116, self.RULE_star_expr)
5457 try:
5458 self.enterOuterAlt(localctx, 1)
5459 self.state = 797
5460 self.match(Python3Parser.STAR)
5461 self.state = 798
5462 self.expr()
5463 except RecognitionException as re:
5464 localctx.exception = re
5465 self._errHandler.reportError(self, re)
5466 self._errHandler.recover(self, re)
5467 finally:
5468 self.exitRule()
5469 return localctx
5472 class ExprContext(ParserRuleContext):
5474 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5475 super().__init__(parent, invokingState)
5476 self.parser = parser
5478 def xor_expr(self, i:int=None):
5479 if i is None:
5480 return self.getTypedRuleContexts(Python3Parser.Xor_exprContext)
5481 else:
5482 return self.getTypedRuleContext(Python3Parser.Xor_exprContext,i)
5485 def OR_OP(self, i:int=None):
5486 if i is None:
5487 return self.getTokens(Python3Parser.OR_OP)
5488 else:
5489 return self.getToken(Python3Parser.OR_OP, i)
5491 def getRuleIndex(self):
5492 return Python3Parser.RULE_expr
5494 def enterRule(self, listener:ParseTreeListener):
5495 if hasattr( listener, "enterExpr" ):
5496 listener.enterExpr(self)
5498 def exitRule(self, listener:ParseTreeListener):
5499 if hasattr( listener, "exitExpr" ):
5500 listener.exitExpr(self)
5505 def expr(self):
5507 localctx = Python3Parser.ExprContext(self, self._ctx, self.state)
5508 self.enterRule(localctx, 118, self.RULE_expr)
5509 self._la = 0 # Token type
5510 try:
5511 self.enterOuterAlt(localctx, 1)
5512 self.state = 800
5513 self.xor_expr()
5514 self.state = 805
5515 self._errHandler.sync(self)
5516 _la = self._input.LA(1)
5517 while _la==Python3Parser.OR_OP:
5518 self.state = 801
5519 self.match(Python3Parser.OR_OP)
5520 self.state = 802
5521 self.xor_expr()
5522 self.state = 807
5523 self._errHandler.sync(self)
5524 _la = self._input.LA(1)
5526 except RecognitionException as re:
5527 localctx.exception = re
5528 self._errHandler.reportError(self, re)
5529 self._errHandler.recover(self, re)
5530 finally:
5531 self.exitRule()
5532 return localctx
5535 class Xor_exprContext(ParserRuleContext):
5537 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5538 super().__init__(parent, invokingState)
5539 self.parser = parser
5541 def and_expr(self, i:int=None):
5542 if i is None:
5543 return self.getTypedRuleContexts(Python3Parser.And_exprContext)
5544 else:
5545 return self.getTypedRuleContext(Python3Parser.And_exprContext,i)
5548 def XOR(self, i:int=None):
5549 if i is None:
5550 return self.getTokens(Python3Parser.XOR)
5551 else:
5552 return self.getToken(Python3Parser.XOR, i)
5554 def getRuleIndex(self):
5555 return Python3Parser.RULE_xor_expr
5557 def enterRule(self, listener:ParseTreeListener):
5558 if hasattr( listener, "enterXor_expr" ):
5559 listener.enterXor_expr(self)
5561 def exitRule(self, listener:ParseTreeListener):
5562 if hasattr( listener, "exitXor_expr" ):
5563 listener.exitXor_expr(self)
5568 def xor_expr(self):
5570 localctx = Python3Parser.Xor_exprContext(self, self._ctx, self.state)
5571 self.enterRule(localctx, 120, self.RULE_xor_expr)
5572 self._la = 0 # Token type
5573 try:
5574 self.enterOuterAlt(localctx, 1)
5575 self.state = 808
5576 self.and_expr()
5577 self.state = 813
5578 self._errHandler.sync(self)
5579 _la = self._input.LA(1)
5580 while _la==Python3Parser.XOR:
5581 self.state = 809
5582 self.match(Python3Parser.XOR)
5583 self.state = 810
5584 self.and_expr()
5585 self.state = 815
5586 self._errHandler.sync(self)
5587 _la = self._input.LA(1)
5589 except RecognitionException as re:
5590 localctx.exception = re
5591 self._errHandler.reportError(self, re)
5592 self._errHandler.recover(self, re)
5593 finally:
5594 self.exitRule()
5595 return localctx
5598 class And_exprContext(ParserRuleContext):
5600 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5601 super().__init__(parent, invokingState)
5602 self.parser = parser
5604 def shift_expr(self, i:int=None):
5605 if i is None:
5606 return self.getTypedRuleContexts(Python3Parser.Shift_exprContext)
5607 else:
5608 return self.getTypedRuleContext(Python3Parser.Shift_exprContext,i)
5611 def AND_OP(self, i:int=None):
5612 if i is None:
5613 return self.getTokens(Python3Parser.AND_OP)
5614 else:
5615 return self.getToken(Python3Parser.AND_OP, i)
5617 def getRuleIndex(self):
5618 return Python3Parser.RULE_and_expr
5620 def enterRule(self, listener:ParseTreeListener):
5621 if hasattr( listener, "enterAnd_expr" ):
5622 listener.enterAnd_expr(self)
5624 def exitRule(self, listener:ParseTreeListener):
5625 if hasattr( listener, "exitAnd_expr" ):
5626 listener.exitAnd_expr(self)
5631 def and_expr(self):
5633 localctx = Python3Parser.And_exprContext(self, self._ctx, self.state)
5634 self.enterRule(localctx, 122, self.RULE_and_expr)
5635 self._la = 0 # Token type
5636 try:
5637 self.enterOuterAlt(localctx, 1)
5638 self.state = 816
5639 self.shift_expr()
5640 self.state = 821
5641 self._errHandler.sync(self)
5642 _la = self._input.LA(1)
5643 while _la==Python3Parser.AND_OP:
5644 self.state = 817
5645 self.match(Python3Parser.AND_OP)
5646 self.state = 818
5647 self.shift_expr()
5648 self.state = 823
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 Shift_exprContext(ParserRuleContext):
5663 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5664 super().__init__(parent, invokingState)
5665 self.parser = parser
5667 def arith_expr(self, i:int=None):
5668 if i is None:
5669 return self.getTypedRuleContexts(Python3Parser.Arith_exprContext)
5670 else:
5671 return self.getTypedRuleContext(Python3Parser.Arith_exprContext,i)
5674 def LEFT_SHIFT(self, i:int=None):
5675 if i is None:
5676 return self.getTokens(Python3Parser.LEFT_SHIFT)
5677 else:
5678 return self.getToken(Python3Parser.LEFT_SHIFT, i)
5680 def RIGHT_SHIFT(self, i:int=None):
5681 if i is None:
5682 return self.getTokens(Python3Parser.RIGHT_SHIFT)
5683 else:
5684 return self.getToken(Python3Parser.RIGHT_SHIFT, i)
5686 def getRuleIndex(self):
5687 return Python3Parser.RULE_shift_expr
5689 def enterRule(self, listener:ParseTreeListener):
5690 if hasattr( listener, "enterShift_expr" ):
5691 listener.enterShift_expr(self)
5693 def exitRule(self, listener:ParseTreeListener):
5694 if hasattr( listener, "exitShift_expr" ):
5695 listener.exitShift_expr(self)
5700 def shift_expr(self):
5702 localctx = Python3Parser.Shift_exprContext(self, self._ctx, self.state)
5703 self.enterRule(localctx, 124, self.RULE_shift_expr)
5704 self._la = 0 # Token type
5705 try:
5706 self.enterOuterAlt(localctx, 1)
5707 self.state = 824
5708 self.arith_expr()
5709 self.state = 829
5710 self._errHandler.sync(self)
5711 _la = self._input.LA(1)
5712 while _la==Python3Parser.LEFT_SHIFT or _la==Python3Parser.RIGHT_SHIFT:
5713 self.state = 825
5714 _la = self._input.LA(1)
5715 if not(_la==Python3Parser.LEFT_SHIFT or _la==Python3Parser.RIGHT_SHIFT):
5716 self._errHandler.recoverInline(self)
5717 else:
5718 self._errHandler.reportMatch(self)
5719 self.consume()
5720 self.state = 826
5721 self.arith_expr()
5722 self.state = 831
5723 self._errHandler.sync(self)
5724 _la = self._input.LA(1)
5726 except RecognitionException as re:
5727 localctx.exception = re
5728 self._errHandler.reportError(self, re)
5729 self._errHandler.recover(self, re)
5730 finally:
5731 self.exitRule()
5732 return localctx
5735 class Arith_exprContext(ParserRuleContext):
5737 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5738 super().__init__(parent, invokingState)
5739 self.parser = parser
5741 def term(self, i:int=None):
5742 if i is None:
5743 return self.getTypedRuleContexts(Python3Parser.TermContext)
5744 else:
5745 return self.getTypedRuleContext(Python3Parser.TermContext,i)
5748 def ADD(self, i:int=None):
5749 if i is None:
5750 return self.getTokens(Python3Parser.ADD)
5751 else:
5752 return self.getToken(Python3Parser.ADD, i)
5754 def MINUS(self, i:int=None):
5755 if i is None:
5756 return self.getTokens(Python3Parser.MINUS)
5757 else:
5758 return self.getToken(Python3Parser.MINUS, i)
5760 def getRuleIndex(self):
5761 return Python3Parser.RULE_arith_expr
5763 def enterRule(self, listener:ParseTreeListener):
5764 if hasattr( listener, "enterArith_expr" ):
5765 listener.enterArith_expr(self)
5767 def exitRule(self, listener:ParseTreeListener):
5768 if hasattr( listener, "exitArith_expr" ):
5769 listener.exitArith_expr(self)
5774 def arith_expr(self):
5776 localctx = Python3Parser.Arith_exprContext(self, self._ctx, self.state)
5777 self.enterRule(localctx, 126, self.RULE_arith_expr)
5778 self._la = 0 # Token type
5779 try:
5780 self.enterOuterAlt(localctx, 1)
5781 self.state = 832
5782 self.term()
5783 self.state = 837
5784 self._errHandler.sync(self)
5785 _la = self._input.LA(1)
5786 while _la==Python3Parser.ADD or _la==Python3Parser.MINUS:
5787 self.state = 833
5788 _la = self._input.LA(1)
5789 if not(_la==Python3Parser.ADD or _la==Python3Parser.MINUS):
5790 self._errHandler.recoverInline(self)
5791 else:
5792 self._errHandler.reportMatch(self)
5793 self.consume()
5794 self.state = 834
5795 self.term()
5796 self.state = 839
5797 self._errHandler.sync(self)
5798 _la = self._input.LA(1)
5800 except RecognitionException as re:
5801 localctx.exception = re
5802 self._errHandler.reportError(self, re)
5803 self._errHandler.recover(self, re)
5804 finally:
5805 self.exitRule()
5806 return localctx
5809 class TermContext(ParserRuleContext):
5811 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5812 super().__init__(parent, invokingState)
5813 self.parser = parser
5815 def factor(self, i:int=None):
5816 if i is None:
5817 return self.getTypedRuleContexts(Python3Parser.FactorContext)
5818 else:
5819 return self.getTypedRuleContext(Python3Parser.FactorContext,i)
5822 def STAR(self, i:int=None):
5823 if i is None:
5824 return self.getTokens(Python3Parser.STAR)
5825 else:
5826 return self.getToken(Python3Parser.STAR, i)
5828 def AT(self, i:int=None):
5829 if i is None:
5830 return self.getTokens(Python3Parser.AT)
5831 else:
5832 return self.getToken(Python3Parser.AT, i)
5834 def DIV(self, i:int=None):
5835 if i is None:
5836 return self.getTokens(Python3Parser.DIV)
5837 else:
5838 return self.getToken(Python3Parser.DIV, i)
5840 def MOD(self, i:int=None):
5841 if i is None:
5842 return self.getTokens(Python3Parser.MOD)
5843 else:
5844 return self.getToken(Python3Parser.MOD, i)
5846 def IDIV(self, i:int=None):
5847 if i is None:
5848 return self.getTokens(Python3Parser.IDIV)
5849 else:
5850 return self.getToken(Python3Parser.IDIV, i)
5852 def getRuleIndex(self):
5853 return Python3Parser.RULE_term
5855 def enterRule(self, listener:ParseTreeListener):
5856 if hasattr( listener, "enterTerm" ):
5857 listener.enterTerm(self)
5859 def exitRule(self, listener:ParseTreeListener):
5860 if hasattr( listener, "exitTerm" ):
5861 listener.exitTerm(self)
5866 def term(self):
5868 localctx = Python3Parser.TermContext(self, self._ctx, self.state)
5869 self.enterRule(localctx, 128, self.RULE_term)
5870 self._la = 0 # Token type
5871 try:
5872 self.enterOuterAlt(localctx, 1)
5873 self.state = 840
5874 self.factor()
5875 self.state = 845
5876 self._errHandler.sync(self)
5877 _la = self._input.LA(1)
5878 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):
5879 self.state = 841
5880 _la = self._input.LA(1)
5881 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)):
5882 self._errHandler.recoverInline(self)
5883 else:
5884 self._errHandler.reportMatch(self)
5885 self.consume()
5886 self.state = 842
5887 self.factor()
5888 self.state = 847
5889 self._errHandler.sync(self)
5890 _la = self._input.LA(1)
5892 except RecognitionException as re:
5893 localctx.exception = re
5894 self._errHandler.reportError(self, re)
5895 self._errHandler.recover(self, re)
5896 finally:
5897 self.exitRule()
5898 return localctx
5901 class FactorContext(ParserRuleContext):
5903 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5904 super().__init__(parent, invokingState)
5905 self.parser = parser
5907 def factor(self):
5908 return self.getTypedRuleContext(Python3Parser.FactorContext,0)
5911 def ADD(self):
5912 return self.getToken(Python3Parser.ADD, 0)
5914 def MINUS(self):
5915 return self.getToken(Python3Parser.MINUS, 0)
5917 def NOT_OP(self):
5918 return self.getToken(Python3Parser.NOT_OP, 0)
5920 def power(self):
5921 return self.getTypedRuleContext(Python3Parser.PowerContext,0)
5924 def getRuleIndex(self):
5925 return Python3Parser.RULE_factor
5927 def enterRule(self, listener:ParseTreeListener):
5928 if hasattr( listener, "enterFactor" ):
5929 listener.enterFactor(self)
5931 def exitRule(self, listener:ParseTreeListener):
5932 if hasattr( listener, "exitFactor" ):
5933 listener.exitFactor(self)
5938 def factor(self):
5940 localctx = Python3Parser.FactorContext(self, self._ctx, self.state)
5941 self.enterRule(localctx, 130, self.RULE_factor)
5942 self._la = 0 # Token type
5943 try:
5944 self.state = 851
5945 self._errHandler.sync(self)
5946 token = self._input.LA(1)
5947 if token in [Python3Parser.ADD, Python3Parser.MINUS, Python3Parser.NOT_OP]:
5948 self.enterOuterAlt(localctx, 1)
5949 self.state = 848
5950 _la = self._input.LA(1)
5951 if not(((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (Python3Parser.ADD - 66)) | (1 << (Python3Parser.MINUS - 66)) | (1 << (Python3Parser.NOT_OP - 66)))) != 0)):
5952 self._errHandler.recoverInline(self)
5953 else:
5954 self._errHandler.reportMatch(self)
5955 self.consume()
5956 self.state = 849
5957 self.factor()
5958 pass
5959 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]:
5960 self.enterOuterAlt(localctx, 2)
5961 self.state = 850
5962 self.power()
5963 pass
5964 else:
5965 raise NoViableAltException(self)
5967 except RecognitionException as re:
5968 localctx.exception = re
5969 self._errHandler.reportError(self, re)
5970 self._errHandler.recover(self, re)
5971 finally:
5972 self.exitRule()
5973 return localctx
5976 class PowerContext(ParserRuleContext):
5978 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
5979 super().__init__(parent, invokingState)
5980 self.parser = parser
5982 def atom_expr(self):
5983 return self.getTypedRuleContext(Python3Parser.Atom_exprContext,0)
5986 def POWER(self):
5987 return self.getToken(Python3Parser.POWER, 0)
5989 def factor(self):
5990 return self.getTypedRuleContext(Python3Parser.FactorContext,0)
5993 def getRuleIndex(self):
5994 return Python3Parser.RULE_power
5996 def enterRule(self, listener:ParseTreeListener):
5997 if hasattr( listener, "enterPower" ):
5998 listener.enterPower(self)
6000 def exitRule(self, listener:ParseTreeListener):
6001 if hasattr( listener, "exitPower" ):
6002 listener.exitPower(self)
6007 def power(self):
6009 localctx = Python3Parser.PowerContext(self, self._ctx, self.state)
6010 self.enterRule(localctx, 132, self.RULE_power)
6011 self._la = 0 # Token type
6012 try:
6013 self.enterOuterAlt(localctx, 1)
6014 self.state = 853
6015 self.atom_expr()
6016 self.state = 856
6017 self._errHandler.sync(self)
6018 _la = self._input.LA(1)
6019 if _la==Python3Parser.POWER:
6020 self.state = 854
6021 self.match(Python3Parser.POWER)
6022 self.state = 855
6023 self.factor()
6026 except RecognitionException as re:
6027 localctx.exception = re
6028 self._errHandler.reportError(self, re)
6029 self._errHandler.recover(self, re)
6030 finally:
6031 self.exitRule()
6032 return localctx
6035 class Atom_exprContext(ParserRuleContext):
6037 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
6038 super().__init__(parent, invokingState)
6039 self.parser = parser
6041 def atom(self):
6042 return self.getTypedRuleContext(Python3Parser.AtomContext,0)
6045 def AWAIT(self):
6046 return self.getToken(Python3Parser.AWAIT, 0)
6048 def trailer(self, i:int=None):
6049 if i is None:
6050 return self.getTypedRuleContexts(Python3Parser.TrailerContext)
6051 else:
6052 return self.getTypedRuleContext(Python3Parser.TrailerContext,i)
6055 def getRuleIndex(self):
6056 return Python3Parser.RULE_atom_expr
6058 def enterRule(self, listener:ParseTreeListener):
6059 if hasattr( listener, "enterAtom_expr" ):
6060 listener.enterAtom_expr(self)
6062 def exitRule(self, listener:ParseTreeListener):
6063 if hasattr( listener, "exitAtom_expr" ):
6064 listener.exitAtom_expr(self)
6069 def atom_expr(self):
6071 localctx = Python3Parser.Atom_exprContext(self, self._ctx, self.state)
6072 self.enterRule(localctx, 134, self.RULE_atom_expr)
6073 self._la = 0 # Token type
6074 try:
6075 self.enterOuterAlt(localctx, 1)
6076 self.state = 859
6077 self._errHandler.sync(self)
6078 _la = self._input.LA(1)
6079 if _la==Python3Parser.AWAIT:
6080 self.state = 858
6081 self.match(Python3Parser.AWAIT)
6084 self.state = 861
6085 self.atom()
6086 self.state = 865
6087 self._errHandler.sync(self)
6088 _la = self._input.LA(1)
6089 while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.DOT) | (1 << Python3Parser.OPEN_PAREN) | (1 << Python3Parser.OPEN_BRACK))) != 0):
6090 self.state = 862
6091 self.trailer()
6092 self.state = 867
6093 self._errHandler.sync(self)
6094 _la = self._input.LA(1)
6096 except RecognitionException as re:
6097 localctx.exception = re
6098 self._errHandler.reportError(self, re)
6099 self._errHandler.recover(self, re)
6100 finally:
6101 self.exitRule()
6102 return localctx
6105 class AtomContext(ParserRuleContext):
6107 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
6108 super().__init__(parent, invokingState)
6109 self.parser = parser
6111 def OPEN_PAREN(self):
6112 return self.getToken(Python3Parser.OPEN_PAREN, 0)
6114 def CLOSE_PAREN(self):
6115 return self.getToken(Python3Parser.CLOSE_PAREN, 0)
6117 def OPEN_BRACK(self):
6118 return self.getToken(Python3Parser.OPEN_BRACK, 0)
6120 def CLOSE_BRACK(self):
6121 return self.getToken(Python3Parser.CLOSE_BRACK, 0)
6123 def OPEN_BRACE(self):
6124 return self.getToken(Python3Parser.OPEN_BRACE, 0)
6126 def CLOSE_BRACE(self):
6127 return self.getToken(Python3Parser.CLOSE_BRACE, 0)
6129 def NAME(self):
6130 return self.getToken(Python3Parser.NAME, 0)
6132 def NUMBER(self):
6133 return self.getToken(Python3Parser.NUMBER, 0)
6135 def ELLIPSIS(self):
6136 return self.getToken(Python3Parser.ELLIPSIS, 0)
6138 def NONE(self):
6139 return self.getToken(Python3Parser.NONE, 0)
6141 def TRUE(self):
6142 return self.getToken(Python3Parser.TRUE, 0)
6144 def FALSE(self):
6145 return self.getToken(Python3Parser.FALSE, 0)
6147 def yield_expr(self):
6148 return self.getTypedRuleContext(Python3Parser.Yield_exprContext,0)
6151 def testlist_comp(self):
6152 return self.getTypedRuleContext(Python3Parser.Testlist_compContext,0)
6155 def dictorsetmaker(self):
6156 return self.getTypedRuleContext(Python3Parser.DictorsetmakerContext,0)
6159 def STRING(self, i:int=None):
6160 if i is None:
6161 return self.getTokens(Python3Parser.STRING)
6162 else:
6163 return self.getToken(Python3Parser.STRING, i)
6165 def getRuleIndex(self):
6166 return Python3Parser.RULE_atom
6168 def enterRule(self, listener:ParseTreeListener):
6169 if hasattr( listener, "enterAtom" ):
6170 listener.enterAtom(self)
6172 def exitRule(self, listener:ParseTreeListener):
6173 if hasattr( listener, "exitAtom" ):
6174 listener.exitAtom(self)
6179 def atom(self):
6181 localctx = Python3Parser.AtomContext(self, self._ctx, self.state)
6182 self.enterRule(localctx, 136, self.RULE_atom)
6183 self._la = 0 # Token type
6184 try:
6185 self.enterOuterAlt(localctx, 1)
6186 self.state = 895
6187 self._errHandler.sync(self)
6188 token = self._input.LA(1)
6189 if token in [Python3Parser.OPEN_PAREN]:
6190 self.state = 868
6191 self.match(Python3Parser.OPEN_PAREN)
6192 self.state = 871
6193 self._errHandler.sync(self)
6194 token = self._input.LA(1)
6195 if token in [Python3Parser.YIELD]:
6196 self.state = 869
6197 self.yield_expr()
6198 pass
6199 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]:
6200 self.state = 870
6201 self.testlist_comp()
6202 pass
6203 elif token in [Python3Parser.CLOSE_PAREN]:
6204 pass
6205 else:
6206 pass
6207 self.state = 873
6208 self.match(Python3Parser.CLOSE_PAREN)
6209 pass
6210 elif token in [Python3Parser.OPEN_BRACK]:
6211 self.state = 874
6212 self.match(Python3Parser.OPEN_BRACK)
6213 self.state = 876
6214 self._errHandler.sync(self)
6215 _la = self._input.LA(1)
6216 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):
6217 self.state = 875
6218 self.testlist_comp()
6221 self.state = 878
6222 self.match(Python3Parser.CLOSE_BRACK)
6223 pass
6224 elif token in [Python3Parser.OPEN_BRACE]:
6225 self.state = 879
6226 self.match(Python3Parser.OPEN_BRACE)
6227 self.state = 881
6228 self._errHandler.sync(self)
6229 _la = self._input.LA(1)
6230 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):
6231 self.state = 880
6232 self.dictorsetmaker()
6235 self.state = 883
6236 self.match(Python3Parser.CLOSE_BRACE)
6237 pass
6238 elif token in [Python3Parser.NAME]:
6239 self.state = 884
6240 self.match(Python3Parser.NAME)
6241 pass
6242 elif token in [Python3Parser.NUMBER]:
6243 self.state = 885
6244 self.match(Python3Parser.NUMBER)
6245 pass
6246 elif token in [Python3Parser.STRING]:
6247 self.state = 887
6248 self._errHandler.sync(self)
6249 _la = self._input.LA(1)
6250 while True:
6251 self.state = 886
6252 self.match(Python3Parser.STRING)
6253 self.state = 889
6254 self._errHandler.sync(self)
6255 _la = self._input.LA(1)
6256 if not (_la==Python3Parser.STRING):
6257 break
6259 pass
6260 elif token in [Python3Parser.ELLIPSIS]:
6261 self.state = 891
6262 self.match(Python3Parser.ELLIPSIS)
6263 pass
6264 elif token in [Python3Parser.NONE]:
6265 self.state = 892
6266 self.match(Python3Parser.NONE)
6267 pass
6268 elif token in [Python3Parser.TRUE]:
6269 self.state = 893
6270 self.match(Python3Parser.TRUE)
6271 pass
6272 elif token in [Python3Parser.FALSE]:
6273 self.state = 894
6274 self.match(Python3Parser.FALSE)
6275 pass
6276 else:
6277 raise NoViableAltException(self)
6279 except RecognitionException as re:
6280 localctx.exception = re
6281 self._errHandler.reportError(self, re)
6282 self._errHandler.recover(self, re)
6283 finally:
6284 self.exitRule()
6285 return localctx
6288 class Testlist_compContext(ParserRuleContext):
6290 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
6291 super().__init__(parent, invokingState)
6292 self.parser = parser
6294 def test(self, i:int=None):
6295 if i is None:
6296 return self.getTypedRuleContexts(Python3Parser.TestContext)
6297 else:
6298 return self.getTypedRuleContext(Python3Parser.TestContext,i)
6301 def star_expr(self, i:int=None):
6302 if i is None:
6303 return self.getTypedRuleContexts(Python3Parser.Star_exprContext)
6304 else:
6305 return self.getTypedRuleContext(Python3Parser.Star_exprContext,i)
6308 def comp_for(self):
6309 return self.getTypedRuleContext(Python3Parser.Comp_forContext,0)
6312 def COMMA(self, i:int=None):
6313 if i is None:
6314 return self.getTokens(Python3Parser.COMMA)
6315 else:
6316 return self.getToken(Python3Parser.COMMA, i)
6318 def getRuleIndex(self):
6319 return Python3Parser.RULE_testlist_comp
6321 def enterRule(self, listener:ParseTreeListener):
6322 if hasattr( listener, "enterTestlist_comp" ):
6323 listener.enterTestlist_comp(self)
6325 def exitRule(self, listener:ParseTreeListener):
6326 if hasattr( listener, "exitTestlist_comp" ):
6327 listener.exitTestlist_comp(self)
6332 def testlist_comp(self):
6334 localctx = Python3Parser.Testlist_compContext(self, self._ctx, self.state)
6335 self.enterRule(localctx, 138, self.RULE_testlist_comp)
6336 self._la = 0 # Token type
6337 try:
6338 self.enterOuterAlt(localctx, 1)
6339 self.state = 899
6340 self._errHandler.sync(self)
6341 token = self._input.LA(1)
6342 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]:
6343 self.state = 897
6344 self.test()
6345 pass
6346 elif token in [Python3Parser.STAR]:
6347 self.state = 898
6348 self.star_expr()
6349 pass
6350 else:
6351 raise NoViableAltException(self)
6353 self.state = 915
6354 self._errHandler.sync(self)
6355 token = self._input.LA(1)
6356 if token in [Python3Parser.FOR, Python3Parser.ASYNC]:
6357 self.state = 901
6358 self.comp_for()
6359 pass
6360 elif token in [Python3Parser.CLOSE_PAREN, Python3Parser.COMMA, Python3Parser.CLOSE_BRACK]:
6361 self.state = 909
6362 self._errHandler.sync(self)
6363 _alt = self._interp.adaptivePredict(self._input,125,self._ctx)
6364 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
6365 if _alt==1:
6366 self.state = 902
6367 self.match(Python3Parser.COMMA)
6368 self.state = 905
6369 self._errHandler.sync(self)
6370 token = self._input.LA(1)
6371 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]:
6372 self.state = 903
6373 self.test()
6374 pass
6375 elif token in [Python3Parser.STAR]:
6376 self.state = 904
6377 self.star_expr()
6378 pass
6379 else:
6380 raise NoViableAltException(self)
6382 self.state = 911
6383 self._errHandler.sync(self)
6384 _alt = self._interp.adaptivePredict(self._input,125,self._ctx)
6386 self.state = 913
6387 self._errHandler.sync(self)
6388 _la = self._input.LA(1)
6389 if _la==Python3Parser.COMMA:
6390 self.state = 912
6391 self.match(Python3Parser.COMMA)
6394 pass
6395 else:
6396 raise NoViableAltException(self)
6398 except RecognitionException as re:
6399 localctx.exception = re
6400 self._errHandler.reportError(self, re)
6401 self._errHandler.recover(self, re)
6402 finally:
6403 self.exitRule()
6404 return localctx
6407 class TrailerContext(ParserRuleContext):
6409 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
6410 super().__init__(parent, invokingState)
6411 self.parser = parser
6413 def OPEN_PAREN(self):
6414 return self.getToken(Python3Parser.OPEN_PAREN, 0)
6416 def CLOSE_PAREN(self):
6417 return self.getToken(Python3Parser.CLOSE_PAREN, 0)
6419 def arglist(self):
6420 return self.getTypedRuleContext(Python3Parser.ArglistContext,0)
6423 def OPEN_BRACK(self):
6424 return self.getToken(Python3Parser.OPEN_BRACK, 0)
6426 def subscriptlist(self):
6427 return self.getTypedRuleContext(Python3Parser.SubscriptlistContext,0)
6430 def CLOSE_BRACK(self):
6431 return self.getToken(Python3Parser.CLOSE_BRACK, 0)
6433 def DOT(self):
6434 return self.getToken(Python3Parser.DOT, 0)
6436 def NAME(self):
6437 return self.getToken(Python3Parser.NAME, 0)
6439 def getRuleIndex(self):
6440 return Python3Parser.RULE_trailer
6442 def enterRule(self, listener:ParseTreeListener):
6443 if hasattr( listener, "enterTrailer" ):
6444 listener.enterTrailer(self)
6446 def exitRule(self, listener:ParseTreeListener):
6447 if hasattr( listener, "exitTrailer" ):
6448 listener.exitTrailer(self)
6453 def trailer(self):
6455 localctx = Python3Parser.TrailerContext(self, self._ctx, self.state)
6456 self.enterRule(localctx, 140, self.RULE_trailer)
6457 self._la = 0 # Token type
6458 try:
6459 self.state = 928
6460 self._errHandler.sync(self)
6461 token = self._input.LA(1)
6462 if token in [Python3Parser.OPEN_PAREN]:
6463 self.enterOuterAlt(localctx, 1)
6464 self.state = 917
6465 self.match(Python3Parser.OPEN_PAREN)
6466 self.state = 919
6467 self._errHandler.sync(self)
6468 _la = self._input.LA(1)
6469 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):
6470 self.state = 918
6471 self.arglist()
6474 self.state = 921
6475 self.match(Python3Parser.CLOSE_PAREN)
6476 pass
6477 elif token in [Python3Parser.OPEN_BRACK]:
6478 self.enterOuterAlt(localctx, 2)
6479 self.state = 922
6480 self.match(Python3Parser.OPEN_BRACK)
6481 self.state = 923
6482 self.subscriptlist()
6483 self.state = 924
6484 self.match(Python3Parser.CLOSE_BRACK)
6485 pass
6486 elif token in [Python3Parser.DOT]:
6487 self.enterOuterAlt(localctx, 3)
6488 self.state = 926
6489 self.match(Python3Parser.DOT)
6490 self.state = 927
6491 self.match(Python3Parser.NAME)
6492 pass
6493 else:
6494 raise NoViableAltException(self)
6496 except RecognitionException as re:
6497 localctx.exception = re
6498 self._errHandler.reportError(self, re)
6499 self._errHandler.recover(self, re)
6500 finally:
6501 self.exitRule()
6502 return localctx
6505 class SubscriptlistContext(ParserRuleContext):
6507 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
6508 super().__init__(parent, invokingState)
6509 self.parser = parser
6511 def subscript(self, i:int=None):
6512 if i is None:
6513 return self.getTypedRuleContexts(Python3Parser.SubscriptContext)
6514 else:
6515 return self.getTypedRuleContext(Python3Parser.SubscriptContext,i)
6518 def COMMA(self, i:int=None):
6519 if i is None:
6520 return self.getTokens(Python3Parser.COMMA)
6521 else:
6522 return self.getToken(Python3Parser.COMMA, i)
6524 def getRuleIndex(self):
6525 return Python3Parser.RULE_subscriptlist
6527 def enterRule(self, listener:ParseTreeListener):
6528 if hasattr( listener, "enterSubscriptlist" ):
6529 listener.enterSubscriptlist(self)
6531 def exitRule(self, listener:ParseTreeListener):
6532 if hasattr( listener, "exitSubscriptlist" ):
6533 listener.exitSubscriptlist(self)
6538 def subscriptlist(self):
6540 localctx = Python3Parser.SubscriptlistContext(self, self._ctx, self.state)
6541 self.enterRule(localctx, 142, self.RULE_subscriptlist)
6542 self._la = 0 # Token type
6543 try:
6544 self.enterOuterAlt(localctx, 1)
6545 self.state = 930
6546 self.subscript()
6547 self.state = 935
6548 self._errHandler.sync(self)
6549 _alt = self._interp.adaptivePredict(self._input,130,self._ctx)
6550 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
6551 if _alt==1:
6552 self.state = 931
6553 self.match(Python3Parser.COMMA)
6554 self.state = 932
6555 self.subscript()
6556 self.state = 937
6557 self._errHandler.sync(self)
6558 _alt = self._interp.adaptivePredict(self._input,130,self._ctx)
6560 self.state = 939
6561 self._errHandler.sync(self)
6562 _la = self._input.LA(1)
6563 if _la==Python3Parser.COMMA:
6564 self.state = 938
6565 self.match(Python3Parser.COMMA)
6568 except RecognitionException as re:
6569 localctx.exception = re
6570 self._errHandler.reportError(self, re)
6571 self._errHandler.recover(self, re)
6572 finally:
6573 self.exitRule()
6574 return localctx
6577 class SubscriptContext(ParserRuleContext):
6579 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
6580 super().__init__(parent, invokingState)
6581 self.parser = parser
6583 def test(self, i:int=None):
6584 if i is None:
6585 return self.getTypedRuleContexts(Python3Parser.TestContext)
6586 else:
6587 return self.getTypedRuleContext(Python3Parser.TestContext,i)
6590 def COLON(self):
6591 return self.getToken(Python3Parser.COLON, 0)
6593 def sliceop(self):
6594 return self.getTypedRuleContext(Python3Parser.SliceopContext,0)
6597 def getRuleIndex(self):
6598 return Python3Parser.RULE_subscript
6600 def enterRule(self, listener:ParseTreeListener):
6601 if hasattr( listener, "enterSubscript" ):
6602 listener.enterSubscript(self)
6604 def exitRule(self, listener:ParseTreeListener):
6605 if hasattr( listener, "exitSubscript" ):
6606 listener.exitSubscript(self)
6611 def subscript(self):
6613 localctx = Python3Parser.SubscriptContext(self, self._ctx, self.state)
6614 self.enterRule(localctx, 144, self.RULE_subscript)
6615 self._la = 0 # Token type
6616 try:
6617 self.state = 952
6618 self._errHandler.sync(self)
6619 la_ = self._interp.adaptivePredict(self._input,135,self._ctx)
6620 if la_ == 1:
6621 self.enterOuterAlt(localctx, 1)
6622 self.state = 941
6623 self.test()
6624 pass
6626 elif la_ == 2:
6627 self.enterOuterAlt(localctx, 2)
6628 self.state = 943
6629 self._errHandler.sync(self)
6630 _la = self._input.LA(1)
6631 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):
6632 self.state = 942
6633 self.test()
6636 self.state = 945
6637 self.match(Python3Parser.COLON)
6638 self.state = 947
6639 self._errHandler.sync(self)
6640 _la = self._input.LA(1)
6641 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):
6642 self.state = 946
6643 self.test()
6646 self.state = 950
6647 self._errHandler.sync(self)
6648 _la = self._input.LA(1)
6649 if _la==Python3Parser.COLON:
6650 self.state = 949
6651 self.sliceop()
6654 pass
6657 except RecognitionException as re:
6658 localctx.exception = re
6659 self._errHandler.reportError(self, re)
6660 self._errHandler.recover(self, re)
6661 finally:
6662 self.exitRule()
6663 return localctx
6666 class SliceopContext(ParserRuleContext):
6668 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
6669 super().__init__(parent, invokingState)
6670 self.parser = parser
6672 def COLON(self):
6673 return self.getToken(Python3Parser.COLON, 0)
6675 def test(self):
6676 return self.getTypedRuleContext(Python3Parser.TestContext,0)
6679 def getRuleIndex(self):
6680 return Python3Parser.RULE_sliceop
6682 def enterRule(self, listener:ParseTreeListener):
6683 if hasattr( listener, "enterSliceop" ):
6684 listener.enterSliceop(self)
6686 def exitRule(self, listener:ParseTreeListener):
6687 if hasattr( listener, "exitSliceop" ):
6688 listener.exitSliceop(self)
6693 def sliceop(self):
6695 localctx = Python3Parser.SliceopContext(self, self._ctx, self.state)
6696 self.enterRule(localctx, 146, self.RULE_sliceop)
6697 self._la = 0 # Token type
6698 try:
6699 self.enterOuterAlt(localctx, 1)
6700 self.state = 954
6701 self.match(Python3Parser.COLON)
6702 self.state = 956
6703 self._errHandler.sync(self)
6704 _la = self._input.LA(1)
6705 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):
6706 self.state = 955
6707 self.test()
6710 except RecognitionException as re:
6711 localctx.exception = re
6712 self._errHandler.reportError(self, re)
6713 self._errHandler.recover(self, re)
6714 finally:
6715 self.exitRule()
6716 return localctx
6719 class ExprlistContext(ParserRuleContext):
6721 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
6722 super().__init__(parent, invokingState)
6723 self.parser = parser
6725 def expr(self, i:int=None):
6726 if i is None:
6727 return self.getTypedRuleContexts(Python3Parser.ExprContext)
6728 else:
6729 return self.getTypedRuleContext(Python3Parser.ExprContext,i)
6732 def star_expr(self, i:int=None):
6733 if i is None:
6734 return self.getTypedRuleContexts(Python3Parser.Star_exprContext)
6735 else:
6736 return self.getTypedRuleContext(Python3Parser.Star_exprContext,i)
6739 def COMMA(self, i:int=None):
6740 if i is None:
6741 return self.getTokens(Python3Parser.COMMA)
6742 else:
6743 return self.getToken(Python3Parser.COMMA, i)
6745 def getRuleIndex(self):
6746 return Python3Parser.RULE_exprlist
6748 def enterRule(self, listener:ParseTreeListener):
6749 if hasattr( listener, "enterExprlist" ):
6750 listener.enterExprlist(self)
6752 def exitRule(self, listener:ParseTreeListener):
6753 if hasattr( listener, "exitExprlist" ):
6754 listener.exitExprlist(self)
6759 def exprlist(self):
6761 localctx = Python3Parser.ExprlistContext(self, self._ctx, self.state)
6762 self.enterRule(localctx, 148, self.RULE_exprlist)
6763 self._la = 0 # Token type
6764 try:
6765 self.enterOuterAlt(localctx, 1)
6766 self.state = 960
6767 self._errHandler.sync(self)
6768 token = self._input.LA(1)
6769 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]:
6770 self.state = 958
6771 self.expr()
6772 pass
6773 elif token in [Python3Parser.STAR]:
6774 self.state = 959
6775 self.star_expr()
6776 pass
6777 else:
6778 raise NoViableAltException(self)
6780 self.state = 969
6781 self._errHandler.sync(self)
6782 _alt = self._interp.adaptivePredict(self._input,139,self._ctx)
6783 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
6784 if _alt==1:
6785 self.state = 962
6786 self.match(Python3Parser.COMMA)
6787 self.state = 965
6788 self._errHandler.sync(self)
6789 token = self._input.LA(1)
6790 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]:
6791 self.state = 963
6792 self.expr()
6793 pass
6794 elif token in [Python3Parser.STAR]:
6795 self.state = 964
6796 self.star_expr()
6797 pass
6798 else:
6799 raise NoViableAltException(self)
6801 self.state = 971
6802 self._errHandler.sync(self)
6803 _alt = self._interp.adaptivePredict(self._input,139,self._ctx)
6805 self.state = 973
6806 self._errHandler.sync(self)
6807 _la = self._input.LA(1)
6808 if _la==Python3Parser.COMMA:
6809 self.state = 972
6810 self.match(Python3Parser.COMMA)
6813 except RecognitionException as re:
6814 localctx.exception = re
6815 self._errHandler.reportError(self, re)
6816 self._errHandler.recover(self, re)
6817 finally:
6818 self.exitRule()
6819 return localctx
6822 class TestlistContext(ParserRuleContext):
6824 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
6825 super().__init__(parent, invokingState)
6826 self.parser = parser
6828 def test(self, i:int=None):
6829 if i is None:
6830 return self.getTypedRuleContexts(Python3Parser.TestContext)
6831 else:
6832 return self.getTypedRuleContext(Python3Parser.TestContext,i)
6835 def COMMA(self, i:int=None):
6836 if i is None:
6837 return self.getTokens(Python3Parser.COMMA)
6838 else:
6839 return self.getToken(Python3Parser.COMMA, i)
6841 def getRuleIndex(self):
6842 return Python3Parser.RULE_testlist
6844 def enterRule(self, listener:ParseTreeListener):
6845 if hasattr( listener, "enterTestlist" ):
6846 listener.enterTestlist(self)
6848 def exitRule(self, listener:ParseTreeListener):
6849 if hasattr( listener, "exitTestlist" ):
6850 listener.exitTestlist(self)
6855 def testlist(self):
6857 localctx = Python3Parser.TestlistContext(self, self._ctx, self.state)
6858 self.enterRule(localctx, 150, self.RULE_testlist)
6859 self._la = 0 # Token type
6860 try:
6861 self.enterOuterAlt(localctx, 1)
6862 self.state = 975
6863 self.test()
6864 self.state = 980
6865 self._errHandler.sync(self)
6866 _alt = self._interp.adaptivePredict(self._input,141,self._ctx)
6867 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
6868 if _alt==1:
6869 self.state = 976
6870 self.match(Python3Parser.COMMA)
6871 self.state = 977
6872 self.test()
6873 self.state = 982
6874 self._errHandler.sync(self)
6875 _alt = self._interp.adaptivePredict(self._input,141,self._ctx)
6877 self.state = 984
6878 self._errHandler.sync(self)
6879 _la = self._input.LA(1)
6880 if _la==Python3Parser.COMMA:
6881 self.state = 983
6882 self.match(Python3Parser.COMMA)
6885 except RecognitionException as re:
6886 localctx.exception = re
6887 self._errHandler.reportError(self, re)
6888 self._errHandler.recover(self, re)
6889 finally:
6890 self.exitRule()
6891 return localctx
6894 class DictorsetmakerContext(ParserRuleContext):
6896 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
6897 super().__init__(parent, invokingState)
6898 self.parser = parser
6900 def test(self, i:int=None):
6901 if i is None:
6902 return self.getTypedRuleContexts(Python3Parser.TestContext)
6903 else:
6904 return self.getTypedRuleContext(Python3Parser.TestContext,i)
6907 def COLON(self, i:int=None):
6908 if i is None:
6909 return self.getTokens(Python3Parser.COLON)
6910 else:
6911 return self.getToken(Python3Parser.COLON, i)
6913 def POWER(self, i:int=None):
6914 if i is None:
6915 return self.getTokens(Python3Parser.POWER)
6916 else:
6917 return self.getToken(Python3Parser.POWER, i)
6919 def expr(self, i:int=None):
6920 if i is None:
6921 return self.getTypedRuleContexts(Python3Parser.ExprContext)
6922 else:
6923 return self.getTypedRuleContext(Python3Parser.ExprContext,i)
6926 def comp_for(self):
6927 return self.getTypedRuleContext(Python3Parser.Comp_forContext,0)
6930 def star_expr(self, i:int=None):
6931 if i is None:
6932 return self.getTypedRuleContexts(Python3Parser.Star_exprContext)
6933 else:
6934 return self.getTypedRuleContext(Python3Parser.Star_exprContext,i)
6937 def COMMA(self, i:int=None):
6938 if i is None:
6939 return self.getTokens(Python3Parser.COMMA)
6940 else:
6941 return self.getToken(Python3Parser.COMMA, i)
6943 def getRuleIndex(self):
6944 return Python3Parser.RULE_dictorsetmaker
6946 def enterRule(self, listener:ParseTreeListener):
6947 if hasattr( listener, "enterDictorsetmaker" ):
6948 listener.enterDictorsetmaker(self)
6950 def exitRule(self, listener:ParseTreeListener):
6951 if hasattr( listener, "exitDictorsetmaker" ):
6952 listener.exitDictorsetmaker(self)
6957 def dictorsetmaker(self):
6959 localctx = Python3Parser.DictorsetmakerContext(self, self._ctx, self.state)
6960 self.enterRule(localctx, 152, self.RULE_dictorsetmaker)
6961 self._la = 0 # Token type
6962 try:
6963 self.enterOuterAlt(localctx, 1)
6964 self.state = 1034
6965 self._errHandler.sync(self)
6966 la_ = self._interp.adaptivePredict(self._input,153,self._ctx)
6967 if la_ == 1:
6968 self.state = 992
6969 self._errHandler.sync(self)
6970 token = self._input.LA(1)
6971 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]:
6972 self.state = 986
6973 self.test()
6974 self.state = 987
6975 self.match(Python3Parser.COLON)
6976 self.state = 988
6977 self.test()
6978 pass
6979 elif token in [Python3Parser.POWER]:
6980 self.state = 990
6981 self.match(Python3Parser.POWER)
6982 self.state = 991
6983 self.expr()
6984 pass
6985 else:
6986 raise NoViableAltException(self)
6988 self.state = 1012
6989 self._errHandler.sync(self)
6990 token = self._input.LA(1)
6991 if token in [Python3Parser.FOR, Python3Parser.ASYNC]:
6992 self.state = 994
6993 self.comp_for()
6994 pass
6995 elif token in [Python3Parser.COMMA, Python3Parser.CLOSE_BRACE]:
6996 self.state = 1006
6997 self._errHandler.sync(self)
6998 _alt = self._interp.adaptivePredict(self._input,145,self._ctx)
6999 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
7000 if _alt==1:
7001 self.state = 995
7002 self.match(Python3Parser.COMMA)
7003 self.state = 1002
7004 self._errHandler.sync(self)
7005 token = self._input.LA(1)
7006 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]:
7007 self.state = 996
7008 self.test()
7009 self.state = 997
7010 self.match(Python3Parser.COLON)
7011 self.state = 998
7012 self.test()
7013 pass
7014 elif token in [Python3Parser.POWER]:
7015 self.state = 1000
7016 self.match(Python3Parser.POWER)
7017 self.state = 1001
7018 self.expr()
7019 pass
7020 else:
7021 raise NoViableAltException(self)
7023 self.state = 1008
7024 self._errHandler.sync(self)
7025 _alt = self._interp.adaptivePredict(self._input,145,self._ctx)
7027 self.state = 1010
7028 self._errHandler.sync(self)
7029 _la = self._input.LA(1)
7030 if _la==Python3Parser.COMMA:
7031 self.state = 1009
7032 self.match(Python3Parser.COMMA)
7035 pass
7036 else:
7037 raise NoViableAltException(self)
7039 pass
7041 elif la_ == 2:
7042 self.state = 1016
7043 self._errHandler.sync(self)
7044 token = self._input.LA(1)
7045 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]:
7046 self.state = 1014
7047 self.test()
7048 pass
7049 elif token in [Python3Parser.STAR]:
7050 self.state = 1015
7051 self.star_expr()
7052 pass
7053 else:
7054 raise NoViableAltException(self)
7056 self.state = 1032
7057 self._errHandler.sync(self)
7058 token = self._input.LA(1)
7059 if token in [Python3Parser.FOR, Python3Parser.ASYNC]:
7060 self.state = 1018
7061 self.comp_for()
7062 pass
7063 elif token in [Python3Parser.COMMA, Python3Parser.CLOSE_BRACE]:
7064 self.state = 1026
7065 self._errHandler.sync(self)
7066 _alt = self._interp.adaptivePredict(self._input,150,self._ctx)
7067 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
7068 if _alt==1:
7069 self.state = 1019
7070 self.match(Python3Parser.COMMA)
7071 self.state = 1022
7072 self._errHandler.sync(self)
7073 token = self._input.LA(1)
7074 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]:
7075 self.state = 1020
7076 self.test()
7077 pass
7078 elif token in [Python3Parser.STAR]:
7079 self.state = 1021
7080 self.star_expr()
7081 pass
7082 else:
7083 raise NoViableAltException(self)
7085 self.state = 1028
7086 self._errHandler.sync(self)
7087 _alt = self._interp.adaptivePredict(self._input,150,self._ctx)
7089 self.state = 1030
7090 self._errHandler.sync(self)
7091 _la = self._input.LA(1)
7092 if _la==Python3Parser.COMMA:
7093 self.state = 1029
7094 self.match(Python3Parser.COMMA)
7097 pass
7098 else:
7099 raise NoViableAltException(self)
7101 pass
7104 except RecognitionException as re:
7105 localctx.exception = re
7106 self._errHandler.reportError(self, re)
7107 self._errHandler.recover(self, re)
7108 finally:
7109 self.exitRule()
7110 return localctx
7113 class ClassdefContext(ParserRuleContext):
7115 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
7116 super().__init__(parent, invokingState)
7117 self.parser = parser
7119 def CLASS(self):
7120 return self.getToken(Python3Parser.CLASS, 0)
7122 def NAME(self):
7123 return self.getToken(Python3Parser.NAME, 0)
7125 def COLON(self):
7126 return self.getToken(Python3Parser.COLON, 0)
7128 def suite(self):
7129 return self.getTypedRuleContext(Python3Parser.SuiteContext,0)
7132 def OPEN_PAREN(self):
7133 return self.getToken(Python3Parser.OPEN_PAREN, 0)
7135 def CLOSE_PAREN(self):
7136 return self.getToken(Python3Parser.CLOSE_PAREN, 0)
7138 def arglist(self):
7139 return self.getTypedRuleContext(Python3Parser.ArglistContext,0)
7142 def getRuleIndex(self):
7143 return Python3Parser.RULE_classdef
7145 def enterRule(self, listener:ParseTreeListener):
7146 if hasattr( listener, "enterClassdef" ):
7147 listener.enterClassdef(self)
7149 def exitRule(self, listener:ParseTreeListener):
7150 if hasattr( listener, "exitClassdef" ):
7151 listener.exitClassdef(self)
7156 def classdef(self):
7158 localctx = Python3Parser.ClassdefContext(self, self._ctx, self.state)
7159 self.enterRule(localctx, 154, self.RULE_classdef)
7160 self._la = 0 # Token type
7161 try:
7162 self.enterOuterAlt(localctx, 1)
7163 self.state = 1036
7164 self.match(Python3Parser.CLASS)
7165 self.state = 1037
7166 self.match(Python3Parser.NAME)
7167 self.state = 1043
7168 self._errHandler.sync(self)
7169 _la = self._input.LA(1)
7170 if _la==Python3Parser.OPEN_PAREN:
7171 self.state = 1038
7172 self.match(Python3Parser.OPEN_PAREN)
7173 self.state = 1040
7174 self._errHandler.sync(self)
7175 _la = self._input.LA(1)
7176 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):
7177 self.state = 1039
7178 self.arglist()
7181 self.state = 1042
7182 self.match(Python3Parser.CLOSE_PAREN)
7185 self.state = 1045
7186 self.match(Python3Parser.COLON)
7187 self.state = 1046
7188 self.suite()
7189 except RecognitionException as re:
7190 localctx.exception = re
7191 self._errHandler.reportError(self, re)
7192 self._errHandler.recover(self, re)
7193 finally:
7194 self.exitRule()
7195 return localctx
7198 class ArglistContext(ParserRuleContext):
7200 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
7201 super().__init__(parent, invokingState)
7202 self.parser = parser
7204 def argument(self, i:int=None):
7205 if i is None:
7206 return self.getTypedRuleContexts(Python3Parser.ArgumentContext)
7207 else:
7208 return self.getTypedRuleContext(Python3Parser.ArgumentContext,i)
7211 def COMMA(self, i:int=None):
7212 if i is None:
7213 return self.getTokens(Python3Parser.COMMA)
7214 else:
7215 return self.getToken(Python3Parser.COMMA, i)
7217 def getRuleIndex(self):
7218 return Python3Parser.RULE_arglist
7220 def enterRule(self, listener:ParseTreeListener):
7221 if hasattr( listener, "enterArglist" ):
7222 listener.enterArglist(self)
7224 def exitRule(self, listener:ParseTreeListener):
7225 if hasattr( listener, "exitArglist" ):
7226 listener.exitArglist(self)
7231 def arglist(self):
7233 localctx = Python3Parser.ArglistContext(self, self._ctx, self.state)
7234 self.enterRule(localctx, 156, self.RULE_arglist)
7235 self._la = 0 # Token type
7236 try:
7237 self.enterOuterAlt(localctx, 1)
7238 self.state = 1048
7239 self.argument()
7240 self.state = 1053
7241 self._errHandler.sync(self)
7242 _alt = self._interp.adaptivePredict(self._input,156,self._ctx)
7243 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
7244 if _alt==1:
7245 self.state = 1049
7246 self.match(Python3Parser.COMMA)
7247 self.state = 1050
7248 self.argument()
7249 self.state = 1055
7250 self._errHandler.sync(self)
7251 _alt = self._interp.adaptivePredict(self._input,156,self._ctx)
7253 self.state = 1057
7254 self._errHandler.sync(self)
7255 _la = self._input.LA(1)
7256 if _la==Python3Parser.COMMA:
7257 self.state = 1056
7258 self.match(Python3Parser.COMMA)
7261 except RecognitionException as re:
7262 localctx.exception = re
7263 self._errHandler.reportError(self, re)
7264 self._errHandler.recover(self, re)
7265 finally:
7266 self.exitRule()
7267 return localctx
7270 class ArgumentContext(ParserRuleContext):
7272 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
7273 super().__init__(parent, invokingState)
7274 self.parser = parser
7276 def test(self, i:int=None):
7277 if i is None:
7278 return self.getTypedRuleContexts(Python3Parser.TestContext)
7279 else:
7280 return self.getTypedRuleContext(Python3Parser.TestContext,i)
7283 def ASSIGN(self):
7284 return self.getToken(Python3Parser.ASSIGN, 0)
7286 def POWER(self):
7287 return self.getToken(Python3Parser.POWER, 0)
7289 def STAR(self):
7290 return self.getToken(Python3Parser.STAR, 0)
7292 def comp_for(self):
7293 return self.getTypedRuleContext(Python3Parser.Comp_forContext,0)
7296 def getRuleIndex(self):
7297 return Python3Parser.RULE_argument
7299 def enterRule(self, listener:ParseTreeListener):
7300 if hasattr( listener, "enterArgument" ):
7301 listener.enterArgument(self)
7303 def exitRule(self, listener:ParseTreeListener):
7304 if hasattr( listener, "exitArgument" ):
7305 listener.exitArgument(self)
7310 def argument(self):
7312 localctx = Python3Parser.ArgumentContext(self, self._ctx, self.state)
7313 self.enterRule(localctx, 158, self.RULE_argument)
7314 self._la = 0 # Token type
7315 try:
7316 self.enterOuterAlt(localctx, 1)
7317 self.state = 1071
7318 self._errHandler.sync(self)
7319 la_ = self._interp.adaptivePredict(self._input,159,self._ctx)
7320 if la_ == 1:
7321 self.state = 1059
7322 self.test()
7323 self.state = 1061
7324 self._errHandler.sync(self)
7325 _la = self._input.LA(1)
7326 if _la==Python3Parser.FOR or _la==Python3Parser.ASYNC:
7327 self.state = 1060
7328 self.comp_for()
7331 pass
7333 elif la_ == 2:
7334 self.state = 1063
7335 self.test()
7336 self.state = 1064
7337 self.match(Python3Parser.ASSIGN)
7338 self.state = 1065
7339 self.test()
7340 pass
7342 elif la_ == 3:
7343 self.state = 1067
7344 self.match(Python3Parser.POWER)
7345 self.state = 1068
7346 self.test()
7347 pass
7349 elif la_ == 4:
7350 self.state = 1069
7351 self.match(Python3Parser.STAR)
7352 self.state = 1070
7353 self.test()
7354 pass
7357 except RecognitionException as re:
7358 localctx.exception = re
7359 self._errHandler.reportError(self, re)
7360 self._errHandler.recover(self, re)
7361 finally:
7362 self.exitRule()
7363 return localctx
7366 class Comp_iterContext(ParserRuleContext):
7368 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
7369 super().__init__(parent, invokingState)
7370 self.parser = parser
7372 def comp_for(self):
7373 return self.getTypedRuleContext(Python3Parser.Comp_forContext,0)
7376 def comp_if(self):
7377 return self.getTypedRuleContext(Python3Parser.Comp_ifContext,0)
7380 def getRuleIndex(self):
7381 return Python3Parser.RULE_comp_iter
7383 def enterRule(self, listener:ParseTreeListener):
7384 if hasattr( listener, "enterComp_iter" ):
7385 listener.enterComp_iter(self)
7387 def exitRule(self, listener:ParseTreeListener):
7388 if hasattr( listener, "exitComp_iter" ):
7389 listener.exitComp_iter(self)
7394 def comp_iter(self):
7396 localctx = Python3Parser.Comp_iterContext(self, self._ctx, self.state)
7397 self.enterRule(localctx, 160, self.RULE_comp_iter)
7398 try:
7399 self.state = 1075
7400 self._errHandler.sync(self)
7401 token = self._input.LA(1)
7402 if token in [Python3Parser.FOR, Python3Parser.ASYNC]:
7403 self.enterOuterAlt(localctx, 1)
7404 self.state = 1073
7405 self.comp_for()
7406 pass
7407 elif token in [Python3Parser.IF]:
7408 self.enterOuterAlt(localctx, 2)
7409 self.state = 1074
7410 self.comp_if()
7411 pass
7412 else:
7413 raise NoViableAltException(self)
7415 except RecognitionException as re:
7416 localctx.exception = re
7417 self._errHandler.reportError(self, re)
7418 self._errHandler.recover(self, re)
7419 finally:
7420 self.exitRule()
7421 return localctx
7424 class Comp_forContext(ParserRuleContext):
7426 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
7427 super().__init__(parent, invokingState)
7428 self.parser = parser
7430 def FOR(self):
7431 return self.getToken(Python3Parser.FOR, 0)
7433 def exprlist(self):
7434 return self.getTypedRuleContext(Python3Parser.ExprlistContext,0)
7437 def IN(self):
7438 return self.getToken(Python3Parser.IN, 0)
7440 def or_test(self):
7441 return self.getTypedRuleContext(Python3Parser.Or_testContext,0)
7444 def ASYNC(self):
7445 return self.getToken(Python3Parser.ASYNC, 0)
7447 def comp_iter(self):
7448 return self.getTypedRuleContext(Python3Parser.Comp_iterContext,0)
7451 def getRuleIndex(self):
7452 return Python3Parser.RULE_comp_for
7454 def enterRule(self, listener:ParseTreeListener):
7455 if hasattr( listener, "enterComp_for" ):
7456 listener.enterComp_for(self)
7458 def exitRule(self, listener:ParseTreeListener):
7459 if hasattr( listener, "exitComp_for" ):
7460 listener.exitComp_for(self)
7465 def comp_for(self):
7467 localctx = Python3Parser.Comp_forContext(self, self._ctx, self.state)
7468 self.enterRule(localctx, 162, self.RULE_comp_for)
7469 self._la = 0 # Token type
7470 try:
7471 self.enterOuterAlt(localctx, 1)
7472 self.state = 1078
7473 self._errHandler.sync(self)
7474 _la = self._input.LA(1)
7475 if _la==Python3Parser.ASYNC:
7476 self.state = 1077
7477 self.match(Python3Parser.ASYNC)
7480 self.state = 1080
7481 self.match(Python3Parser.FOR)
7482 self.state = 1081
7483 self.exprlist()
7484 self.state = 1082
7485 self.match(Python3Parser.IN)
7486 self.state = 1083
7487 self.or_test()
7488 self.state = 1085
7489 self._errHandler.sync(self)
7490 _la = self._input.LA(1)
7491 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.IF) | (1 << Python3Parser.FOR) | (1 << Python3Parser.ASYNC))) != 0):
7492 self.state = 1084
7493 self.comp_iter()
7496 except RecognitionException as re:
7497 localctx.exception = re
7498 self._errHandler.reportError(self, re)
7499 self._errHandler.recover(self, re)
7500 finally:
7501 self.exitRule()
7502 return localctx
7505 class Comp_ifContext(ParserRuleContext):
7507 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
7508 super().__init__(parent, invokingState)
7509 self.parser = parser
7511 def IF(self):
7512 return self.getToken(Python3Parser.IF, 0)
7514 def test_nocond(self):
7515 return self.getTypedRuleContext(Python3Parser.Test_nocondContext,0)
7518 def comp_iter(self):
7519 return self.getTypedRuleContext(Python3Parser.Comp_iterContext,0)
7522 def getRuleIndex(self):
7523 return Python3Parser.RULE_comp_if
7525 def enterRule(self, listener:ParseTreeListener):
7526 if hasattr( listener, "enterComp_if" ):
7527 listener.enterComp_if(self)
7529 def exitRule(self, listener:ParseTreeListener):
7530 if hasattr( listener, "exitComp_if" ):
7531 listener.exitComp_if(self)
7536 def comp_if(self):
7538 localctx = Python3Parser.Comp_ifContext(self, self._ctx, self.state)
7539 self.enterRule(localctx, 164, self.RULE_comp_if)
7540 self._la = 0 # Token type
7541 try:
7542 self.enterOuterAlt(localctx, 1)
7543 self.state = 1087
7544 self.match(Python3Parser.IF)
7545 self.state = 1088
7546 self.test_nocond()
7547 self.state = 1090
7548 self._errHandler.sync(self)
7549 _la = self._input.LA(1)
7550 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Python3Parser.IF) | (1 << Python3Parser.FOR) | (1 << Python3Parser.ASYNC))) != 0):
7551 self.state = 1089
7552 self.comp_iter()
7555 except RecognitionException as re:
7556 localctx.exception = re
7557 self._errHandler.reportError(self, re)
7558 self._errHandler.recover(self, re)
7559 finally:
7560 self.exitRule()
7561 return localctx
7564 class Encoding_declContext(ParserRuleContext):
7566 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
7567 super().__init__(parent, invokingState)
7568 self.parser = parser
7570 def NAME(self):
7571 return self.getToken(Python3Parser.NAME, 0)
7573 def getRuleIndex(self):
7574 return Python3Parser.RULE_encoding_decl
7576 def enterRule(self, listener:ParseTreeListener):
7577 if hasattr( listener, "enterEncoding_decl" ):
7578 listener.enterEncoding_decl(self)
7580 def exitRule(self, listener:ParseTreeListener):
7581 if hasattr( listener, "exitEncoding_decl" ):
7582 listener.exitEncoding_decl(self)
7587 def encoding_decl(self):
7589 localctx = Python3Parser.Encoding_declContext(self, self._ctx, self.state)
7590 self.enterRule(localctx, 166, self.RULE_encoding_decl)
7591 try:
7592 self.enterOuterAlt(localctx, 1)
7593 self.state = 1092
7594 self.match(Python3Parser.NAME)
7595 except RecognitionException as re:
7596 localctx.exception = re
7597 self._errHandler.reportError(self, re)
7598 self._errHandler.recover(self, re)
7599 finally:
7600 self.exitRule()
7601 return localctx
7604 class Yield_exprContext(ParserRuleContext):
7606 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
7607 super().__init__(parent, invokingState)
7608 self.parser = parser
7610 def YIELD(self):
7611 return self.getToken(Python3Parser.YIELD, 0)
7613 def yield_arg(self):
7614 return self.getTypedRuleContext(Python3Parser.Yield_argContext,0)
7617 def getRuleIndex(self):
7618 return Python3Parser.RULE_yield_expr
7620 def enterRule(self, listener:ParseTreeListener):
7621 if hasattr( listener, "enterYield_expr" ):
7622 listener.enterYield_expr(self)
7624 def exitRule(self, listener:ParseTreeListener):
7625 if hasattr( listener, "exitYield_expr" ):
7626 listener.exitYield_expr(self)
7631 def yield_expr(self):
7633 localctx = Python3Parser.Yield_exprContext(self, self._ctx, self.state)
7634 self.enterRule(localctx, 168, self.RULE_yield_expr)
7635 self._la = 0 # Token type
7636 try:
7637 self.enterOuterAlt(localctx, 1)
7638 self.state = 1094
7639 self.match(Python3Parser.YIELD)
7640 self.state = 1096
7641 self._errHandler.sync(self)
7642 _la = self._input.LA(1)
7643 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):
7644 self.state = 1095
7645 self.yield_arg()
7648 except RecognitionException as re:
7649 localctx.exception = re
7650 self._errHandler.reportError(self, re)
7651 self._errHandler.recover(self, re)
7652 finally:
7653 self.exitRule()
7654 return localctx
7657 class Yield_argContext(ParserRuleContext):
7659 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
7660 super().__init__(parent, invokingState)
7661 self.parser = parser
7663 def FROM(self):
7664 return self.getToken(Python3Parser.FROM, 0)
7666 def test(self):
7667 return self.getTypedRuleContext(Python3Parser.TestContext,0)
7670 def testlist(self):
7671 return self.getTypedRuleContext(Python3Parser.TestlistContext,0)
7674 def getRuleIndex(self):
7675 return Python3Parser.RULE_yield_arg
7677 def enterRule(self, listener:ParseTreeListener):
7678 if hasattr( listener, "enterYield_arg" ):
7679 listener.enterYield_arg(self)
7681 def exitRule(self, listener:ParseTreeListener):
7682 if hasattr( listener, "exitYield_arg" ):
7683 listener.exitYield_arg(self)
7688 def yield_arg(self):
7690 localctx = Python3Parser.Yield_argContext(self, self._ctx, self.state)
7691 self.enterRule(localctx, 170, self.RULE_yield_arg)
7692 try:
7693 self.state = 1101
7694 self._errHandler.sync(self)
7695 token = self._input.LA(1)
7696 if token in [Python3Parser.FROM]:
7697 self.enterOuterAlt(localctx, 1)
7698 self.state = 1098
7699 self.match(Python3Parser.FROM)
7700 self.state = 1099
7701 self.test()
7702 pass
7703 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]:
7704 self.enterOuterAlt(localctx, 2)
7705 self.state = 1100
7706 self.testlist()
7707 pass
7708 else:
7709 raise NoViableAltException(self)
7711 except RecognitionException as re:
7712 localctx.exception = re
7713 self._errHandler.reportError(self, re)
7714 self._errHandler.recover(self, re)
7715 finally:
7716 self.exitRule()
7717 return localctx