Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.xlrit.gears.base.snel.SnelParser Maven / Gradle / Ivy
// Generated from com/xlrit/gears/base/snel/Snel.g4 by ANTLR 4.13.1
package com.xlrit.gears.base.snel;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"})
public class SnelParser extends Parser {
static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
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,
BooleanLiteral=32, IntegerLiteral=33, StringLiteral=34, Parameter=35,
Identifier=36, WS=37;
public static final int
RULE_startExportSpec = 0, RULE_exportItem = 1, RULE_rootPath = 2, RULE_subPaths = 3,
RULE_subPath = 4, RULE_attributePath = 5, RULE_relationPath = 6, RULE_asteriskPath = 7,
RULE_startSortClauses = 8, RULE_sortClauses = 9, RULE_sortClause = 10,
RULE_sortDirection = 11, RULE_startExpr = 12, RULE_expr = 13, RULE_filter = 14,
RULE_prefixOp = 15, RULE_postfixOp = 16, RULE_mulOp = 17, RULE_addOp = 18,
RULE_eqOp = 19, RULE_relOp = 20, RULE_memberOp = 21, RULE_andOp = 22,
RULE_orOp = 23, RULE_otherwiseOp = 24, RULE_listExpression = 25, RULE_optionalTrailingComma = 26,
RULE_functionExpression = 27, RULE_actualParams = 28, RULE_parameter = 29,
RULE_identifier = 30, RULE_literal = 31;
private static String[] makeRuleNames() {
return new String[] {
"startExportSpec", "exportItem", "rootPath", "subPaths", "subPath", "attributePath",
"relationPath", "asteriskPath", "startSortClauses", "sortClauses", "sortClause",
"sortDirection", "startExpr", "expr", "filter", "prefixOp", "postfixOp",
"mulOp", "addOp", "eqOp", "relOp", "memberOp", "andOp", "orOp", "otherwiseOp",
"listExpression", "optionalTrailingComma", "functionExpression", "actualParams",
"parameter", "identifier", "literal"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "':'", "'{'", "'}'", "','", "'*'", "'ascending'", "'descending'",
"'.'", "'('", "')'", "'['", "']'", "'-'", "'not'", "'exists'", "'does not exist'",
"'/'", "'%'", "'+'", "'=='", "'<>'", "'like'", "'<'", "'>'", "'<='",
"'>='", "'in'", "'contains'", "'and'", "'or'", "'otherwise'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, "BooleanLiteral", "IntegerLiteral",
"StringLiteral", "Parameter", "Identifier", "WS"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "Snel.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public SnelParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
@SuppressWarnings("CheckReturnValue")
public static class StartExportSpecContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(SnelParser.EOF, 0); }
public List exportItem() {
return getRuleContexts(ExportItemContext.class);
}
public ExportItemContext exportItem(int i) {
return getRuleContext(ExportItemContext.class,i);
}
public StartExportSpecContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_startExportSpec; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitStartExportSpec(this);
else return visitor.visitChildren(this);
}
}
public final StartExportSpecContext startExportSpec() throws RecognitionException {
StartExportSpecContext _localctx = new StartExportSpecContext(_ctx, getState());
enterRule(_localctx, 0, RULE_startExportSpec);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(65);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(64);
exportItem();
}
}
setState(67);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==Identifier );
setState(69);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExportItemContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public RootPathContext rootPath() {
return getRuleContext(RootPathContext.class,0);
}
public ExportItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exportItem; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitExportItem(this);
else return visitor.visitChildren(this);
}
}
public final ExportItemContext exportItem() throws RecognitionException {
ExportItemContext _localctx = new ExportItemContext(_ctx, getState());
enterRule(_localctx, 2, RULE_exportItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(71);
identifier();
setState(72);
match(T__0);
setState(73);
rootPath();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RootPathContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public SubPathsContext subPaths() {
return getRuleContext(SubPathsContext.class,0);
}
public FilterContext filter() {
return getRuleContext(FilterContext.class,0);
}
public RootPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rootPath; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitRootPath(this);
else return visitor.visitChildren(this);
}
}
public final RootPathContext rootPath() throws RecognitionException {
RootPathContext _localctx = new RootPathContext(_ctx, getState());
enterRule(_localctx, 4, RULE_rootPath);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(75);
identifier();
setState(77);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__10) {
{
setState(76);
filter();
}
}
setState(79);
match(T__1);
setState(80);
subPaths();
setState(81);
match(T__2);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SubPathsContext extends ParserRuleContext {
public List subPath() {
return getRuleContexts(SubPathContext.class);
}
public SubPathContext subPath(int i) {
return getRuleContext(SubPathContext.class,i);
}
public SubPathsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subPaths; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitSubPaths(this);
else return visitor.visitChildren(this);
}
}
public final SubPathsContext subPaths() throws RecognitionException {
SubPathsContext _localctx = new SubPathsContext(_ctx, getState());
enterRule(_localctx, 6, RULE_subPaths);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(89);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__4 || _la==Identifier) {
{
{
setState(83);
subPath();
setState(85);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__3) {
{
setState(84);
match(T__3);
}
}
}
}
setState(91);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SubPathContext extends ParserRuleContext {
public AttributePathContext attributePath() {
return getRuleContext(AttributePathContext.class,0);
}
public RelationPathContext relationPath() {
return getRuleContext(RelationPathContext.class,0);
}
public AsteriskPathContext asteriskPath() {
return getRuleContext(AsteriskPathContext.class,0);
}
public SubPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subPath; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitSubPath(this);
else return visitor.visitChildren(this);
}
}
public final SubPathContext subPath() throws RecognitionException {
SubPathContext _localctx = new SubPathContext(_ctx, getState());
enterRule(_localctx, 8, RULE_subPath);
try {
setState(95);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(92);
attributePath();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(93);
relationPath();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(94);
asteriskPath();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AttributePathContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public AttributePathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributePath; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitAttributePath(this);
else return visitor.visitChildren(this);
}
}
public final AttributePathContext attributePath() throws RecognitionException {
AttributePathContext _localctx = new AttributePathContext(_ctx, getState());
enterRule(_localctx, 10, RULE_attributePath);
try {
enterOuterAlt(_localctx, 1);
{
setState(97);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RelationPathContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public SubPathsContext subPaths() {
return getRuleContext(SubPathsContext.class,0);
}
public FilterContext filter() {
return getRuleContext(FilterContext.class,0);
}
public RelationPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relationPath; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitRelationPath(this);
else return visitor.visitChildren(this);
}
}
public final RelationPathContext relationPath() throws RecognitionException {
RelationPathContext _localctx = new RelationPathContext(_ctx, getState());
enterRule(_localctx, 12, RULE_relationPath);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(99);
identifier();
setState(101);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__10) {
{
setState(100);
filter();
}
}
setState(103);
match(T__1);
setState(104);
subPaths();
setState(105);
match(T__2);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AsteriskPathContext extends ParserRuleContext {
public AsteriskPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_asteriskPath; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitAsteriskPath(this);
else return visitor.visitChildren(this);
}
}
public final AsteriskPathContext asteriskPath() throws RecognitionException {
AsteriskPathContext _localctx = new AsteriskPathContext(_ctx, getState());
enterRule(_localctx, 14, RULE_asteriskPath);
try {
enterOuterAlt(_localctx, 1);
{
setState(107);
match(T__4);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StartSortClausesContext extends ParserRuleContext {
public SortClausesContext sortClauses() {
return getRuleContext(SortClausesContext.class,0);
}
public TerminalNode EOF() { return getToken(SnelParser.EOF, 0); }
public StartSortClausesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_startSortClauses; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitStartSortClauses(this);
else return visitor.visitChildren(this);
}
}
public final StartSortClausesContext startSortClauses() throws RecognitionException {
StartSortClausesContext _localctx = new StartSortClausesContext(_ctx, getState());
enterRule(_localctx, 16, RULE_startSortClauses);
try {
enterOuterAlt(_localctx, 1);
{
setState(109);
sortClauses();
setState(110);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SortClausesContext extends ParserRuleContext {
public List sortClause() {
return getRuleContexts(SortClauseContext.class);
}
public SortClauseContext sortClause(int i) {
return getRuleContext(SortClauseContext.class,i);
}
public SortClausesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sortClauses; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitSortClauses(this);
else return visitor.visitChildren(this);
}
}
public final SortClausesContext sortClauses() throws RecognitionException {
SortClausesContext _localctx = new SortClausesContext(_ctx, getState());
enterRule(_localctx, 18, RULE_sortClauses);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(112);
sortClause();
setState(117);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__3) {
{
{
setState(113);
match(T__3);
setState(114);
sortClause();
}
}
setState(119);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SortClauseContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public SortDirectionContext sortDirection() {
return getRuleContext(SortDirectionContext.class,0);
}
public SortClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sortClause; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitSortClause(this);
else return visitor.visitChildren(this);
}
}
public final SortClauseContext sortClause() throws RecognitionException {
SortClauseContext _localctx = new SortClauseContext(_ctx, getState());
enterRule(_localctx, 20, RULE_sortClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(120);
expr(0);
setState(122);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__5 || _la==T__6) {
{
setState(121);
sortDirection();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SortDirectionContext extends ParserRuleContext {
public SortDirectionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sortDirection; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitSortDirection(this);
else return visitor.visitChildren(this);
}
}
public final SortDirectionContext sortDirection() throws RecognitionException {
SortDirectionContext _localctx = new SortDirectionContext(_ctx, getState());
enterRule(_localctx, 22, RULE_sortDirection);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(124);
_la = _input.LA(1);
if ( !(_la==T__5 || _la==T__6) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StartExprContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode EOF() { return getToken(SnelParser.EOF, 0); }
public StartExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_startExpr; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitStartExpr(this);
else return visitor.visitChildren(this);
}
}
public final StartExprContext startExpr() throws RecognitionException {
StartExprContext _localctx = new StartExprContext(_ctx, getState());
enterRule(_localctx, 24, RULE_startExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(126);
expr(0);
setState(127);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExprContext extends ParserRuleContext {
public ExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr; }
public ExprContext() { }
public void copyFrom(ExprContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class FunExprContext extends ExprContext {
public FunctionExpressionContext functionExpression() {
return getRuleContext(FunctionExpressionContext.class,0);
}
public FunExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitFunExpr(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class MemberExprContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public MemberOpContext memberOp() {
return getRuleContext(MemberOpContext.class,0);
}
public MemberExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitMemberExpr(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class OrExprContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public OrOpContext orOp() {
return getRuleContext(OrOpContext.class,0);
}
public OrExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitOrExpr(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class FilterExprContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public FilterContext filter() {
return getRuleContext(FilterContext.class,0);
}
public FilterExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitFilterExpr(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ParenExprContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public ParenExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitParenExpr(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class IdentExprContext extends ExprContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public IdentExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitIdentExpr(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PrefixExprContext extends ExprContext {
public PrefixOpContext prefixOp() {
return getRuleContext(PrefixOpContext.class,0);
}
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public PrefixExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitPrefixExpr(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ParamExprContext extends ExprContext {
public ParameterContext parameter() {
return getRuleContext(ParameterContext.class,0);
}
public ParamExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitParamExpr(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class EqExprContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public EqOpContext eqOp() {
return getRuleContext(EqOpContext.class,0);
}
public EqExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitEqExpr(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AddExprContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public AddOpContext addOp() {
return getRuleContext(AddOpContext.class,0);
}
public AddExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitAddExpr(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class LiteralExprContext extends ExprContext {
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public LiteralExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitLiteralExpr(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class MulExprContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public MulOpContext mulOp() {
return getRuleContext(MulOpContext.class,0);
}
public MulExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitMulExpr(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AttrExprContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public AttrExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitAttrExpr(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class OtherwiseExprContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public OtherwiseOpContext otherwiseOp() {
return getRuleContext(OtherwiseOpContext.class,0);
}
public OtherwiseExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitOtherwiseExpr(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PostfixExprContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public PostfixOpContext postfixOp() {
return getRuleContext(PostfixOpContext.class,0);
}
public PostfixExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitPostfixExpr(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RelExprContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public RelOpContext relOp() {
return getRuleContext(RelOpContext.class,0);
}
public RelExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitRelExpr(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ListExprContext extends ExprContext {
public ListExpressionContext listExpression() {
return getRuleContext(ListExpressionContext.class,0);
}
public ListExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitListExpr(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AndExprContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public AndOpContext andOp() {
return getRuleContext(AndOpContext.class,0);
}
public AndExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitAndExpr(this);
else return visitor.visitChildren(this);
}
}
public final ExprContext expr() throws RecognitionException {
return expr(0);
}
private ExprContext expr(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExprContext _localctx = new ExprContext(_ctx, _parentState);
ExprContext _prevctx = _localctx;
int _startState = 26;
enterRecursionRule(_localctx, 26, RULE_expr, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(142);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
case 1:
{
_localctx = new PrefixExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(130);
prefixOp();
setState(131);
expr(18);
}
break;
case 2:
{
_localctx = new ListExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(133);
listExpression();
}
break;
case 3:
{
_localctx = new FunExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(134);
functionExpression();
}
break;
case 4:
{
_localctx = new ParenExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(135);
match(T__8);
setState(136);
expr(0);
setState(137);
match(T__9);
}
break;
case 5:
{
_localctx = new ParamExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(139);
parameter();
}
break;
case 6:
{
_localctx = new IdentExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(140);
identifier();
}
break;
case 7:
{
_localctx = new LiteralExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(141);
literal();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(185);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,10,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(183);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
case 1:
{
_localctx = new MulExprContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(144);
if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)");
setState(145);
mulOp();
setState(146);
expr(17);
}
break;
case 2:
{
_localctx = new AddExprContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(148);
if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)");
setState(149);
addOp();
setState(150);
expr(16);
}
break;
case 3:
{
_localctx = new EqExprContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(152);
if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)");
setState(153);
eqOp();
setState(154);
expr(15);
}
break;
case 4:
{
_localctx = new RelExprContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(156);
if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)");
setState(157);
relOp();
setState(158);
expr(14);
}
break;
case 5:
{
_localctx = new MemberExprContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(160);
if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)");
setState(161);
memberOp();
setState(162);
expr(13);
}
break;
case 6:
{
_localctx = new AndExprContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(164);
if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)");
setState(165);
andOp();
setState(166);
expr(12);
}
break;
case 7:
{
_localctx = new OrExprContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(168);
if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)");
setState(169);
orOp();
setState(170);
expr(11);
}
break;
case 8:
{
_localctx = new OtherwiseExprContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(172);
if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
setState(173);
otherwiseOp();
setState(174);
expr(10);
}
break;
case 9:
{
_localctx = new PostfixExprContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(176);
if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)");
setState(177);
postfixOp();
}
break;
case 10:
{
_localctx = new AttrExprContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(178);
if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
setState(179);
match(T__7);
setState(180);
identifier();
}
break;
case 11:
{
_localctx = new FilterExprContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(181);
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
setState(182);
filter();
}
break;
}
}
}
setState(187);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,10,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FilterContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public FilterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_filter; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitFilter(this);
else return visitor.visitChildren(this);
}
}
public final FilterContext filter() throws RecognitionException {
FilterContext _localctx = new FilterContext(_ctx, getState());
enterRule(_localctx, 28, RULE_filter);
try {
enterOuterAlt(_localctx, 1);
{
setState(188);
match(T__10);
setState(189);
expr(0);
setState(190);
match(T__11);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PrefixOpContext extends ParserRuleContext {
public PrefixOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_prefixOp; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitPrefixOp(this);
else return visitor.visitChildren(this);
}
}
public final PrefixOpContext prefixOp() throws RecognitionException {
PrefixOpContext _localctx = new PrefixOpContext(_ctx, getState());
enterRule(_localctx, 30, RULE_prefixOp);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(192);
_la = _input.LA(1);
if ( !(_la==T__12 || _la==T__13) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PostfixOpContext extends ParserRuleContext {
public PostfixOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_postfixOp; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitPostfixOp(this);
else return visitor.visitChildren(this);
}
}
public final PostfixOpContext postfixOp() throws RecognitionException {
PostfixOpContext _localctx = new PostfixOpContext(_ctx, getState());
enterRule(_localctx, 32, RULE_postfixOp);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(194);
_la = _input.LA(1);
if ( !(_la==T__14 || _la==T__15) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MulOpContext extends ParserRuleContext {
public MulOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mulOp; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitMulOp(this);
else return visitor.visitChildren(this);
}
}
public final MulOpContext mulOp() throws RecognitionException {
MulOpContext _localctx = new MulOpContext(_ctx, getState());
enterRule(_localctx, 34, RULE_mulOp);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(196);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 393248L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AddOpContext extends ParserRuleContext {
public AddOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_addOp; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitAddOp(this);
else return visitor.visitChildren(this);
}
}
public final AddOpContext addOp() throws RecognitionException {
AddOpContext _localctx = new AddOpContext(_ctx, getState());
enterRule(_localctx, 36, RULE_addOp);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(198);
_la = _input.LA(1);
if ( !(_la==T__12 || _la==T__18) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EqOpContext extends ParserRuleContext {
public EqOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_eqOp; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitEqOp(this);
else return visitor.visitChildren(this);
}
}
public final EqOpContext eqOp() throws RecognitionException {
EqOpContext _localctx = new EqOpContext(_ctx, getState());
enterRule(_localctx, 38, RULE_eqOp);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(200);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 7340032L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RelOpContext extends ParserRuleContext {
public RelOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relOp; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitRelOp(this);
else return visitor.visitChildren(this);
}
}
public final RelOpContext relOp() throws RecognitionException {
RelOpContext _localctx = new RelOpContext(_ctx, getState());
enterRule(_localctx, 40, RULE_relOp);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(202);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 125829120L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MemberOpContext extends ParserRuleContext {
public MemberOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_memberOp; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitMemberOp(this);
else return visitor.visitChildren(this);
}
}
public final MemberOpContext memberOp() throws RecognitionException {
MemberOpContext _localctx = new MemberOpContext(_ctx, getState());
enterRule(_localctx, 42, RULE_memberOp);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(204);
_la = _input.LA(1);
if ( !(_la==T__26 || _la==T__27) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AndOpContext extends ParserRuleContext {
public AndOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_andOp; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitAndOp(this);
else return visitor.visitChildren(this);
}
}
public final AndOpContext andOp() throws RecognitionException {
AndOpContext _localctx = new AndOpContext(_ctx, getState());
enterRule(_localctx, 44, RULE_andOp);
try {
enterOuterAlt(_localctx, 1);
{
setState(206);
match(T__28);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class OrOpContext extends ParserRuleContext {
public OrOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orOp; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitOrOp(this);
else return visitor.visitChildren(this);
}
}
public final OrOpContext orOp() throws RecognitionException {
OrOpContext _localctx = new OrOpContext(_ctx, getState());
enterRule(_localctx, 46, RULE_orOp);
try {
enterOuterAlt(_localctx, 1);
{
setState(208);
match(T__29);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class OtherwiseOpContext extends ParserRuleContext {
public OtherwiseOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_otherwiseOp; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitOtherwiseOp(this);
else return visitor.visitChildren(this);
}
}
public final OtherwiseOpContext otherwiseOp() throws RecognitionException {
OtherwiseOpContext _localctx = new OtherwiseOpContext(_ctx, getState());
enterRule(_localctx, 48, RULE_otherwiseOp);
try {
enterOuterAlt(_localctx, 1);
{
setState(210);
match(T__30);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ListExpressionContext extends ParserRuleContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public OptionalTrailingCommaContext optionalTrailingComma() {
return getRuleContext(OptionalTrailingCommaContext.class,0);
}
public ListExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_listExpression; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitListExpression(this);
else return visitor.visitChildren(this);
}
}
public final ListExpressionContext listExpression() throws RecognitionException {
ListExpressionContext _localctx = new ListExpressionContext(_ctx, getState());
enterRule(_localctx, 50, RULE_listExpression);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(212);
match(T__10);
setState(223);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 133144013312L) != 0)) {
{
setState(213);
expr(0);
setState(218);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,11,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(214);
match(T__3);
setState(215);
expr(0);
}
}
}
setState(220);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,11,_ctx);
}
setState(221);
optionalTrailingComma();
}
}
setState(225);
match(T__11);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class OptionalTrailingCommaContext extends ParserRuleContext {
public OptionalTrailingCommaContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_optionalTrailingComma; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitOptionalTrailingComma(this);
else return visitor.visitChildren(this);
}
}
public final OptionalTrailingCommaContext optionalTrailingComma() throws RecognitionException {
OptionalTrailingCommaContext _localctx = new OptionalTrailingCommaContext(_ctx, getState());
enterRule(_localctx, 52, RULE_optionalTrailingComma);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(228);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__3) {
{
setState(227);
match(T__3);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionExpressionContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ActualParamsContext actualParams() {
return getRuleContext(ActualParamsContext.class,0);
}
public FunctionExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionExpression; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitFunctionExpression(this);
else return visitor.visitChildren(this);
}
}
public final FunctionExpressionContext functionExpression() throws RecognitionException {
FunctionExpressionContext _localctx = new FunctionExpressionContext(_ctx, getState());
enterRule(_localctx, 54, RULE_functionExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(230);
identifier();
setState(231);
match(T__8);
setState(233);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 133144013312L) != 0)) {
{
setState(232);
actualParams();
}
}
setState(235);
match(T__9);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ActualParamsContext extends ParserRuleContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public ActualParamsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_actualParams; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitActualParams(this);
else return visitor.visitChildren(this);
}
}
public final ActualParamsContext actualParams() throws RecognitionException {
ActualParamsContext _localctx = new ActualParamsContext(_ctx, getState());
enterRule(_localctx, 56, RULE_actualParams);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(237);
expr(0);
setState(242);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__3) {
{
{
setState(238);
match(T__3);
setState(239);
expr(0);
}
}
setState(244);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ParameterContext extends ParserRuleContext {
public TerminalNode Parameter() { return getToken(SnelParser.Parameter, 0); }
public ParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameter; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitParameter(this);
else return visitor.visitChildren(this);
}
}
public final ParameterContext parameter() throws RecognitionException {
ParameterContext _localctx = new ParameterContext(_ctx, getState());
enterRule(_localctx, 58, RULE_parameter);
try {
enterOuterAlt(_localctx, 1);
{
setState(245);
match(Parameter);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IdentifierContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(SnelParser.Identifier, 0); }
public IdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifier; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierContext identifier() throws RecognitionException {
IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
enterRule(_localctx, 60, RULE_identifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(247);
match(Identifier);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LiteralContext extends ParserRuleContext {
public LiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literal; }
public LiteralContext() { }
public void copyFrom(LiteralContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class StringLiteralContext extends LiteralContext {
public TerminalNode StringLiteral() { return getToken(SnelParser.StringLiteral, 0); }
public StringLiteralContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitStringLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class IntegerLiteralContext extends LiteralContext {
public TerminalNode IntegerLiteral() { return getToken(SnelParser.IntegerLiteral, 0); }
public IntegerLiteralContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitIntegerLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BooleanLiteralContext extends LiteralContext {
public TerminalNode BooleanLiteral() { return getToken(SnelParser.BooleanLiteral, 0); }
public BooleanLiteralContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnelVisitor ) return ((SnelVisitor)visitor).visitBooleanLiteral(this);
else return visitor.visitChildren(this);
}
}
public final LiteralContext literal() throws RecognitionException {
LiteralContext _localctx = new LiteralContext(_ctx, getState());
enterRule(_localctx, 62, RULE_literal);
try {
setState(252);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BooleanLiteral:
_localctx = new BooleanLiteralContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(249);
match(BooleanLiteral);
}
break;
case IntegerLiteral:
_localctx = new IntegerLiteralContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(250);
match(IntegerLiteral);
}
break;
case StringLiteral:
_localctx = new StringLiteralContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(251);
match(StringLiteral);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 13:
return expr_sempred((ExprContext)_localctx, predIndex);
}
return true;
}
private boolean expr_sempred(ExprContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 16);
case 1:
return precpred(_ctx, 15);
case 2:
return precpred(_ctx, 14);
case 3:
return precpred(_ctx, 13);
case 4:
return precpred(_ctx, 12);
case 5:
return precpred(_ctx, 11);
case 6:
return precpred(_ctx, 10);
case 7:
return precpred(_ctx, 9);
case 8:
return precpred(_ctx, 17);
case 9:
return precpred(_ctx, 8);
case 10:
return precpred(_ctx, 7);
}
return true;
}
public static final String _serializedATN =
"\u0004\u0001%\u00ff\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002"+
"\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002"+
"\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002"+
"\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b\u0002"+
"\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007\u000f"+
"\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007\u0012"+
"\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007\u0015"+
"\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007\u0018"+
"\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007\u001b"+
"\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007\u001e"+
"\u0002\u001f\u0007\u001f\u0001\u0000\u0004\u0000B\b\u0000\u000b\u0000"+
"\f\u0000C\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0001"+
"\u0001\u0001\u0001\u0002\u0001\u0002\u0003\u0002N\b\u0002\u0001\u0002"+
"\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0003\u0003"+
"V\b\u0003\u0005\u0003X\b\u0003\n\u0003\f\u0003[\t\u0003\u0001\u0004\u0001"+
"\u0004\u0001\u0004\u0003\u0004`\b\u0004\u0001\u0005\u0001\u0005\u0001"+
"\u0006\u0001\u0006\u0003\u0006f\b\u0006\u0001\u0006\u0001\u0006\u0001"+
"\u0006\u0001\u0006\u0001\u0007\u0001\u0007\u0001\b\u0001\b\u0001\b\u0001"+
"\t\u0001\t\u0001\t\u0005\tt\b\t\n\t\f\tw\t\t\u0001\n\u0001\n\u0003\n{"+
"\b\n\u0001\u000b\u0001\u000b\u0001\f\u0001\f\u0001\f\u0001\r\u0001\r\u0001"+
"\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001"+
"\r\u0001\r\u0003\r\u008f\b\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001"+
"\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001"+
"\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001"+
"\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001"+
"\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0005\r\u00b8\b\r\n"+
"\r\f\r\u00bb\t\r\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001"+
"\u000f\u0001\u000f\u0001\u0010\u0001\u0010\u0001\u0011\u0001\u0011\u0001"+
"\u0012\u0001\u0012\u0001\u0013\u0001\u0013\u0001\u0014\u0001\u0014\u0001"+
"\u0015\u0001\u0015\u0001\u0016\u0001\u0016\u0001\u0017\u0001\u0017\u0001"+
"\u0018\u0001\u0018\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0005"+
"\u0019\u00d9\b\u0019\n\u0019\f\u0019\u00dc\t\u0019\u0001\u0019\u0001\u0019"+
"\u0003\u0019\u00e0\b\u0019\u0001\u0019\u0001\u0019\u0001\u001a\u0003\u001a"+
"\u00e5\b\u001a\u0001\u001b\u0001\u001b\u0001\u001b\u0003\u001b\u00ea\b"+
"\u001b\u0001\u001b\u0001\u001b\u0001\u001c\u0001\u001c\u0001\u001c\u0005"+
"\u001c\u00f1\b\u001c\n\u001c\f\u001c\u00f4\t\u001c\u0001\u001d\u0001\u001d"+
"\u0001\u001e\u0001\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0003\u001f"+
"\u00fd\b\u001f\u0001\u001f\u0000\u0001\u001a \u0000\u0002\u0004\u0006"+
"\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a\u001c\u001e \"$&(*,."+
"02468:<>\u0000\b\u0001\u0000\u0006\u0007\u0001\u0000\r\u000e\u0001\u0000"+
"\u000f\u0010\u0002\u0000\u0005\u0005\u0011\u0012\u0002\u0000\r\r\u0013"+
"\u0013\u0001\u0000\u0014\u0016\u0001\u0000\u0017\u001a\u0001\u0000\u001b"+
"\u001c\u00ff\u0000A\u0001\u0000\u0000\u0000\u0002G\u0001\u0000\u0000\u0000"+
"\u0004K\u0001\u0000\u0000\u0000\u0006Y\u0001\u0000\u0000\u0000\b_\u0001"+
"\u0000\u0000\u0000\na\u0001\u0000\u0000\u0000\fc\u0001\u0000\u0000\u0000"+
"\u000ek\u0001\u0000\u0000\u0000\u0010m\u0001\u0000\u0000\u0000\u0012p"+
"\u0001\u0000\u0000\u0000\u0014x\u0001\u0000\u0000\u0000\u0016|\u0001\u0000"+
"\u0000\u0000\u0018~\u0001\u0000\u0000\u0000\u001a\u008e\u0001\u0000\u0000"+
"\u0000\u001c\u00bc\u0001\u0000\u0000\u0000\u001e\u00c0\u0001\u0000\u0000"+
"\u0000 \u00c2\u0001\u0000\u0000\u0000\"\u00c4\u0001\u0000\u0000\u0000"+
"$\u00c6\u0001\u0000\u0000\u0000&\u00c8\u0001\u0000\u0000\u0000(\u00ca"+
"\u0001\u0000\u0000\u0000*\u00cc\u0001\u0000\u0000\u0000,\u00ce\u0001\u0000"+
"\u0000\u0000.\u00d0\u0001\u0000\u0000\u00000\u00d2\u0001\u0000\u0000\u0000"+
"2\u00d4\u0001\u0000\u0000\u00004\u00e4\u0001\u0000\u0000\u00006\u00e6"+
"\u0001\u0000\u0000\u00008\u00ed\u0001\u0000\u0000\u0000:\u00f5\u0001\u0000"+
"\u0000\u0000<\u00f7\u0001\u0000\u0000\u0000>\u00fc\u0001\u0000\u0000\u0000"+
"@B\u0003\u0002\u0001\u0000A@\u0001\u0000\u0000\u0000BC\u0001\u0000\u0000"+
"\u0000CA\u0001\u0000\u0000\u0000CD\u0001\u0000\u0000\u0000DE\u0001\u0000"+
"\u0000\u0000EF\u0005\u0000\u0000\u0001F\u0001\u0001\u0000\u0000\u0000"+
"GH\u0003<\u001e\u0000HI\u0005\u0001\u0000\u0000IJ\u0003\u0004\u0002\u0000"+
"J\u0003\u0001\u0000\u0000\u0000KM\u0003<\u001e\u0000LN\u0003\u001c\u000e"+
"\u0000ML\u0001\u0000\u0000\u0000MN\u0001\u0000\u0000\u0000NO\u0001\u0000"+
"\u0000\u0000OP\u0005\u0002\u0000\u0000PQ\u0003\u0006\u0003\u0000QR\u0005"+
"\u0003\u0000\u0000R\u0005\u0001\u0000\u0000\u0000SU\u0003\b\u0004\u0000"+
"TV\u0005\u0004\u0000\u0000UT\u0001\u0000\u0000\u0000UV\u0001\u0000\u0000"+
"\u0000VX\u0001\u0000\u0000\u0000WS\u0001\u0000\u0000\u0000X[\u0001\u0000"+
"\u0000\u0000YW\u0001\u0000\u0000\u0000YZ\u0001\u0000\u0000\u0000Z\u0007"+
"\u0001\u0000\u0000\u0000[Y\u0001\u0000\u0000\u0000\\`\u0003\n\u0005\u0000"+
"]`\u0003\f\u0006\u0000^`\u0003\u000e\u0007\u0000_\\\u0001\u0000\u0000"+
"\u0000_]\u0001\u0000\u0000\u0000_^\u0001\u0000\u0000\u0000`\t\u0001\u0000"+
"\u0000\u0000ab\u0003<\u001e\u0000b\u000b\u0001\u0000\u0000\u0000ce\u0003"+
"<\u001e\u0000df\u0003\u001c\u000e\u0000ed\u0001\u0000\u0000\u0000ef\u0001"+
"\u0000\u0000\u0000fg\u0001\u0000\u0000\u0000gh\u0005\u0002\u0000\u0000"+
"hi\u0003\u0006\u0003\u0000ij\u0005\u0003\u0000\u0000j\r\u0001\u0000\u0000"+
"\u0000kl\u0005\u0005\u0000\u0000l\u000f\u0001\u0000\u0000\u0000mn\u0003"+
"\u0012\t\u0000no\u0005\u0000\u0000\u0001o\u0011\u0001\u0000\u0000\u0000"+
"pu\u0003\u0014\n\u0000qr\u0005\u0004\u0000\u0000rt\u0003\u0014\n\u0000"+
"sq\u0001\u0000\u0000\u0000tw\u0001\u0000\u0000\u0000us\u0001\u0000\u0000"+
"\u0000uv\u0001\u0000\u0000\u0000v\u0013\u0001\u0000\u0000\u0000wu\u0001"+
"\u0000\u0000\u0000xz\u0003\u001a\r\u0000y{\u0003\u0016\u000b\u0000zy\u0001"+
"\u0000\u0000\u0000z{\u0001\u0000\u0000\u0000{\u0015\u0001\u0000\u0000"+
"\u0000|}\u0007\u0000\u0000\u0000}\u0017\u0001\u0000\u0000\u0000~\u007f"+
"\u0003\u001a\r\u0000\u007f\u0080\u0005\u0000\u0000\u0001\u0080\u0019\u0001"+
"\u0000\u0000\u0000\u0081\u0082\u0006\r\uffff\uffff\u0000\u0082\u0083\u0003"+
"\u001e\u000f\u0000\u0083\u0084\u0003\u001a\r\u0012\u0084\u008f\u0001\u0000"+
"\u0000\u0000\u0085\u008f\u00032\u0019\u0000\u0086\u008f\u00036\u001b\u0000"+
"\u0087\u0088\u0005\t\u0000\u0000\u0088\u0089\u0003\u001a\r\u0000\u0089"+
"\u008a\u0005\n\u0000\u0000\u008a\u008f\u0001\u0000\u0000\u0000\u008b\u008f"+
"\u0003:\u001d\u0000\u008c\u008f\u0003<\u001e\u0000\u008d\u008f\u0003>"+
"\u001f\u0000\u008e\u0081\u0001\u0000\u0000\u0000\u008e\u0085\u0001\u0000"+
"\u0000\u0000\u008e\u0086\u0001\u0000\u0000\u0000\u008e\u0087\u0001\u0000"+
"\u0000\u0000\u008e\u008b\u0001\u0000\u0000\u0000\u008e\u008c\u0001\u0000"+
"\u0000\u0000\u008e\u008d\u0001\u0000\u0000\u0000\u008f\u00b9\u0001\u0000"+
"\u0000\u0000\u0090\u0091\n\u0010\u0000\u0000\u0091\u0092\u0003\"\u0011"+
"\u0000\u0092\u0093\u0003\u001a\r\u0011\u0093\u00b8\u0001\u0000\u0000\u0000"+
"\u0094\u0095\n\u000f\u0000\u0000\u0095\u0096\u0003$\u0012\u0000\u0096"+
"\u0097\u0003\u001a\r\u0010\u0097\u00b8\u0001\u0000\u0000\u0000\u0098\u0099"+
"\n\u000e\u0000\u0000\u0099\u009a\u0003&\u0013\u0000\u009a\u009b\u0003"+
"\u001a\r\u000f\u009b\u00b8\u0001\u0000\u0000\u0000\u009c\u009d\n\r\u0000"+
"\u0000\u009d\u009e\u0003(\u0014\u0000\u009e\u009f\u0003\u001a\r\u000e"+
"\u009f\u00b8\u0001\u0000\u0000\u0000\u00a0\u00a1\n\f\u0000\u0000\u00a1"+
"\u00a2\u0003*\u0015\u0000\u00a2\u00a3\u0003\u001a\r\r\u00a3\u00b8\u0001"+
"\u0000\u0000\u0000\u00a4\u00a5\n\u000b\u0000\u0000\u00a5\u00a6\u0003,"+
"\u0016\u0000\u00a6\u00a7\u0003\u001a\r\f\u00a7\u00b8\u0001\u0000\u0000"+
"\u0000\u00a8\u00a9\n\n\u0000\u0000\u00a9\u00aa\u0003.\u0017\u0000\u00aa"+
"\u00ab\u0003\u001a\r\u000b\u00ab\u00b8\u0001\u0000\u0000\u0000\u00ac\u00ad"+
"\n\t\u0000\u0000\u00ad\u00ae\u00030\u0018\u0000\u00ae\u00af\u0003\u001a"+
"\r\n\u00af\u00b8\u0001\u0000\u0000\u0000\u00b0\u00b1\n\u0011\u0000\u0000"+
"\u00b1\u00b8\u0003 \u0010\u0000\u00b2\u00b3\n\b\u0000\u0000\u00b3\u00b4"+
"\u0005\b\u0000\u0000\u00b4\u00b8\u0003<\u001e\u0000\u00b5\u00b6\n\u0007"+
"\u0000\u0000\u00b6\u00b8\u0003\u001c\u000e\u0000\u00b7\u0090\u0001\u0000"+
"\u0000\u0000\u00b7\u0094\u0001\u0000\u0000\u0000\u00b7\u0098\u0001\u0000"+
"\u0000\u0000\u00b7\u009c\u0001\u0000\u0000\u0000\u00b7\u00a0\u0001\u0000"+
"\u0000\u0000\u00b7\u00a4\u0001\u0000\u0000\u0000\u00b7\u00a8\u0001\u0000"+
"\u0000\u0000\u00b7\u00ac\u0001\u0000\u0000\u0000\u00b7\u00b0\u0001\u0000"+
"\u0000\u0000\u00b7\u00b2\u0001\u0000\u0000\u0000\u00b7\u00b5\u0001\u0000"+
"\u0000\u0000\u00b8\u00bb\u0001\u0000\u0000\u0000\u00b9\u00b7\u0001\u0000"+
"\u0000\u0000\u00b9\u00ba\u0001\u0000\u0000\u0000\u00ba\u001b\u0001\u0000"+
"\u0000\u0000\u00bb\u00b9\u0001\u0000\u0000\u0000\u00bc\u00bd\u0005\u000b"+
"\u0000\u0000\u00bd\u00be\u0003\u001a\r\u0000\u00be\u00bf\u0005\f\u0000"+
"\u0000\u00bf\u001d\u0001\u0000\u0000\u0000\u00c0\u00c1\u0007\u0001\u0000"+
"\u0000\u00c1\u001f\u0001\u0000\u0000\u0000\u00c2\u00c3\u0007\u0002\u0000"+
"\u0000\u00c3!\u0001\u0000\u0000\u0000\u00c4\u00c5\u0007\u0003\u0000\u0000"+
"\u00c5#\u0001\u0000\u0000\u0000\u00c6\u00c7\u0007\u0004\u0000\u0000\u00c7"+
"%\u0001\u0000\u0000\u0000\u00c8\u00c9\u0007\u0005\u0000\u0000\u00c9\'"+
"\u0001\u0000\u0000\u0000\u00ca\u00cb\u0007\u0006\u0000\u0000\u00cb)\u0001"+
"\u0000\u0000\u0000\u00cc\u00cd\u0007\u0007\u0000\u0000\u00cd+\u0001\u0000"+
"\u0000\u0000\u00ce\u00cf\u0005\u001d\u0000\u0000\u00cf-\u0001\u0000\u0000"+
"\u0000\u00d0\u00d1\u0005\u001e\u0000\u0000\u00d1/\u0001\u0000\u0000\u0000"+
"\u00d2\u00d3\u0005\u001f\u0000\u0000\u00d31\u0001\u0000\u0000\u0000\u00d4"+
"\u00df\u0005\u000b\u0000\u0000\u00d5\u00da\u0003\u001a\r\u0000\u00d6\u00d7"+
"\u0005\u0004\u0000\u0000\u00d7\u00d9\u0003\u001a\r\u0000\u00d8\u00d6\u0001"+
"\u0000\u0000\u0000\u00d9\u00dc\u0001\u0000\u0000\u0000\u00da\u00d8\u0001"+
"\u0000\u0000\u0000\u00da\u00db\u0001\u0000\u0000\u0000\u00db\u00dd\u0001"+
"\u0000\u0000\u0000\u00dc\u00da\u0001\u0000\u0000\u0000\u00dd\u00de\u0003"+
"4\u001a\u0000\u00de\u00e0\u0001\u0000\u0000\u0000\u00df\u00d5\u0001\u0000"+
"\u0000\u0000\u00df\u00e0\u0001\u0000\u0000\u0000\u00e0\u00e1\u0001\u0000"+
"\u0000\u0000\u00e1\u00e2\u0005\f\u0000\u0000\u00e23\u0001\u0000\u0000"+
"\u0000\u00e3\u00e5\u0005\u0004\u0000\u0000\u00e4\u00e3\u0001\u0000\u0000"+
"\u0000\u00e4\u00e5\u0001\u0000\u0000\u0000\u00e55\u0001\u0000\u0000\u0000"+
"\u00e6\u00e7\u0003<\u001e\u0000\u00e7\u00e9\u0005\t\u0000\u0000\u00e8"+
"\u00ea\u00038\u001c\u0000\u00e9\u00e8\u0001\u0000\u0000\u0000\u00e9\u00ea"+
"\u0001\u0000\u0000\u0000\u00ea\u00eb\u0001\u0000\u0000\u0000\u00eb\u00ec"+
"\u0005\n\u0000\u0000\u00ec7\u0001\u0000\u0000\u0000\u00ed\u00f2\u0003"+
"\u001a\r\u0000\u00ee\u00ef\u0005\u0004\u0000\u0000\u00ef\u00f1\u0003\u001a"+
"\r\u0000\u00f0\u00ee\u0001\u0000\u0000\u0000\u00f1\u00f4\u0001\u0000\u0000"+
"\u0000\u00f2\u00f0\u0001\u0000\u0000\u0000\u00f2\u00f3\u0001\u0000\u0000"+
"\u0000\u00f39\u0001\u0000\u0000\u0000\u00f4\u00f2\u0001\u0000\u0000\u0000"+
"\u00f5\u00f6\u0005#\u0000\u0000\u00f6;\u0001\u0000\u0000\u0000\u00f7\u00f8"+
"\u0005$\u0000\u0000\u00f8=\u0001\u0000\u0000\u0000\u00f9\u00fd\u0005 "+
"\u0000\u0000\u00fa\u00fd\u0005!\u0000\u0000\u00fb\u00fd\u0005\"\u0000"+
"\u0000\u00fc\u00f9\u0001\u0000\u0000\u0000\u00fc\u00fa\u0001\u0000\u0000"+
"\u0000\u00fc\u00fb\u0001\u0000\u0000\u0000\u00fd?\u0001\u0000\u0000\u0000"+
"\u0011CMUY_euz\u008e\u00b7\u00b9\u00da\u00df\u00e4\u00e9\u00f2\u00fc";
public static final ATN _ATN =
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
}
