742 lines
24 KiB
Python
742 lines
24 KiB
Python
# Generated from ArmControl.g4 by ANTLR 4.7.2
|
|
# 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\21")
|
|
buf.write("Z\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b")
|
|
buf.write("\t\b\4\t\t\t\4\n\t\n\3\2\7\2\26\n\2\f\2\16\2\31\13\2\3")
|
|
buf.write("\2\3\2\3\3\3\3\3\3\7\3 \n\3\f\3\16\3#\13\3\3\3\5\3&\n")
|
|
buf.write("\3\3\3\5\3)\n\3\3\4\3\4\3\4\3\4\5\4/\n\4\3\4\3\4\3\4\5")
|
|
buf.write("\4\64\n\4\3\4\3\4\3\4\3\4\3\4\5\4;\n\4\5\4=\n\4\3\5\3")
|
|
buf.write("\5\5\5A\n\5\3\5\3\5\5\5E\n\5\7\5G\n\5\f\5\16\5J\13\5\3")
|
|
buf.write("\5\3\5\3\6\3\6\3\7\3\7\5\7R\n\7\3\b\3\b\3\t\3\t\3\n\3")
|
|
buf.write("\n\3\n\2\2\13\2\4\6\b\n\f\16\20\22\2\2\2`\2\27\3\2\2\2")
|
|
buf.write("\4(\3\2\2\2\6<\3\2\2\2\b>\3\2\2\2\nM\3\2\2\2\fQ\3\2\2")
|
|
buf.write("\2\16S\3\2\2\2\20U\3\2\2\2\22W\3\2\2\2\24\26\5\4\3\2\25")
|
|
buf.write("\24\3\2\2\2\26\31\3\2\2\2\27\25\3\2\2\2\27\30\3\2\2\2")
|
|
buf.write("\30\32\3\2\2\2\31\27\3\2\2\2\32\33\7\2\2\3\33\3\3\2\2")
|
|
buf.write("\2\34!\5\6\4\2\35\36\7\3\2\2\36 \5\6\4\2\37\35\3\2\2\2")
|
|
buf.write(" #\3\2\2\2!\37\3\2\2\2!\"\3\2\2\2\"%\3\2\2\2#!\3\2\2\2")
|
|
buf.write("$&\7\17\2\2%$\3\2\2\2%&\3\2\2\2&)\3\2\2\2\')\7\17\2\2")
|
|
buf.write("(\34\3\2\2\2(\'\3\2\2\2)\5\3\2\2\2*+\7\4\2\2+=\5\16\b")
|
|
buf.write("\2,.\7\5\2\2-/\5\16\b\2.-\3\2\2\2./\3\2\2\2/=\3\2\2\2")
|
|
buf.write("\60=\7\6\2\2\61=\7\7\2\2\62\64\7\b\2\2\63\62\3\2\2\2\63")
|
|
buf.write("\64\3\2\2\2\64:\3\2\2\2\65;\5\b\5\2\66\67\5\n\6\2\678")
|
|
buf.write("\5\f\7\28;\3\2\2\29;\5\n\6\2:\65\3\2\2\2:\66\3\2\2\2:")
|
|
buf.write("9\3\2\2\2;=\3\2\2\2<*\3\2\2\2<,\3\2\2\2<\60\3\2\2\2<\61")
|
|
buf.write("\3\2\2\2<\63\3\2\2\2=\7\3\2\2\2>@\7\t\2\2?A\5\f\7\2@?")
|
|
buf.write("\3\2\2\2@A\3\2\2\2AH\3\2\2\2BD\5\22\n\2CE\5\f\7\2DC\3")
|
|
buf.write("\2\2\2DE\3\2\2\2EG\3\2\2\2FB\3\2\2\2GJ\3\2\2\2HF\3\2\2")
|
|
buf.write("\2HI\3\2\2\2IK\3\2\2\2JH\3\2\2\2KL\7\n\2\2L\t\3\2\2\2")
|
|
buf.write("MN\7\13\2\2N\13\3\2\2\2OR\5\16\b\2PR\5\20\t\2QO\3\2\2")
|
|
buf.write("\2QP\3\2\2\2R\r\3\2\2\2ST\7\f\2\2T\17\3\2\2\2UV\7\r\2")
|
|
buf.write("\2V\21\3\2\2\2WX\7\16\2\2X\23\3\2\2\2\16\27!%(.\63:<@")
|
|
buf.write("DHQ")
|
|
return buf.getvalue()
|
|
|
|
|
|
class ArmControlParser ( Parser ):
|
|
|
|
grammarFileName = "ArmControl.g4"
|
|
|
|
atn = ATNDeserializer().deserialize(serializedATN())
|
|
|
|
decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
|
|
|
|
sharedContextCache = PredictionContextCache()
|
|
|
|
literalNames = [ "<INVALID>", "';'", "'pause'", "'wait'", "'pass'",
|
|
"'whereami'", "'go'", "'{'", "'}'", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "','" ]
|
|
|
|
symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "NAME", "NUMBER", "HEX", "SEPERATOR",
|
|
"NEWLINE", "WS", "COMMENT" ]
|
|
|
|
RULE_prog = 0
|
|
RULE_statement = 1
|
|
RULE_command = 2
|
|
RULE_coords = 3
|
|
RULE_name = 4
|
|
RULE_value = 5
|
|
RULE_number = 6
|
|
RULE_hexidecimal = 7
|
|
RULE_seperator = 8
|
|
|
|
ruleNames = [ "prog", "statement", "command", "coords", "name", "value",
|
|
"number", "hexidecimal", "seperator" ]
|
|
|
|
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
|
|
NAME=9
|
|
NUMBER=10
|
|
HEX=11
|
|
SEPERATOR=12
|
|
NEWLINE=13
|
|
WS=14
|
|
COMMENT=15
|
|
|
|
def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
|
|
super().__init__(input, output)
|
|
self.checkVersion("4.7.2")
|
|
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(ArmControlParser.EOF, 0)
|
|
|
|
def statement(self, i:int=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(ArmControlParser.StatementContext)
|
|
else:
|
|
return self.getTypedRuleContext(ArmControlParser.StatementContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return ArmControlParser.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 = ArmControlParser.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 = 21
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ArmControlParser.T__1) | (1 << ArmControlParser.T__2) | (1 << ArmControlParser.T__3) | (1 << ArmControlParser.T__4) | (1 << ArmControlParser.T__5) | (1 << ArmControlParser.T__6) | (1 << ArmControlParser.NAME) | (1 << ArmControlParser.NEWLINE))) != 0):
|
|
self.state = 18
|
|
self.statement()
|
|
self.state = 23
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
self.state = 24
|
|
self.match(ArmControlParser.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 command(self, i:int=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(ArmControlParser.CommandContext)
|
|
else:
|
|
return self.getTypedRuleContext(ArmControlParser.CommandContext,i)
|
|
|
|
|
|
def NEWLINE(self):
|
|
return self.getToken(ArmControlParser.NEWLINE, 0)
|
|
|
|
def getRuleIndex(self):
|
|
return ArmControlParser.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 = ArmControlParser.StatementContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 2, self.RULE_statement)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.state = 38
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
if token in [ArmControlParser.T__1, ArmControlParser.T__2, ArmControlParser.T__3, ArmControlParser.T__4, ArmControlParser.T__5, ArmControlParser.T__6, ArmControlParser.NAME]:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 26
|
|
self.command()
|
|
self.state = 31
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while _la==ArmControlParser.T__0:
|
|
self.state = 27
|
|
self.match(ArmControlParser.T__0)
|
|
self.state = 28
|
|
self.command()
|
|
self.state = 33
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
self.state = 35
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
|
|
if la_ == 1:
|
|
self.state = 34
|
|
self.match(ArmControlParser.NEWLINE)
|
|
|
|
|
|
pass
|
|
elif token in [ArmControlParser.NEWLINE]:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 37
|
|
self.match(ArmControlParser.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 CommandContext(ParserRuleContext):
|
|
|
|
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return ArmControlParser.RULE_command
|
|
|
|
|
|
def copyFrom(self, ctx:ParserRuleContext):
|
|
super().copyFrom(ctx)
|
|
|
|
|
|
|
|
class PauseContext(CommandContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a ArmControlParser.CommandContext
|
|
super().__init__(parser)
|
|
self.copyFrom(ctx)
|
|
|
|
def number(self):
|
|
return self.getTypedRuleContext(ArmControlParser.NumberContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterPause" ):
|
|
listener.enterPause(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitPause" ):
|
|
listener.exitPause(self)
|
|
|
|
|
|
class PassContext(CommandContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a ArmControlParser.CommandContext
|
|
super().__init__(parser)
|
|
self.copyFrom(ctx)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterPass" ):
|
|
listener.enterPass(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitPass" ):
|
|
listener.exitPass(self)
|
|
|
|
|
|
class GoContext(CommandContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a ArmControlParser.CommandContext
|
|
super().__init__(parser)
|
|
self.copyFrom(ctx)
|
|
|
|
def coords(self):
|
|
return self.getTypedRuleContext(ArmControlParser.CoordsContext,0)
|
|
|
|
def name(self):
|
|
return self.getTypedRuleContext(ArmControlParser.NameContext,0)
|
|
|
|
def value(self):
|
|
return self.getTypedRuleContext(ArmControlParser.ValueContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterGo" ):
|
|
listener.enterGo(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitGo" ):
|
|
listener.exitGo(self)
|
|
|
|
|
|
class WhereAmIContext(CommandContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a ArmControlParser.CommandContext
|
|
super().__init__(parser)
|
|
self.copyFrom(ctx)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterWhereAmI" ):
|
|
listener.enterWhereAmI(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitWhereAmI" ):
|
|
listener.exitWhereAmI(self)
|
|
|
|
|
|
class WaitContext(CommandContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a ArmControlParser.CommandContext
|
|
super().__init__(parser)
|
|
self.copyFrom(ctx)
|
|
|
|
def number(self):
|
|
return self.getTypedRuleContext(ArmControlParser.NumberContext,0)
|
|
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterWait" ):
|
|
listener.enterWait(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitWait" ):
|
|
listener.exitWait(self)
|
|
|
|
|
|
|
|
def command(self):
|
|
|
|
localctx = ArmControlParser.CommandContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 4, self.RULE_command)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.state = 58
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
if token in [ArmControlParser.T__1]:
|
|
localctx = ArmControlParser.PauseContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 40
|
|
self.match(ArmControlParser.T__1)
|
|
self.state = 41
|
|
self.number()
|
|
pass
|
|
elif token in [ArmControlParser.T__2]:
|
|
localctx = ArmControlParser.WaitContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 42
|
|
self.match(ArmControlParser.T__2)
|
|
self.state = 44
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==ArmControlParser.NUMBER:
|
|
self.state = 43
|
|
self.number()
|
|
|
|
|
|
pass
|
|
elif token in [ArmControlParser.T__3]:
|
|
localctx = ArmControlParser.PassContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 3)
|
|
self.state = 46
|
|
self.match(ArmControlParser.T__3)
|
|
pass
|
|
elif token in [ArmControlParser.T__4]:
|
|
localctx = ArmControlParser.WhereAmIContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 4)
|
|
self.state = 47
|
|
self.match(ArmControlParser.T__4)
|
|
pass
|
|
elif token in [ArmControlParser.T__5, ArmControlParser.T__6, ArmControlParser.NAME]:
|
|
localctx = ArmControlParser.GoContext(self, localctx)
|
|
self.enterOuterAlt(localctx, 5)
|
|
self.state = 49
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==ArmControlParser.T__5:
|
|
self.state = 48
|
|
self.match(ArmControlParser.T__5)
|
|
|
|
|
|
self.state = 56
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
|
|
if la_ == 1:
|
|
self.state = 51
|
|
self.coords()
|
|
pass
|
|
|
|
elif la_ == 2:
|
|
self.state = 52
|
|
self.name()
|
|
self.state = 53
|
|
self.value()
|
|
pass
|
|
|
|
elif la_ == 3:
|
|
self.state = 55
|
|
self.name()
|
|
pass
|
|
|
|
|
|
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 CoordsContext(ParserRuleContext):
|
|
|
|
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def value(self, i:int=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(ArmControlParser.ValueContext)
|
|
else:
|
|
return self.getTypedRuleContext(ArmControlParser.ValueContext,i)
|
|
|
|
|
|
def seperator(self, i:int=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(ArmControlParser.SeperatorContext)
|
|
else:
|
|
return self.getTypedRuleContext(ArmControlParser.SeperatorContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return ArmControlParser.RULE_coords
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterCoords" ):
|
|
listener.enterCoords(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitCoords" ):
|
|
listener.exitCoords(self)
|
|
|
|
|
|
|
|
|
|
def coords(self):
|
|
|
|
localctx = ArmControlParser.CoordsContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 6, self.RULE_coords)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 60
|
|
self.match(ArmControlParser.T__6)
|
|
self.state = 62
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==ArmControlParser.NUMBER or _la==ArmControlParser.HEX:
|
|
self.state = 61
|
|
self.value()
|
|
|
|
|
|
self.state = 70
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while _la==ArmControlParser.SEPERATOR:
|
|
self.state = 64
|
|
self.seperator()
|
|
self.state = 66
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if _la==ArmControlParser.NUMBER or _la==ArmControlParser.HEX:
|
|
self.state = 65
|
|
self.value()
|
|
|
|
|
|
self.state = 72
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
|
|
self.state = 73
|
|
self.match(ArmControlParser.T__7)
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
|
|
class NameContext(ParserRuleContext):
|
|
|
|
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def NAME(self):
|
|
return self.getToken(ArmControlParser.NAME, 0)
|
|
|
|
def getRuleIndex(self):
|
|
return ArmControlParser.RULE_name
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterName" ):
|
|
listener.enterName(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitName" ):
|
|
listener.exitName(self)
|
|
|
|
|
|
|
|
|
|
def name(self):
|
|
|
|
localctx = ArmControlParser.NameContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 8, self.RULE_name)
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 75
|
|
self.match(ArmControlParser.NAME)
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
|
|
class ValueContext(ParserRuleContext):
|
|
|
|
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def number(self):
|
|
return self.getTypedRuleContext(ArmControlParser.NumberContext,0)
|
|
|
|
|
|
def hexidecimal(self):
|
|
return self.getTypedRuleContext(ArmControlParser.HexidecimalContext,0)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return ArmControlParser.RULE_value
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterValue" ):
|
|
listener.enterValue(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitValue" ):
|
|
listener.exitValue(self)
|
|
|
|
|
|
|
|
|
|
def value(self):
|
|
|
|
localctx = ArmControlParser.ValueContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 10, self.RULE_value)
|
|
try:
|
|
self.state = 79
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
if token in [ArmControlParser.NUMBER]:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 77
|
|
self.number()
|
|
pass
|
|
elif token in [ArmControlParser.HEX]:
|
|
self.enterOuterAlt(localctx, 2)
|
|
self.state = 78
|
|
self.hexidecimal()
|
|
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 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(ArmControlParser.NUMBER, 0)
|
|
|
|
def getRuleIndex(self):
|
|
return ArmControlParser.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 = ArmControlParser.NumberContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 12, self.RULE_number)
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 81
|
|
self.match(ArmControlParser.NUMBER)
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
|
|
class HexidecimalContext(ParserRuleContext):
|
|
|
|
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def HEX(self):
|
|
return self.getToken(ArmControlParser.HEX, 0)
|
|
|
|
def getRuleIndex(self):
|
|
return ArmControlParser.RULE_hexidecimal
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterHexidecimal" ):
|
|
listener.enterHexidecimal(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitHexidecimal" ):
|
|
listener.exitHexidecimal(self)
|
|
|
|
|
|
|
|
|
|
def hexidecimal(self):
|
|
|
|
localctx = ArmControlParser.HexidecimalContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 14, self.RULE_hexidecimal)
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 83
|
|
self.match(ArmControlParser.HEX)
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
|
|
class SeperatorContext(ParserRuleContext):
|
|
|
|
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def SEPERATOR(self):
|
|
return self.getToken(ArmControlParser.SEPERATOR, 0)
|
|
|
|
def getRuleIndex(self):
|
|
return ArmControlParser.RULE_seperator
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterSeperator" ):
|
|
listener.enterSeperator(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitSeperator" ):
|
|
listener.exitSeperator(self)
|
|
|
|
|
|
|
|
|
|
def seperator(self):
|
|
|
|
localctx = ArmControlParser.SeperatorContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 16, self.RULE_seperator)
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 85
|
|
self.match(ArmControlParser.SEPERATOR)
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
|
|
|
|
|
|
|