io.legaldocml.xpath.XPath2Parser Maven / Gradle / Ivy
// Generated from io\legaldocml\xpath\XPath2Parser.g4 by ANTLR 4.7
package io.legaldocml.xpath;
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 XPath2Parser extends Parser {
static { RuntimeMetaData.checkVersion("4.7", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
DIGITS=1, DECIMAL_LITERAL=2, DOUBLE_LITERAL=3, STRING_LITERAL=4, LBRACKET=5,
RBRACKET=6, LPAR=7, RPAR=8, PLUS=9, MINUS=10, STAR=11, PIPE=12, EQUALS=13,
NOTEQUALS=14, LESSTHAN=15, LESSEQUAL=16, GREATER=17, GREATEREQUAL=18,
LESS_LESS=19, GREATER_GREATER=20, FORWARD_SLASH=21, FORWARD_SLASHSLASH=22,
COLONCOLON=23, AT_SYM=24, DOTDOT=25, COLON=26, COMMA=27, DOLLAR=28, DOT=29,
QUESTIONMARK=30, CHILD=31, DESCENDANT=32, ATTRIBUTE=33, SELF=34, DESCENDANT_OR_SELF=35,
FOLLOWING_SIBLING=36, FOLLOWING=37, NAMESPACE=38, PARENT=39, ANCESTOR=40,
PRECEDING_SIBLING=41, PRECEDING=42, ANCESTOR_OR_SELF=43, EQ=44, NE=45,
LT=46, LE=47, GT=48, GE=49, IDIV=50, DIV=51, MOD=52, UNION=53, INTERSECT=54,
EXCEPT=55, INSTANCE=56, TREAT=57, CASTABLE=58, CAST=59, AS=60, OF=61,
IS=62, FOR=63, IN=64, RETURN=65, SATISFIES=66, TO=67, SOME=68, EVERY=69,
IF=70, THEN=71, ELSE=72, AND=73, OR=74, EMPTY_SEQUENCE=75, ITEM=76, NODE=77,
DOCUMENT_NODE=78, TEXT=79, COMMENT=80, PROCESSING_INSTRUCTION=81, SCHEMA_ATTRIBUTE=82,
ELEMENT=83, SCHEMA_ELEMENT=84, TYPESWITCH=85, STRING=86, INTEGER=87, DOUBLE=88,
DECIMAL=89, NCNAME=90;
public static final int
RULE_xPath = 0, RULE_expr = 1, RULE_exprSingle = 2, RULE_forExpr = 3,
RULE_simpleForClause = 4, RULE_quantifiedExpr = 5, RULE_quantifiedExprMiddle = 6,
RULE_ifExpr = 7, RULE_orExpr = 8, RULE_andExpr = 9, RULE_comparisonExpr = 10,
RULE_rangeExpr = 11, RULE_additiveExpr = 12, RULE_multiplicativeExpr = 13,
RULE_unionExpr = 14, RULE_intersectExceptExpr = 15, RULE_instanceOfExpr = 16,
RULE_treatExpr = 17, RULE_castableExpr = 18, RULE_castExpr = 19, RULE_unaryExpr = 20,
RULE_valueExpr = 21, RULE_generalComp = 22, RULE_valueComp = 23, RULE_nodeComp = 24,
RULE_pathExpr = 25, RULE_relativePathExpr = 26, RULE_stepExpr = 27, RULE_axisStep = 28,
RULE_forwardStep = 29, RULE_forwardAxis = 30, RULE_abbrevForwardStep = 31,
RULE_reverseStep = 32, RULE_reverseAxis = 33, RULE_abbrevReverseStep = 34,
RULE_nodeTest = 35, RULE_nameTest = 36, RULE_wildcard = 37, RULE_filterExpr = 38,
RULE_predicateList = 39, RULE_predicate = 40, RULE_primaryExpr = 41, RULE_literal = 42,
RULE_numericLiteral = 43, RULE_varRef = 44, RULE_varName = 45, RULE_parenthesizedExpr = 46,
RULE_contextItemExpr = 47, RULE_functionCall = 48, RULE_functionCallMiddle = 49,
RULE_singleType = 50, RULE_sequenceType = 51, RULE_occurrenceIndicator = 52,
RULE_itemType = 53, RULE_atomicType = 54, RULE_kindTest = 55, RULE_anyKindTest = 56,
RULE_documentTest = 57, RULE_textTest = 58, RULE_commentTest = 59, RULE_pITest = 60,
RULE_attributeTest = 61, RULE_attribNameOrWildcard = 62, RULE_schemaAttributeTest = 63,
RULE_attributeDeclaration = 64, RULE_elementTest = 65, RULE_elementNameOrWildcard = 66,
RULE_schemaElementTest = 67, RULE_elementDeclaration = 68, RULE_attributeName = 69,
RULE_elementName = 70, RULE_typeName = 71, RULE_integerLiteral = 72, RULE_decimalLiteral = 73,
RULE_doubleLiteral = 74, RULE_stringLiteral = 75, RULE_qName = 76, RULE_nCName = 77,
RULE_reservedFunctionNames = 78, RULE_reservedFunctionNCNames = 79;
public static final String[] ruleNames = {
"xPath", "expr", "exprSingle", "forExpr", "simpleForClause", "quantifiedExpr",
"quantifiedExprMiddle", "ifExpr", "orExpr", "andExpr", "comparisonExpr",
"rangeExpr", "additiveExpr", "multiplicativeExpr", "unionExpr", "intersectExceptExpr",
"instanceOfExpr", "treatExpr", "castableExpr", "castExpr", "unaryExpr",
"valueExpr", "generalComp", "valueComp", "nodeComp", "pathExpr", "relativePathExpr",
"stepExpr", "axisStep", "forwardStep", "forwardAxis", "abbrevForwardStep",
"reverseStep", "reverseAxis", "abbrevReverseStep", "nodeTest", "nameTest",
"wildcard", "filterExpr", "predicateList", "predicate", "primaryExpr",
"literal", "numericLiteral", "varRef", "varName", "parenthesizedExpr",
"contextItemExpr", "functionCall", "functionCallMiddle", "singleType",
"sequenceType", "occurrenceIndicator", "itemType", "atomicType", "kindTest",
"anyKindTest", "documentTest", "textTest", "commentTest", "pITest", "attributeTest",
"attribNameOrWildcard", "schemaAttributeTest", "attributeDeclaration",
"elementTest", "elementNameOrWildcard", "schemaElementTest", "elementDeclaration",
"attributeName", "elementName", "typeName", "integerLiteral", "decimalLiteral",
"doubleLiteral", "stringLiteral", "qName", "nCName", "reservedFunctionNames",
"reservedFunctionNCNames"
};
private static final String[] _LITERAL_NAMES = {
null, null, null, null, null, "'['", "']'", "'('", "')'", "'+'", "'-'",
"'*'", "'|'", "'='", "'!='", "'<'", "'<='", "'>'", "'>='", "'<<'", "'>>'",
"'/'", "'//'", "'::'", "'@'", "'..'", "':'", "','", "'$'", "'.'", "'?'",
"'child'", "'descendant'", "'attribute'", "'self'", "'descendant-or-self'",
"'following-sibling'", "'following'", "'namespace'", "'parent'", "'ancestor'",
"'preceding-sibling'", "'preceding'", "'ancestor-or-self'", "'eq'", "'ne'",
"'lt'", "'le'", "'gt'", "'ge'", "'idiv'", "'div'", "'mod'", "'union'",
"'intersect'", "'except'", "'instance'", "'treat'", "'castable'", "'cast'",
"'as'", "'of'", "'is'", "'for'", "'in'", "'return'", "'satisfies'", "'to'",
"'some'", "'every'", "'if'", "'then'", "'else'", "'and'", "'or'", "'empty-sequence'",
"'item'", "'node'", "'document-node'", "'text'", "'comment'", "'processing-instruction'",
"'schema-attribute'", "'element'", "'schema-element'", "'typeswitch'"
};
private static final String[] _SYMBOLIC_NAMES = {
null, "DIGITS", "DECIMAL_LITERAL", "DOUBLE_LITERAL", "STRING_LITERAL",
"LBRACKET", "RBRACKET", "LPAR", "RPAR", "PLUS", "MINUS", "STAR", "PIPE",
"EQUALS", "NOTEQUALS", "LESSTHAN", "LESSEQUAL", "GREATER", "GREATEREQUAL",
"LESS_LESS", "GREATER_GREATER", "FORWARD_SLASH", "FORWARD_SLASHSLASH",
"COLONCOLON", "AT_SYM", "DOTDOT", "COLON", "COMMA", "DOLLAR", "DOT", "QUESTIONMARK",
"CHILD", "DESCENDANT", "ATTRIBUTE", "SELF", "DESCENDANT_OR_SELF", "FOLLOWING_SIBLING",
"FOLLOWING", "NAMESPACE", "PARENT", "ANCESTOR", "PRECEDING_SIBLING", "PRECEDING",
"ANCESTOR_OR_SELF", "EQ", "NE", "LT", "LE", "GT", "GE", "IDIV", "DIV",
"MOD", "UNION", "INTERSECT", "EXCEPT", "INSTANCE", "TREAT", "CASTABLE",
"CAST", "AS", "OF", "IS", "FOR", "IN", "RETURN", "SATISFIES", "TO", "SOME",
"EVERY", "IF", "THEN", "ELSE", "AND", "OR", "EMPTY_SEQUENCE", "ITEM",
"NODE", "DOCUMENT_NODE", "TEXT", "COMMENT", "PROCESSING_INSTRUCTION",
"SCHEMA_ATTRIBUTE", "ELEMENT", "SCHEMA_ELEMENT", "TYPESWITCH", "STRING",
"INTEGER", "DOUBLE", "DECIMAL", "NCNAME"
};
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "XPath2Parser.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public XPath2Parser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class XPathContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode EOF() { return getToken(XPath2Parser.EOF, 0); }
public XPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_xPath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterXPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitXPath(this);
}
}
public final XPathContext xPath() throws RecognitionException {
XPathContext _localctx = new XPathContext(_ctx, getState());
enterRule(_localctx, 0, RULE_xPath);
try {
enterOuterAlt(_localctx, 1);
{
setState(160);
expr();
setState(161);
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 exprSingle() {
return getRuleContexts(ExprSingleContext.class);
}
public ExprSingleContext exprSingle(int i) {
return getRuleContext(ExprSingleContext.class,i);
}
public List COMMA() { return getTokens(XPath2Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(XPath2Parser.COMMA, i);
}
public ExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitExpr(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(163);
exprSingle();
setState(168);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(164);
match(COMMA);
setState(165);
exprSingle();
}
}
setState(170);
_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 ForExprContext forExpr() {
return getRuleContext(ForExprContext.class,0);
}
public QuantifiedExprContext quantifiedExpr() {
return getRuleContext(QuantifiedExprContext.class,0);
}
public IfExprContext ifExpr() {
return getRuleContext(IfExprContext.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 void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterExprSingle(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitExprSingle(this);
}
}
public final ExprSingleContext exprSingle() throws RecognitionException {
ExprSingleContext _localctx = new ExprSingleContext(_ctx, getState());
enterRule(_localctx, 4, RULE_exprSingle);
try {
setState(175);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(171);
forExpr();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(172);
quantifiedExpr();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(173);
ifExpr();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(174);
orExpr(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForExprContext extends ParserRuleContext {
public SimpleForClauseContext simpleForClause() {
return getRuleContext(SimpleForClauseContext.class,0);
}
public TerminalNode RETURN() { return getToken(XPath2Parser.RETURN, 0); }
public ExprSingleContext exprSingle() {
return getRuleContext(ExprSingleContext.class,0);
}
public ForExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterForExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitForExpr(this);
}
}
public final ForExprContext forExpr() throws RecognitionException {
ForExprContext _localctx = new ForExprContext(_ctx, getState());
enterRule(_localctx, 6, RULE_forExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(177);
simpleForClause(0);
setState(178);
match(RETURN);
setState(179);
exprSingle();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SimpleForClauseContext extends ParserRuleContext {
public TerminalNode FOR() { return getToken(XPath2Parser.FOR, 0); }
public TerminalNode DOLLAR() { return getToken(XPath2Parser.DOLLAR, 0); }
public VarNameContext varName() {
return getRuleContext(VarNameContext.class,0);
}
public TerminalNode IN() { return getToken(XPath2Parser.IN, 0); }
public ExprSingleContext exprSingle() {
return getRuleContext(ExprSingleContext.class,0);
}
public SimpleForClauseContext simpleForClause() {
return getRuleContext(SimpleForClauseContext.class,0);
}
public TerminalNode COMMA() { return getToken(XPath2Parser.COMMA, 0); }
public SimpleForClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleForClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterSimpleForClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitSimpleForClause(this);
}
}
public final SimpleForClauseContext simpleForClause() throws RecognitionException {
return simpleForClause(0);
}
private SimpleForClauseContext simpleForClause(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
SimpleForClauseContext _localctx = new SimpleForClauseContext(_ctx, _parentState);
SimpleForClauseContext _prevctx = _localctx;
int _startState = 8;
enterRecursionRule(_localctx, 8, RULE_simpleForClause, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(182);
match(FOR);
setState(183);
match(DOLLAR);
setState(184);
varName();
setState(185);
match(IN);
setState(186);
exprSingle();
}
_ctx.stop = _input.LT(-1);
setState(197);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new SimpleForClauseContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_simpleForClause);
setState(188);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(189);
match(COMMA);
setState(190);
match(DOLLAR);
setState(191);
varName();
setState(192);
match(IN);
setState(193);
exprSingle();
}
}
}
setState(199);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class QuantifiedExprContext extends ParserRuleContext {
public TerminalNode SOME() { return getToken(XPath2Parser.SOME, 0); }
public TerminalNode DOLLAR() { return getToken(XPath2Parser.DOLLAR, 0); }
public QuantifiedExprMiddleContext quantifiedExprMiddle() {
return getRuleContext(QuantifiedExprMiddleContext.class,0);
}
public TerminalNode SATISFIES() { return getToken(XPath2Parser.SATISFIES, 0); }
public ExprSingleContext exprSingle() {
return getRuleContext(ExprSingleContext.class,0);
}
public TerminalNode EVERY() { return getToken(XPath2Parser.EVERY, 0); }
public QuantifiedExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_quantifiedExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterQuantifiedExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitQuantifiedExpr(this);
}
}
public final QuantifiedExprContext quantifiedExpr() throws RecognitionException {
QuantifiedExprContext _localctx = new QuantifiedExprContext(_ctx, getState());
enterRule(_localctx, 10, RULE_quantifiedExpr);
try {
setState(212);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SOME:
enterOuterAlt(_localctx, 1);
{
setState(200);
match(SOME);
setState(201);
match(DOLLAR);
setState(202);
quantifiedExprMiddle(0);
setState(203);
match(SATISFIES);
setState(204);
exprSingle();
}
break;
case EVERY:
enterOuterAlt(_localctx, 2);
{
setState(206);
match(EVERY);
setState(207);
match(DOLLAR);
setState(208);
quantifiedExprMiddle(0);
setState(209);
match(SATISFIES);
setState(210);
exprSingle();
}
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 QuantifiedExprMiddleContext extends ParserRuleContext {
public VarNameContext varName() {
return getRuleContext(VarNameContext.class,0);
}
public TerminalNode IN() { return getToken(XPath2Parser.IN, 0); }
public ExprSingleContext exprSingle() {
return getRuleContext(ExprSingleContext.class,0);
}
public QuantifiedExprMiddleContext quantifiedExprMiddle() {
return getRuleContext(QuantifiedExprMiddleContext.class,0);
}
public TerminalNode COMMA() { return getToken(XPath2Parser.COMMA, 0); }
public TerminalNode DOLLAR() { return getToken(XPath2Parser.DOLLAR, 0); }
public QuantifiedExprMiddleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_quantifiedExprMiddle; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterQuantifiedExprMiddle(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitQuantifiedExprMiddle(this);
}
}
public final QuantifiedExprMiddleContext quantifiedExprMiddle() throws RecognitionException {
return quantifiedExprMiddle(0);
}
private QuantifiedExprMiddleContext quantifiedExprMiddle(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
QuantifiedExprMiddleContext _localctx = new QuantifiedExprMiddleContext(_ctx, _parentState);
QuantifiedExprMiddleContext _prevctx = _localctx;
int _startState = 12;
enterRecursionRule(_localctx, 12, RULE_quantifiedExprMiddle, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(215);
varName();
setState(216);
match(IN);
setState(217);
exprSingle();
}
_ctx.stop = _input.LT(-1);
setState(228);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new QuantifiedExprMiddleContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_quantifiedExprMiddle);
setState(219);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(220);
match(COMMA);
setState(221);
match(DOLLAR);
setState(222);
varName();
setState(223);
match(IN);
setState(224);
exprSingle();
}
}
}
setState(230);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class IfExprContext extends ParserRuleContext {
public TerminalNode IF() { return getToken(XPath2Parser.IF, 0); }
public TerminalNode LPAR() { return getToken(XPath2Parser.LPAR, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode RPAR() { return getToken(XPath2Parser.RPAR, 0); }
public TerminalNode THEN() { return getToken(XPath2Parser.THEN, 0); }
public List exprSingle() {
return getRuleContexts(ExprSingleContext.class);
}
public ExprSingleContext exprSingle(int i) {
return getRuleContext(ExprSingleContext.class,i);
}
public TerminalNode ELSE() { return getToken(XPath2Parser.ELSE, 0); }
public IfExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ifExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterIfExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitIfExpr(this);
}
}
public final IfExprContext ifExpr() throws RecognitionException {
IfExprContext _localctx = new IfExprContext(_ctx, getState());
enterRule(_localctx, 14, RULE_ifExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(231);
match(IF);
setState(232);
match(LPAR);
setState(233);
expr();
setState(234);
match(RPAR);
setState(235);
match(THEN);
setState(236);
exprSingle();
setState(237);
match(ELSE);
setState(238);
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 AndExprContext andExpr() {
return getRuleContext(AndExprContext.class,0);
}
public OrExprContext orExpr() {
return getRuleContext(OrExprContext.class,0);
}
public TerminalNode OR() { return getToken(XPath2Parser.OR, 0); }
public OrExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterOrExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitOrExpr(this);
}
}
public final OrExprContext orExpr() throws RecognitionException {
return orExpr(0);
}
private OrExprContext orExpr(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
OrExprContext _localctx = new OrExprContext(_ctx, _parentState);
OrExprContext _prevctx = _localctx;
int _startState = 16;
enterRecursionRule(_localctx, 16, RULE_orExpr, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(241);
andExpr(0);
}
_ctx.stop = _input.LT(-1);
setState(248);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new OrExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_orExpr);
setState(243);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(244);
match(OR);
setState(245);
andExpr(0);
}
}
}
setState(250);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class AndExprContext extends ParserRuleContext {
public ComparisonExprContext comparisonExpr() {
return getRuleContext(ComparisonExprContext.class,0);
}
public AndExprContext andExpr() {
return getRuleContext(AndExprContext.class,0);
}
public TerminalNode AND() { return getToken(XPath2Parser.AND, 0); }
public AndExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_andExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterAndExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitAndExpr(this);
}
}
public final AndExprContext andExpr() throws RecognitionException {
return andExpr(0);
}
private AndExprContext andExpr(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
AndExprContext _localctx = new AndExprContext(_ctx, _parentState);
AndExprContext _prevctx = _localctx;
int _startState = 18;
enterRecursionRule(_localctx, 18, RULE_andExpr, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(252);
comparisonExpr();
}
_ctx.stop = _input.LT(-1);
setState(259);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,6,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new AndExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_andExpr);
setState(254);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(255);
match(AND);
setState(256);
comparisonExpr();
}
}
}
setState(261);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,6,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class ComparisonExprContext extends ParserRuleContext {
public List rangeExpr() {
return getRuleContexts(RangeExprContext.class);
}
public RangeExprContext rangeExpr(int i) {
return getRuleContext(RangeExprContext.class,i);
}
public ValueCompContext valueComp() {
return getRuleContext(ValueCompContext.class,0);
}
public GeneralCompContext generalComp() {
return getRuleContext(GeneralCompContext.class,0);
}
public NodeCompContext nodeComp() {
return getRuleContext(NodeCompContext.class,0);
}
public ComparisonExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comparisonExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterComparisonExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitComparisonExpr(this);
}
}
public final ComparisonExprContext comparisonExpr() throws RecognitionException {
ComparisonExprContext _localctx = new ComparisonExprContext(_ctx, getState());
enterRule(_localctx, 20, RULE_comparisonExpr);
try {
setState(275);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(262);
rangeExpr();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(263);
rangeExpr();
setState(264);
valueComp();
setState(265);
rangeExpr();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(267);
rangeExpr();
setState(268);
generalComp();
setState(269);
rangeExpr();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(271);
rangeExpr();
setState(272);
nodeComp();
setState(273);
rangeExpr();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RangeExprContext extends ParserRuleContext {
public List additiveExpr() {
return getRuleContexts(AdditiveExprContext.class);
}
public AdditiveExprContext additiveExpr(int i) {
return getRuleContext(AdditiveExprContext.class,i);
}
public TerminalNode TO() { return getToken(XPath2Parser.TO, 0); }
public RangeExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rangeExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterRangeExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitRangeExpr(this);
}
}
public final RangeExprContext rangeExpr() throws RecognitionException {
RangeExprContext _localctx = new RangeExprContext(_ctx, getState());
enterRule(_localctx, 22, RULE_rangeExpr);
try {
setState(282);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(277);
additiveExpr(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(278);
additiveExpr(0);
setState(279);
match(TO);
setState(280);
additiveExpr(0);
}
break;
}
}
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 MultiplicativeExprContext multiplicativeExpr() {
return getRuleContext(MultiplicativeExprContext.class,0);
}
public AdditiveExprContext additiveExpr() {
return getRuleContext(AdditiveExprContext.class,0);
}
public TerminalNode PLUS() { return getToken(XPath2Parser.PLUS, 0); }
public TerminalNode MINUS() { return getToken(XPath2Parser.MINUS, 0); }
public AdditiveExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_additiveExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterAdditiveExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitAdditiveExpr(this);
}
}
public final AdditiveExprContext additiveExpr() throws RecognitionException {
return additiveExpr(0);
}
private AdditiveExprContext additiveExpr(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
AdditiveExprContext _localctx = new AdditiveExprContext(_ctx, _parentState);
AdditiveExprContext _prevctx = _localctx;
int _startState = 24;
enterRecursionRule(_localctx, 24, RULE_additiveExpr, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(285);
multiplicativeExpr(0);
}
_ctx.stop = _input.LT(-1);
setState(295);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,10,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(293);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
case 1:
{
_localctx = new AdditiveExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_additiveExpr);
setState(287);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(288);
match(PLUS);
setState(289);
multiplicativeExpr(0);
}
break;
case 2:
{
_localctx = new AdditiveExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_additiveExpr);
setState(290);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(291);
match(MINUS);
setState(292);
multiplicativeExpr(0);
}
break;
}
}
}
setState(297);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,10,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class MultiplicativeExprContext extends ParserRuleContext {
public UnionExprContext unionExpr() {
return getRuleContext(UnionExprContext.class,0);
}
public MultiplicativeExprContext multiplicativeExpr() {
return getRuleContext(MultiplicativeExprContext.class,0);
}
public TerminalNode STAR() { return getToken(XPath2Parser.STAR, 0); }
public TerminalNode DIV() { return getToken(XPath2Parser.DIV, 0); }
public TerminalNode IDIV() { return getToken(XPath2Parser.IDIV, 0); }
public TerminalNode MOD() { return getToken(XPath2Parser.MOD, 0); }
public MultiplicativeExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiplicativeExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterMultiplicativeExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitMultiplicativeExpr(this);
}
}
public final MultiplicativeExprContext multiplicativeExpr() throws RecognitionException {
return multiplicativeExpr(0);
}
private MultiplicativeExprContext multiplicativeExpr(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
MultiplicativeExprContext _localctx = new MultiplicativeExprContext(_ctx, _parentState);
MultiplicativeExprContext _prevctx = _localctx;
int _startState = 26;
enterRecursionRule(_localctx, 26, RULE_multiplicativeExpr, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(299);
unionExpr(0);
}
_ctx.stop = _input.LT(-1);
setState(315);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(313);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
{
_localctx = new MultiplicativeExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpr);
setState(301);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(302);
match(STAR);
setState(303);
unionExpr(0);
}
break;
case 2:
{
_localctx = new MultiplicativeExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpr);
setState(304);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(305);
match(DIV);
setState(306);
unionExpr(0);
}
break;
case 3:
{
_localctx = new MultiplicativeExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpr);
setState(307);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(308);
match(IDIV);
setState(309);
unionExpr(0);
}
break;
case 4:
{
_localctx = new MultiplicativeExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpr);
setState(310);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(311);
match(MOD);
setState(312);
unionExpr(0);
}
break;
}
}
}
setState(317);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class UnionExprContext extends ParserRuleContext {
public IntersectExceptExprContext intersectExceptExpr() {
return getRuleContext(IntersectExceptExprContext.class,0);
}
public UnionExprContext unionExpr() {
return getRuleContext(UnionExprContext.class,0);
}
public TerminalNode UNION() { return getToken(XPath2Parser.UNION, 0); }
public TerminalNode PIPE() { return getToken(XPath2Parser.PIPE, 0); }
public UnionExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unionExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterUnionExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitUnionExpr(this);
}
}
public final UnionExprContext unionExpr() throws RecognitionException {
return unionExpr(0);
}
private UnionExprContext unionExpr(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
UnionExprContext _localctx = new UnionExprContext(_ctx, _parentState);
UnionExprContext _prevctx = _localctx;
int _startState = 28;
enterRecursionRule(_localctx, 28, RULE_unionExpr, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(319);
intersectExceptExpr(0);
}
_ctx.stop = _input.LT(-1);
setState(329);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(327);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
case 1:
{
_localctx = new UnionExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_unionExpr);
setState(321);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(322);
match(UNION);
setState(323);
intersectExceptExpr(0);
}
break;
case 2:
{
_localctx = new UnionExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_unionExpr);
setState(324);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(325);
match(PIPE);
setState(326);
intersectExceptExpr(0);
}
break;
}
}
}
setState(331);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class IntersectExceptExprContext extends ParserRuleContext {
public InstanceOfExprContext instanceOfExpr() {
return getRuleContext(InstanceOfExprContext.class,0);
}
public IntersectExceptExprContext intersectExceptExpr() {
return getRuleContext(IntersectExceptExprContext.class,0);
}
public TerminalNode INTERSECT() { return getToken(XPath2Parser.INTERSECT, 0); }
public TerminalNode EXCEPT() { return getToken(XPath2Parser.EXCEPT, 0); }
public IntersectExceptExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_intersectExceptExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterIntersectExceptExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitIntersectExceptExpr(this);
}
}
public final IntersectExceptExprContext intersectExceptExpr() throws RecognitionException {
return intersectExceptExpr(0);
}
private IntersectExceptExprContext intersectExceptExpr(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
IntersectExceptExprContext _localctx = new IntersectExceptExprContext(_ctx, _parentState);
IntersectExceptExprContext _prevctx = _localctx;
int _startState = 30;
enterRecursionRule(_localctx, 30, RULE_intersectExceptExpr, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(333);
instanceOfExpr();
}
_ctx.stop = _input.LT(-1);
setState(343);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,16,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(341);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
case 1:
{
_localctx = new IntersectExceptExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_intersectExceptExpr);
setState(335);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(336);
match(INTERSECT);
setState(337);
instanceOfExpr();
}
break;
case 2:
{
_localctx = new IntersectExceptExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_intersectExceptExpr);
setState(338);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(339);
match(EXCEPT);
setState(340);
instanceOfExpr();
}
break;
}
}
}
setState(345);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,16,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class InstanceOfExprContext extends ParserRuleContext {
public TreatExprContext treatExpr() {
return getRuleContext(TreatExprContext.class,0);
}
public TerminalNode INSTANCE() { return getToken(XPath2Parser.INSTANCE, 0); }
public TerminalNode OF() { return getToken(XPath2Parser.OF, 0); }
public SequenceTypeContext sequenceType() {
return getRuleContext(SequenceTypeContext.class,0);
}
public InstanceOfExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_instanceOfExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterInstanceOfExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitInstanceOfExpr(this);
}
}
public final InstanceOfExprContext instanceOfExpr() throws RecognitionException {
InstanceOfExprContext _localctx = new InstanceOfExprContext(_ctx, getState());
enterRule(_localctx, 32, RULE_instanceOfExpr);
try {
setState(352);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(346);
treatExpr();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(347);
treatExpr();
setState(348);
match(INSTANCE);
setState(349);
match(OF);
setState(350);
sequenceType();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TreatExprContext extends ParserRuleContext {
public CastableExprContext castableExpr() {
return getRuleContext(CastableExprContext.class,0);
}
public TerminalNode TREAT() { return getToken(XPath2Parser.TREAT, 0); }
public TerminalNode AS() { return getToken(XPath2Parser.AS, 0); }
public SequenceTypeContext sequenceType() {
return getRuleContext(SequenceTypeContext.class,0);
}
public TreatExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_treatExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterTreatExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitTreatExpr(this);
}
}
public final TreatExprContext treatExpr() throws RecognitionException {
TreatExprContext _localctx = new TreatExprContext(_ctx, getState());
enterRule(_localctx, 34, RULE_treatExpr);
try {
setState(360);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(354);
castableExpr();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(355);
castableExpr();
setState(356);
match(TREAT);
setState(357);
match(AS);
setState(358);
sequenceType();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CastableExprContext extends ParserRuleContext {
public CastExprContext castExpr() {
return getRuleContext(CastExprContext.class,0);
}
public TerminalNode CASTABLE() { return getToken(XPath2Parser.CASTABLE, 0); }
public TerminalNode AS() { return getToken(XPath2Parser.AS, 0); }
public SingleTypeContext singleType() {
return getRuleContext(SingleTypeContext.class,0);
}
public CastableExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_castableExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterCastableExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitCastableExpr(this);
}
}
public final CastableExprContext castableExpr() throws RecognitionException {
CastableExprContext _localctx = new CastableExprContext(_ctx, getState());
enterRule(_localctx, 36, RULE_castableExpr);
try {
setState(368);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(362);
castExpr();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(363);
castExpr();
setState(364);
match(CASTABLE);
setState(365);
match(AS);
setState(366);
singleType();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CastExprContext extends ParserRuleContext {
public UnaryExprContext unaryExpr() {
return getRuleContext(UnaryExprContext.class,0);
}
public TerminalNode CAST() { return getToken(XPath2Parser.CAST, 0); }
public TerminalNode AS() { return getToken(XPath2Parser.AS, 0); }
public SingleTypeContext singleType() {
return getRuleContext(SingleTypeContext.class,0);
}
public CastExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_castExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterCastExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitCastExpr(this);
}
}
public final CastExprContext castExpr() throws RecognitionException {
CastExprContext _localctx = new CastExprContext(_ctx, getState());
enterRule(_localctx, 38, RULE_castExpr);
try {
setState(376);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(370);
unaryExpr();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(371);
unaryExpr();
setState(372);
match(CAST);
setState(373);
match(AS);
setState(374);
singleType();
}
break;
}
}
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 TerminalNode MINUS() { return getToken(XPath2Parser.MINUS, 0); }
public UnaryExprContext unaryExpr() {
return getRuleContext(UnaryExprContext.class,0);
}
public TerminalNode PLUS() { return getToken(XPath2Parser.PLUS, 0); }
public UnaryExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unaryExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterUnaryExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitUnaryExpr(this);
}
}
public final UnaryExprContext unaryExpr() throws RecognitionException {
UnaryExprContext _localctx = new UnaryExprContext(_ctx, getState());
enterRule(_localctx, 40, RULE_unaryExpr);
try {
setState(383);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DIGITS:
case DECIMAL_LITERAL:
case DOUBLE_LITERAL:
case STRING_LITERAL:
case LPAR:
case STAR:
case FORWARD_SLASH:
case FORWARD_SLASHSLASH:
case AT_SYM:
case DOTDOT:
case DOLLAR:
case DOT:
case CHILD:
case DESCENDANT:
case ATTRIBUTE:
case SELF:
case DESCENDANT_OR_SELF:
case FOLLOWING_SIBLING:
case FOLLOWING:
case NAMESPACE:
case PARENT:
case ANCESTOR:
case PRECEDING_SIBLING:
case PRECEDING:
case ANCESTOR_OR_SELF:
case EQ:
case NE:
case LT:
case LE:
case GT:
case GE:
case IDIV:
case DIV:
case MOD:
case UNION:
case INTERSECT:
case EXCEPT:
case INSTANCE:
case TREAT:
case CASTABLE:
case CAST:
case AS:
case OF:
case IS:
case FOR:
case IN:
case RETURN:
case SATISFIES:
case TO:
case SOME:
case EVERY:
case IF:
case THEN:
case ELSE:
case AND:
case OR:
case EMPTY_SEQUENCE:
case ITEM:
case NODE:
case DOCUMENT_NODE:
case TEXT:
case COMMENT:
case PROCESSING_INSTRUCTION:
case SCHEMA_ATTRIBUTE:
case ELEMENT:
case SCHEMA_ELEMENT:
case TYPESWITCH:
case NCNAME:
enterOuterAlt(_localctx, 1);
{
setState(378);
valueExpr();
}
break;
case MINUS:
enterOuterAlt(_localctx, 2);
{
setState(379);
match(MINUS);
setState(380);
unaryExpr();
}
break;
case PLUS:
enterOuterAlt(_localctx, 3);
{
setState(381);
match(PLUS);
setState(382);
unaryExpr();
}
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 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 void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterValueExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitValueExpr(this);
}
}
public final ValueExprContext valueExpr() throws RecognitionException {
ValueExprContext _localctx = new ValueExprContext(_ctx, getState());
enterRule(_localctx, 42, RULE_valueExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(385);
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 EQUALS() { return getToken(XPath2Parser.EQUALS, 0); }
public TerminalNode NOTEQUALS() { return getToken(XPath2Parser.NOTEQUALS, 0); }
public TerminalNode LESSTHAN() { return getToken(XPath2Parser.LESSTHAN, 0); }
public TerminalNode LESSEQUAL() { return getToken(XPath2Parser.LESSEQUAL, 0); }
public TerminalNode GREATER() { return getToken(XPath2Parser.GREATER, 0); }
public TerminalNode GREATEREQUAL() { return getToken(XPath2Parser.GREATEREQUAL, 0); }
public GeneralCompContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_generalComp; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterGeneralComp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitGeneralComp(this);
}
}
public final GeneralCompContext generalComp() throws RecognitionException {
GeneralCompContext _localctx = new GeneralCompContext(_ctx, getState());
enterRule(_localctx, 44, RULE_generalComp);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(387);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EQUALS) | (1L << NOTEQUALS) | (1L << LESSTHAN) | (1L << LESSEQUAL) | (1L << GREATER) | (1L << GREATEREQUAL))) != 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 EQ() { return getToken(XPath2Parser.EQ, 0); }
public TerminalNode NE() { return getToken(XPath2Parser.NE, 0); }
public TerminalNode LT() { return getToken(XPath2Parser.LT, 0); }
public TerminalNode LE() { return getToken(XPath2Parser.LE, 0); }
public TerminalNode GT() { return getToken(XPath2Parser.GT, 0); }
public TerminalNode GE() { return getToken(XPath2Parser.GE, 0); }
public ValueCompContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_valueComp; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterValueComp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitValueComp(this);
}
}
public final ValueCompContext valueComp() throws RecognitionException {
ValueCompContext _localctx = new ValueCompContext(_ctx, getState());
enterRule(_localctx, 46, RULE_valueComp);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(389);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EQ) | (1L << NE) | (1L << LT) | (1L << LE) | (1L << GT) | (1L << GE))) != 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 NodeCompContext extends ParserRuleContext {
public TerminalNode IS() { return getToken(XPath2Parser.IS, 0); }
public TerminalNode LESS_LESS() { return getToken(XPath2Parser.LESS_LESS, 0); }
public TerminalNode GREATER_GREATER() { return getToken(XPath2Parser.GREATER_GREATER, 0); }
public NodeCompContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nodeComp; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterNodeComp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitNodeComp(this);
}
}
public final NodeCompContext nodeComp() throws RecognitionException {
NodeCompContext _localctx = new NodeCompContext(_ctx, getState());
enterRule(_localctx, 48, RULE_nodeComp);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(391);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LESS_LESS) | (1L << GREATER_GREATER) | (1L << IS))) != 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 FORWARD_SLASH() { return getToken(XPath2Parser.FORWARD_SLASH, 0); }
public RelativePathExprContext relativePathExpr() {
return getRuleContext(RelativePathExprContext.class,0);
}
public TerminalNode FORWARD_SLASHSLASH() { return getToken(XPath2Parser.FORWARD_SLASHSLASH, 0); }
public PathExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pathExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterPathExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitPathExpr(this);
}
}
public final PathExprContext pathExpr() throws RecognitionException {
PathExprContext _localctx = new PathExprContext(_ctx, getState());
enterRule(_localctx, 50, RULE_pathExpr);
try {
setState(399);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(393);
match(FORWARD_SLASH);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(394);
match(FORWARD_SLASH);
setState(395);
relativePathExpr(0);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(396);
match(FORWARD_SLASHSLASH);
setState(397);
relativePathExpr(0);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(398);
relativePathExpr(0);
}
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 StepExprContext stepExpr() {
return getRuleContext(StepExprContext.class,0);
}
public RelativePathExprContext relativePathExpr() {
return getRuleContext(RelativePathExprContext.class,0);
}
public TerminalNode FORWARD_SLASH() { return getToken(XPath2Parser.FORWARD_SLASH, 0); }
public TerminalNode FORWARD_SLASHSLASH() { return getToken(XPath2Parser.FORWARD_SLASHSLASH, 0); }
public RelativePathExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relativePathExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterRelativePathExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitRelativePathExpr(this);
}
}
public final RelativePathExprContext relativePathExpr() throws RecognitionException {
return relativePathExpr(0);
}
private RelativePathExprContext relativePathExpr(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
RelativePathExprContext _localctx = new RelativePathExprContext(_ctx, _parentState);
RelativePathExprContext _prevctx = _localctx;
int _startState = 52;
enterRecursionRule(_localctx, 52, RULE_relativePathExpr, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(402);
stepExpr();
}
_ctx.stop = _input.LT(-1);
setState(412);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,24,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(410);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
case 1:
{
_localctx = new RelativePathExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_relativePathExpr);
setState(404);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(405);
match(FORWARD_SLASH);
setState(406);
stepExpr();
}
break;
case 2:
{
_localctx = new RelativePathExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_relativePathExpr);
setState(407);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(408);
match(FORWARD_SLASHSLASH);
setState(409);
stepExpr();
}
break;
}
}
}
setState(414);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,24,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class StepExprContext extends ParserRuleContext {
public AxisStepContext axisStep() {
return getRuleContext(AxisStepContext.class,0);
}
public FilterExprContext filterExpr() {
return getRuleContext(FilterExprContext.class,0);
}
public StepExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stepExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterStepExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitStepExpr(this);
}
}
public final StepExprContext stepExpr() throws RecognitionException {
StepExprContext _localctx = new StepExprContext(_ctx, getState());
enterRule(_localctx, 54, RULE_stepExpr);
try {
setState(417);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(415);
axisStep();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(416);
filterExpr();
}
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 ForwardStepContext forwardStep() {
return getRuleContext(ForwardStepContext.class,0);
}
public PredicateListContext predicateList() {
return getRuleContext(PredicateListContext.class,0);
}
public ReverseStepContext reverseStep() {
return getRuleContext(ReverseStepContext.class,0);
}
public AxisStepContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_axisStep; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterAxisStep(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitAxisStep(this);
}
}
public final AxisStepContext axisStep() throws RecognitionException {
AxisStepContext _localctx = new AxisStepContext(_ctx, getState());
enterRule(_localctx, 56, RULE_axisStep);
try {
setState(425);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(419);
forwardStep();
setState(420);
predicateList();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(422);
reverseStep();
setState(423);
predicateList();
}
break;
}
}
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 NodeTestContext nodeTest() {
return getRuleContext(NodeTestContext.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 void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterForwardStep(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitForwardStep(this);
}
}
public final ForwardStepContext forwardStep() throws RecognitionException {
ForwardStepContext _localctx = new ForwardStepContext(_ctx, getState());
enterRule(_localctx, 58, RULE_forwardStep);
try {
setState(431);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(427);
forwardAxis();
setState(428);
nodeTest();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(430);
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 CHILD() { return getToken(XPath2Parser.CHILD, 0); }
public TerminalNode COLONCOLON() { return getToken(XPath2Parser.COLONCOLON, 0); }
public TerminalNode DESCENDANT() { return getToken(XPath2Parser.DESCENDANT, 0); }
public TerminalNode ATTRIBUTE() { return getToken(XPath2Parser.ATTRIBUTE, 0); }
public TerminalNode SELF() { return getToken(XPath2Parser.SELF, 0); }
public TerminalNode DESCENDANT_OR_SELF() { return getToken(XPath2Parser.DESCENDANT_OR_SELF, 0); }
public TerminalNode FOLLOWING_SIBLING() { return getToken(XPath2Parser.FOLLOWING_SIBLING, 0); }
public TerminalNode FOLLOWING() { return getToken(XPath2Parser.FOLLOWING, 0); }
public TerminalNode NAMESPACE() { return getToken(XPath2Parser.NAMESPACE, 0); }
public ForwardAxisContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forwardAxis; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterForwardAxis(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitForwardAxis(this);
}
}
public final ForwardAxisContext forwardAxis() throws RecognitionException {
ForwardAxisContext _localctx = new ForwardAxisContext(_ctx, getState());
enterRule(_localctx, 60, RULE_forwardAxis);
try {
setState(449);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CHILD:
enterOuterAlt(_localctx, 1);
{
setState(433);
match(CHILD);
setState(434);
match(COLONCOLON);
}
break;
case DESCENDANT:
enterOuterAlt(_localctx, 2);
{
setState(435);
match(DESCENDANT);
setState(436);
match(COLONCOLON);
}
break;
case ATTRIBUTE:
enterOuterAlt(_localctx, 3);
{
setState(437);
match(ATTRIBUTE);
setState(438);
match(COLONCOLON);
}
break;
case SELF:
enterOuterAlt(_localctx, 4);
{
setState(439);
match(SELF);
setState(440);
match(COLONCOLON);
}
break;
case DESCENDANT_OR_SELF:
enterOuterAlt(_localctx, 5);
{
setState(441);
match(DESCENDANT_OR_SELF);
setState(442);
match(COLONCOLON);
}
break;
case FOLLOWING_SIBLING:
enterOuterAlt(_localctx, 6);
{
setState(443);
match(FOLLOWING_SIBLING);
setState(444);
match(COLONCOLON);
}
break;
case FOLLOWING:
enterOuterAlt(_localctx, 7);
{
setState(445);
match(FOLLOWING);
setState(446);
match(COLONCOLON);
}
break;
case NAMESPACE:
enterOuterAlt(_localctx, 8);
{
setState(447);
match(NAMESPACE);
setState(448);
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 TerminalNode AT_SYM() { return getToken(XPath2Parser.AT_SYM, 0); }
public NodeTestContext nodeTest() {
return getRuleContext(NodeTestContext.class,0);
}
public AbbrevForwardStepContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_abbrevForwardStep; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterAbbrevForwardStep(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitAbbrevForwardStep(this);
}
}
public final AbbrevForwardStepContext abbrevForwardStep() throws RecognitionException {
AbbrevForwardStepContext _localctx = new AbbrevForwardStepContext(_ctx, getState());
enterRule(_localctx, 62, RULE_abbrevForwardStep);
try {
setState(454);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AT_SYM:
enterOuterAlt(_localctx, 1);
{
setState(451);
match(AT_SYM);
setState(452);
nodeTest();
}
break;
case STAR:
case CHILD:
case DESCENDANT:
case ATTRIBUTE:
case SELF:
case DESCENDANT_OR_SELF:
case FOLLOWING_SIBLING:
case FOLLOWING:
case NAMESPACE:
case PARENT:
case ANCESTOR:
case PRECEDING_SIBLING:
case PRECEDING:
case ANCESTOR_OR_SELF:
case EQ:
case NE:
case LT:
case LE:
case GT:
case GE:
case IDIV:
case DIV:
case MOD:
case UNION:
case INTERSECT:
case EXCEPT:
case INSTANCE:
case TREAT:
case CASTABLE:
case CAST:
case AS:
case OF:
case IS:
case FOR:
case IN:
case RETURN:
case SATISFIES:
case TO:
case SOME:
case EVERY:
case IF:
case THEN:
case ELSE:
case AND:
case OR:
case EMPTY_SEQUENCE:
case ITEM:
case NODE:
case DOCUMENT_NODE:
case TEXT:
case COMMENT:
case PROCESSING_INSTRUCTION:
case SCHEMA_ATTRIBUTE:
case ELEMENT:
case SCHEMA_ELEMENT:
case TYPESWITCH:
case NCNAME:
enterOuterAlt(_localctx, 2);
{
setState(453);
nodeTest();
}
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 ReverseStepContext extends ParserRuleContext {
public ReverseAxisContext reverseAxis() {
return getRuleContext(ReverseAxisContext.class,0);
}
public NodeTestContext nodeTest() {
return getRuleContext(NodeTestContext.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 void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterReverseStep(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitReverseStep(this);
}
}
public final ReverseStepContext reverseStep() throws RecognitionException {
ReverseStepContext _localctx = new ReverseStepContext(_ctx, getState());
enterRule(_localctx, 64, RULE_reverseStep);
try {
setState(460);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PARENT:
case ANCESTOR:
case PRECEDING_SIBLING:
case PRECEDING:
case ANCESTOR_OR_SELF:
enterOuterAlt(_localctx, 1);
{
setState(456);
reverseAxis();
setState(457);
nodeTest();
}
break;
case DOTDOT:
enterOuterAlt(_localctx, 2);
{
setState(459);
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 PARENT() { return getToken(XPath2Parser.PARENT, 0); }
public TerminalNode COLONCOLON() { return getToken(XPath2Parser.COLONCOLON, 0); }
public TerminalNode ANCESTOR() { return getToken(XPath2Parser.ANCESTOR, 0); }
public TerminalNode PRECEDING_SIBLING() { return getToken(XPath2Parser.PRECEDING_SIBLING, 0); }
public TerminalNode PRECEDING() { return getToken(XPath2Parser.PRECEDING, 0); }
public TerminalNode ANCESTOR_OR_SELF() { return getToken(XPath2Parser.ANCESTOR_OR_SELF, 0); }
public ReverseAxisContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_reverseAxis; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterReverseAxis(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitReverseAxis(this);
}
}
public final ReverseAxisContext reverseAxis() throws RecognitionException {
ReverseAxisContext _localctx = new ReverseAxisContext(_ctx, getState());
enterRule(_localctx, 66, RULE_reverseAxis);
try {
setState(472);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PARENT:
enterOuterAlt(_localctx, 1);
{
setState(462);
match(PARENT);
setState(463);
match(COLONCOLON);
}
break;
case ANCESTOR:
enterOuterAlt(_localctx, 2);
{
setState(464);
match(ANCESTOR);
setState(465);
match(COLONCOLON);
}
break;
case PRECEDING_SIBLING:
enterOuterAlt(_localctx, 3);
{
setState(466);
match(PRECEDING_SIBLING);
setState(467);
match(COLONCOLON);
}
break;
case PRECEDING:
enterOuterAlt(_localctx, 4);
{
setState(468);
match(PRECEDING);
setState(469);
match(COLONCOLON);
}
break;
case ANCESTOR_OR_SELF:
enterOuterAlt(_localctx, 5);
{
setState(470);
match(ANCESTOR_OR_SELF);
setState(471);
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 DOTDOT() { return getToken(XPath2Parser.DOTDOT, 0); }
public AbbrevReverseStepContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_abbrevReverseStep; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterAbbrevReverseStep(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitAbbrevReverseStep(this);
}
}
public final AbbrevReverseStepContext abbrevReverseStep() throws RecognitionException {
AbbrevReverseStepContext _localctx = new AbbrevReverseStepContext(_ctx, getState());
enterRule(_localctx, 68, RULE_abbrevReverseStep);
try {
enterOuterAlt(_localctx, 1);
{
setState(474);
match(DOTDOT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NodeTestContext extends ParserRuleContext {
public KindTestContext kindTest() {
return getRuleContext(KindTestContext.class,0);
}
public NameTestContext nameTest() {
return getRuleContext(NameTestContext.class,0);
}
public NodeTestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nodeTest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterNodeTest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitNodeTest(this);
}
}
public final NodeTestContext nodeTest() throws RecognitionException {
NodeTestContext _localctx = new NodeTestContext(_ctx, getState());
enterRule(_localctx, 70, RULE_nodeTest);
try {
setState(478);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(476);
kindTest();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(477);
nameTest();
}
break;
}
}
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 QNameContext qName() {
return getRuleContext(QNameContext.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 void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterNameTest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitNameTest(this);
}
}
public final NameTestContext nameTest() throws RecognitionException {
NameTestContext _localctx = new NameTestContext(_ctx, getState());
enterRule(_localctx, 72, RULE_nameTest);
try {
setState(482);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(480);
qName();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(481);
wildcard();
}
break;
}
}
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(XPath2Parser.STAR, 0); }
public NCNameContext nCName() {
return getRuleContext(NCNameContext.class,0);
}
public TerminalNode COLON() { return getToken(XPath2Parser.COLON, 0); }
public WildcardContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_wildcard; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterWildcard(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitWildcard(this);
}
}
public final WildcardContext wildcard() throws RecognitionException {
WildcardContext _localctx = new WildcardContext(_ctx, getState());
enterRule(_localctx, 74, RULE_wildcard);
try {
setState(492);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(484);
match(STAR);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(485);
nCName();
setState(486);
match(COLON);
setState(487);
match(STAR);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(489);
match(STAR);
setState(490);
match(COLON);
setState(491);
nCName();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FilterExprContext extends ParserRuleContext {
public PrimaryExprContext primaryExpr() {
return getRuleContext(PrimaryExprContext.class,0);
}
public PredicateListContext predicateList() {
return getRuleContext(PredicateListContext.class,0);
}
public FilterExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_filterExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterFilterExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitFilterExpr(this);
}
}
public final FilterExprContext filterExpr() throws RecognitionException {
FilterExprContext _localctx = new FilterExprContext(_ctx, getState());
enterRule(_localctx, 76, RULE_filterExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(494);
primaryExpr();
setState(495);
predicateList();
}
}
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 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 void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterPredicateList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitPredicateList(this);
}
}
public final PredicateListContext predicateList() throws RecognitionException {
PredicateListContext _localctx = new PredicateListContext(_ctx, getState());
enterRule(_localctx, 78, RULE_predicateList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(500);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,35,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(497);
predicate();
}
}
}
setState(502);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,35,_ctx);
}
}
}
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 LBRACKET() { return getToken(XPath2Parser.LBRACKET, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode RBRACKET() { return getToken(XPath2Parser.RBRACKET, 0); }
public PredicateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_predicate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitPredicate(this);
}
}
public final PredicateContext predicate() throws RecognitionException {
PredicateContext _localctx = new PredicateContext(_ctx, getState());
enterRule(_localctx, 80, RULE_predicate);
try {
enterOuterAlt(_localctx, 1);
{
setState(503);
match(LBRACKET);
setState(504);
expr();
setState(505);
match(RBRACKET);
}
}
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 void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterPrimaryExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitPrimaryExpr(this);
}
}
public final PrimaryExprContext primaryExpr() throws RecognitionException {
PrimaryExprContext _localctx = new PrimaryExprContext(_ctx, getState());
enterRule(_localctx, 82, RULE_primaryExpr);
try {
setState(512);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DIGITS:
case DECIMAL_LITERAL:
case DOUBLE_LITERAL:
case STRING_LITERAL:
enterOuterAlt(_localctx, 1);
{
setState(507);
literal();
}
break;
case DOLLAR:
enterOuterAlt(_localctx, 2);
{
setState(508);
varRef();
}
break;
case LPAR:
enterOuterAlt(_localctx, 3);
{
setState(509);
parenthesizedExpr();
}
break;
case DOT:
enterOuterAlt(_localctx, 4);
{
setState(510);
contextItemExpr();
}
break;
case CHILD:
case DESCENDANT:
case ATTRIBUTE:
case SELF:
case DESCENDANT_OR_SELF:
case FOLLOWING_SIBLING:
case FOLLOWING:
case NAMESPACE:
case PARENT:
case ANCESTOR:
case PRECEDING_SIBLING:
case PRECEDING:
case ANCESTOR_OR_SELF:
case EQ:
case NE:
case LT:
case LE:
case GT:
case GE:
case IDIV:
case DIV:
case MOD:
case UNION:
case INTERSECT:
case EXCEPT:
case INSTANCE:
case TREAT:
case CASTABLE:
case CAST:
case AS:
case OF:
case IS:
case FOR:
case IN:
case RETURN:
case SATISFIES:
case TO:
case SOME:
case EVERY:
case IF:
case THEN:
case ELSE:
case AND:
case OR:
case EMPTY_SEQUENCE:
case ITEM:
case NODE:
case DOCUMENT_NODE:
case TEXT:
case COMMENT:
case PROCESSING_INSTRUCTION:
case SCHEMA_ATTRIBUTE:
case ELEMENT:
case SCHEMA_ELEMENT:
case TYPESWITCH:
case NCNAME:
enterOuterAlt(_localctx, 5);
{
setState(511);
functionCall();
}
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 LiteralContext extends ParserRuleContext {
public NumericLiteralContext numericLiteral() {
return getRuleContext(NumericLiteralContext.class,0);
}
public StringLiteralContext stringLiteral() {
return getRuleContext(StringLiteralContext.class,0);
}
public LiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literal; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitLiteral(this);
}
}
public final LiteralContext literal() throws RecognitionException {
LiteralContext _localctx = new LiteralContext(_ctx, getState());
enterRule(_localctx, 84, RULE_literal);
try {
setState(516);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DIGITS:
case DECIMAL_LITERAL:
case DOUBLE_LITERAL:
enterOuterAlt(_localctx, 1);
{
setState(514);
numericLiteral();
}
break;
case STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(515);
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 IntegerLiteralContext integerLiteral() {
return getRuleContext(IntegerLiteralContext.class,0);
}
public DecimalLiteralContext decimalLiteral() {
return getRuleContext(DecimalLiteralContext.class,0);
}
public DoubleLiteralContext doubleLiteral() {
return getRuleContext(DoubleLiteralContext.class,0);
}
public NumericLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_numericLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterNumericLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitNumericLiteral(this);
}
}
public final NumericLiteralContext numericLiteral() throws RecognitionException {
NumericLiteralContext _localctx = new NumericLiteralContext(_ctx, getState());
enterRule(_localctx, 86, RULE_numericLiteral);
try {
setState(521);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DIGITS:
enterOuterAlt(_localctx, 1);
{
setState(518);
integerLiteral();
}
break;
case DECIMAL_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(519);
decimalLiteral();
}
break;
case DOUBLE_LITERAL:
enterOuterAlt(_localctx, 3);
{
setState(520);
doubleLiteral();
}
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 VarRefContext extends ParserRuleContext {
public TerminalNode DOLLAR() { return getToken(XPath2Parser.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 void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterVarRef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitVarRef(this);
}
}
public final VarRefContext varRef() throws RecognitionException {
VarRefContext _localctx = new VarRefContext(_ctx, getState());
enterRule(_localctx, 88, RULE_varRef);
try {
enterOuterAlt(_localctx, 1);
{
setState(523);
match(DOLLAR);
setState(524);
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 QNameContext qName() {
return getRuleContext(QNameContext.class,0);
}
public VarNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_varName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterVarName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitVarName(this);
}
}
public final VarNameContext varName() throws RecognitionException {
VarNameContext _localctx = new VarNameContext(_ctx, getState());
enterRule(_localctx, 90, RULE_varName);
try {
enterOuterAlt(_localctx, 1);
{
setState(526);
qName();
}
}
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 LPAR() { return getToken(XPath2Parser.LPAR, 0); }
public TerminalNode RPAR() { return getToken(XPath2Parser.RPAR, 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 void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterParenthesizedExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitParenthesizedExpr(this);
}
}
public final ParenthesizedExprContext parenthesizedExpr() throws RecognitionException {
ParenthesizedExprContext _localctx = new ParenthesizedExprContext(_ctx, getState());
enterRule(_localctx, 92, RULE_parenthesizedExpr);
try {
setState(534);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(528);
match(LPAR);
setState(529);
match(RPAR);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(530);
match(LPAR);
setState(531);
expr();
setState(532);
match(RPAR);
}
break;
}
}
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 DOT() { return getToken(XPath2Parser.DOT, 0); }
public ContextItemExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_contextItemExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterContextItemExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitContextItemExpr(this);
}
}
public final ContextItemExprContext contextItemExpr() throws RecognitionException {
ContextItemExprContext _localctx = new ContextItemExprContext(_ctx, getState());
enterRule(_localctx, 94, RULE_contextItemExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(536);
match(DOT);
}
}
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 ReservedFunctionNamesContext reservedFunctionNames() {
return getRuleContext(ReservedFunctionNamesContext.class,0);
}
public TerminalNode LPAR() { return getToken(XPath2Parser.LPAR, 0); }
public TerminalNode RPAR() { return getToken(XPath2Parser.RPAR, 0); }
public FunctionCallMiddleContext functionCallMiddle() {
return getRuleContext(FunctionCallMiddleContext.class,0);
}
public FunctionCallContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionCall; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterFunctionCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitFunctionCall(this);
}
}
public final FunctionCallContext functionCall() throws RecognitionException {
FunctionCallContext _localctx = new FunctionCallContext(_ctx, getState());
enterRule(_localctx, 96, RULE_functionCall);
try {
setState(547);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(538);
reservedFunctionNames();
setState(539);
match(LPAR);
setState(540);
match(RPAR);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(542);
reservedFunctionNames();
setState(543);
match(LPAR);
setState(544);
functionCallMiddle(0);
setState(545);
match(RPAR);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FunctionCallMiddleContext extends ParserRuleContext {
public ExprSingleContext exprSingle() {
return getRuleContext(ExprSingleContext.class,0);
}
public FunctionCallMiddleContext functionCallMiddle() {
return getRuleContext(FunctionCallMiddleContext.class,0);
}
public TerminalNode COMMA() { return getToken(XPath2Parser.COMMA, 0); }
public FunctionCallMiddleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionCallMiddle; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterFunctionCallMiddle(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitFunctionCallMiddle(this);
}
}
public final FunctionCallMiddleContext functionCallMiddle() throws RecognitionException {
return functionCallMiddle(0);
}
private FunctionCallMiddleContext functionCallMiddle(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
FunctionCallMiddleContext _localctx = new FunctionCallMiddleContext(_ctx, _parentState);
FunctionCallMiddleContext _prevctx = _localctx;
int _startState = 98;
enterRecursionRule(_localctx, 98, RULE_functionCallMiddle, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(550);
exprSingle();
}
_ctx.stop = _input.LT(-1);
setState(557);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,41,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new FunctionCallMiddleContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_functionCallMiddle);
setState(552);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(553);
match(COMMA);
setState(554);
exprSingle();
}
}
}
setState(559);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,41,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class SingleTypeContext extends ParserRuleContext {
public AtomicTypeContext atomicType() {
return getRuleContext(AtomicTypeContext.class,0);
}
public TerminalNode QUESTIONMARK() { return getToken(XPath2Parser.QUESTIONMARK, 0); }
public SingleTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_singleType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterSingleType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitSingleType(this);
}
}
public final SingleTypeContext singleType() throws RecognitionException {
SingleTypeContext _localctx = new SingleTypeContext(_ctx, getState());
enterRule(_localctx, 100, RULE_singleType);
try {
setState(564);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(560);
atomicType();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(561);
atomicType();
setState(562);
match(QUESTIONMARK);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SequenceTypeContext extends ParserRuleContext {
public ItemTypeContext itemType() {
return getRuleContext(ItemTypeContext.class,0);
}
public OccurrenceIndicatorContext occurrenceIndicator() {
return getRuleContext(OccurrenceIndicatorContext.class,0);
}
public TerminalNode EMPTY_SEQUENCE() { return getToken(XPath2Parser.EMPTY_SEQUENCE, 0); }
public TerminalNode LPAR() { return getToken(XPath2Parser.LPAR, 0); }
public TerminalNode RPAR() { return getToken(XPath2Parser.RPAR, 0); }
public SequenceTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sequenceType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterSequenceType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitSequenceType(this);
}
}
public final SequenceTypeContext sequenceType() throws RecognitionException {
SequenceTypeContext _localctx = new SequenceTypeContext(_ctx, getState());
enterRule(_localctx, 102, RULE_sequenceType);
try {
setState(573);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(566);
itemType();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(567);
itemType();
setState(568);
occurrenceIndicator();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(570);
match(EMPTY_SEQUENCE);
setState(571);
match(LPAR);
setState(572);
match(RPAR);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OccurrenceIndicatorContext extends ParserRuleContext {
public TerminalNode QUESTIONMARK() { return getToken(XPath2Parser.QUESTIONMARK, 0); }
public TerminalNode STAR() { return getToken(XPath2Parser.STAR, 0); }
public TerminalNode PLUS() { return getToken(XPath2Parser.PLUS, 0); }
public OccurrenceIndicatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_occurrenceIndicator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterOccurrenceIndicator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitOccurrenceIndicator(this);
}
}
public final OccurrenceIndicatorContext occurrenceIndicator() throws RecognitionException {
OccurrenceIndicatorContext _localctx = new OccurrenceIndicatorContext(_ctx, getState());
enterRule(_localctx, 104, RULE_occurrenceIndicator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(575);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PLUS) | (1L << STAR) | (1L << QUESTIONMARK))) != 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 ItemTypeContext extends ParserRuleContext {
public AtomicTypeContext atomicType() {
return getRuleContext(AtomicTypeContext.class,0);
}
public KindTestContext kindTest() {
return getRuleContext(KindTestContext.class,0);
}
public TerminalNode ITEM() { return getToken(XPath2Parser.ITEM, 0); }
public TerminalNode LPAR() { return getToken(XPath2Parser.LPAR, 0); }
public TerminalNode RPAR() { return getToken(XPath2Parser.RPAR, 0); }
public ItemTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_itemType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterItemType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitItemType(this);
}
}
public final ItemTypeContext itemType() throws RecognitionException {
ItemTypeContext _localctx = new ItemTypeContext(_ctx, getState());
enterRule(_localctx, 106, RULE_itemType);
try {
setState(582);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(577);
atomicType();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(578);
kindTest();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(579);
match(ITEM);
setState(580);
match(LPAR);
setState(581);
match(RPAR);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AtomicTypeContext extends ParserRuleContext {
public QNameContext qName() {
return getRuleContext(QNameContext.class,0);
}
public AtomicTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_atomicType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterAtomicType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitAtomicType(this);
}
}
public final AtomicTypeContext atomicType() throws RecognitionException {
AtomicTypeContext _localctx = new AtomicTypeContext(_ctx, getState());
enterRule(_localctx, 108, RULE_atomicType);
try {
enterOuterAlt(_localctx, 1);
{
setState(584);
qName();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class KindTestContext extends ParserRuleContext {
public DocumentTestContext documentTest() {
return getRuleContext(DocumentTestContext.class,0);
}
public ElementTestContext elementTest() {
return getRuleContext(ElementTestContext.class,0);
}
public AttributeTestContext attributeTest() {
return getRuleContext(AttributeTestContext.class,0);
}
public SchemaElementTestContext schemaElementTest() {
return getRuleContext(SchemaElementTestContext.class,0);
}
public SchemaAttributeTestContext schemaAttributeTest() {
return getRuleContext(SchemaAttributeTestContext.class,0);
}
public PITestContext pITest() {
return getRuleContext(PITestContext.class,0);
}
public CommentTestContext commentTest() {
return getRuleContext(CommentTestContext.class,0);
}
public TextTestContext textTest() {
return getRuleContext(TextTestContext.class,0);
}
public AnyKindTestContext anyKindTest() {
return getRuleContext(AnyKindTestContext.class,0);
}
public KindTestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_kindTest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterKindTest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitKindTest(this);
}
}
public final KindTestContext kindTest() throws RecognitionException {
KindTestContext _localctx = new KindTestContext(_ctx, getState());
enterRule(_localctx, 110, RULE_kindTest);
try {
setState(595);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DOCUMENT_NODE:
enterOuterAlt(_localctx, 1);
{
setState(586);
documentTest();
}
break;
case ELEMENT:
enterOuterAlt(_localctx, 2);
{
setState(587);
elementTest();
}
break;
case ATTRIBUTE:
enterOuterAlt(_localctx, 3);
{
setState(588);
attributeTest();
}
break;
case SCHEMA_ELEMENT:
enterOuterAlt(_localctx, 4);
{
setState(589);
schemaElementTest();
}
break;
case SCHEMA_ATTRIBUTE:
enterOuterAlt(_localctx, 5);
{
setState(590);
schemaAttributeTest();
}
break;
case PROCESSING_INSTRUCTION:
enterOuterAlt(_localctx, 6);
{
setState(591);
pITest();
}
break;
case COMMENT:
enterOuterAlt(_localctx, 7);
{
setState(592);
commentTest();
}
break;
case TEXT:
enterOuterAlt(_localctx, 8);
{
setState(593);
textTest();
}
break;
case NODE:
enterOuterAlt(_localctx, 9);
{
setState(594);
anyKindTest();
}
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 AnyKindTestContext extends ParserRuleContext {
public TerminalNode NODE() { return getToken(XPath2Parser.NODE, 0); }
public TerminalNode LPAR() { return getToken(XPath2Parser.LPAR, 0); }
public TerminalNode RPAR() { return getToken(XPath2Parser.RPAR, 0); }
public AnyKindTestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_anyKindTest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterAnyKindTest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitAnyKindTest(this);
}
}
public final AnyKindTestContext anyKindTest() throws RecognitionException {
AnyKindTestContext _localctx = new AnyKindTestContext(_ctx, getState());
enterRule(_localctx, 112, RULE_anyKindTest);
try {
enterOuterAlt(_localctx, 1);
{
setState(597);
match(NODE);
setState(598);
match(LPAR);
setState(599);
match(RPAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DocumentTestContext extends ParserRuleContext {
public TerminalNode DOCUMENT_NODE() { return getToken(XPath2Parser.DOCUMENT_NODE, 0); }
public TerminalNode LPAR() { return getToken(XPath2Parser.LPAR, 0); }
public TerminalNode RPAR() { return getToken(XPath2Parser.RPAR, 0); }
public ElementTestContext elementTest() {
return getRuleContext(ElementTestContext.class,0);
}
public SchemaElementTestContext schemaElementTest() {
return getRuleContext(SchemaElementTestContext.class,0);
}
public DocumentTestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_documentTest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterDocumentTest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitDocumentTest(this);
}
}
public final DocumentTestContext documentTest() throws RecognitionException {
DocumentTestContext _localctx = new DocumentTestContext(_ctx, getState());
enterRule(_localctx, 114, RULE_documentTest);
try {
setState(614);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(601);
match(DOCUMENT_NODE);
setState(602);
match(LPAR);
setState(603);
match(RPAR);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(604);
match(DOCUMENT_NODE);
setState(605);
match(LPAR);
setState(606);
elementTest();
setState(607);
match(RPAR);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(609);
match(DOCUMENT_NODE);
setState(610);
match(LPAR);
setState(611);
schemaElementTest();
setState(612);
match(RPAR);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TextTestContext extends ParserRuleContext {
public TerminalNode TEXT() { return getToken(XPath2Parser.TEXT, 0); }
public TerminalNode LPAR() { return getToken(XPath2Parser.LPAR, 0); }
public TerminalNode RPAR() { return getToken(XPath2Parser.RPAR, 0); }
public TextTestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_textTest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterTextTest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitTextTest(this);
}
}
public final TextTestContext textTest() throws RecognitionException {
TextTestContext _localctx = new TextTestContext(_ctx, getState());
enterRule(_localctx, 116, RULE_textTest);
try {
enterOuterAlt(_localctx, 1);
{
setState(616);
match(TEXT);
setState(617);
match(LPAR);
setState(618);
match(RPAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CommentTestContext extends ParserRuleContext {
public TerminalNode COMMENT() { return getToken(XPath2Parser.COMMENT, 0); }
public TerminalNode LPAR() { return getToken(XPath2Parser.LPAR, 0); }
public TerminalNode RPAR() { return getToken(XPath2Parser.RPAR, 0); }
public CommentTestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_commentTest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterCommentTest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitCommentTest(this);
}
}
public final CommentTestContext commentTest() throws RecognitionException {
CommentTestContext _localctx = new CommentTestContext(_ctx, getState());
enterRule(_localctx, 118, RULE_commentTest);
try {
enterOuterAlt(_localctx, 1);
{
setState(620);
match(COMMENT);
setState(621);
match(LPAR);
setState(622);
match(RPAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PITestContext extends ParserRuleContext {
public TerminalNode PROCESSING_INSTRUCTION() { return getToken(XPath2Parser.PROCESSING_INSTRUCTION, 0); }
public TerminalNode LPAR() { return getToken(XPath2Parser.LPAR, 0); }
public TerminalNode RPAR() { return getToken(XPath2Parser.RPAR, 0); }
public NCNameContext nCName() {
return getRuleContext(NCNameContext.class,0);
}
public StringLiteralContext stringLiteral() {
return getRuleContext(StringLiteralContext.class,0);
}
public PITestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pITest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterPITest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitPITest(this);
}
}
public final PITestContext pITest() throws RecognitionException {
PITestContext _localctx = new PITestContext(_ctx, getState());
enterRule(_localctx, 120, RULE_pITest);
try {
setState(637);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(624);
match(PROCESSING_INSTRUCTION);
setState(625);
match(LPAR);
setState(626);
match(RPAR);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(627);
match(PROCESSING_INSTRUCTION);
setState(628);
match(LPAR);
setState(629);
nCName();
setState(630);
match(RPAR);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(632);
match(PROCESSING_INSTRUCTION);
setState(633);
match(LPAR);
setState(634);
stringLiteral();
setState(635);
match(RPAR);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AttributeTestContext extends ParserRuleContext {
public TerminalNode ATTRIBUTE() { return getToken(XPath2Parser.ATTRIBUTE, 0); }
public TerminalNode LPAR() { return getToken(XPath2Parser.LPAR, 0); }
public TerminalNode RPAR() { return getToken(XPath2Parser.RPAR, 0); }
public AttribNameOrWildcardContext attribNameOrWildcard() {
return getRuleContext(AttribNameOrWildcardContext.class,0);
}
public TerminalNode COMMA() { return getToken(XPath2Parser.COMMA, 0); }
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public AttributeTestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributeTest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterAttributeTest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitAttributeTest(this);
}
}
public final AttributeTestContext attributeTest() throws RecognitionException {
AttributeTestContext _localctx = new AttributeTestContext(_ctx, getState());
enterRule(_localctx, 122, RULE_attributeTest);
try {
setState(654);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(639);
match(ATTRIBUTE);
setState(640);
match(LPAR);
setState(641);
match(RPAR);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(642);
match(ATTRIBUTE);
setState(643);
match(LPAR);
setState(644);
attribNameOrWildcard();
setState(645);
match(RPAR);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(647);
match(ATTRIBUTE);
setState(648);
match(LPAR);
setState(649);
attribNameOrWildcard();
setState(650);
match(COMMA);
setState(651);
typeName();
setState(652);
match(RPAR);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AttribNameOrWildcardContext extends ParserRuleContext {
public AttributeNameContext attributeName() {
return getRuleContext(AttributeNameContext.class,0);
}
public TerminalNode STAR() { return getToken(XPath2Parser.STAR, 0); }
public AttribNameOrWildcardContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attribNameOrWildcard; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterAttribNameOrWildcard(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitAttribNameOrWildcard(this);
}
}
public final AttribNameOrWildcardContext attribNameOrWildcard() throws RecognitionException {
AttribNameOrWildcardContext _localctx = new AttribNameOrWildcardContext(_ctx, getState());
enterRule(_localctx, 124, RULE_attribNameOrWildcard);
try {
setState(658);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CHILD:
case DESCENDANT:
case ATTRIBUTE:
case SELF:
case DESCENDANT_OR_SELF:
case FOLLOWING_SIBLING:
case FOLLOWING:
case NAMESPACE:
case PARENT:
case ANCESTOR:
case PRECEDING_SIBLING:
case PRECEDING:
case ANCESTOR_OR_SELF:
case EQ:
case NE:
case LT:
case LE:
case GT:
case GE:
case IDIV:
case DIV:
case MOD:
case UNION:
case INTERSECT:
case EXCEPT:
case INSTANCE:
case TREAT:
case CASTABLE:
case CAST:
case AS:
case OF:
case IS:
case FOR:
case IN:
case RETURN:
case SATISFIES:
case TO:
case SOME:
case EVERY:
case IF:
case THEN:
case ELSE:
case AND:
case OR:
case EMPTY_SEQUENCE:
case ITEM:
case NODE:
case DOCUMENT_NODE:
case TEXT:
case COMMENT:
case PROCESSING_INSTRUCTION:
case SCHEMA_ATTRIBUTE:
case ELEMENT:
case SCHEMA_ELEMENT:
case TYPESWITCH:
case NCNAME:
enterOuterAlt(_localctx, 1);
{
setState(656);
attributeName();
}
break;
case STAR:
enterOuterAlt(_localctx, 2);
{
setState(657);
match(STAR);
}
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 SchemaAttributeTestContext extends ParserRuleContext {
public TerminalNode SCHEMA_ATTRIBUTE() { return getToken(XPath2Parser.SCHEMA_ATTRIBUTE, 0); }
public TerminalNode LPAR() { return getToken(XPath2Parser.LPAR, 0); }
public AttributeDeclarationContext attributeDeclaration() {
return getRuleContext(AttributeDeclarationContext.class,0);
}
public TerminalNode RPAR() { return getToken(XPath2Parser.RPAR, 0); }
public SchemaAttributeTestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_schemaAttributeTest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterSchemaAttributeTest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitSchemaAttributeTest(this);
}
}
public final SchemaAttributeTestContext schemaAttributeTest() throws RecognitionException {
SchemaAttributeTestContext _localctx = new SchemaAttributeTestContext(_ctx, getState());
enterRule(_localctx, 126, RULE_schemaAttributeTest);
try {
enterOuterAlt(_localctx, 1);
{
setState(660);
match(SCHEMA_ATTRIBUTE);
setState(661);
match(LPAR);
setState(662);
attributeDeclaration();
setState(663);
match(RPAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AttributeDeclarationContext extends ParserRuleContext {
public AttributeNameContext attributeName() {
return getRuleContext(AttributeNameContext.class,0);
}
public AttributeDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributeDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterAttributeDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitAttributeDeclaration(this);
}
}
public final AttributeDeclarationContext attributeDeclaration() throws RecognitionException {
AttributeDeclarationContext _localctx = new AttributeDeclarationContext(_ctx, getState());
enterRule(_localctx, 128, RULE_attributeDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(665);
attributeName();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElementTestContext extends ParserRuleContext {
public TerminalNode ELEMENT() { return getToken(XPath2Parser.ELEMENT, 0); }
public TerminalNode LPAR() { return getToken(XPath2Parser.LPAR, 0); }
public TerminalNode RPAR() { return getToken(XPath2Parser.RPAR, 0); }
public ElementNameOrWildcardContext elementNameOrWildcard() {
return getRuleContext(ElementNameOrWildcardContext.class,0);
}
public TerminalNode COMMA() { return getToken(XPath2Parser.COMMA, 0); }
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public TerminalNode QUESTIONMARK() { return getToken(XPath2Parser.QUESTIONMARK, 0); }
public ElementTestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementTest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterElementTest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitElementTest(this);
}
}
public final ElementTestContext elementTest() throws RecognitionException {
ElementTestContext _localctx = new ElementTestContext(_ctx, getState());
enterRule(_localctx, 130, RULE_elementTest);
try {
setState(690);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(667);
match(ELEMENT);
setState(668);
match(LPAR);
setState(669);
match(RPAR);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(670);
match(ELEMENT);
setState(671);
match(LPAR);
setState(672);
elementNameOrWildcard();
setState(673);
match(RPAR);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(675);
match(ELEMENT);
setState(676);
match(LPAR);
setState(677);
elementNameOrWildcard();
setState(678);
match(COMMA);
setState(679);
typeName();
setState(680);
match(RPAR);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(682);
match(ELEMENT);
setState(683);
match(LPAR);
setState(684);
elementNameOrWildcard();
setState(685);
match(COMMA);
setState(686);
typeName();
setState(687);
match(QUESTIONMARK);
setState(688);
match(RPAR);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElementNameOrWildcardContext extends ParserRuleContext {
public ElementNameContext elementName() {
return getRuleContext(ElementNameContext.class,0);
}
public TerminalNode STAR() { return getToken(XPath2Parser.STAR, 0); }
public ElementNameOrWildcardContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementNameOrWildcard; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterElementNameOrWildcard(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitElementNameOrWildcard(this);
}
}
public final ElementNameOrWildcardContext elementNameOrWildcard() throws RecognitionException {
ElementNameOrWildcardContext _localctx = new ElementNameOrWildcardContext(_ctx, getState());
enterRule(_localctx, 132, RULE_elementNameOrWildcard);
try {
setState(694);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CHILD:
case DESCENDANT:
case ATTRIBUTE:
case SELF:
case DESCENDANT_OR_SELF:
case FOLLOWING_SIBLING:
case FOLLOWING:
case NAMESPACE:
case PARENT:
case ANCESTOR:
case PRECEDING_SIBLING:
case PRECEDING:
case ANCESTOR_OR_SELF:
case EQ:
case NE:
case LT:
case LE:
case GT:
case GE:
case IDIV:
case DIV:
case MOD:
case UNION:
case INTERSECT:
case EXCEPT:
case INSTANCE:
case TREAT:
case CASTABLE:
case CAST:
case AS:
case OF:
case IS:
case FOR:
case IN:
case RETURN:
case SATISFIES:
case TO:
case SOME:
case EVERY:
case IF:
case THEN:
case ELSE:
case AND:
case OR:
case EMPTY_SEQUENCE:
case ITEM:
case NODE:
case DOCUMENT_NODE:
case TEXT:
case COMMENT:
case PROCESSING_INSTRUCTION:
case SCHEMA_ATTRIBUTE:
case ELEMENT:
case SCHEMA_ELEMENT:
case TYPESWITCH:
case NCNAME:
enterOuterAlt(_localctx, 1);
{
setState(692);
elementName();
}
break;
case STAR:
enterOuterAlt(_localctx, 2);
{
setState(693);
match(STAR);
}
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 SchemaElementTestContext extends ParserRuleContext {
public TerminalNode SCHEMA_ELEMENT() { return getToken(XPath2Parser.SCHEMA_ELEMENT, 0); }
public TerminalNode LPAR() { return getToken(XPath2Parser.LPAR, 0); }
public ElementDeclarationContext elementDeclaration() {
return getRuleContext(ElementDeclarationContext.class,0);
}
public TerminalNode RPAR() { return getToken(XPath2Parser.RPAR, 0); }
public SchemaElementTestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_schemaElementTest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterSchemaElementTest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitSchemaElementTest(this);
}
}
public final SchemaElementTestContext schemaElementTest() throws RecognitionException {
SchemaElementTestContext _localctx = new SchemaElementTestContext(_ctx, getState());
enterRule(_localctx, 134, RULE_schemaElementTest);
try {
enterOuterAlt(_localctx, 1);
{
setState(696);
match(SCHEMA_ELEMENT);
setState(697);
match(LPAR);
setState(698);
elementDeclaration();
setState(699);
match(RPAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElementDeclarationContext extends ParserRuleContext {
public ElementNameContext elementName() {
return getRuleContext(ElementNameContext.class,0);
}
public ElementDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterElementDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitElementDeclaration(this);
}
}
public final ElementDeclarationContext elementDeclaration() throws RecognitionException {
ElementDeclarationContext _localctx = new ElementDeclarationContext(_ctx, getState());
enterRule(_localctx, 136, RULE_elementDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(701);
elementName();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AttributeNameContext extends ParserRuleContext {
public QNameContext qName() {
return getRuleContext(QNameContext.class,0);
}
public AttributeNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributeName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterAttributeName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitAttributeName(this);
}
}
public final AttributeNameContext attributeName() throws RecognitionException {
AttributeNameContext _localctx = new AttributeNameContext(_ctx, getState());
enterRule(_localctx, 138, RULE_attributeName);
try {
enterOuterAlt(_localctx, 1);
{
setState(703);
qName();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElementNameContext extends ParserRuleContext {
public QNameContext qName() {
return getRuleContext(QNameContext.class,0);
}
public ElementNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterElementName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitElementName(this);
}
}
public final ElementNameContext elementName() throws RecognitionException {
ElementNameContext _localctx = new ElementNameContext(_ctx, getState());
enterRule(_localctx, 140, RULE_elementName);
try {
enterOuterAlt(_localctx, 1);
{
setState(705);
qName();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeNameContext extends ParserRuleContext {
public QNameContext qName() {
return getRuleContext(QNameContext.class,0);
}
public TypeNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterTypeName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitTypeName(this);
}
}
public final TypeNameContext typeName() throws RecognitionException {
TypeNameContext _localctx = new TypeNameContext(_ctx, getState());
enterRule(_localctx, 142, RULE_typeName);
try {
enterOuterAlt(_localctx, 1);
{
setState(707);
qName();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IntegerLiteralContext extends ParserRuleContext {
public TerminalNode DIGITS() { return getToken(XPath2Parser.DIGITS, 0); }
public IntegerLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_integerLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterIntegerLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitIntegerLiteral(this);
}
}
public final IntegerLiteralContext integerLiteral() throws RecognitionException {
IntegerLiteralContext _localctx = new IntegerLiteralContext(_ctx, getState());
enterRule(_localctx, 144, RULE_integerLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(709);
match(DIGITS);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DecimalLiteralContext extends ParserRuleContext {
public TerminalNode DECIMAL_LITERAL() { return getToken(XPath2Parser.DECIMAL_LITERAL, 0); }
public DecimalLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_decimalLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterDecimalLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitDecimalLiteral(this);
}
}
public final DecimalLiteralContext decimalLiteral() throws RecognitionException {
DecimalLiteralContext _localctx = new DecimalLiteralContext(_ctx, getState());
enterRule(_localctx, 146, RULE_decimalLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(711);
match(DECIMAL_LITERAL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DoubleLiteralContext extends ParserRuleContext {
public TerminalNode DOUBLE_LITERAL() { return getToken(XPath2Parser.DOUBLE_LITERAL, 0); }
public DoubleLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_doubleLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterDoubleLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitDoubleLiteral(this);
}
}
public final DoubleLiteralContext doubleLiteral() throws RecognitionException {
DoubleLiteralContext _localctx = new DoubleLiteralContext(_ctx, getState());
enterRule(_localctx, 148, RULE_doubleLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(713);
match(DOUBLE_LITERAL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StringLiteralContext extends ParserRuleContext {
public TerminalNode STRING_LITERAL() { return getToken(XPath2Parser.STRING_LITERAL, 0); }
public StringLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stringLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterStringLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitStringLiteral(this);
}
}
public final StringLiteralContext stringLiteral() throws RecognitionException {
StringLiteralContext _localctx = new StringLiteralContext(_ctx, getState());
enterRule(_localctx, 150, RULE_stringLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(715);
match(STRING_LITERAL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QNameContext extends ParserRuleContext {
public List nCName() {
return getRuleContexts(NCNameContext.class);
}
public NCNameContext nCName(int i) {
return getRuleContext(NCNameContext.class,i);
}
public TerminalNode COLON() { return getToken(XPath2Parser.COLON, 0); }
public QNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterQName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitQName(this);
}
}
public final QNameContext qName() throws RecognitionException {
QNameContext _localctx = new QNameContext(_ctx, getState());
enterRule(_localctx, 152, RULE_qName);
try {
setState(722);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(717);
nCName();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(718);
nCName();
setState(719);
match(COLON);
setState(720);
nCName();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NCNameContext extends ParserRuleContext {
public TerminalNode NCNAME() { return getToken(XPath2Parser.NCNAME, 0); }
public TerminalNode TO() { return getToken(XPath2Parser.TO, 0); }
public TerminalNode CHILD() { return getToken(XPath2Parser.CHILD, 0); }
public TerminalNode DESCENDANT() { return getToken(XPath2Parser.DESCENDANT, 0); }
public TerminalNode ATTRIBUTE() { return getToken(XPath2Parser.ATTRIBUTE, 0); }
public TerminalNode SELF() { return getToken(XPath2Parser.SELF, 0); }
public TerminalNode DESCENDANT_OR_SELF() { return getToken(XPath2Parser.DESCENDANT_OR_SELF, 0); }
public TerminalNode FOLLOWING_SIBLING() { return getToken(XPath2Parser.FOLLOWING_SIBLING, 0); }
public TerminalNode FOLLOWING() { return getToken(XPath2Parser.FOLLOWING, 0); }
public TerminalNode NAMESPACE() { return getToken(XPath2Parser.NAMESPACE, 0); }
public TerminalNode PARENT() { return getToken(XPath2Parser.PARENT, 0); }
public TerminalNode ANCESTOR() { return getToken(XPath2Parser.ANCESTOR, 0); }
public TerminalNode PRECEDING_SIBLING() { return getToken(XPath2Parser.PRECEDING_SIBLING, 0); }
public TerminalNode PRECEDING() { return getToken(XPath2Parser.PRECEDING, 0); }
public TerminalNode ANCESTOR_OR_SELF() { return getToken(XPath2Parser.ANCESTOR_OR_SELF, 0); }
public TerminalNode UNION() { return getToken(XPath2Parser.UNION, 0); }
public TerminalNode INTERSECT() { return getToken(XPath2Parser.INTERSECT, 0); }
public TerminalNode EXCEPT() { return getToken(XPath2Parser.EXCEPT, 0); }
public TerminalNode INSTANCE() { return getToken(XPath2Parser.INSTANCE, 0); }
public TerminalNode OF() { return getToken(XPath2Parser.OF, 0); }
public TerminalNode AS() { return getToken(XPath2Parser.AS, 0); }
public TerminalNode TREAT() { return getToken(XPath2Parser.TREAT, 0); }
public TerminalNode CASTABLE() { return getToken(XPath2Parser.CASTABLE, 0); }
public TerminalNode CAST() { return getToken(XPath2Parser.CAST, 0); }
public TerminalNode IS() { return getToken(XPath2Parser.IS, 0); }
public TerminalNode FOR() { return getToken(XPath2Parser.FOR, 0); }
public TerminalNode IN() { return getToken(XPath2Parser.IN, 0); }
public TerminalNode RETURN() { return getToken(XPath2Parser.RETURN, 0); }
public TerminalNode SATISFIES() { return getToken(XPath2Parser.SATISFIES, 0); }
public TerminalNode SOME() { return getToken(XPath2Parser.SOME, 0); }
public TerminalNode EVERY() { return getToken(XPath2Parser.EVERY, 0); }
public TerminalNode IF() { return getToken(XPath2Parser.IF, 0); }
public TerminalNode THEN() { return getToken(XPath2Parser.THEN, 0); }
public TerminalNode ELSE() { return getToken(XPath2Parser.ELSE, 0); }
public TerminalNode AND() { return getToken(XPath2Parser.AND, 0); }
public TerminalNode OR() { return getToken(XPath2Parser.OR, 0); }
public TerminalNode DIV() { return getToken(XPath2Parser.DIV, 0); }
public TerminalNode IDIV() { return getToken(XPath2Parser.IDIV, 0); }
public TerminalNode COMMENT() { return getToken(XPath2Parser.COMMENT, 0); }
public TerminalNode DOCUMENT_NODE() { return getToken(XPath2Parser.DOCUMENT_NODE, 0); }
public TerminalNode ELEMENT() { return getToken(XPath2Parser.ELEMENT, 0); }
public TerminalNode EMPTY_SEQUENCE() { return getToken(XPath2Parser.EMPTY_SEQUENCE, 0); }
public TerminalNode ITEM() { return getToken(XPath2Parser.ITEM, 0); }
public TerminalNode NODE() { return getToken(XPath2Parser.NODE, 0); }
public TerminalNode PROCESSING_INSTRUCTION() { return getToken(XPath2Parser.PROCESSING_INSTRUCTION, 0); }
public TerminalNode SCHEMA_ATTRIBUTE() { return getToken(XPath2Parser.SCHEMA_ATTRIBUTE, 0); }
public TerminalNode SCHEMA_ELEMENT() { return getToken(XPath2Parser.SCHEMA_ELEMENT, 0); }
public TerminalNode TEXT() { return getToken(XPath2Parser.TEXT, 0); }
public TerminalNode TYPESWITCH() { return getToken(XPath2Parser.TYPESWITCH, 0); }
public TerminalNode MOD() { return getToken(XPath2Parser.MOD, 0); }
public TerminalNode EQ() { return getToken(XPath2Parser.EQ, 0); }
public TerminalNode NE() { return getToken(XPath2Parser.NE, 0); }
public TerminalNode LT() { return getToken(XPath2Parser.LT, 0); }
public TerminalNode LE() { return getToken(XPath2Parser.LE, 0); }
public TerminalNode GT() { return getToken(XPath2Parser.GT, 0); }
public TerminalNode GE() { return getToken(XPath2Parser.GE, 0); }
public NCNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nCName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterNCName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitNCName(this);
}
}
public final NCNameContext nCName() throws RecognitionException {
NCNameContext _localctx = new NCNameContext(_ctx, getState());
enterRule(_localctx, 154, RULE_nCName);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(724);
_la = _input.LA(1);
if ( !(((((_la - 31)) & ~0x3f) == 0 && ((1L << (_la - 31)) & ((1L << (CHILD - 31)) | (1L << (DESCENDANT - 31)) | (1L << (ATTRIBUTE - 31)) | (1L << (SELF - 31)) | (1L << (DESCENDANT_OR_SELF - 31)) | (1L << (FOLLOWING_SIBLING - 31)) | (1L << (FOLLOWING - 31)) | (1L << (NAMESPACE - 31)) | (1L << (PARENT - 31)) | (1L << (ANCESTOR - 31)) | (1L << (PRECEDING_SIBLING - 31)) | (1L << (PRECEDING - 31)) | (1L << (ANCESTOR_OR_SELF - 31)) | (1L << (EQ - 31)) | (1L << (NE - 31)) | (1L << (LT - 31)) | (1L << (LE - 31)) | (1L << (GT - 31)) | (1L << (GE - 31)) | (1L << (IDIV - 31)) | (1L << (DIV - 31)) | (1L << (MOD - 31)) | (1L << (UNION - 31)) | (1L << (INTERSECT - 31)) | (1L << (EXCEPT - 31)) | (1L << (INSTANCE - 31)) | (1L << (TREAT - 31)) | (1L << (CASTABLE - 31)) | (1L << (CAST - 31)) | (1L << (AS - 31)) | (1L << (OF - 31)) | (1L << (IS - 31)) | (1L << (FOR - 31)) | (1L << (IN - 31)) | (1L << (RETURN - 31)) | (1L << (SATISFIES - 31)) | (1L << (TO - 31)) | (1L << (SOME - 31)) | (1L << (EVERY - 31)) | (1L << (IF - 31)) | (1L << (THEN - 31)) | (1L << (ELSE - 31)) | (1L << (AND - 31)) | (1L << (OR - 31)) | (1L << (EMPTY_SEQUENCE - 31)) | (1L << (ITEM - 31)) | (1L << (NODE - 31)) | (1L << (DOCUMENT_NODE - 31)) | (1L << (TEXT - 31)) | (1L << (COMMENT - 31)) | (1L << (PROCESSING_INSTRUCTION - 31)) | (1L << (SCHEMA_ATTRIBUTE - 31)) | (1L << (ELEMENT - 31)) | (1L << (SCHEMA_ELEMENT - 31)) | (1L << (TYPESWITCH - 31)) | (1L << (NCNAME - 31)))) != 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 ReservedFunctionNamesContext extends ParserRuleContext {
public ReservedFunctionNCNamesContext reservedFunctionNCNames() {
return getRuleContext(ReservedFunctionNCNamesContext.class,0);
}
public List nCName() {
return getRuleContexts(NCNameContext.class);
}
public NCNameContext nCName(int i) {
return getRuleContext(NCNameContext.class,i);
}
public TerminalNode COLON() { return getToken(XPath2Parser.COLON, 0); }
public ReservedFunctionNamesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_reservedFunctionNames; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterReservedFunctionNames(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitReservedFunctionNames(this);
}
}
public final ReservedFunctionNamesContext reservedFunctionNames() throws RecognitionException {
ReservedFunctionNamesContext _localctx = new ReservedFunctionNamesContext(_ctx, getState());
enterRule(_localctx, 156, RULE_reservedFunctionNames);
try {
setState(731);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,53,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(726);
reservedFunctionNCNames();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(727);
nCName();
setState(728);
match(COLON);
setState(729);
nCName();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReservedFunctionNCNamesContext extends ParserRuleContext {
public TerminalNode NCNAME() { return getToken(XPath2Parser.NCNAME, 0); }
public TerminalNode TO() { return getToken(XPath2Parser.TO, 0); }
public TerminalNode CHILD() { return getToken(XPath2Parser.CHILD, 0); }
public TerminalNode DESCENDANT() { return getToken(XPath2Parser.DESCENDANT, 0); }
public TerminalNode SELF() { return getToken(XPath2Parser.SELF, 0); }
public TerminalNode DESCENDANT_OR_SELF() { return getToken(XPath2Parser.DESCENDANT_OR_SELF, 0); }
public TerminalNode FOLLOWING_SIBLING() { return getToken(XPath2Parser.FOLLOWING_SIBLING, 0); }
public TerminalNode FOLLOWING() { return getToken(XPath2Parser.FOLLOWING, 0); }
public TerminalNode NAMESPACE() { return getToken(XPath2Parser.NAMESPACE, 0); }
public TerminalNode PARENT() { return getToken(XPath2Parser.PARENT, 0); }
public TerminalNode ANCESTOR() { return getToken(XPath2Parser.ANCESTOR, 0); }
public TerminalNode PRECEDING_SIBLING() { return getToken(XPath2Parser.PRECEDING_SIBLING, 0); }
public TerminalNode PRECEDING() { return getToken(XPath2Parser.PRECEDING, 0); }
public TerminalNode ANCESTOR_OR_SELF() { return getToken(XPath2Parser.ANCESTOR_OR_SELF, 0); }
public TerminalNode UNION() { return getToken(XPath2Parser.UNION, 0); }
public TerminalNode INTERSECT() { return getToken(XPath2Parser.INTERSECT, 0); }
public TerminalNode EXCEPT() { return getToken(XPath2Parser.EXCEPT, 0); }
public TerminalNode INSTANCE() { return getToken(XPath2Parser.INSTANCE, 0); }
public TerminalNode OF() { return getToken(XPath2Parser.OF, 0); }
public TerminalNode AS() { return getToken(XPath2Parser.AS, 0); }
public TerminalNode TREAT() { return getToken(XPath2Parser.TREAT, 0); }
public TerminalNode CASTABLE() { return getToken(XPath2Parser.CASTABLE, 0); }
public TerminalNode CAST() { return getToken(XPath2Parser.CAST, 0); }
public TerminalNode IS() { return getToken(XPath2Parser.IS, 0); }
public TerminalNode FOR() { return getToken(XPath2Parser.FOR, 0); }
public TerminalNode IN() { return getToken(XPath2Parser.IN, 0); }
public TerminalNode RETURN() { return getToken(XPath2Parser.RETURN, 0); }
public TerminalNode SATISFIES() { return getToken(XPath2Parser.SATISFIES, 0); }
public TerminalNode SOME() { return getToken(XPath2Parser.SOME, 0); }
public TerminalNode EVERY() { return getToken(XPath2Parser.EVERY, 0); }
public TerminalNode THEN() { return getToken(XPath2Parser.THEN, 0); }
public TerminalNode ELSE() { return getToken(XPath2Parser.ELSE, 0); }
public TerminalNode AND() { return getToken(XPath2Parser.AND, 0); }
public TerminalNode OR() { return getToken(XPath2Parser.OR, 0); }
public TerminalNode DIV() { return getToken(XPath2Parser.DIV, 0); }
public TerminalNode IDIV() { return getToken(XPath2Parser.IDIV, 0); }
public TerminalNode MOD() { return getToken(XPath2Parser.MOD, 0); }
public TerminalNode EQ() { return getToken(XPath2Parser.EQ, 0); }
public TerminalNode NE() { return getToken(XPath2Parser.NE, 0); }
public TerminalNode LT() { return getToken(XPath2Parser.LT, 0); }
public TerminalNode LE() { return getToken(XPath2Parser.LE, 0); }
public TerminalNode GT() { return getToken(XPath2Parser.GT, 0); }
public TerminalNode GE() { return getToken(XPath2Parser.GE, 0); }
public ReservedFunctionNCNamesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_reservedFunctionNCNames; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).enterReservedFunctionNCNames(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof XPath2ParserListener ) ((XPath2ParserListener)listener).exitReservedFunctionNCNames(this);
}
}
public final ReservedFunctionNCNamesContext reservedFunctionNCNames() throws RecognitionException {
ReservedFunctionNCNamesContext _localctx = new ReservedFunctionNCNamesContext(_ctx, getState());
enterRule(_localctx, 158, RULE_reservedFunctionNCNames);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(733);
_la = _input.LA(1);
if ( !(((((_la - 31)) & ~0x3f) == 0 && ((1L << (_la - 31)) & ((1L << (CHILD - 31)) | (1L << (DESCENDANT - 31)) | (1L << (SELF - 31)) | (1L << (DESCENDANT_OR_SELF - 31)) | (1L << (FOLLOWING_SIBLING - 31)) | (1L << (FOLLOWING - 31)) | (1L << (NAMESPACE - 31)) | (1L << (PARENT - 31)) | (1L << (ANCESTOR - 31)) | (1L << (PRECEDING_SIBLING - 31)) | (1L << (PRECEDING - 31)) | (1L << (ANCESTOR_OR_SELF - 31)) | (1L << (EQ - 31)) | (1L << (NE - 31)) | (1L << (LT - 31)) | (1L << (LE - 31)) | (1L << (GT - 31)) | (1L << (GE - 31)) | (1L << (IDIV - 31)) | (1L << (DIV - 31)) | (1L << (MOD - 31)) | (1L << (UNION - 31)) | (1L << (INTERSECT - 31)) | (1L << (EXCEPT - 31)) | (1L << (INSTANCE - 31)) | (1L << (TREAT - 31)) | (1L << (CASTABLE - 31)) | (1L << (CAST - 31)) | (1L << (AS - 31)) | (1L << (OF - 31)) | (1L << (IS - 31)) | (1L << (FOR - 31)) | (1L << (IN - 31)) | (1L << (RETURN - 31)) | (1L << (SATISFIES - 31)) | (1L << (TO - 31)) | (1L << (SOME - 31)) | (1L << (EVERY - 31)) | (1L << (THEN - 31)) | (1L << (ELSE - 31)) | (1L << (AND - 31)) | (1L << (OR - 31)) | (1L << (NCNAME - 31)))) != 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 4:
return simpleForClause_sempred((SimpleForClauseContext)_localctx, predIndex);
case 6:
return quantifiedExprMiddle_sempred((QuantifiedExprMiddleContext)_localctx, predIndex);
case 8:
return orExpr_sempred((OrExprContext)_localctx, predIndex);
case 9:
return andExpr_sempred((AndExprContext)_localctx, predIndex);
case 12:
return additiveExpr_sempred((AdditiveExprContext)_localctx, predIndex);
case 13:
return multiplicativeExpr_sempred((MultiplicativeExprContext)_localctx, predIndex);
case 14:
return unionExpr_sempred((UnionExprContext)_localctx, predIndex);
case 15:
return intersectExceptExpr_sempred((IntersectExceptExprContext)_localctx, predIndex);
case 26:
return relativePathExpr_sempred((RelativePathExprContext)_localctx, predIndex);
case 49:
return functionCallMiddle_sempred((FunctionCallMiddleContext)_localctx, predIndex);
}
return true;
}
private boolean simpleForClause_sempred(SimpleForClauseContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 1);
}
return true;
}
private boolean quantifiedExprMiddle_sempred(QuantifiedExprMiddleContext _localctx, int predIndex) {
switch (predIndex) {
case 1:
return precpred(_ctx, 1);
}
return true;
}
private boolean orExpr_sempred(OrExprContext _localctx, int predIndex) {
switch (predIndex) {
case 2:
return precpred(_ctx, 1);
}
return true;
}
private boolean andExpr_sempred(AndExprContext _localctx, int predIndex) {
switch (predIndex) {
case 3:
return precpred(_ctx, 1);
}
return true;
}
private boolean additiveExpr_sempred(AdditiveExprContext _localctx, int predIndex) {
switch (predIndex) {
case 4:
return precpred(_ctx, 2);
case 5:
return precpred(_ctx, 1);
}
return true;
}
private boolean multiplicativeExpr_sempred(MultiplicativeExprContext _localctx, int predIndex) {
switch (predIndex) {
case 6:
return precpred(_ctx, 4);
case 7:
return precpred(_ctx, 3);
case 8:
return precpred(_ctx, 2);
case 9:
return precpred(_ctx, 1);
}
return true;
}
private boolean unionExpr_sempred(UnionExprContext _localctx, int predIndex) {
switch (predIndex) {
case 10:
return precpred(_ctx, 2);
case 11:
return precpred(_ctx, 1);
}
return true;
}
private boolean intersectExceptExpr_sempred(IntersectExceptExprContext _localctx, int predIndex) {
switch (predIndex) {
case 12:
return precpred(_ctx, 2);
case 13:
return precpred(_ctx, 1);
}
return true;
}
private boolean relativePathExpr_sempred(RelativePathExprContext _localctx, int predIndex) {
switch (predIndex) {
case 14:
return precpred(_ctx, 2);
case 15:
return precpred(_ctx, 1);
}
return true;
}
private boolean functionCallMiddle_sempred(FunctionCallMiddleContext _localctx, int predIndex) {
switch (predIndex) {
case 16:
return precpred(_ctx, 1);
}
return true;
}
public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\\\u02e2\4\2\t\2\4"+
"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\3\2\3\2\3\2\3\3\3"+
"\3\3\3\7\3\u00a9\n\3\f\3\16\3\u00ac\13\3\3\4\3\4\3\4\3\4\5\4\u00b2\n\4"+
"\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3"+
"\6\7\6\u00c6\n\6\f\6\16\6\u00c9\13\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3"+
"\7\3\7\3\7\3\7\5\7\u00d7\n\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3"+
"\b\3\b\7\b\u00e5\n\b\f\b\16\b\u00e8\13\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3"+
"\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\7\n\u00f9\n\n\f\n\16\n\u00fc\13\n\3\13"+
"\3\13\3\13\3\13\3\13\3\13\7\13\u0104\n\13\f\13\16\13\u0107\13\13\3\f\3"+
"\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\5\f\u0116\n\f\3\r\3\r\3"+
"\r\3\r\3\r\5\r\u011d\n\r\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16"+
"\7\16\u0128\n\16\f\16\16\16\u012b\13\16\3\17\3\17\3\17\3\17\3\17\3\17"+
"\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\7\17\u013c\n\17\f\17\16"+
"\17\u013f\13\17\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\7\20\u014a"+
"\n\20\f\20\16\20\u014d\13\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3"+
"\21\7\21\u0158\n\21\f\21\16\21\u015b\13\21\3\22\3\22\3\22\3\22\3\22\3"+
"\22\5\22\u0163\n\22\3\23\3\23\3\23\3\23\3\23\3\23\5\23\u016b\n\23\3\24"+
"\3\24\3\24\3\24\3\24\3\24\5\24\u0173\n\24\3\25\3\25\3\25\3\25\3\25\3\25"+
"\5\25\u017b\n\25\3\26\3\26\3\26\3\26\3\26\5\26\u0182\n\26\3\27\3\27\3"+
"\30\3\30\3\31\3\31\3\32\3\32\3\33\3\33\3\33\3\33\3\33\3\33\5\33\u0192"+
"\n\33\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\7\34\u019d\n\34\f\34"+
"\16\34\u01a0\13\34\3\35\3\35\5\35\u01a4\n\35\3\36\3\36\3\36\3\36\3\36"+
"\3\36\5\36\u01ac\n\36\3\37\3\37\3\37\3\37\5\37\u01b2\n\37\3 \3 \3 \3 "+
"\3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \5 \u01c4\n \3!\3!\3!\5!\u01c9\n!"+
"\3\"\3\"\3\"\3\"\5\"\u01cf\n\"\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\5#\u01db"+
"\n#\3$\3$\3%\3%\5%\u01e1\n%\3&\3&\5&\u01e5\n&\3\'\3\'\3\'\3\'\3\'\3\'"+
"\3\'\3\'\5\'\u01ef\n\'\3(\3(\3(\3)\7)\u01f5\n)\f)\16)\u01f8\13)\3*\3*"+
"\3*\3*\3+\3+\3+\3+\3+\5+\u0203\n+\3,\3,\5,\u0207\n,\3-\3-\3-\5-\u020c"+
"\n-\3.\3.\3.\3/\3/\3\60\3\60\3\60\3\60\3\60\3\60\5\60\u0219\n\60\3\61"+
"\3\61\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\5\62\u0226\n\62\3\63"+
"\3\63\3\63\3\63\3\63\3\63\7\63\u022e\n\63\f\63\16\63\u0231\13\63\3\64"+
"\3\64\3\64\3\64\5\64\u0237\n\64\3\65\3\65\3\65\3\65\3\65\3\65\3\65\5\65"+
"\u0240\n\65\3\66\3\66\3\67\3\67\3\67\3\67\3\67\5\67\u0249\n\67\38\38\3"+
"9\39\39\39\39\39\39\39\39\59\u0256\n9\3:\3:\3:\3:\3;\3;\3;\3;\3;\3;\3"+
";\3;\3;\3;\3;\3;\3;\5;\u0269\n;\3<\3<\3<\3<\3=\3=\3=\3=\3>\3>\3>\3>\3"+
">\3>\3>\3>\3>\3>\3>\3>\3>\5>\u0280\n>\3?\3?\3?\3?\3?\3?\3?\3?\3?\3?\3"+
"?\3?\3?\3?\3?\5?\u0291\n?\3@\3@\5@\u0295\n@\3A\3A\3A\3A\3A\3B\3B\3C\3"+
"C\3C\3C\3C\3C\3C\3C\3C\3C\3C\3C\3C\3C\3C\3C\3C\3C\3C\3C\3C\3C\3C\5C\u02b5"+
"\nC\3D\3D\5D\u02b9\nD\3E\3E\3E\3E\3E\3F\3F\3G\3G\3H\3H\3I\3I\3J\3J\3K"+
"\3K\3L\3L\3M\3M\3N\3N\3N\3N\3N\5N\u02d5\nN\3O\3O\3P\3P\3P\3P\3P\5P\u02de"+
"\nP\3Q\3Q\3Q\2\f\n\16\22\24\32\34\36 \66dR\2\4\6\b\n\f\16\20\22\24\26"+
"\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|"+
"~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096"+
"\u0098\u009a\u009c\u009e\u00a0\2\b\3\2\17\24\3\2.\63\4\2\25\26@@\5\2\13"+
"\13\r\r \4\2!W\\\\\6\2!\"$GIL\\\\\2\u02ec\2\u00a2\3\2\2\2\4\u00a5\3\2"+
"\2\2\6\u00b1\3\2\2\2\b\u00b3\3\2\2\2\n\u00b7\3\2\2\2\f\u00d6\3\2\2\2\16"+
"\u00d8\3\2\2\2\20\u00e9\3\2\2\2\22\u00f2\3\2\2\2\24\u00fd\3\2\2\2\26\u0115"+
"\3\2\2\2\30\u011c\3\2\2\2\32\u011e\3\2\2\2\34\u012c\3\2\2\2\36\u0140\3"+
"\2\2\2 \u014e\3\2\2\2\"\u0162\3\2\2\2$\u016a\3\2\2\2&\u0172\3\2\2\2(\u017a"+
"\3\2\2\2*\u0181\3\2\2\2,\u0183\3\2\2\2.\u0185\3\2\2\2\60\u0187\3\2\2\2"+
"\62\u0189\3\2\2\2\64\u0191\3\2\2\2\66\u0193\3\2\2\28\u01a3\3\2\2\2:\u01ab"+
"\3\2\2\2<\u01b1\3\2\2\2>\u01c3\3\2\2\2@\u01c8\3\2\2\2B\u01ce\3\2\2\2D"+
"\u01da\3\2\2\2F\u01dc\3\2\2\2H\u01e0\3\2\2\2J\u01e4\3\2\2\2L\u01ee\3\2"+
"\2\2N\u01f0\3\2\2\2P\u01f6\3\2\2\2R\u01f9\3\2\2\2T\u0202\3\2\2\2V\u0206"+
"\3\2\2\2X\u020b\3\2\2\2Z\u020d\3\2\2\2\\\u0210\3\2\2\2^\u0218\3\2\2\2"+
"`\u021a\3\2\2\2b\u0225\3\2\2\2d\u0227\3\2\2\2f\u0236\3\2\2\2h\u023f\3"+
"\2\2\2j\u0241\3\2\2\2l\u0248\3\2\2\2n\u024a\3\2\2\2p\u0255\3\2\2\2r\u0257"+
"\3\2\2\2t\u0268\3\2\2\2v\u026a\3\2\2\2x\u026e\3\2\2\2z\u027f\3\2\2\2|"+
"\u0290\3\2\2\2~\u0294\3\2\2\2\u0080\u0296\3\2\2\2\u0082\u029b\3\2\2\2"+
"\u0084\u02b4\3\2\2\2\u0086\u02b8\3\2\2\2\u0088\u02ba\3\2\2\2\u008a\u02bf"+
"\3\2\2\2\u008c\u02c1\3\2\2\2\u008e\u02c3\3\2\2\2\u0090\u02c5\3\2\2\2\u0092"+
"\u02c7\3\2\2\2\u0094\u02c9\3\2\2\2\u0096\u02cb\3\2\2\2\u0098\u02cd\3\2"+
"\2\2\u009a\u02d4\3\2\2\2\u009c\u02d6\3\2\2\2\u009e\u02dd\3\2\2\2\u00a0"+
"\u02df\3\2\2\2\u00a2\u00a3\5\4\3\2\u00a3\u00a4\7\2\2\3\u00a4\3\3\2\2\2"+
"\u00a5\u00aa\5\6\4\2\u00a6\u00a7\7\35\2\2\u00a7\u00a9\5\6\4\2\u00a8\u00a6"+
"\3\2\2\2\u00a9\u00ac\3\2\2\2\u00aa\u00a8\3\2\2\2\u00aa\u00ab\3\2\2\2\u00ab"+
"\5\3\2\2\2\u00ac\u00aa\3\2\2\2\u00ad\u00b2\5\b\5\2\u00ae\u00b2\5\f\7\2"+
"\u00af\u00b2\5\20\t\2\u00b0\u00b2\5\22\n\2\u00b1\u00ad\3\2\2\2\u00b1\u00ae"+
"\3\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b0\3\2\2\2\u00b2\7\3\2\2\2\u00b3"+
"\u00b4\5\n\6\2\u00b4\u00b5\7C\2\2\u00b5\u00b6\5\6\4\2\u00b6\t\3\2\2\2"+
"\u00b7\u00b8\b\6\1\2\u00b8\u00b9\7A\2\2\u00b9\u00ba\7\36\2\2\u00ba\u00bb"+
"\5\\/\2\u00bb\u00bc\7B\2\2\u00bc\u00bd\5\6\4\2\u00bd\u00c7\3\2\2\2\u00be"+
"\u00bf\f\3\2\2\u00bf\u00c0\7\35\2\2\u00c0\u00c1\7\36\2\2\u00c1\u00c2\5"+
"\\/\2\u00c2\u00c3\7B\2\2\u00c3\u00c4\5\6\4\2\u00c4\u00c6\3\2\2\2\u00c5"+
"\u00be\3\2\2\2\u00c6\u00c9\3\2\2\2\u00c7\u00c5\3\2\2\2\u00c7\u00c8\3\2"+
"\2\2\u00c8\13\3\2\2\2\u00c9\u00c7\3\2\2\2\u00ca\u00cb\7F\2\2\u00cb\u00cc"+
"\7\36\2\2\u00cc\u00cd\5\16\b\2\u00cd\u00ce\7D\2\2\u00ce\u00cf\5\6\4\2"+
"\u00cf\u00d7\3\2\2\2\u00d0\u00d1\7G\2\2\u00d1\u00d2\7\36\2\2\u00d2\u00d3"+
"\5\16\b\2\u00d3\u00d4\7D\2\2\u00d4\u00d5\5\6\4\2\u00d5\u00d7\3\2\2\2\u00d6"+
"\u00ca\3\2\2\2\u00d6\u00d0\3\2\2\2\u00d7\r\3\2\2\2\u00d8\u00d9\b\b\1\2"+
"\u00d9\u00da\5\\/\2\u00da\u00db\7B\2\2\u00db\u00dc\5\6\4\2\u00dc\u00e6"+
"\3\2\2\2\u00dd\u00de\f\3\2\2\u00de\u00df\7\35\2\2\u00df\u00e0\7\36\2\2"+
"\u00e0\u00e1\5\\/\2\u00e1\u00e2\7B\2\2\u00e2\u00e3\5\6\4\2\u00e3\u00e5"+
"\3\2\2\2\u00e4\u00dd\3\2\2\2\u00e5\u00e8\3\2\2\2\u00e6\u00e4\3\2\2\2\u00e6"+
"\u00e7\3\2\2\2\u00e7\17\3\2\2\2\u00e8\u00e6\3\2\2\2\u00e9\u00ea\7H\2\2"+
"\u00ea\u00eb\7\t\2\2\u00eb\u00ec\5\4\3\2\u00ec\u00ed\7\n\2\2\u00ed\u00ee"+
"\7I\2\2\u00ee\u00ef\5\6\4\2\u00ef\u00f0\7J\2\2\u00f0\u00f1\5\6\4\2\u00f1"+
"\21\3\2\2\2\u00f2\u00f3\b\n\1\2\u00f3\u00f4\5\24\13\2\u00f4\u00fa\3\2"+
"\2\2\u00f5\u00f6\f\3\2\2\u00f6\u00f7\7L\2\2\u00f7\u00f9\5\24\13\2\u00f8"+
"\u00f5\3\2\2\2\u00f9\u00fc\3\2\2\2\u00fa\u00f8\3\2\2\2\u00fa\u00fb\3\2"+
"\2\2\u00fb\23\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fd\u00fe\b\13\1\2\u00fe\u00ff"+
"\5\26\f\2\u00ff\u0105\3\2\2\2\u0100\u0101\f\3\2\2\u0101\u0102\7K\2\2\u0102"+
"\u0104\5\26\f\2\u0103\u0100\3\2\2\2\u0104\u0107\3\2\2\2\u0105\u0103\3"+
"\2\2\2\u0105\u0106\3\2\2\2\u0106\25\3\2\2\2\u0107\u0105\3\2\2\2\u0108"+
"\u0116\5\30\r\2\u0109\u010a\5\30\r\2\u010a\u010b\5\60\31\2\u010b\u010c"+
"\5\30\r\2\u010c\u0116\3\2\2\2\u010d\u010e\5\30\r\2\u010e\u010f\5.\30\2"+
"\u010f\u0110\5\30\r\2\u0110\u0116\3\2\2\2\u0111\u0112\5\30\r\2\u0112\u0113"+
"\5\62\32\2\u0113\u0114\5\30\r\2\u0114\u0116\3\2\2\2\u0115\u0108\3\2\2"+
"\2\u0115\u0109\3\2\2\2\u0115\u010d\3\2\2\2\u0115\u0111\3\2\2\2\u0116\27"+
"\3\2\2\2\u0117\u011d\5\32\16\2\u0118\u0119\5\32\16\2\u0119\u011a\7E\2"+
"\2\u011a\u011b\5\32\16\2\u011b\u011d\3\2\2\2\u011c\u0117\3\2\2\2\u011c"+
"\u0118\3\2\2\2\u011d\31\3\2\2\2\u011e\u011f\b\16\1\2\u011f\u0120\5\34"+
"\17\2\u0120\u0129\3\2\2\2\u0121\u0122\f\4\2\2\u0122\u0123\7\13\2\2\u0123"+
"\u0128\5\34\17\2\u0124\u0125\f\3\2\2\u0125\u0126\7\f\2\2\u0126\u0128\5"+
"\34\17\2\u0127\u0121\3\2\2\2\u0127\u0124\3\2\2\2\u0128\u012b\3\2\2\2\u0129"+
"\u0127\3\2\2\2\u0129\u012a\3\2\2\2\u012a\33\3\2\2\2\u012b\u0129\3\2\2"+
"\2\u012c\u012d\b\17\1\2\u012d\u012e\5\36\20\2\u012e\u013d\3\2\2\2\u012f"+
"\u0130\f\6\2\2\u0130\u0131\7\r\2\2\u0131\u013c\5\36\20\2\u0132\u0133\f"+
"\5\2\2\u0133\u0134\7\65\2\2\u0134\u013c\5\36\20\2\u0135\u0136\f\4\2\2"+
"\u0136\u0137\7\64\2\2\u0137\u013c\5\36\20\2\u0138\u0139\f\3\2\2\u0139"+
"\u013a\7\66\2\2\u013a\u013c\5\36\20\2\u013b\u012f\3\2\2\2\u013b\u0132"+
"\3\2\2\2\u013b\u0135\3\2\2\2\u013b\u0138\3\2\2\2\u013c\u013f\3\2\2\2\u013d"+
"\u013b\3\2\2\2\u013d\u013e\3\2\2\2\u013e\35\3\2\2\2\u013f\u013d\3\2\2"+
"\2\u0140\u0141\b\20\1\2\u0141\u0142\5 \21\2\u0142\u014b\3\2\2\2\u0143"+
"\u0144\f\4\2\2\u0144\u0145\7\67\2\2\u0145\u014a\5 \21\2\u0146\u0147\f"+
"\3\2\2\u0147\u0148\7\16\2\2\u0148\u014a\5 \21\2\u0149\u0143\3\2\2\2\u0149"+
"\u0146\3\2\2\2\u014a\u014d\3\2\2\2\u014b\u0149\3\2\2\2\u014b\u014c\3\2"+
"\2\2\u014c\37\3\2\2\2\u014d\u014b\3\2\2\2\u014e\u014f\b\21\1\2\u014f\u0150"+
"\5\"\22\2\u0150\u0159\3\2\2\2\u0151\u0152\f\4\2\2\u0152\u0153\78\2\2\u0153"+
"\u0158\5\"\22\2\u0154\u0155\f\3\2\2\u0155\u0156\79\2\2\u0156\u0158\5\""+
"\22\2\u0157\u0151\3\2\2\2\u0157\u0154\3\2\2\2\u0158\u015b\3\2\2\2\u0159"+
"\u0157\3\2\2\2\u0159\u015a\3\2\2\2\u015a!\3\2\2\2\u015b\u0159\3\2\2\2"+
"\u015c\u0163\5$\23\2\u015d\u015e\5$\23\2\u015e\u015f\7:\2\2\u015f\u0160"+
"\7?\2\2\u0160\u0161\5h\65\2\u0161\u0163\3\2\2\2\u0162\u015c\3\2\2\2\u0162"+
"\u015d\3\2\2\2\u0163#\3\2\2\2\u0164\u016b\5&\24\2\u0165\u0166\5&\24\2"+
"\u0166\u0167\7;\2\2\u0167\u0168\7>\2\2\u0168\u0169\5h\65\2\u0169\u016b"+
"\3\2\2\2\u016a\u0164\3\2\2\2\u016a\u0165\3\2\2\2\u016b%\3\2\2\2\u016c"+
"\u0173\5(\25\2\u016d\u016e\5(\25\2\u016e\u016f\7<\2\2\u016f\u0170\7>\2"+
"\2\u0170\u0171\5f\64\2\u0171\u0173\3\2\2\2\u0172\u016c\3\2\2\2\u0172\u016d"+
"\3\2\2\2\u0173\'\3\2\2\2\u0174\u017b\5*\26\2\u0175\u0176\5*\26\2\u0176"+
"\u0177\7=\2\2\u0177\u0178\7>\2\2\u0178\u0179\5f\64\2\u0179\u017b\3\2\2"+
"\2\u017a\u0174\3\2\2\2\u017a\u0175\3\2\2\2\u017b)\3\2\2\2\u017c\u0182"+
"\5,\27\2\u017d\u017e\7\f\2\2\u017e\u0182\5*\26\2\u017f\u0180\7\13\2\2"+
"\u0180\u0182\5*\26\2\u0181\u017c\3\2\2\2\u0181\u017d\3\2\2\2\u0181\u017f"+
"\3\2\2\2\u0182+\3\2\2\2\u0183\u0184\5\64\33\2\u0184-\3\2\2\2\u0185\u0186"+
"\t\2\2\2\u0186/\3\2\2\2\u0187\u0188\t\3\2\2\u0188\61\3\2\2\2\u0189\u018a"+
"\t\4\2\2\u018a\63\3\2\2\2\u018b\u0192\7\27\2\2\u018c\u018d\7\27\2\2\u018d"+
"\u0192\5\66\34\2\u018e\u018f\7\30\2\2\u018f\u0192\5\66\34\2\u0190\u0192"+
"\5\66\34\2\u0191\u018b\3\2\2\2\u0191\u018c\3\2\2\2\u0191\u018e\3\2\2\2"+
"\u0191\u0190\3\2\2\2\u0192\65\3\2\2\2\u0193\u0194\b\34\1\2\u0194\u0195"+
"\58\35\2\u0195\u019e\3\2\2\2\u0196\u0197\f\4\2\2\u0197\u0198\7\27\2\2"+
"\u0198\u019d\58\35\2\u0199\u019a\f\3\2\2\u019a\u019b\7\30\2\2\u019b\u019d"+
"\58\35\2\u019c\u0196\3\2\2\2\u019c\u0199\3\2\2\2\u019d\u01a0\3\2\2\2\u019e"+
"\u019c\3\2\2\2\u019e\u019f\3\2\2\2\u019f\67\3\2\2\2\u01a0\u019e\3\2\2"+
"\2\u01a1\u01a4\5:\36\2\u01a2\u01a4\5N(\2\u01a3\u01a1\3\2\2\2\u01a3\u01a2"+
"\3\2\2\2\u01a49\3\2\2\2\u01a5\u01a6\5<\37\2\u01a6\u01a7\5P)\2\u01a7\u01ac"+
"\3\2\2\2\u01a8\u01a9\5B\"\2\u01a9\u01aa\5P)\2\u01aa\u01ac\3\2\2\2\u01ab"+
"\u01a5\3\2\2\2\u01ab\u01a8\3\2\2\2\u01ac;\3\2\2\2\u01ad\u01ae\5> \2\u01ae"+
"\u01af\5H%\2\u01af\u01b2\3\2\2\2\u01b0\u01b2\5@!\2\u01b1\u01ad\3\2\2\2"+
"\u01b1\u01b0\3\2\2\2\u01b2=\3\2\2\2\u01b3\u01b4\7!\2\2\u01b4\u01c4\7\31"+
"\2\2\u01b5\u01b6\7\"\2\2\u01b6\u01c4\7\31\2\2\u01b7\u01b8\7#\2\2\u01b8"+
"\u01c4\7\31\2\2\u01b9\u01ba\7$\2\2\u01ba\u01c4\7\31\2\2\u01bb\u01bc\7"+
"%\2\2\u01bc\u01c4\7\31\2\2\u01bd\u01be\7&\2\2\u01be\u01c4\7\31\2\2\u01bf"+
"\u01c0\7\'\2\2\u01c0\u01c4\7\31\2\2\u01c1\u01c2\7(\2\2\u01c2\u01c4\7\31"+
"\2\2\u01c3\u01b3\3\2\2\2\u01c3\u01b5\3\2\2\2\u01c3\u01b7\3\2\2\2\u01c3"+
"\u01b9\3\2\2\2\u01c3\u01bb\3\2\2\2\u01c3\u01bd\3\2\2\2\u01c3\u01bf\3\2"+
"\2\2\u01c3\u01c1\3\2\2\2\u01c4?\3\2\2\2\u01c5\u01c6\7\32\2\2\u01c6\u01c9"+
"\5H%\2\u01c7\u01c9\5H%\2\u01c8\u01c5\3\2\2\2\u01c8\u01c7\3\2\2\2\u01c9"+
"A\3\2\2\2\u01ca\u01cb\5D#\2\u01cb\u01cc\5H%\2\u01cc\u01cf\3\2\2\2\u01cd"+
"\u01cf\5F$\2\u01ce\u01ca\3\2\2\2\u01ce\u01cd\3\2\2\2\u01cfC\3\2\2\2\u01d0"+
"\u01d1\7)\2\2\u01d1\u01db\7\31\2\2\u01d2\u01d3\7*\2\2\u01d3\u01db\7\31"+
"\2\2\u01d4\u01d5\7+\2\2\u01d5\u01db\7\31\2\2\u01d6\u01d7\7,\2\2\u01d7"+
"\u01db\7\31\2\2\u01d8\u01d9\7-\2\2\u01d9\u01db\7\31\2\2\u01da\u01d0\3"+
"\2\2\2\u01da\u01d2\3\2\2\2\u01da\u01d4\3\2\2\2\u01da\u01d6\3\2\2\2\u01da"+
"\u01d8\3\2\2\2\u01dbE\3\2\2\2\u01dc\u01dd\7\33\2\2\u01ddG\3\2\2\2\u01de"+
"\u01e1\5p9\2\u01df\u01e1\5J&\2\u01e0\u01de\3\2\2\2\u01e0\u01df\3\2\2\2"+
"\u01e1I\3\2\2\2\u01e2\u01e5\5\u009aN\2\u01e3\u01e5\5L\'\2\u01e4\u01e2"+
"\3\2\2\2\u01e4\u01e3\3\2\2\2\u01e5K\3\2\2\2\u01e6\u01ef\7\r\2\2\u01e7"+
"\u01e8\5\u009cO\2\u01e8\u01e9\7\34\2\2\u01e9\u01ea\7\r\2\2\u01ea\u01ef"+
"\3\2\2\2\u01eb\u01ec\7\r\2\2\u01ec\u01ed\7\34\2\2\u01ed\u01ef\5\u009c"+
"O\2\u01ee\u01e6\3\2\2\2\u01ee\u01e7\3\2\2\2\u01ee\u01eb\3\2\2\2\u01ef"+
"M\3\2\2\2\u01f0\u01f1\5T+\2\u01f1\u01f2\5P)\2\u01f2O\3\2\2\2\u01f3\u01f5"+
"\5R*\2\u01f4\u01f3\3\2\2\2\u01f5\u01f8\3\2\2\2\u01f6\u01f4\3\2\2\2\u01f6"+
"\u01f7\3\2\2\2\u01f7Q\3\2\2\2\u01f8\u01f6\3\2\2\2\u01f9\u01fa\7\7\2\2"+
"\u01fa\u01fb\5\4\3\2\u01fb\u01fc\7\b\2\2\u01fcS\3\2\2\2\u01fd\u0203\5"+
"V,\2\u01fe\u0203\5Z.\2\u01ff\u0203\5^\60\2\u0200\u0203\5`\61\2\u0201\u0203"+
"\5b\62\2\u0202\u01fd\3\2\2\2\u0202\u01fe\3\2\2\2\u0202\u01ff\3\2\2\2\u0202"+
"\u0200\3\2\2\2\u0202\u0201\3\2\2\2\u0203U\3\2\2\2\u0204\u0207\5X-\2\u0205"+
"\u0207\5\u0098M\2\u0206\u0204\3\2\2\2\u0206\u0205\3\2\2\2\u0207W\3\2\2"+
"\2\u0208\u020c\5\u0092J\2\u0209\u020c\5\u0094K\2\u020a\u020c\5\u0096L"+
"\2\u020b\u0208\3\2\2\2\u020b\u0209\3\2\2\2\u020b\u020a\3\2\2\2\u020cY"+
"\3\2\2\2\u020d\u020e\7\36\2\2\u020e\u020f\5\\/\2\u020f[\3\2\2\2\u0210"+
"\u0211\5\u009aN\2\u0211]\3\2\2\2\u0212\u0213\7\t\2\2\u0213\u0219\7\n\2"+
"\2\u0214\u0215\7\t\2\2\u0215\u0216\5\4\3\2\u0216\u0217\7\n\2\2\u0217\u0219"+
"\3\2\2\2\u0218\u0212\3\2\2\2\u0218\u0214\3\2\2\2\u0219_\3\2\2\2\u021a"+
"\u021b\7\37\2\2\u021ba\3\2\2\2\u021c\u021d\5\u009eP\2\u021d\u021e\7\t"+
"\2\2\u021e\u021f\7\n\2\2\u021f\u0226\3\2\2\2\u0220\u0221\5\u009eP\2\u0221"+
"\u0222\7\t\2\2\u0222\u0223\5d\63\2\u0223\u0224\7\n\2\2\u0224\u0226\3\2"+
"\2\2\u0225\u021c\3\2\2\2\u0225\u0220\3\2\2\2\u0226c\3\2\2\2\u0227\u0228"+
"\b\63\1\2\u0228\u0229\5\6\4\2\u0229\u022f\3\2\2\2\u022a\u022b\f\3\2\2"+
"\u022b\u022c\7\35\2\2\u022c\u022e\5\6\4\2\u022d\u022a\3\2\2\2\u022e\u0231"+
"\3\2\2\2\u022f\u022d\3\2\2\2\u022f\u0230\3\2\2\2\u0230e\3\2\2\2\u0231"+
"\u022f\3\2\2\2\u0232\u0237\5n8\2\u0233\u0234\5n8\2\u0234\u0235\7 \2\2"+
"\u0235\u0237\3\2\2\2\u0236\u0232\3\2\2\2\u0236\u0233\3\2\2\2\u0237g\3"+
"\2\2\2\u0238\u0240\5l\67\2\u0239\u023a\5l\67\2\u023a\u023b\5j\66\2\u023b"+
"\u0240\3\2\2\2\u023c\u023d\7M\2\2\u023d\u023e\7\t\2\2\u023e\u0240\7\n"+
"\2\2\u023f\u0238\3\2\2\2\u023f\u0239\3\2\2\2\u023f\u023c\3\2\2\2\u0240"+
"i\3\2\2\2\u0241\u0242\t\5\2\2\u0242k\3\2\2\2\u0243\u0249\5n8\2\u0244\u0249"+
"\5p9\2\u0245\u0246\7N\2\2\u0246\u0247\7\t\2\2\u0247\u0249\7\n\2\2\u0248"+
"\u0243\3\2\2\2\u0248\u0244\3\2\2\2\u0248\u0245\3\2\2\2\u0249m\3\2\2\2"+
"\u024a\u024b\5\u009aN\2\u024bo\3\2\2\2\u024c\u0256\5t;\2\u024d\u0256\5"+
"\u0084C\2\u024e\u0256\5|?\2\u024f\u0256\5\u0088E\2\u0250\u0256\5\u0080"+
"A\2\u0251\u0256\5z>\2\u0252\u0256\5x=\2\u0253\u0256\5v<\2\u0254\u0256"+
"\5r:\2\u0255\u024c\3\2\2\2\u0255\u024d\3\2\2\2\u0255\u024e\3\2\2\2\u0255"+
"\u024f\3\2\2\2\u0255\u0250\3\2\2\2\u0255\u0251\3\2\2\2\u0255\u0252\3\2"+
"\2\2\u0255\u0253\3\2\2\2\u0255\u0254\3\2\2\2\u0256q\3\2\2\2\u0257\u0258"+
"\7O\2\2\u0258\u0259\7\t\2\2\u0259\u025a\7\n\2\2\u025as\3\2\2\2\u025b\u025c"+
"\7P\2\2\u025c\u025d\7\t\2\2\u025d\u0269\7\n\2\2\u025e\u025f\7P\2\2\u025f"+
"\u0260\7\t\2\2\u0260\u0261\5\u0084C\2\u0261\u0262\7\n\2\2\u0262\u0269"+
"\3\2\2\2\u0263\u0264\7P\2\2\u0264\u0265\7\t\2\2\u0265\u0266\5\u0088E\2"+
"\u0266\u0267\7\n\2\2\u0267\u0269\3\2\2\2\u0268\u025b\3\2\2\2\u0268\u025e"+
"\3\2\2\2\u0268\u0263\3\2\2\2\u0269u\3\2\2\2\u026a\u026b\7Q\2\2\u026b\u026c"+
"\7\t\2\2\u026c\u026d\7\n\2\2\u026dw\3\2\2\2\u026e\u026f\7R\2\2\u026f\u0270"+
"\7\t\2\2\u0270\u0271\7\n\2\2\u0271y\3\2\2\2\u0272\u0273\7S\2\2\u0273\u0274"+
"\7\t\2\2\u0274\u0280\7\n\2\2\u0275\u0276\7S\2\2\u0276\u0277\7\t\2\2\u0277"+
"\u0278\5\u009cO\2\u0278\u0279\7\n\2\2\u0279\u0280\3\2\2\2\u027a\u027b"+
"\7S\2\2\u027b\u027c\7\t\2\2\u027c\u027d\5\u0098M\2\u027d\u027e\7\n\2\2"+
"\u027e\u0280\3\2\2\2\u027f\u0272\3\2\2\2\u027f\u0275\3\2\2\2\u027f\u027a"+
"\3\2\2\2\u0280{\3\2\2\2\u0281\u0282\7#\2\2\u0282\u0283\7\t\2\2\u0283\u0291"+
"\7\n\2\2\u0284\u0285\7#\2\2\u0285\u0286\7\t\2\2\u0286\u0287\5~@\2\u0287"+
"\u0288\7\n\2\2\u0288\u0291\3\2\2\2\u0289\u028a\7#\2\2\u028a\u028b\7\t"+
"\2\2\u028b\u028c\5~@\2\u028c\u028d\7\35\2\2\u028d\u028e\5\u0090I\2\u028e"+
"\u028f\7\n\2\2\u028f\u0291\3\2\2\2\u0290\u0281\3\2\2\2\u0290\u0284\3\2"+
"\2\2\u0290\u0289\3\2\2\2\u0291}\3\2\2\2\u0292\u0295\5\u008cG\2\u0293\u0295"+
"\7\r\2\2\u0294\u0292\3\2\2\2\u0294\u0293\3\2\2\2\u0295\177\3\2\2\2\u0296"+
"\u0297\7T\2\2\u0297\u0298\7\t\2\2\u0298\u0299\5\u0082B\2\u0299\u029a\7"+
"\n\2\2\u029a\u0081\3\2\2\2\u029b\u029c\5\u008cG\2\u029c\u0083\3\2\2\2"+
"\u029d\u029e\7U\2\2\u029e\u029f\7\t\2\2\u029f\u02b5\7\n\2\2\u02a0\u02a1"+
"\7U\2\2\u02a1\u02a2\7\t\2\2\u02a2\u02a3\5\u0086D\2\u02a3\u02a4\7\n\2\2"+
"\u02a4\u02b5\3\2\2\2\u02a5\u02a6\7U\2\2\u02a6\u02a7\7\t\2\2\u02a7\u02a8"+
"\5\u0086D\2\u02a8\u02a9\7\35\2\2\u02a9\u02aa\5\u0090I\2\u02aa\u02ab\7"+
"\n\2\2\u02ab\u02b5\3\2\2\2\u02ac\u02ad\7U\2\2\u02ad\u02ae\7\t\2\2\u02ae"+
"\u02af\5\u0086D\2\u02af\u02b0\7\35\2\2\u02b0\u02b1\5\u0090I\2\u02b1\u02b2"+
"\7 \2\2\u02b2\u02b3\7\n\2\2\u02b3\u02b5\3\2\2\2\u02b4\u029d\3\2\2\2\u02b4"+
"\u02a0\3\2\2\2\u02b4\u02a5\3\2\2\2\u02b4\u02ac\3\2\2\2\u02b5\u0085\3\2"+
"\2\2\u02b6\u02b9\5\u008eH\2\u02b7\u02b9\7\r\2\2\u02b8\u02b6\3\2\2\2\u02b8"+
"\u02b7\3\2\2\2\u02b9\u0087\3\2\2\2\u02ba\u02bb\7V\2\2\u02bb\u02bc\7\t"+
"\2\2\u02bc\u02bd\5\u008aF\2\u02bd\u02be\7\n\2\2\u02be\u0089\3\2\2\2\u02bf"+
"\u02c0\5\u008eH\2\u02c0\u008b\3\2\2\2\u02c1\u02c2\5\u009aN\2\u02c2\u008d"+
"\3\2\2\2\u02c3\u02c4\5\u009aN\2\u02c4\u008f\3\2\2\2\u02c5\u02c6\5\u009a"+
"N\2\u02c6\u0091\3\2\2\2\u02c7\u02c8\7\3\2\2\u02c8\u0093\3\2\2\2\u02c9"+
"\u02ca\7\4\2\2\u02ca\u0095\3\2\2\2\u02cb\u02cc\7\5\2\2\u02cc\u0097\3\2"+
"\2\2\u02cd\u02ce\7\6\2\2\u02ce\u0099\3\2\2\2\u02cf\u02d5\5\u009cO\2\u02d0"+
"\u02d1\5\u009cO\2\u02d1\u02d2\7\34\2\2\u02d2\u02d3\5\u009cO\2\u02d3\u02d5"+
"\3\2\2\2\u02d4\u02cf\3\2\2\2\u02d4\u02d0\3\2\2\2\u02d5\u009b\3\2\2\2\u02d6"+
"\u02d7\t\6\2\2\u02d7\u009d\3\2\2\2\u02d8\u02de\5\u00a0Q\2\u02d9\u02da"+
"\5\u009cO\2\u02da\u02db\7\34\2\2\u02db\u02dc\5\u009cO\2\u02dc\u02de\3"+
"\2\2\2\u02dd\u02d8\3\2\2\2\u02dd\u02d9\3\2\2\2\u02de\u009f\3\2\2\2\u02df"+
"\u02e0\t\7\2\2\u02e0\u00a1\3\2\2\28\u00aa\u00b1\u00c7\u00d6\u00e6\u00fa"+
"\u0105\u0115\u011c\u0127\u0129\u013b\u013d\u0149\u014b\u0157\u0159\u0162"+
"\u016a\u0172\u017a\u0181\u0191\u019c\u019e\u01a3\u01ab\u01b1\u01c3\u01c8"+
"\u01ce\u01da\u01e0\u01e4\u01ee\u01f6\u0202\u0206\u020b\u0218\u0225\u022f"+
"\u0236\u023f\u0248\u0255\u0268\u027f\u0290\u0294\u02b4\u02b8\u02d4\u02dd";
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);
}
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy