kevin
/
armCtl
1
0
Fork 0
Code Releases Activity

scripting language

This commit is contained in:
Kevin Matz 2019-07-29 23:45:16 -04:00
parent cf65aa0c8c
commit f82c24fcf5
4 changed files with 1041 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

112
ArmControl.g4 Normal file
View File

@ -0,0 +1,112 @@
/*
The MIT License (MIT)
=====================
Copyright © 2019 Kevin Matz (kevin@company235.com)
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the “Software”), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
*/
grammar ArmControl;
/**
** Parser Rules
**/
prog : statement* EOF;
statement : command ( ';' command )* NEWLINE?
| NEWLINE
;
command
: 'GO' ( coords | name value | name ) #Go
| 'PAUSE' number #Pause
| 'WAIT' number? #Wait
| 'PASS' #Pass
;
coords : '{' value? ( seperator value? )* '}' ;
name : NAME ;
value
: number
| hexidecimal
;
number
: NUMBER
;
hexidecimal
: HEX
;
seperator
: SEPERATOR
;
/**
** LEXAR Rules
**/
NAME
: [a-zA-Z_][a-zA-Z_0-9]*
;
NUMBER
: DIGIT+ ('.' DIGIT+)?
;
HEX
: HexDigit HexDigit
;
fragment
DIGIT
: [0-9]
;
fragment
HexDigit
: [0-9a-fA-F]
;
SEPERATOR
: ','
;
NEWLINE // return newlines to parser
: '\r'? '\n'
;
WS // ignore whitespace
: [ \t]+ -> skip
;
COMMENT // ignore inline commkents
: ( '//' ~[\r\n]*
| '#' ~[\r\n]*
) -> skip
;

100
ArmControlLexer.py Normal file
View File

@ -0,0 +1,100 @@
# Generated from ArmControl.g4 by ANTLR 4.7.2
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\2\20")
buf.write("y\b\1\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\3\2\3\2\3\3\3\3\3")
buf.write("\3\3\4\3\4\3\4\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3\6\3\6")
buf.write("\3\6\3\6\3\6\3\7\3\7\3\b\3\b\3\t\3\t\7\t?\n\t\f\t\16\t")
buf.write("B\13\t\3\n\6\nE\n\n\r\n\16\nF\3\n\3\n\6\nK\n\n\r\n\16")
buf.write("\nL\5\nO\n\n\3\13\3\13\3\13\3\f\3\f\3\r\3\r\3\16\3\16")
buf.write("\3\17\5\17[\n\17\3\17\3\17\3\20\6\20`\n\20\r\20\16\20")
buf.write("a\3\20\3\20\3\21\3\21\3\21\3\21\7\21j\n\21\f\21\16\21")
buf.write("m\13\21\3\21\3\21\7\21q\n\21\f\21\16\21t\13\21\5\21v\n")
buf.write("\21\3\21\3\21\2\2\22\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21")
buf.write("\n\23\13\25\f\27\2\31\2\33\r\35\16\37\17!\20\3\2\b\5\2")
buf.write("C\\aac|\6\2\62;C\\aac|\3\2\62;\5\2\62;CHch\4\2\13\13\"")
buf.write("\"\4\2\f\f\17\17\2\177\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2")
buf.write("\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2")
buf.write("\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\33\3\2\2\2\2")
buf.write("\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\3#\3\2\2\2\5%\3\2")
buf.write("\2\2\7(\3\2\2\2\t.\3\2\2\2\13\63\3\2\2\2\r8\3\2\2\2\17")
buf.write(":\3\2\2\2\21<\3\2\2\2\23D\3\2\2\2\25P\3\2\2\2\27S\3\2")
buf.write("\2\2\31U\3\2\2\2\33W\3\2\2\2\35Z\3\2\2\2\37_\3\2\2\2!")
buf.write("u\3\2\2\2#$\7=\2\2$\4\3\2\2\2%&\7I\2\2&\'\7Q\2\2\'\6\3")
buf.write("\2\2\2()\7R\2\2)*\7C\2\2*+\7W\2\2+,\7U\2\2,-\7G\2\2-\b")
buf.write("\3\2\2\2./\7Y\2\2/\60\7C\2\2\60\61\7K\2\2\61\62\7V\2\2")
buf.write("\62\n\3\2\2\2\63\64\7R\2\2\64\65\7C\2\2\65\66\7U\2\2\66")
buf.write("\67\7U\2\2\67\f\3\2\2\289\7}\2\29\16\3\2\2\2:;\7\177\2")
buf.write("\2;\20\3\2\2\2<@\t\2\2\2=?\t\3\2\2>=\3\2\2\2?B\3\2\2\2")
buf.write("@>\3\2\2\2@A\3\2\2\2A\22\3\2\2\2B@\3\2\2\2CE\5\27\f\2")
buf.write("DC\3\2\2\2EF\3\2\2\2FD\3\2\2\2FG\3\2\2\2GN\3\2\2\2HJ\7")
buf.write("\60\2\2IK\5\27\f\2JI\3\2\2\2KL\3\2\2\2LJ\3\2\2\2LM\3\2")
buf.write("\2\2MO\3\2\2\2NH\3\2\2\2NO\3\2\2\2O\24\3\2\2\2PQ\5\31")
buf.write("\r\2QR\5\31\r\2R\26\3\2\2\2ST\t\4\2\2T\30\3\2\2\2UV\t")
buf.write("\5\2\2V\32\3\2\2\2WX\7.\2\2X\34\3\2\2\2Y[\7\17\2\2ZY\3")
buf.write("\2\2\2Z[\3\2\2\2[\\\3\2\2\2\\]\7\f\2\2]\36\3\2\2\2^`\t")
buf.write("\6\2\2_^\3\2\2\2`a\3\2\2\2a_\3\2\2\2ab\3\2\2\2bc\3\2\2")
buf.write("\2cd\b\20\2\2d \3\2\2\2ef\7\61\2\2fg\7\61\2\2gk\3\2\2")
buf.write("\2hj\n\7\2\2ih\3\2\2\2jm\3\2\2\2ki\3\2\2\2kl\3\2\2\2l")
buf.write("v\3\2\2\2mk\3\2\2\2nr\7%\2\2oq\n\7\2\2po\3\2\2\2qt\3\2")
buf.write("\2\2rp\3\2\2\2rs\3\2\2\2sv\3\2\2\2tr\3\2\2\2ue\3\2\2\2")
buf.write("un\3\2\2\2vw\3\2\2\2wx\b\21\2\2x\"\3\2\2\2\f\2@FLNZak")
buf.write("ru\3\b\2\2")
return buf.getvalue()
class ArmControlLexer(Lexer):
atn = ATNDeserializer().deserialize(serializedATN())
decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
T__0 = 1
T__1 = 2
T__2 = 3
T__3 = 4
T__4 = 5
T__5 = 6
T__6 = 7
NAME = 8
NUMBER = 9
HEX = 10
SEPERATOR = 11
NEWLINE = 12
WS = 13
COMMENT = 14
channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
modeNames = [ "DEFAULT_MODE" ]
literalNames = [ "<INVALID>",
"';'", "'GO'", "'PAUSE'", "'WAIT'", "'PASS'", "'{'", "'}'",
"','" ]
symbolicNames = [ "<INVALID>",
"NAME", "NUMBER", "HEX", "SEPERATOR", "NEWLINE", "WS", "COMMENT" ]
ruleNames = [ "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6",
"NAME", "NUMBER", "HEX", "DIGIT", "HexDigit", "SEPERATOR",
"NEWLINE", "WS", "COMMENT" ]
grammarFileName = "ArmControl.g4"
def __init__(self, input=None, output:TextIO = sys.stdout):
super().__init__(input, output)
self.checkVersion("4.7.2")
self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
self._actions = None
self._predicates = None

118
ArmControlListener.py Normal file
View File

