# Generated from gn.g4 by ANTLR 4.7.1
|
# encoding: utf-8
|
from __future__ import print_function
|
from antlr4 import *
|
from io import StringIO
|
import sys
|
|
def serializedATN():
|
with StringIO() as buf:
|
buf.write(u"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3")
|
buf.write(u"\24\u008e\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
|
buf.write(u"\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t")
|
buf.write(u"\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\3\2\3\2\3")
|
buf.write(u"\2\3\3\3\3\3\3\5\3)\n\3\3\4\3\4\3\4\5\4.\n\4\3\5\3\5")
|
buf.write(u"\3\5\3\5\3\6\3\6\3\6\5\6\67\n\6\3\6\3\6\5\6;\n\6\3\7")
|
buf.write(u"\3\7\3\7\3\7\3\7\3\7\3\7\3\7\5\7E\n\7\5\7G\n\7\3\b\3")
|
buf.write(u"\b\3\b\3\b\3\t\3\t\7\tO\n\t\f\t\16\tR\13\t\3\n\3\n\3")
|
buf.write(u"\n\3\n\3\n\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3")
|
buf.write(u"\f\7\fc\n\f\f\f\16\ff\13\f\3\r\3\r\3\r\5\rk\n\r\3\16")
|
buf.write(u"\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3")
|
buf.write(u"\16\3\16\3\16\5\16{\n\16\5\16}\n\16\3\16\5\16\u0080\n")
|
buf.write(u"\16\3\17\3\17\3\17\7\17\u0085\n\17\f\17\16\17\u0088\13")
|
buf.write(u"\17\3\20\3\20\3\21\3\21\3\21\2\3\26\22\2\4\6\b\n\f\16")
|
buf.write(u"\20\22\24\26\30\32\34\36 \2\2\2\u0094\2\"\3\2\2\2\4(")
|
buf.write(u"\3\2\2\2\6-\3\2\2\2\b/\3\2\2\2\n\63\3\2\2\2\f<\3\2\2")
|
buf.write(u"\2\16H\3\2\2\2\20P\3\2\2\2\22S\3\2\2\2\24X\3\2\2\2\26")
|
buf.write(u"\\\3\2\2\2\30j\3\2\2\2\32\177\3\2\2\2\34\u0081\3\2\2")
|
buf.write(u"\2\36\u0089\3\2\2\2 \u008b\3\2\2\2\"#\5\20\t\2#$\7\2")
|
buf.write(u"\2\3$\3\3\2\2\2%)\5\b\5\2&)\5\n\6\2\')\5\f\7\2(%\3\2")
|
buf.write(u"\2\2(&\3\2\2\2(\'\3\2\2\2)\5\3\2\2\2*.\7\20\2\2+.\5\22")
|
buf.write(u"\n\2,.\5\24\13\2-*\3\2\2\2-+\3\2\2\2-,\3\2\2\2.\7\3\2")
|
buf.write(u"\2\2/\60\5\6\4\2\60\61\7\r\2\2\61\62\5\26\f\2\62\t\3")
|
buf.write(u"\2\2\2\63\64\7\20\2\2\64\66\7\3\2\2\65\67\5\34\17\2\66")
|
buf.write(u"\65\3\2\2\2\66\67\3\2\2\2\678\3\2\2\28:\7\4\2\29;\5\16")
|
buf.write(u"\b\2:9\3\2\2\2:;\3\2\2\2;\13\3\2\2\2<=\7\5\2\2=>\7\3")
|
buf.write(u"\2\2>?\5\26\f\2?@\7\4\2\2@F\5\16\b\2AD\5\36\20\2BE\5")
|
buf.write(u"\f\7\2CE\5\16\b\2DB\3\2\2\2DC\3\2\2\2EG\3\2\2\2FA\3\2")
|
buf.write(u"\2\2FG\3\2\2\2G\r\3\2\2\2HI\7\6\2\2IJ\5\20\t\2JK\7\7")
|
buf.write(u"\2\2K\17\3\2\2\2LO\5\4\3\2MO\5 \21\2NL\3\2\2\2NM\3\2")
|
buf.write(u"\2\2OR\3\2\2\2PN\3\2\2\2PQ\3\2\2\2Q\21\3\2\2\2RP\3\2")
|
buf.write(u"\2\2ST\7\20\2\2TU\7\b\2\2UV\5\26\f\2VW\7\t\2\2W\23\3")
|
buf.write(u"\2\2\2XY\7\20\2\2YZ\7\n\2\2Z[\7\20\2\2[\25\3\2\2\2\\")
|
buf.write(u"]\b\f\1\2]^\5\30\r\2^d\3\2\2\2_`\f\3\2\2`a\7\17\2\2a")
|
buf.write(u"c\5\26\f\4b_\3\2\2\2cf\3\2\2\2db\3\2\2\2de\3\2\2\2e\27")
|
buf.write(u"\3\2\2\2fd\3\2\2\2gk\5\32\16\2hi\7\16\2\2ik\5\30\r\2")
|
buf.write(u"jg\3\2\2\2jh\3\2\2\2k\31\3\2\2\2l\u0080\7\20\2\2m\u0080")
|
buf.write(u"\7\21\2\2n\u0080\7\22\2\2o\u0080\5\n\6\2p\u0080\5\22")
|
buf.write(u"\n\2q\u0080\5\24\13\2r\u0080\5\16\b\2st\7\3\2\2tu\5\26")
|
buf.write(u"\f\2uv\7\4\2\2v\u0080\3\2\2\2w|\7\b\2\2xz\5\34\17\2y")
|
buf.write(u"{\7\13\2\2zy\3\2\2\2z{\3\2\2\2{}\3\2\2\2|x\3\2\2\2|}")
|
buf.write(u"\3\2\2\2}~\3\2\2\2~\u0080\7\t\2\2\177l\3\2\2\2\177m\3")
|
buf.write(u"\2\2\2\177n\3\2\2\2\177o\3\2\2\2\177p\3\2\2\2\177q\3")
|
buf.write(u"\2\2\2\177r\3\2\2\2\177s\3\2\2\2\177w\3\2\2\2\u0080\33")
|
buf.write(u"\3\2\2\2\u0081\u0086\5\26\f\2\u0082\u0083\7\13\2\2\u0083")
|
buf.write(u"\u0085\5\26\f\2\u0084\u0082\3\2\2\2\u0085\u0088\3\2\2")
|
buf.write(u"\2\u0086\u0084\3\2\2\2\u0086\u0087\3\2\2\2\u0087\35\3")
|
buf.write(u"\2\2\2\u0088\u0086\3\2\2\2\u0089\u008a\7\f\2\2\u008a")
|
buf.write(u"\37\3\2\2\2\u008b\u008c\7\23\2\2\u008c!\3\2\2\2\20(-")
|
buf.write(u"\66:DFNPdjz|\177\u0086")
|
return buf.getvalue()
|
|
|
class gnParser ( Parser ):
|
|
grammarFileName = "gn.g4"
|
|
atn = ATNDeserializer().deserialize(serializedATN())
|
|
decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
|
|
sharedContextCache = PredictionContextCache()
|
|
literalNames = [ u"<INVALID>", u"'('", u"')'", u"'if'", u"'{'", u"'}'",
|
u"'['", u"']'", u"'.'", u"','", u"'else'", u"<INVALID>",
|
u"'!'" ]
|
|
symbolicNames = [ u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>",
|
u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>",
|
u"<INVALID>", u"<INVALID>", u"<INVALID>", u"AssignOp",
|
u"UnaryOp", u"BinaryOp", u"Identifier", u"Integer",
|
u"String", u"COMMENT", u"WS" ]
|
|
RULE_r = 0
|
RULE_statement = 1
|
RULE_lvalue = 2
|
RULE_assignment = 3
|
RULE_call = 4
|
RULE_condition = 5
|
RULE_block = 6
|
RULE_statementlist = 7
|
RULE_arrayaccess = 8
|
RULE_scopeaccess = 9
|
RULE_expr = 10
|
RULE_unaryexpr = 11
|
RULE_primaryexpr = 12
|
RULE_exprlist = 13
|
RULE_elsec = 14
|
RULE_comment = 15
|
|
ruleNames = [ u"r", u"statement", u"lvalue", u"assignment", u"call",
|
u"condition", u"block", u"statementlist", u"arrayaccess",
|
u"scopeaccess", u"expr", u"unaryexpr", u"primaryexpr",
|
u"exprlist", u"elsec", u"comment" ]
|
|
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
|
AssignOp=11
|
UnaryOp=12
|
BinaryOp=13
|
Identifier=14
|
Integer=15
|
String=16
|
COMMENT=17
|
WS=18
|
|
def __init__(self, input, output=sys.stdout):
|
super(gnParser, self).__init__(input, output=output)
|
self.checkVersion("4.7.1")
|
self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
|
self._predicates = None
|
|
|
|
class RContext(ParserRuleContext):
|
|
def __init__(self, parser, parent=None, invokingState=-1):
|
super(gnParser.RContext, self).__init__(parent, invokingState)
|
self.parser = parser
|
|
def statementlist(self):
|
return self.getTypedRuleContext(gnParser.StatementlistContext,0)
|
|
|
def EOF(self):
|
return self.getToken(gnParser.EOF, 0)
|
|
def getRuleIndex(self):
|
return gnParser.RULE_r
|
|
def enterRule(self, listener):
|
if hasattr(listener, "enterR"):
|
listener.enterR(self)
|
|
def exitRule(self, listener):
|
if hasattr(listener, "exitR"):
|
listener.exitR(self)
|
|
|
|
|
def r(self):
|
|
localctx = gnParser.RContext(self, self._ctx, self.state)
|
self.enterRule(localctx, 0, self.RULE_r)
|
try:
|
self.enterOuterAlt(localctx, 1)
|
self.state = 32
|
self.statementlist()
|
self.state = 33
|
self.match(gnParser.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=None, invokingState=-1):
|
super(gnParser.StatementContext, self).__init__(parent, invokingState)
|
self.parser = parser
|
|
def assignment(self):
|
return self.getTypedRuleContext(gnParser.AssignmentContext,0)
|
|
|
def call(self):
|
return self.getTypedRuleContext(gnParser.CallContext,0)
|
|
|
def condition(self):
|
return self.getTypedRuleContext(gnParser.ConditionContext,0)
|
|
|
def getRuleIndex(self):
|
return gnParser.RULE_statement
|
|
def enterRule(self, listener):
|
if hasattr(listener, "enterStatement"):
|
listener.enterStatement(self)
|
|
def exitRule(self, listener):
|
if hasattr(listener, "exitStatement"):
|
listener.exitStatement(self)
|
|
|
|
|
def statement(self):
|
|
localctx = gnParser.StatementContext(self, self._ctx, self.state)
|
self.enterRule(localctx, 2, self.RULE_statement)
|
try:
|
self.state = 38
|
self._errHandler.sync(self)
|
la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
|
if la_ == 1:
|
self.enterOuterAlt(localctx, 1)
|
self.state = 35
|
self.assignment()
|
pass
|
|
elif la_ == 2:
|
self.enterOuterAlt(localctx, 2)
|
self.state = 36
|
self.call()
|
pass
|
|
elif la_ == 3:
|
self.enterOuterAlt(localctx, 3)
|
self.state = 37
|
self.condition()
|
pass
|
|
|
except RecognitionException as re:
|
localctx.exception = re
|
self._errHandler.reportError(self, re)
|
self._errHandler.recover(self, re)
|
finally:
|
self.exitRule()
|
return localctx
|
|
class LvalueContext(ParserRuleContext):
|
|
def __init__(self, parser, parent=None, invokingState=-1):
|
super(gnParser.LvalueContext, self).__init__(parent, invokingState)
|
self.parser = parser
|
|
def Identifier(self):
|
return self.getToken(gnParser.Identifier, 0)
|
|
def arrayaccess(self):
|
return self.getTypedRuleContext(gnParser.ArrayaccessContext,0)
|
|
|
def scopeaccess(self):
|
return self.getTypedRuleContext(gnParser.ScopeaccessContext,0)
|
|
|
def getRuleIndex(self):
|
return gnParser.RULE_lvalue
|
|
def enterRule(self, listener):
|
if hasattr(listener, "enterLvalue"):
|
listener.enterLvalue(self)
|
|
def exitRule(self, listener):
|
if hasattr(listener, "exitLvalue"):
|
listener.exitLvalue(self)
|
|
|
|
|
def lvalue(self):
|
|
localctx = gnParser.LvalueContext(self, self._ctx, self.state)
|
self.enterRule(localctx, 4, self.RULE_lvalue)
|
try:
|
self.state = 43
|
self._errHandler.sync(self)
|
la_ = self._interp.adaptivePredict(self._input,1,self._ctx)
|
if la_ == 1:
|
self.enterOuterAlt(localctx, 1)
|
self.state = 40
|
self.match(gnParser.Identifier)
|
pass
|
|
elif la_ == 2:
|
self.enterOuterAlt(localctx, 2)
|
self.state = 41
|
self.arrayaccess()
|
pass
|
|
elif la_ == 3:
|
self.enterOuterAlt(localctx, 3)
|
self.state = 42
|
self.scopeaccess()
|
pass
|
|
|
except RecognitionException as re:
|
localctx.exception = re
|
self._errHandler.reportError(self, re)
|
self._errHandler.recover(self, re)
|
finally:
|
self.exitRule()
|
return localctx
|
|
class AssignmentContext(ParserRuleContext):
|
|
def __init__(self, parser, parent=None, invokingState=-1):
|
super(gnParser.AssignmentContext, self).__init__(parent, invokingState)
|
self.parser = parser
|
|
def lvalue(self):
|
return self.getTypedRuleContext(gnParser.LvalueContext,0)
|
|
|
def AssignOp(self):
|
return self.getToken(gnParser.AssignOp, 0)
|
|
def expr(self):
|
return self.getTypedRuleContext(gnParser.ExprContext,0)
|
|
|
def getRuleIndex(self):
|
return gnParser.RULE_assignment
|
|
def enterRule(self, listener):
|
if hasattr(listener, "enterAssignment"):
|
listener.enterAssignment(self)
|
|
def exitRule(self, listener):
|
if hasattr(listener, "exitAssignment"):
|
listener.exitAssignment(self)
|
|
|
|
|
def assignment(self):
|
|
localctx = gnParser.AssignmentContext(self, self._ctx, self.state)
|
self.enterRule(localctx, 6, self.RULE_assignment)
|
try:
|
self.enterOuterAlt(localctx, 1)
|
self.state = 45
|
self.lvalue()
|
self.state = 46
|
self.match(gnParser.AssignOp)
|
self.state = 47
|
self.expr(0)
|
except RecognitionException as re:
|
localctx.exception = re
|
self._errHandler.reportError(self, re)
|
self._errHandler.recover(self, re)
|
finally:
|
self.exitRule()
|
return localctx
|
|
class CallContext(ParserRuleContext):
|
|
def __init__(self, parser, parent=None, invokingState=-1):
|
super(gnParser.CallContext, self).__init__(parent, invokingState)
|
self.parser = parser
|
|
def Identifier(self):
|
return self.getToken(gnParser.Identifier, 0)
|
|
def exprlist(self):
|
return self.getTypedRuleContext(gnParser.ExprlistContext,0)
|
|
|
def block(self):
|
return self.getTypedRuleContext(gnParser.BlockContext,0)
|
|
|
def getRuleIndex(self):
|
return gnParser.RULE_call
|
|
def enterRule(self, listener):
|
if hasattr(listener, "enterCall"):
|
listener.enterCall(self)
|
|
def exitRule(self, listener):
|
if hasattr(listener, "exitCall"):
|
listener.exitCall(self)
|
|
|
|
|
def call(self):
|
|
localctx = gnParser.CallContext(self, self._ctx, self.state)
|
self.enterRule(localctx, 8, self.RULE_call)
|
self._la = 0 # Token type
|
try:
|
self.enterOuterAlt(localctx, 1)
|
self.state = 49
|
self.match(gnParser.Identifier)
|
self.state = 50
|
self.match(gnParser.T__0)
|
self.state = 52
|
self._errHandler.sync(self)
|
_la = self._input.LA(1)
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << gnParser.T__0) | (1 << gnParser.T__3) | (1 << gnParser.T__5) | (1 << gnParser.UnaryOp) | (1 << gnParser.Identifier) | (1 << gnParser.Integer) | (1 << gnParser.String))) != 0):
|
self.state = 51
|
self.exprlist()
|
|
|
self.state = 54
|
self.match(gnParser.T__1)
|
self.state = 56
|
self._errHandler.sync(self)
|
la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
|
if la_ == 1:
|
self.state = 55
|
self.block()
|
|
|
except RecognitionException as re:
|
localctx.exception = re
|
self._errHandler.reportError(self, re)
|
self._errHandler.recover(self, re)
|
finally:
|
self.exitRule()
|
return localctx
|
|
class ConditionContext(ParserRuleContext):
|
|
def __init__(self, parser, parent=None, invokingState=-1):
|
super(gnParser.ConditionContext, self).__init__(parent, invokingState)
|
self.parser = parser
|
|
def expr(self):
|
return self.getTypedRuleContext(gnParser.ExprContext,0)
|
|
|
def block(self, i=None):
|
if i is None:
|
return self.getTypedRuleContexts(gnParser.BlockContext)
|
else:
|
return self.getTypedRuleContext(gnParser.BlockContext,i)
|
|
|
def elsec(self):
|
return self.getTypedRuleContext(gnParser.ElsecContext,0)
|
|
|
def condition(self):
|
return self.getTypedRuleContext(gnParser.ConditionContext,0)
|
|
|
def getRuleIndex(self):
|
return gnParser.RULE_condition
|
|
def enterRule(self, listener):
|
if hasattr(listener, "enterCondition"):
|
listener.enterCondition(self)
|
|
def exitRule(self, listener):
|
if hasattr(listener, "exitCondition"):
|
listener.exitCondition(self)
|
|
|
|
|
def condition(self):
|
|
localctx = gnParser.ConditionContext(self, self._ctx, self.state)
|
self.enterRule(localctx, 10, self.RULE_condition)
|
self._la = 0 # Token type
|
try:
|
self.enterOuterAlt(localctx, 1)
|
self.state = 58
|
self.match(gnParser.T__2)
|
self.state = 59
|
self.match(gnParser.T__0)
|
self.state = 60
|
self.expr(0)
|
self.state = 61
|
self.match(gnParser.T__1)
|
self.state = 62
|
self.block()
|
self.state = 68
|
self._errHandler.sync(self)
|
_la = self._input.LA(1)
|
if _la==gnParser.T__9:
|
self.state = 63
|
self.elsec()
|
self.state = 66
|
self._errHandler.sync(self)
|
token = self._input.LA(1)
|
if token in [gnParser.T__2]:
|
self.state = 64
|
self.condition()
|
pass
|
elif token in [gnParser.T__3]:
|
self.state = 65
|
self.block()
|
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 BlockContext(ParserRuleContext):
|
|
def __init__(self, parser, parent=None, invokingState=-1):
|
super(gnParser.BlockContext, self).__init__(parent, invokingState)
|
self.parser = parser
|
|
def statementlist(self):
|
return self.getTypedRuleContext(gnParser.StatementlistContext,0)
|
|
|
def getRuleIndex(self):
|
return gnParser.RULE_block
|
|
def enterRule(self, listener):
|
if hasattr(listener, "enterBlock"):
|
listener.enterBlock(self)
|
|
def exitRule(self, listener):
|
if hasattr(listener, "exitBlock"):
|
listener.exitBlock(self)
|
|
|
|
|
def block(self):
|
|
localctx = gnParser.BlockContext(self, self._ctx, self.state)
|
self.enterRule(localctx, 12, self.RULE_block)
|
try:
|
self.enterOuterAlt(localctx, 1)
|
self.state = 70
|
self.match(gnParser.T__3)
|
self.state = 71
|
self.statementlist()
|
self.state = 72
|
self.match(gnParser.T__4)
|
except RecognitionException as re:
|
localctx.exception = re
|
self._errHandler.reportError(self, re)
|
self._errHandler.recover(self, re)
|
finally:
|
self.exitRule()
|
return localctx
|
|
class StatementlistContext(ParserRuleContext):
|
|
def __init__(self, parser, parent=None, invokingState=-1):
|
super(gnParser.StatementlistContext, self).__init__(parent, invokingState)
|
self.parser = parser
|
|
def statement(self, i=None):
|
if i is None:
|
return self.getTypedRuleContexts(gnParser.StatementContext)
|
else:
|
return self.getTypedRuleContext(gnParser.StatementContext,i)
|
|
|
def comment(self, i=None):
|
if i is None:
|
return self.getTypedRuleContexts(gnParser.CommentContext)
|
else:
|
return self.getTypedRuleContext(gnParser.CommentContext,i)
|
|
|
def getRuleIndex(self):
|
return gnParser.RULE_statementlist
|
|
def enterRule(self, listener):
|
if hasattr(listener, "enterStatementlist"):
|
listener.enterStatementlist(self)
|
|
def exitRule(self, listener):
|
if hasattr(listener, "exitStatementlist"):
|
listener.exitStatementlist(self)
|
|
|
|
|
def statementlist(self):
|
|
localctx = gnParser.StatementlistContext(self, self._ctx, self.state)
|
self.enterRule(localctx, 14, self.RULE_statementlist)
|
self._la = 0 # Token type
|
try:
|
self.enterOuterAlt(localctx, 1)
|
self.state = 78
|
self._errHandler.sync(self)
|
_la = self._input.LA(1)
|
while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << gnParser.T__2) | (1 << gnParser.Identifier) | (1 << gnParser.COMMENT))) != 0):
|
self.state = 76
|
self._errHandler.sync(self)
|
token = self._input.LA(1)
|
if token in [gnParser.T__2, gnParser.Identifier]:
|
self.state = 74
|
self.statement()
|
pass
|
elif token in [gnParser.COMMENT]:
|
self.state = 75
|
self.comment()
|
pass
|
else:
|
raise NoViableAltException(self)
|
|
self.state = 80
|
self._errHandler.sync(self)
|
_la = self._input.LA(1)
|
|
except RecognitionException as re:
|
localctx.exception = re
|
self._errHandler.reportError(self, re)
|
self._errHandler.recover(self, re)
|
finally:
|
self.exitRule()
|
return localctx
|
|
class ArrayaccessContext(ParserRuleContext):
|
|
def __init__(self, parser, parent=None, invokingState=-1):
|
super(gnParser.ArrayaccessContext, self).__init__(parent, invokingState)
|
self.parser = parser
|
|
def Identifier(self):
|
return self.getToken(gnParser.Identifier, 0)
|
|
def expr(self):
|
return self.getTypedRuleContext(gnParser.ExprContext,0)
|
|
|
def getRuleIndex(self):
|
return gnParser.RULE_arrayaccess
|
|
def enterRule(self, listener):
|
if hasattr(listener, "enterArrayaccess"):
|
listener.enterArrayaccess(self)
|
|
def exitRule(self, listener):
|
if hasattr(listener, "exitArrayaccess"):
|
listener.exitArrayaccess(self)
|
|
|
|
|
def arrayaccess(self):
|
|
localctx = gnParser.ArrayaccessContext(self, self._ctx, self.state)
|
self.enterRule(localctx, 16, self.RULE_arrayaccess)
|
try:
|
self.enterOuterAlt(localctx, 1)
|
self.state = 81
|
self.match(gnParser.Identifier)
|
self.state = 82
|
self.match(gnParser.T__5)
|
self.state = 83
|
self.expr(0)
|
self.state = 84
|
self.match(gnParser.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 ScopeaccessContext(ParserRuleContext):
|
|
def __init__(self, parser, parent=None, invokingState=-1):
|
super(gnParser.ScopeaccessContext, self).__init__(parent, invokingState)
|
self.parser = parser
|
|
def Identifier(self, i=None):
|
if i is None:
|
return self.getTokens(gnParser.Identifier)
|
else:
|
return self.getToken(gnParser.Identifier, i)
|
|
def getRuleIndex(self):
|
return gnParser.RULE_scopeaccess
|
|
def enterRule(self, listener):
|
if hasattr(listener, "enterScopeaccess"):
|
listener.enterScopeaccess(self)
|
|
def exitRule(self, listener):
|
if hasattr(listener, "exitScopeaccess"):
|
listener.exitScopeaccess(self)
|
|
|
|
|
def scopeaccess(self):
|
|
localctx = gnParser.ScopeaccessContext(self, self._ctx, self.state)
|
self.enterRule(localctx, 18, self.RULE_scopeaccess)
|
try:
|
self.enterOuterAlt(localctx, 1)
|
self.state = 86
|
self.match(gnParser.Identifier)
|
self.state = 87
|
self.match(gnParser.T__7)
|
self.state = 88
|
self.match(gnParser.Identifier)
|
except RecognitionException as re:
|
localctx.exception = re
|
self._errHandler.reportError(self, re)
|
self._errHandler.recover(self, re)
|
finally:
|
self.exitRule()
|
return localctx
|
|
class ExprContext(ParserRuleContext):
|
|
def __init__(self, parser, parent=None, invokingState=-1):
|
super(gnParser.ExprContext, self).__init__(parent, invokingState)
|
self.parser = parser
|
|
def unaryexpr(self):
|
return self.getTypedRuleContext(gnParser.UnaryexprContext,0)
|
|
|
def expr(self, i=None):
|
if i is None:
|
return self.getTypedRuleContexts(gnParser.ExprContext)
|
else:
|
return self.getTypedRuleContext(gnParser.ExprContext,i)
|
|
|
def BinaryOp(self):
|
return self.getToken(gnParser.BinaryOp, 0)
|
|
def getRuleIndex(self):
|
return gnParser.RULE_expr
|
|
def enterRule(self, listener):
|
if hasattr(listener, "enterExpr"):
|
listener.enterExpr(self)
|
|
def exitRule(self, listener):
|
if hasattr(listener, "exitExpr"):
|
listener.exitExpr(self)
|
|
|
|
def expr(self, _p=0):
|
_parentctx = self._ctx
|
_parentState = self.state
|
localctx = gnParser.ExprContext(self, self._ctx, _parentState)
|
_prevctx = localctx
|
_startState = 20
|
self.enterRecursionRule(localctx, 20, self.RULE_expr, _p)
|
try:
|
self.enterOuterAlt(localctx, 1)
|
self.state = 91
|
self.unaryexpr()
|
self._ctx.stop = self._input.LT(-1)
|
self.state = 98
|
self._errHandler.sync(self)
|
_alt = self._interp.adaptivePredict(self._input,8,self._ctx)
|
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
|
if _alt==1:
|
if self._parseListeners is not None:
|
self.triggerExitRuleEvent()
|
_prevctx = localctx
|
localctx = gnParser.ExprContext(self, _parentctx, _parentState)
|
self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
|
self.state = 93
|
if not self.precpred(self._ctx, 1):
|
from antlr4.error.Errors import FailedPredicateException
|
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
|
self.state = 94
|
self.match(gnParser.BinaryOp)
|
self.state = 95
|
self.expr(2)
|
self.state = 100
|
self._errHandler.sync(self)
|
_alt = self._interp.adaptivePredict(self._input,8,self._ctx)
|
|
except RecognitionException as re:
|
localctx.exception = re
|
self._errHandler.reportError(self, re)
|
self._errHandler.recover(self, re)
|
finally:
|
self.unrollRecursionContexts(_parentctx)
|
return localctx
|
|
class UnaryexprContext(ParserRuleContext):
|
|
def __init__(self, parser, parent=None, invokingState=-1):
|
super(gnParser.UnaryexprContext, self).__init__(parent, invokingState)
|
self.parser = parser
|
|
def primaryexpr(self):
|
return self.getTypedRuleContext(gnParser.PrimaryexprContext,0)
|
|
|
def UnaryOp(self):
|
return self.getToken(gnParser.UnaryOp, 0)
|
|
def unaryexpr(self):
|
return self.getTypedRuleContext(gnParser.UnaryexprContext,0)
|
|
|
def getRuleIndex(self):
|
return gnParser.RULE_unaryexpr
|
|
def enterRule(self, listener):
|
if hasattr(listener, "enterUnaryexpr"):
|
listener.enterUnaryexpr(self)
|
|
def exitRule(self, listener):
|
if hasattr(listener, "exitUnaryexpr"):
|
listener.exitUnaryexpr(self)
|
|
|
|
|
def unaryexpr(self):
|
|
localctx = gnParser.UnaryexprContext(self, self._ctx, self.state)
|
self.enterRule(localctx, 22, self.RULE_unaryexpr)
|
try:
|
self.state = 104
|
self._errHandler.sync(self)
|
token = self._input.LA(1)
|
if token in [gnParser.T__0, gnParser.T__3, gnParser.T__5, gnParser.Identifier, gnParser.Integer, gnParser.String]:
|
self.enterOuterAlt(localctx, 1)
|
self.state = 101
|
self.primaryexpr()
|
pass
|
elif token in [gnParser.UnaryOp]:
|
self.enterOuterAlt(localctx, 2)
|
self.state = 102
|
self.match(gnParser.UnaryOp)
|
self.state = 103
|
self.unaryexpr()
|
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 PrimaryexprContext(ParserRuleContext):
|
|
def __init__(self, parser, parent=None, invokingState=-1):
|
super(gnParser.PrimaryexprContext, self).__init__(parent, invokingState)
|
self.parser = parser
|
|
def Identifier(self):
|
return self.getToken(gnParser.Identifier, 0)
|
|
def Integer(self):
|
return self.getToken(gnParser.Integer, 0)
|
|
def String(self):
|
return self.getToken(gnParser.String, 0)
|
|
def call(self):
|
return self.getTypedRuleContext(gnParser.CallContext,0)
|
|
|
def arrayaccess(self):
|
return self.getTypedRuleContext(gnParser.ArrayaccessContext,0)
|
|
|
def scopeaccess(self):
|
return self.getTypedRuleContext(gnParser.ScopeaccessContext,0)
|
|
|
def block(self):
|
return self.getTypedRuleContext(gnParser.BlockContext,0)
|
|
|
def expr(self):
|
return self.getTypedRuleContext(gnParser.ExprContext,0)
|
|
|
def exprlist(self):
|
return self.getTypedRuleContext(gnParser.ExprlistContext,0)
|
|
|
def getRuleIndex(self):
|
return gnParser.RULE_primaryexpr
|
|
def enterRule(self, listener):
|
if hasattr(listener, "enterPrimaryexpr"):
|
listener.enterPrimaryexpr(self)
|
|
def exitRule(self, listener):
|
if hasattr(listener, "exitPrimaryexpr"):
|
listener.exitPrimaryexpr(self)
|
|
|
|
|
def primaryexpr(self):
|
|
localctx = gnParser.PrimaryexprContext(self, self._ctx, self.state)
|
self.enterRule(localctx, 24, self.RULE_primaryexpr)
|
self._la = 0 # Token type
|
try:
|
self.state = 125
|
self._errHandler.sync(self)
|
la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
|
if la_ == 1:
|
self.enterOuterAlt(localctx, 1)
|
self.state = 106
|
self.match(gnParser.Identifier)
|
pass
|
|
elif la_ == 2:
|
self.enterOuterAlt(localctx, 2)
|
self.state = 107
|
self.match(gnParser.Integer)
|
pass
|
|
elif la_ == 3:
|
self.enterOuterAlt(localctx, 3)
|
self.state = 108
|
self.match(gnParser.String)
|
pass
|
|
elif la_ == 4:
|
self.enterOuterAlt(localctx, 4)
|
self.state = 109
|
self.call()
|
pass
|
|
elif la_ == 5:
|
self.enterOuterAlt(localctx, 5)
|
self.state = 110
|
self.arrayaccess()
|
pass
|
|
elif la_ == 6:
|
self.enterOuterAlt(localctx, 6)
|
self.state = 111
|
self.scopeaccess()
|
pass
|
|
elif la_ == 7:
|
self.enterOuterAlt(localctx, 7)
|
self.state = 112
|
self.block()
|
pass
|
|
elif la_ == 8:
|
self.enterOuterAlt(localctx, 8)
|
self.state = 113
|
self.match(gnParser.T__0)
|
self.state = 114
|
self.expr(0)
|
self.state = 115
|
self.match(gnParser.T__1)
|
pass
|
|
elif la_ == 9:
|
self.enterOuterAlt(localctx, 9)
|
self.state = 117
|
self.match(gnParser.T__5)
|
self.state = 122
|
self._errHandler.sync(self)
|
_la = self._input.LA(1)
|
if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << gnParser.T__0) | (1 << gnParser.T__3) | (1 << gnParser.T__5) | (1 << gnParser.UnaryOp) | (1 << gnParser.Identifier) | (1 << gnParser.Integer) | (1 << gnParser.String))) != 0):
|
self.state = 118
|
self.exprlist()
|
self.state = 120
|
self._errHandler.sync(self)
|
_la = self._input.LA(1)
|
if _la==gnParser.T__8:
|
self.state = 119
|
self.match(gnParser.T__8)
|
|
|
|
|
self.state = 124
|
self.match(gnParser.T__6)
|
pass
|
|
|
except RecognitionException as re:
|
localctx.exception = re
|
self._errHandler.reportError(self, re)
|
self._errHandler.recover(self, re)
|
finally:
|
self.exitRule()
|
return localctx
|
|
class ExprlistContext(ParserRuleContext):
|
|
def __init__(self, parser, parent=None, invokingState=-1):
|
super(gnParser.ExprlistContext, self).__init__(parent, invokingState)
|
self.parser = parser
|
|
def expr(self, i=None):
|
if i is None:
|
return self.getTypedRuleContexts(gnParser.ExprContext)
|
else:
|
return self.getTypedRuleContext(gnParser.ExprContext,i)
|
|
|
def getRuleIndex(self):
|
return gnParser.RULE_exprlist
|
|
def enterRule(self, listener):
|
if hasattr(listener, "enterExprlist"):
|
listener.enterExprlist(self)
|
|
def exitRule(self, listener):
|
if hasattr(listener, "exitExprlist"):
|
listener.exitExprlist(self)
|
|
|
|
|
def exprlist(self):
|
|
localctx = gnParser.ExprlistContext(self, self._ctx, self.state)
|
self.enterRule(localctx, 26, self.RULE_exprlist)
|
try:
|
self.enterOuterAlt(localctx, 1)
|
self.state = 127
|
self.expr(0)
|
self.state = 132
|
self._errHandler.sync(self)
|
_alt = self._interp.adaptivePredict(self._input,13,self._ctx)
|
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
|
if _alt==1:
|
self.state = 128
|
self.match(gnParser.T__8)
|
self.state = 129
|
self.expr(0)
|
self.state = 134
|
self._errHandler.sync(self)
|
_alt = self._interp.adaptivePredict(self._input,13,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 ElsecContext(ParserRuleContext):
|
|
def __init__(self, parser, parent=None, invokingState=-1):
|
super(gnParser.ElsecContext, self).__init__(parent, invokingState)
|
self.parser = parser
|
|
|
def getRuleIndex(self):
|
return gnParser.RULE_elsec
|
|
def enterRule(self, listener):
|
if hasattr(listener, "enterElsec"):
|
listener.enterElsec(self)
|
|
def exitRule(self, listener):
|
if hasattr(listener, "exitElsec"):
|
listener.exitElsec(self)
|
|
|
|
|
def elsec(self):
|
|
localctx = gnParser.ElsecContext(self, self._ctx, self.state)
|
self.enterRule(localctx, 28, self.RULE_elsec)
|
try:
|
self.enterOuterAlt(localctx, 1)
|
self.state = 135
|
self.match(gnParser.T__9)
|
except RecognitionException as re:
|
localctx.exception = re
|
self._errHandler.reportError(self, re)
|
self._errHandler.recover(self, re)
|
finally:
|
self.exitRule()
|
return localctx
|
|
class CommentContext(ParserRuleContext):
|
|
def __init__(self, parser, parent=None, invokingState=-1):
|
super(gnParser.CommentContext, self).__init__(parent, invokingState)
|
self.parser = parser
|
|
def COMMENT(self):
|
return self.getToken(gnParser.COMMENT, 0)
|
|
def getRuleIndex(self):
|
return gnParser.RULE_comment
|
|
def enterRule(self, listener):
|
if hasattr(listener, "enterComment"):
|
listener.enterComment(self)
|
|
def exitRule(self, listener):
|
if hasattr(listener, "exitComment"):
|
listener.exitComment(self)
|
|
|
|
|
def comment(self):
|
|
localctx = gnParser.CommentContext(self, self._ctx, self.state)
|
self.enterRule(localctx, 30, self.RULE_comment)
|
try:
|
self.enterOuterAlt(localctx, 1)
|
self.state = 137
|
self.match(gnParser.COMMENT)
|
except RecognitionException as re:
|
localctx.exception = re
|
self._errHandler.reportError(self, re)
|
self._errHandler.recover(self, re)
|
finally:
|
self.exitRule()
|
return localctx
|
|
|
|
def sempred(self, localctx, ruleIndex, predIndex):
|
if self._predicates == None:
|
self._predicates = dict()
|
self._predicates[10] = self.expr_sempred
|
pred = self._predicates.get(ruleIndex, None)
|
if pred is None:
|
raise Exception("No predicate with index:" + str(ruleIndex))
|
else:
|
return pred(localctx, predIndex)
|
|
def expr_sempred(self, localctx, predIndex):
|
if predIndex == 0:
|
return self.precpred(self._ctx, 1)
|
|
