2107 lines
80 KiB
Python
2107 lines
80 KiB
Python
# Generated from CommentMacro.g4 by ANTLR 4.7.1
|
|
# encoding: utf-8
|
|
from antlr4 import *
|
|
from io import StringIO
|
|
from typing.io import TextIO
|
|
import sys
|
|
|
|
def serializedATN():
|
|
with StringIO() as buf:
|
|
buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3-")
|
|
buf.write("\u00f9\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\3\2\6\2\26\n\2\r\2\16\2\27\3")
|
|
buf.write("\2\3\2\3\3\3\3\3\3\7\3\37\n\3\f\3\16\3\"\13\3\3\3\5\3")
|
|
buf.write("%\n\3\3\3\5\3(\n\3\3\4\3\4\3\4\5\4-\n\4\3\4\5\4\60\n\4")
|
|
buf.write("\3\4\3\4\3\4\5\4\65\n\4\3\4\3\4\3\4\5\4:\n\4\3\4\3\4\3")
|
|
buf.write("\4\5\4?\n\4\3\4\5\4B\n\4\3\4\3\4\3\4\5\4G\n\4\3\4\5\4")
|
|
buf.write("J\n\4\3\4\3\4\3\4\5\4O\n\4\3\4\5\4R\n\4\3\4\3\4\5\4V\n")
|
|
buf.write("\4\3\4\3\4\5\4Z\n\4\3\4\3\4\3\4\5\4_\n\4\3\4\3\4\3\4\5")
|
|
buf.write("\4d\n\4\3\4\5\4g\n\4\3\4\3\4\3\4\5\4l\n\4\3\4\5\4o\n\4")
|
|
buf.write("\3\4\3\4\3\4\5\4t\n\4\3\4\3\4\3\4\5\4y\n\4\3\4\3\4\3\4")
|
|
buf.write("\3\4\3\4\5\4\u0080\n\4\3\4\3\4\3\4\5\4\u0085\n\4\3\4\3")
|
|
buf.write("\4\3\4\5\4\u008a\n\4\3\4\3\4\3\4\5\4\u008f\n\4\3\4\3\4")
|
|
buf.write("\3\4\5\4\u0094\n\4\3\4\3\4\3\4\5\4\u0099\n\4\3\4\3\4\3")
|
|
buf.write("\4\5\4\u009e\n\4\3\4\3\4\3\4\5\4\u00a3\n\4\3\4\3\4\3\4")
|
|
buf.write("\5\4\u00a8\n\4\3\4\3\4\3\4\5\4\u00ad\n\4\3\4\3\4\3\4\5")
|
|
buf.write("\4\u00b2\n\4\3\4\3\4\3\4\5\4\u00b7\n\4\3\4\3\4\3\4\5\4")
|
|
buf.write("\u00bc\n\4\3\4\3\4\3\4\5\4\u00c1\n\4\3\4\3\4\3\4\5\4\u00c6")
|
|
buf.write("\n\4\3\4\3\4\3\4\5\4\u00cb\n\4\3\4\3\4\3\4\3\4\3\4\5\4")
|
|
buf.write("\u00d2\n\4\3\4\3\4\3\4\5\4\u00d7\n\4\3\4\3\4\3\4\5\4\u00dc")
|
|
buf.write("\n\4\5\4\u00de\n\4\3\5\3\5\3\5\3\6\3\6\3\6\3\7\3\7\3\b")
|
|
buf.write("\3\b\5\b\u00ea\n\b\3\b\3\b\7\b\u00ee\n\b\f\b\16\b\u00f1")
|
|
buf.write("\13\b\3\t\3\t\3\t\3\t\3\n\3\n\3\n\2\2\13\2\4\6\b\n\f\16")
|
|
buf.write("\20\22\2\3\3\2\')\2\u0139\2\25\3\2\2\2\4\'\3\2\2\2\6\u00dd")
|
|
buf.write("\3\2\2\2\b\u00df\3\2\2\2\n\u00e2\3\2\2\2\f\u00e5\3\2\2")
|
|
buf.write("\2\16\u00e9\3\2\2\2\20\u00f2\3\2\2\2\22\u00f6\3\2\2\2")
|
|
buf.write("\24\26\5\4\3\2\25\24\3\2\2\2\26\27\3\2\2\2\27\25\3\2\2")
|
|
buf.write("\2\27\30\3\2\2\2\30\31\3\2\2\2\31\32\7\2\2\3\32\3\3\2")
|
|
buf.write("\2\2\33 \5\6\4\2\34\35\7\3\2\2\35\37\5\6\4\2\36\34\3\2")
|
|
buf.write("\2\2\37\"\3\2\2\2 \36\3\2\2\2 !\3\2\2\2!$\3\2\2\2\" \3")
|
|
buf.write("\2\2\2#%\7*\2\2$#\3\2\2\2$%\3\2\2\2%(\3\2\2\2&(\7*\2\2")
|
|
buf.write("\'\33\3\2\2\2\'&\3\2\2\2(\5\3\2\2\2),\7\4\2\2*-\5\16\b")
|
|
buf.write("\2+-\7%\2\2,*\3\2\2\2,+\3\2\2\2-/\3\2\2\2.\60\5\n\6\2")
|
|
buf.write("/.\3\2\2\2/\60\3\2\2\2\60\u00de\3\2\2\2\61\64\7\4\2\2")
|
|
buf.write("\62\65\5\16\b\2\63\65\7%\2\2\64\62\3\2\2\2\64\63\3\2\2")
|
|
buf.write("\2\65\66\3\2\2\2\66\67\7\5\2\2\679\5\22\n\28:\5\n\6\2")
|
|
buf.write("98\3\2\2\29:\3\2\2\2:\u00de\3\2\2\2;>\7\6\2\2<?\5\16\b")
|
|
buf.write("\2=?\7%\2\2><\3\2\2\2>=\3\2\2\2?A\3\2\2\2@B\5\n\6\2A@")
|
|
buf.write("\3\2\2\2AB\3\2\2\2B\u00de\3\2\2\2CF\7\7\2\2DG\5\16\b\2")
|
|
buf.write("EG\7%\2\2FD\3\2\2\2FE\3\2\2\2GI\3\2\2\2HJ\5\n\6\2IH\3")
|
|
buf.write("\2\2\2IJ\3\2\2\2J\u00de\3\2\2\2KN\7\b\2\2LO\5\16\b\2M")
|
|
buf.write("O\7%\2\2NL\3\2\2\2NM\3\2\2\2OQ\3\2\2\2PR\5\n\6\2QP\3\2")
|
|
buf.write("\2\2QR\3\2\2\2R\u00de\3\2\2\2SU\7\t\2\2TV\5\n\6\2UT\3")
|
|
buf.write("\2\2\2UV\3\2\2\2V\u00de\3\2\2\2WY\7\n\2\2XZ\5\n\6\2YX")
|
|
buf.write("\3\2\2\2YZ\3\2\2\2Z\u00de\3\2\2\2[^\7\13\2\2\\_\5\16\b")
|
|
buf.write("\2]_\7%\2\2^\\\3\2\2\2^]\3\2\2\2_`\3\2\2\2`a\7\5\2\2a")
|
|
buf.write("c\5\22\n\2bd\5\b\5\2cb\3\2\2\2cd\3\2\2\2df\3\2\2\2eg\5")
|
|
buf.write("\n\6\2fe\3\2\2\2fg\3\2\2\2g\u00de\3\2\2\2hi\7\f\2\2ik")
|
|
buf.write("\5\22\n\2jl\5\b\5\2kj\3\2\2\2kl\3\2\2\2ln\3\2\2\2mo\5")
|
|
buf.write("\n\6\2nm\3\2\2\2no\3\2\2\2o\u00de\3\2\2\2pq\7\r\2\2qs")
|
|
buf.write("\5\22\n\2rt\5\n\6\2sr\3\2\2\2st\3\2\2\2t\u00de\3\2\2\2")
|
|
buf.write("uv\7\16\2\2vx\5\16\b\2wy\5\n\6\2xw\3\2\2\2xy\3\2\2\2y")
|
|
buf.write("\u00de\3\2\2\2z{\7\16\2\2{|\5\16\b\2|}\7\5\2\2}\177\5")
|
|
buf.write("\22\n\2~\u0080\5\n\6\2\177~\3\2\2\2\177\u0080\3\2\2\2")
|
|
buf.write("\u0080\u00de\3\2\2\2\u0081\u0082\7\17\2\2\u0082\u0084")
|
|
buf.write("\5\16\b\2\u0083\u0085\5\n\6\2\u0084\u0083\3\2\2\2\u0084")
|
|
buf.write("\u0085\3\2\2\2\u0085\u00de\3\2\2\2\u0086\u0087\7\20\2")
|
|
buf.write("\2\u0087\u0089\5\16\b\2\u0088\u008a\5\n\6\2\u0089\u0088")
|
|
buf.write("\3\2\2\2\u0089\u008a\3\2\2\2\u008a\u00de\3\2\2\2\u008b")
|
|
buf.write("\u008c\7\21\2\2\u008c\u008e\5\16\b\2\u008d\u008f\5\n\6")
|
|
buf.write("\2\u008e\u008d\3\2\2\2\u008e\u008f\3\2\2\2\u008f\u00de")
|
|
buf.write("\3\2\2\2\u0090\u0091\7\22\2\2\u0091\u0093\5\16\b\2\u0092")
|
|
buf.write("\u0094\5\n\6\2\u0093\u0092\3\2\2\2\u0093\u0094\3\2\2\2")
|
|
buf.write("\u0094\u00de\3\2\2\2\u0095\u0096\7\23\2\2\u0096\u0098")
|
|
buf.write("\5\16\b\2\u0097\u0099\5\n\6\2\u0098\u0097\3\2\2\2\u0098")
|
|
buf.write("\u0099\3\2\2\2\u0099\u00de\3\2\2\2\u009a\u009b\7\24\2")
|
|
buf.write("\2\u009b\u009d\5\16\b\2\u009c\u009e\5\n\6\2\u009d\u009c")
|
|
buf.write("\3\2\2\2\u009d\u009e\3\2\2\2\u009e\u00de\3\2\2\2\u009f")
|
|
buf.write("\u00a0\7\25\2\2\u00a0\u00a2\5\16\b\2\u00a1\u00a3\5\n\6")
|
|
buf.write("\2\u00a2\u00a1\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3\u00de")
|
|
buf.write("\3\2\2\2\u00a4\u00a5\7\26\2\2\u00a5\u00a7\5\16\b\2\u00a6")
|
|
buf.write("\u00a8\5\n\6\2\u00a7\u00a6\3\2\2\2\u00a7\u00a8\3\2\2\2")
|
|
buf.write("\u00a8\u00de\3\2\2\2\u00a9\u00aa\7\27\2\2\u00aa\u00ac")
|
|
buf.write("\5\16\b\2\u00ab\u00ad\5\n\6\2\u00ac\u00ab\3\2\2\2\u00ac")
|
|
buf.write("\u00ad\3\2\2\2\u00ad\u00de\3\2\2\2\u00ae\u00af\7\30\2")
|
|
buf.write("\2\u00af\u00b1\5\16\b\2\u00b0\u00b2\5\n\6\2\u00b1\u00b0")
|
|
buf.write("\3\2\2\2\u00b1\u00b2\3\2\2\2\u00b2\u00de\3\2\2\2\u00b3")
|
|
buf.write("\u00b4\7\31\2\2\u00b4\u00b6\5\16\b\2\u00b5\u00b7\5\n\6")
|
|
buf.write("\2\u00b6\u00b5\3\2\2\2\u00b6\u00b7\3\2\2\2\u00b7\u00de")
|
|
buf.write("\3\2\2\2\u00b8\u00b9\7\32\2\2\u00b9\u00bb\5\22\n\2\u00ba")
|
|
buf.write("\u00bc\5\n\6\2\u00bb\u00ba\3\2\2\2\u00bb\u00bc\3\2\2\2")
|
|
buf.write("\u00bc\u00de\3\2\2\2\u00bd\u00be\7\32\2\2\u00be\u00c0")
|
|
buf.write("\7\33\2\2\u00bf\u00c1\5\n\6\2\u00c0\u00bf\3\2\2\2\u00c0")
|
|
buf.write("\u00c1\3\2\2\2\u00c1\u00de\3\2\2\2\u00c2\u00c3\7\32\2")
|
|
buf.write("\2\u00c3\u00c5\7\34\2\2\u00c4\u00c6\5\n\6\2\u00c5\u00c4")
|
|
buf.write("\3\2\2\2\u00c5\u00c6\3\2\2\2\u00c6\u00de\3\2\2\2\u00c7")
|
|
buf.write("\u00c8\7\35\2\2\u00c8\u00ca\5\22\n\2\u00c9\u00cb\5\n\6")
|
|
buf.write("\2\u00ca\u00c9\3\2\2\2\u00ca\u00cb\3\2\2\2\u00cb\u00de")
|
|
buf.write("\3\2\2\2\u00cc\u00cd\7\36\2\2\u00cd\u00de\5\n\6\2\u00ce")
|
|
buf.write("\u00cf\7\37\2\2\u00cf\u00d1\5\16\b\2\u00d0\u00d2\5\n\6")
|
|
buf.write("\2\u00d1\u00d0\3\2\2\2\u00d1\u00d2\3\2\2\2\u00d2\u00de")
|
|
buf.write("\3\2\2\2\u00d3\u00d4\7 \2\2\u00d4\u00d6\5\16\b\2\u00d5")
|
|
buf.write("\u00d7\5\n\6\2\u00d6\u00d5\3\2\2\2\u00d6\u00d7\3\2\2\2")
|
|
buf.write("\u00d7\u00de\3\2\2\2\u00d8\u00d9\7!\2\2\u00d9\u00db\5")
|
|
buf.write("\16\b\2\u00da\u00dc\5\n\6\2\u00db\u00da\3\2\2\2\u00db")
|
|
buf.write("\u00dc\3\2\2\2\u00dc\u00de\3\2\2\2\u00dd)\3\2\2\2\u00dd")
|
|
buf.write("\61\3\2\2\2\u00dd;\3\2\2\2\u00ddC\3\2\2\2\u00ddK\3\2\2")
|
|
buf.write("\2\u00ddS\3\2\2\2\u00ddW\3\2\2\2\u00dd[\3\2\2\2\u00dd")
|
|
buf.write("h\3\2\2\2\u00ddp\3\2\2\2\u00ddu\3\2\2\2\u00ddz\3\2\2\2")
|
|
buf.write("\u00dd\u0081\3\2\2\2\u00dd\u0086\3\2\2\2\u00dd\u008b\3")
|
|
buf.write("\2\2\2\u00dd\u0090\3\2\2\2\u00dd\u0095\3\2\2\2\u00dd\u009a")
|
|
buf.write("\3\2\2\2\u00dd\u009f\3\2\2\2\u00dd\u00a4\3\2\2\2\u00dd")
|
|
buf.write("\u00a9\3\2\2\2\u00dd\u00ae\3\2\2\2\u00dd\u00b3\3\2\2\2")
|
|
buf.write("\u00dd\u00b8\3\2\2\2\u00dd\u00bd\3\2\2\2\u00dd\u00c2\3")
|
|
buf.write("\2\2\2\u00dd\u00c7\3\2\2\2\u00dd\u00cc\3\2\2\2\u00dd\u00ce")
|
|
buf.write("\3\2\2\2\u00dd\u00d3\3\2\2\2\u00dd\u00d8\3\2\2\2\u00de")
|
|
buf.write("\7\3\2\2\2\u00df\u00e0\7&\2\2\u00e0\u00e1\5\22\n\2\u00e1")
|
|
buf.write("\t\3\2\2\2\u00e2\u00e3\5\f\7\2\u00e3\u00e4\5\22\n\2\u00e4")
|
|
buf.write("\13\3\2\2\2\u00e5\u00e6\t\2\2\2\u00e6\r\3\2\2\2\u00e7")
|
|
buf.write("\u00ea\5\22\n\2\u00e8\u00ea\5\20\t\2\u00e9\u00e7\3\2\2")
|
|
buf.write("\2\u00e9\u00e8\3\2\2\2\u00ea\u00ef\3\2\2\2\u00eb\u00ec")
|
|
buf.write("\7\"\2\2\u00ec\u00ee\5\16\b\2\u00ed\u00eb\3\2\2\2\u00ee")
|
|
buf.write("\u00f1\3\2\2\2\u00ef\u00ed\3\2\2\2\u00ef\u00f0\3\2\2\2")
|
|
buf.write("\u00f0\17\3\2\2\2\u00f1\u00ef\3\2\2\2\u00f2\u00f3\5\22")
|
|
buf.write("\n\2\u00f3\u00f4\7$\2\2\u00f4\u00f5\5\22\n\2\u00f5\21")
|
|
buf.write("\3\2\2\2\u00f6\u00f7\7#\2\2\u00f7\23\3\2\2\2/\27 $\',")
|
|
buf.write("/\649>AFINQUY^cfknsx\177\u0084\u0089\u008e\u0093\u0098")
|
|
buf.write("\u009d\u00a2\u00a7\u00ac\u00b1\u00b6\u00bb\u00c0\u00c5")
|
|
buf.write("\u00ca\u00d1\u00d6\u00db\u00dd\u00e9\u00ef")
|
|
return buf.getvalue()
|
|
|
|
|
|
class CommentMacroParser ( Parser ):
|
|
|
|
grammarFileName = "CommentMacro.g4"
|
|
|
|
atn = ATNDeserializer().deserialize(serializedATN())
|
|
|
|
decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
|
|
|
|
sharedContextCache = PredictionContextCache()
|
|
|
|
literalNames = [ "<INVALID>", "':'", "'GM'", "'/'", "'HM'", "'AM'",
|
|
"'RM'", "'RA'", "'RO'", "'FM'", "'FGM'", "'CM'", "'GL'",
|
|
"'HL'", "'AL'", "'RL'", "'GB'", "'HB'", "'AB'", "'RB'",
|
|
"'GS'", "'HS'", "'AS'", "'RS'", "'CP'", "'+'", "'-'",
|
|
"'RV'", "'RN'", "'GK'", "'HK'", "'RK'", "','", "<INVALID>",
|
|
"'>'", "'*'", "'t'", "<INVALID>", "<INVALID>", "'IOP'" ]
|
|
|
|
symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "NUMBER", "THRU", "CURRENT", "TIME",
|
|
"WHOLEHOG", "DP8K", "IOP", "NEWLINE", "WS", "COMMENT",
|
|
"LINE_COMMENT" ]
|
|
|
|
RULE_prog = 0
|
|
RULE_statement = 1
|
|
RULE_macro = 2
|
|
RULE_time = 3
|
|
RULE_device = 4
|
|
RULE_nodeType = 5
|
|
RULE_target = 6
|
|
RULE_span = 7
|
|
RULE_number = 8
|
|
|
|
ruleNames = [ "prog", "statement", "macro", "time", "device", "nodeType",
|
|
"target", "span", "number" ]
|
|
|
|
EOF = Token.EOF
|
|
T__0=1
|
|
T__1=2
|
|
T__2=3
|
|
T__3=4
|
|
T__4=5
|
|
T__5=6
|
|
T__6=7
|
|
T__7=8
|
|
T__8=9
|
|
T__9=10
|
|
T__10=11
|
|
T__11=12
|
|
T__12=13
|
|
T__13=14
|
|
T__14=15
|
|
T__15=16
|
|
T__16=17
|
|
T__17=18
|
|
T__18=19
|
|
T__19=20
|
|
T__20=21
|
|
T__21=22
|
|
T__22=23
|
|
T__23=24
|
|
T__24=25
|
|
T__25=26
|
|
T__26=27
|
|
T__27=28
|
|
T__28=29
|
|
T__29=30
|
|
T__30=31
|
|
T__31=32
|
|
NUMBER=33
|
|
THRU=34
|
|
CURRENT=35
|
|
TIME=36
|
|
WHOLEHOG=37
|
|
DP8K=38
|
|
IOP=39
|
|
NEWLINE=40
|
|
WS=41
|
|
COMMENT=42
|
|
LINE_COMMENT=43
|
|
|
|
def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
|
|
super().__init__(input, output)
|
|
self.checkVersion("4.7.1")
|
|
self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
|
|
self._predicates = None
|
|
|
|
|
|
|
|
class ProgContext(ParserRuleContext):
|
|
|
|
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def EOF(self):
|
|
return self.getToken(CommentMacroParser.EOF, 0)
|
|
|
|
def statement(self, i:int=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CommentMacroParser.StatementContext)
|
|
else:
|
|
return self.getTypedRuleContext(CommentMacroParser.StatementContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CommentMacroParser.RULE_prog
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterProg" ):
|
|
listener.enterProg(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitProg" ):
|
|
listener.exitProg(self)
|
|
|
|
|
|
|
|
|
|
def prog(self):
|
|
|
|
localctx = CommentMacroParser.ProgContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 0, self.RULE_prog)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 19
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while True:
|
|
self.state = 18
|
|
self.statement()
|
|
self.state = 21
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.T__1) | (1 << CommentMacroParser.T__3) | (1 << CommentMacroParser.T__4) | (1 << CommentMacroParser.T__5) | (1 << CommentMacroParser.T__6) | (1 << CommentMacroParser.T__7) | (1 << CommentMacroParser.T__8) | (1 << CommentMacroParser.T__9) | (1 << CommentMacroParser.T__10) | (1 << CommentMacroParser.T__11) | (1 << CommentMacroParser.T__12) | (1 << CommentMacroParser.T__13) | (1 << CommentMacroParser.T__14) | (1 << CommentMacroParser.T__15) | (1 << CommentMacroParser.T__16) | (1 << CommentMacroParser.T__17) | (1 << CommentMacroParser.T__18) | (1 << CommentMacroParser.T__19) | (1 << CommentMacroParser.T__20) | (1 << CommentMacroParser.T__21) | (1 << CommentMacroParser.T__22) | (1 << CommentMacroParser.T__23) | (1 << CommentMacroParser.T__26) | (1 << CommentMacroParser.T__27) | (1 << CommentMacroParser.T__28) | (1 << CommentMacroParser.T__29) | (1 << CommentMacroParser.T__30) | (1 << CommentMacroParser.NEWLINE))) != 0)):
|
|
break
|
|
|
|
self.state = 23
|
|
self.match(CommentMacroParser.EOF)
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class StatementContext(ParserRuleContext):
|
|
|
|
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def macro(self, i:int=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CommentMacroParser.MacroContext)
|
|
else:
|
|
return self.getTypedRuleContext(CommentMacroParser.MacroContext,i)
|
|
|
|
|
|
def NEWLINE(self):
|
|
return self.getToken(CommentMacroParser.NEWLINE, 0)
|
|
|
|
def getRuleIndex(self):
|
|
return CommentMacroParser.RULE_statement
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterStatement" ):
|
|
listener.enterStatement(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitStatement" ):
|
|
listener.exitStatement(self)
|
|
|
|
|
|
|
|
|
|
def statement(self):
|
|
|
|
localctx = CommentMacroParser.StatementContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 2, self.RULE_statement)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.state = 37
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
if token in [CommentMacroParser.T__1, CommentMacroParser.T__3, CommentMacroParser.T__4, CommentMacroParser.T__5, CommentMacroParser.T__6, CommentMacroParser.T__7, CommentMacroParser.T__8, CommentMacroParser.T__9, CommentMacroParser.T__10, CommentMacroParser.T__11, CommentMacroParser.T__12, CommentMacroParser.T__13, CommentMacroParser.T__14, CommentMacroParser.T__15, CommentMacroParser.T__16, CommentMacroParser.T__17, CommentMacroParser.T__18, CommentMacroParser.T__19, CommentMacroParser.T__20, CommentMacroParser.T__21, CommentMacroParser.T__22, CommentMacroParser.T__23, CommentMacroParser.T__26, CommentMacroParser.T__27, CommentMacroParser.T__28, CommentMacroParser.T__29, CommentMacroParser.T__30]:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 25
|
|
self.macro()
|
|
self.state = 30
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while _la==CommentMacroParser.T__0:
|
|
self.state = 26
|
|
self.match(CommentMacroParser.T__0)
|
|
self.state = 27
|
|
self.macro()
|
|
self.state = 32
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
self.state = 34
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
|
|
if la_ == 1:
|
|
self.state = 33
|
|
self.match(CommentMacroParser.NEWLINE)
|
|
|
|
|
|
pass
|
|
elif token in [CommentMacroParser.NEWLINE]:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 36
|
|
self.match(CommentMacroParser.NEWLINE)
|
|
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
|
|
|
|
class MacroContext(ParserRuleContext):
|
|
|
|
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CommentMacroParser.RULE_macro
|
|
|
|
|
|
def copyFrom(self, ctx:ParserRuleContext):
|
|
super().copyFrom(ctx)
|
|
|
|
|
|
|
|
class SceneReleaseContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.t = None # TargetContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def target(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterSceneRelease" ):
|
|
listener.enterSceneRelease(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitSceneRelease" ):
|
|
listener.exitSceneRelease(self)
|
|
|
|
|
|
class MasterAssertContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.t = None # TargetContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def target(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterMasterAssert" ):
|
|
listener.enterMasterAssert(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitMasterAssert" ):
|
|
listener.exitMasterAssert(self)
|
|
|
|
|
|
class MasterGotoContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.t = None # TargetContext
|
|
self.n = None # NumberContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def number(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.NumberContext,0)
|
|
|
|
def target(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterMasterGoto" ):
|
|
listener.enterMasterGoto(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitMasterGoto" ):
|
|
listener.exitMasterGoto(self)
|
|
|
|
|
|
class ListGotoContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.t = None # TargetContext
|
|
self.n = None # NumberContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def target(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)
|
|
|
|
def number(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.NumberContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterListGoto" ):
|
|
listener.enterListGoto(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitListGoto" ):
|
|
listener.exitListGoto(self)
|
|
|
|
|
|
class SceneAssertContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.t = None # TargetContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def target(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterSceneAssert" ):
|
|
listener.enterSceneAssert(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitSceneAssert" ):
|
|
listener.exitSceneAssert(self)
|
|
|
|
|
|
class RecallViewContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.n = None # NumberContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def number(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.NumberContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterRecallView" ):
|
|
listener.enterRecallView(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitRecallView" ):
|
|
listener.exitRecallView(self)
|
|
|
|
|
|
class MasterGoContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.t = None # TargetContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def target(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterMasterGo" ):
|
|
listener.enterMasterGo(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitMasterGo" ):
|
|
listener.exitMasterGo(self)
|
|
|
|
|
|
class SceneHaltContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.t = None # TargetContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def target(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterSceneHalt" ):
|
|
listener.enterSceneHalt(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitSceneHalt" ):
|
|
listener.exitSceneHalt(self)
|
|
|
|
|
|
class MasterChooseContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.n = None # NumberContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def number(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.NumberContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterMasterChoose" ):
|
|
listener.enterMasterChoose(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitMasterChoose" ):
|
|
listener.exitMasterChoose(self)
|
|
|
|
|
|
class BatchGoContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.t = None # TargetContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def target(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterBatchGo" ):
|
|
listener.enterBatchGo(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitBatchGo" ):
|
|
listener.exitBatchGo(self)
|
|
|
|
|
|
class PagePrevContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterPagePrev" ):
|
|
listener.enterPagePrev(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitPagePrev" ):
|
|
listener.exitPagePrev(self)
|
|
|
|
|
|
class PageNextContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterPageNext" ):
|
|
listener.enterPageNext(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitPageNext" ):
|
|
listener.exitPageNext(self)
|
|
|
|
|
|
class ListReleseContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.t = None # TargetContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def target(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterListRelese" ):
|
|
listener.enterListRelese(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitListRelese" ):
|
|
listener.exitListRelese(self)
|
|
|
|
|
|
class ListHaltContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.t = None # TargetContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def target(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterListHalt" ):
|
|
listener.enterListHalt(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitListHalt" ):
|
|
listener.exitListHalt(self)
|
|
|
|
|
|
class ReleaseAllContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterReleaseAll" ):
|
|
listener.enterReleaseAll(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitReleaseAll" ):
|
|
listener.exitReleaseAll(self)
|
|
|
|
|
|
class MacroGoContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.t = None # TargetContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def target(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterMacroGo" ):
|
|
listener.enterMacroGo(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitMacroGo" ):
|
|
listener.exitMacroGo(self)
|
|
|
|
|
|
class MasterReleaseContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.t = None # TargetContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def target(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterMasterRelease" ):
|
|
listener.enterMasterRelease(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitMasterRelease" ):
|
|
listener.exitMasterRelease(self)
|
|
|
|
|
|
class MasterFadeContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.t = None # TargetContext
|
|
self.n = None # NumberContext
|
|
self.f = None # TimeContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def number(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.NumberContext,0)
|
|
|
|
def target(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)
|
|
|
|
def time(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TimeContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterMasterFade" ):
|
|
listener.enterMasterFade(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitMasterFade" ):
|
|
listener.exitMasterFade(self)
|
|
|
|
|
|
class BatchAssertContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.t = None # TargetContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def target(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterBatchAssert" ):
|
|
listener.enterBatchAssert(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitBatchAssert" ):
|
|
listener.exitBatchAssert(self)
|
|
|
|
|
|
class MasterHaltContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.t = None # TargetContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def target(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterMasterHalt" ):
|
|
listener.enterMasterHalt(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitMasterHalt" ):
|
|
listener.exitMasterHalt(self)
|
|
|
|
|
|
class SceneGoContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.t = None # TargetContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def target(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterSceneGo" ):
|
|
listener.enterSceneGo(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitSceneGo" ):
|
|
listener.exitSceneGo(self)
|
|
|
|
|
|
class ListAssertContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.t = None # TargetContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def target(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterListAssert" ):
|
|
listener.enterListAssert(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitListAssert" ):
|
|
listener.exitListAssert(self)
|
|
|
|
|
|
class ListGoContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.t = None # TargetContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def target(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterListGo" ):
|
|
listener.enterListGo(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitListGo" ):
|
|
listener.exitListGo(self)
|
|
|
|
|
|
class BatchReleaseContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.t = None # TargetContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def target(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterBatchRelease" ):
|
|
listener.enterBatchRelease(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitBatchRelease" ):
|
|
listener.exitBatchRelease(self)
|
|
|
|
|
|
class FadeGrandMasterContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.n = None # NumberContext
|
|
self.f = None # TimeContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def number(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.NumberContext,0)
|
|
|
|
def time(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TimeContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterFadeGrandMaster" ):
|
|
listener.enterFadeGrandMaster(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitFadeGrandMaster" ):
|
|
listener.exitFadeGrandMaster(self)
|
|
|
|
|
|
class BatchHaltContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.t = None # TargetContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def target(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterBatchHalt" ):
|
|
listener.enterBatchHalt(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitBatchHalt" ):
|
|
listener.exitBatchHalt(self)
|
|
|
|
|
|
class MacroStopContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.t = None # TargetContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def target(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterMacroStop" ):
|
|
listener.enterMacroStop(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitMacroStop" ):
|
|
listener.exitMacroStop(self)
|
|
|
|
|
|
class PageChangeContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.n = None # NumberContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def number(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.NumberContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterPageChange" ):
|
|
listener.enterPageChange(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitPageChange" ):
|
|
listener.exitPageChange(self)
|
|
|
|
|
|
class NodeResetContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterNodeReset" ):
|
|
listener.enterNodeReset(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitNodeReset" ):
|
|
listener.exitNodeReset(self)
|
|
|
|
|
|
class ReleaseOthersContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterReleaseOthers" ):
|
|
listener.enterReleaseOthers(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitReleaseOthers" ):
|
|
listener.exitReleaseOthers(self)
|
|
|
|
|
|
class MacroHaltContext(MacroContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a CommentMacroParser.MacroContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.t = None # TargetContext
|
|
self.dev = None # DeviceContext
|
|
self.copyFrom(ctx)
|
|
|
|
def target(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.TargetContext,0)
|
|
|
|
def device(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.DeviceContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterMacroHalt" ):
|
|
listener.enterMacroHalt(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitMacroHalt" ):
|
|
listener.exitMacroHalt(self)
|
|
|
|
|
|
|
|
def macro(self):
|
|
|
|
localctx = CommentMacroParser.MacroContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 4, self.RULE_macro)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.state = 219
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
|
|
if la_ == 1:
|
|
localctx = CommentMacroParser.MasterGoContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 39
|
|
localctx.op = self.match(CommentMacroParser.T__1)
|
|
self.state = 42
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
if token in [CommentMacroParser.NUMBER]:
|
|
self.state = 40
|
|
localctx.t = self.target()
|
|
pass
|
|
elif token in [CommentMacroParser.CURRENT]:
|
|
self.state = 41
|
|
self.match(CommentMacroParser.CURRENT)
|
|
pass
|
|
else:
|
|
raise NoViableAltException(self)
|
|
|
|
self.state = 45
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 44
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 2:
|
|
localctx = CommentMacroParser.MasterGotoContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 47
|
|
localctx.op = self.match(CommentMacroParser.T__1)
|
|
self.state = 50
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
if token in [CommentMacroParser.NUMBER]:
|
|
self.state = 48
|
|
localctx.t = self.target()
|
|
pass
|
|
elif token in [CommentMacroParser.CURRENT]:
|
|
self.state = 49
|
|
self.match(CommentMacroParser.CURRENT)
|
|
pass
|
|
else:
|
|
raise NoViableAltException(self)
|
|
|
|
self.state = 52
|
|
self.match(CommentMacroParser.T__2)
|
|
self.state = 53
|
|
localctx.n = self.number()
|
|
self.state = 55
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 54
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 3:
|
|
localctx = CommentMacroParser.MasterHaltContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 3)
|
|
self.state = 57
|
|
localctx.op = self.match(CommentMacroParser.T__3)
|
|
self.state = 60
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
if token in [CommentMacroParser.NUMBER]:
|
|
self.state = 58
|
|
localctx.t = self.target()
|
|
pass
|
|
elif token in [CommentMacroParser.CURRENT]:
|
|
self.state = 59
|
|
self.match(CommentMacroParser.CURRENT)
|
|
pass
|
|
else:
|
|
raise NoViableAltException(self)
|
|
|
|
self.state = 63
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 62
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 4:
|
|
localctx = CommentMacroParser.MasterAssertContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 4)
|
|
self.state = 65
|
|
localctx.op = self.match(CommentMacroParser.T__4)
|
|
self.state = 68
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
if token in [CommentMacroParser.NUMBER]:
|
|
self.state = 66
|
|
localctx.t = self.target()
|
|
pass
|
|
elif token in [CommentMacroParser.CURRENT]:
|
|
self.state = 67
|
|
self.match(CommentMacroParser.CURRENT)
|
|
pass
|
|
else:
|
|
raise NoViableAltException(self)
|
|
|
|
self.state = 71
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 70
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 5:
|
|
localctx = CommentMacroParser.MasterReleaseContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 5)
|
|
self.state = 73
|
|
localctx.op = self.match(CommentMacroParser.T__5)
|
|
self.state = 76
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
if token in [CommentMacroParser.NUMBER]:
|
|
self.state = 74
|
|
localctx.t = self.target()
|
|
pass
|
|
elif token in [CommentMacroParser.CURRENT]:
|
|
self.state = 75
|
|
self.match(CommentMacroParser.CURRENT)
|
|
pass
|
|
else:
|
|
raise NoViableAltException(self)
|
|
|
|
self.state = 79
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 78
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 6:
|
|
localctx = CommentMacroParser.ReleaseAllContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 6)
|
|
self.state = 81
|
|
localctx.op = self.match(CommentMacroParser.T__6)
|
|
self.state = 83
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 82
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 7:
|
|
localctx = CommentMacroParser.ReleaseOthersContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 7)
|
|
self.state = 85
|
|
localctx.op = self.match(CommentMacroParser.T__7)
|
|
self.state = 87
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 86
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 8:
|
|
localctx = CommentMacroParser.MasterFadeContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 8)
|
|
self.state = 89
|
|
localctx.op = self.match(CommentMacroParser.T__8)
|
|
self.state = 92
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
if token in [CommentMacroParser.NUMBER]:
|
|
self.state = 90
|
|
localctx.t = self.target()
|
|
pass
|
|
elif token in [CommentMacroParser.CURRENT]:
|
|
self.state = 91
|
|
self.match(CommentMacroParser.CURRENT)
|
|
pass
|
|
else:
|
|
raise NoViableAltException(self)
|
|
|
|
self.state = 94
|
|
self.match(CommentMacroParser.T__2)
|
|
self.state = 95
|
|
localctx.n = self.number()
|
|
self.state = 97
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==CommentMacroParser.TIME:
|
|
self.state = 96
|
|
localctx.f = self.time()
|
|
|
|
|
|
self.state = 100
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 99
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 9:
|
|
localctx = CommentMacroParser.FadeGrandMasterContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 9)
|
|
self.state = 102
|
|
localctx.op = self.match(CommentMacroParser.T__9)
|
|
self.state = 103
|
|
localctx.n = self.number()
|
|
self.state = 105
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==CommentMacroParser.TIME:
|
|
self.state = 104
|
|
localctx.f = self.time()
|
|
|
|
|
|
self.state = 108
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 107
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 10:
|
|
localctx = CommentMacroParser.MasterChooseContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 10)
|
|
self.state = 110
|
|
localctx.op = self.match(CommentMacroParser.T__10)
|
|
self.state = 111
|
|
localctx.n = self.number()
|
|
self.state = 113
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 112
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 11:
|
|
localctx = CommentMacroParser.ListGoContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 11)
|
|
self.state = 115
|
|
localctx.op = self.match(CommentMacroParser.T__11)
|
|
self.state = 116
|
|
localctx.t = self.target()
|
|
self.state = 118
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 117
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 12:
|
|
localctx = CommentMacroParser.ListGotoContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 12)
|
|
self.state = 120
|
|
localctx.op = self.match(CommentMacroParser.T__11)
|
|
self.state = 121
|
|
localctx.t = self.target()
|
|
self.state = 122
|
|
self.match(CommentMacroParser.T__2)
|
|
self.state = 123
|
|
localctx.n = self.number()
|
|
self.state = 125
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 124
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 13:
|
|
localctx = CommentMacroParser.ListHaltContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 13)
|
|
self.state = 127
|
|
localctx.op = self.match(CommentMacroParser.T__12)
|
|
self.state = 128
|
|
localctx.t = self.target()
|
|
self.state = 130
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 129
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 14:
|
|
localctx = CommentMacroParser.ListAssertContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 14)
|
|
self.state = 132
|
|
localctx.op = self.match(CommentMacroParser.T__13)
|
|
self.state = 133
|
|
localctx.t = self.target()
|
|
self.state = 135
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 134
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 15:
|
|
localctx = CommentMacroParser.ListReleseContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 15)
|
|
self.state = 137
|
|
localctx.op = self.match(CommentMacroParser.T__14)
|
|
self.state = 138
|
|
localctx.t = self.target()
|
|
self.state = 140
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 139
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 16:
|
|
localctx = CommentMacroParser.BatchGoContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 16)
|
|
self.state = 142
|
|
localctx.op = self.match(CommentMacroParser.T__15)
|
|
self.state = 143
|
|
localctx.t = self.target()
|
|
self.state = 145
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 144
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 17:
|
|
localctx = CommentMacroParser.BatchHaltContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 17)
|
|
self.state = 147
|
|
localctx.op = self.match(CommentMacroParser.T__16)
|
|
self.state = 148
|
|
localctx.t = self.target()
|
|
self.state = 150
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 149
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 18:
|
|
localctx = CommentMacroParser.BatchAssertContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 18)
|
|
self.state = 152
|
|
localctx.op = self.match(CommentMacroParser.T__17)
|
|
self.state = 153
|
|
localctx.t = self.target()
|
|
self.state = 155
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 154
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 19:
|
|
localctx = CommentMacroParser.BatchReleaseContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 19)
|
|
self.state = 157
|
|
localctx.op = self.match(CommentMacroParser.T__18)
|
|
self.state = 158
|
|
localctx.t = self.target()
|
|
self.state = 160
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 159
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 20:
|
|
localctx = CommentMacroParser.SceneGoContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 20)
|
|
self.state = 162
|
|
localctx.op = self.match(CommentMacroParser.T__19)
|
|
self.state = 163
|
|
localctx.t = self.target()
|
|
self.state = 165
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 164
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 21:
|
|
localctx = CommentMacroParser.SceneHaltContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 21)
|
|
self.state = 167
|
|
localctx.op = self.match(CommentMacroParser.T__20)
|
|
self.state = 168
|
|
localctx.t = self.target()
|
|
self.state = 170
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 169
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 22:
|
|
localctx = CommentMacroParser.SceneAssertContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 22)
|
|
self.state = 172
|
|
localctx.op = self.match(CommentMacroParser.T__21)
|
|
self.state = 173
|
|
localctx.t = self.target()
|
|
self.state = 175
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 174
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 23:
|
|
localctx = CommentMacroParser.SceneReleaseContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 23)
|
|
self.state = 177
|
|
localctx.op = self.match(CommentMacroParser.T__22)
|
|
self.state = 178
|
|
localctx.t = self.target()
|
|
self.state = 180
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 179
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 24:
|
|
localctx = CommentMacroParser.PageChangeContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 24)
|
|
self.state = 182
|
|
localctx.op = self.match(CommentMacroParser.T__23)
|
|
self.state = 183
|
|
localctx.n = self.number()
|
|
self.state = 185
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 184
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 25:
|
|
localctx = CommentMacroParser.PageNextContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 25)
|
|
self.state = 187
|
|
localctx.op = self.match(CommentMacroParser.T__23)
|
|
self.state = 188
|
|
self.match(CommentMacroParser.T__24)
|
|
self.state = 190
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 189
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 26:
|
|
localctx = CommentMacroParser.PagePrevContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 26)
|
|
self.state = 192
|
|
localctx.op = self.match(CommentMacroParser.T__23)
|
|
self.state = 193
|
|
self.match(CommentMacroParser.T__25)
|
|
self.state = 195
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 194
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 27:
|
|
localctx = CommentMacroParser.RecallViewContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 27)
|
|
self.state = 197
|
|
localctx.op = self.match(CommentMacroParser.T__26)
|
|
self.state = 198
|
|
localctx.n = self.number()
|
|
self.state = 200
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 199
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 28:
|
|
localctx = CommentMacroParser.NodeResetContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 28)
|
|
self.state = 202
|
|
localctx.op = self.match(CommentMacroParser.T__27)
|
|
self.state = 203
|
|
localctx.dev = self.device()
|
|
pass
|
|
|
|
elif la_ == 29:
|
|
localctx = CommentMacroParser.MacroGoContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 29)
|
|
self.state = 204
|
|
localctx.op = self.match(CommentMacroParser.T__28)
|
|
self.state = 205
|
|
localctx.t = self.target()
|
|
self.state = 207
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 206
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 30:
|
|
localctx = CommentMacroParser.MacroHaltContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 30)
|
|
self.state = 209
|
|
localctx.op = self.match(CommentMacroParser.T__29)
|
|
self.state = 210
|
|
localctx.t = self.target()
|
|
self.state = 212
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 211
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
elif la_ == 31:
|
|
localctx = CommentMacroParser.MacroStopContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 31)
|
|
self.state = 214
|
|
localctx.op = self.match(CommentMacroParser.T__30)
|
|
self.state = 215
|
|
localctx.t = self.target()
|
|
self.state = 217
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 0):
|
|
self.state = 216
|
|
localctx.dev = self.device()
|
|
|
|
|
|
pass
|
|
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class TimeContext(ParserRuleContext):
|
|
|
|
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
self.n = None # NumberContext
|
|
|
|
def TIME(self):
|
|
return self.getToken(CommentMacroParser.TIME, 0)
|
|
|
|
def number(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.NumberContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CommentMacroParser.RULE_time
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterTime" ):
|
|
listener.enterTime(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitTime" ):
|
|
listener.exitTime(self)
|
|
|
|
|
|
|
|
|
|
def time(self):
|
|
|
|
localctx = CommentMacroParser.TimeContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 6, self.RULE_time)
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 221
|
|
self.match(CommentMacroParser.TIME)
|
|
self.state = 222
|
|
localctx.n = self.number()
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class DeviceContext(ParserRuleContext):
|
|
|
|
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
self.ntype = None # NodeTypeContext
|
|
self.n = None # NumberContext
|
|
|
|
def nodeType(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.NodeTypeContext,0)
|
|
|
|
|
|
def number(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.NumberContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CommentMacroParser.RULE_device
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterDevice" ):
|
|
listener.enterDevice(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitDevice" ):
|
|
listener.exitDevice(self)
|
|
|
|
|
|
|
|
|
|
def device(self):
|
|
|
|
localctx = CommentMacroParser.DeviceContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 8, self.RULE_device)
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 224
|
|
localctx.ntype = self.nodeType()
|
|
self.state = 225
|
|
localctx.n = self.number()
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class NodeTypeContext(ParserRuleContext):
|
|
|
|
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def WHOLEHOG(self):
|
|
return self.getToken(CommentMacroParser.WHOLEHOG, 0)
|
|
|
|
def DP8K(self):
|
|
return self.getToken(CommentMacroParser.DP8K, 0)
|
|
|
|
def IOP(self):
|
|
return self.getToken(CommentMacroParser.IOP, 0)
|
|
|
|
def getRuleIndex(self):
|
|
return CommentMacroParser.RULE_nodeType
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterNodeType" ):
|
|
listener.enterNodeType(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitNodeType" ):
|
|
listener.exitNodeType(self)
|
|
|
|
|
|
|
|
|
|
def nodeType(self):
|
|
|
|
localctx = CommentMacroParser.NodeTypeContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 10, self.RULE_nodeType)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 227
|
|
_la = self._input.LA(1)
|
|
if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CommentMacroParser.WHOLEHOG) | (1 << CommentMacroParser.DP8K) | (1 << CommentMacroParser.IOP))) != 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
|
|
|
|
class TargetContext(ParserRuleContext):
|
|
|
|
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def number(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.NumberContext,0)
|
|
|
|
|
|
def span(self):
|
|
return self.getTypedRuleContext(CommentMacroParser.SpanContext,0)
|
|
|
|
|
|
def target(self, i:int=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CommentMacroParser.TargetContext)
|
|
else:
|
|
return self.getTypedRuleContext(CommentMacroParser.TargetContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CommentMacroParser.RULE_target
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterTarget" ):
|
|
listener.enterTarget(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitTarget" ):
|
|
listener.exitTarget(self)
|
|
|
|
|
|
|
|
|
|
def target(self):
|
|
|
|
localctx = CommentMacroParser.TargetContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 12, self.RULE_target)
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 231
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,43,self._ctx)
|
|
if la_ == 1:
|
|
self.state = 229
|
|
self.number()
|
|
pass
|
|
|
|
elif la_ == 2:
|
|
self.state = 230
|
|
self.span()
|
|
pass
|
|
|
|
|
|
self.state = 237
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,44,self._ctx)
|
|
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
|
|
if _alt==1:
|
|
self.state = 233
|
|
self.match(CommentMacroParser.T__31)
|
|
self.state = 234
|
|
self.target()
|
|
self.state = 239
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,44,self._ctx)
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class SpanContext(ParserRuleContext):
|
|
|
|
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
self.n1 = None # NumberContext
|
|
self.n2 = None # NumberContext
|
|
|
|
def THRU(self):
|
|
return self.getToken(CommentMacroParser.THRU, 0)
|
|
|
|
def number(self, i:int=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(CommentMacroParser.NumberContext)
|
|
else:
|
|
return self.getTypedRuleContext(CommentMacroParser.NumberContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return CommentMacroParser.RULE_span
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterSpan" ):
|
|
listener.enterSpan(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitSpan" ):
|
|
listener.exitSpan(self)
|
|
|
|
|
|
|
|
|
|
def span(self):
|
|
|
|
localctx = CommentMacroParser.SpanContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 14, self.RULE_span)
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 240
|
|
localctx.n1 = self.number()
|
|
self.state = 241
|
|
self.match(CommentMacroParser.THRU)
|
|
self.state = 242
|
|
localctx.n2 = self.number()
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
class NumberContext(ParserRuleContext):
|
|
|
|
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def NUMBER(self):
|
|
return self.getToken(CommentMacroParser.NUMBER, 0)
|
|
|
|
def getRuleIndex(self):
|
|
return CommentMacroParser.RULE_number
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterNumber" ):
|
|
listener.enterNumber(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitNumber" ):
|
|
listener.exitNumber(self)
|
|
|
|
|
|
|
|
|
|
def number(self):
|
|
|
|
localctx = CommentMacroParser.NumberContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 16, self.RULE_number)
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 244
|
|
self.match(CommentMacroParser.NUMBER)
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
|
|
|
|
|
|
|