@ -0,0 +1,118 @@
# Generated from ArmControl.g4 by ANTLR 4.7.2
from antlr4 import *
if __name__ is not None and "." in __name__:
from .ArmControlParser import ArmControlParser
else:
from ArmControlParser import ArmControlParser
# This class defines a complete listener for a parse tree produced by ArmControlParser.
class ArmControlListener(ParseTreeListener):
# Enter a parse tree produced by ArmControlParser#prog.
def enterProg(self, ctx:ArmControlParser.ProgContext):
pass
# Exit a parse tree produced by ArmControlParser#prog.
def exitProg(self, ctx:ArmControlParser.ProgContext):
pass
# Enter a parse tree produced by ArmControlParser#statement.
def enterStatement(self, ctx:ArmControlParser.StatementContext):
pass
# Exit a parse tree produced by ArmControlParser#statement.
def exitStatement(self, ctx:ArmControlParser.StatementContext):
pass
# Enter a parse tree produced by ArmControlParser#Go.
def enterGo(self, ctx:ArmControlParser.GoContext):
pass
# Exit a parse tree produced by ArmControlParser#Go.
def exitGo(self, ctx:ArmControlParser.GoContext):
pass
# Enter a parse tree produced by ArmControlParser#Pause.
def enterPause(self, ctx:ArmControlParser.PauseContext):
pass
# Exit a parse tree produced by ArmControlParser#Pause.
def exitPause(self, ctx:ArmControlParser.PauseContext):
pass
# Enter a parse tree produced by ArmControlParser#Wait.
def enterWait(self, ctx:ArmControlParser.WaitContext):
pass
# Exit a parse tree produced by ArmControlParser#Wait.
def exitWait(self, ctx:ArmControlParser.WaitContext):
pass
# Enter a parse tree produced by ArmControlParser#Pass.
def enterPass(self, ctx:ArmControlParser.PassContext):
pass
# Exit a parse tree produced by ArmControlParser#Pass.
def exitPass(self, ctx:ArmControlParser.PassContext):
pass
# Enter a parse tree produced by ArmControlParser#coords.
def enterCoords(self, ctx:ArmControlParser.CoordsContext):
pass
# Exit a parse tree produced by ArmControlParser#coords.
def exitCoords(self, ctx:ArmControlParser.CoordsContext):
pass
# Enter a parse tree produced by ArmControlParser#name.
def enterName(self, ctx:ArmControlParser.NameContext):
pass
# Exit a parse tree produced by ArmControlParser#name.
def exitName(self, ctx:ArmControlParser.NameContext):
pass
# Enter a parse tree produced by ArmControlParser#value.
def enterValue(self, ctx:ArmControlParser.ValueContext):
pass
# Exit a parse tree produced by ArmControlParser#value.
def exitValue(self, ctx:ArmControlParser.ValueContext):
pass
# Enter a parse tree produced by ArmControlParser#number.
def enterNumber(self, ctx:ArmControlParser.NumberContext):
pass
# Exit a parse tree produced by ArmControlParser#number.
def exitNumber(self, ctx:ArmControlParser.NumberContext):
pass
# Enter a parse tree produced by ArmControlParser#hexidecimal.
def enterHexidecimal(self, ctx:ArmControlParser.HexidecimalContext):
pass
# Exit a parse tree produced by ArmControlParser#hexidecimal.
def exitHexidecimal(self, ctx:ArmControlParser.HexidecimalContext):
pass
# Enter a parse tree produced by ArmControlParser#seperator.
def enterSeperator(self, ctx:ArmControlParser.SeperatorContext):
pass
# Exit a parse tree produced by ArmControlParser#seperator.
def exitSeperator(self, ctx:ArmControlParser.SeperatorContext):
pass

711
ArmControlParser.py Normal file
View File

