com.github.antlr.grammars_v4.xpath.xpathParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of xsd2pgschema Show documentation
Show all versions of xsd2pgschema Show documentation
Database replication tool based on XML Schema
// Generated from xpath.g4 by ANTLR 4.10.1
package com.github.antlr.grammars_v4.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 xpathParser extends Parser {
static { RuntimeMetaData.checkVersion("4.10.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, NodeType=9,
Number=10, AxisName=11, PATHSEP=12, ABRPATH=13, LPAR=14, RPAR=15, LBRAC=16,
RBRAC=17, MINUS=18, PLUS=19, DOT=20, MUL=21, DOTDOT=22, AT=23, COMMA=24,
PIPE=25, LESS=26, MORE_=27, LE=28, GE=29, COLON=30, CC=31, APOS=32, QUOT=33,
Literal=34, Whitespace=35, NCName=36;
public static final int
RULE_main = 0, RULE_locationPath = 1, RULE_absoluteLocationPathNoroot = 2,
RULE_relativeLocationPath = 3, RULE_step = 4, RULE_axisSpecifier = 5,
RULE_nodeTest = 6, RULE_predicate = 7, RULE_abbreviatedStep = 8, RULE_expr = 9,
RULE_primaryExpr = 10, RULE_functionCall = 11, RULE_unionExprNoRoot = 12,
RULE_pathExprNoRoot = 13, RULE_filterExpr = 14, RULE_orExpr = 15, RULE_andExpr = 16,
RULE_equalityExpr = 17, RULE_relationalExpr = 18, RULE_additiveExpr = 19,
RULE_multiplicativeExpr = 20, RULE_unaryExprNoRoot = 21, RULE_qName = 22,
RULE_functionName = 23, RULE_variableReference = 24, RULE_nameTest = 25,
RULE_nCName = 26;
private static String[] makeRuleNames() {
return new String[] {
"main", "locationPath", "absoluteLocationPathNoroot", "relativeLocationPath",
"step", "axisSpecifier", "nodeTest", "predicate", "abbreviatedStep",
"expr", "primaryExpr", "functionCall", "unionExprNoRoot", "pathExprNoRoot",
"filterExpr", "orExpr", "andExpr", "equalityExpr", "relationalExpr",
"additiveExpr", "multiplicativeExpr", "unaryExprNoRoot", "qName", "functionName",
"variableReference", "nameTest", "nCName"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'processing-instruction'", "'or'", "'and'", "'='", "'!='", "'div'",
"'mod'", "'$'", null, null, null, "'/'", "'//'", "'('", "')'", "'['",
"']'", "'-'", "'+'", "'.'", "'*'", "'..'", "'@'", "','", "'|'", "'<'",
"'>'", "'<='", "'>='", "':'", "'::'", "'''", "'\"'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, null, null, null, null, null, null, null, null, "NodeType", "Number",
"AxisName", "PATHSEP", "ABRPATH", "LPAR", "RPAR", "LBRAC", "RBRAC", "MINUS",
"PLUS", "DOT", "MUL", "DOTDOT", "AT", "COMMA", "PIPE", "LESS", "MORE_",
"LE", "GE", "COLON", "CC", "APOS", "QUOT", "Literal", "Whitespace", "NCName"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "xpath.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public xpathParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class MainContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public MainContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_main; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).enterMain(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitMain(this);
}
}
public final MainContext main() throws RecognitionException {
MainContext _localctx = new MainContext(_ctx, getState());
enterRule(_localctx, 0, RULE_main);
try {
enterOuterAlt(_localctx, 1);
{
setState(54);
expr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LocationPathContext extends ParserRuleContext {
public RelativeLocationPathContext relativeLocationPath() {
return getRuleContext(RelativeLocationPathContext.class,0);
}
public AbsoluteLocationPathNorootContext absoluteLocationPathNoroot() {
return getRuleContext(AbsoluteLocationPathNorootContext.class,0);
}
public LocationPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_locationPath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).enterLocationPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitLocationPath(this);
}
}
public final LocationPathContext locationPath() throws RecognitionException {
LocationPathContext _localctx = new LocationPathContext(_ctx, getState());
enterRule(_localctx, 2, RULE_locationPath);
try {
setState(58);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__0:
case NodeType:
case AxisName:
case DOT:
case MUL:
case DOTDOT:
case AT:
case NCName:
enterOuterAlt(_localctx, 1);
{
setState(56);
relativeLocationPath();
}
break;
case PATHSEP:
case ABRPATH:
enterOuterAlt(_localctx, 2);
{
setState(57);
absoluteLocationPathNoroot();
}
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 AbsoluteLocationPathNorootContext extends ParserRuleContext {
public TerminalNode PATHSEP() { return getToken(xpathParser.PATHSEP, 0); }
public RelativeLocationPathContext relativeLocationPath() {
return getRuleContext(RelativeLocationPathContext.class,0);
}
public TerminalNode ABRPATH() { return getToken(xpathParser.ABRPATH, 0); }
public AbsoluteLocationPathNorootContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_absoluteLocationPathNoroot; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).enterAbsoluteLocationPathNoroot(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitAbsoluteLocationPathNoroot(this);
}
}
public final AbsoluteLocationPathNorootContext absoluteLocationPathNoroot() throws RecognitionException {
AbsoluteLocationPathNorootContext _localctx = new AbsoluteLocationPathNorootContext(_ctx, getState());
enterRule(_localctx, 4, RULE_absoluteLocationPathNoroot);
try {
setState(64);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PATHSEP:
enterOuterAlt(_localctx, 1);
{
setState(60);
match(PATHSEP);
setState(61);
relativeLocationPath();
}
break;
case ABRPATH:
enterOuterAlt(_localctx, 2);
{
setState(62);
match(ABRPATH);
setState(63);
relativeLocationPath();
}
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 RelativeLocationPathContext extends ParserRuleContext {
public List step() {
return getRuleContexts(StepContext.class);
}
public StepContext step(int i) {
return getRuleContext(StepContext.class,i);
}
public List PATHSEP() { return getTokens(xpathParser.PATHSEP); }
public TerminalNode PATHSEP(int i) {
return getToken(xpathParser.PATHSEP, i);
}
public List ABRPATH() { return getTokens(xpathParser.ABRPATH); }
public TerminalNode ABRPATH(int i) {
return getToken(xpathParser.ABRPATH, i);
}
public RelativeLocationPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relativeLocationPath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).enterRelativeLocationPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitRelativeLocationPath(this);
}
}
public final RelativeLocationPathContext relativeLocationPath() throws RecognitionException {
RelativeLocationPathContext _localctx = new RelativeLocationPathContext(_ctx, getState());
enterRule(_localctx, 6, RULE_relativeLocationPath);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(66);
step();
setState(71);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==PATHSEP || _la==ABRPATH) {
{
{
setState(67);
_la = _input.LA(1);
if ( !(_la==PATHSEP || _la==ABRPATH) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(68);
step();
}
}
setState(73);
_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 StepContext extends ParserRuleContext {
public AxisSpecifierContext axisSpecifier() {
return getRuleContext(AxisSpecifierContext.class,0);
}
public NodeTestContext nodeTest() {
return getRuleContext(NodeTestContext.class,0);
}
public List predicate() {
return getRuleContexts(PredicateContext.class);
}
public PredicateContext predicate(int i) {
return getRuleContext(PredicateContext.class,i);
}
public AbbreviatedStepContext abbreviatedStep() {
return getRuleContext(AbbreviatedStepContext.class,0);
}
public StepContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_step; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).enterStep(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitStep(this);
}
}
public final StepContext step() throws RecognitionException {
StepContext _localctx = new StepContext(_ctx, getState());
enterRule(_localctx, 8, RULE_step);
int _la;
try {
setState(83);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__0:
case NodeType:
case AxisName:
case MUL:
case AT:
case NCName:
enterOuterAlt(_localctx, 1);
{
setState(74);
axisSpecifier();
setState(75);
nodeTest();
setState(79);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRAC) {
{
{
setState(76);
predicate();
}
}
setState(81);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case DOT:
case DOTDOT:
enterOuterAlt(_localctx, 2);
{
setState(82);
abbreviatedStep();
}
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 AxisSpecifierContext extends ParserRuleContext {
public TerminalNode AxisName() { return getToken(xpathParser.AxisName, 0); }
public TerminalNode CC() { return getToken(xpathParser.CC, 0); }
public TerminalNode AT() { return getToken(xpathParser.AT, 0); }
public AxisSpecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_axisSpecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).enterAxisSpecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitAxisSpecifier(this);
}
}
public final AxisSpecifierContext axisSpecifier() throws RecognitionException {
AxisSpecifierContext _localctx = new AxisSpecifierContext(_ctx, getState());
enterRule(_localctx, 10, RULE_axisSpecifier);
int _la;
try {
setState(90);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(85);
match(AxisName);
setState(86);
match(CC);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(88);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AT) {
{
setState(87);
match(AT);
}
}
}
break;
}
}
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 NameTestContext nameTest() {
return getRuleContext(NameTestContext.class,0);
}
public TerminalNode NodeType() { return getToken(xpathParser.NodeType, 0); }
public TerminalNode LPAR() { return getToken(xpathParser.LPAR, 0); }
public TerminalNode RPAR() { return getToken(xpathParser.RPAR, 0); }
public TerminalNode Literal() { return getToken(xpathParser.Literal, 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 xpathListener ) ((xpathListener)listener).enterNodeTest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitNodeTest(this);
}
}
public final NodeTestContext nodeTest() throws RecognitionException {
NodeTestContext _localctx = new NodeTestContext(_ctx, getState());
enterRule(_localctx, 12, RULE_nodeTest);
try {
setState(100);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(92);
nameTest();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(93);
match(NodeType);
setState(94);
match(LPAR);
setState(95);
match(RPAR);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(96);
match(T__0);
setState(97);
match(LPAR);
setState(98);
match(Literal);
setState(99);
match(RPAR);
}
break;
}
}
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 LBRAC() { return getToken(xpathParser.LBRAC, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode RBRAC() { return getToken(xpathParser.RBRAC, 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 xpathListener ) ((xpathListener)listener).enterPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitPredicate(this);
}
}
public final PredicateContext predicate() throws RecognitionException {
PredicateContext _localctx = new PredicateContext(_ctx, getState());
enterRule(_localctx, 14, RULE_predicate);
try {
enterOuterAlt(_localctx, 1);
{
setState(102);
match(LBRAC);
setState(103);
expr();
setState(104);
match(RBRAC);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AbbreviatedStepContext extends ParserRuleContext {
public TerminalNode DOT() { return getToken(xpathParser.DOT, 0); }
public TerminalNode DOTDOT() { return getToken(xpathParser.DOTDOT, 0); }
public AbbreviatedStepContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_abbreviatedStep; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).enterAbbreviatedStep(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitAbbreviatedStep(this);
}
}
public final AbbreviatedStepContext abbreviatedStep() throws RecognitionException {
AbbreviatedStepContext _localctx = new AbbreviatedStepContext(_ctx, getState());
enterRule(_localctx, 16, RULE_abbreviatedStep);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(106);
_la = _input.LA(1);
if ( !(_la==DOT || _la==DOTDOT) ) {
_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 ExprContext extends ParserRuleContext {
public OrExprContext orExpr() {
return getRuleContext(OrExprContext.class,0);
}
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 xpathListener ) ((xpathListener)listener).enterExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitExpr(this);
}
}
public final ExprContext expr() throws RecognitionException {
ExprContext _localctx = new ExprContext(_ctx, getState());
enterRule(_localctx, 18, RULE_expr);
try {
enterOuterAlt(_localctx, 1);
{
setState(108);
orExpr();
}
}
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 VariableReferenceContext variableReference() {
return getRuleContext(VariableReferenceContext.class,0);
}
public TerminalNode LPAR() { return getToken(xpathParser.LPAR, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode RPAR() { return getToken(xpathParser.RPAR, 0); }
public TerminalNode Literal() { return getToken(xpathParser.Literal, 0); }
public TerminalNode Number() { return getToken(xpathParser.Number, 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 xpathListener ) ((xpathListener)listener).enterPrimaryExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitPrimaryExpr(this);
}
}
public final PrimaryExprContext primaryExpr() throws RecognitionException {
PrimaryExprContext _localctx = new PrimaryExprContext(_ctx, getState());
enterRule(_localctx, 20, RULE_primaryExpr);
try {
setState(118);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__7:
enterOuterAlt(_localctx, 1);
{
setState(110);
variableReference();
}
break;
case LPAR:
enterOuterAlt(_localctx, 2);
{
setState(111);
match(LPAR);
setState(112);
expr();
setState(113);
match(RPAR);
}
break;
case Literal:
enterOuterAlt(_localctx, 3);
{
setState(115);
match(Literal);
}
break;
case Number:
enterOuterAlt(_localctx, 4);
{
setState(116);
match(Number);
}
break;
case NodeType:
case AxisName:
case NCName:
enterOuterAlt(_localctx, 5);
{
setState(117);
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 FunctionCallContext extends ParserRuleContext {
public FunctionNameContext functionName() {
return getRuleContext(FunctionNameContext.class,0);
}
public TerminalNode LPAR() { return getToken(xpathParser.LPAR, 0); }
public TerminalNode RPAR() { return getToken(xpathParser.RPAR, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public List COMMA() { return getTokens(xpathParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(xpathParser.COMMA, i);
}
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 xpathListener ) ((xpathListener)listener).enterFunctionCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitFunctionCall(this);
}
}
public final FunctionCallContext functionCall() throws RecognitionException {
FunctionCallContext _localctx = new FunctionCallContext(_ctx, getState());
enterRule(_localctx, 22, RULE_functionCall);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(120);
functionName();
setState(121);
match(LPAR);
setState(130);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__7) | (1L << NodeType) | (1L << Number) | (1L << AxisName) | (1L << PATHSEP) | (1L << ABRPATH) | (1L << LPAR) | (1L << MINUS) | (1L << DOT) | (1L << MUL) | (1L << DOTDOT) | (1L << AT) | (1L << Literal) | (1L << NCName))) != 0)) {
{
setState(122);
expr();
setState(127);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(123);
match(COMMA);
setState(124);
expr();
}
}
setState(129);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(132);
match(RPAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnionExprNoRootContext extends ParserRuleContext {
public PathExprNoRootContext pathExprNoRoot() {
return getRuleContext(PathExprNoRootContext.class,0);
}
public TerminalNode PIPE() { return getToken(xpathParser.PIPE, 0); }
public UnionExprNoRootContext unionExprNoRoot() {
return getRuleContext(UnionExprNoRootContext.class,0);
}
public TerminalNode PATHSEP() { return getToken(xpathParser.PATHSEP, 0); }
public UnionExprNoRootContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unionExprNoRoot; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).enterUnionExprNoRoot(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitUnionExprNoRoot(this);
}
}
public final UnionExprNoRootContext unionExprNoRoot() throws RecognitionException {
UnionExprNoRootContext _localctx = new UnionExprNoRootContext(_ctx, getState());
enterRule(_localctx, 24, RULE_unionExprNoRoot);
int _la;
try {
setState(142);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(134);
pathExprNoRoot();
setState(137);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PIPE) {
{
setState(135);
match(PIPE);
setState(136);
unionExprNoRoot();
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(139);
match(PATHSEP);
setState(140);
match(PIPE);
setState(141);
unionExprNoRoot();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PathExprNoRootContext extends ParserRuleContext {
public LocationPathContext locationPath() {
return getRuleContext(LocationPathContext.class,0);
}
public FilterExprContext filterExpr() {
return getRuleContext(FilterExprContext.class,0);
}
public RelativeLocationPathContext relativeLocationPath() {
return getRuleContext(RelativeLocationPathContext.class,0);
}
public TerminalNode PATHSEP() { return getToken(xpathParser.PATHSEP, 0); }
public TerminalNode ABRPATH() { return getToken(xpathParser.ABRPATH, 0); }
public PathExprNoRootContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pathExprNoRoot; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).enterPathExprNoRoot(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitPathExprNoRoot(this);
}
}
public final PathExprNoRootContext pathExprNoRoot() throws RecognitionException {
PathExprNoRootContext _localctx = new PathExprNoRootContext(_ctx, getState());
enterRule(_localctx, 26, RULE_pathExprNoRoot);
int _la;
try {
setState(150);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(144);
locationPath();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(145);
filterExpr();
setState(148);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PATHSEP || _la==ABRPATH) {
{
setState(146);
_la = _input.LA(1);
if ( !(_la==PATHSEP || _la==ABRPATH) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(147);
relativeLocationPath();
}
}
}
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 List predicate() {
return getRuleContexts(PredicateContext.class);
}
public PredicateContext predicate(int i) {
return getRuleContext(PredicateContext.class,i);
}
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 xpathListener ) ((xpathListener)listener).enterFilterExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitFilterExpr(this);
}
}
public final FilterExprContext filterExpr() throws RecognitionException {
FilterExprContext _localctx = new FilterExprContext(_ctx, getState());
enterRule(_localctx, 28, RULE_filterExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(152);
primaryExpr();
setState(156);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRAC) {
{
{
setState(153);
predicate();
}
}
setState(158);
_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 OrExprContext extends ParserRuleContext {
public List andExpr() {
return getRuleContexts(AndExprContext.class);
}
public AndExprContext andExpr(int i) {
return getRuleContext(AndExprContext.class,i);
}
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 xpathListener ) ((xpathListener)listener).enterOrExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitOrExpr(this);
}
}
public final OrExprContext orExpr() throws RecognitionException {
OrExprContext _localctx = new OrExprContext(_ctx, getState());
enterRule(_localctx, 30, RULE_orExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(159);
andExpr();
setState(164);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(160);
match(T__1);
setState(161);
andExpr();
}
}
setState(166);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AndExprContext extends ParserRuleContext {
public List equalityExpr() {
return getRuleContexts(EqualityExprContext.class);
}
public EqualityExprContext equalityExpr(int i) {
return getRuleContext(EqualityExprContext.class,i);
}
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 xpathListener ) ((xpathListener)listener).enterAndExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitAndExpr(this);
}
}
public final AndExprContext andExpr() throws RecognitionException {
AndExprContext _localctx = new AndExprContext(_ctx, getState());
enterRule(_localctx, 32, RULE_andExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(167);
equalityExpr();
setState(172);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__2) {
{
{
setState(168);
match(T__2);
setState(169);
equalityExpr();
}
}
setState(174);
_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 EqualityExprContext extends ParserRuleContext {
public List relationalExpr() {
return getRuleContexts(RelationalExprContext.class);
}
public RelationalExprContext relationalExpr(int i) {
return getRuleContext(RelationalExprContext.class,i);
}
public EqualityExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_equalityExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).enterEqualityExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitEqualityExpr(this);
}
}
public final EqualityExprContext equalityExpr() throws RecognitionException {
EqualityExprContext _localctx = new EqualityExprContext(_ctx, getState());
enterRule(_localctx, 34, RULE_equalityExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(175);
relationalExpr();
setState(180);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__3 || _la==T__4) {
{
{
setState(176);
_la = _input.LA(1);
if ( !(_la==T__3 || _la==T__4) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(177);
relationalExpr();
}
}
setState(182);
_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 RelationalExprContext extends ParserRuleContext {
public List additiveExpr() {
return getRuleContexts(AdditiveExprContext.class);
}
public AdditiveExprContext additiveExpr(int i) {
return getRuleContext(AdditiveExprContext.class,i);
}
public List LESS() { return getTokens(xpathParser.LESS); }
public TerminalNode LESS(int i) {
return getToken(xpathParser.LESS, i);
}
public List MORE_() { return getTokens(xpathParser.MORE_); }
public TerminalNode MORE_(int i) {
return getToken(xpathParser.MORE_, i);
}
public List LE() { return getTokens(xpathParser.LE); }
public TerminalNode LE(int i) {
return getToken(xpathParser.LE, i);
}
public List GE() { return getTokens(xpathParser.GE); }
public TerminalNode GE(int i) {
return getToken(xpathParser.GE, i);
}
public RelationalExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relationalExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).enterRelationalExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitRelationalExpr(this);
}
}
public final RelationalExprContext relationalExpr() throws RecognitionException {
RelationalExprContext _localctx = new RelationalExprContext(_ctx, getState());
enterRule(_localctx, 36, RULE_relationalExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(183);
additiveExpr();
setState(188);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LESS) | (1L << MORE_) | (1L << LE) | (1L << GE))) != 0)) {
{
{
setState(184);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LESS) | (1L << MORE_) | (1L << LE) | (1L << GE))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(185);
additiveExpr();
}
}
setState(190);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AdditiveExprContext extends ParserRuleContext {
public List multiplicativeExpr() {
return getRuleContexts(MultiplicativeExprContext.class);
}
public MultiplicativeExprContext multiplicativeExpr(int i) {
return getRuleContext(MultiplicativeExprContext.class,i);
}
public List PLUS() { return getTokens(xpathParser.PLUS); }
public TerminalNode PLUS(int i) {
return getToken(xpathParser.PLUS, i);
}
public List MINUS() { return getTokens(xpathParser.MINUS); }
public TerminalNode MINUS(int i) {
return getToken(xpathParser.MINUS, i);
}
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 xpathListener ) ((xpathListener)listener).enterAdditiveExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitAdditiveExpr(this);
}
}
public final AdditiveExprContext additiveExpr() throws RecognitionException {
AdditiveExprContext _localctx = new AdditiveExprContext(_ctx, getState());
enterRule(_localctx, 38, RULE_additiveExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(191);
multiplicativeExpr();
setState(196);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==MINUS || _la==PLUS) {
{
{
setState(192);
_la = _input.LA(1);
if ( !(_la==MINUS || _la==PLUS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(193);
multiplicativeExpr();
}
}
setState(198);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MultiplicativeExprContext extends ParserRuleContext {
public UnaryExprNoRootContext unaryExprNoRoot() {
return getRuleContext(UnaryExprNoRootContext.class,0);
}
public MultiplicativeExprContext multiplicativeExpr() {
return getRuleContext(MultiplicativeExprContext.class,0);
}
public TerminalNode MUL() { return getToken(xpathParser.MUL, 0); }
public TerminalNode PATHSEP() { return getToken(xpathParser.PATHSEP, 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 xpathListener ) ((xpathListener)listener).enterMultiplicativeExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitMultiplicativeExpr(this);
}
}
public final MultiplicativeExprContext multiplicativeExpr() throws RecognitionException {
MultiplicativeExprContext _localctx = new MultiplicativeExprContext(_ctx, getState());
enterRule(_localctx, 40, RULE_multiplicativeExpr);
int _la;
try {
setState(209);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(199);
unaryExprNoRoot();
setState(202);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__5) | (1L << T__6) | (1L << MUL))) != 0)) {
{
setState(200);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__5) | (1L << T__6) | (1L << MUL))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(201);
multiplicativeExpr();
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(204);
match(PATHSEP);
setState(207);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__5 || _la==T__6) {
{
setState(205);
_la = _input.LA(1);
if ( !(_la==T__5 || _la==T__6) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(206);
multiplicativeExpr();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnaryExprNoRootContext extends ParserRuleContext {
public UnionExprNoRootContext unionExprNoRoot() {
return getRuleContext(UnionExprNoRootContext.class,0);
}
public List MINUS() { return getTokens(xpathParser.MINUS); }
public TerminalNode MINUS(int i) {
return getToken(xpathParser.MINUS, i);
}
public UnaryExprNoRootContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unaryExprNoRoot; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).enterUnaryExprNoRoot(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitUnaryExprNoRoot(this);
}
}
public final UnaryExprNoRootContext unaryExprNoRoot() throws RecognitionException {
UnaryExprNoRootContext _localctx = new UnaryExprNoRootContext(_ctx, getState());
enterRule(_localctx, 42, RULE_unaryExprNoRoot);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(214);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==MINUS) {
{
{
setState(211);
match(MINUS);
}
}
setState(216);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(217);
unionExprNoRoot();
}
}
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(xpathParser.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 xpathListener ) ((xpathListener)listener).enterQName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitQName(this);
}
}
public final QNameContext qName() throws RecognitionException {
QNameContext _localctx = new QNameContext(_ctx, getState());
enterRule(_localctx, 44, RULE_qName);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(219);
nCName();
setState(222);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(220);
match(COLON);
setState(221);
nCName();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FunctionNameContext extends ParserRuleContext {
public List nCName() {
return getRuleContexts(NCNameContext.class);
}
public NCNameContext nCName(int i) {
return getRuleContext(NCNameContext.class,i);
}
public TerminalNode COLON() { return getToken(xpathParser.COLON, 0); }
public TerminalNode NCName() { return getToken(xpathParser.NCName, 0); }
public TerminalNode AxisName() { return getToken(xpathParser.AxisName, 0); }
public FunctionNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).enterFunctionName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitFunctionName(this);
}
}
public final FunctionNameContext functionName() throws RecognitionException {
FunctionNameContext _localctx = new FunctionNameContext(_ctx, getState());
enterRule(_localctx, 46, RULE_functionName);
try {
setState(230);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(224);
nCName();
setState(225);
match(COLON);
setState(226);
nCName();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(228);
match(NCName);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(229);
match(AxisName);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VariableReferenceContext extends ParserRuleContext {
public QNameContext qName() {
return getRuleContext(QNameContext.class,0);
}
public VariableReferenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variableReference; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).enterVariableReference(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitVariableReference(this);
}
}
public final VariableReferenceContext variableReference() throws RecognitionException {
VariableReferenceContext _localctx = new VariableReferenceContext(_ctx, getState());
enterRule(_localctx, 48, RULE_variableReference);
try {
enterOuterAlt(_localctx, 1);
{
setState(232);
match(T__7);
setState(233);
qName();
}
}
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 TerminalNode MUL() { return getToken(xpathParser.MUL, 0); }
public NCNameContext nCName() {
return getRuleContext(NCNameContext.class,0);
}
public TerminalNode COLON() { return getToken(xpathParser.COLON, 0); }
public QNameContext qName() {
return getRuleContext(QNameContext.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 xpathListener ) ((xpathListener)listener).enterNameTest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitNameTest(this);
}
}
public final NameTestContext nameTest() throws RecognitionException {
NameTestContext _localctx = new NameTestContext(_ctx, getState());
enterRule(_localctx, 50, RULE_nameTest);
try {
setState(241);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(235);
match(MUL);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(236);
nCName();
setState(237);
match(COLON);
setState(238);
match(MUL);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(240);
qName();
}
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(xpathParser.NCName, 0); }
public TerminalNode AxisName() { return getToken(xpathParser.AxisName, 0); }
public TerminalNode NodeType() { return getToken(xpathParser.NodeType, 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 xpathListener ) ((xpathListener)listener).enterNCName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof xpathListener ) ((xpathListener)listener).exitNCName(this);
}
}
public final NCNameContext nCName() throws RecognitionException {
NCNameContext _localctx = new NCNameContext(_ctx, getState());
enterRule(_localctx, 52, RULE_nCName);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(243);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NodeType) | (1L << AxisName) | (1L << NCName))) != 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 final String _serializedATN =
"\u0004\u0001$\u00f6\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002"+
"\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002"+
"\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002"+
"\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b\u0002"+
"\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007\u000f"+
"\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007\u0012"+
"\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007\u0015"+
"\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007\u0018"+
"\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0001\u0000\u0001\u0000"+
"\u0001\u0001\u0001\u0001\u0003\u0001;\b\u0001\u0001\u0002\u0001\u0002"+
"\u0001\u0002\u0001\u0002\u0003\u0002A\b\u0002\u0001\u0003\u0001\u0003"+
"\u0001\u0003\u0005\u0003F\b\u0003\n\u0003\f\u0003I\t\u0003\u0001\u0004"+
"\u0001\u0004\u0001\u0004\u0005\u0004N\b\u0004\n\u0004\f\u0004Q\t\u0004"+
"\u0001\u0004\u0003\u0004T\b\u0004\u0001\u0005\u0001\u0005\u0001\u0005"+
"\u0003\u0005Y\b\u0005\u0003\u0005[\b\u0005\u0001\u0006\u0001\u0006\u0001"+
"\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0003"+
"\u0006e\b\u0006\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001"+
"\b\u0001\b\u0001\t\u0001\t\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001"+
"\n\u0001\n\u0001\n\u0003\nw\b\n\u0001\u000b\u0001\u000b\u0001\u000b\u0001"+
"\u000b\u0001\u000b\u0005\u000b~\b\u000b\n\u000b\f\u000b\u0081\t\u000b"+
"\u0003\u000b\u0083\b\u000b\u0001\u000b\u0001\u000b\u0001\f\u0001\f\u0001"+
"\f\u0003\f\u008a\b\f\u0001\f\u0001\f\u0001\f\u0003\f\u008f\b\f\u0001\r"+
"\u0001\r\u0001\r\u0001\r\u0003\r\u0095\b\r\u0003\r\u0097\b\r\u0001\u000e"+
"\u0001\u000e\u0005\u000e\u009b\b\u000e\n\u000e\f\u000e\u009e\t\u000e\u0001"+
"\u000f\u0001\u000f\u0001\u000f\u0005\u000f\u00a3\b\u000f\n\u000f\f\u000f"+
"\u00a6\t\u000f\u0001\u0010\u0001\u0010\u0001\u0010\u0005\u0010\u00ab\b"+
"\u0010\n\u0010\f\u0010\u00ae\t\u0010\u0001\u0011\u0001\u0011\u0001\u0011"+
"\u0005\u0011\u00b3\b\u0011\n\u0011\f\u0011\u00b6\t\u0011\u0001\u0012\u0001"+
"\u0012\u0001\u0012\u0005\u0012\u00bb\b\u0012\n\u0012\f\u0012\u00be\t\u0012"+
"\u0001\u0013\u0001\u0013\u0001\u0013\u0005\u0013\u00c3\b\u0013\n\u0013"+
"\f\u0013\u00c6\t\u0013\u0001\u0014\u0001\u0014\u0001\u0014\u0003\u0014"+
"\u00cb\b\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0003\u0014\u00d0\b"+
"\u0014\u0003\u0014\u00d2\b\u0014\u0001\u0015\u0005\u0015\u00d5\b\u0015"+
"\n\u0015\f\u0015\u00d8\t\u0015\u0001\u0015\u0001\u0015\u0001\u0016\u0001"+
"\u0016\u0001\u0016\u0003\u0016\u00df\b\u0016\u0001\u0017\u0001\u0017\u0001"+
"\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0003\u0017\u00e7\b\u0017\u0001"+
"\u0018\u0001\u0018\u0001\u0018\u0001\u0019\u0001\u0019\u0001\u0019\u0001"+
"\u0019\u0001\u0019\u0001\u0019\u0003\u0019\u00f2\b\u0019\u0001\u001a\u0001"+
"\u001a\u0001\u001a\u0000\u0000\u001b\u0000\u0002\u0004\u0006\b\n\f\u000e"+
"\u0010\u0012\u0014\u0016\u0018\u001a\u001c\u001e \"$&(*,.024\u0000\b\u0001"+
"\u0000\f\r\u0002\u0000\u0014\u0014\u0016\u0016\u0001\u0000\u0004\u0005"+
"\u0001\u0000\u001a\u001d\u0001\u0000\u0012\u0013\u0002\u0000\u0006\u0007"+
"\u0015\u0015\u0001\u0000\u0006\u0007\u0003\u0000\t\t\u000b\u000b$$\u00fc"+
"\u00006\u0001\u0000\u0000\u0000\u0002:\u0001\u0000\u0000\u0000\u0004@"+
"\u0001\u0000\u0000\u0000\u0006B\u0001\u0000\u0000\u0000\bS\u0001\u0000"+
"\u0000\u0000\nZ\u0001\u0000\u0000\u0000\fd\u0001\u0000\u0000\u0000\u000e"+
"f\u0001\u0000\u0000\u0000\u0010j\u0001\u0000\u0000\u0000\u0012l\u0001"+
"\u0000\u0000\u0000\u0014v\u0001\u0000\u0000\u0000\u0016x\u0001\u0000\u0000"+
"\u0000\u0018\u008e\u0001\u0000\u0000\u0000\u001a\u0096\u0001\u0000\u0000"+
"\u0000\u001c\u0098\u0001\u0000\u0000\u0000\u001e\u009f\u0001\u0000\u0000"+
"\u0000 \u00a7\u0001\u0000\u0000\u0000\"\u00af\u0001\u0000\u0000\u0000"+
"$\u00b7\u0001\u0000\u0000\u0000&\u00bf\u0001\u0000\u0000\u0000(\u00d1"+
"\u0001\u0000\u0000\u0000*\u00d6\u0001\u0000\u0000\u0000,\u00db\u0001\u0000"+
"\u0000\u0000.\u00e6\u0001\u0000\u0000\u00000\u00e8\u0001\u0000\u0000\u0000"+
"2\u00f1\u0001\u0000\u0000\u00004\u00f3\u0001\u0000\u0000\u000067\u0003"+
"\u0012\t\u00007\u0001\u0001\u0000\u0000\u00008;\u0003\u0006\u0003\u0000"+
"9;\u0003\u0004\u0002\u0000:8\u0001\u0000\u0000\u0000:9\u0001\u0000\u0000"+
"\u0000;\u0003\u0001\u0000\u0000\u0000<=\u0005\f\u0000\u0000=A\u0003\u0006"+
"\u0003\u0000>?\u0005\r\u0000\u0000?A\u0003\u0006\u0003\u0000@<\u0001\u0000"+
"\u0000\u0000@>\u0001\u0000\u0000\u0000A\u0005\u0001\u0000\u0000\u0000"+
"BG\u0003\b\u0004\u0000CD\u0007\u0000\u0000\u0000DF\u0003\b\u0004\u0000"+
"EC\u0001\u0000\u0000\u0000FI\u0001\u0000\u0000\u0000GE\u0001\u0000\u0000"+
"\u0000GH\u0001\u0000\u0000\u0000H\u0007\u0001\u0000\u0000\u0000IG\u0001"+
"\u0000\u0000\u0000JK\u0003\n\u0005\u0000KO\u0003\f\u0006\u0000LN\u0003"+
"\u000e\u0007\u0000ML\u0001\u0000\u0000\u0000NQ\u0001\u0000\u0000\u0000"+
"OM\u0001\u0000\u0000\u0000OP\u0001\u0000\u0000\u0000PT\u0001\u0000\u0000"+
"\u0000QO\u0001\u0000\u0000\u0000RT\u0003\u0010\b\u0000SJ\u0001\u0000\u0000"+
"\u0000SR\u0001\u0000\u0000\u0000T\t\u0001\u0000\u0000\u0000UV\u0005\u000b"+
"\u0000\u0000V[\u0005\u001f\u0000\u0000WY\u0005\u0017\u0000\u0000XW\u0001"+
"\u0000\u0000\u0000XY\u0001\u0000\u0000\u0000Y[\u0001\u0000\u0000\u0000"+
"ZU\u0001\u0000\u0000\u0000ZX\u0001\u0000\u0000\u0000[\u000b\u0001\u0000"+
"\u0000\u0000\\e\u00032\u0019\u0000]^\u0005\t\u0000\u0000^_\u0005\u000e"+
"\u0000\u0000_e\u0005\u000f\u0000\u0000`a\u0005\u0001\u0000\u0000ab\u0005"+
"\u000e\u0000\u0000bc\u0005\"\u0000\u0000ce\u0005\u000f\u0000\u0000d\\"+
"\u0001\u0000\u0000\u0000d]\u0001\u0000\u0000\u0000d`\u0001\u0000\u0000"+
"\u0000e\r\u0001\u0000\u0000\u0000fg\u0005\u0010\u0000\u0000gh\u0003\u0012"+
"\t\u0000hi\u0005\u0011\u0000\u0000i\u000f\u0001\u0000\u0000\u0000jk\u0007"+
"\u0001\u0000\u0000k\u0011\u0001\u0000\u0000\u0000lm\u0003\u001e\u000f"+
"\u0000m\u0013\u0001\u0000\u0000\u0000nw\u00030\u0018\u0000op\u0005\u000e"+
"\u0000\u0000pq\u0003\u0012\t\u0000qr\u0005\u000f\u0000\u0000rw\u0001\u0000"+
"\u0000\u0000sw\u0005\"\u0000\u0000tw\u0005\n\u0000\u0000uw\u0003\u0016"+
"\u000b\u0000vn\u0001\u0000\u0000\u0000vo\u0001\u0000\u0000\u0000vs\u0001"+
"\u0000\u0000\u0000vt\u0001\u0000\u0000\u0000vu\u0001\u0000\u0000\u0000"+
"w\u0015\u0001\u0000\u0000\u0000xy\u0003.\u0017\u0000y\u0082\u0005\u000e"+
"\u0000\u0000z\u007f\u0003\u0012\t\u0000{|\u0005\u0018\u0000\u0000|~\u0003"+
"\u0012\t\u0000}{\u0001\u0000\u0000\u0000~\u0081\u0001\u0000\u0000\u0000"+
"\u007f}\u0001\u0000\u0000\u0000\u007f\u0080\u0001\u0000\u0000\u0000\u0080"+
"\u0083\u0001\u0000\u0000\u0000\u0081\u007f\u0001\u0000\u0000\u0000\u0082"+
"z\u0001\u0000\u0000\u0000\u0082\u0083\u0001\u0000\u0000\u0000\u0083\u0084"+
"\u0001\u0000\u0000\u0000\u0084\u0085\u0005\u000f\u0000\u0000\u0085\u0017"+
"\u0001\u0000\u0000\u0000\u0086\u0089\u0003\u001a\r\u0000\u0087\u0088\u0005"+
"\u0019\u0000\u0000\u0088\u008a\u0003\u0018\f\u0000\u0089\u0087\u0001\u0000"+
"\u0000\u0000\u0089\u008a\u0001\u0000\u0000\u0000\u008a\u008f\u0001\u0000"+
"\u0000\u0000\u008b\u008c\u0005\f\u0000\u0000\u008c\u008d\u0005\u0019\u0000"+
"\u0000\u008d\u008f\u0003\u0018\f\u0000\u008e\u0086\u0001\u0000\u0000\u0000"+
"\u008e\u008b\u0001\u0000\u0000\u0000\u008f\u0019\u0001\u0000\u0000\u0000"+
"\u0090\u0097\u0003\u0002\u0001\u0000\u0091\u0094\u0003\u001c\u000e\u0000"+
"\u0092\u0093\u0007\u0000\u0000\u0000\u0093\u0095\u0003\u0006\u0003\u0000"+
"\u0094\u0092\u0001\u0000\u0000\u0000\u0094\u0095\u0001\u0000\u0000\u0000"+
"\u0095\u0097\u0001\u0000\u0000\u0000\u0096\u0090\u0001\u0000\u0000\u0000"+
"\u0096\u0091\u0001\u0000\u0000\u0000\u0097\u001b\u0001\u0000\u0000\u0000"+
"\u0098\u009c\u0003\u0014\n\u0000\u0099\u009b\u0003\u000e\u0007\u0000\u009a"+
"\u0099\u0001\u0000\u0000\u0000\u009b\u009e\u0001\u0000\u0000\u0000\u009c"+
"\u009a\u0001\u0000\u0000\u0000\u009c\u009d\u0001\u0000\u0000\u0000\u009d"+
"\u001d\u0001\u0000\u0000\u0000\u009e\u009c\u0001\u0000\u0000\u0000\u009f"+
"\u00a4\u0003 \u0010\u0000\u00a0\u00a1\u0005\u0002\u0000\u0000\u00a1\u00a3"+
"\u0003 \u0010\u0000\u00a2\u00a0\u0001\u0000\u0000\u0000\u00a3\u00a6\u0001"+
"\u0000\u0000\u0000\u00a4\u00a2\u0001\u0000\u0000\u0000\u00a4\u00a5\u0001"+
"\u0000\u0000\u0000\u00a5\u001f\u0001\u0000\u0000\u0000\u00a6\u00a4\u0001"+
"\u0000\u0000\u0000\u00a7\u00ac\u0003\"\u0011\u0000\u00a8\u00a9\u0005\u0003"+
"\u0000\u0000\u00a9\u00ab\u0003\"\u0011\u0000\u00aa\u00a8\u0001\u0000\u0000"+
"\u0000\u00ab\u00ae\u0001\u0000\u0000\u0000\u00ac\u00aa\u0001\u0000\u0000"+
"\u0000\u00ac\u00ad\u0001\u0000\u0000\u0000\u00ad!\u0001\u0000\u0000\u0000"+
"\u00ae\u00ac\u0001\u0000\u0000\u0000\u00af\u00b4\u0003$\u0012\u0000\u00b0"+
"\u00b1\u0007\u0002\u0000\u0000\u00b1\u00b3\u0003$\u0012\u0000\u00b2\u00b0"+
"\u0001\u0000\u0000\u0000\u00b3\u00b6\u0001\u0000\u0000\u0000\u00b4\u00b2"+
"\u0001\u0000\u0000\u0000\u00b4\u00b5\u0001\u0000\u0000\u0000\u00b5#\u0001"+
"\u0000\u0000\u0000\u00b6\u00b4\u0001\u0000\u0000\u0000\u00b7\u00bc\u0003"+
"&\u0013\u0000\u00b8\u00b9\u0007\u0003\u0000\u0000\u00b9\u00bb\u0003&\u0013"+
"\u0000\u00ba\u00b8\u0001\u0000\u0000\u0000\u00bb\u00be\u0001\u0000\u0000"+
"\u0000\u00bc\u00ba\u0001\u0000\u0000\u0000\u00bc\u00bd\u0001\u0000\u0000"+
"\u0000\u00bd%\u0001\u0000\u0000\u0000\u00be\u00bc\u0001\u0000\u0000\u0000"+
"\u00bf\u00c4\u0003(\u0014\u0000\u00c0\u00c1\u0007\u0004\u0000\u0000\u00c1"+
"\u00c3\u0003(\u0014\u0000\u00c2\u00c0\u0001\u0000\u0000\u0000\u00c3\u00c6"+
"\u0001\u0000\u0000\u0000\u00c4\u00c2\u0001\u0000\u0000\u0000\u00c4\u00c5"+
"\u0001\u0000\u0000\u0000\u00c5\'\u0001\u0000\u0000\u0000\u00c6\u00c4\u0001"+
"\u0000\u0000\u0000\u00c7\u00ca\u0003*\u0015\u0000\u00c8\u00c9\u0007\u0005"+
"\u0000\u0000\u00c9\u00cb\u0003(\u0014\u0000\u00ca\u00c8\u0001\u0000\u0000"+
"\u0000\u00ca\u00cb\u0001\u0000\u0000\u0000\u00cb\u00d2\u0001\u0000\u0000"+
"\u0000\u00cc\u00cf\u0005\f\u0000\u0000\u00cd\u00ce\u0007\u0006\u0000\u0000"+
"\u00ce\u00d0\u0003(\u0014\u0000\u00cf\u00cd\u0001\u0000\u0000\u0000\u00cf"+
"\u00d0\u0001\u0000\u0000\u0000\u00d0\u00d2\u0001\u0000\u0000\u0000\u00d1"+
"\u00c7\u0001\u0000\u0000\u0000\u00d1\u00cc\u0001\u0000\u0000\u0000\u00d2"+
")\u0001\u0000\u0000\u0000\u00d3\u00d5\u0005\u0012\u0000\u0000\u00d4\u00d3"+
"\u0001\u0000\u0000\u0000\u00d5\u00d8\u0001\u0000\u0000\u0000\u00d6\u00d4"+
"\u0001\u0000\u0000\u0000\u00d6\u00d7\u0001\u0000\u0000\u0000\u00d7\u00d9"+
"\u0001\u0000\u0000\u0000\u00d8\u00d6\u0001\u0000\u0000\u0000\u00d9\u00da"+
"\u0003\u0018\f\u0000\u00da+\u0001\u0000\u0000\u0000\u00db\u00de\u0003"+
"4\u001a\u0000\u00dc\u00dd\u0005\u001e\u0000\u0000\u00dd\u00df\u00034\u001a"+
"\u0000\u00de\u00dc\u0001\u0000\u0000\u0000\u00de\u00df\u0001\u0000\u0000"+
"\u0000\u00df-\u0001\u0000\u0000\u0000\u00e0\u00e1\u00034\u001a\u0000\u00e1"+
"\u00e2\u0005\u001e\u0000\u0000\u00e2\u00e3\u00034\u001a\u0000\u00e3\u00e7"+
"\u0001\u0000\u0000\u0000\u00e4\u00e7\u0005$\u0000\u0000\u00e5\u00e7\u0005"+
"\u000b\u0000\u0000\u00e6\u00e0\u0001\u0000\u0000\u0000\u00e6\u00e4\u0001"+
"\u0000\u0000\u0000\u00e6\u00e5\u0001\u0000\u0000\u0000\u00e7/\u0001\u0000"+
"\u0000\u0000\u00e8\u00e9\u0005\b\u0000\u0000\u00e9\u00ea\u0003,\u0016"+
"\u0000\u00ea1\u0001\u0000\u0000\u0000\u00eb\u00f2\u0005\u0015\u0000\u0000"+
"\u00ec\u00ed\u00034\u001a\u0000\u00ed\u00ee\u0005\u001e\u0000\u0000\u00ee"+
"\u00ef\u0005\u0015\u0000\u0000\u00ef\u00f2\u0001\u0000\u0000\u0000\u00f0"+
"\u00f2\u0003,\u0016\u0000\u00f1\u00eb\u0001\u0000\u0000\u0000\u00f1\u00ec"+
"\u0001\u0000\u0000\u0000\u00f1\u00f0\u0001\u0000\u0000\u0000\u00f23\u0001"+
"\u0000\u0000\u0000\u00f3\u00f4\u0007\u0007\u0000\u0000\u00f45\u0001\u0000"+
"\u0000\u0000\u001c:@GOSXZdv\u007f\u0082\u0089\u008e\u0094\u0096\u009c"+
"\u00a4\u00ac\u00b4\u00bc\u00c4\u00ca\u00cf\u00d1\u00d6\u00de\u00e6\u00f1";
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