metapath10Parser.java
// Generated from metapath10.g4 by ANTLR 4.10.1
package gov.nist.secauto.metaschema.core.metapath.antlr;
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"})
public class metapath10Parser extends Parser {
static { RuntimeMetaData.checkVersion("4.10.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
AT=1, BANG=2, CB=3, CC=4, CEQ=5, COLON=6, COLONCOLON=7, COMMA=8, CP=9,
CS=10, D=11, DD=12, DOLLAR=13, EG=14, EQ=15, GE=16, GG=17, GT=18, LE=19,
LL=20, LT=21, MINUS=22, NE=23, OB=24, OC=25, OP=26, P=27, PLUS=28, POUND=29,
PP=30, QM=31, SC=32, SLASH=33, SS=34, STAR=35, KW_ANCESTOR=36, KW_ANCESTOR_OR_SELF=37,
KW_AND=38, KW_CHILD=39, KW_DESCENDANT=40, KW_DESCENDANT_OR_SELF=41, KW_DIV=42,
KW_EMPTY_SEQUENCE=43, KW_EQ=44, KW_EXCEPT=45, KW_FOLLOWING=46, KW_FOLLOWING_SIBLING=47,
KW_GE=48, KW_GT=49, KW_IDIV=50, KW_INTERSECT=51, KW_LE=52, KW_LET=53,
KW_LT=54, KW_MOD=55, KW_NE=56, KW_OR=57, KW_PARENT=58, KW_PRECEDING=59,
KW_PRECEDING_SIBLING=60, KW_RETURN=61, KW_SELF=62, KW_UNION=63, IntegerLiteral=64,
DecimalLiteral=65, DoubleLiteral=66, StringLiteral=67, Comment=68, LocalName=69,
NCName=70, Whitespace=71;
public static final int
RULE_metapath = 0, RULE_expr = 1, RULE_exprsingle = 2, RULE_letexpr = 3,
RULE_simpleletclause = 4, RULE_simpleletbinding = 5, RULE_orexpr = 6,
RULE_andexpr = 7, RULE_comparisonexpr = 8, RULE_stringconcatexpr = 9,
RULE_additiveexpr = 10, RULE_multiplicativeexpr = 11, RULE_unionexpr = 12,
RULE_intersectexceptexpr = 13, RULE_arrowexpr = 14, RULE_unaryexpr = 15,
RULE_valueexpr = 16, RULE_generalcomp = 17, RULE_valuecomp = 18, RULE_pathexpr = 19,
RULE_relativepathexpr = 20, RULE_stepexpr = 21, RULE_axisstep = 22, RULE_forwardstep = 23,
RULE_forwardaxis = 24, RULE_abbrevforwardstep = 25, RULE_reversestep = 26,
RULE_reverseaxis = 27, RULE_abbrevreversestep = 28, RULE_nametest = 29,
RULE_wildcard = 30, RULE_postfixexpr = 31, RULE_argumentlist = 32, RULE_predicatelist = 33,
RULE_predicate = 34, RULE_arrowfunctionspecifier = 35, RULE_primaryexpr = 36,
RULE_literal = 37, RULE_numericliteral = 38, RULE_varref = 39, RULE_varname = 40,
RULE_parenthesizedexpr = 41, RULE_contextitemexpr = 42, RULE_functioncall = 43,
RULE_argument = 44, RULE_eqname = 45;
private static String[] makeRuleNames() {
return new String[] {
"metapath", "expr", "exprsingle", "letexpr", "simpleletclause", "simpleletbinding",
"orexpr", "andexpr", "comparisonexpr", "stringconcatexpr", "additiveexpr",
"multiplicativeexpr", "unionexpr", "intersectexceptexpr", "arrowexpr",
"unaryexpr", "valueexpr", "generalcomp", "valuecomp", "pathexpr", "relativepathexpr",
"stepexpr", "axisstep", "forwardstep", "forwardaxis", "abbrevforwardstep",
"reversestep", "reverseaxis", "abbrevreversestep", "nametest", "wildcard",
"postfixexpr", "argumentlist", "predicatelist", "predicate", "arrowfunctionspecifier",
"primaryexpr", "literal", "numericliteral", "varref", "varname", "parenthesizedexpr",
"contextitemexpr", "functioncall", "argument", "eqname"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'@'", "'!'", "']'", "'}'", "':='", "':'", "'::'", "','", "')'",
"':*'", "'.'", "'..'", "'$'", "'=>'", "'='", "'>='", "'>>'", "'>'", "'<='",
"'<<'", "'<'", "'-'", "'!='", "'['", "'{'", "'('", "'|'", "'+'", "'#'",
"'||'", "'?'", "'*:'", "'/'", "'//'", "'*'", "'ancestor'", "'ancestor-or-self'",
"'and'", "'child'", "'descendant'", "'descendant-or-self'", "'div'",
"'empty-sequence'", "'eq'", "'except'", "'following'", "'following-sibling'",
"'ge'", "'gt'", "'idiv'", "'intersect'", "'le'", "'let'", "'lt'", "'mod'",
"'ne'", "'or'", "'parent'", "'preceding'", "'preceding-sibling'", "'return'",
"'self'", "'union'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "AT", "BANG", "CB", "CC", "CEQ", "COLON", "COLONCOLON", "COMMA",
"CP", "CS", "D", "DD", "DOLLAR", "EG", "EQ", "GE", "GG", "GT", "LE",
"LL", "LT", "MINUS", "NE", "OB", "OC", "OP", "P", "PLUS", "POUND", "PP",
"QM", "SC", "SLASH", "SS", "STAR", "KW_ANCESTOR", "KW_ANCESTOR_OR_SELF",
"KW_AND", "KW_CHILD", "KW_DESCENDANT", "KW_DESCENDANT_OR_SELF", "KW_DIV",
"KW_EMPTY_SEQUENCE", "KW_EQ", "KW_EXCEPT", "KW_FOLLOWING", "KW_FOLLOWING_SIBLING",
"KW_GE", "KW_GT", "KW_IDIV", "KW_INTERSECT", "KW_LE", "KW_LET", "KW_LT",
"KW_MOD", "KW_NE", "KW_OR", "KW_PARENT", "KW_PRECEDING", "KW_PRECEDING_SIBLING",
"KW_RETURN", "KW_SELF", "KW_UNION", "IntegerLiteral", "DecimalLiteral",
"DoubleLiteral", "StringLiteral", "Comment", "LocalName", "NCName", "Whitespace"
};
}
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] = "<INVALID>";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "metapath10.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public metapath10Parser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class MetapathContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode EOF() { return getToken(metapath10Parser.EOF, 0); }
public MetapathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_metapath; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitMetapath(this);
else return visitor.visitChildren(this);
}
}
public final MetapathContext metapath() throws RecognitionException {
MetapathContext _localctx = new MetapathContext(_ctx, getState());
enterRule(_localctx, 0, RULE_metapath);
try {
enterOuterAlt(_localctx, 1);
{
setState(92);
expr();
setState(93);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExprContext extends ParserRuleContext {
public List<ExprsingleContext> exprsingle() {
return getRuleContexts(ExprsingleContext.class);
}
public ExprsingleContext exprsingle(int i) {
return getRuleContext(ExprsingleContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(metapath10Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(metapath10Parser.COMMA, i);
}
public ExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitExpr(this);
else return visitor.visitChildren(this);
}
}
public final ExprContext expr() throws RecognitionException {
ExprContext _localctx = new ExprContext(_ctx, getState());
enterRule(_localctx, 2, RULE_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(95);
exprsingle();
setState(100);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(96);
match(COMMA);
setState(97);
exprsingle();
}
}
setState(102);
_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;
}
public static class ExprsingleContext extends ParserRuleContext {
public LetexprContext letexpr() {
return getRuleContext(LetexprContext.class,0);
}
public OrexprContext orexpr() {
return getRuleContext(OrexprContext.class,0);
}
public ExprsingleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exprsingle; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitExprsingle(this);
else return visitor.visitChildren(this);
}
}
public final ExprsingleContext exprsingle() throws RecognitionException {
ExprsingleContext _localctx = new ExprsingleContext(_ctx, getState());
enterRule(_localctx, 4, RULE_exprsingle);
try {
setState(105);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(103);
letexpr();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(104);
orexpr();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LetexprContext extends ParserRuleContext {
public SimpleletclauseContext simpleletclause() {
return getRuleContext(SimpleletclauseContext.class,0);
}
public TerminalNode KW_RETURN() { return getToken(metapath10Parser.KW_RETURN, 0); }
public ExprsingleContext exprsingle() {
return getRuleContext(ExprsingleContext.class,0);
}
public LetexprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_letexpr; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitLetexpr(this);
else return visitor.visitChildren(this);
}
}
public final LetexprContext letexpr() throws RecognitionException {
LetexprContext _localctx = new LetexprContext(_ctx, getState());
enterRule(_localctx, 6, RULE_letexpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(107);
simpleletclause();
setState(108);
match(KW_RETURN);
setState(109);
exprsingle();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SimpleletclauseContext extends ParserRuleContext {
public TerminalNode KW_LET() { return getToken(metapath10Parser.KW_LET, 0); }
public List<SimpleletbindingContext> simpleletbinding() {
return getRuleContexts(SimpleletbindingContext.class);
}
public SimpleletbindingContext simpleletbinding(int i) {
return getRuleContext(SimpleletbindingContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(metapath10Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(metapath10Parser.COMMA, i);
}
public SimpleletclauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleletclause; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitSimpleletclause(this);
else return visitor.visitChildren(this);
}
}
public final SimpleletclauseContext simpleletclause() throws RecognitionException {
SimpleletclauseContext _localctx = new SimpleletclauseContext(_ctx, getState());
enterRule(_localctx, 8, RULE_simpleletclause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(111);
match(KW_LET);
setState(112);
simpleletbinding();
setState(117);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(113);
match(COMMA);
setState(114);
simpleletbinding();
}
}
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;
}
public static class SimpleletbindingContext extends ParserRuleContext {
public TerminalNode DOLLAR() { return getToken(metapath10Parser.DOLLAR, 0); }
public VarnameContext varname() {
return getRuleContext(VarnameContext.class,0);
}
public TerminalNode CEQ() { return getToken(metapath10Parser.CEQ, 0); }
public ExprsingleContext exprsingle() {
return getRuleContext(ExprsingleContext.class,0);
}
public SimpleletbindingContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleletbinding; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitSimpleletbinding(this);
else return visitor.visitChildren(this);
}
}
public final SimpleletbindingContext simpleletbinding() throws RecognitionException {
SimpleletbindingContext _localctx = new SimpleletbindingContext(_ctx, getState());
enterRule(_localctx, 10, RULE_simpleletbinding);
try {
enterOuterAlt(_localctx, 1);
{
setState(120);
match(DOLLAR);
setState(121);
varname();
setState(122);
match(CEQ);
setState(123);
exprsingle();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrexprContext extends ParserRuleContext {
public List<AndexprContext> andexpr() {
return getRuleContexts(AndexprContext.class);
}
public AndexprContext andexpr(int i) {
return getRuleContext(AndexprContext.class,i);
}
public List<TerminalNode> KW_OR() { return getTokens(metapath10Parser.KW_OR); }
public TerminalNode KW_OR(int i) {
return getToken(metapath10Parser.KW_OR, i);
}
public OrexprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orexpr; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitOrexpr(this);
else return visitor.visitChildren(this);
}
}
public final OrexprContext orexpr() throws RecognitionException {
OrexprContext _localctx = new OrexprContext(_ctx, getState());
enterRule(_localctx, 12, RULE_orexpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(125);
andexpr();
setState(130);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==KW_OR) {
{
{
setState(126);
match(KW_OR);
setState(127);
andexpr();
}
}
setState(132);
_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;
}
public static class AndexprContext extends ParserRuleContext {
public List<ComparisonexprContext> comparisonexpr() {
return getRuleContexts(ComparisonexprContext.class);
}
public ComparisonexprContext comparisonexpr(int i) {
return getRuleContext(ComparisonexprContext.class,i);
}
public List<TerminalNode> KW_AND() { return getTokens(metapath10Parser.KW_AND); }
public TerminalNode KW_AND(int i) {
return getToken(metapath10Parser.KW_AND, i);
}
public AndexprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_andexpr; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitAndexpr(this);
else return visitor.visitChildren(this);
}
}
public final AndexprContext andexpr() throws RecognitionException {
AndexprContext _localctx = new AndexprContext(_ctx, getState());
enterRule(_localctx, 14, RULE_andexpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(133);
comparisonexpr();
setState(138);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==KW_AND) {
{
{
setState(134);
match(KW_AND);
setState(135);
comparisonexpr();
}
}
setState(140);
_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;
}
public static class ComparisonexprContext extends ParserRuleContext {
public List<StringconcatexprContext> stringconcatexpr() {
return getRuleContexts(StringconcatexprContext.class);
}
public StringconcatexprContext stringconcatexpr(int i) {
return getRuleContext(StringconcatexprContext.class,i);
}
public ValuecompContext valuecomp() {
return getRuleContext(ValuecompContext.class,0);
}
public GeneralcompContext generalcomp() {
return getRuleContext(GeneralcompContext.class,0);
}
public ComparisonexprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comparisonexpr; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitComparisonexpr(this);
else return visitor.visitChildren(this);
}
}
public final ComparisonexprContext comparisonexpr() throws RecognitionException {
ComparisonexprContext _localctx = new ComparisonexprContext(_ctx, getState());
enterRule(_localctx, 16, RULE_comparisonexpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(141);
stringconcatexpr();
setState(148);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EQ) | (1L << GE) | (1L << GT) | (1L << LE) | (1L << LT) | (1L << NE) | (1L << KW_EQ) | (1L << KW_GE) | (1L << KW_GT) | (1L << KW_LE) | (1L << KW_LT) | (1L << KW_NE))) != 0)) {
{
setState(144);
_errHandler.sync(this);
switch (_input.LA(1)) {
case KW_EQ:
case KW_GE:
case KW_GT:
case KW_LE:
case KW_LT:
case KW_NE:
{
setState(142);
valuecomp();
}
break;
case EQ:
case GE:
case GT:
case LE:
case LT:
case NE:
{
setState(143);
generalcomp();
}
break;
default:
throw new NoViableAltException(this);
}
setState(146);
stringconcatexpr();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StringconcatexprContext extends ParserRuleContext {
public List<AdditiveexprContext> additiveexpr() {
return getRuleContexts(AdditiveexprContext.class);
}
public AdditiveexprContext additiveexpr(int i) {
return getRuleContext(AdditiveexprContext.class,i);
}
public List<TerminalNode> PP() { return getTokens(metapath10Parser.PP); }
public TerminalNode PP(int i) {
return getToken(metapath10Parser.PP, i);
}
public StringconcatexprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stringconcatexpr; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitStringconcatexpr(this);
else return visitor.visitChildren(this);
}
}
public final StringconcatexprContext stringconcatexpr() throws RecognitionException {
StringconcatexprContext _localctx = new StringconcatexprContext(_ctx, getState());
enterRule(_localctx, 18, RULE_stringconcatexpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(150);
additiveexpr();
setState(155);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==PP) {
{
{
setState(151);
match(PP);
setState(152);
additiveexpr();
}
}
setState(157);
_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;
}
public static class AdditiveexprContext extends ParserRuleContext {
public List<MultiplicativeexprContext> multiplicativeexpr() {
return getRuleContexts(MultiplicativeexprContext.class);
}
public MultiplicativeexprContext multiplicativeexpr(int i) {
return getRuleContext(MultiplicativeexprContext.class,i);
}
public List<TerminalNode> PLUS() { return getTokens(metapath10Parser.PLUS); }
public TerminalNode PLUS(int i) {
return getToken(metapath10Parser.PLUS, i);
}
public List<TerminalNode> MINUS() { return getTokens(metapath10Parser.MINUS); }
public TerminalNode MINUS(int i) {
return getToken(metapath10Parser.MINUS, i);
}
public AdditiveexprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_additiveexpr; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitAdditiveexpr(this);
else return visitor.visitChildren(this);
}
}
public final AdditiveexprContext additiveexpr() throws RecognitionException {
AdditiveexprContext _localctx = new AdditiveexprContext(_ctx, getState());
enterRule(_localctx, 20, RULE_additiveexpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(158);
multiplicativeexpr();
setState(163);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==MINUS || _la==PLUS) {
{
{
setState(159);
_la = _input.LA(1);
if ( !(_la==MINUS || _la==PLUS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(160);
multiplicativeexpr();
}
}
setState(165);
_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;
}
public static class MultiplicativeexprContext extends ParserRuleContext {
public List<UnionexprContext> unionexpr() {
return getRuleContexts(UnionexprContext.class);
}
public UnionexprContext unionexpr(int i) {
return getRuleContext(UnionexprContext.class,i);
}
public List<TerminalNode> STAR() { return getTokens(metapath10Parser.STAR); }
public TerminalNode STAR(int i) {
return getToken(metapath10Parser.STAR, i);
}
public List<TerminalNode> KW_DIV() { return getTokens(metapath10Parser.KW_DIV); }
public TerminalNode KW_DIV(int i) {
return getToken(metapath10Parser.KW_DIV, i);
}
public List<TerminalNode> KW_IDIV() { return getTokens(metapath10Parser.KW_IDIV); }
public TerminalNode KW_IDIV(int i) {
return getToken(metapath10Parser.KW_IDIV, i);
}
public List<TerminalNode> KW_MOD() { return getTokens(metapath10Parser.KW_MOD); }
public TerminalNode KW_MOD(int i) {
return getToken(metapath10Parser.KW_MOD, i);
}
public MultiplicativeexprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiplicativeexpr; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitMultiplicativeexpr(this);
else return visitor.visitChildren(this);
}
}
public final MultiplicativeexprContext multiplicativeexpr() throws RecognitionException {
MultiplicativeexprContext _localctx = new MultiplicativeexprContext(_ctx, getState());
enterRule(_localctx, 22, RULE_multiplicativeexpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(166);
unionexpr();
setState(171);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STAR) | (1L << KW_DIV) | (1L << KW_IDIV) | (1L << KW_MOD))) != 0)) {
{
{
setState(167);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STAR) | (1L << KW_DIV) | (1L << KW_IDIV) | (1L << KW_MOD))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(168);
unionexpr();
}
}
setState(173);
_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;
}
public static class UnionexprContext extends ParserRuleContext {
public List<IntersectexceptexprContext> intersectexceptexpr() {
return getRuleContexts(IntersectexceptexprContext.class);
}
public IntersectexceptexprContext intersectexceptexpr(int i) {
return getRuleContext(IntersectexceptexprContext.class,i);
}
public List<TerminalNode> KW_UNION() { return getTokens(metapath10Parser.KW_UNION); }
public TerminalNode KW_UNION(int i) {
return getToken(metapath10Parser.KW_UNION, i);
}
public List<TerminalNode> P() { return getTokens(metapath10Parser.P); }
public TerminalNode P(int i) {
return getToken(metapath10Parser.P, i);
}
public UnionexprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unionexpr; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitUnionexpr(this);
else return visitor.visitChildren(this);
}
}
public final UnionexprContext unionexpr() throws RecognitionException {
UnionexprContext _localctx = new UnionexprContext(_ctx, getState());
enterRule(_localctx, 24, RULE_unionexpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(174);
intersectexceptexpr();
setState(179);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==P || _la==KW_UNION) {
{
{
setState(175);
_la = _input.LA(1);
if ( !(_la==P || _la==KW_UNION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(176);
intersectexceptexpr();
}
}
setState(181);
_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;
}
public static class IntersectexceptexprContext extends ParserRuleContext {
public List<ArrowexprContext> arrowexpr() {
return getRuleContexts(ArrowexprContext.class);
}
public ArrowexprContext arrowexpr(int i) {
return getRuleContext(ArrowexprContext.class,i);
}
public List<TerminalNode> KW_INTERSECT() { return getTokens(metapath10Parser.KW_INTERSECT); }
public TerminalNode KW_INTERSECT(int i) {
return getToken(metapath10Parser.KW_INTERSECT, i);
}
public List<TerminalNode> KW_EXCEPT() { return getTokens(metapath10Parser.KW_EXCEPT); }
public TerminalNode KW_EXCEPT(int i) {
return getToken(metapath10Parser.KW_EXCEPT, i);
}
public IntersectexceptexprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_intersectexceptexpr; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitIntersectexceptexpr(this);
else return visitor.visitChildren(this);
}
}
public final IntersectexceptexprContext intersectexceptexpr() throws RecognitionException {
IntersectexceptexprContext _localctx = new IntersectexceptexprContext(_ctx, getState());
enterRule(_localctx, 26, RULE_intersectexceptexpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(182);
arrowexpr();
setState(187);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==KW_EXCEPT || _la==KW_INTERSECT) {
{
{
setState(183);
_la = _input.LA(1);
if ( !(_la==KW_EXCEPT || _la==KW_INTERSECT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(184);
arrowexpr();
}
}
setState(189);
_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;
}
public static class ArrowexprContext extends ParserRuleContext {
public UnaryexprContext unaryexpr() {
return getRuleContext(UnaryexprContext.class,0);
}
public List<TerminalNode> EG() { return getTokens(metapath10Parser.EG); }
public TerminalNode EG(int i) {
return getToken(metapath10Parser.EG, i);
}
public List<ArrowfunctionspecifierContext> arrowfunctionspecifier() {
return getRuleContexts(ArrowfunctionspecifierContext.class);
}
public ArrowfunctionspecifierContext arrowfunctionspecifier(int i) {
return getRuleContext(ArrowfunctionspecifierContext.class,i);
}
public List<ArgumentlistContext> argumentlist() {
return getRuleContexts(ArgumentlistContext.class);
}
public ArgumentlistContext argumentlist(int i) {
return getRuleContext(ArgumentlistContext.class,i);
}
public ArrowexprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrowexpr; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitArrowexpr(this);
else return visitor.visitChildren(this);
}
}
public final ArrowexprContext arrowexpr() throws RecognitionException {
ArrowexprContext _localctx = new ArrowexprContext(_ctx, getState());
enterRule(_localctx, 28, RULE_arrowexpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(190);
unaryexpr();
setState(197);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==EG) {
{
{
setState(191);
match(EG);
setState(192);
arrowfunctionspecifier();
setState(193);
argumentlist();
}
}
setState(199);
_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;
}
public static class UnaryexprContext extends ParserRuleContext {
public ValueexprContext valueexpr() {
return getRuleContext(ValueexprContext.class,0);
}
public List<TerminalNode> MINUS() { return getTokens(metapath10Parser.MINUS); }
public TerminalNode MINUS(int i) {
return getToken(metapath10Parser.MINUS, i);
}
public List<TerminalNode> PLUS() { return getTokens(metapath10Parser.PLUS); }
public TerminalNode PLUS(int i) {
return getToken(metapath10Parser.PLUS, i);
}
public UnaryexprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unaryexpr; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitUnaryexpr(this);
else return visitor.visitChildren(this);
}
}
public final UnaryexprContext unaryexpr() throws RecognitionException {
UnaryexprContext _localctx = new UnaryexprContext(_ctx, getState());
enterRule(_localctx, 30, RULE_unaryexpr);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(203);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,13,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(200);
_la = _input.LA(1);
if ( !(_la==MINUS || _la==PLUS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
}
setState(205);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,13,_ctx);
}
setState(206);
valueexpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ValueexprContext extends ParserRuleContext {
public PathexprContext pathexpr() {
return getRuleContext(PathexprContext.class,0);
}
public ValueexprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_valueexpr; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitValueexpr(this);
else return visitor.visitChildren(this);
}
}
public final ValueexprContext valueexpr() throws RecognitionException {
ValueexprContext _localctx = new ValueexprContext(_ctx, getState());
enterRule(_localctx, 32, RULE_valueexpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(208);
pathexpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GeneralcompContext extends ParserRuleContext {
public TerminalNode EQ() { return getToken(metapath10Parser.EQ, 0); }
public TerminalNode NE() { return getToken(metapath10Parser.NE, 0); }
public TerminalNode LT() { return getToken(metapath10Parser.LT, 0); }
public TerminalNode LE() { return getToken(metapath10Parser.LE, 0); }
public TerminalNode GT() { return getToken(metapath10Parser.GT, 0); }
public TerminalNode GE() { return getToken(metapath10Parser.GE, 0); }
public GeneralcompContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_generalcomp; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitGeneralcomp(this);
else return visitor.visitChildren(this);
}
}
public final GeneralcompContext generalcomp() throws RecognitionException {
GeneralcompContext _localctx = new GeneralcompContext(_ctx, getState());
enterRule(_localctx, 34, RULE_generalcomp);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(210);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EQ) | (1L << GE) | (1L << GT) | (1L << LE) | (1L << LT) | (1L << NE))) != 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;
}
public static class ValuecompContext extends ParserRuleContext {
public TerminalNode KW_EQ() { return getToken(metapath10Parser.KW_EQ, 0); }
public TerminalNode KW_NE() { return getToken(metapath10Parser.KW_NE, 0); }
public TerminalNode KW_LT() { return getToken(metapath10Parser.KW_LT, 0); }
public TerminalNode KW_LE() { return getToken(metapath10Parser.KW_LE, 0); }
public TerminalNode KW_GT() { return getToken(metapath10Parser.KW_GT, 0); }
public TerminalNode KW_GE() { return getToken(metapath10Parser.KW_GE, 0); }
public ValuecompContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_valuecomp; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitValuecomp(this);
else return visitor.visitChildren(this);
}
}
public final ValuecompContext valuecomp() throws RecognitionException {
ValuecompContext _localctx = new ValuecompContext(_ctx, getState());
enterRule(_localctx, 36, RULE_valuecomp);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(212);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << KW_EQ) | (1L << KW_GE) | (1L << KW_GT) | (1L << KW_LE) | (1L << KW_LT) | (1L << KW_NE))) != 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;
}
public static class PathexprContext extends ParserRuleContext {
public TerminalNode SLASH() { return getToken(metapath10Parser.SLASH, 0); }
public RelativepathexprContext relativepathexpr() {
return getRuleContext(RelativepathexprContext.class,0);
}
public TerminalNode SS() { return getToken(metapath10Parser.SS, 0); }
public PathexprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pathexpr; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitPathexpr(this);
else return visitor.visitChildren(this);
}
}
public final PathexprContext pathexpr() throws RecognitionException {
PathexprContext _localctx = new PathexprContext(_ctx, getState());
enterRule(_localctx, 38, RULE_pathexpr);
try {
setState(221);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
{
setState(214);
match(SLASH);
setState(216);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
case 1:
{
setState(215);
relativepathexpr();
}
break;
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
{
setState(218);
match(SS);
setState(219);
relativepathexpr();
}
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(220);
relativepathexpr();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RelativepathexprContext extends ParserRuleContext {
public List<StepexprContext> stepexpr() {
return getRuleContexts(StepexprContext.class);
}
public StepexprContext stepexpr(int i) {
return getRuleContext(StepexprContext.class,i);
}
public List<TerminalNode> SLASH() { return getTokens(metapath10Parser.SLASH); }
public TerminalNode SLASH(int i) {
return getToken(metapath10Parser.SLASH, i);
}
public List<TerminalNode> SS() { return getTokens(metapath10Parser.SS); }
public TerminalNode SS(int i) {
return getToken(metapath10Parser.SS, i);
}
public RelativepathexprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relativepathexpr; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitRelativepathexpr(this);
else return visitor.visitChildren(this);
}
}
public final RelativepathexprContext relativepathexpr() throws RecognitionException {
RelativepathexprContext _localctx = new RelativepathexprContext(_ctx, getState());
enterRule(_localctx, 40, RULE_relativepathexpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(223);
stepexpr();
setState(228);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SLASH || _la==SS) {
{
{
setState(224);
_la = _input.LA(1);
if ( !(_la==SLASH || _la==SS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(225);
stepexpr();
}
}
setState(230);
_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;
}
public static class StepexprContext extends ParserRuleContext {
public PostfixexprContext postfixexpr() {
return getRuleContext(PostfixexprContext.class,0);
}
public AxisstepContext axisstep() {
return getRuleContext(AxisstepContext.class,0);
}
public StepexprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stepexpr; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitStepexpr(this);
else return visitor.visitChildren(this);
}
}
public final StepexprContext stepexpr() throws RecognitionException {
StepexprContext _localctx = new StepexprContext(_ctx, getState());
enterRule(_localctx, 42, RULE_stepexpr);
try {
setState(233);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(231);
postfixexpr();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(232);
axisstep();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AxisstepContext extends ParserRuleContext {
public PredicatelistContext predicatelist() {
return getRuleContext(PredicatelistContext.class,0);
}
public ReversestepContext reversestep() {
return getRuleContext(ReversestepContext.class,0);
}
public ForwardstepContext forwardstep() {
return getRuleContext(ForwardstepContext.class,0);
}
public AxisstepContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_axisstep; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitAxisstep(this);
else return visitor.visitChildren(this);
}
}
public final AxisstepContext axisstep() throws RecognitionException {
AxisstepContext _localctx = new AxisstepContext(_ctx, getState());
enterRule(_localctx, 44, RULE_axisstep);
try {
enterOuterAlt(_localctx, 1);
{
setState(237);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
{
setState(235);
reversestep();
}
break;
case 2:
{
setState(236);
forwardstep();
}
break;
}
setState(239);
predicatelist();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForwardstepContext extends ParserRuleContext {
public ForwardaxisContext forwardaxis() {
return getRuleContext(ForwardaxisContext.class,0);
}
public NametestContext nametest() {
return getRuleContext(NametestContext.class,0);
}
public AbbrevforwardstepContext abbrevforwardstep() {
return getRuleContext(AbbrevforwardstepContext.class,0);
}
public ForwardstepContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forwardstep; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitForwardstep(this);
else return visitor.visitChildren(this);
}
}
public final ForwardstepContext forwardstep() throws RecognitionException {
ForwardstepContext _localctx = new ForwardstepContext(_ctx, getState());
enterRule(_localctx, 46, RULE_forwardstep);
try {
setState(245);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
{
setState(241);
forwardaxis();
setState(242);
nametest();
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(244);
abbrevforwardstep();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForwardaxisContext extends ParserRuleContext {
public TerminalNode KW_CHILD() { return getToken(metapath10Parser.KW_CHILD, 0); }
public TerminalNode COLONCOLON() { return getToken(metapath10Parser.COLONCOLON, 0); }
public TerminalNode KW_DESCENDANT() { return getToken(metapath10Parser.KW_DESCENDANT, 0); }
public TerminalNode KW_SELF() { return getToken(metapath10Parser.KW_SELF, 0); }
public TerminalNode KW_DESCENDANT_OR_SELF() { return getToken(metapath10Parser.KW_DESCENDANT_OR_SELF, 0); }
public ForwardaxisContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forwardaxis; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitForwardaxis(this);
else return visitor.visitChildren(this);
}
}
public final ForwardaxisContext forwardaxis() throws RecognitionException {
ForwardaxisContext _localctx = new ForwardaxisContext(_ctx, getState());
enterRule(_localctx, 48, RULE_forwardaxis);
try {
setState(255);
_errHandler.sync(this);
switch (_input.LA(1)) {
case KW_CHILD:
enterOuterAlt(_localctx, 1);
{
{
setState(247);
match(KW_CHILD);
setState(248);
match(COLONCOLON);
}
}
break;
case KW_DESCENDANT:
enterOuterAlt(_localctx, 2);
{
{
setState(249);
match(KW_DESCENDANT);
setState(250);
match(COLONCOLON);
}
}
break;
case KW_SELF:
enterOuterAlt(_localctx, 3);
{
{
setState(251);
match(KW_SELF);
setState(252);
match(COLONCOLON);
}
}
break;
case KW_DESCENDANT_OR_SELF:
enterOuterAlt(_localctx, 4);
{
{
setState(253);
match(KW_DESCENDANT_OR_SELF);
setState(254);
match(COLONCOLON);
}
}
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 static class AbbrevforwardstepContext extends ParserRuleContext {
public NametestContext nametest() {
return getRuleContext(NametestContext.class,0);
}
public TerminalNode AT() { return getToken(metapath10Parser.AT, 0); }
public AbbrevforwardstepContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_abbrevforwardstep; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitAbbrevforwardstep(this);
else return visitor.visitChildren(this);
}
}
public final AbbrevforwardstepContext abbrevforwardstep() throws RecognitionException {
AbbrevforwardstepContext _localctx = new AbbrevforwardstepContext(_ctx, getState());
enterRule(_localctx, 50, RULE_abbrevforwardstep);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(258);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AT) {
{
setState(257);
match(AT);
}
}
setState(260);
nametest();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReversestepContext extends ParserRuleContext {
public ReverseaxisContext reverseaxis() {
return getRuleContext(ReverseaxisContext.class,0);
}
public NametestContext nametest() {
return getRuleContext(NametestContext.class,0);
}
public AbbrevreversestepContext abbrevreversestep() {
return getRuleContext(AbbrevreversestepContext.class,0);
}
public ReversestepContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_reversestep; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitReversestep(this);
else return visitor.visitChildren(this);
}
}
public final ReversestepContext reversestep() throws RecognitionException {
ReversestepContext _localctx = new ReversestepContext(_ctx, getState());
enterRule(_localctx, 52, RULE_reversestep);
try {
setState(266);
_errHandler.sync(this);
switch (_input.LA(1)) {
case KW_ANCESTOR:
case KW_ANCESTOR_OR_SELF:
case KW_PARENT:
enterOuterAlt(_localctx, 1);
{
{
setState(262);
reverseaxis();
setState(263);
nametest();
}
}
break;
case DD:
enterOuterAlt(_localctx, 2);
{
setState(265);
abbrevreversestep();
}
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 static class ReverseaxisContext extends ParserRuleContext {
public TerminalNode KW_PARENT() { return getToken(metapath10Parser.KW_PARENT, 0); }
public TerminalNode COLONCOLON() { return getToken(metapath10Parser.COLONCOLON, 0); }
public TerminalNode KW_ANCESTOR() { return getToken(metapath10Parser.KW_ANCESTOR, 0); }
public TerminalNode KW_ANCESTOR_OR_SELF() { return getToken(metapath10Parser.KW_ANCESTOR_OR_SELF, 0); }
public ReverseaxisContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_reverseaxis; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitReverseaxis(this);
else return visitor.visitChildren(this);
}
}
public final ReverseaxisContext reverseaxis() throws RecognitionException {
ReverseaxisContext _localctx = new ReverseaxisContext(_ctx, getState());
enterRule(_localctx, 54, RULE_reverseaxis);
try {
setState(274);
_errHandler.sync(this);
switch (_input.LA(1)) {
case KW_PARENT:
enterOuterAlt(_localctx, 1);
{
{
setState(268);
match(KW_PARENT);
setState(269);
match(COLONCOLON);
}
}
break;
case KW_ANCESTOR:
enterOuterAlt(_localctx, 2);
{
{
setState(270);
match(KW_ANCESTOR);
setState(271);
match(COLONCOLON);
}
}
break;
case KW_ANCESTOR_OR_SELF:
enterOuterAlt(_localctx, 3);
{
{
setState(272);
match(KW_ANCESTOR_OR_SELF);
setState(273);
match(COLONCOLON);
}
}
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 static class AbbrevreversestepContext extends ParserRuleContext {
public TerminalNode DD() { return getToken(metapath10Parser.DD, 0); }
public AbbrevreversestepContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_abbrevreversestep; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitAbbrevreversestep(this);
else return visitor.visitChildren(this);
}
}
public final AbbrevreversestepContext abbrevreversestep() throws RecognitionException {
AbbrevreversestepContext _localctx = new AbbrevreversestepContext(_ctx, getState());
enterRule(_localctx, 56, RULE_abbrevreversestep);
try {
enterOuterAlt(_localctx, 1);
{
setState(276);
match(DD);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NametestContext extends ParserRuleContext {
public EqnameContext eqname() {
return getRuleContext(EqnameContext.class,0);
}
public WildcardContext wildcard() {
return getRuleContext(WildcardContext.class,0);
}
public NametestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nametest; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitNametest(this);
else return visitor.visitChildren(this);
}
}
public final NametestContext nametest() throws RecognitionException {
NametestContext _localctx = new NametestContext(_ctx, getState());
enterRule(_localctx, 58, RULE_nametest);
try {
setState(280);
_errHandler.sync(this);
switch (_input.LA(1)) {
case KW_ANCESTOR:
case KW_ANCESTOR_OR_SELF:
case KW_AND:
case KW_CHILD:
case KW_DESCENDANT:
case KW_DESCENDANT_OR_SELF:
case KW_DIV:
case KW_EMPTY_SEQUENCE:
case KW_EQ:
case KW_EXCEPT:
case KW_GE:
case KW_GT:
case KW_IDIV:
case KW_INTERSECT:
case KW_LE:
case KW_LET:
case KW_LT:
case KW_MOD:
case KW_NE:
case KW_OR:
case KW_PARENT:
case KW_PRECEDING:
case KW_PRECEDING_SIBLING:
case KW_RETURN:
case KW_SELF:
case KW_UNION:
case LocalName:
enterOuterAlt(_localctx, 1);
{
setState(278);
eqname();
}
break;
case STAR:
enterOuterAlt(_localctx, 2);
{
setState(279);
wildcard();
}
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 static class WildcardContext extends ParserRuleContext {
public TerminalNode STAR() { return getToken(metapath10Parser.STAR, 0); }
public WildcardContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_wildcard; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitWildcard(this);
else return visitor.visitChildren(this);
}
}
public final WildcardContext wildcard() throws RecognitionException {
WildcardContext _localctx = new WildcardContext(_ctx, getState());
enterRule(_localctx, 60, RULE_wildcard);
try {
enterOuterAlt(_localctx, 1);
{
setState(282);
match(STAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PostfixexprContext extends ParserRuleContext {
public PrimaryexprContext primaryexpr() {
return getRuleContext(PrimaryexprContext.class,0);
}
public List<PredicateContext> predicate() {
return getRuleContexts(PredicateContext.class);
}
public PredicateContext predicate(int i) {
return getRuleContext(PredicateContext.class,i);
}
public PostfixexprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_postfixexpr; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitPostfixexpr(this);
else return visitor.visitChildren(this);
}
}
public final PostfixexprContext postfixexpr() throws RecognitionException {
PostfixexprContext _localctx = new PostfixexprContext(_ctx, getState());
enterRule(_localctx, 62, RULE_postfixexpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(284);
primaryexpr();
setState(288);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OB) {
{
{
setState(285);
predicate();
}
}
setState(290);
_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;
}
public static class ArgumentlistContext extends ParserRuleContext {
public TerminalNode OP() { return getToken(metapath10Parser.OP, 0); }
public TerminalNode CP() { return getToken(metapath10Parser.CP, 0); }
public List<ArgumentContext> argument() {
return getRuleContexts(ArgumentContext.class);
}
public ArgumentContext argument(int i) {
return getRuleContext(ArgumentContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(metapath10Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(metapath10Parser.COMMA, i);
}
public ArgumentlistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_argumentlist; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitArgumentlist(this);
else return visitor.visitChildren(this);
}
}
public final ArgumentlistContext argumentlist() throws RecognitionException {
ArgumentlistContext _localctx = new ArgumentlistContext(_ctx, getState());
enterRule(_localctx, 64, RULE_argumentlist);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(291);
match(OP);
setState(300);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
case 1:
{
setState(292);
argument();
setState(297);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(293);
match(COMMA);
setState(294);
argument();
}
}
setState(299);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
setState(302);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PredicatelistContext extends ParserRuleContext {
public List<PredicateContext> predicate() {
return getRuleContexts(PredicateContext.class);
}
public PredicateContext predicate(int i) {
return getRuleContext(PredicateContext.class,i);
}
public PredicatelistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_predicatelist; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitPredicatelist(this);
else return visitor.visitChildren(this);
}
}
public final PredicatelistContext predicatelist() throws RecognitionException {
PredicatelistContext _localctx = new PredicatelistContext(_ctx, getState());
enterRule(_localctx, 66, RULE_predicatelist);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(307);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OB) {
{
{
setState(304);
predicate();
}
}
setState(309);
_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;
}
public static class PredicateContext extends ParserRuleContext {
public TerminalNode OB() { return getToken(metapath10Parser.OB, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode CB() { return getToken(metapath10Parser.CB, 0); }
public PredicateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_predicate; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitPredicate(this);
else return visitor.visitChildren(this);
}
}
public final PredicateContext predicate() throws RecognitionException {
PredicateContext _localctx = new PredicateContext(_ctx, getState());
enterRule(_localctx, 68, RULE_predicate);
try {
enterOuterAlt(_localctx, 1);
{
setState(310);
match(OB);
setState(311);
expr();
setState(312);
match(CB);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArrowfunctionspecifierContext extends ParserRuleContext {
public EqnameContext eqname() {
return getRuleContext(EqnameContext.class,0);
}
public VarrefContext varref() {
return getRuleContext(VarrefContext.class,0);
}
public ParenthesizedexprContext parenthesizedexpr() {
return getRuleContext(ParenthesizedexprContext.class,0);
}
public ArrowfunctionspecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrowfunctionspecifier; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitArrowfunctionspecifier(this);
else return visitor.visitChildren(this);
}
}
public final ArrowfunctionspecifierContext arrowfunctionspecifier() throws RecognitionException {
ArrowfunctionspecifierContext _localctx = new ArrowfunctionspecifierContext(_ctx, getState());
enterRule(_localctx, 70, RULE_arrowfunctionspecifier);
try {
setState(317);
_errHandler.sync(this);
switch (_input.LA(1)) {
case KW_ANCESTOR:
case KW_ANCESTOR_OR_SELF:
case KW_AND:
case KW_CHILD:
case KW_DESCENDANT:
case KW_DESCENDANT_OR_SELF:
case KW_DIV:
case KW_EMPTY_SEQUENCE:
case KW_EQ:
case KW_EXCEPT:
case KW_GE:
case KW_GT:
case KW_IDIV:
case KW_INTERSECT:
case KW_LE:
case KW_LET:
case KW_LT:
case KW_MOD:
case KW_NE:
case KW_OR:
case KW_PARENT:
case KW_PRECEDING:
case KW_PRECEDING_SIBLING:
case KW_RETURN:
case KW_SELF:
case KW_UNION:
case LocalName:
enterOuterAlt(_localctx, 1);
{
setState(314);
eqname();
}
break;
case DOLLAR:
enterOuterAlt(_localctx, 2);
{
setState(315);
varref();
}
break;
case OP:
enterOuterAlt(_localctx, 3);
{
setState(316);
parenthesizedexpr();
}
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 static class PrimaryexprContext extends ParserRuleContext {
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public VarrefContext varref() {
return getRuleContext(VarrefContext.class,0);
}
public ParenthesizedexprContext parenthesizedexpr() {
return getRuleContext(ParenthesizedexprContext.class,0);
}
public ContextitemexprContext contextitemexpr() {
return getRuleContext(ContextitemexprContext.class,0);
}
public FunctioncallContext functioncall() {
return getRuleContext(FunctioncallContext.class,0);
}
public PrimaryexprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryexpr; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitPrimaryexpr(this);
else return visitor.visitChildren(this);
}
}
public final PrimaryexprContext primaryexpr() throws RecognitionException {
PrimaryexprContext _localctx = new PrimaryexprContext(_ctx, getState());
enterRule(_localctx, 72, RULE_primaryexpr);
try {
setState(324);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(319);
literal();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(320);
varref();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(321);
parenthesizedexpr();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(322);
contextitemexpr();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(323);
functioncall();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LiteralContext extends ParserRuleContext {
public NumericliteralContext numericliteral() {
return getRuleContext(NumericliteralContext.class,0);
}
public TerminalNode StringLiteral() { return getToken(metapath10Parser.StringLiteral, 0); }
public LiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literal; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitLiteral(this);
else return visitor.visitChildren(this);
}
}
public final LiteralContext literal() throws RecognitionException {
LiteralContext _localctx = new LiteralContext(_ctx, getState());
enterRule(_localctx, 74, RULE_literal);
try {
setState(328);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IntegerLiteral:
case DecimalLiteral:
case DoubleLiteral:
enterOuterAlt(_localctx, 1);
{
setState(326);
numericliteral();
}
break;
case StringLiteral:
enterOuterAlt(_localctx, 2);
{
setState(327);
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 static class NumericliteralContext extends ParserRuleContext {
public TerminalNode IntegerLiteral() { return getToken(metapath10Parser.IntegerLiteral, 0); }
public TerminalNode DecimalLiteral() { return getToken(metapath10Parser.DecimalLiteral, 0); }
public TerminalNode DoubleLiteral() { return getToken(metapath10Parser.DoubleLiteral, 0); }
public NumericliteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_numericliteral; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitNumericliteral(this);
else return visitor.visitChildren(this);
}
}
public final NumericliteralContext numericliteral() throws RecognitionException {
NumericliteralContext _localctx = new NumericliteralContext(_ctx, getState());
enterRule(_localctx, 76, RULE_numericliteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(330);
_la = _input.LA(1);
if ( !(((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (IntegerLiteral - 64)) | (1L << (DecimalLiteral - 64)) | (1L << (DoubleLiteral - 64)))) != 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;
}
public static class VarrefContext extends ParserRuleContext {
public TerminalNode DOLLAR() { return getToken(metapath10Parser.DOLLAR, 0); }
public VarnameContext varname() {
return getRuleContext(VarnameContext.class,0);
}
public VarrefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_varref; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitVarref(this);
else return visitor.visitChildren(this);
}
}
public final VarrefContext varref() throws RecognitionException {
VarrefContext _localctx = new VarrefContext(_ctx, getState());
enterRule(_localctx, 78, RULE_varref);
try {
enterOuterAlt(_localctx, 1);
{
setState(332);
match(DOLLAR);
setState(333);
varname();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VarnameContext extends ParserRuleContext {
public EqnameContext eqname() {
return getRuleContext(EqnameContext.class,0);
}
public VarnameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_varname; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitVarname(this);
else return visitor.visitChildren(this);
}
}
public final VarnameContext varname() throws RecognitionException {
VarnameContext _localctx = new VarnameContext(_ctx, getState());
enterRule(_localctx, 80, RULE_varname);
try {
enterOuterAlt(_localctx, 1);
{
setState(335);
eqname();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParenthesizedexprContext extends ParserRuleContext {
public TerminalNode OP() { return getToken(metapath10Parser.OP, 0); }
public TerminalNode CP() { return getToken(metapath10Parser.CP, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public ParenthesizedexprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parenthesizedexpr; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitParenthesizedexpr(this);
else return visitor.visitChildren(this);
}
}
public final ParenthesizedexprContext parenthesizedexpr() throws RecognitionException {
ParenthesizedexprContext _localctx = new ParenthesizedexprContext(_ctx, getState());
enterRule(_localctx, 82, RULE_parenthesizedexpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(337);
match(OP);
setState(339);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) {
case 1:
{
setState(338);
expr();
}
break;
}
setState(341);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ContextitemexprContext extends ParserRuleContext {
public TerminalNode D() { return getToken(metapath10Parser.D, 0); }
public ContextitemexprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_contextitemexpr; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitContextitemexpr(this);
else return visitor.visitChildren(this);
}
}
public final ContextitemexprContext contextitemexpr() throws RecognitionException {
ContextitemexprContext _localctx = new ContextitemexprContext(_ctx, getState());
enterRule(_localctx, 84, RULE_contextitemexpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(343);
match(D);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FunctioncallContext extends ParserRuleContext {
public EqnameContext eqname() {
return getRuleContext(EqnameContext.class,0);
}
public ArgumentlistContext argumentlist() {
return getRuleContext(ArgumentlistContext.class,0);
}
public FunctioncallContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functioncall; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitFunctioncall(this);
else return visitor.visitChildren(this);
}
}
public final FunctioncallContext functioncall() throws RecognitionException {
FunctioncallContext _localctx = new FunctioncallContext(_ctx, getState());
enterRule(_localctx, 86, RULE_functioncall);
try {
enterOuterAlt(_localctx, 1);
{
setState(345);
if (!( !(
getInputStream().LA(1)==KW_EMPTY_SEQUENCE
) )) throw new FailedPredicateException(this, " !(\n getInputStream().LA(1)==KW_EMPTY_SEQUENCE\n ) ");
setState(346);
eqname();
setState(347);
argumentlist();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArgumentContext extends ParserRuleContext {
public ExprsingleContext exprsingle() {
return getRuleContext(ExprsingleContext.class,0);
}
public ArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_argument; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitArgument(this);
else return visitor.visitChildren(this);
}
}
public final ArgumentContext argument() throws RecognitionException {
ArgumentContext _localctx = new ArgumentContext(_ctx, getState());
enterRule(_localctx, 88, RULE_argument);
try {
enterOuterAlt(_localctx, 1);
{
setState(349);
exprsingle();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EqnameContext extends ParserRuleContext {
public TerminalNode LocalName() { return getToken(metapath10Parser.LocalName, 0); }
public TerminalNode KW_ANCESTOR() { return getToken(metapath10Parser.KW_ANCESTOR, 0); }
public TerminalNode KW_ANCESTOR_OR_SELF() { return getToken(metapath10Parser.KW_ANCESTOR_OR_SELF, 0); }
public TerminalNode KW_AND() { return getToken(metapath10Parser.KW_AND, 0); }
public TerminalNode KW_CHILD() { return getToken(metapath10Parser.KW_CHILD, 0); }
public TerminalNode KW_DESCENDANT() { return getToken(metapath10Parser.KW_DESCENDANT, 0); }
public TerminalNode KW_DESCENDANT_OR_SELF() { return getToken(metapath10Parser.KW_DESCENDANT_OR_SELF, 0); }
public TerminalNode KW_DIV() { return getToken(metapath10Parser.KW_DIV, 0); }
public TerminalNode KW_EMPTY_SEQUENCE() { return getToken(metapath10Parser.KW_EMPTY_SEQUENCE, 0); }
public TerminalNode KW_EQ() { return getToken(metapath10Parser.KW_EQ, 0); }
public TerminalNode KW_EXCEPT() { return getToken(metapath10Parser.KW_EXCEPT, 0); }
public TerminalNode KW_GE() { return getToken(metapath10Parser.KW_GE, 0); }
public TerminalNode KW_GT() { return getToken(metapath10Parser.KW_GT, 0); }
public TerminalNode KW_IDIV() { return getToken(metapath10Parser.KW_IDIV, 0); }
public TerminalNode KW_INTERSECT() { return getToken(metapath10Parser.KW_INTERSECT, 0); }
public TerminalNode KW_LE() { return getToken(metapath10Parser.KW_LE, 0); }
public TerminalNode KW_LET() { return getToken(metapath10Parser.KW_LET, 0); }
public TerminalNode KW_LT() { return getToken(metapath10Parser.KW_LT, 0); }
public TerminalNode KW_MOD() { return getToken(metapath10Parser.KW_MOD, 0); }
public TerminalNode KW_NE() { return getToken(metapath10Parser.KW_NE, 0); }
public TerminalNode KW_OR() { return getToken(metapath10Parser.KW_OR, 0); }
public TerminalNode KW_PARENT() { return getToken(metapath10Parser.KW_PARENT, 0); }
public TerminalNode KW_PRECEDING() { return getToken(metapath10Parser.KW_PRECEDING, 0); }
public TerminalNode KW_PRECEDING_SIBLING() { return getToken(metapath10Parser.KW_PRECEDING_SIBLING, 0); }
public TerminalNode KW_RETURN() { return getToken(metapath10Parser.KW_RETURN, 0); }
public TerminalNode KW_SELF() { return getToken(metapath10Parser.KW_SELF, 0); }
public TerminalNode KW_UNION() { return getToken(metapath10Parser.KW_UNION, 0); }
public EqnameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_eqname; }
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof metapath10Visitor ) return ((metapath10Visitor<? extends T>)visitor).visitEqname(this);
else return visitor.visitChildren(this);
}
}
public final EqnameContext eqname() throws RecognitionException {
EqnameContext _localctx = new EqnameContext(_ctx, getState());
enterRule(_localctx, 90, RULE_eqname);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(351);
_la = _input.LA(1);
if ( !(((((_la - 36)) & ~0x3f) == 0 && ((1L << (_la - 36)) & ((1L << (KW_ANCESTOR - 36)) | (1L << (KW_ANCESTOR_OR_SELF - 36)) | (1L << (KW_AND - 36)) | (1L << (KW_CHILD - 36)) | (1L << (KW_DESCENDANT - 36)) | (1L << (KW_DESCENDANT_OR_SELF - 36)) | (1L << (KW_DIV - 36)) | (1L << (KW_EMPTY_SEQUENCE - 36)) | (1L << (KW_EQ - 36)) | (1L << (KW_EXCEPT - 36)) | (1L << (KW_GE - 36)) | (1L << (KW_GT - 36)) | (1L << (KW_IDIV - 36)) | (1L << (KW_INTERSECT - 36)) | (1L << (KW_LE - 36)) | (1L << (KW_LET - 36)) | (1L << (KW_LT - 36)) | (1L << (KW_MOD - 36)) | (1L << (KW_NE - 36)) | (1L << (KW_OR - 36)) | (1L << (KW_PARENT - 36)) | (1L << (KW_PRECEDING - 36)) | (1L << (KW_PRECEDING_SIBLING - 36)) | (1L << (KW_RETURN - 36)) | (1L << (KW_SELF - 36)) | (1L << (KW_UNION - 36)) | (1L << (LocalName - 36)))) != 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;
}
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 43:
return functioncall_sempred((FunctioncallContext)_localctx, predIndex);
}
return true;
}
private boolean functioncall_sempred(FunctioncallContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return !(
getInputStream().LA(1)==KW_EMPTY_SEQUENCE
) ;
}
return true;
}
public static final String _serializedATN =
"\u0004\u0001G\u0162\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\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007\"\u0002"+
"#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007\'\u0002"+
"(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007,\u0002"+
"-\u0007-\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001"+
"\u0001\u0005\u0001c\b\u0001\n\u0001\f\u0001f\t\u0001\u0001\u0002\u0001"+
"\u0002\u0003\u0002j\b\u0002\u0001\u0003\u0001\u0003\u0001\u0003\u0001"+
"\u0003\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0005\u0004t\b"+
"\u0004\n\u0004\f\u0004w\t\u0004\u0001\u0005\u0001\u0005\u0001\u0005\u0001"+
"\u0005\u0001\u0005\u0001\u0006\u0001\u0006\u0001\u0006\u0005\u0006\u0081"+
"\b\u0006\n\u0006\f\u0006\u0084\t\u0006\u0001\u0007\u0001\u0007\u0001\u0007"+
"\u0005\u0007\u0089\b\u0007\n\u0007\f\u0007\u008c\t\u0007\u0001\b\u0001"+
"\b\u0001\b\u0003\b\u0091\b\b\u0001\b\u0001\b\u0003\b\u0095\b\b\u0001\t"+
"\u0001\t\u0001\t\u0005\t\u009a\b\t\n\t\f\t\u009d\t\t\u0001\n\u0001\n\u0001"+
"\n\u0005\n\u00a2\b\n\n\n\f\n\u00a5\t\n\u0001\u000b\u0001\u000b\u0001\u000b"+
"\u0005\u000b\u00aa\b\u000b\n\u000b\f\u000b\u00ad\t\u000b\u0001\f\u0001"+
"\f\u0001\f\u0005\f\u00b2\b\f\n\f\f\f\u00b5\t\f\u0001\r\u0001\r\u0001\r"+
"\u0005\r\u00ba\b\r\n\r\f\r\u00bd\t\r\u0001\u000e\u0001\u000e\u0001\u000e"+
"\u0001\u000e\u0001\u000e\u0005\u000e\u00c4\b\u000e\n\u000e\f\u000e\u00c7"+
"\t\u000e\u0001\u000f\u0005\u000f\u00ca\b\u000f\n\u000f\f\u000f\u00cd\t"+
"\u000f\u0001\u000f\u0001\u000f\u0001\u0010\u0001\u0010\u0001\u0011\u0001"+
"\u0011\u0001\u0012\u0001\u0012\u0001\u0013\u0001\u0013\u0003\u0013\u00d9"+
"\b\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0003\u0013\u00de\b\u0013"+
"\u0001\u0014\u0001\u0014\u0001\u0014\u0005\u0014\u00e3\b\u0014\n\u0014"+
"\f\u0014\u00e6\t\u0014\u0001\u0015\u0001\u0015\u0003\u0015\u00ea\b\u0015"+
"\u0001\u0016\u0001\u0016\u0003\u0016\u00ee\b\u0016\u0001\u0016\u0001\u0016"+
"\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0003\u0017\u00f6\b\u0017"+
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
"\u0001\u0018\u0001\u0018\u0003\u0018\u0100\b\u0018\u0001\u0019\u0003\u0019"+
"\u0103\b\u0019\u0001\u0019\u0001\u0019\u0001\u001a\u0001\u001a\u0001\u001a"+
"\u0001\u001a\u0003\u001a\u010b\b\u001a\u0001\u001b\u0001\u001b\u0001\u001b"+
"\u0001\u001b\u0001\u001b\u0001\u001b\u0003\u001b\u0113\b\u001b\u0001\u001c"+
"\u0001\u001c\u0001\u001d\u0001\u001d\u0003\u001d\u0119\b\u001d\u0001\u001e"+
"\u0001\u001e\u0001\u001f\u0001\u001f\u0005\u001f\u011f\b\u001f\n\u001f"+
"\f\u001f\u0122\t\u001f\u0001 \u0001 \u0001 \u0001 \u0005 \u0128\b \n "+
"\f \u012b\t \u0003 \u012d\b \u0001 \u0001 \u0001!\u0005!\u0132\b!\n!\f"+
"!\u0135\t!\u0001\"\u0001\"\u0001\"\u0001\"\u0001#\u0001#\u0001#\u0003"+
"#\u013e\b#\u0001$\u0001$\u0001$\u0001$\u0001$\u0003$\u0145\b$\u0001%\u0001"+
"%\u0003%\u0149\b%\u0001&\u0001&\u0001\'\u0001\'\u0001\'\u0001(\u0001("+
"\u0001)\u0001)\u0003)\u0154\b)\u0001)\u0001)\u0001*\u0001*\u0001+\u0001"+
"+\u0001+\u0001+\u0001,\u0001,\u0001-\u0001-\u0001-\u0000\u0000.\u0000"+
"\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a\u001c"+
"\u001e \"$&(*,.02468:<>@BDFHJLNPRTVXZ\u0000\t\u0002\u0000\u0016\u0016"+
"\u001c\u001c\u0004\u0000##**2277\u0002\u0000\u001b\u001b??\u0002\u0000"+
"--33\u0004\u0000\u000f\u0010\u0012\u0013\u0015\u0015\u0017\u0017\u0005"+
"\u0000,,01446688\u0001\u0000!\"\u0001\u0000@B\u0003\u0000$-0?EE\u015c"+
"\u0000\\\u0001\u0000\u0000\u0000\u0002_\u0001\u0000\u0000\u0000\u0004"+
"i\u0001\u0000\u0000\u0000\u0006k\u0001\u0000\u0000\u0000\bo\u0001\u0000"+
"\u0000\u0000\nx\u0001\u0000\u0000\u0000\f}\u0001\u0000\u0000\u0000\u000e"+
"\u0085\u0001\u0000\u0000\u0000\u0010\u008d\u0001\u0000\u0000\u0000\u0012"+
"\u0096\u0001\u0000\u0000\u0000\u0014\u009e\u0001\u0000\u0000\u0000\u0016"+
"\u00a6\u0001\u0000\u0000\u0000\u0018\u00ae\u0001\u0000\u0000\u0000\u001a"+
"\u00b6\u0001\u0000\u0000\u0000\u001c\u00be\u0001\u0000\u0000\u0000\u001e"+
"\u00cb\u0001\u0000\u0000\u0000 \u00d0\u0001\u0000\u0000\u0000\"\u00d2"+
"\u0001\u0000\u0000\u0000$\u00d4\u0001\u0000\u0000\u0000&\u00dd\u0001\u0000"+
"\u0000\u0000(\u00df\u0001\u0000\u0000\u0000*\u00e9\u0001\u0000\u0000\u0000"+
",\u00ed\u0001\u0000\u0000\u0000.\u00f5\u0001\u0000\u0000\u00000\u00ff"+
"\u0001\u0000\u0000\u00002\u0102\u0001\u0000\u0000\u00004\u010a\u0001\u0000"+
"\u0000\u00006\u0112\u0001\u0000\u0000\u00008\u0114\u0001\u0000\u0000\u0000"+
":\u0118\u0001\u0000\u0000\u0000<\u011a\u0001\u0000\u0000\u0000>\u011c"+
"\u0001\u0000\u0000\u0000@\u0123\u0001\u0000\u0000\u0000B\u0133\u0001\u0000"+
"\u0000\u0000D\u0136\u0001\u0000\u0000\u0000F\u013d\u0001\u0000\u0000\u0000"+
"H\u0144\u0001\u0000\u0000\u0000J\u0148\u0001\u0000\u0000\u0000L\u014a"+
"\u0001\u0000\u0000\u0000N\u014c\u0001\u0000\u0000\u0000P\u014f\u0001\u0000"+
"\u0000\u0000R\u0151\u0001\u0000\u0000\u0000T\u0157\u0001\u0000\u0000\u0000"+
"V\u0159\u0001\u0000\u0000\u0000X\u015d\u0001\u0000\u0000\u0000Z\u015f"+
"\u0001\u0000\u0000\u0000\\]\u0003\u0002\u0001\u0000]^\u0005\u0000\u0000"+
"\u0001^\u0001\u0001\u0000\u0000\u0000_d\u0003\u0004\u0002\u0000`a\u0005"+
"\b\u0000\u0000ac\u0003\u0004\u0002\u0000b`\u0001\u0000\u0000\u0000cf\u0001"+
"\u0000\u0000\u0000db\u0001\u0000\u0000\u0000de\u0001\u0000\u0000\u0000"+
"e\u0003\u0001\u0000\u0000\u0000fd\u0001\u0000\u0000\u0000gj\u0003\u0006"+
"\u0003\u0000hj\u0003\f\u0006\u0000ig\u0001\u0000\u0000\u0000ih\u0001\u0000"+
"\u0000\u0000j\u0005\u0001\u0000\u0000\u0000kl\u0003\b\u0004\u0000lm\u0005"+
"=\u0000\u0000mn\u0003\u0004\u0002\u0000n\u0007\u0001\u0000\u0000\u0000"+
"op\u00055\u0000\u0000pu\u0003\n\u0005\u0000qr\u0005\b\u0000\u0000rt\u0003"+
"\n\u0005\u0000sq\u0001\u0000\u0000\u0000tw\u0001\u0000\u0000\u0000us\u0001"+
"\u0000\u0000\u0000uv\u0001\u0000\u0000\u0000v\t\u0001\u0000\u0000\u0000"+
"wu\u0001\u0000\u0000\u0000xy\u0005\r\u0000\u0000yz\u0003P(\u0000z{\u0005"+
"\u0005\u0000\u0000{|\u0003\u0004\u0002\u0000|\u000b\u0001\u0000\u0000"+
"\u0000}\u0082\u0003\u000e\u0007\u0000~\u007f\u00059\u0000\u0000\u007f"+
"\u0081\u0003\u000e\u0007\u0000\u0080~\u0001\u0000\u0000\u0000\u0081\u0084"+
"\u0001\u0000\u0000\u0000\u0082\u0080\u0001\u0000\u0000\u0000\u0082\u0083"+
"\u0001\u0000\u0000\u0000\u0083\r\u0001\u0000\u0000\u0000\u0084\u0082\u0001"+
"\u0000\u0000\u0000\u0085\u008a\u0003\u0010\b\u0000\u0086\u0087\u0005&"+
"\u0000\u0000\u0087\u0089\u0003\u0010\b\u0000\u0088\u0086\u0001\u0000\u0000"+
"\u0000\u0089\u008c\u0001\u0000\u0000\u0000\u008a\u0088\u0001\u0000\u0000"+
"\u0000\u008a\u008b\u0001\u0000\u0000\u0000\u008b\u000f\u0001\u0000\u0000"+
"\u0000\u008c\u008a\u0001\u0000\u0000\u0000\u008d\u0094\u0003\u0012\t\u0000"+
"\u008e\u0091\u0003$\u0012\u0000\u008f\u0091\u0003\"\u0011\u0000\u0090"+
"\u008e\u0001\u0000\u0000\u0000\u0090\u008f\u0001\u0000\u0000\u0000\u0091"+
"\u0092\u0001\u0000\u0000\u0000\u0092\u0093\u0003\u0012\t\u0000\u0093\u0095"+
"\u0001\u0000\u0000\u0000\u0094\u0090\u0001\u0000\u0000\u0000\u0094\u0095"+
"\u0001\u0000\u0000\u0000\u0095\u0011\u0001\u0000\u0000\u0000\u0096\u009b"+
"\u0003\u0014\n\u0000\u0097\u0098\u0005\u001e\u0000\u0000\u0098\u009a\u0003"+
"\u0014\n\u0000\u0099\u0097\u0001\u0000\u0000\u0000\u009a\u009d\u0001\u0000"+
"\u0000\u0000\u009b\u0099\u0001\u0000\u0000\u0000\u009b\u009c\u0001\u0000"+
"\u0000\u0000\u009c\u0013\u0001\u0000\u0000\u0000\u009d\u009b\u0001\u0000"+
"\u0000\u0000\u009e\u00a3\u0003\u0016\u000b\u0000\u009f\u00a0\u0007\u0000"+
"\u0000\u0000\u00a0\u00a2\u0003\u0016\u000b\u0000\u00a1\u009f\u0001\u0000"+
"\u0000\u0000\u00a2\u00a5\u0001\u0000\u0000\u0000\u00a3\u00a1\u0001\u0000"+
"\u0000\u0000\u00a3\u00a4\u0001\u0000\u0000\u0000\u00a4\u0015\u0001\u0000"+
"\u0000\u0000\u00a5\u00a3\u0001\u0000\u0000\u0000\u00a6\u00ab\u0003\u0018"+
"\f\u0000\u00a7\u00a8\u0007\u0001\u0000\u0000\u00a8\u00aa\u0003\u0018\f"+
"\u0000\u00a9\u00a7\u0001\u0000\u0000\u0000\u00aa\u00ad\u0001\u0000\u0000"+
"\u0000\u00ab\u00a9\u0001\u0000\u0000\u0000\u00ab\u00ac\u0001\u0000\u0000"+
"\u0000\u00ac\u0017\u0001\u0000\u0000\u0000\u00ad\u00ab\u0001\u0000\u0000"+
"\u0000\u00ae\u00b3\u0003\u001a\r\u0000\u00af\u00b0\u0007\u0002\u0000\u0000"+
"\u00b0\u00b2\u0003\u001a\r\u0000\u00b1\u00af\u0001\u0000\u0000\u0000\u00b2"+
"\u00b5\u0001\u0000\u0000\u0000\u00b3\u00b1\u0001\u0000\u0000\u0000\u00b3"+
"\u00b4\u0001\u0000\u0000\u0000\u00b4\u0019\u0001\u0000\u0000\u0000\u00b5"+
"\u00b3\u0001\u0000\u0000\u0000\u00b6\u00bb\u0003\u001c\u000e\u0000\u00b7"+
"\u00b8\u0007\u0003\u0000\u0000\u00b8\u00ba\u0003\u001c\u000e\u0000\u00b9"+
"\u00b7\u0001\u0000\u0000\u0000\u00ba\u00bd\u0001\u0000\u0000\u0000\u00bb"+
"\u00b9\u0001\u0000\u0000\u0000\u00bb\u00bc\u0001\u0000\u0000\u0000\u00bc"+
"\u001b\u0001\u0000\u0000\u0000\u00bd\u00bb\u0001\u0000\u0000\u0000\u00be"+
"\u00c5\u0003\u001e\u000f\u0000\u00bf\u00c0\u0005\u000e\u0000\u0000\u00c0"+
"\u00c1\u0003F#\u0000\u00c1\u00c2\u0003@ \u0000\u00c2\u00c4\u0001\u0000"+
"\u0000\u0000\u00c3\u00bf\u0001\u0000\u0000\u0000\u00c4\u00c7\u0001\u0000"+
"\u0000\u0000\u00c5\u00c3\u0001\u0000\u0000\u0000\u00c5\u00c6\u0001\u0000"+
"\u0000\u0000\u00c6\u001d\u0001\u0000\u0000\u0000\u00c7\u00c5\u0001\u0000"+
"\u0000\u0000\u00c8\u00ca\u0007\u0000\u0000\u0000\u00c9\u00c8\u0001\u0000"+
"\u0000\u0000\u00ca\u00cd\u0001\u0000\u0000\u0000\u00cb\u00c9\u0001\u0000"+
"\u0000\u0000\u00cb\u00cc\u0001\u0000\u0000\u0000\u00cc\u00ce\u0001\u0000"+
"\u0000\u0000\u00cd\u00cb\u0001\u0000\u0000\u0000\u00ce\u00cf\u0003 \u0010"+
"\u0000\u00cf\u001f\u0001\u0000\u0000\u0000\u00d0\u00d1\u0003&\u0013\u0000"+
"\u00d1!\u0001\u0000\u0000\u0000\u00d2\u00d3\u0007\u0004\u0000\u0000\u00d3"+
"#\u0001\u0000\u0000\u0000\u00d4\u00d5\u0007\u0005\u0000\u0000\u00d5%\u0001"+
"\u0000\u0000\u0000\u00d6\u00d8\u0005!\u0000\u0000\u00d7\u00d9\u0003(\u0014"+
"\u0000\u00d8\u00d7\u0001\u0000\u0000\u0000\u00d8\u00d9\u0001\u0000\u0000"+
"\u0000\u00d9\u00de\u0001\u0000\u0000\u0000\u00da\u00db\u0005\"\u0000\u0000"+
"\u00db\u00de\u0003(\u0014\u0000\u00dc\u00de\u0003(\u0014\u0000\u00dd\u00d6"+
"\u0001\u0000\u0000\u0000\u00dd\u00da\u0001\u0000\u0000\u0000\u00dd\u00dc"+
"\u0001\u0000\u0000\u0000\u00de\'\u0001\u0000\u0000\u0000\u00df\u00e4\u0003"+
"*\u0015\u0000\u00e0\u00e1\u0007\u0006\u0000\u0000\u00e1\u00e3\u0003*\u0015"+
"\u0000\u00e2\u00e0\u0001\u0000\u0000\u0000\u00e3\u00e6\u0001\u0000\u0000"+
"\u0000\u00e4\u00e2\u0001\u0000\u0000\u0000\u00e4\u00e5\u0001\u0000\u0000"+
"\u0000\u00e5)\u0001\u0000\u0000\u0000\u00e6\u00e4\u0001\u0000\u0000\u0000"+
"\u00e7\u00ea\u0003>\u001f\u0000\u00e8\u00ea\u0003,\u0016\u0000\u00e9\u00e7"+
"\u0001\u0000\u0000\u0000\u00e9\u00e8\u0001\u0000\u0000\u0000\u00ea+\u0001"+
"\u0000\u0000\u0000\u00eb\u00ee\u00034\u001a\u0000\u00ec\u00ee\u0003.\u0017"+
"\u0000\u00ed\u00eb\u0001\u0000\u0000\u0000\u00ed\u00ec\u0001\u0000\u0000"+
"\u0000\u00ee\u00ef\u0001\u0000\u0000\u0000\u00ef\u00f0\u0003B!\u0000\u00f0"+
"-\u0001\u0000\u0000\u0000\u00f1\u00f2\u00030\u0018\u0000\u00f2\u00f3\u0003"+
":\u001d\u0000\u00f3\u00f6\u0001\u0000\u0000\u0000\u00f4\u00f6\u00032\u0019"+
"\u0000\u00f5\u00f1\u0001\u0000\u0000\u0000\u00f5\u00f4\u0001\u0000\u0000"+
"\u0000\u00f6/\u0001\u0000\u0000\u0000\u00f7\u00f8\u0005\'\u0000\u0000"+
"\u00f8\u0100\u0005\u0007\u0000\u0000\u00f9\u00fa\u0005(\u0000\u0000\u00fa"+
"\u0100\u0005\u0007\u0000\u0000\u00fb\u00fc\u0005>\u0000\u0000\u00fc\u0100"+
"\u0005\u0007\u0000\u0000\u00fd\u00fe\u0005)\u0000\u0000\u00fe\u0100\u0005"+
"\u0007\u0000\u0000\u00ff\u00f7\u0001\u0000\u0000\u0000\u00ff\u00f9\u0001"+
"\u0000\u0000\u0000\u00ff\u00fb\u0001\u0000\u0000\u0000\u00ff\u00fd\u0001"+
"\u0000\u0000\u0000\u01001\u0001\u0000\u0000\u0000\u0101\u0103\u0005\u0001"+
"\u0000\u0000\u0102\u0101\u0001\u0000\u0000\u0000\u0102\u0103\u0001\u0000"+
"\u0000\u0000\u0103\u0104\u0001\u0000\u0000\u0000\u0104\u0105\u0003:\u001d"+
"\u0000\u01053\u0001\u0000\u0000\u0000\u0106\u0107\u00036\u001b\u0000\u0107"+
"\u0108\u0003:\u001d\u0000\u0108\u010b\u0001\u0000\u0000\u0000\u0109\u010b"+
"\u00038\u001c\u0000\u010a\u0106\u0001\u0000\u0000\u0000\u010a\u0109\u0001"+
"\u0000\u0000\u0000\u010b5\u0001\u0000\u0000\u0000\u010c\u010d\u0005:\u0000"+
"\u0000\u010d\u0113\u0005\u0007\u0000\u0000\u010e\u010f\u0005$\u0000\u0000"+
"\u010f\u0113\u0005\u0007\u0000\u0000\u0110\u0111\u0005%\u0000\u0000\u0111"+
"\u0113\u0005\u0007\u0000\u0000\u0112\u010c\u0001\u0000\u0000\u0000\u0112"+
"\u010e\u0001\u0000\u0000\u0000\u0112\u0110\u0001\u0000\u0000\u0000\u0113"+
"7\u0001\u0000\u0000\u0000\u0114\u0115\u0005\f\u0000\u0000\u01159\u0001"+
"\u0000\u0000\u0000\u0116\u0119\u0003Z-\u0000\u0117\u0119\u0003<\u001e"+
"\u0000\u0118\u0116\u0001\u0000\u0000\u0000\u0118\u0117\u0001\u0000\u0000"+
"\u0000\u0119;\u0001\u0000\u0000\u0000\u011a\u011b\u0005#\u0000\u0000\u011b"+
"=\u0001\u0000\u0000\u0000\u011c\u0120\u0003H$\u0000\u011d\u011f\u0003"+
"D\"\u0000\u011e\u011d\u0001\u0000\u0000\u0000\u011f\u0122\u0001\u0000"+
"\u0000\u0000\u0120\u011e\u0001\u0000\u0000\u0000\u0120\u0121\u0001\u0000"+
"\u0000\u0000\u0121?\u0001\u0000\u0000\u0000\u0122\u0120\u0001\u0000\u0000"+
"\u0000\u0123\u012c\u0005\u001a\u0000\u0000\u0124\u0129\u0003X,\u0000\u0125"+
"\u0126\u0005\b\u0000\u0000\u0126\u0128\u0003X,\u0000\u0127\u0125\u0001"+
"\u0000\u0000\u0000\u0128\u012b\u0001\u0000\u0000\u0000\u0129\u0127\u0001"+
"\u0000\u0000\u0000\u0129\u012a\u0001\u0000\u0000\u0000\u012a\u012d\u0001"+
"\u0000\u0000\u0000\u012b\u0129\u0001\u0000\u0000\u0000\u012c\u0124\u0001"+
"\u0000\u0000\u0000\u012c\u012d\u0001\u0000\u0000\u0000\u012d\u012e\u0001"+
"\u0000\u0000\u0000\u012e\u012f\u0005\t\u0000\u0000\u012fA\u0001\u0000"+
"\u0000\u0000\u0130\u0132\u0003D\"\u0000\u0131\u0130\u0001\u0000\u0000"+
"\u0000\u0132\u0135\u0001\u0000\u0000\u0000\u0133\u0131\u0001\u0000\u0000"+
"\u0000\u0133\u0134\u0001\u0000\u0000\u0000\u0134C\u0001\u0000\u0000\u0000"+
"\u0135\u0133\u0001\u0000\u0000\u0000\u0136\u0137\u0005\u0018\u0000\u0000"+
"\u0137\u0138\u0003\u0002\u0001\u0000\u0138\u0139\u0005\u0003\u0000\u0000"+
"\u0139E\u0001\u0000\u0000\u0000\u013a\u013e\u0003Z-\u0000\u013b\u013e"+
"\u0003N\'\u0000\u013c\u013e\u0003R)\u0000\u013d\u013a\u0001\u0000\u0000"+
"\u0000\u013d\u013b\u0001\u0000\u0000\u0000\u013d\u013c\u0001\u0000\u0000"+
"\u0000\u013eG\u0001\u0000\u0000\u0000\u013f\u0145\u0003J%\u0000\u0140"+
"\u0145\u0003N\'\u0000\u0141\u0145\u0003R)\u0000\u0142\u0145\u0003T*\u0000"+
"\u0143\u0145\u0003V+\u0000\u0144\u013f\u0001\u0000\u0000\u0000\u0144\u0140"+
"\u0001\u0000\u0000\u0000\u0144\u0141\u0001\u0000\u0000\u0000\u0144\u0142"+
"\u0001\u0000\u0000\u0000\u0144\u0143\u0001\u0000\u0000\u0000\u0145I\u0001"+
"\u0000\u0000\u0000\u0146\u0149\u0003L&\u0000\u0147\u0149\u0005C\u0000"+
"\u0000\u0148\u0146\u0001\u0000\u0000\u0000\u0148\u0147\u0001\u0000\u0000"+
"\u0000\u0149K\u0001\u0000\u0000\u0000\u014a\u014b\u0007\u0007\u0000\u0000"+
"\u014bM\u0001\u0000\u0000\u0000\u014c\u014d\u0005\r\u0000\u0000\u014d"+
"\u014e\u0003P(\u0000\u014eO\u0001\u0000\u0000\u0000\u014f\u0150\u0003"+
"Z-\u0000\u0150Q\u0001\u0000\u0000\u0000\u0151\u0153\u0005\u001a\u0000"+
"\u0000\u0152\u0154\u0003\u0002\u0001\u0000\u0153\u0152\u0001\u0000\u0000"+
"\u0000\u0153\u0154\u0001\u0000\u0000\u0000\u0154\u0155\u0001\u0000\u0000"+
"\u0000\u0155\u0156\u0005\t\u0000\u0000\u0156S\u0001\u0000\u0000\u0000"+
"\u0157\u0158\u0005\u000b\u0000\u0000\u0158U\u0001\u0000\u0000\u0000\u0159"+
"\u015a\u0004+\u0000\u0000\u015a\u015b\u0003Z-\u0000\u015b\u015c\u0003"+
"@ \u0000\u015cW\u0001\u0000\u0000\u0000\u015d\u015e\u0003\u0004\u0002"+
"\u0000\u015eY\u0001\u0000\u0000\u0000\u015f\u0160\u0007\b\u0000\u0000"+
"\u0160[\u0001\u0000\u0000\u0000!diu\u0082\u008a\u0090\u0094\u009b\u00a3"+
"\u00ab\u00b3\u00bb\u00c5\u00cb\u00d8\u00dd\u00e4\u00e9\u00ed\u00f5\u00ff"+
"\u0102\u010a\u0112\u0118\u0120\u0129\u012c\u0133\u013d\u0144\u0148\u0153";
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);
}
}
}