# Generated from PythonParser.g4 by ANTLR 4.8
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
from typing import TextIO
else:
from typing.io import TextIO
if __name__ is not None and "." in __name__:
from .PythonParserBase import PythonParserBase
else:
from PythonParserBase import PythonParserBase
[docs]
def serializedATN():
with StringIO() as buf:
buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3f")
buf.write("\u03cc\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
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")
buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
buf.write(";\4<\t<\3\2\3\2\3\2\5\2|\n\2\3\2\3\2\3\3\3\3\3\3\3\3\3")
buf.write("\3\5\3\u0085\n\3\3\4\3\4\6\4\u0089\n\4\r\4\16\4\u008a")
buf.write("\3\5\3\5\7\5\u008f\n\5\f\5\16\5\u0092\13\5\3\6\3\6\5\6")
buf.write("\u0096\n\6\3\7\3\7\3\7\3\7\3\7\7\7\u009d\n\7\f\7\16\7")
buf.write("\u00a0\13\7\3\7\5\7\u00a3\n\7\3\7\3\7\3\7\3\7\3\7\5\7")
buf.write("\u00aa\n\7\3\7\5\7\u00ad\n\7\3\7\3\7\3\7\3\7\3\7\3\7\3")
buf.write("\7\5\7\u00b6\n\7\3\7\3\7\3\7\3\7\6\7\u00bc\n\7\r\7\16")
buf.write("\7\u00bd\3\7\5\7\u00c1\n\7\3\7\5\7\u00c4\n\7\3\7\5\7\u00c7")
buf.write("\n\7\3\7\5\7\u00ca\n\7\3\7\3\7\3\7\3\7\7\7\u00d0\n\7\f")
buf.write("\7\16\7\u00d3\13\7\3\7\3\7\3\7\3\7\7\7\u00d9\n\7\f\7\16")
buf.write("\7\u00dc\13\7\3\7\3\7\5\7\u00e0\n\7\5\7\u00e2\n\7\3\b")
buf.write("\3\b\3\b\3\b\6\b\u00e8\n\b\r\b\16\b\u00e9\3\b\3\b\5\b")
buf.write("\u00ee\n\b\3\t\3\t\3\t\3\t\5\t\u00f4\n\t\3\t\5\t\u00f7")
buf.write("\n\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3")
buf.write("\f\3\f\3\f\3\f\3\r\3\r\3\r\5\r\u010b\n\r\3\16\3\16\3\16")
buf.write("\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\5\16\u0119")
buf.write("\n\16\5\16\u011b\n\16\3\16\3\16\3\16\3\17\3\17\3\17\3")
buf.write("\17\5\17\u0124\n\17\3\17\5\17\u0127\n\17\3\17\3\17\3\17")
buf.write("\3\20\5\20\u012d\n\20\3\20\3\20\3\20\3\20\5\20\u0133\n")
buf.write("\20\3\20\3\20\3\20\5\20\u0138\n\20\3\20\3\20\3\20\3\21")
buf.write("\3\21\3\21\5\21\u0140\n\21\3\21\3\21\3\21\5\21\u0145\n")
buf.write("\21\3\21\3\21\5\21\u0149\n\21\3\21\5\21\u014c\n\21\3\21")
buf.write("\5\21\u014f\n\21\3\21\3\21\5\21\u0153\n\21\5\21\u0155")
buf.write("\n\21\3\22\3\22\3\22\3\23\3\23\3\23\3\24\3\24\3\24\7\24")
buf.write("\u0160\n\24\f\24\16\24\u0163\13\24\3\25\3\25\3\25\5\25")
buf.write("\u0168\n\25\3\25\5\25\u016b\n\25\3\26\3\26\3\26\5\26\u0170")
buf.write("\n\26\3\27\3\27\3\27\7\27\u0175\n\27\f\27\16\27\u0178")
buf.write("\13\27\3\27\5\27\u017b\n\27\3\27\3\27\3\30\3\30\5\30\u0181")
buf.write("\n\30\3\30\3\30\3\30\3\30\3\30\7\30\u0188\n\30\f\30\16")
buf.write("\30\u018b\13\30\3\30\5\30\u018e\n\30\3\30\3\30\3\30\3")
buf.write("\30\6\30\u0194\n\30\r\30\16\30\u0195\3\30\5\30\u0199\n")
buf.write("\30\5\30\u019b\n\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30")
buf.write("\3\30\3\30\5\30\u01a6\n\30\3\30\3\30\3\30\3\30\3\30\3")
buf.write("\30\5\30\u01ae\n\30\5\30\u01b0\n\30\5\30\u01b2\n\30\3")
buf.write("\30\3\30\5\30\u01b6\n\30\3\30\3\30\3\30\3\30\3\30\7\30")
buf.write("\u01bd\n\30\f\30\16\30\u01c0\13\30\3\30\3\30\6\30\u01c4")
buf.write("\n\30\r\30\16\30\u01c5\5\30\u01c8\n\30\3\30\3\30\3\30")
buf.write("\3\30\3\30\3\30\3\30\5\30\u01d1\n\30\3\30\3\30\3\30\3")
buf.write("\30\7\30\u01d7\n\30\f\30\16\30\u01da\13\30\3\30\3\30\3")
buf.write("\30\3\30\3\30\3\30\3\30\5\30\u01e3\n\30\5\30\u01e5\n\30")
buf.write("\3\30\3\30\3\30\3\30\3\30\3\30\5\30\u01ed\n\30\3\30\3")
buf.write("\30\3\30\3\30\3\30\7\30\u01f4\n\30\f\30\16\30\u01f7\13")
buf.write("\30\3\30\3\30\5\30\u01fb\n\30\3\31\3\31\5\31\u01ff\n\31")
buf.write("\3\31\3\31\6\31\u0203\n\31\r\31\16\31\u0204\3\31\3\31")
buf.write("\5\31\u0209\n\31\3\31\5\31\u020c\n\31\3\32\3\32\3\32\3")
buf.write("\33\3\33\3\33\3\33\7\33\u0215\n\33\f\33\16\33\u0218\13")
buf.write("\33\3\33\3\33\5\33\u021c\n\33\3\33\5\33\u021f\n\33\3\33")
buf.write("\3\33\3\33\3\33\3\33\5\33\u0226\n\33\3\33\3\33\3\33\3")
buf.write("\33\3\33\5\33\u022d\n\33\5\33\u022f\n\33\3\34\3\34\3\34")
buf.write("\7\34\u0234\n\34\f\34\16\34\u0237\13\34\3\34\5\34\u023a")
buf.write("\n\34\3\35\3\35\3\35\7\35\u023f\n\35\f\35\16\35\u0242")
buf.write("\13\35\3\35\5\35\u0245\n\35\3\36\3\36\3\36\5\36\u024a")
buf.write("\n\36\3\37\3\37\3\37\7\37\u024f\n\37\f\37\16\37\u0252")
buf.write("\13\37\3 \3 \3 \5 \u0257\n \3!\3!\3!\3!\3!\3!\5!\u025f")
buf.write("\n!\3!\3!\5!\u0263\n!\3!\3!\5!\u0267\n!\3\"\3\"\3\"\5")
buf.write("\"\u026c\n\"\3\"\3\"\3\"\5\"\u0271\n\"\3\"\3\"\5\"\u0275")
buf.write("\n\"\3\"\5\"\u0278\n\"\3\"\5\"\u027b\n\"\3\"\3\"\5\"\u027f")
buf.write("\n\"\5\"\u0281\n\"\3#\3#\3#\7#\u0286\n#\f#\16#\u0289\13")
buf.write("#\3$\3$\3$\5$\u028e\n$\3$\5$\u0291\n$\3%\3%\3%\3&\3&\3")
buf.write("&\3\'\3\'\3\'\3\'\5\'\u029d\n\'\3\'\3\'\3\'\3\'\3\'\3")
buf.write("\'\7\'\u02a5\n\'\f\'\16\'\u02a8\13\'\3(\3(\3(\3(\3(\3")
buf.write("(\3(\3(\3(\3(\3(\3(\5(\u02b6\n(\3(\3(\3(\5(\u02bb\n(\5")
buf.write("(\u02bd\n(\3(\7(\u02c0\n(\f(\16(\u02c3\13(\3)\3)\5)\u02c7")
buf.write("\n)\3)\3)\7)\u02cb\n)\f)\16)\u02ce\13)\3)\3)\5)\u02d2")
buf.write("\n)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3")
buf.write(")\3)\3)\3)\3)\7)\u02e9\n)\f)\16)\u02ec\13)\3*\3*\3*\5")
buf.write("*\u02f1\n*\3*\3*\3*\5*\u02f6\n*\3*\3*\3*\5*\u02fb\n*\3")
buf.write("*\3*\3*\3*\5*\u0301\n*\3*\3*\3*\3*\3*\3*\3*\5*\u030a\n")
buf.write("*\3*\3*\3*\6*\u030f\n*\r*\16*\u0310\5*\u0313\n*\3+\3+")
buf.write("\3+\3+\3+\3+\5+\u031b\n+\3+\3+\3+\3+\3+\3+\3+\5+\u0324")
buf.write("\n+\7+\u0326\n+\f+\16+\u0329\13+\3+\5+\u032c\n+\3+\3+")
buf.write("\3+\3+\3+\3+\5+\u0334\n+\3,\3,\5,\u0338\n,\3,\3,\3,\3")
buf.write(",\5,\u033e\n,\7,\u0340\n,\f,\16,\u0343\13,\3,\5,\u0346")
buf.write("\n,\5,\u0348\n,\3-\3-\3-\7-\u034d\n-\f-\16-\u0350\13-")
buf.write("\3-\5-\u0353\n-\3.\3.\3.\3.\3.\3.\7.\u035b\n.\f.\16.\u035e")
buf.write("\13.\3/\3/\3\60\3\60\3\60\5\60\u0365\n\60\3\61\3\61\3")
buf.write("\62\3\62\5\62\u036b\n\62\3\63\3\63\3\63\5\63\u0370\n\63")
buf.write("\3\64\3\64\3\64\5\64\u0375\n\64\3\64\5\64\u0378\n\64\3")
buf.write("\65\3\65\5\65\u037c\n\65\3\65\3\65\3\65\3\65\3\65\5\65")
buf.write("\u0383\n\65\3\66\3\66\3\66\7\66\u0388\n\66\f\66\16\66")
buf.write("\u038b\13\66\3\66\5\66\u038e\n\66\3\67\3\67\3\67\3\67")
buf.write("\5\67\u0394\n\67\3\67\3\67\5\67\u0398\n\67\38\38\38\7")
buf.write("8\u039d\n8\f8\168\u03a0\138\38\58\u03a3\n8\39\39\39\3")
buf.write("9\59\u03a9\n9\39\59\u03ac\n9\59\u03ae\n9\39\39\59\u03b2")
buf.write("\n9\39\59\u03b5\n9\59\u03b7\n9\3:\3:\5:\u03bb\n:\3;\3")
buf.write(";\3;\3;\3;\5;\u03c2\n;\3<\3<\3<\3<\5<\u03c8\n<\5<\u03ca")
buf.write("\n<\3<\2\6LNPZ=\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36")
buf.write(" \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprt")
buf.write("v\2\f\3\3\5\5\3\2+,\3\2HT\4\29:>>\5\2..;=FF\3\29:\3\2")
buf.write("\678\4\2)*bb\3\2VY\4\2..\62\62\2\u0459\2{\3\2\2\2\4\u0084")
buf.write("\3\2\2\2\6\u0088\3\2\2\2\b\u008c\3\2\2\2\n\u0095\3\2\2")
buf.write("\2\f\u00e1\3\2\2\2\16\u00ed\3\2\2\2\20\u00ef\3\2\2\2\22")
buf.write("\u00fa\3\2\2\2\24\u00ff\3\2\2\2\26\u0103\3\2\2\2\30\u0107")
buf.write("\3\2\2\2\32\u010c\3\2\2\2\34\u011f\3\2\2\2\36\u012c\3")
buf.write("\2\2\2 \u0154\3\2\2\2\"\u0156\3\2\2\2$\u0159\3\2\2\2&")
buf.write("\u015c\3\2\2\2(\u016a\3\2\2\2*\u016c\3\2\2\2,\u0171\3")
buf.write("\2\2\2.\u01fa\3\2\2\2\60\u020b\3\2\2\2\62\u020d\3\2\2")
buf.write("\2\64\u022e\3\2\2\2\66\u0230\3\2\2\28\u023b\3\2\2\2:\u0246")
buf.write("\3\2\2\2<\u024b\3\2\2\2>\u0253\3\2\2\2@\u0266\3\2\2\2")
buf.write("B\u0280\3\2\2\2D\u0282\3\2\2\2F\u0290\3\2\2\2H\u0292\3")
buf.write("\2\2\2J\u0295\3\2\2\2L\u029c\3\2\2\2N\u02a9\3\2\2\2P\u02d1")
buf.write("\3\2\2\2R\u0312\3\2\2\2T\u0333\3\2\2\2V\u0337\3\2\2\2")
buf.write("X\u0349\3\2\2\2Z\u0354\3\2\2\2\\\u035f\3\2\2\2^\u0364")
buf.write("\3\2\2\2`\u0366\3\2\2\2b\u0368\3\2\2\2d\u036f\3\2\2\2")
buf.write("f\u0377\3\2\2\2h\u0382\3\2\2\2j\u0384\3\2\2\2l\u0397\3")
buf.write("\2\2\2n\u0399\3\2\2\2p\u03b6\3\2\2\2r\u03b8\3\2\2\2t\u03bc")
buf.write("\3\2\2\2v\u03c9\3\2\2\2x|\5\4\3\2y|\5\6\4\2z|\5\b\5\2")
buf.write("{x\3\2\2\2{y\3\2\2\2{z\3\2\2\2{|\3\2\2\2|}\3\2\2\2}~\7")
buf.write("\2\2\3~\3\3\2\2\2\177\u0085\7\5\2\2\u0080\u0085\5,\27")
buf.write("\2\u0081\u0082\5\f\7\2\u0082\u0083\7\5\2\2\u0083\u0085")
buf.write("\3\2\2\2\u0084\177\3\2\2\2\u0084\u0080\3\2\2\2\u0084\u0081")
buf.write("\3\2\2\2\u0085\5\3\2\2\2\u0086\u0089\7\5\2\2\u0087\u0089")
buf.write("\5\n\6\2\u0088\u0086\3\2\2\2\u0088\u0087\3\2\2\2\u0089")
buf.write("\u008a\3\2\2\2\u008a\u0088\3\2\2\2\u008a\u008b\3\2\2\2")
buf.write("\u008b\7\3\2\2\2\u008c\u0090\5X-\2\u008d\u008f\7\5\2\2")
buf.write("\u008e\u008d\3\2\2\2\u008f\u0092\3\2\2\2\u0090\u008e\3")
buf.write("\2\2\2\u0090\u0091\3\2\2\2\u0091\t\3\2\2\2\u0092\u0090")
buf.write("\3\2\2\2\u0093\u0096\5,\27\2\u0094\u0096\5\f\7\2\u0095")
buf.write("\u0093\3\2\2\2\u0095\u0094\3\2\2\2\u0096\13\3\2\2\2\u0097")
buf.write("\u0098\7\17\2\2\u0098\u0099\5@!\2\u0099\u009a\7\60\2\2")
buf.write("\u009a\u009e\5\16\b\2\u009b\u009d\5\22\n\2\u009c\u009b")
buf.write("\3\2\2\2\u009d\u00a0\3\2\2\2\u009e\u009c\3\2\2\2\u009e")
buf.write("\u009f\3\2\2\2\u009f\u00a2\3\2\2\2\u00a0\u009e\3\2\2\2")
buf.write("\u00a1\u00a3\5\24\13\2\u00a2\u00a1\3\2\2\2\u00a2\u00a3")
buf.write("\3\2\2\2\u00a3\u00e2\3\2\2\2\u00a4\u00a5\7\22\2\2\u00a5")
buf.write("\u00a6\5@!\2\u00a6\u00a7\7\60\2\2\u00a7\u00a9\5\16\b\2")
buf.write("\u00a8\u00aa\5\24\13\2\u00a9\u00a8\3\2\2\2\u00a9\u00aa")
buf.write("\3\2\2\2\u00aa\u00e2\3\2\2\2\u00ab\u00ad\7%\2\2\u00ac")
buf.write("\u00ab\3\2\2\2\u00ac\u00ad\3\2\2\2\u00ad\u00ae\3\2\2\2")
buf.write("\u00ae\u00af\7\23\2\2\u00af\u00b0\5\66\34\2\u00b0\u00b1")
buf.write("\7\24\2\2\u00b1\u00b2\5X-\2\u00b2\u00b3\7\60\2\2\u00b3")
buf.write("\u00b5\5\16\b\2\u00b4\u00b6\5\24\13\2\u00b5\u00b4\3\2")
buf.write("\2\2\u00b5\u00b6\3\2\2\2\u00b6\u00e2\3\2\2\2\u00b7\u00b8")
buf.write("\7\25\2\2\u00b8\u00b9\7\60\2\2\u00b9\u00c6\5\16\b\2\u00ba")
buf.write("\u00bc\5\32\16\2\u00bb\u00ba\3\2\2\2\u00bc\u00bd\3\2\2")
buf.write("\2\u00bd\u00bb\3\2\2\2\u00bd\u00be\3\2\2\2\u00be\u00c0")
buf.write("\3\2\2\2\u00bf\u00c1\5\24\13\2\u00c0\u00bf\3\2\2\2\u00c0")
buf.write("\u00c1\3\2\2\2\u00c1\u00c3\3\2\2\2\u00c2\u00c4\5\26\f")
buf.write("\2\u00c3\u00c2\3\2\2\2\u00c3\u00c4\3\2\2\2\u00c4\u00c7")
buf.write("\3\2\2\2\u00c5\u00c7\5\26\f\2\u00c6\u00bb\3\2\2\2\u00c6")
buf.write("\u00c5\3\2\2\2\u00c7\u00e2\3\2\2\2\u00c8\u00ca\7%\2\2")
buf.write("\u00c9\u00c8\3\2\2\2\u00c9\u00ca\3\2\2\2\u00ca\u00cb\3")
buf.write("\2\2\2\u00cb\u00cc\7\30\2\2\u00cc\u00d1\5\30\r\2\u00cd")
buf.write("\u00ce\7/\2\2\u00ce\u00d0\5\30\r\2\u00cf\u00cd\3\2\2\2")
buf.write("\u00d0\u00d3\3\2\2\2\u00d1\u00cf\3\2\2\2\u00d1\u00d2\3")
buf.write("\2\2\2\u00d2\u00d4\3\2\2\2\u00d3\u00d1\3\2\2\2\u00d4\u00d5")
buf.write("\7\60\2\2\u00d5\u00d6\5\16\b\2\u00d6\u00e2\3\2\2\2\u00d7")
buf.write("\u00d9\5\20\t\2\u00d8\u00d7\3\2\2\2\u00d9\u00dc\3\2\2")
buf.write("\2\u00da\u00d8\3\2\2\2\u00da\u00db\3\2\2\2\u00db\u00df")
buf.write("\3\2\2\2\u00dc\u00da\3\2\2\2\u00dd\u00e0\5\34\17\2\u00de")
buf.write("\u00e0\5\36\20\2\u00df\u00dd\3\2\2\2\u00df\u00de\3\2\2")
buf.write("\2\u00e0\u00e2\3\2\2\2\u00e1\u0097\3\2\2\2\u00e1\u00a4")
buf.write("\3\2\2\2\u00e1\u00ac\3\2\2\2\u00e1\u00b7\3\2\2\2\u00e1")
buf.write("\u00c9\3\2\2\2\u00e1\u00da\3\2\2\2\u00e2\r\3\2\2\2\u00e3")
buf.write("\u00ee\5,\27\2\u00e4\u00e5\7\5\2\2\u00e5\u00e7\7\3\2\2")
buf.write("\u00e6\u00e8\5\n\6\2\u00e7\u00e6\3\2\2\2\u00e8\u00e9\3")
buf.write("\2\2\2\u00e9\u00e7\3\2\2\2\u00e9\u00ea\3\2\2\2\u00ea\u00eb")
buf.write("\3\2\2\2\u00eb\u00ec\7\4\2\2\u00ec\u00ee\3\2\2\2\u00ed")
buf.write("\u00e3\3\2\2\2\u00ed\u00e4\3\2\2\2\u00ee\17\3\2\2\2\u00ef")
buf.write("\u00f0\7F\2\2\u00f0\u00f6\5Z.\2\u00f1\u00f3\7\\\2\2\u00f2")
buf.write("\u00f4\5j\66\2\u00f3\u00f2\3\2\2\2\u00f3\u00f4\3\2\2\2")
buf.write("\u00f4\u00f5\3\2\2\2\u00f5\u00f7\7]\2\2\u00f6\u00f1\3")
buf.write("\2\2\2\u00f6\u00f7\3\2\2\2\u00f7\u00f8\3\2\2\2\u00f8\u00f9")
buf.write("\7\5\2\2\u00f9\21\3\2\2\2\u00fa\u00fb\7\20\2\2\u00fb\u00fc")
buf.write("\5@!\2\u00fc\u00fd\7\60\2\2\u00fd\u00fe\5\16\b\2\u00fe")
buf.write("\23\3\2\2\2\u00ff\u0100\7\21\2\2\u0100\u0101\7\60\2\2")
buf.write("\u0101\u0102\5\16\b\2\u0102\25\3\2\2\2\u0103\u0104\7\27")
buf.write("\2\2\u0104\u0105\7\60\2\2\u0105\u0106\5\16\b\2\u0106\27")
buf.write("\3\2\2\2\u0107\u010a\5@!\2\u0108\u0109\7\f\2\2\u0109\u010b")
buf.write("\5P)\2\u010a\u0108\3\2\2\2\u010a\u010b\3\2\2\2\u010b\31")
buf.write("\3\2\2\2\u010c\u011a\7\31\2\2\u010d\u0118\5@!\2\u010e")
buf.write("\u010f\6\16\2\2\u010f\u0110\7/\2\2\u0110\u0111\5\\/\2")
buf.write("\u0111\u0112\b\16\1\2\u0112\u0119\3\2\2\2\u0113\u0114")
buf.write("\6\16\3\2\u0114\u0115\7\f\2\2\u0115\u0116\5\\/\2\u0116")
buf.write("\u0117\b\16\1\2\u0117\u0119\3\2\2\2\u0118\u010e\3\2\2")
buf.write("\2\u0118\u0113\3\2\2\2\u0118\u0119\3\2\2\2\u0119\u011b")
buf.write("\3\2\2\2\u011a\u010d\3\2\2\2\u011a\u011b\3\2\2\2\u011b")
buf.write("\u011c\3\2\2\2\u011c\u011d\7\60\2\2\u011d\u011e\5\16\b")
buf.write("\2\u011e\33\3\2\2\2\u011f\u0120\7\37\2\2\u0120\u0126\5")
buf.write("\\/\2\u0121\u0123\7\\\2\2\u0122\u0124\5j\66\2\u0123\u0122")
buf.write("\3\2\2\2\u0123\u0124\3\2\2\2\u0124\u0125\3\2\2\2\u0125")
buf.write("\u0127\7]\2\2\u0126\u0121\3\2\2\2\u0126\u0127\3\2\2\2")
buf.write("\u0127\u0128\3\2\2\2\u0128\u0129\7\60\2\2\u0129\u012a")
buf.write("\5\16\b\2\u012a\35\3\2\2\2\u012b\u012d\7%\2\2\u012c\u012b")
buf.write("\3\2\2\2\u012c\u012d\3\2\2\2\u012d\u012e\3\2\2\2\u012e")
buf.write("\u012f\7\6\2\2\u012f\u0130\5\\/\2\u0130\u0132\7\\\2\2")
buf.write("\u0131\u0133\5 \21\2\u0132\u0131\3\2\2\2\u0132\u0133\3")
buf.write("\2\2\2\u0133\u0134\3\2\2\2\u0134\u0137\7]\2\2\u0135\u0136")
buf.write("\7G\2\2\u0136\u0138\5@!\2\u0137\u0135\3\2\2\2\u0137\u0138")
buf.write("\3\2\2\2\u0138\u0139\3\2\2\2\u0139\u013a\7\60\2\2\u013a")
buf.write("\u013b\5\16\b\2\u013b\37\3\2\2\2\u013c\u013d\5&\24\2\u013d")
buf.write("\u013e\7/\2\2\u013e\u0140\3\2\2\2\u013f\u013c\3\2\2\2")
buf.write("\u013f\u0140\3\2\2\2\u0140\u014b\3\2\2\2\u0141\u0144\5")
buf.write("\"\22\2\u0142\u0143\7/\2\2\u0143\u0145\5&\24\2\u0144\u0142")
buf.write("\3\2\2\2\u0144\u0145\3\2\2\2\u0145\u0148\3\2\2\2\u0146")
buf.write("\u0147\7/\2\2\u0147\u0149\5$\23\2\u0148\u0146\3\2\2\2")
buf.write("\u0148\u0149\3\2\2\2\u0149\u014c\3\2\2\2\u014a\u014c\5")
buf.write("$\23\2\u014b\u0141\3\2\2\2\u014b\u014a\3\2\2\2\u014c\u014e")
buf.write("\3\2\2\2\u014d\u014f\7/\2\2\u014e\u014d\3\2\2\2\u014e")
buf.write("\u014f\3\2\2\2\u014f\u0155\3\2\2\2\u0150\u0152\5&\24\2")
buf.write("\u0151\u0153\7/\2\2\u0152\u0151\3\2\2\2\u0152\u0153\3")
buf.write("\2\2\2\u0153\u0155\3\2\2\2\u0154\u013f\3\2\2\2\u0154\u0150")
buf.write("\3\2\2\2\u0155!\3\2\2\2\u0156\u0157\7.\2\2\u0157\u0158")
buf.write("\5*\26\2\u0158#\3\2\2\2\u0159\u015a\7\62\2\2\u015a\u015b")
buf.write("\5*\26\2\u015b%\3\2\2\2\u015c\u0161\5(\25\2\u015d\u015e")
buf.write("\7/\2\2\u015e\u0160\5(\25\2\u015f\u015d\3\2\2\2\u0160")
buf.write("\u0163\3\2\2\2\u0161\u015f\3\2\2\2\u0161\u0162\3\2\2\2")
buf.write("\u0162\'\3\2\2\2\u0163\u0161\3\2\2\2\u0164\u0167\5*\26")
buf.write("\2\u0165\u0166\7\63\2\2\u0166\u0168\5@!\2\u0167\u0165")
buf.write("\3\2\2\2\u0167\u0168\3\2\2\2\u0168\u016b\3\2\2\2\u0169")
buf.write("\u016b\7.\2\2\u016a\u0164\3\2\2\2\u016a\u0169\3\2\2\2")
buf.write("\u016b)\3\2\2\2\u016c\u016f\5\\/\2\u016d\u016e\7\60\2")
buf.write("\2\u016e\u0170\5@!\2\u016f\u016d\3\2\2\2\u016f\u0170\3")
buf.write("\2\2\2\u0170+\3\2\2\2\u0171\u0176\5.\30\2\u0172\u0173")
buf.write("\7\61\2\2\u0173\u0175\5.\30\2\u0174\u0172\3\2\2\2\u0175")
buf.write("\u0178\3\2\2\2\u0176\u0174\3\2\2\2\u0176\u0177\3\2\2\2")
buf.write("\u0177\u017a\3\2\2\2\u0178\u0176\3\2\2\2\u0179\u017b\7")
buf.write("\61\2\2\u017a\u0179\3\2\2\2\u017a\u017b\3\2\2\2\u017b")
buf.write("\u017c\3\2\2\2\u017c\u017d\t\2\2\2\u017d-\3\2\2\2\u017e")
buf.write("\u0180\5\60\31\2\u017f\u0181\5\64\33\2\u0180\u017f\3\2")
buf.write("\2\2\u0180\u0181\3\2\2\2\u0181\u01fb\3\2\2\2\u0182\u0183")
buf.write("\6\30\4\2\u0183\u019a\7\'\2\2\u0184\u0189\5@!\2\u0185")
buf.write("\u0186\7/\2\2\u0186\u0188\5@!\2\u0187\u0185\3\2\2\2\u0188")
buf.write("\u018b\3\2\2\2\u0189\u0187\3\2\2\2\u0189\u018a\3\2\2\2")
buf.write("\u018a\u018d\3\2\2\2\u018b\u0189\3\2\2\2\u018c\u018e\7")
buf.write("/\2\2\u018d\u018c\3\2\2\2\u018d\u018e\3\2\2\2\u018e\u019b")
buf.write("\3\2\2\2\u018f\u0190\78\2\2\u0190\u0193\5@!\2\u0191\u0192")
buf.write("\7/\2\2\u0192\u0194\5@!\2\u0193\u0191\3\2\2\2\u0194\u0195")
buf.write("\3\2\2\2\u0195\u0193\3\2\2\2\u0195\u0196\3\2\2\2\u0196")
buf.write("\u0198\3\2\2\2\u0197\u0199\7/\2\2\u0198\u0197\3\2\2\2")
buf.write("\u0198\u0199\3\2\2\2\u0199\u019b\3\2\2\2\u019a\u0184\3")
buf.write("\2\2\2\u019a\u018f\3\2\2\2\u019b\u019c\3\2\2\2\u019c\u019d")
buf.write("\b\30\1\2\u019d\u01fb\3\2\2\2\u019e\u019f\7!\2\2\u019f")
buf.write("\u01fb\5\66\34\2\u01a0\u01fb\7\"\2\2\u01a1\u01fb\7$\2")
buf.write("\2\u01a2\u01fb\7#\2\2\u01a3\u01a5\7\7\2\2\u01a4\u01a6")
buf.write("\5X-\2\u01a5\u01a4\3\2\2\2\u01a5\u01a6\3\2\2\2\u01a6\u01fb")
buf.write("\3\2\2\2\u01a7\u01b1\7\b\2\2\u01a8\u01af\5@!\2\u01a9\u01aa")
buf.write("\7/\2\2\u01aa\u01ad\5@!\2\u01ab\u01ac\7/\2\2\u01ac\u01ae")
buf.write("\5@!\2\u01ad\u01ab\3\2\2\2\u01ad\u01ae\3\2\2\2\u01ae\u01b0")
buf.write("\3\2\2\2\u01af\u01a9\3\2\2\2\u01af\u01b0\3\2\2\2\u01b0")
buf.write("\u01b2\3\2\2\2\u01b1\u01a8\3\2\2\2\u01b1\u01b2\3\2\2\2")
buf.write("\u01b2\u01b5\3\2\2\2\u01b3\u01b4\7\t\2\2\u01b4\u01b6\5")
buf.write("@!\2\u01b5\u01b3\3\2\2\2\u01b5\u01b6\3\2\2\2\u01b6\u01fb")
buf.write("\3\2\2\2\u01b7\u01fb\5b\62\2\u01b8\u01b9\7\n\2\2\u01b9")
buf.write("\u01fb\5<\37\2\u01ba\u01c7\7\t\2\2\u01bb\u01bd\t\3\2\2")
buf.write("\u01bc\u01bb\3\2\2\2\u01bd\u01c0\3\2\2\2\u01be\u01bc\3")
buf.write("\2\2\2\u01be\u01bf\3\2\2\2\u01bf\u01c1\3\2\2\2\u01c0\u01be")
buf.write("\3\2\2\2\u01c1\u01c8\5Z.\2\u01c2\u01c4\t\3\2\2\u01c3\u01c2")
buf.write("\3\2\2\2\u01c4\u01c5\3\2\2\2\u01c5\u01c3\3\2\2\2\u01c5")
buf.write("\u01c6\3\2\2\2\u01c6\u01c8\3\2\2\2\u01c7\u01be\3\2\2\2")
buf.write("\u01c7\u01c3\3\2\2\2\u01c8\u01c9\3\2\2\2\u01c9\u01d0\7")
buf.write("\n\2\2\u01ca\u01d1\7.\2\2\u01cb\u01cc\7\\\2\2\u01cc\u01cd")
buf.write("\58\35\2\u01cd\u01ce\7]\2\2\u01ce\u01d1\3\2\2\2\u01cf")
buf.write("\u01d1\58\35\2\u01d0\u01ca\3\2\2\2\u01d0\u01cb\3\2\2\2")
buf.write("\u01d0\u01cf\3\2\2\2\u01d1\u01fb\3\2\2\2\u01d2\u01d3\7")
buf.write("\r\2\2\u01d3\u01d8\5\\/\2\u01d4\u01d5\7/\2\2\u01d5\u01d7")
buf.write("\5\\/\2\u01d6\u01d4\3\2\2\2\u01d7\u01da\3\2\2\2\u01d8")
buf.write("\u01d6\3\2\2\2\u01d8\u01d9\3\2\2\2\u01d9\u01fb\3\2\2\2")
buf.write("\u01da\u01d8\3\2\2\2\u01db\u01dc\6\30\5\2\u01dc\u01dd")
buf.write("\7(\2\2\u01dd\u01e4\5P)\2\u01de\u01df\7\24\2\2\u01df\u01e2")
buf.write("\5@!\2\u01e0\u01e1\7/\2\2\u01e1\u01e3\5@!\2\u01e2\u01e0")
buf.write("\3\2\2\2\u01e2\u01e3\3\2\2\2\u01e3\u01e5\3\2\2\2\u01e4")
buf.write("\u01de\3\2\2\2\u01e4\u01e5\3\2\2\2\u01e5\u01e6\3\2\2\2")
buf.write("\u01e6\u01e7\b\30\1\2\u01e7\u01fb\3\2\2\2\u01e8\u01e9")
buf.write("\7\16\2\2\u01e9\u01ec\5@!\2\u01ea\u01eb\7/\2\2\u01eb\u01ed")
buf.write("\5@!\2\u01ec\u01ea\3\2\2\2\u01ec\u01ed\3\2\2\2\u01ed\u01fb")
buf.write("\3\2\2\2\u01ee\u01ef\6\30\6\2\u01ef\u01f0\7\13\2\2\u01f0")
buf.write("\u01f5\5\\/\2\u01f1\u01f2\7/\2\2\u01f2\u01f4\5\\/\2\u01f3")
buf.write("\u01f1\3\2\2\2\u01f4\u01f7\3\2\2\2\u01f5\u01f3\3\2\2\2")
buf.write("\u01f5\u01f6\3\2\2\2\u01f6\u01f8\3\2\2\2\u01f7\u01f5\3")
buf.write("\2\2\2\u01f8\u01f9\b\30\1\2\u01f9\u01fb\3\2\2\2\u01fa")
buf.write("\u017e\3\2\2\2\u01fa\u0182\3\2\2\2\u01fa\u019e\3\2\2\2")
buf.write("\u01fa\u01a0\3\2\2\2\u01fa\u01a1\3\2\2\2\u01fa\u01a2\3")
buf.write("\2\2\2\u01fa\u01a3\3\2\2\2\u01fa\u01a7\3\2\2\2\u01fa\u01b7")
buf.write("\3\2\2\2\u01fa\u01b8\3\2\2\2\u01fa\u01ba\3\2\2\2\u01fa")
buf.write("\u01d2\3\2\2\2\u01fa\u01db\3\2\2\2\u01fa\u01e8\3\2\2\2")
buf.write("\u01fa\u01ee\3\2\2\2\u01fb/\3\2\2\2\u01fc\u01ff\5@!\2")
buf.write("\u01fd\u01ff\5\62\32\2\u01fe\u01fc\3\2\2\2\u01fe\u01fd")
buf.write("\3\2\2\2\u01ff\u0200\3\2\2\2\u0200\u0201\7/\2\2\u0201")
buf.write("\u0203\3\2\2\2\u0202\u01fe\3\2\2\2\u0203\u0204\3\2\2\2")
buf.write("\u0204\u0202\3\2\2\2\u0204\u0205\3\2\2\2\u0205\u0208\3")
buf.write("\2\2\2\u0206\u0209\5@!\2\u0207\u0209\5\62\32\2\u0208\u0206")
buf.write("\3\2\2\2\u0208\u0207\3\2\2\2\u0208\u0209\3\2\2\2\u0209")
buf.write("\u020c\3\2\2\2\u020a\u020c\5X-\2\u020b\u0202\3\2\2\2\u020b")
buf.write("\u020a\3\2\2\2\u020c\61\3\2\2\2\u020d\u020e\7.\2\2\u020e")
buf.write("\u020f\5P)\2\u020f\63\3\2\2\2\u0210\u021e\7\63\2\2\u0211")
buf.write("\u0216\5\60\31\2\u0212\u0213\7\63\2\2\u0213\u0215\5\60")
buf.write("\31\2\u0214\u0212\3\2\2\2\u0215\u0218\3\2\2\2\u0216\u0214")
buf.write("\3\2\2\2\u0216\u0217\3\2\2\2\u0217\u021b\3\2\2\2\u0218")
buf.write("\u0216\3\2\2\2\u0219\u021a\7\63\2\2\u021a\u021c\5b\62")
buf.write("\2\u021b\u0219\3\2\2\2\u021b\u021c\3\2\2\2\u021c\u021f")
buf.write("\3\2\2\2\u021d\u021f\5b\62\2\u021e\u0211\3\2\2\2\u021e")
buf.write("\u021d\3\2\2\2\u021f\u022f\3\2\2\2\u0220\u0221\6\33\7")
buf.write("\2\u0221\u0222\7\60\2\2\u0222\u0225\5@!\2\u0223\u0224")
buf.write("\7\63\2\2\u0224\u0226\5X-\2\u0225\u0223\3\2\2\2\u0225")
buf.write("\u0226\3\2\2\2\u0226\u0227\3\2\2\2\u0227\u0228\b\33\1")
buf.write("\2\u0228\u022f\3\2\2\2\u0229\u022c\t\4\2\2\u022a\u022d")
buf.write("\5b\62\2\u022b\u022d\5X-\2\u022c\u022a\3\2\2\2\u022c\u022b")
buf.write("\3\2\2\2\u022d\u022f\3\2\2\2\u022e\u0210\3\2\2\2\u022e")
buf.write("\u0220\3\2\2\2\u022e\u0229\3\2\2\2\u022f\65\3\2\2\2\u0230")
buf.write("\u0235\5P)\2\u0231\u0232\7/\2\2\u0232\u0234\5P)\2\u0233")
buf.write("\u0231\3\2\2\2\u0234\u0237\3\2\2\2\u0235\u0233\3\2\2\2")
buf.write("\u0235\u0236\3\2\2\2\u0236\u0239\3\2\2\2\u0237\u0235\3")
buf.write("\2\2\2\u0238\u023a\7/\2\2\u0239\u0238\3\2\2\2\u0239\u023a")
buf.write("\3\2\2\2\u023a\67\3\2\2\2\u023b\u0240\5:\36\2\u023c\u023d")
buf.write("\7/\2\2\u023d\u023f\5:\36\2\u023e\u023c\3\2\2\2\u023f")
buf.write("\u0242\3\2\2\2\u0240\u023e\3\2\2\2\u0240\u0241\3\2\2\2")
buf.write("\u0241\u0244\3\2\2\2\u0242\u0240\3\2\2\2\u0243\u0245\7")
buf.write("/\2\2\u0244\u0243\3\2\2\2\u0244\u0245\3\2\2\2\u02459\3")
buf.write("\2\2\2\u0246\u0249\5\\/\2\u0247\u0248\7\f\2\2\u0248\u024a")
buf.write("\5\\/\2\u0249\u0247\3\2\2\2\u0249\u024a\3\2\2\2\u024a")
buf.write(";\3\2\2\2\u024b\u0250\5> \2\u024c\u024d\7/\2\2\u024d\u024f")
buf.write("\5> \2\u024e\u024c\3\2\2\2\u024f\u0252\3\2\2\2\u0250\u024e")
buf.write("\3\2\2\2\u0250\u0251\3\2\2\2\u0251=\3\2\2\2\u0252\u0250")
buf.write("\3\2\2\2\u0253\u0256\5Z.\2\u0254\u0255\7\f\2\2\u0255\u0257")
buf.write("\5\\/\2\u0256\u0254\3\2\2\2\u0256\u0257\3\2\2\2\u0257")
buf.write("?\3\2\2\2\u0258\u025e\5L\'\2\u0259\u025a\7\17\2\2\u025a")
buf.write("\u025b\5L\'\2\u025b\u025c\7\21\2\2\u025c\u025d\5@!\2\u025d")
buf.write("\u025f\3\2\2\2\u025e\u0259\3\2\2\2\u025e\u025f\3\2\2\2")
buf.write("\u025f\u0267\3\2\2\2\u0260\u0262\7\32\2\2\u0261\u0263")
buf.write("\5B\"\2\u0262\u0261\3\2\2\2\u0262\u0263\3\2\2\2\u0263")
buf.write("\u0264\3\2\2\2\u0264\u0265\7\60\2\2\u0265\u0267\5@!\2")
buf.write("\u0266\u0258\3\2\2\2\u0266\u0260\3\2\2\2\u0267A\3\2\2")
buf.write("\2\u0268\u0269\5D#\2\u0269\u026a\7/\2\2\u026a\u026c\3")
buf.write("\2\2\2\u026b\u0268\3\2\2\2\u026b\u026c\3\2\2\2\u026c\u0277")
buf.write("\3\2\2\2\u026d\u0270\5H%\2\u026e\u026f\7/\2\2\u026f\u0271")
buf.write("\5D#\2\u0270\u026e\3\2\2\2\u0270\u0271\3\2\2\2\u0271\u0274")
buf.write("\3\2\2\2\u0272\u0273\7/\2\2\u0273\u0275\5J&\2\u0274\u0272")
buf.write("\3\2\2\2\u0274\u0275\3\2\2\2\u0275\u0278\3\2\2\2\u0276")
buf.write("\u0278\5J&\2\u0277\u026d\3\2\2\2\u0277\u0276\3\2\2\2\u0278")
buf.write("\u027a\3\2\2\2\u0279\u027b\7/\2\2\u027a\u0279\3\2\2\2")
buf.write("\u027a\u027b\3\2\2\2\u027b\u0281\3\2\2\2\u027c\u027e\5")
buf.write("D#\2\u027d\u027f\7/\2\2\u027e\u027d\3\2\2\2\u027e\u027f")
buf.write("\3\2\2\2\u027f\u0281\3\2\2\2\u0280\u026b\3\2\2\2\u0280")
buf.write("\u027c\3\2\2\2\u0281C\3\2\2\2\u0282\u0287\5F$\2\u0283")
buf.write("\u0284\7/\2\2\u0284\u0286\5F$\2\u0285\u0283\3\2\2\2\u0286")
buf.write("\u0289\3\2\2\2\u0287\u0285\3\2\2\2\u0287\u0288\3\2\2\2")
buf.write("\u0288E\3\2\2\2\u0289\u0287\3\2\2\2\u028a\u028d\5\\/\2")
buf.write("\u028b\u028c\7\63\2\2\u028c\u028e\5@!\2\u028d\u028b\3")
buf.write("\2\2\2\u028d\u028e\3\2\2\2\u028e\u0291\3\2\2\2\u028f\u0291")
buf.write("\7.\2\2\u0290\u028a\3\2\2\2\u0290\u028f\3\2\2\2\u0291")
buf.write("G\3\2\2\2\u0292\u0293\7.\2\2\u0293\u0294\5\\/\2\u0294")
buf.write("I\3\2\2\2\u0295\u0296\7\62\2\2\u0296\u0297\5\\/\2\u0297")
buf.write("K\3\2\2\2\u0298\u0299\b\'\1\2\u0299\u029d\5N(\2\u029a")
buf.write("\u029b\7\35\2\2\u029b\u029d\5L\'\5\u029c\u0298\3\2\2\2")
buf.write("\u029c\u029a\3\2\2\2\u029d\u02a6\3\2\2\2\u029e\u029f\f")
buf.write("\4\2\2\u029f\u02a0\7\34\2\2\u02a0\u02a5\5L\'\5\u02a1\u02a2")
buf.write("\f\3\2\2\u02a2\u02a3\7\33\2\2\u02a3\u02a5\5L\'\4\u02a4")
buf.write("\u029e\3\2\2\2\u02a4\u02a1\3\2\2\2\u02a5\u02a8\3\2\2\2")
buf.write("\u02a6\u02a4\3\2\2\2\u02a6\u02a7\3\2\2\2\u02a7M\3\2\2")
buf.write("\2\u02a8\u02a6\3\2\2\2\u02a9\u02aa\b(\1\2\u02aa\u02ab")
buf.write("\5P)\2\u02ab\u02c1\3\2\2\2\u02ac\u02bc\f\4\2\2\u02ad\u02bd")
buf.write("\7?\2\2\u02ae\u02bd\7@\2\2\u02af\u02bd\7A\2\2\u02b0\u02bd")
buf.write("\7B\2\2\u02b1\u02bd\7C\2\2\u02b2\u02bd\7D\2\2\u02b3\u02bd")
buf.write("\7E\2\2\u02b4\u02b6\7\35\2\2\u02b5\u02b4\3\2\2\2\u02b5")
buf.write("\u02b6\3\2\2\2\u02b6\u02b7\3\2\2\2\u02b7\u02bd\7\24\2")
buf.write("\2\u02b8\u02ba\7\36\2\2\u02b9\u02bb\7\35\2\2\u02ba\u02b9")
buf.write("\3\2\2\2\u02ba\u02bb\3\2\2\2\u02bb\u02bd\3\2\2\2\u02bc")
buf.write("\u02ad\3\2\2\2\u02bc\u02ae\3\2\2\2\u02bc\u02af\3\2\2\2")
buf.write("\u02bc\u02b0\3\2\2\2\u02bc\u02b1\3\2\2\2\u02bc\u02b2\3")
buf.write("\2\2\2\u02bc\u02b3\3\2\2\2\u02bc\u02b5\3\2\2\2\u02bc\u02b8")
buf.write("\3\2\2\2\u02bd\u02be\3\2\2\2\u02be\u02c0\5N(\5\u02bf\u02ac")
buf.write("\3\2\2\2\u02c0\u02c3\3\2\2\2\u02c1\u02bf\3\2\2\2\u02c1")
buf.write("\u02c2\3\2\2\2\u02c2O\3\2\2\2\u02c3\u02c1\3\2\2\2\u02c4")
buf.write("\u02c6\b)\1\2\u02c5\u02c7\7&\2\2\u02c6\u02c5\3\2\2\2\u02c6")
buf.write("\u02c7\3\2\2\2\u02c7\u02c8\3\2\2\2\u02c8\u02cc\5R*\2\u02c9")
buf.write("\u02cb\5f\64\2\u02ca\u02c9\3\2\2\2\u02cb\u02ce\3\2\2\2")
buf.write("\u02cc\u02ca\3\2\2\2\u02cc\u02cd\3\2\2\2\u02cd\u02d2\3")
buf.write("\2\2\2\u02ce\u02cc\3\2\2\2\u02cf\u02d0\t\5\2\2\u02d0\u02d2")
buf.write("\5P)\t\u02d1\u02c4\3\2\2\2\u02d1\u02cf\3\2\2\2\u02d2\u02ea")
buf.write("\3\2\2\2\u02d3\u02d4\f\n\2\2\u02d4\u02d5\7\62\2\2\u02d5")
buf.write("\u02e9\5P)\n\u02d6\u02d7\f\b\2\2\u02d7\u02d8\t\6\2\2\u02d8")
buf.write("\u02e9\5P)\t\u02d9\u02da\f\7\2\2\u02da\u02db\t\7\2\2\u02db")
buf.write("\u02e9\5P)\b\u02dc\u02dd\f\6\2\2\u02dd\u02de\t\b\2\2\u02de")
buf.write("\u02e9\5P)\7\u02df\u02e0\f\5\2\2\u02e0\u02e1\7\66\2\2")
buf.write("\u02e1\u02e9\5P)\6\u02e2\u02e3\f\4\2\2\u02e3\u02e4\7\65")
buf.write("\2\2\u02e4\u02e9\5P)\5\u02e5\u02e6\f\3\2\2\u02e6\u02e7")
buf.write("\7\64\2\2\u02e7\u02e9\5P)\4\u02e8\u02d3\3\2\2\2\u02e8")
buf.write("\u02d6\3\2\2\2\u02e8\u02d9\3\2\2\2\u02e8\u02dc\3\2\2\2")
buf.write("\u02e8\u02df\3\2\2\2\u02e8\u02e2\3\2\2\2\u02e8\u02e5\3")
buf.write("\2\2\2\u02e9\u02ec\3\2\2\2\u02ea\u02e8\3\2\2\2\u02ea\u02eb")
buf.write("\3\2\2\2\u02ebQ\3\2\2\2\u02ec\u02ea\3\2\2\2\u02ed\u02f0")
buf.write("\7\\\2\2\u02ee\u02f1\5b\62\2\u02ef\u02f1\5V,\2\u02f0\u02ee")
buf.write("\3\2\2\2\u02f0\u02ef\3\2\2\2\u02f0\u02f1\3\2\2\2\u02f1")
buf.write("\u02f2\3\2\2\2\u02f2\u0313\7]\2\2\u02f3\u02f5\7`\2\2\u02f4")
buf.write("\u02f6\5V,\2\u02f5\u02f4\3\2\2\2\u02f5\u02f6\3\2\2\2\u02f6")
buf.write("\u02f7\3\2\2\2\u02f7\u0313\7a\2\2\u02f8\u02fa\7^\2\2\u02f9")
buf.write("\u02fb\5T+\2\u02fa\u02f9\3\2\2\2\u02fa\u02fb\3\2\2\2\u02fb")
buf.write("\u02fc\3\2\2\2\u02fc\u0313\7_\2\2\u02fd\u02fe\7-\2\2\u02fe")
buf.write("\u0300\5X-\2\u02ff\u0301\7/\2\2\u0300\u02ff\3\2\2\2\u0300")
buf.write("\u0301\3\2\2\2\u0301\u0302\3\2\2\2\u0302\u0303\7-\2\2")
buf.write("\u0303\u0313\3\2\2\2\u0304\u0313\7,\2\2\u0305\u0313\5")
buf.write("\\/\2\u0306\u0313\7\'\2\2\u0307\u0313\7(\2\2\u0308\u030a")
buf.write("\7:\2\2\u0309\u0308\3\2\2\2\u0309\u030a\3\2\2\2\u030a")
buf.write("\u030b\3\2\2\2\u030b\u0313\5^\60\2\u030c\u0313\7\26\2")
buf.write("\2\u030d\u030f\7U\2\2\u030e\u030d\3\2\2\2\u030f\u0310")
buf.write("\3\2\2\2\u0310\u030e\3\2\2\2\u0310\u0311\3\2\2\2\u0311")
buf.write("\u0313\3\2\2\2\u0312\u02ed\3\2\2\2\u0312\u02f3\3\2\2\2")
buf.write("\u0312\u02f8\3\2\2\2\u0312\u02fd\3\2\2\2\u0312\u0304\3")
buf.write("\2\2\2\u0312\u0305\3\2\2\2\u0312\u0306\3\2\2\2\u0312\u0307")
buf.write("\3\2\2\2\u0312\u0309\3\2\2\2\u0312\u030c\3\2\2\2\u0312")
buf.write("\u030e\3\2\2\2\u0313S\3\2\2\2\u0314\u0315\5@!\2\u0315")
buf.write("\u0316\7\60\2\2\u0316\u0317\5@!\2\u0317\u031b\3\2\2\2")
buf.write("\u0318\u0319\7\62\2\2\u0319\u031b\5P)\2\u031a\u0314\3")
buf.write("\2\2\2\u031a\u0318\3\2\2\2\u031b\u0327\3\2\2\2\u031c\u0323")
buf.write("\7/\2\2\u031d\u031e\5@!\2\u031e\u031f\7\60\2\2\u031f\u0320")
buf.write("\5@!\2\u0320\u0324\3\2\2\2\u0321\u0322\7\62\2\2\u0322")
buf.write("\u0324\5P)\2\u0323\u031d\3\2\2\2\u0323\u0321\3\2\2\2\u0324")
buf.write("\u0326\3\2\2\2\u0325\u031c\3\2\2\2\u0326\u0329\3\2\2\2")
buf.write("\u0327\u0325\3\2\2\2\u0327\u0328\3\2\2\2\u0328\u032b\3")
buf.write("\2\2\2\u0329\u0327\3\2\2\2\u032a\u032c\7/\2\2\u032b\u032a")
buf.write("\3\2\2\2\u032b\u032c\3\2\2\2\u032c\u0334\3\2\2\2\u032d")
buf.write("\u032e\5@!\2\u032e\u032f\7\60\2\2\u032f\u0330\5@!\2\u0330")
buf.write("\u0331\5t;\2\u0331\u0334\3\2\2\2\u0332\u0334\5V,\2\u0333")
buf.write("\u031a\3\2\2\2\u0333\u032d\3\2\2\2\u0333\u0332\3\2\2\2")
buf.write("\u0334U\3\2\2\2\u0335\u0338\5@!\2\u0336\u0338\5\62\32")
buf.write("\2\u0337\u0335\3\2\2\2\u0337\u0336\3\2\2\2\u0338\u0347")
buf.write("\3\2\2\2\u0339\u0348\5t;\2\u033a\u033d\7/\2\2\u033b\u033e")
buf.write("\5@!\2\u033c\u033e\5\62\32\2\u033d\u033b\3\2\2\2\u033d")
buf.write("\u033c\3\2\2\2\u033e\u0340\3\2\2\2\u033f\u033a\3\2\2\2")
buf.write("\u0340\u0343\3\2\2\2\u0341\u033f\3\2\2\2\u0341\u0342\3")
buf.write("\2\2\2\u0342\u0345\3\2\2\2\u0343\u0341\3\2\2\2\u0344\u0346")
buf.write("\7/\2\2\u0345\u0344\3\2\2\2\u0345\u0346\3\2\2\2\u0346")
buf.write("\u0348\3\2\2\2\u0347\u0339\3\2\2\2\u0347\u0341\3\2\2\2")
buf.write("\u0348W\3\2\2\2\u0349\u034e\5@!\2\u034a\u034b\7/\2\2\u034b")
buf.write("\u034d\5@!\2\u034c\u034a\3\2\2\2\u034d\u0350\3\2\2\2\u034e")
buf.write("\u034c\3\2\2\2\u034e\u034f\3\2\2\2\u034f\u0352\3\2\2\2")
buf.write("\u0350\u034e\3\2\2\2\u0351\u0353\7/\2\2\u0352\u0351\3")
buf.write("\2\2\2\u0352\u0353\3\2\2\2\u0353Y\3\2\2\2\u0354\u0355")
buf.write("\b.\1\2\u0355\u0356\5\\/\2\u0356\u035c\3\2\2\2\u0357\u0358")
buf.write("\f\4\2\2\u0358\u0359\7+\2\2\u0359\u035b\5\\/\2\u035a\u0357")
buf.write("\3\2\2\2\u035b\u035e\3\2\2\2\u035c\u035a\3\2\2\2\u035c")
buf.write("\u035d\3\2\2\2\u035d[\3\2\2\2\u035e\u035c\3\2\2\2\u035f")
buf.write("\u0360\t\t\2\2\u0360]\3\2\2\2\u0361\u0365\5`\61\2\u0362")
buf.write("\u0365\7Z\2\2\u0363\u0365\7[\2\2\u0364\u0361\3\2\2\2\u0364")
buf.write("\u0362\3\2\2\2\u0364\u0363\3\2\2\2\u0365_\3\2\2\2\u0366")
buf.write("\u0367\t\n\2\2\u0367a\3\2\2\2\u0368\u036a\7 \2\2\u0369")
buf.write("\u036b\5d\63\2\u036a\u0369\3\2\2\2\u036a\u036b\3\2\2\2")
buf.write("\u036bc\3\2\2\2\u036c\u036d\7\t\2\2\u036d\u0370\5@!\2")
buf.write("\u036e\u0370\5X-\2\u036f\u036c\3\2\2\2\u036f\u036e\3\2")
buf.write("\2\2\u0370e\3\2\2\2\u0371\u0372\7+\2\2\u0372\u0374\5\\")
buf.write("/\2\u0373\u0375\5h\65\2\u0374\u0373\3\2\2\2\u0374\u0375")
buf.write("\3\2\2\2\u0375\u0378\3\2\2\2\u0376\u0378\5h\65\2\u0377")
buf.write("\u0371\3\2\2\2\u0377\u0376\3\2\2\2\u0378g\3\2\2\2\u0379")
buf.write("\u037b\7\\\2\2\u037a\u037c\5j\66\2\u037b\u037a\3\2\2\2")
buf.write("\u037b\u037c\3\2\2\2\u037c\u037d\3\2\2\2\u037d\u0383\7")
buf.write("]\2\2\u037e\u037f\7`\2\2\u037f\u0380\5n8\2\u0380\u0381")
buf.write("\7a\2\2\u0381\u0383\3\2\2\2\u0382\u0379\3\2\2\2\u0382")
buf.write("\u037e\3\2\2\2\u0383i\3\2\2\2\u0384\u0389\5l\67\2\u0385")
buf.write("\u0386\7/\2\2\u0386\u0388\5l\67\2\u0387\u0385\3\2\2\2")
buf.write("\u0388\u038b\3\2\2\2\u0389\u0387\3\2\2\2\u0389\u038a\3")
buf.write("\2\2\2\u038a\u038d\3\2\2\2\u038b\u0389\3\2\2\2\u038c\u038e")
buf.write("\7/\2\2\u038d\u038c\3\2\2\2\u038d\u038e\3\2\2\2\u038e")
buf.write("k\3\2\2\2\u038f\u0393\5@!\2\u0390\u0394\5t;\2\u0391\u0392")
buf.write("\7\63\2\2\u0392\u0394\5@!\2\u0393\u0390\3\2\2\2\u0393")
buf.write("\u0391\3\2\2\2\u0393\u0394\3\2\2\2\u0394\u0398\3\2\2\2")
buf.write("\u0395\u0396\t\13\2\2\u0396\u0398\5@!\2\u0397\u038f\3")
buf.write("\2\2\2\u0397\u0395\3\2\2\2\u0398m\3\2\2\2\u0399\u039e")
buf.write("\5p9\2\u039a\u039b\7/\2\2\u039b\u039d\5p9\2\u039c\u039a")
buf.write("\3\2\2\2\u039d\u03a0\3\2\2\2\u039e\u039c\3\2\2\2\u039e")
buf.write("\u039f\3\2\2\2\u039f\u03a2\3\2\2\2\u03a0\u039e\3\2\2\2")
buf.write("\u03a1\u03a3\7/\2\2\u03a2\u03a1\3\2\2\2\u03a2\u03a3\3")
buf.write("\2\2\2\u03a3o\3\2\2\2\u03a4\u03b7\7,\2\2\u03a5\u03ad\5")
buf.write("@!\2\u03a6\u03a8\7\60\2\2\u03a7\u03a9\5@!\2\u03a8\u03a7")
buf.write("\3\2\2\2\u03a8\u03a9\3\2\2\2\u03a9\u03ab\3\2\2\2\u03aa")
buf.write("\u03ac\5r:\2\u03ab\u03aa\3\2\2\2\u03ab\u03ac\3\2\2\2\u03ac")
buf.write("\u03ae\3\2\2\2\u03ad\u03a6\3\2\2\2\u03ad\u03ae\3\2\2\2")
buf.write("\u03ae\u03b7\3\2\2\2\u03af\u03b1\7\60\2\2\u03b0\u03b2")
buf.write("\5@!\2\u03b1\u03b0\3\2\2\2\u03b1\u03b2\3\2\2\2\u03b2\u03b4")
buf.write("\3\2\2\2\u03b3\u03b5\5r:\2\u03b4\u03b3\3\2\2\2\u03b4\u03b5")
buf.write("\3\2\2\2\u03b5\u03b7\3\2\2\2\u03b6\u03a4\3\2\2\2\u03b6")
buf.write("\u03a5\3\2\2\2\u03b6\u03af\3\2\2\2\u03b7q\3\2\2\2\u03b8")
buf.write("\u03ba\7\60\2\2\u03b9\u03bb\5@!\2\u03ba\u03b9\3\2\2\2")
buf.write("\u03ba\u03bb\3\2\2\2\u03bbs\3\2\2\2\u03bc\u03bd\7\23\2")
buf.write("\2\u03bd\u03be\5\66\34\2\u03be\u03bf\7\24\2\2\u03bf\u03c1")
buf.write("\5L\'\2\u03c0\u03c2\5v<\2\u03c1\u03c0\3\2\2\2\u03c1\u03c2")
buf.write("\3\2\2\2\u03c2u\3\2\2\2\u03c3\u03ca\5t;\2\u03c4\u03c5")
buf.write("\7\17\2\2\u03c5\u03c7\5@!\2\u03c6\u03c8\5v<\2\u03c7\u03c6")
buf.write("\3\2\2\2\u03c7\u03c8\3\2\2\2\u03c8\u03ca\3\2\2\2\u03c9")
buf.write("\u03c3\3\2\2\2\u03c9\u03c4\3\2\2\2\u03caw\3\2\2\2\u0099")
buf.write("{\u0084\u0088\u008a\u0090\u0095\u009e\u00a2\u00a9\u00ac")
buf.write("\u00b5\u00bd\u00c0\u00c3\u00c6\u00c9\u00d1\u00da\u00df")
buf.write("\u00e1\u00e9\u00ed\u00f3\u00f6\u010a\u0118\u011a\u0123")
buf.write("\u0126\u012c\u0132\u0137\u013f\u0144\u0148\u014b\u014e")
buf.write("\u0152\u0154\u0161\u0167\u016a\u016f\u0176\u017a\u0180")
buf.write("\u0189\u018d\u0195\u0198\u019a\u01a5\u01ad\u01af\u01b1")
buf.write("\u01b5\u01be\u01c5\u01c7\u01d0\u01d8\u01e2\u01e4\u01ec")
buf.write("\u01f5\u01fa\u01fe\u0204\u0208\u020b\u0216\u021b\u021e")
buf.write("\u0225\u022c\u022e\u0235\u0239\u0240\u0244\u0249\u0250")
buf.write("\u0256\u025e\u0262\u0266\u026b\u0270\u0274\u0277\u027a")
buf.write("\u027e\u0280\u0287\u028d\u0290\u029c\u02a4\u02a6\u02b5")
buf.write("\u02ba\u02bc\u02c1\u02c6\u02cc\u02d1\u02e8\u02ea\u02f0")
buf.write("\u02f5\u02fa\u0300\u0309\u0310\u0312\u031a\u0323\u0327")
buf.write("\u032b\u0333\u0337\u033d\u0341\u0345\u0347\u034e\u0352")
buf.write("\u035c\u0364\u036a\u036f\u0374\u0377\u037b\u0382\u0389")
buf.write("\u038d\u0393\u0397\u039e\u03a2\u03a8\u03ab\u03ad\u03b1")
buf.write("\u03b4\u03b6\u03ba\u03c1\u03c7\u03c9")
return buf.getvalue()
[docs]
class PythonParser ( PythonParserBase ):
grammarFileName = "PythonParser.g4"
atn = ATNDeserializer().deserialize(serializedATN())
decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
sharedContextCache = PredictionContextCache()
literalNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"'def'", "'return'", "'raise'", "'from'", "'import'",
"'nonlocal'", "'as'", "'global'", "'assert'", "'if'",
"'elif'", "'else'", "'while'", "'for'", "'in'", "'try'",
"'None'", "'finally'", "'with'", "'except'", "'lambda'",
"'or'", "'and'", "'not'", "'is'", "'class'", "'yield'",
"'del'", "'pass'", "'continue'", "'break'", "'async'",
"'await'", "'print'", "'exec'", "'True'", "'False'",
"'.'", "'...'", "'`'", "'*'", "','", "':'", "';'",
"'**'", "'='", "'|'", "'^'", "'&'", "'<<'", "'>>'",
"'+'", "'-'", "'/'", "'%'", "'//'", "'~'", "'<'", "'>'",
"'=='", "'>='", "'<='", "'<>'", "'!='", "'@'", "'->'",
"'+='", "'-='", "'*='", "'@='", "'/='", "'%='", "'&='",
"'|='", "'^='", "'<<='", "'>>='", "'**='", "'//='",
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "'('", "')'",
"'{'", "'}'", "'['", "']'" ]
symbolicNames = [ "<INVALID>", "INDENT", "DEDENT", "LINE_BREAK", "DEF",
"RETURN", "RAISE", "FROM", "IMPORT", "NONLOCAL", "AS",
"GLOBAL", "ASSERT", "IF", "ELIF", "ELSE", "WHILE",
"FOR", "IN", "TRY", "NONE", "FINALLY", "WITH", "EXCEPT",
"LAMBDA", "OR", "AND", "NOT", "IS", "CLASS", "YIELD",
"DEL", "PASS", "CONTINUE", "BREAK", "ASYNC", "AWAIT",
"PRINT", "EXEC", "TRUE", "FALSE", "DOT", "ELLIPSIS",
"REVERSE_QUOTE", "STAR", "COMMA", "COLON", "SEMI_COLON",
"POWER", "ASSIGN", "OR_OP", "XOR", "AND_OP", "LEFT_SHIFT",
"RIGHT_SHIFT", "ADD", "MINUS", "DIV", "MOD", "IDIV",
"NOT_OP", "LESS_THAN", "GREATER_THAN", "EQUALS", "GT_EQ",
"LT_EQ", "NOT_EQ_1", "NOT_EQ_2", "AT", "ARROW", "ADD_ASSIGN",
"SUB_ASSIGN", "MULT_ASSIGN", "AT_ASSIGN", "DIV_ASSIGN",
"MOD_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN",
"LEFT_SHIFT_ASSIGN", "RIGHT_SHIFT_ASSIGN", "POWER_ASSIGN",
"IDIV_ASSIGN", "STRING", "DECIMAL_INTEGER", "OCT_INTEGER",
"HEX_INTEGER", "BIN_INTEGER", "IMAG_NUMBER", "FLOAT_NUMBER",
"OPEN_PAREN", "CLOSE_PAREN", "OPEN_BRACE", "CLOSE_BRACE",
"OPEN_BRACKET", "CLOSE_BRACKET", "NAME", "LINE_JOIN",
"NEWLINE", "WS", "COMMENT" ]
RULE_root = 0
RULE_single_input = 1
RULE_file_input = 2
RULE_eval_input = 3
RULE_stmt = 4
RULE_compound_stmt = 5
RULE_suite = 6
RULE_decorator = 7
RULE_elif_clause = 8
RULE_else_clause = 9
RULE_finally_clause = 10
RULE_with_item = 11
RULE_except_clause = 12
RULE_classdef = 13
RULE_funcdef = 14
RULE_typedargslist = 15
RULE_args = 16
RULE_kwargs = 17
RULE_def_parameters = 18
RULE_def_parameter = 19
RULE_named_parameter = 20
RULE_simple_stmt = 21
RULE_small_stmt = 22
RULE_testlist_star_expr = 23
RULE_star_expr = 24
RULE_assign_part = 25
RULE_exprlist = 26
RULE_import_as_names = 27
RULE_import_as_name = 28
RULE_dotted_as_names = 29
RULE_dotted_as_name = 30
RULE_test = 31
RULE_varargslist = 32
RULE_vardef_parameters = 33
RULE_vardef_parameter = 34
RULE_varargs = 35
RULE_varkwargs = 36
RULE_logical_test = 37
RULE_comparison = 38
RULE_expr = 39
RULE_atom = 40
RULE_dictorsetmaker = 41
RULE_testlist_comp = 42
RULE_testlist = 43
RULE_dotted_name = 44
RULE_name = 45
RULE_number = 46
RULE_integer = 47
RULE_yield_expr = 48
RULE_yield_arg = 49
RULE_trailer = 50
RULE_arguments = 51
RULE_arglist = 52
RULE_argument = 53
RULE_subscriptlist = 54
RULE_subscript = 55
RULE_sliceop = 56
RULE_comp_for = 57
RULE_comp_iter = 58
ruleNames = [ "root", "single_input", "file_input", "eval_input", "stmt",
"compound_stmt", "suite", "decorator", "elif_clause",
"else_clause", "finally_clause", "with_item", "except_clause",
"classdef", "funcdef", "typedargslist", "args", "kwargs",
"def_parameters", "def_parameter", "named_parameter",
"simple_stmt", "small_stmt", "testlist_star_expr", "star_expr",
"assign_part", "exprlist", "import_as_names", "import_as_name",
"dotted_as_names", "dotted_as_name", "test", "varargslist",
"vardef_parameters", "vardef_parameter", "varargs", "varkwargs",
"logical_test", "comparison", "expr", "atom", "dictorsetmaker",
"testlist_comp", "testlist", "dotted_name", "name", "number",
"integer", "yield_expr", "yield_arg", "trailer", "arguments",
"arglist", "argument", "subscriptlist", "subscript",
"sliceop", "comp_for", "comp_iter" ]
EOF = Token.EOF
INDENT=1
DEDENT=2
LINE_BREAK=3
DEF=4
RETURN=5
RAISE=6
FROM=7
IMPORT=8
NONLOCAL=9
AS=10
GLOBAL=11
ASSERT=12
IF=13
ELIF=14
ELSE=15
WHILE=16
FOR=17
IN=18
TRY=19
NONE=20
FINALLY=21
WITH=22
EXCEPT=23
LAMBDA=24
OR=25
AND=26
NOT=27
IS=28
CLASS=29
YIELD=30
DEL=31
PASS=32
CONTINUE=33
BREAK=34
ASYNC=35
AWAIT=36
PRINT=37
EXEC=38
TRUE=39
FALSE=40
DOT=41
ELLIPSIS=42
REVERSE_QUOTE=43
STAR=44
COMMA=45
COLON=46
SEMI_COLON=47
POWER=48
ASSIGN=49
OR_OP=50
XOR=51
AND_OP=52
LEFT_SHIFT=53
RIGHT_SHIFT=54
ADD=55
MINUS=56
DIV=57
MOD=58
IDIV=59
NOT_OP=60
LESS_THAN=61
GREATER_THAN=62
EQUALS=63
GT_EQ=64
LT_EQ=65
NOT_EQ_1=66
NOT_EQ_2=67
AT=68
ARROW=69
ADD_ASSIGN=70
SUB_ASSIGN=71
MULT_ASSIGN=72
AT_ASSIGN=73
DIV_ASSIGN=74
MOD_ASSIGN=75
AND_ASSIGN=76
OR_ASSIGN=77
XOR_ASSIGN=78
LEFT_SHIFT_ASSIGN=79
RIGHT_SHIFT_ASSIGN=80
POWER_ASSIGN=81
IDIV_ASSIGN=82
STRING=83
DECIMAL_INTEGER=84
OCT_INTEGER=85
HEX_INTEGER=86
BIN_INTEGER=87
IMAG_NUMBER=88
FLOAT_NUMBER=89
OPEN_PAREN=90
CLOSE_PAREN=91
OPEN_BRACE=92
CLOSE_BRACE=93
OPEN_BRACKET=94
CLOSE_BRACKET=95
NAME=96
LINE_JOIN=97
NEWLINE=98
WS=99
COMMENT=100
def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
super().__init__(input, output)
self.checkVersion("4.8")
self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
self._predicates = None
[docs]
class RootContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def EOF(self):
return self.getToken(PythonParser.EOF, 0)
[docs]
def single_input(self):
return self.getTypedRuleContext(PythonParser.Single_inputContext,0)
[docs]
def file_input(self):
return self.getTypedRuleContext(PythonParser.File_inputContext,0)
[docs]
def eval_input(self):
return self.getTypedRuleContext(PythonParser.Eval_inputContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_root
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterRoot" ):
listener.enterRoot(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitRoot" ):
listener.exitRoot(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitRoot" ):
return visitor.visitRoot(self)
else:
return visitor.visitChildren(self)
[docs]
def root(self):
localctx = PythonParser.RootContext(self, self._ctx, self.state)
self.enterRule(localctx, 0, self.RULE_root)
try:
self.enterOuterAlt(localctx, 1)
self.state = 121
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
if la_ == 1:
self.state = 118
self.single_input()
elif la_ == 2:
self.state = 119
self.file_input()
elif la_ == 3:
self.state = 120
self.eval_input()
self.state = 123
self.match(PythonParser.EOF)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Single_inputContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LINE_BREAK(self):
return self.getToken(PythonParser.LINE_BREAK, 0)
[docs]
def simple_stmt(self):
return self.getTypedRuleContext(PythonParser.Simple_stmtContext,0)
[docs]
def compound_stmt(self):
return self.getTypedRuleContext(PythonParser.Compound_stmtContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_single_input
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSingle_input" ):
listener.enterSingle_input(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSingle_input" ):
listener.exitSingle_input(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSingle_input" ):
return visitor.visitSingle_input(self)
else:
return visitor.visitChildren(self)
[docs]
class File_inputContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def LINE_BREAK(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.LINE_BREAK)
else:
return self.getToken(PythonParser.LINE_BREAK, i)
[docs]
def stmt(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.StmtContext)
else:
return self.getTypedRuleContext(PythonParser.StmtContext,i)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_file_input
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFile_input" ):
listener.enterFile_input(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFile_input" ):
listener.exitFile_input(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFile_input" ):
return visitor.visitFile_input(self)
else:
return visitor.visitChildren(self)
[docs]
class Eval_inputContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def testlist(self):
return self.getTypedRuleContext(PythonParser.TestlistContext,0)
[docs]
def LINE_BREAK(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.LINE_BREAK)
else:
return self.getToken(PythonParser.LINE_BREAK, i)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_eval_input
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterEval_input" ):
listener.enterEval_input(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitEval_input" ):
listener.exitEval_input(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitEval_input" ):
return visitor.visitEval_input(self)
else:
return visitor.visitChildren(self)
[docs]
class StmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def simple_stmt(self):
return self.getTypedRuleContext(PythonParser.Simple_stmtContext,0)
[docs]
def compound_stmt(self):
return self.getTypedRuleContext(PythonParser.Compound_stmtContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_stmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStmt" ):
listener.enterStmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStmt" ):
listener.exitStmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitStmt" ):
return visitor.visitStmt(self)
else:
return visitor.visitChildren(self)
[docs]
def stmt(self):
localctx = PythonParser.StmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 8, self.RULE_stmt)
try:
self.state = 147
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 145
self.simple_stmt()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 146
self.compound_stmt()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Compound_stmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def getRuleIndex(self):
return PythonParser.RULE_compound_stmt
[docs]
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
[docs]
class While_stmtContext(Compound_stmtContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Compound_stmtContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def WHILE(self):
return self.getToken(PythonParser.WHILE, 0)
[docs]
def test(self):
return self.getTypedRuleContext(PythonParser.TestContext,0)
[docs]
def COLON(self):
return self.getToken(PythonParser.COLON, 0)
[docs]
def suite(self):
return self.getTypedRuleContext(PythonParser.SuiteContext,0)
[docs]
def else_clause(self):
return self.getTypedRuleContext(PythonParser.Else_clauseContext,0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterWhile_stmt" ):
listener.enterWhile_stmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitWhile_stmt" ):
listener.exitWhile_stmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitWhile_stmt" ):
return visitor.visitWhile_stmt(self)
else:
return visitor.visitChildren(self)
[docs]
class Try_stmtContext(Compound_stmtContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Compound_stmtContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def TRY(self):
return self.getToken(PythonParser.TRY, 0)
[docs]
def COLON(self):
return self.getToken(PythonParser.COLON, 0)
[docs]
def suite(self):
return self.getTypedRuleContext(PythonParser.SuiteContext,0)
[docs]
def finally_clause(self):
return self.getTypedRuleContext(PythonParser.Finally_clauseContext,0)
[docs]
def except_clause(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.Except_clauseContext)
else:
return self.getTypedRuleContext(PythonParser.Except_clauseContext,i)
[docs]
def else_clause(self):
return self.getTypedRuleContext(PythonParser.Else_clauseContext,0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTry_stmt" ):
listener.enterTry_stmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTry_stmt" ):
listener.exitTry_stmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTry_stmt" ):
return visitor.visitTry_stmt(self)
else:
return visitor.visitChildren(self)
[docs]
class If_stmtContext(Compound_stmtContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Compound_stmtContext
super().__init__(parser)
self.cond = None # TestContext
self.copyFrom(ctx)
[docs]
def IF(self):
return self.getToken(PythonParser.IF, 0)
[docs]
def COLON(self):
return self.getToken(PythonParser.COLON, 0)
[docs]
def suite(self):
return self.getTypedRuleContext(PythonParser.SuiteContext,0)
[docs]
def test(self):
return self.getTypedRuleContext(PythonParser.TestContext,0)
[docs]
def elif_clause(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.Elif_clauseContext)
else:
return self.getTypedRuleContext(PythonParser.Elif_clauseContext,i)
[docs]
def else_clause(self):
return self.getTypedRuleContext(PythonParser.Else_clauseContext,0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterIf_stmt" ):
listener.enterIf_stmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitIf_stmt" ):
listener.exitIf_stmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitIf_stmt" ):
return visitor.visitIf_stmt(self)
else:
return visitor.visitChildren(self)
[docs]
class With_stmtContext(Compound_stmtContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Compound_stmtContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def WITH(self):
return self.getToken(PythonParser.WITH, 0)
[docs]
def with_item(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.With_itemContext)
else:
return self.getTypedRuleContext(PythonParser.With_itemContext,i)
[docs]
def COLON(self):
return self.getToken(PythonParser.COLON, 0)
[docs]
def suite(self):
return self.getTypedRuleContext(PythonParser.SuiteContext,0)
[docs]
def ASYNC(self):
return self.getToken(PythonParser.ASYNC, 0)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.COMMA)
else:
return self.getToken(PythonParser.COMMA, i)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterWith_stmt" ):
listener.enterWith_stmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitWith_stmt" ):
listener.exitWith_stmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitWith_stmt" ):
return visitor.visitWith_stmt(self)
else:
return visitor.visitChildren(self)
[docs]
class Class_or_func_def_stmtContext(Compound_stmtContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Compound_stmtContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def classdef(self):
return self.getTypedRuleContext(PythonParser.ClassdefContext,0)
[docs]
def funcdef(self):
return self.getTypedRuleContext(PythonParser.FuncdefContext,0)
[docs]
def decorator(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.DecoratorContext)
else:
return self.getTypedRuleContext(PythonParser.DecoratorContext,i)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterClass_or_func_def_stmt" ):
listener.enterClass_or_func_def_stmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitClass_or_func_def_stmt" ):
listener.exitClass_or_func_def_stmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitClass_or_func_def_stmt" ):
return visitor.visitClass_or_func_def_stmt(self)
else:
return visitor.visitChildren(self)
[docs]
class For_stmtContext(Compound_stmtContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Compound_stmtContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def FOR(self):
return self.getToken(PythonParser.FOR, 0)
[docs]
def exprlist(self):
return self.getTypedRuleContext(PythonParser.ExprlistContext,0)
[docs]
def IN(self):
return self.getToken(PythonParser.IN, 0)
[docs]
def testlist(self):
return self.getTypedRuleContext(PythonParser.TestlistContext,0)
[docs]
def COLON(self):
return self.getToken(PythonParser.COLON, 0)
[docs]
def suite(self):
return self.getTypedRuleContext(PythonParser.SuiteContext,0)
[docs]
def ASYNC(self):
return self.getToken(PythonParser.ASYNC, 0)
[docs]
def else_clause(self):
return self.getTypedRuleContext(PythonParser.Else_clauseContext,0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFor_stmt" ):
listener.enterFor_stmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFor_stmt" ):
listener.exitFor_stmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFor_stmt" ):
return visitor.visitFor_stmt(self)
else:
return visitor.visitChildren(self)
[docs]
def compound_stmt(self):
localctx = PythonParser.Compound_stmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 10, self.RULE_compound_stmt)
self._la = 0 # Token type
try:
self.state = 223
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,19,self._ctx)
if la_ == 1:
localctx = PythonParser.If_stmtContext(self, localctx)
self.enterOuterAlt(localctx, 1)
self.state = 149
self.match(PythonParser.IF)
self.state = 150
localctx.cond = self.test()
self.state = 151
self.match(PythonParser.COLON)
self.state = 152
self.suite()
self.state = 156
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,6,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 153
self.elif_clause()
self.state = 158
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,6,self._ctx)
self.state = 160
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
if la_ == 1:
self.state = 159
self.else_clause()
pass
elif la_ == 2:
localctx = PythonParser.While_stmtContext(self, localctx)
self.enterOuterAlt(localctx, 2)
self.state = 162
self.match(PythonParser.WHILE)
self.state = 163
self.test()
self.state = 164
self.match(PythonParser.COLON)
self.state = 165
self.suite()
self.state = 167
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
if la_ == 1:
self.state = 166
self.else_clause()
pass
elif la_ == 3:
localctx = PythonParser.For_stmtContext(self, localctx)
self.enterOuterAlt(localctx, 3)
self.state = 170
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.ASYNC:
self.state = 169
self.match(PythonParser.ASYNC)
self.state = 172
self.match(PythonParser.FOR)
self.state = 173
self.exprlist()
self.state = 174
self.match(PythonParser.IN)
self.state = 175
self.testlist()
self.state = 176
self.match(PythonParser.COLON)
self.state = 177
self.suite()
self.state = 179
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
if la_ == 1:
self.state = 178
self.else_clause()
pass
elif la_ == 4:
localctx = PythonParser.Try_stmtContext(self, localctx)
self.enterOuterAlt(localctx, 4)
self.state = 181
self.match(PythonParser.TRY)
self.state = 182
self.match(PythonParser.COLON)
self.state = 183
self.suite()
self.state = 196
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.EXCEPT]:
self.state = 185
self._errHandler.sync(self)
_alt = 1
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 184
self.except_clause()
else:
raise NoViableAltException(self)
self.state = 187
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,11,self._ctx)
self.state = 190
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
if la_ == 1:
self.state = 189
self.else_clause()
self.state = 193
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
if la_ == 1:
self.state = 192
self.finally_clause()
pass
elif token in [PythonParser.FINALLY]:
self.state = 195
self.finally_clause()
pass
else:
raise NoViableAltException(self)
pass
elif la_ == 5:
localctx = PythonParser.With_stmtContext(self, localctx)
self.enterOuterAlt(localctx, 5)
self.state = 199
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.ASYNC:
self.state = 198
self.match(PythonParser.ASYNC)
self.state = 201
self.match(PythonParser.WITH)
self.state = 202
self.with_item()
self.state = 207
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==PythonParser.COMMA:
self.state = 203
self.match(PythonParser.COMMA)
self.state = 204
self.with_item()
self.state = 209
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 210
self.match(PythonParser.COLON)
self.state = 211
self.suite()
pass
elif la_ == 6:
localctx = PythonParser.Class_or_func_def_stmtContext(self, localctx)
self.enterOuterAlt(localctx, 6)
self.state = 216
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==PythonParser.AT:
self.state = 213
self.decorator()
self.state = 218
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 221
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.CLASS]:
self.state = 219
self.classdef()
pass
elif token in [PythonParser.DEF, PythonParser.ASYNC]:
self.state = 220
self.funcdef()
pass
else:
raise NoViableAltException(self)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SuiteContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def simple_stmt(self):
return self.getTypedRuleContext(PythonParser.Simple_stmtContext,0)
[docs]
def LINE_BREAK(self):
return self.getToken(PythonParser.LINE_BREAK, 0)
[docs]
def INDENT(self):
return self.getToken(PythonParser.INDENT, 0)
[docs]
def DEDENT(self):
return self.getToken(PythonParser.DEDENT, 0)
[docs]
def stmt(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.StmtContext)
else:
return self.getTypedRuleContext(PythonParser.StmtContext,i)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_suite
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSuite" ):
listener.enterSuite(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSuite" ):
listener.exitSuite(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSuite" ):
return visitor.visitSuite(self)
else:
return visitor.visitChildren(self)
[docs]
def suite(self):
localctx = PythonParser.SuiteContext(self, self._ctx, self.state)
self.enterRule(localctx, 12, self.RULE_suite)
try:
self.state = 235
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,21,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 225
self.simple_stmt()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 226
self.match(PythonParser.LINE_BREAK)
self.state = 227
self.match(PythonParser.INDENT)
self.state = 229
self._errHandler.sync(self)
_alt = 1
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 228
self.stmt()
else:
raise NoViableAltException(self)
self.state = 231
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,20,self._ctx)
self.state = 233
self.match(PythonParser.DEDENT)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DecoratorContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def AT(self):
return self.getToken(PythonParser.AT, 0)
[docs]
def dotted_name(self):
return self.getTypedRuleContext(PythonParser.Dotted_nameContext,0)
[docs]
def LINE_BREAK(self):
return self.getToken(PythonParser.LINE_BREAK, 0)
[docs]
def OPEN_PAREN(self):
return self.getToken(PythonParser.OPEN_PAREN, 0)
[docs]
def CLOSE_PAREN(self):
return self.getToken(PythonParser.CLOSE_PAREN, 0)
[docs]
def arglist(self):
return self.getTypedRuleContext(PythonParser.ArglistContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_decorator
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDecorator" ):
listener.enterDecorator(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDecorator" ):
listener.exitDecorator(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDecorator" ):
return visitor.visitDecorator(self)
else:
return visitor.visitChildren(self)
[docs]
def decorator(self):
localctx = PythonParser.DecoratorContext(self, self._ctx, self.state)
self.enterRule(localctx, 14, self.RULE_decorator)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 237
self.match(PythonParser.AT)
self.state = 238
self.dotted_name(0)
self.state = 244
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.OPEN_PAREN:
self.state = 239
self.match(PythonParser.OPEN_PAREN)
self.state = 241
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.STAR) | (1 << PythonParser.POWER) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
self.state = 240
self.arglist()
self.state = 243
self.match(PythonParser.CLOSE_PAREN)
self.state = 246
self.match(PythonParser.LINE_BREAK)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Elif_clauseContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ELIF(self):
return self.getToken(PythonParser.ELIF, 0)
[docs]
def test(self):
return self.getTypedRuleContext(PythonParser.TestContext,0)
[docs]
def COLON(self):
return self.getToken(PythonParser.COLON, 0)
[docs]
def suite(self):
return self.getTypedRuleContext(PythonParser.SuiteContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_elif_clause
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterElif_clause" ):
listener.enterElif_clause(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitElif_clause" ):
listener.exitElif_clause(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitElif_clause" ):
return visitor.visitElif_clause(self)
else:
return visitor.visitChildren(self)
[docs]
def elif_clause(self):
localctx = PythonParser.Elif_clauseContext(self, self._ctx, self.state)
self.enterRule(localctx, 16, self.RULE_elif_clause)
try:
self.enterOuterAlt(localctx, 1)
self.state = 248
self.match(PythonParser.ELIF)
self.state = 249
self.test()
self.state = 250
self.match(PythonParser.COLON)
self.state = 251
self.suite()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Else_clauseContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ELSE(self):
return self.getToken(PythonParser.ELSE, 0)
[docs]
def COLON(self):
return self.getToken(PythonParser.COLON, 0)
[docs]
def suite(self):
return self.getTypedRuleContext(PythonParser.SuiteContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_else_clause
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterElse_clause" ):
listener.enterElse_clause(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitElse_clause" ):
listener.exitElse_clause(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitElse_clause" ):
return visitor.visitElse_clause(self)
else:
return visitor.visitChildren(self)
[docs]
def else_clause(self):
localctx = PythonParser.Else_clauseContext(self, self._ctx, self.state)
self.enterRule(localctx, 18, self.RULE_else_clause)
try:
self.enterOuterAlt(localctx, 1)
self.state = 253
self.match(PythonParser.ELSE)
self.state = 254
self.match(PythonParser.COLON)
self.state = 255
self.suite()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Finally_clauseContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def FINALLY(self):
return self.getToken(PythonParser.FINALLY, 0)
[docs]
def COLON(self):
return self.getToken(PythonParser.COLON, 0)
[docs]
def suite(self):
return self.getTypedRuleContext(PythonParser.SuiteContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_finally_clause
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFinally_clause" ):
listener.enterFinally_clause(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFinally_clause" ):
listener.exitFinally_clause(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFinally_clause" ):
return visitor.visitFinally_clause(self)
else:
return visitor.visitChildren(self)
[docs]
def finally_clause(self):
localctx = PythonParser.Finally_clauseContext(self, self._ctx, self.state)
self.enterRule(localctx, 20, self.RULE_finally_clause)
try:
self.enterOuterAlt(localctx, 1)
self.state = 257
self.match(PythonParser.FINALLY)
self.state = 258
self.match(PythonParser.COLON)
self.state = 259
self.suite()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class With_itemContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def test(self):
return self.getTypedRuleContext(PythonParser.TestContext,0)
[docs]
def AS(self):
return self.getToken(PythonParser.AS, 0)
[docs]
def expr(self):
return self.getTypedRuleContext(PythonParser.ExprContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_with_item
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterWith_item" ):
listener.enterWith_item(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitWith_item" ):
listener.exitWith_item(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitWith_item" ):
return visitor.visitWith_item(self)
else:
return visitor.visitChildren(self)
[docs]
def with_item(self):
localctx = PythonParser.With_itemContext(self, self._ctx, self.state)
self.enterRule(localctx, 22, self.RULE_with_item)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 261
self.test()
self.state = 264
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.AS:
self.state = 262
self.match(PythonParser.AS)
self.state = 263
self.expr(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Except_clauseContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def EXCEPT(self):
return self.getToken(PythonParser.EXCEPT, 0)
[docs]
def COLON(self):
return self.getToken(PythonParser.COLON, 0)
[docs]
def suite(self):
return self.getTypedRuleContext(PythonParser.SuiteContext,0)
[docs]
def test(self):
return self.getTypedRuleContext(PythonParser.TestContext,0)
[docs]
def COMMA(self):
return self.getToken(PythonParser.COMMA, 0)
[docs]
def name(self):
return self.getTypedRuleContext(PythonParser.NameContext,0)
[docs]
def AS(self):
return self.getToken(PythonParser.AS, 0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_except_clause
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExcept_clause" ):
listener.enterExcept_clause(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExcept_clause" ):
listener.exitExcept_clause(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExcept_clause" ):
return visitor.visitExcept_clause(self)
else:
return visitor.visitChildren(self)
[docs]
def except_clause(self):
localctx = PythonParser.Except_clauseContext(self, self._ctx, self.state)
self.enterRule(localctx, 24, self.RULE_except_clause)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 266
self.match(PythonParser.EXCEPT)
self.state = 280
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
self.state = 267
self.test()
self.state = 278
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,25,self._ctx)
if la_ == 1:
self.state = 268
if not self.CheckVersion(2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.CheckVersion(2)")
self.state = 269
self.match(PythonParser.COMMA)
self.state = 270
self.name()
self.SetVersion(2);
elif la_ == 2:
self.state = 273
if not self.CheckVersion(3):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.CheckVersion(3)")
self.state = 274
self.match(PythonParser.AS)
self.state = 275
self.name()
self.SetVersion(3);
self.state = 282
self.match(PythonParser.COLON)
self.state = 283
self.suite()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ClassdefContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def CLASS(self):
return self.getToken(PythonParser.CLASS, 0)
[docs]
def name(self):
return self.getTypedRuleContext(PythonParser.NameContext,0)
[docs]
def COLON(self):
return self.getToken(PythonParser.COLON, 0)
[docs]
def suite(self):
return self.getTypedRuleContext(PythonParser.SuiteContext,0)
[docs]
def OPEN_PAREN(self):
return self.getToken(PythonParser.OPEN_PAREN, 0)
[docs]
def CLOSE_PAREN(self):
return self.getToken(PythonParser.CLOSE_PAREN, 0)
[docs]
def arglist(self):
return self.getTypedRuleContext(PythonParser.ArglistContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_classdef
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterClassdef" ):
listener.enterClassdef(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitClassdef" ):
listener.exitClassdef(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitClassdef" ):
return visitor.visitClassdef(self)
else:
return visitor.visitChildren(self)
[docs]
def classdef(self):
localctx = PythonParser.ClassdefContext(self, self._ctx, self.state)
self.enterRule(localctx, 26, self.RULE_classdef)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 285
self.match(PythonParser.CLASS)
self.state = 286
self.name()
self.state = 292
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.OPEN_PAREN:
self.state = 287
self.match(PythonParser.OPEN_PAREN)
self.state = 289
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.STAR) | (1 << PythonParser.POWER) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
self.state = 288
self.arglist()
self.state = 291
self.match(PythonParser.CLOSE_PAREN)
self.state = 294
self.match(PythonParser.COLON)
self.state = 295
self.suite()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class FuncdefContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def DEF(self):
return self.getToken(PythonParser.DEF, 0)
[docs]
def name(self):
return self.getTypedRuleContext(PythonParser.NameContext,0)
[docs]
def OPEN_PAREN(self):
return self.getToken(PythonParser.OPEN_PAREN, 0)
[docs]
def CLOSE_PAREN(self):
return self.getToken(PythonParser.CLOSE_PAREN, 0)
[docs]
def COLON(self):
return self.getToken(PythonParser.COLON, 0)
[docs]
def suite(self):
return self.getTypedRuleContext(PythonParser.SuiteContext,0)
[docs]
def ASYNC(self):
return self.getToken(PythonParser.ASYNC, 0)
[docs]
def typedargslist(self):
return self.getTypedRuleContext(PythonParser.TypedargslistContext,0)
[docs]
def ARROW(self):
return self.getToken(PythonParser.ARROW, 0)
[docs]
def test(self):
return self.getTypedRuleContext(PythonParser.TestContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_funcdef
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFuncdef" ):
listener.enterFuncdef(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFuncdef" ):
listener.exitFuncdef(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFuncdef" ):
return visitor.visitFuncdef(self)
else:
return visitor.visitChildren(self)
[docs]
def funcdef(self):
localctx = PythonParser.FuncdefContext(self, self._ctx, self.state)
self.enterRule(localctx, 28, self.RULE_funcdef)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 298
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.ASYNC:
self.state = 297
self.match(PythonParser.ASYNC)
self.state = 300
self.match(PythonParser.DEF)
self.state = 301
self.name()
self.state = 302
self.match(PythonParser.OPEN_PAREN)
self.state = 304
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((((_la - 39)) & ~0x3f) == 0 and ((1 << (_la - 39)) & ((1 << (PythonParser.TRUE - 39)) | (1 << (PythonParser.FALSE - 39)) | (1 << (PythonParser.STAR - 39)) | (1 << (PythonParser.POWER - 39)) | (1 << (PythonParser.NAME - 39)))) != 0):
self.state = 303
self.typedargslist()
self.state = 306
self.match(PythonParser.CLOSE_PAREN)
self.state = 309
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.ARROW:
self.state = 307
self.match(PythonParser.ARROW)
self.state = 308
self.test()
self.state = 311
self.match(PythonParser.COLON)
self.state = 312
self.suite()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TypedargslistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def args(self):
return self.getTypedRuleContext(PythonParser.ArgsContext,0)
[docs]
def kwargs(self):
return self.getTypedRuleContext(PythonParser.KwargsContext,0)
[docs]
def def_parameters(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.Def_parametersContext)
else:
return self.getTypedRuleContext(PythonParser.Def_parametersContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.COMMA)
else:
return self.getToken(PythonParser.COMMA, i)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_typedargslist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTypedargslist" ):
listener.enterTypedargslist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTypedargslist" ):
listener.exitTypedargslist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTypedargslist" ):
return visitor.visitTypedargslist(self)
else:
return visitor.visitChildren(self)
[docs]
def typedargslist(self):
localctx = PythonParser.TypedargslistContext(self, self._ctx, self.state)
self.enterRule(localctx, 30, self.RULE_typedargslist)
self._la = 0 # Token type
try:
self.state = 338
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,38,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 317
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,32,self._ctx)
if la_ == 1:
self.state = 314
self.def_parameters()
self.state = 315
self.match(PythonParser.COMMA)
self.state = 329
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.STAR]:
self.state = 319
self.args()
self.state = 322
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,33,self._ctx)
if la_ == 1:
self.state = 320
self.match(PythonParser.COMMA)
self.state = 321
self.def_parameters()
self.state = 326
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
if la_ == 1:
self.state = 324
self.match(PythonParser.COMMA)
self.state = 325
self.kwargs()
pass
elif token in [PythonParser.POWER]:
self.state = 328
self.kwargs()
pass
else:
raise NoViableAltException(self)
self.state = 332
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.COMMA:
self.state = 331
self.match(PythonParser.COMMA)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 334
self.def_parameters()
self.state = 336
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.COMMA:
self.state = 335
self.match(PythonParser.COMMA)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ArgsContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def STAR(self):
return self.getToken(PythonParser.STAR, 0)
[docs]
def named_parameter(self):
return self.getTypedRuleContext(PythonParser.Named_parameterContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_args
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterArgs" ):
listener.enterArgs(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitArgs" ):
listener.exitArgs(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitArgs" ):
return visitor.visitArgs(self)
else:
return visitor.visitChildren(self)
[docs]
def args(self):
localctx = PythonParser.ArgsContext(self, self._ctx, self.state)
self.enterRule(localctx, 32, self.RULE_args)
try:
self.enterOuterAlt(localctx, 1)
self.state = 340
self.match(PythonParser.STAR)
self.state = 341
self.named_parameter()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class KwargsContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def POWER(self):
return self.getToken(PythonParser.POWER, 0)
[docs]
def named_parameter(self):
return self.getTypedRuleContext(PythonParser.Named_parameterContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_kwargs
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterKwargs" ):
listener.enterKwargs(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitKwargs" ):
listener.exitKwargs(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitKwargs" ):
return visitor.visitKwargs(self)
else:
return visitor.visitChildren(self)
[docs]
def kwargs(self):
localctx = PythonParser.KwargsContext(self, self._ctx, self.state)
self.enterRule(localctx, 34, self.RULE_kwargs)
try:
self.enterOuterAlt(localctx, 1)
self.state = 343
self.match(PythonParser.POWER)
self.state = 344
self.named_parameter()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Def_parametersContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def def_parameter(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.Def_parameterContext)
else:
return self.getTypedRuleContext(PythonParser.Def_parameterContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.COMMA)
else:
return self.getToken(PythonParser.COMMA, i)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_def_parameters
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDef_parameters" ):
listener.enterDef_parameters(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDef_parameters" ):
listener.exitDef_parameters(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDef_parameters" ):
return visitor.visitDef_parameters(self)
else:
return visitor.visitChildren(self)
[docs]
def def_parameters(self):
localctx = PythonParser.Def_parametersContext(self, self._ctx, self.state)
self.enterRule(localctx, 36, self.RULE_def_parameters)
try:
self.enterOuterAlt(localctx, 1)
self.state = 346
self.def_parameter()
self.state = 351
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,39,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 347
self.match(PythonParser.COMMA)
self.state = 348
self.def_parameter()
self.state = 353
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,39,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Def_parameterContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def named_parameter(self):
return self.getTypedRuleContext(PythonParser.Named_parameterContext,0)
[docs]
def ASSIGN(self):
return self.getToken(PythonParser.ASSIGN, 0)
[docs]
def test(self):
return self.getTypedRuleContext(PythonParser.TestContext,0)
[docs]
def STAR(self):
return self.getToken(PythonParser.STAR, 0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_def_parameter
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDef_parameter" ):
listener.enterDef_parameter(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDef_parameter" ):
listener.exitDef_parameter(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDef_parameter" ):
return visitor.visitDef_parameter(self)
else:
return visitor.visitChildren(self)
[docs]
def def_parameter(self):
localctx = PythonParser.Def_parameterContext(self, self._ctx, self.state)
self.enterRule(localctx, 38, self.RULE_def_parameter)
self._la = 0 # Token type
try:
self.state = 360
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.TRUE, PythonParser.FALSE, PythonParser.NAME]:
self.enterOuterAlt(localctx, 1)
self.state = 354
self.named_parameter()
self.state = 357
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.ASSIGN:
self.state = 355
self.match(PythonParser.ASSIGN)
self.state = 356
self.test()
pass
elif token in [PythonParser.STAR]:
self.enterOuterAlt(localctx, 2)
self.state = 359
self.match(PythonParser.STAR)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Named_parameterContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def name(self):
return self.getTypedRuleContext(PythonParser.NameContext,0)
[docs]
def COLON(self):
return self.getToken(PythonParser.COLON, 0)
[docs]
def test(self):
return self.getTypedRuleContext(PythonParser.TestContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_named_parameter
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNamed_parameter" ):
listener.enterNamed_parameter(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNamed_parameter" ):
listener.exitNamed_parameter(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNamed_parameter" ):
return visitor.visitNamed_parameter(self)
else:
return visitor.visitChildren(self)
[docs]
def named_parameter(self):
localctx = PythonParser.Named_parameterContext(self, self._ctx, self.state)
self.enterRule(localctx, 40, self.RULE_named_parameter)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 362
self.name()
self.state = 365
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.COLON:
self.state = 363
self.match(PythonParser.COLON)
self.state = 364
self.test()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Simple_stmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def small_stmt(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.Small_stmtContext)
else:
return self.getTypedRuleContext(PythonParser.Small_stmtContext,i)
[docs]
def LINE_BREAK(self):
return self.getToken(PythonParser.LINE_BREAK, 0)
[docs]
def EOF(self):
return self.getToken(PythonParser.EOF, 0)
[docs]
def SEMI_COLON(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.SEMI_COLON)
else:
return self.getToken(PythonParser.SEMI_COLON, i)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_simple_stmt
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSimple_stmt" ):
listener.enterSimple_stmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSimple_stmt" ):
listener.exitSimple_stmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSimple_stmt" ):
return visitor.visitSimple_stmt(self)
else:
return visitor.visitChildren(self)
[docs]
def simple_stmt(self):
localctx = PythonParser.Simple_stmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 42, self.RULE_simple_stmt)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 367
self.small_stmt()
self.state = 372
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,43,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 368
self.match(PythonParser.SEMI_COLON)
self.state = 369
self.small_stmt()
self.state = 374
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,43,self._ctx)
self.state = 376
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.SEMI_COLON:
self.state = 375
self.match(PythonParser.SEMI_COLON)
self.state = 378
_la = self._input.LA(1)
if not(_la==PythonParser.EOF or _la==PythonParser.LINE_BREAK):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Small_stmtContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def getRuleIndex(self):
return PythonParser.RULE_small_stmt
[docs]
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
[docs]
class Assert_stmtContext(Small_stmtContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def ASSERT(self):
return self.getToken(PythonParser.ASSERT, 0)
[docs]
def test(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.TestContext)
else:
return self.getTypedRuleContext(PythonParser.TestContext,i)
[docs]
def COMMA(self):
return self.getToken(PythonParser.COMMA, 0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAssert_stmt" ):
listener.enterAssert_stmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAssert_stmt" ):
listener.exitAssert_stmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAssert_stmt" ):
return visitor.visitAssert_stmt(self)
else:
return visitor.visitChildren(self)
[docs]
class Nonlocal_stmtContext(Small_stmtContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def NONLOCAL(self):
return self.getToken(PythonParser.NONLOCAL, 0)
[docs]
def name(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.NameContext)
else:
return self.getTypedRuleContext(PythonParser.NameContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.COMMA)
else:
return self.getToken(PythonParser.COMMA, i)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNonlocal_stmt" ):
listener.enterNonlocal_stmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNonlocal_stmt" ):
listener.exitNonlocal_stmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNonlocal_stmt" ):
return visitor.visitNonlocal_stmt(self)
else:
return visitor.visitChildren(self)
[docs]
class Pass_stmtContext(Small_stmtContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def PASS(self):
return self.getToken(PythonParser.PASS, 0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPass_stmt" ):
listener.enterPass_stmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPass_stmt" ):
listener.exitPass_stmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPass_stmt" ):
return visitor.visitPass_stmt(self)
else:
return visitor.visitChildren(self)
[docs]
class Import_stmtContext(Small_stmtContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def IMPORT(self):
return self.getToken(PythonParser.IMPORT, 0)
[docs]
def dotted_as_names(self):
return self.getTypedRuleContext(PythonParser.Dotted_as_namesContext,0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterImport_stmt" ):
listener.enterImport_stmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitImport_stmt" ):
listener.exitImport_stmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitImport_stmt" ):
return visitor.visitImport_stmt(self)
else:
return visitor.visitChildren(self)
[docs]
class Expr_stmtContext(Small_stmtContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def testlist_star_expr(self):
return self.getTypedRuleContext(PythonParser.Testlist_star_exprContext,0)
[docs]
def assign_part(self):
return self.getTypedRuleContext(PythonParser.Assign_partContext,0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExpr_stmt" ):
listener.enterExpr_stmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExpr_stmt" ):
listener.exitExpr_stmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExpr_stmt" ):
return visitor.visitExpr_stmt(self)
else:
return visitor.visitChildren(self)
[docs]
class Raise_stmtContext(Small_stmtContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def RAISE(self):
return self.getToken(PythonParser.RAISE, 0)
[docs]
def test(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.TestContext)
else:
return self.getTypedRuleContext(PythonParser.TestContext,i)
[docs]
def FROM(self):
return self.getToken(PythonParser.FROM, 0)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.COMMA)
else:
return self.getToken(PythonParser.COMMA, i)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterRaise_stmt" ):
listener.enterRaise_stmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitRaise_stmt" ):
listener.exitRaise_stmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitRaise_stmt" ):
return visitor.visitRaise_stmt(self)
else:
return visitor.visitChildren(self)
[docs]
class Yield_stmtContext(Small_stmtContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def yield_expr(self):
return self.getTypedRuleContext(PythonParser.Yield_exprContext,0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterYield_stmt" ):
listener.enterYield_stmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitYield_stmt" ):
listener.exitYield_stmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitYield_stmt" ):
return visitor.visitYield_stmt(self)
else:
return visitor.visitChildren(self)
[docs]
class From_stmtContext(Small_stmtContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def FROM(self):
return self.getToken(PythonParser.FROM, 0)
[docs]
def IMPORT(self):
return self.getToken(PythonParser.IMPORT, 0)
[docs]
def dotted_name(self):
return self.getTypedRuleContext(PythonParser.Dotted_nameContext,0)
[docs]
def STAR(self):
return self.getToken(PythonParser.STAR, 0)
[docs]
def OPEN_PAREN(self):
return self.getToken(PythonParser.OPEN_PAREN, 0)
[docs]
def import_as_names(self):
return self.getTypedRuleContext(PythonParser.Import_as_namesContext,0)
[docs]
def CLOSE_PAREN(self):
return self.getToken(PythonParser.CLOSE_PAREN, 0)
[docs]
def DOT(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.DOT)
else:
return self.getToken(PythonParser.DOT, i)
[docs]
def ELLIPSIS(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.ELLIPSIS)
else:
return self.getToken(PythonParser.ELLIPSIS, i)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterFrom_stmt" ):
listener.enterFrom_stmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitFrom_stmt" ):
listener.exitFrom_stmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFrom_stmt" ):
return visitor.visitFrom_stmt(self)
else:
return visitor.visitChildren(self)
[docs]
class Global_stmtContext(Small_stmtContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def GLOBAL(self):
return self.getToken(PythonParser.GLOBAL, 0)
[docs]
def name(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.NameContext)
else:
return self.getTypedRuleContext(PythonParser.NameContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.COMMA)
else:
return self.getToken(PythonParser.COMMA, i)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterGlobal_stmt" ):
listener.enterGlobal_stmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitGlobal_stmt" ):
listener.exitGlobal_stmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitGlobal_stmt" ):
return visitor.visitGlobal_stmt(self)
else:
return visitor.visitChildren(self)
[docs]
class Continue_stmtContext(Small_stmtContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def CONTINUE(self):
return self.getToken(PythonParser.CONTINUE, 0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterContinue_stmt" ):
listener.enterContinue_stmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitContinue_stmt" ):
listener.exitContinue_stmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitContinue_stmt" ):
return visitor.visitContinue_stmt(self)
else:
return visitor.visitChildren(self)
[docs]
class Exec_stmtContext(Small_stmtContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def EXEC(self):
return self.getToken(PythonParser.EXEC, 0)
[docs]
def expr(self):
return self.getTypedRuleContext(PythonParser.ExprContext,0)
[docs]
def IN(self):
return self.getToken(PythonParser.IN, 0)
[docs]
def test(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.TestContext)
else:
return self.getTypedRuleContext(PythonParser.TestContext,i)
[docs]
def COMMA(self):
return self.getToken(PythonParser.COMMA, 0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExec_stmt" ):
listener.enterExec_stmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExec_stmt" ):
listener.exitExec_stmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExec_stmt" ):
return visitor.visitExec_stmt(self)
else:
return visitor.visitChildren(self)
[docs]
class Break_stmtContext(Small_stmtContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def BREAK(self):
return self.getToken(PythonParser.BREAK, 0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterBreak_stmt" ):
listener.enterBreak_stmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitBreak_stmt" ):
listener.exitBreak_stmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBreak_stmt" ):
return visitor.visitBreak_stmt(self)
else:
return visitor.visitChildren(self)
[docs]
class Del_stmtContext(Small_stmtContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def DEL(self):
return self.getToken(PythonParser.DEL, 0)
[docs]
def exprlist(self):
return self.getTypedRuleContext(PythonParser.ExprlistContext,0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDel_stmt" ):
listener.enterDel_stmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDel_stmt" ):
listener.exitDel_stmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDel_stmt" ):
return visitor.visitDel_stmt(self)
else:
return visitor.visitChildren(self)
[docs]
class Print_stmtContext(Small_stmtContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def PRINT(self):
return self.getToken(PythonParser.PRINT, 0)
[docs]
def RIGHT_SHIFT(self):
return self.getToken(PythonParser.RIGHT_SHIFT, 0)
[docs]
def test(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.TestContext)
else:
return self.getTypedRuleContext(PythonParser.TestContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.COMMA)
else:
return self.getToken(PythonParser.COMMA, i)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterPrint_stmt" ):
listener.enterPrint_stmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitPrint_stmt" ):
listener.exitPrint_stmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPrint_stmt" ):
return visitor.visitPrint_stmt(self)
else:
return visitor.visitChildren(self)
[docs]
class Return_stmtContext(Small_stmtContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
super().__init__(parser)
self.copyFrom(ctx)
[docs]
def RETURN(self):
return self.getToken(PythonParser.RETURN, 0)
[docs]
def testlist(self):
return self.getTypedRuleContext(PythonParser.TestlistContext,0)
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterReturn_stmt" ):
listener.enterReturn_stmt(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitReturn_stmt" ):
listener.exitReturn_stmt(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitReturn_stmt" ):
return visitor.visitReturn_stmt(self)
else:
return visitor.visitChildren(self)
[docs]
def small_stmt(self):
localctx = PythonParser.Small_stmtContext(self, self._ctx, self.state)
self.enterRule(localctx, 44, self.RULE_small_stmt)
self._la = 0 # Token type
try:
self.state = 504
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,65,self._ctx)
if la_ == 1:
localctx = PythonParser.Expr_stmtContext(self, localctx)
self.enterOuterAlt(localctx, 1)
self.state = 380
self.testlist_star_expr()
self.state = 382
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
if la_ == 1:
self.state = 381
self.assign_part()
pass
elif la_ == 2:
localctx = PythonParser.Print_stmtContext(self, localctx)
self.enterOuterAlt(localctx, 2)
self.state = 384
if not self.CheckVersion(2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.CheckVersion(2)")
self.state = 385
self.match(PythonParser.PRINT)
self.state = 408
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.NONE, PythonParser.LAMBDA, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
self.state = 386
self.test()
self.state = 391
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,46,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 387
self.match(PythonParser.COMMA)
self.state = 388
self.test()
self.state = 393
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,46,self._ctx)
self.state = 395
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.COMMA:
self.state = 394
self.match(PythonParser.COMMA)
pass
elif token in [PythonParser.RIGHT_SHIFT]:
self.state = 397
self.match(PythonParser.RIGHT_SHIFT)
self.state = 398
self.test()
self.state = 401
self._errHandler.sync(self)
_alt = 1
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 399
self.match(PythonParser.COMMA)
self.state = 400
self.test()
else:
raise NoViableAltException(self)
self.state = 403
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,48,self._ctx)
self.state = 406
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.COMMA:
self.state = 405
self.match(PythonParser.COMMA)
pass
else:
raise NoViableAltException(self)
self.SetVersion(2);
pass
elif la_ == 3:
localctx = PythonParser.Del_stmtContext(self, localctx)
self.enterOuterAlt(localctx, 3)
self.state = 412
self.match(PythonParser.DEL)
self.state = 413
self.exprlist()
pass
elif la_ == 4:
localctx = PythonParser.Pass_stmtContext(self, localctx)
self.enterOuterAlt(localctx, 4)
self.state = 414
self.match(PythonParser.PASS)
pass
elif la_ == 5:
localctx = PythonParser.Break_stmtContext(self, localctx)
self.enterOuterAlt(localctx, 5)
self.state = 415
self.match(PythonParser.BREAK)
pass
elif la_ == 6:
localctx = PythonParser.Continue_stmtContext(self, localctx)
self.enterOuterAlt(localctx, 6)
self.state = 416
self.match(PythonParser.CONTINUE)
pass
elif la_ == 7:
localctx = PythonParser.Return_stmtContext(self, localctx)
self.enterOuterAlt(localctx, 7)
self.state = 417
self.match(PythonParser.RETURN)
self.state = 419
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
self.state = 418
self.testlist()
pass
elif la_ == 8:
localctx = PythonParser.Raise_stmtContext(self, localctx)
self.enterOuterAlt(localctx, 8)
self.state = 421
self.match(PythonParser.RAISE)
self.state = 431
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
self.state = 422
self.test()
self.state = 429
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.COMMA:
self.state = 423
self.match(PythonParser.COMMA)
self.state = 424
self.test()
self.state = 427
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.COMMA:
self.state = 425
self.match(PythonParser.COMMA)
self.state = 426
self.test()
self.state = 435
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.FROM:
self.state = 433
self.match(PythonParser.FROM)
self.state = 434
self.test()
pass
elif la_ == 9:
localctx = PythonParser.Yield_stmtContext(self, localctx)
self.enterOuterAlt(localctx, 9)
self.state = 437
self.yield_expr()
pass
elif la_ == 10:
localctx = PythonParser.Import_stmtContext(self, localctx)
self.enterOuterAlt(localctx, 10)
self.state = 438
self.match(PythonParser.IMPORT)
self.state = 439
self.dotted_as_names()
pass
elif la_ == 11:
localctx = PythonParser.From_stmtContext(self, localctx)
self.enterOuterAlt(localctx, 11)
self.state = 440
self.match(PythonParser.FROM)
self.state = 453
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,58,self._ctx)
if la_ == 1:
self.state = 444
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==PythonParser.DOT or _la==PythonParser.ELLIPSIS:
self.state = 441
_la = self._input.LA(1)
if not(_la==PythonParser.DOT or _la==PythonParser.ELLIPSIS):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 446
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 447
self.dotted_name(0)
pass
elif la_ == 2:
self.state = 449
self._errHandler.sync(self)
_la = self._input.LA(1)
while True:
self.state = 448
_la = self._input.LA(1)
if not(_la==PythonParser.DOT or _la==PythonParser.ELLIPSIS):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 451
self._errHandler.sync(self)
_la = self._input.LA(1)
if not (_la==PythonParser.DOT or _la==PythonParser.ELLIPSIS):
break
pass
self.state = 455
self.match(PythonParser.IMPORT)
self.state = 462
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.STAR]:
self.state = 456
self.match(PythonParser.STAR)
pass
elif token in [PythonParser.OPEN_PAREN]:
self.state = 457
self.match(PythonParser.OPEN_PAREN)
self.state = 458
self.import_as_names()
self.state = 459
self.match(PythonParser.CLOSE_PAREN)
pass
elif token in [PythonParser.TRUE, PythonParser.FALSE, PythonParser.NAME]:
self.state = 461
self.import_as_names()
pass
else:
raise NoViableAltException(self)
pass
elif la_ == 12:
localctx = PythonParser.Global_stmtContext(self, localctx)
self.enterOuterAlt(localctx, 12)
self.state = 464
self.match(PythonParser.GLOBAL)
self.state = 465
self.name()
self.state = 470
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==PythonParser.COMMA:
self.state = 466
self.match(PythonParser.COMMA)
self.state = 467
self.name()
self.state = 472
self._errHandler.sync(self)
_la = self._input.LA(1)
pass
elif la_ == 13:
localctx = PythonParser.Exec_stmtContext(self, localctx)
self.enterOuterAlt(localctx, 13)
self.state = 473
if not self.CheckVersion(2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.CheckVersion(2)")
self.state = 474
self.match(PythonParser.EXEC)
self.state = 475
self.expr(0)
self.state = 482
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.IN:
self.state = 476
self.match(PythonParser.IN)
self.state = 477
self.test()
self.state = 480
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.COMMA:
self.state = 478
self.match(PythonParser.COMMA)
self.state = 479
self.test()
self.SetVersion(2);
pass
elif la_ == 14:
localctx = PythonParser.Assert_stmtContext(self, localctx)
self.enterOuterAlt(localctx, 14)
self.state = 486
self.match(PythonParser.ASSERT)
self.state = 487
self.test()
self.state = 490
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.COMMA:
self.state = 488
self.match(PythonParser.COMMA)
self.state = 489
self.test()
pass
elif la_ == 15:
localctx = PythonParser.Nonlocal_stmtContext(self, localctx)
self.enterOuterAlt(localctx, 15)
self.state = 492
if not self.CheckVersion(3):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.CheckVersion(3)")
self.state = 493
self.match(PythonParser.NONLOCAL)
self.state = 494
self.name()
self.state = 499
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==PythonParser.COMMA:
self.state = 495
self.match(PythonParser.COMMA)
self.state = 496
self.name()
self.state = 501
self._errHandler.sync(self)
_la = self._input.LA(1)
self.SetVersion(3);
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Testlist_star_exprContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.COMMA)
else:
return self.getToken(PythonParser.COMMA, i)
[docs]
def test(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.TestContext)
else:
return self.getTypedRuleContext(PythonParser.TestContext,i)
[docs]
def star_expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.Star_exprContext)
else:
return self.getTypedRuleContext(PythonParser.Star_exprContext,i)
[docs]
def testlist(self):
return self.getTypedRuleContext(PythonParser.TestlistContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_testlist_star_expr
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTestlist_star_expr" ):
listener.enterTestlist_star_expr(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTestlist_star_expr" ):
listener.exitTestlist_star_expr(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTestlist_star_expr" ):
return visitor.visitTestlist_star_expr(self)
else:
return visitor.visitChildren(self)
[docs]
def testlist_star_expr(self):
localctx = PythonParser.Testlist_star_exprContext(self, self._ctx, self.state)
self.enterRule(localctx, 46, self.RULE_testlist_star_expr)
try:
self.state = 521
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,69,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 512
self._errHandler.sync(self)
_alt = 1
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 508
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.NONE, PythonParser.LAMBDA, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
self.state = 506
self.test()
pass
elif token in [PythonParser.STAR]:
self.state = 507
self.star_expr()
pass
else:
raise NoViableAltException(self)
self.state = 510
self.match(PythonParser.COMMA)
else:
raise NoViableAltException(self)
self.state = 514
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,67,self._ctx)
self.state = 518
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,68,self._ctx)
if la_ == 1:
self.state = 516
self.test()
elif la_ == 2:
self.state = 517
self.star_expr()
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 520
self.testlist()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Star_exprContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def STAR(self):
return self.getToken(PythonParser.STAR, 0)
[docs]
def expr(self):
return self.getTypedRuleContext(PythonParser.ExprContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_star_expr
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterStar_expr" ):
listener.enterStar_expr(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitStar_expr" ):
listener.exitStar_expr(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitStar_expr" ):
return visitor.visitStar_expr(self)
else:
return visitor.visitChildren(self)
[docs]
def star_expr(self):
localctx = PythonParser.Star_exprContext(self, self._ctx, self.state)
self.enterRule(localctx, 48, self.RULE_star_expr)
try:
self.enterOuterAlt(localctx, 1)
self.state = 523
self.match(PythonParser.STAR)
self.state = 524
self.expr(0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Assign_partContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
self.op = None # Token
[docs]
def ASSIGN(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.ASSIGN)
else:
return self.getToken(PythonParser.ASSIGN, i)
[docs]
def testlist_star_expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.Testlist_star_exprContext)
else:
return self.getTypedRuleContext(PythonParser.Testlist_star_exprContext,i)
[docs]
def yield_expr(self):
return self.getTypedRuleContext(PythonParser.Yield_exprContext,0)
[docs]
def COLON(self):
return self.getToken(PythonParser.COLON, 0)
[docs]
def test(self):
return self.getTypedRuleContext(PythonParser.TestContext,0)
[docs]
def testlist(self):
return self.getTypedRuleContext(PythonParser.TestlistContext,0)
[docs]
def ADD_ASSIGN(self):
return self.getToken(PythonParser.ADD_ASSIGN, 0)
[docs]
def SUB_ASSIGN(self):
return self.getToken(PythonParser.SUB_ASSIGN, 0)
[docs]
def MULT_ASSIGN(self):
return self.getToken(PythonParser.MULT_ASSIGN, 0)
[docs]
def AT_ASSIGN(self):
return self.getToken(PythonParser.AT_ASSIGN, 0)
[docs]
def DIV_ASSIGN(self):
return self.getToken(PythonParser.DIV_ASSIGN, 0)
[docs]
def MOD_ASSIGN(self):
return self.getToken(PythonParser.MOD_ASSIGN, 0)
[docs]
def AND_ASSIGN(self):
return self.getToken(PythonParser.AND_ASSIGN, 0)
[docs]
def OR_ASSIGN(self):
return self.getToken(PythonParser.OR_ASSIGN, 0)
[docs]
def XOR_ASSIGN(self):
return self.getToken(PythonParser.XOR_ASSIGN, 0)
[docs]
def LEFT_SHIFT_ASSIGN(self):
return self.getToken(PythonParser.LEFT_SHIFT_ASSIGN, 0)
[docs]
def RIGHT_SHIFT_ASSIGN(self):
return self.getToken(PythonParser.RIGHT_SHIFT_ASSIGN, 0)
[docs]
def POWER_ASSIGN(self):
return self.getToken(PythonParser.POWER_ASSIGN, 0)
[docs]
def IDIV_ASSIGN(self):
return self.getToken(PythonParser.IDIV_ASSIGN, 0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_assign_part
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAssign_part" ):
listener.enterAssign_part(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAssign_part" ):
listener.exitAssign_part(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAssign_part" ):
return visitor.visitAssign_part(self)
else:
return visitor.visitChildren(self)
[docs]
def assign_part(self):
localctx = PythonParser.Assign_partContext(self, self._ctx, self.state)
self.enterRule(localctx, 50, self.RULE_assign_part)
self._la = 0 # Token type
try:
self.state = 556
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 526
self.match(PythonParser.ASSIGN)
self.state = 540
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.NONE, PythonParser.LAMBDA, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.STAR, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
self.state = 527
self.testlist_star_expr()
self.state = 532
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,70,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 528
self.match(PythonParser.ASSIGN)
self.state = 529
self.testlist_star_expr()
self.state = 534
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,70,self._ctx)
self.state = 537
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.ASSIGN:
self.state = 535
self.match(PythonParser.ASSIGN)
self.state = 536
self.yield_expr()
pass
elif token in [PythonParser.YIELD]:
self.state = 539
self.yield_expr()
pass
else:
raise NoViableAltException(self)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 542
if not self.CheckVersion(3):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.CheckVersion(3)")
self.state = 543
self.match(PythonParser.COLON)
self.state = 544
self.test()
self.state = 547
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.ASSIGN:
self.state = 545
self.match(PythonParser.ASSIGN)
self.state = 546
self.testlist()
self.SetVersion(3);
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 551
localctx.op = self._input.LT(1)
_la = self._input.LA(1)
if not(((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & ((1 << (PythonParser.ADD_ASSIGN - 70)) | (1 << (PythonParser.SUB_ASSIGN - 70)) | (1 << (PythonParser.MULT_ASSIGN - 70)) | (1 << (PythonParser.AT_ASSIGN - 70)) | (1 << (PythonParser.DIV_ASSIGN - 70)) | (1 << (PythonParser.MOD_ASSIGN - 70)) | (1 << (PythonParser.AND_ASSIGN - 70)) | (1 << (PythonParser.OR_ASSIGN - 70)) | (1 << (PythonParser.XOR_ASSIGN - 70)) | (1 << (PythonParser.LEFT_SHIFT_ASSIGN - 70)) | (1 << (PythonParser.RIGHT_SHIFT_ASSIGN - 70)) | (1 << (PythonParser.POWER_ASSIGN - 70)) | (1 << (PythonParser.IDIV_ASSIGN - 70)))) != 0)):
localctx.op = self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 554
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.YIELD]:
self.state = 552
self.yield_expr()
pass
elif token in [PythonParser.NONE, PythonParser.LAMBDA, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
self.state = 553
self.testlist()
pass
else:
raise NoViableAltException(self)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ExprlistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.ExprContext)
else:
return self.getTypedRuleContext(PythonParser.ExprContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.COMMA)
else:
return self.getToken(PythonParser.COMMA, i)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_exprlist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExprlist" ):
listener.enterExprlist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExprlist" ):
listener.exitExprlist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExprlist" ):
return visitor.visitExprlist(self)
else:
return visitor.visitChildren(self)
[docs]
def exprlist(self):
localctx = PythonParser.ExprlistContext(self, self._ctx, self.state)
self.enterRule(localctx, 52, self.RULE_exprlist)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 558
self.expr(0)
self.state = 563
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,76,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 559
self.match(PythonParser.COMMA)
self.state = 560
self.expr(0)
self.state = 565
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,76,self._ctx)
self.state = 567
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.COMMA:
self.state = 566
self.match(PythonParser.COMMA)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Import_as_namesContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def import_as_name(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.Import_as_nameContext)
else:
return self.getTypedRuleContext(PythonParser.Import_as_nameContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.COMMA)
else:
return self.getToken(PythonParser.COMMA, i)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_import_as_names
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterImport_as_names" ):
listener.enterImport_as_names(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitImport_as_names" ):
listener.exitImport_as_names(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitImport_as_names" ):
return visitor.visitImport_as_names(self)
else:
return visitor.visitChildren(self)
[docs]
def import_as_names(self):
localctx = PythonParser.Import_as_namesContext(self, self._ctx, self.state)
self.enterRule(localctx, 54, self.RULE_import_as_names)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 569
self.import_as_name()
self.state = 574
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,78,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 570
self.match(PythonParser.COMMA)
self.state = 571
self.import_as_name()
self.state = 576
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,78,self._ctx)
self.state = 578
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.COMMA:
self.state = 577
self.match(PythonParser.COMMA)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Import_as_nameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def name(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.NameContext)
else:
return self.getTypedRuleContext(PythonParser.NameContext,i)
[docs]
def AS(self):
return self.getToken(PythonParser.AS, 0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_import_as_name
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterImport_as_name" ):
listener.enterImport_as_name(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitImport_as_name" ):
listener.exitImport_as_name(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitImport_as_name" ):
return visitor.visitImport_as_name(self)
else:
return visitor.visitChildren(self)
[docs]
def import_as_name(self):
localctx = PythonParser.Import_as_nameContext(self, self._ctx, self.state)
self.enterRule(localctx, 56, self.RULE_import_as_name)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 580
self.name()
self.state = 583
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.AS:
self.state = 581
self.match(PythonParser.AS)
self.state = 582
self.name()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Dotted_as_namesContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def dotted_as_name(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.Dotted_as_nameContext)
else:
return self.getTypedRuleContext(PythonParser.Dotted_as_nameContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.COMMA)
else:
return self.getToken(PythonParser.COMMA, i)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_dotted_as_names
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDotted_as_names" ):
listener.enterDotted_as_names(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDotted_as_names" ):
listener.exitDotted_as_names(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDotted_as_names" ):
return visitor.visitDotted_as_names(self)
else:
return visitor.visitChildren(self)
[docs]
def dotted_as_names(self):
localctx = PythonParser.Dotted_as_namesContext(self, self._ctx, self.state)
self.enterRule(localctx, 58, self.RULE_dotted_as_names)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 585
self.dotted_as_name()
self.state = 590
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==PythonParser.COMMA:
self.state = 586
self.match(PythonParser.COMMA)
self.state = 587
self.dotted_as_name()
self.state = 592
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Dotted_as_nameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def dotted_name(self):
return self.getTypedRuleContext(PythonParser.Dotted_nameContext,0)
[docs]
def AS(self):
return self.getToken(PythonParser.AS, 0)
[docs]
def name(self):
return self.getTypedRuleContext(PythonParser.NameContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_dotted_as_name
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDotted_as_name" ):
listener.enterDotted_as_name(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDotted_as_name" ):
listener.exitDotted_as_name(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDotted_as_name" ):
return visitor.visitDotted_as_name(self)
else:
return visitor.visitChildren(self)
[docs]
def dotted_as_name(self):
localctx = PythonParser.Dotted_as_nameContext(self, self._ctx, self.state)
self.enterRule(localctx, 60, self.RULE_dotted_as_name)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 593
self.dotted_name(0)
self.state = 596
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.AS:
self.state = 594
self.match(PythonParser.AS)
self.state = 595
self.name()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TestContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def logical_test(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.Logical_testContext)
else:
return self.getTypedRuleContext(PythonParser.Logical_testContext,i)
[docs]
def IF(self):
return self.getToken(PythonParser.IF, 0)
[docs]
def ELSE(self):
return self.getToken(PythonParser.ELSE, 0)
[docs]
def test(self):
return self.getTypedRuleContext(PythonParser.TestContext,0)
[docs]
def LAMBDA(self):
return self.getToken(PythonParser.LAMBDA, 0)
[docs]
def COLON(self):
return self.getToken(PythonParser.COLON, 0)
[docs]
def varargslist(self):
return self.getTypedRuleContext(PythonParser.VarargslistContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_test
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTest" ):
listener.enterTest(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTest" ):
listener.exitTest(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTest" ):
return visitor.visitTest(self)
else:
return visitor.visitChildren(self)
[docs]
def test(self):
localctx = PythonParser.TestContext(self, self._ctx, self.state)
self.enterRule(localctx, 62, self.RULE_test)
self._la = 0 # Token type
try:
self.state = 612
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.NONE, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
self.enterOuterAlt(localctx, 1)
self.state = 598
self.logical_test(0)
self.state = 604
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,83,self._ctx)
if la_ == 1:
self.state = 599
self.match(PythonParser.IF)
self.state = 600
self.logical_test(0)
self.state = 601
self.match(PythonParser.ELSE)
self.state = 602
self.test()
pass
elif token in [PythonParser.LAMBDA]:
self.enterOuterAlt(localctx, 2)
self.state = 606
self.match(PythonParser.LAMBDA)
self.state = 608
self._errHandler.sync(self)
_la = self._input.LA(1)
if ((((_la - 39)) & ~0x3f) == 0 and ((1 << (_la - 39)) & ((1 << (PythonParser.TRUE - 39)) | (1 << (PythonParser.FALSE - 39)) | (1 << (PythonParser.STAR - 39)) | (1 << (PythonParser.POWER - 39)) | (1 << (PythonParser.NAME - 39)))) != 0):
self.state = 607
self.varargslist()
self.state = 610
self.match(PythonParser.COLON)
self.state = 611
self.test()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class VarargslistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def varargs(self):
return self.getTypedRuleContext(PythonParser.VarargsContext,0)
[docs]
def varkwargs(self):
return self.getTypedRuleContext(PythonParser.VarkwargsContext,0)
[docs]
def vardef_parameters(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.Vardef_parametersContext)
else:
return self.getTypedRuleContext(PythonParser.Vardef_parametersContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.COMMA)
else:
return self.getToken(PythonParser.COMMA, i)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_varargslist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterVarargslist" ):
listener.enterVarargslist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitVarargslist" ):
listener.exitVarargslist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitVarargslist" ):
return visitor.visitVarargslist(self)
else:
return visitor.visitChildren(self)
[docs]
def varargslist(self):
localctx = PythonParser.VarargslistContext(self, self._ctx, self.state)
self.enterRule(localctx, 64, self.RULE_varargslist)
self._la = 0 # Token type
try:
self.state = 638
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,92,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 617
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,86,self._ctx)
if la_ == 1:
self.state = 614
self.vardef_parameters()
self.state = 615
self.match(PythonParser.COMMA)
self.state = 629
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.STAR]:
self.state = 619
self.varargs()
self.state = 622
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,87,self._ctx)
if la_ == 1:
self.state = 620
self.match(PythonParser.COMMA)
self.state = 621
self.vardef_parameters()
self.state = 626
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,88,self._ctx)
if la_ == 1:
self.state = 624
self.match(PythonParser.COMMA)
self.state = 625
self.varkwargs()
pass
elif token in [PythonParser.POWER]:
self.state = 628
self.varkwargs()
pass
else:
raise NoViableAltException(self)
self.state = 632
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.COMMA:
self.state = 631
self.match(PythonParser.COMMA)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 634
self.vardef_parameters()
self.state = 636
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.COMMA:
self.state = 635
self.match(PythonParser.COMMA)
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Vardef_parametersContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def vardef_parameter(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.Vardef_parameterContext)
else:
return self.getTypedRuleContext(PythonParser.Vardef_parameterContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.COMMA)
else:
return self.getToken(PythonParser.COMMA, i)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_vardef_parameters
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterVardef_parameters" ):
listener.enterVardef_parameters(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitVardef_parameters" ):
listener.exitVardef_parameters(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitVardef_parameters" ):
return visitor.visitVardef_parameters(self)
else:
return visitor.visitChildren(self)
[docs]
def vardef_parameters(self):
localctx = PythonParser.Vardef_parametersContext(self, self._ctx, self.state)
self.enterRule(localctx, 66, self.RULE_vardef_parameters)
try:
self.enterOuterAlt(localctx, 1)
self.state = 640
self.vardef_parameter()
self.state = 645
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,93,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 641
self.match(PythonParser.COMMA)
self.state = 642
self.vardef_parameter()
self.state = 647
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,93,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Vardef_parameterContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def name(self):
return self.getTypedRuleContext(PythonParser.NameContext,0)
[docs]
def ASSIGN(self):
return self.getToken(PythonParser.ASSIGN, 0)
[docs]
def test(self):
return self.getTypedRuleContext(PythonParser.TestContext,0)
[docs]
def STAR(self):
return self.getToken(PythonParser.STAR, 0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_vardef_parameter
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterVardef_parameter" ):
listener.enterVardef_parameter(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitVardef_parameter" ):
listener.exitVardef_parameter(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitVardef_parameter" ):
return visitor.visitVardef_parameter(self)
else:
return visitor.visitChildren(self)
[docs]
def vardef_parameter(self):
localctx = PythonParser.Vardef_parameterContext(self, self._ctx, self.state)
self.enterRule(localctx, 68, self.RULE_vardef_parameter)
self._la = 0 # Token type
try:
self.state = 654
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.TRUE, PythonParser.FALSE, PythonParser.NAME]:
self.enterOuterAlt(localctx, 1)
self.state = 648
self.name()
self.state = 651
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.ASSIGN:
self.state = 649
self.match(PythonParser.ASSIGN)
self.state = 650
self.test()
pass
elif token in [PythonParser.STAR]:
self.enterOuterAlt(localctx, 2)
self.state = 653
self.match(PythonParser.STAR)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class VarargsContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def STAR(self):
return self.getToken(PythonParser.STAR, 0)
[docs]
def name(self):
return self.getTypedRuleContext(PythonParser.NameContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_varargs
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterVarargs" ):
listener.enterVarargs(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitVarargs" ):
listener.exitVarargs(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitVarargs" ):
return visitor.visitVarargs(self)
else:
return visitor.visitChildren(self)
[docs]
def varargs(self):
localctx = PythonParser.VarargsContext(self, self._ctx, self.state)
self.enterRule(localctx, 70, self.RULE_varargs)
try:
self.enterOuterAlt(localctx, 1)
self.state = 656
self.match(PythonParser.STAR)
self.state = 657
self.name()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class VarkwargsContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def POWER(self):
return self.getToken(PythonParser.POWER, 0)
[docs]
def name(self):
return self.getTypedRuleContext(PythonParser.NameContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_varkwargs
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterVarkwargs" ):
listener.enterVarkwargs(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitVarkwargs" ):
listener.exitVarkwargs(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitVarkwargs" ):
return visitor.visitVarkwargs(self)
else:
return visitor.visitChildren(self)
[docs]
def varkwargs(self):
localctx = PythonParser.VarkwargsContext(self, self._ctx, self.state)
self.enterRule(localctx, 72, self.RULE_varkwargs)
try:
self.enterOuterAlt(localctx, 1)
self.state = 659
self.match(PythonParser.POWER)
self.state = 660
self.name()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Logical_testContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
self.op = None # Token
[docs]
def comparison(self):
return self.getTypedRuleContext(PythonParser.ComparisonContext,0)
[docs]
def NOT(self):
return self.getToken(PythonParser.NOT, 0)
[docs]
def logical_test(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.Logical_testContext)
else:
return self.getTypedRuleContext(PythonParser.Logical_testContext,i)
[docs]
def AND(self):
return self.getToken(PythonParser.AND, 0)
[docs]
def OR(self):
return self.getToken(PythonParser.OR, 0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_logical_test
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterLogical_test" ):
listener.enterLogical_test(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitLogical_test" ):
listener.exitLogical_test(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLogical_test" ):
return visitor.visitLogical_test(self)
else:
return visitor.visitChildren(self)
[docs]
def logical_test(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = PythonParser.Logical_testContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 74
self.enterRecursionRule(localctx, 74, self.RULE_logical_test, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 666
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.NONE, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
self.state = 663
self.comparison(0)
pass
elif token in [PythonParser.NOT]:
self.state = 664
self.match(PythonParser.NOT)
self.state = 665
self.logical_test(3)
pass
else:
raise NoViableAltException(self)
self._ctx.stop = self._input.LT(-1)
self.state = 676
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,98,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 674
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,97,self._ctx)
if la_ == 1:
localctx = PythonParser.Logical_testContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_logical_test)
self.state = 668
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 669
localctx.op = self.match(PythonParser.AND)
self.state = 670
self.logical_test(3)
pass
elif la_ == 2:
localctx = PythonParser.Logical_testContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_logical_test)
self.state = 671
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 672
localctx.op = self.match(PythonParser.OR)
self.state = 673
self.logical_test(2)
pass
self.state = 678
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,98,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class ComparisonContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
self.optional = None # Token
[docs]
def expr(self):
return self.getTypedRuleContext(PythonParser.ExprContext,0)
[docs]
def comparison(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.ComparisonContext)
else:
return self.getTypedRuleContext(PythonParser.ComparisonContext,i)
[docs]
def LESS_THAN(self):
return self.getToken(PythonParser.LESS_THAN, 0)
[docs]
def GREATER_THAN(self):
return self.getToken(PythonParser.GREATER_THAN, 0)
[docs]
def EQUALS(self):
return self.getToken(PythonParser.EQUALS, 0)
[docs]
def GT_EQ(self):
return self.getToken(PythonParser.GT_EQ, 0)
[docs]
def LT_EQ(self):
return self.getToken(PythonParser.LT_EQ, 0)
[docs]
def NOT_EQ_1(self):
return self.getToken(PythonParser.NOT_EQ_1, 0)
[docs]
def NOT_EQ_2(self):
return self.getToken(PythonParser.NOT_EQ_2, 0)
[docs]
def IN(self):
return self.getToken(PythonParser.IN, 0)
[docs]
def IS(self):
return self.getToken(PythonParser.IS, 0)
[docs]
def NOT(self):
return self.getToken(PythonParser.NOT, 0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_comparison
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComparison" ):
listener.enterComparison(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComparison" ):
listener.exitComparison(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComparison" ):
return visitor.visitComparison(self)
else:
return visitor.visitChildren(self)
[docs]
def comparison(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = PythonParser.ComparisonContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 76
self.enterRecursionRule(localctx, 76, self.RULE_comparison, _p)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 680
self.expr(0)
self._ctx.stop = self._input.LT(-1)
self.state = 703
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,102,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = PythonParser.ComparisonContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_comparison)
self.state = 682
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 698
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.LESS_THAN]:
self.state = 683
self.match(PythonParser.LESS_THAN)
pass
elif token in [PythonParser.GREATER_THAN]:
self.state = 684
self.match(PythonParser.GREATER_THAN)
pass
elif token in [PythonParser.EQUALS]:
self.state = 685
self.match(PythonParser.EQUALS)
pass
elif token in [PythonParser.GT_EQ]:
self.state = 686
self.match(PythonParser.GT_EQ)
pass
elif token in [PythonParser.LT_EQ]:
self.state = 687
self.match(PythonParser.LT_EQ)
pass
elif token in [PythonParser.NOT_EQ_1]:
self.state = 688
self.match(PythonParser.NOT_EQ_1)
pass
elif token in [PythonParser.NOT_EQ_2]:
self.state = 689
self.match(PythonParser.NOT_EQ_2)
pass
elif token in [PythonParser.IN, PythonParser.NOT]:
self.state = 691
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.NOT:
self.state = 690
localctx.optional = self.match(PythonParser.NOT)
self.state = 693
self.match(PythonParser.IN)
pass
elif token in [PythonParser.IS]:
self.state = 694
self.match(PythonParser.IS)
self.state = 696
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.NOT:
self.state = 695
localctx.optional = self.match(PythonParser.NOT)
pass
else:
raise NoViableAltException(self)
self.state = 700
self.comparison(3)
self.state = 705
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,102,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class ExprContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
self.op = None # Token
[docs]
def atom(self):
return self.getTypedRuleContext(PythonParser.AtomContext,0)
[docs]
def AWAIT(self):
return self.getToken(PythonParser.AWAIT, 0)
[docs]
def trailer(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.TrailerContext)
else:
return self.getTypedRuleContext(PythonParser.TrailerContext,i)
[docs]
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.ExprContext)
else:
return self.getTypedRuleContext(PythonParser.ExprContext,i)
[docs]
def ADD(self):
return self.getToken(PythonParser.ADD, 0)
[docs]
def MINUS(self):
return self.getToken(PythonParser.MINUS, 0)
[docs]
def NOT_OP(self):
return self.getToken(PythonParser.NOT_OP, 0)
[docs]
def POWER(self):
return self.getToken(PythonParser.POWER, 0)
[docs]
def STAR(self):
return self.getToken(PythonParser.STAR, 0)
[docs]
def DIV(self):
return self.getToken(PythonParser.DIV, 0)
[docs]
def MOD(self):
return self.getToken(PythonParser.MOD, 0)
[docs]
def IDIV(self):
return self.getToken(PythonParser.IDIV, 0)
[docs]
def AT(self):
return self.getToken(PythonParser.AT, 0)
[docs]
def LEFT_SHIFT(self):
return self.getToken(PythonParser.LEFT_SHIFT, 0)
[docs]
def RIGHT_SHIFT(self):
return self.getToken(PythonParser.RIGHT_SHIFT, 0)
[docs]
def AND_OP(self):
return self.getToken(PythonParser.AND_OP, 0)
[docs]
def XOR(self):
return self.getToken(PythonParser.XOR, 0)
[docs]
def OR_OP(self):
return self.getToken(PythonParser.OR_OP, 0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_expr
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterExpr" ):
listener.enterExpr(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitExpr" ):
listener.exitExpr(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitExpr" ):
return visitor.visitExpr(self)
else:
return visitor.visitChildren(self)
[docs]
def expr(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = PythonParser.ExprContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 78
self.enterRecursionRule(localctx, 78, self.RULE_expr, _p)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 719
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,105,self._ctx)
if la_ == 1:
self.state = 708
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.AWAIT:
self.state = 707
self.match(PythonParser.AWAIT)
self.state = 710
self.atom()
self.state = 714
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,104,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 711
self.trailer()
self.state = 716
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,104,self._ctx)
pass
elif la_ == 2:
self.state = 717
localctx.op = self._input.LT(1)
_la = self._input.LA(1)
if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0)):
localctx.op = self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 718
self.expr(7)
pass
self._ctx.stop = self._input.LT(-1)
self.state = 744
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,107,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 742
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,106,self._ctx)
if la_ == 1:
localctx = PythonParser.ExprContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
self.state = 721
if not self.precpred(self._ctx, 8):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
self.state = 722
localctx.op = self.match(PythonParser.POWER)
self.state = 723
self.expr(8)
pass
elif la_ == 2:
localctx = PythonParser.ExprContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
self.state = 724
if not self.precpred(self._ctx, 6):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
self.state = 725
localctx.op = self._input.LT(1)
_la = self._input.LA(1)
if not(((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & ((1 << (PythonParser.STAR - 44)) | (1 << (PythonParser.DIV - 44)) | (1 << (PythonParser.MOD - 44)) | (1 << (PythonParser.IDIV - 44)) | (1 << (PythonParser.AT - 44)))) != 0)):
localctx.op = self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 726
self.expr(7)
pass
elif la_ == 3:
localctx = PythonParser.ExprContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
self.state = 727
if not self.precpred(self._ctx, 5):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
self.state = 728
localctx.op = self._input.LT(1)
_la = self._input.LA(1)
if not(_la==PythonParser.ADD or _la==PythonParser.MINUS):
localctx.op = self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 729
self.expr(6)
pass
elif la_ == 4:
localctx = PythonParser.ExprContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
self.state = 730
if not self.precpred(self._ctx, 4):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
self.state = 731
localctx.op = self._input.LT(1)
_la = self._input.LA(1)
if not(_la==PythonParser.LEFT_SHIFT or _la==PythonParser.RIGHT_SHIFT):
localctx.op = self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 732
self.expr(5)
pass
elif la_ == 5:
localctx = PythonParser.ExprContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
self.state = 733
if not self.precpred(self._ctx, 3):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
self.state = 734
localctx.op = self.match(PythonParser.AND_OP)
self.state = 735
self.expr(4)
pass
elif la_ == 6:
localctx = PythonParser.ExprContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
self.state = 736
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 737
localctx.op = self.match(PythonParser.XOR)
self.state = 738
self.expr(3)
pass
elif la_ == 7:
localctx = PythonParser.ExprContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
self.state = 739
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 740
localctx.op = self.match(PythonParser.OR_OP)
self.state = 741
self.expr(2)
pass
self.state = 746
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,107,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class AtomContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def OPEN_PAREN(self):
return self.getToken(PythonParser.OPEN_PAREN, 0)
[docs]
def CLOSE_PAREN(self):
return self.getToken(PythonParser.CLOSE_PAREN, 0)
[docs]
def yield_expr(self):
return self.getTypedRuleContext(PythonParser.Yield_exprContext,0)
[docs]
def testlist_comp(self):
return self.getTypedRuleContext(PythonParser.Testlist_compContext,0)
[docs]
def OPEN_BRACKET(self):
return self.getToken(PythonParser.OPEN_BRACKET, 0)
[docs]
def CLOSE_BRACKET(self):
return self.getToken(PythonParser.CLOSE_BRACKET, 0)
[docs]
def OPEN_BRACE(self):
return self.getToken(PythonParser.OPEN_BRACE, 0)
[docs]
def CLOSE_BRACE(self):
return self.getToken(PythonParser.CLOSE_BRACE, 0)
[docs]
def dictorsetmaker(self):
return self.getTypedRuleContext(PythonParser.DictorsetmakerContext,0)
[docs]
def REVERSE_QUOTE(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.REVERSE_QUOTE)
else:
return self.getToken(PythonParser.REVERSE_QUOTE, i)
[docs]
def testlist(self):
return self.getTypedRuleContext(PythonParser.TestlistContext,0)
[docs]
def COMMA(self):
return self.getToken(PythonParser.COMMA, 0)
[docs]
def ELLIPSIS(self):
return self.getToken(PythonParser.ELLIPSIS, 0)
[docs]
def name(self):
return self.getTypedRuleContext(PythonParser.NameContext,0)
[docs]
def PRINT(self):
return self.getToken(PythonParser.PRINT, 0)
[docs]
def EXEC(self):
return self.getToken(PythonParser.EXEC, 0)
[docs]
def number(self):
return self.getTypedRuleContext(PythonParser.NumberContext,0)
[docs]
def MINUS(self):
return self.getToken(PythonParser.MINUS, 0)
[docs]
def NONE(self):
return self.getToken(PythonParser.NONE, 0)
[docs]
def STRING(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.STRING)
else:
return self.getToken(PythonParser.STRING, i)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_atom
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterAtom" ):
listener.enterAtom(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitAtom" ):
listener.exitAtom(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitAtom" ):
return visitor.visitAtom(self)
else:
return visitor.visitChildren(self)
[docs]
def atom(self):
localctx = PythonParser.AtomContext(self, self._ctx, self.state)
self.enterRule(localctx, 80, self.RULE_atom)
self._la = 0 # Token type
try:
self.state = 784
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.OPEN_PAREN]:
self.enterOuterAlt(localctx, 1)
self.state = 747
self.match(PythonParser.OPEN_PAREN)
self.state = 750
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.YIELD]:
self.state = 748
self.yield_expr()
pass
elif token in [PythonParser.NONE, PythonParser.LAMBDA, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.STAR, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
self.state = 749
self.testlist_comp()
pass
elif token in [PythonParser.CLOSE_PAREN]:
pass
else:
pass
self.state = 752
self.match(PythonParser.CLOSE_PAREN)
pass
elif token in [PythonParser.OPEN_BRACKET]:
self.enterOuterAlt(localctx, 2)
self.state = 753
self.match(PythonParser.OPEN_BRACKET)
self.state = 755
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.STAR) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
self.state = 754
self.testlist_comp()
self.state = 757
self.match(PythonParser.CLOSE_BRACKET)
pass
elif token in [PythonParser.OPEN_BRACE]:
self.enterOuterAlt(localctx, 3)
self.state = 758
self.match(PythonParser.OPEN_BRACE)
self.state = 760
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.STAR) | (1 << PythonParser.POWER) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
self.state = 759
self.dictorsetmaker()
self.state = 762
self.match(PythonParser.CLOSE_BRACE)
pass
elif token in [PythonParser.REVERSE_QUOTE]:
self.enterOuterAlt(localctx, 4)
self.state = 763
self.match(PythonParser.REVERSE_QUOTE)
self.state = 764
self.testlist()
self.state = 766
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.COMMA:
self.state = 765
self.match(PythonParser.COMMA)
self.state = 768
self.match(PythonParser.REVERSE_QUOTE)
pass
elif token in [PythonParser.ELLIPSIS]:
self.enterOuterAlt(localctx, 5)
self.state = 770
self.match(PythonParser.ELLIPSIS)
pass
elif token in [PythonParser.TRUE, PythonParser.FALSE, PythonParser.NAME]:
self.enterOuterAlt(localctx, 6)
self.state = 771
self.name()
pass
elif token in [PythonParser.PRINT]:
self.enterOuterAlt(localctx, 7)
self.state = 772
self.match(PythonParser.PRINT)
pass
elif token in [PythonParser.EXEC]:
self.enterOuterAlt(localctx, 8)
self.state = 773
self.match(PythonParser.EXEC)
pass
elif token in [PythonParser.MINUS, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER]:
self.enterOuterAlt(localctx, 9)
self.state = 775
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.MINUS:
self.state = 774
self.match(PythonParser.MINUS)
self.state = 777
self.number()
pass
elif token in [PythonParser.NONE]:
self.enterOuterAlt(localctx, 10)
self.state = 778
self.match(PythonParser.NONE)
pass
elif token in [PythonParser.STRING]:
self.enterOuterAlt(localctx, 11)
self.state = 780
self._errHandler.sync(self)
_alt = 1
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt == 1:
self.state = 779
self.match(PythonParser.STRING)
else:
raise NoViableAltException(self)
self.state = 782
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,113,self._ctx)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class DictorsetmakerContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def test(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.TestContext)
else:
return self.getTypedRuleContext(PythonParser.TestContext,i)
[docs]
def COLON(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.COLON)
else:
return self.getToken(PythonParser.COLON, i)
[docs]
def POWER(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.POWER)
else:
return self.getToken(PythonParser.POWER, i)
[docs]
def expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.ExprContext)
else:
return self.getTypedRuleContext(PythonParser.ExprContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.COMMA)
else:
return self.getToken(PythonParser.COMMA, i)
[docs]
def comp_for(self):
return self.getTypedRuleContext(PythonParser.Comp_forContext,0)
[docs]
def testlist_comp(self):
return self.getTypedRuleContext(PythonParser.Testlist_compContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_dictorsetmaker
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDictorsetmaker" ):
listener.enterDictorsetmaker(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDictorsetmaker" ):
listener.exitDictorsetmaker(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDictorsetmaker" ):
return visitor.visitDictorsetmaker(self)
else:
return visitor.visitChildren(self)
[docs]
def dictorsetmaker(self):
localctx = PythonParser.DictorsetmakerContext(self, self._ctx, self.state)
self.enterRule(localctx, 82, self.RULE_dictorsetmaker)
self._la = 0 # Token type
try:
self.state = 817
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,119,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 792
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.NONE, PythonParser.LAMBDA, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
self.state = 786
self.test()
self.state = 787
self.match(PythonParser.COLON)
self.state = 788
self.test()
pass
elif token in [PythonParser.POWER]:
self.state = 790
self.match(PythonParser.POWER)
self.state = 791
self.expr(0)
pass
else:
raise NoViableAltException(self)
self.state = 805
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,117,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 794
self.match(PythonParser.COMMA)
self.state = 801
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.NONE, PythonParser.LAMBDA, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
self.state = 795
self.test()
self.state = 796
self.match(PythonParser.COLON)
self.state = 797
self.test()
pass
elif token in [PythonParser.POWER]:
self.state = 799
self.match(PythonParser.POWER)
self.state = 800
self.expr(0)
pass
else:
raise NoViableAltException(self)
self.state = 807
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,117,self._ctx)
self.state = 809
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.COMMA:
self.state = 808
self.match(PythonParser.COMMA)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 811
self.test()
self.state = 812
self.match(PythonParser.COLON)
self.state = 813
self.test()
self.state = 814
self.comp_for()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 816
self.testlist_comp()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Testlist_compContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def test(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.TestContext)
else:
return self.getTypedRuleContext(PythonParser.TestContext,i)
[docs]
def star_expr(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.Star_exprContext)
else:
return self.getTypedRuleContext(PythonParser.Star_exprContext,i)
[docs]
def comp_for(self):
return self.getTypedRuleContext(PythonParser.Comp_forContext,0)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.COMMA)
else:
return self.getToken(PythonParser.COMMA, i)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_testlist_comp
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTestlist_comp" ):
listener.enterTestlist_comp(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTestlist_comp" ):
listener.exitTestlist_comp(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTestlist_comp" ):
return visitor.visitTestlist_comp(self)
else:
return visitor.visitChildren(self)
[docs]
def testlist_comp(self):
localctx = PythonParser.Testlist_compContext(self, self._ctx, self.state)
self.enterRule(localctx, 84, self.RULE_testlist_comp)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 821
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.NONE, PythonParser.LAMBDA, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
self.state = 819
self.test()
pass
elif token in [PythonParser.STAR]:
self.state = 820
self.star_expr()
pass
else:
raise NoViableAltException(self)
self.state = 837
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.FOR]:
self.state = 823
self.comp_for()
pass
elif token in [PythonParser.COMMA, PythonParser.CLOSE_PAREN, PythonParser.CLOSE_BRACE, PythonParser.CLOSE_BRACKET]:
self.state = 831
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,122,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 824
self.match(PythonParser.COMMA)
self.state = 827
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.NONE, PythonParser.LAMBDA, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
self.state = 825
self.test()
pass
elif token in [PythonParser.STAR]:
self.state = 826
self.star_expr()
pass
else:
raise NoViableAltException(self)
self.state = 833
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,122,self._ctx)
self.state = 835
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.COMMA:
self.state = 834
self.match(PythonParser.COMMA)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TestlistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def test(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.TestContext)
else:
return self.getTypedRuleContext(PythonParser.TestContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.COMMA)
else:
return self.getToken(PythonParser.COMMA, i)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_testlist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTestlist" ):
listener.enterTestlist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTestlist" ):
listener.exitTestlist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTestlist" ):
return visitor.visitTestlist(self)
else:
return visitor.visitChildren(self)
[docs]
def testlist(self):
localctx = PythonParser.TestlistContext(self, self._ctx, self.state)
self.enterRule(localctx, 86, self.RULE_testlist)
try:
self.enterOuterAlt(localctx, 1)
self.state = 839
self.test()
self.state = 844
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,125,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 840
self.match(PythonParser.COMMA)
self.state = 841
self.test()
self.state = 846
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,125,self._ctx)
self.state = 848
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,126,self._ctx)
if la_ == 1:
self.state = 847
self.match(PythonParser.COMMA)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Dotted_nameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def name(self):
return self.getTypedRuleContext(PythonParser.NameContext,0)
[docs]
def dotted_name(self):
return self.getTypedRuleContext(PythonParser.Dotted_nameContext,0)
[docs]
def DOT(self):
return self.getToken(PythonParser.DOT, 0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_dotted_name
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterDotted_name" ):
listener.enterDotted_name(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitDotted_name" ):
listener.exitDotted_name(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDotted_name" ):
return visitor.visitDotted_name(self)
else:
return visitor.visitChildren(self)
[docs]
def dotted_name(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = PythonParser.Dotted_nameContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 88
self.enterRecursionRule(localctx, 88, self.RULE_dotted_name, _p)
try:
self.enterOuterAlt(localctx, 1)
self.state = 851
self.name()
self._ctx.stop = self._input.LT(-1)
self.state = 858
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,127,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
localctx = PythonParser.Dotted_nameContext(self, _parentctx, _parentState)
self.pushNewRecursionContext(localctx, _startState, self.RULE_dotted_name)
self.state = 853
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 854
self.match(PythonParser.DOT)
self.state = 855
self.name()
self.state = 860
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,127,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
[docs]
class NameContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def NAME(self):
return self.getToken(PythonParser.NAME, 0)
[docs]
def TRUE(self):
return self.getToken(PythonParser.TRUE, 0)
[docs]
def FALSE(self):
return self.getToken(PythonParser.FALSE, 0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_name
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterName" ):
listener.enterName(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitName" ):
listener.exitName(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitName" ):
return visitor.visitName(self)
else:
return visitor.visitChildren(self)
[docs]
def name(self):
localctx = PythonParser.NameContext(self, self._ctx, self.state)
self.enterRule(localctx, 90, self.RULE_name)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 861
_la = self._input.LA(1)
if not(((((_la - 39)) & ~0x3f) == 0 and ((1 << (_la - 39)) & ((1 << (PythonParser.TRUE - 39)) | (1 << (PythonParser.FALSE - 39)) | (1 << (PythonParser.NAME - 39)))) != 0)):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class NumberContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def integer(self):
return self.getTypedRuleContext(PythonParser.IntegerContext,0)
[docs]
def IMAG_NUMBER(self):
return self.getToken(PythonParser.IMAG_NUMBER, 0)
[docs]
def FLOAT_NUMBER(self):
return self.getToken(PythonParser.FLOAT_NUMBER, 0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_number
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterNumber" ):
listener.enterNumber(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitNumber" ):
listener.exitNumber(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNumber" ):
return visitor.visitNumber(self)
else:
return visitor.visitChildren(self)
[docs]
def number(self):
localctx = PythonParser.NumberContext(self, self._ctx, self.state)
self.enterRule(localctx, 92, self.RULE_number)
try:
self.state = 866
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER]:
self.enterOuterAlt(localctx, 1)
self.state = 863
self.integer()
pass
elif token in [PythonParser.IMAG_NUMBER]:
self.enterOuterAlt(localctx, 2)
self.state = 864
self.match(PythonParser.IMAG_NUMBER)
pass
elif token in [PythonParser.FLOAT_NUMBER]:
self.enterOuterAlt(localctx, 3)
self.state = 865
self.match(PythonParser.FLOAT_NUMBER)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class IntegerContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def DECIMAL_INTEGER(self):
return self.getToken(PythonParser.DECIMAL_INTEGER, 0)
[docs]
def OCT_INTEGER(self):
return self.getToken(PythonParser.OCT_INTEGER, 0)
[docs]
def HEX_INTEGER(self):
return self.getToken(PythonParser.HEX_INTEGER, 0)
[docs]
def BIN_INTEGER(self):
return self.getToken(PythonParser.BIN_INTEGER, 0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_integer
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterInteger" ):
listener.enterInteger(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitInteger" ):
listener.exitInteger(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitInteger" ):
return visitor.visitInteger(self)
else:
return visitor.visitChildren(self)
[docs]
def integer(self):
localctx = PythonParser.IntegerContext(self, self._ctx, self.state)
self.enterRule(localctx, 94, self.RULE_integer)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 868
_la = self._input.LA(1)
if not(((((_la - 84)) & ~0x3f) == 0 and ((1 << (_la - 84)) & ((1 << (PythonParser.DECIMAL_INTEGER - 84)) | (1 << (PythonParser.OCT_INTEGER - 84)) | (1 << (PythonParser.HEX_INTEGER - 84)) | (1 << (PythonParser.BIN_INTEGER - 84)))) != 0)):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Yield_exprContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def YIELD(self):
return self.getToken(PythonParser.YIELD, 0)
[docs]
def yield_arg(self):
return self.getTypedRuleContext(PythonParser.Yield_argContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_yield_expr
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterYield_expr" ):
listener.enterYield_expr(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitYield_expr" ):
listener.exitYield_expr(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitYield_expr" ):
return visitor.visitYield_expr(self)
else:
return visitor.visitChildren(self)
[docs]
def yield_expr(self):
localctx = PythonParser.Yield_exprContext(self, self._ctx, self.state)
self.enterRule(localctx, 96, self.RULE_yield_expr)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 870
self.match(PythonParser.YIELD)
self.state = 872
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.FROM) | (1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
self.state = 871
self.yield_arg()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Yield_argContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def FROM(self):
return self.getToken(PythonParser.FROM, 0)
[docs]
def test(self):
return self.getTypedRuleContext(PythonParser.TestContext,0)
[docs]
def testlist(self):
return self.getTypedRuleContext(PythonParser.TestlistContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_yield_arg
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterYield_arg" ):
listener.enterYield_arg(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitYield_arg" ):
listener.exitYield_arg(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitYield_arg" ):
return visitor.visitYield_arg(self)
else:
return visitor.visitChildren(self)
[docs]
def yield_arg(self):
localctx = PythonParser.Yield_argContext(self, self._ctx, self.state)
self.enterRule(localctx, 98, self.RULE_yield_arg)
try:
self.state = 877
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.FROM]:
self.enterOuterAlt(localctx, 1)
self.state = 874
self.match(PythonParser.FROM)
self.state = 875
self.test()
pass
elif token in [PythonParser.NONE, PythonParser.LAMBDA, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
self.enterOuterAlt(localctx, 2)
self.state = 876
self.testlist()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class TrailerContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def DOT(self):
return self.getToken(PythonParser.DOT, 0)
[docs]
def name(self):
return self.getTypedRuleContext(PythonParser.NameContext,0)
[docs]
def arguments(self):
return self.getTypedRuleContext(PythonParser.ArgumentsContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_trailer
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterTrailer" ):
listener.enterTrailer(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitTrailer" ):
listener.exitTrailer(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitTrailer" ):
return visitor.visitTrailer(self)
else:
return visitor.visitChildren(self)
[docs]
def trailer(self):
localctx = PythonParser.TrailerContext(self, self._ctx, self.state)
self.enterRule(localctx, 100, self.RULE_trailer)
try:
self.state = 885
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.DOT]:
self.enterOuterAlt(localctx, 1)
self.state = 879
self.match(PythonParser.DOT)
self.state = 880
self.name()
self.state = 882
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,131,self._ctx)
if la_ == 1:
self.state = 881
self.arguments()
pass
elif token in [PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACKET]:
self.enterOuterAlt(localctx, 2)
self.state = 884
self.arguments()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ArgumentsContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def OPEN_PAREN(self):
return self.getToken(PythonParser.OPEN_PAREN, 0)
[docs]
def CLOSE_PAREN(self):
return self.getToken(PythonParser.CLOSE_PAREN, 0)
[docs]
def arglist(self):
return self.getTypedRuleContext(PythonParser.ArglistContext,0)
[docs]
def OPEN_BRACKET(self):
return self.getToken(PythonParser.OPEN_BRACKET, 0)
[docs]
def subscriptlist(self):
return self.getTypedRuleContext(PythonParser.SubscriptlistContext,0)
[docs]
def CLOSE_BRACKET(self):
return self.getToken(PythonParser.CLOSE_BRACKET, 0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_arguments
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterArguments" ):
listener.enterArguments(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitArguments" ):
listener.exitArguments(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitArguments" ):
return visitor.visitArguments(self)
else:
return visitor.visitChildren(self)
[docs]
def arguments(self):
localctx = PythonParser.ArgumentsContext(self, self._ctx, self.state)
self.enterRule(localctx, 102, self.RULE_arguments)
self._la = 0 # Token type
try:
self.state = 896
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.OPEN_PAREN]:
self.enterOuterAlt(localctx, 1)
self.state = 887
self.match(PythonParser.OPEN_PAREN)
self.state = 889
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.STAR) | (1 << PythonParser.POWER) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
self.state = 888
self.arglist()
self.state = 891
self.match(PythonParser.CLOSE_PAREN)
pass
elif token in [PythonParser.OPEN_BRACKET]:
self.enterOuterAlt(localctx, 2)
self.state = 892
self.match(PythonParser.OPEN_BRACKET)
self.state = 893
self.subscriptlist()
self.state = 894
self.match(PythonParser.CLOSE_BRACKET)
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ArglistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def argument(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.ArgumentContext)
else:
return self.getTypedRuleContext(PythonParser.ArgumentContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.COMMA)
else:
return self.getToken(PythonParser.COMMA, i)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_arglist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterArglist" ):
listener.enterArglist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitArglist" ):
listener.exitArglist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitArglist" ):
return visitor.visitArglist(self)
else:
return visitor.visitChildren(self)
[docs]
def arglist(self):
localctx = PythonParser.ArglistContext(self, self._ctx, self.state)
self.enterRule(localctx, 104, self.RULE_arglist)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 898
self.argument()
self.state = 903
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,135,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 899
self.match(PythonParser.COMMA)
self.state = 900
self.argument()
self.state = 905
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,135,self._ctx)
self.state = 907
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.COMMA:
self.state = 906
self.match(PythonParser.COMMA)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class ArgumentContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def test(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.TestContext)
else:
return self.getTypedRuleContext(PythonParser.TestContext,i)
[docs]
def comp_for(self):
return self.getTypedRuleContext(PythonParser.Comp_forContext,0)
[docs]
def ASSIGN(self):
return self.getToken(PythonParser.ASSIGN, 0)
[docs]
def POWER(self):
return self.getToken(PythonParser.POWER, 0)
[docs]
def STAR(self):
return self.getToken(PythonParser.STAR, 0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_argument
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterArgument" ):
listener.enterArgument(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitArgument" ):
listener.exitArgument(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitArgument" ):
return visitor.visitArgument(self)
else:
return visitor.visitChildren(self)
[docs]
def argument(self):
localctx = PythonParser.ArgumentContext(self, self._ctx, self.state)
self.enterRule(localctx, 106, self.RULE_argument)
self._la = 0 # Token type
try:
self.state = 917
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.NONE, PythonParser.LAMBDA, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
self.enterOuterAlt(localctx, 1)
self.state = 909
self.test()
self.state = 913
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.FOR]:
self.state = 910
self.comp_for()
pass
elif token in [PythonParser.ASSIGN]:
self.state = 911
self.match(PythonParser.ASSIGN)
self.state = 912
self.test()
pass
elif token in [PythonParser.COMMA, PythonParser.CLOSE_PAREN]:
pass
else:
pass
pass
elif token in [PythonParser.STAR, PythonParser.POWER]:
self.enterOuterAlt(localctx, 2)
self.state = 915
_la = self._input.LA(1)
if not(_la==PythonParser.STAR or _la==PythonParser.POWER):
self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 916
self.test()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SubscriptlistContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def subscript(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.SubscriptContext)
else:
return self.getTypedRuleContext(PythonParser.SubscriptContext,i)
[docs]
def COMMA(self, i:int=None):
if i is None:
return self.getTokens(PythonParser.COMMA)
else:
return self.getToken(PythonParser.COMMA, i)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_subscriptlist
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubscriptlist" ):
listener.enterSubscriptlist(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubscriptlist" ):
listener.exitSubscriptlist(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubscriptlist" ):
return visitor.visitSubscriptlist(self)
else:
return visitor.visitChildren(self)
[docs]
def subscriptlist(self):
localctx = PythonParser.SubscriptlistContext(self, self._ctx, self.state)
self.enterRule(localctx, 108, self.RULE_subscriptlist)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 919
self.subscript()
self.state = 924
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,139,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
self.state = 920
self.match(PythonParser.COMMA)
self.state = 921
self.subscript()
self.state = 926
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,139,self._ctx)
self.state = 928
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.COMMA:
self.state = 927
self.match(PythonParser.COMMA)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SubscriptContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def ELLIPSIS(self):
return self.getToken(PythonParser.ELLIPSIS, 0)
[docs]
def test(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(PythonParser.TestContext)
else:
return self.getTypedRuleContext(PythonParser.TestContext,i)
[docs]
def COLON(self):
return self.getToken(PythonParser.COLON, 0)
[docs]
def sliceop(self):
return self.getTypedRuleContext(PythonParser.SliceopContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_subscript
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSubscript" ):
listener.enterSubscript(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSubscript" ):
listener.exitSubscript(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSubscript" ):
return visitor.visitSubscript(self)
else:
return visitor.visitChildren(self)
[docs]
def subscript(self):
localctx = PythonParser.SubscriptContext(self, self._ctx, self.state)
self.enterRule(localctx, 110, self.RULE_subscript)
self._la = 0 # Token type
try:
self.state = 948
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,146,self._ctx)
if la_ == 1:
self.enterOuterAlt(localctx, 1)
self.state = 930
self.match(PythonParser.ELLIPSIS)
pass
elif la_ == 2:
self.enterOuterAlt(localctx, 2)
self.state = 931
self.test()
self.state = 939
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.COLON:
self.state = 932
self.match(PythonParser.COLON)
self.state = 934
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
self.state = 933
self.test()
self.state = 937
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.COLON:
self.state = 936
self.sliceop()
pass
elif la_ == 3:
self.enterOuterAlt(localctx, 3)
self.state = 941
self.match(PythonParser.COLON)
self.state = 943
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
self.state = 942
self.test()
self.state = 946
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.COLON:
self.state = 945
self.sliceop()
pass
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class SliceopContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def COLON(self):
return self.getToken(PythonParser.COLON, 0)
[docs]
def test(self):
return self.getTypedRuleContext(PythonParser.TestContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_sliceop
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterSliceop" ):
listener.enterSliceop(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitSliceop" ):
listener.exitSliceop(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitSliceop" ):
return visitor.visitSliceop(self)
else:
return visitor.visitChildren(self)
[docs]
def sliceop(self):
localctx = PythonParser.SliceopContext(self, self._ctx, self.state)
self.enterRule(localctx, 112, self.RULE_sliceop)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 950
self.match(PythonParser.COLON)
self.state = 952
self._errHandler.sync(self)
_la = self._input.LA(1)
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
self.state = 951
self.test()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Comp_forContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def FOR(self):
return self.getToken(PythonParser.FOR, 0)
[docs]
def exprlist(self):
return self.getTypedRuleContext(PythonParser.ExprlistContext,0)
[docs]
def IN(self):
return self.getToken(PythonParser.IN, 0)
[docs]
def logical_test(self):
return self.getTypedRuleContext(PythonParser.Logical_testContext,0)
[docs]
def comp_iter(self):
return self.getTypedRuleContext(PythonParser.Comp_iterContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_comp_for
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComp_for" ):
listener.enterComp_for(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComp_for" ):
listener.exitComp_for(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComp_for" ):
return visitor.visitComp_for(self)
else:
return visitor.visitChildren(self)
[docs]
def comp_for(self):
localctx = PythonParser.Comp_forContext(self, self._ctx, self.state)
self.enterRule(localctx, 114, self.RULE_comp_for)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 954
self.match(PythonParser.FOR)
self.state = 955
self.exprlist()
self.state = 956
self.match(PythonParser.IN)
self.state = 957
self.logical_test(0)
self.state = 959
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.IF or _la==PythonParser.FOR:
self.state = 958
self.comp_iter()
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
class Comp_iterContext(ParserRuleContext):
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
[docs]
def comp_for(self):
return self.getTypedRuleContext(PythonParser.Comp_forContext,0)
[docs]
def IF(self):
return self.getToken(PythonParser.IF, 0)
[docs]
def test(self):
return self.getTypedRuleContext(PythonParser.TestContext,0)
[docs]
def comp_iter(self):
return self.getTypedRuleContext(PythonParser.Comp_iterContext,0)
[docs]
def getRuleIndex(self):
return PythonParser.RULE_comp_iter
[docs]
def enterRule(self, listener:ParseTreeListener):
if hasattr( listener, "enterComp_iter" ):
listener.enterComp_iter(self)
[docs]
def exitRule(self, listener:ParseTreeListener):
if hasattr( listener, "exitComp_iter" ):
listener.exitComp_iter(self)
[docs]
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitComp_iter" ):
return visitor.visitComp_iter(self)
else:
return visitor.visitChildren(self)
[docs]
def comp_iter(self):
localctx = PythonParser.Comp_iterContext(self, self._ctx, self.state)
self.enterRule(localctx, 116, self.RULE_comp_iter)
self._la = 0 # Token type
try:
self.state = 967
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [PythonParser.FOR]:
self.enterOuterAlt(localctx, 1)
self.state = 961
self.comp_for()
pass
elif token in [PythonParser.IF]:
self.enterOuterAlt(localctx, 2)
self.state = 962
self.match(PythonParser.IF)
self.state = 963
self.test()
self.state = 965
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==PythonParser.IF or _la==PythonParser.FOR:
self.state = 964
self.comp_iter()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
[docs]
def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
if self._predicates == None:
self._predicates = dict()
self._predicates[12] = self.except_clause_sempred
self._predicates[22] = self.small_stmt_sempred
self._predicates[25] = self.assign_part_sempred
self._predicates[37] = self.logical_test_sempred
self._predicates[38] = self.comparison_sempred
self._predicates[39] = self.expr_sempred
self._predicates[44] = self.dotted_name_sempred
pred = self._predicates.get(ruleIndex, None)
if pred is None:
raise Exception("No predicate with index:" + str(ruleIndex))
else:
return pred(localctx, predIndex)
[docs]
def except_clause_sempred(self, localctx:Except_clauseContext, predIndex:int):
if predIndex == 0:
return self.CheckVersion(2)
if predIndex == 1:
return self.CheckVersion(3)
[docs]
def small_stmt_sempred(self, localctx:Small_stmtContext, predIndex:int):
if predIndex == 2:
return self.CheckVersion(2)
if predIndex == 3:
return self.CheckVersion(2)
if predIndex == 4:
return self.CheckVersion(3)
[docs]
def assign_part_sempred(self, localctx:Assign_partContext, predIndex:int):
if predIndex == 5:
return self.CheckVersion(3)
[docs]
def logical_test_sempred(self, localctx:Logical_testContext, predIndex:int):
if predIndex == 6:
return self.precpred(self._ctx, 2)
if predIndex == 7:
return self.precpred(self._ctx, 1)
[docs]
def comparison_sempred(self, localctx:ComparisonContext, predIndex:int):
if predIndex == 8:
return self.precpred(self._ctx, 2)
[docs]
def expr_sempred(self, localctx:ExprContext, predIndex:int):
if predIndex == 9:
return self.precpred(self._ctx, 8)
if predIndex == 10:
return self.precpred(self._ctx, 6)
if predIndex == 11:
return self.precpred(self._ctx, 5)
if predIndex == 12:
return self.precpred(self._ctx, 4)
if predIndex == 13:
return self.precpred(self._ctx, 3)
if predIndex == 14:
return self.precpred(self._ctx, 2)
if predIndex == 15:
return self.precpred(self._ctx, 1)
[docs]
def dotted_name_sempred(self, localctx:Dotted_nameContext, predIndex:int):
if predIndex == 16:
return self.precpred(self._ctx, 2)