@ -0,0 +1,711 @@
# 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\20")
buf.write("W\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\3\4\3\4\5\4\61\n\4\3\4")
buf.write("\3\4\3\4\3\4\5\4\67\n\4\3\4\5\4:\n\4\3\5\3\5\5\5>\n\5")
buf.write("\3\5\3\5\5\5B\n\5\7\5D\n\5\f\5\16\5G\13\5\3\5\3\5\3\6")
buf.write("\3\6\3\7\3\7\5\7O\n\7\3\b\3\b\3\t\3\t\3\n\3\n\3\n\2\2")
buf.write("\13\2\4\6\b\n\f\16\20\22\2\2\2[\2\27\3\2\2\2\4(\3\2\2")
buf.write("\2\69\3\2\2\2\b;\3\2\2\2\nJ\3\2\2\2\fN\3\2\2\2\16P\3\2")
buf.write("\2\2\20R\3\2\2\2\22T\3\2\2\2\24\26\5\4\3\2\25\24\3\2\2")
buf.write("\2\26\31\3\2\2\2\27\25\3\2\2\2\27\30\3\2\2\2\30\32\3\2")
buf.write("\2\2\31\27\3\2\2\2\32\33\7\2\2\3\33\3\3\2\2\2\34!\5\6")
buf.write("\4\2\35\36\7\3\2\2\36 \5\6\4\2\37\35\3\2\2\2 #\3\2\2\2")
buf.write("!\37\3\2\2\2!\"\3\2\2\2\"%\3\2\2\2#!\3\2\2\2$&\7\16\2")
buf.write("\2%$\3\2\2\2%&\3\2\2\2&)\3\2\2\2\')\7\16\2\2(\34\3\2\2")
buf.write("\2(\'\3\2\2\2)\5\3\2\2\2*\60\7\4\2\2+\61\5\b\5\2,-\5\n")
buf.write("\6\2-.\5\f\7\2.\61\3\2\2\2/\61\5\n\6\2\60+\3\2\2\2\60")
buf.write(",\3\2\2\2\60/\3\2\2\2\61:\3\2\2\2\62\63\7\5\2\2\63:\5")
buf.write("\16\b\2\64\66\7\6\2\2\65\67\5\16\b\2\66\65\3\2\2\2\66")
buf.write("\67\3\2\2\2\67:\3\2\2\28:\7\7\2\29*\3\2\2\29\62\3\2\2")
buf.write("\29\64\3\2\2\298\3\2\2\2:\7\3\2\2\2;=\7\b\2\2<>\5\f\7")
buf.write("\2=<\3\2\2\2=>\3\2\2\2>E\3\2\2\2?A\5\22\n\2@B\5\f\7\2")
buf.write("A@\3\2\2\2AB\3\2\2\2BD\3\2\2\2C?\3\2\2\2DG\3\2\2\2EC\3")
buf.write("\2\2\2EF\3\2\2\2FH\3\2\2\2GE\3\2\2\2HI\7\t\2\2I\t\3\2")
buf.write("\2\2JK\7\n\2\2K\13\3\2\2\2LO\5\16\b\2MO\5\20\t\2NL\3\2")
buf.write("\2\2NM\3\2\2\2O\r\3\2\2\2PQ\7\13\2\2Q\17\3\2\2\2RS\7\f")
buf.write("\2\2S\21\3\2\2\2TU\7\r\2\2U\23\3\2\2\2\r\27!%(\60\669")
buf.write("=AEN")
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>", "';'", "'GO'", "'PAUSE'", "'WAIT'", "'PASS'",
"'{'", "'}'", "<INVALID>", "<INVALID>", "<INVALID>",
"','" ]
symbolicNames = [ "<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
NAME=8
NUMBER=9
HEX=10
SEPERATOR=11
NEWLINE=12
WS=13
COMMENT=14
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.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]:
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 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 = 55
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [ArmControlParser.T__1]:
localctx = ArmControlParser.GoContext(self, localctx)
self.enterOuterAlt(localctx, 1)
self.state = 40
self.match(ArmControlParser.T__1)
self.state = 46
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
if la_ == 1:
self.state = 41
self.coords()
pass
elif la_ == 2:
self.state = 42
self.name()
self.state = 43
self.value()
pass
elif la_ == 3:
self.state = 45
self.name()
pass
pass
elif token in [ArmControlParser.T__2]:
localctx = ArmControlParser.PauseContext(self, localctx)
self.enterOuterAlt(localctx, 2)
self.state = 48
self.match(ArmControlParser.T__2)
self.state = 49
self.number()
pass
elif token in [ArmControlParser.T__3]:
localctx = ArmControlParser.WaitContext(self, localctx)
self.enterOuterAlt(localctx, 3)
self.state = 50
self.match(ArmControlParser.T__3)
self.state = 52
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==ArmControlParser.NUMBER:
self.state = 51
self.number()
pass
elif token in [ArmControlParser.T__4]:
localctx = ArmControlParser.PassContext(self, localctx)
self.enterOuterAlt(localctx, 4)
self.state = 54
self.match(ArmControlParser.T__4)
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 = 57
self.match(ArmControlParser.T__5)
self.state = 59
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==ArmControlParser.NUMBER or _la==ArmControlParser.HEX:
self.state = 58
self.value()
self.state = 67
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==ArmControlParser.SEPERATOR:
self.state = 61
self.seperator()
self.state = 63
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==ArmControlParser.NUMBER or _la==ArmControlParser.HEX:
self.state = 62
self.value()
self.state = 69
self._errHandler.sync(self)
_la = self._input.LA(1)
self.state = 70
self.match(ArmControlParser.T__6)
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 = 72
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 = 76
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [ArmControlParser.NUMBER]:
self.enterOuterAlt(localctx, 1)
self.state = 74
self.number()
pass
elif token in [ArmControlParser.HEX]:
self.enterOuterAlt(localctx, 2)
self.state = 75
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 = 78
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 = 80
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 = 82
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