Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
io.konig.antlr.path.PathParser Maven / Gradle / Ivy
// Generated from Path.g4 by ANTLR 4.5.3
package io.konig.antlr.path;
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 PathParser extends Parser {
static { RuntimeMetaData.checkVersion("4.5.3", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9,
T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17,
T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24,
T__24=25, T__25=26, T__26=27, T__27=28, T__28=29, T__29=30, T__30=31,
T__31=32, TRUE=33, FALSE=34, UNICODE=35, LETTER=36, DIGIT=37, WS=38;
public static final int
RULE_path = 0, RULE_step = 1, RULE_start = 2, RULE_in = 3, RULE_out = 4,
RULE_resource = 5, RULE_filter = 6, RULE_hasStep = 7, RULE_hasStepSpace = 8,
RULE_hasPredicate = 9, RULE_hasValue = 10, RULE_literal = 11, RULE_booleanLiteral = 12,
RULE_stringLiteral = 13, RULE_stringModifier = 14, RULE_stringType = 15,
RULE_languageCode = 16, RULE_stringContent = 17, RULE_stringChar = 18,
RULE_asciiChar = 19, RULE_numericLiteral = 20, RULE_iri = 21, RULE_fullIri = 22,
RULE_rawIri = 23, RULE_qname = 24, RULE_prefix = 25, RULE_localName = 26,
RULE_bareLocalName = 27, RULE_bnode = 28;
public static final String[] ruleNames = {
"path", "step", "start", "in", "out", "resource", "filter", "hasStep",
"hasStepSpace", "hasPredicate", "hasValue", "literal", "booleanLiteral",
"stringLiteral", "stringModifier", "stringType", "languageCode", "stringContent",
"stringChar", "asciiChar", "numericLiteral", "iri", "fullIri", "rawIri",
"qname", "prefix", "localName", "bareLocalName", "bnode"
};
private static final String[] _LITERAL_NAMES = {
null, "'^'", "'/'", "'['", "';'", "']'", "'\"'", "'@'", "'!'", "'#'",
"'$'", "'%'", "'&'", "'\\u0027'", "'('", "')'", "'*'", "'+'", "','", "'-'",
"'.'", "':'", "'<'", "'='", "'>'", "'?'", "'_'", "'`'", "'{'", "'|'",
"'}'", "'~'", "'_:'", "'true'", "'false'"
};
private static final String[] _SYMBOLIC_NAMES = {
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, "TRUE", "FALSE",
"UNICODE", "LETTER", "DIGIT", "WS"
};
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 "Path.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public PathParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class PathContext extends ParserRuleContext {
public List step() {
return getRuleContexts(StepContext.class);
}
public StepContext step(int i) {
return getRuleContext(StepContext.class,i);
}
public PathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_path; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitPath(this);
}
}
public final PathContext path() throws RecognitionException {
PathContext _localctx = new PathContext(_ctx, getState());
enterRule(_localctx, 0, RULE_path);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(59);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(58);
step();
}
}
setState(61);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__21) | (1L << T__25) | (1L << LETTER))) != 0) );
}
}
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 StartContext start() {
return getRuleContext(StartContext.class,0);
}
public InContext in() {
return getRuleContext(InContext.class,0);
}
public OutContext out() {
return getRuleContext(OutContext.class,0);
}
public FilterContext filter() {
return getRuleContext(FilterContext.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 PathListener ) ((PathListener)listener).enterStep(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitStep(this);
}
}
public final StepContext step() throws RecognitionException {
StepContext _localctx = new StepContext(_ctx, getState());
enterRule(_localctx, 2, RULE_step);
try {
setState(67);
switch (_input.LA(1)) {
case T__21:
case T__25:
case LETTER:
enterOuterAlt(_localctx, 1);
{
setState(63);
start();
}
break;
case T__0:
enterOuterAlt(_localctx, 2);
{
setState(64);
in();
}
break;
case T__1:
enterOuterAlt(_localctx, 3);
{
setState(65);
out();
}
break;
case T__2:
enterOuterAlt(_localctx, 4);
{
setState(66);
filter();
}
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 StartContext extends ParserRuleContext {
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public StartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_start; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterStart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitStart(this);
}
}
public final StartContext start() throws RecognitionException {
StartContext _localctx = new StartContext(_ctx, getState());
enterRule(_localctx, 4, RULE_start);
try {
enterOuterAlt(_localctx, 1);
{
setState(69);
iri();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InContext extends ParserRuleContext {
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public InContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_in; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterIn(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitIn(this);
}
}
public final InContext in() throws RecognitionException {
InContext _localctx = new InContext(_ctx, getState());
enterRule(_localctx, 6, RULE_in);
try {
enterOuterAlt(_localctx, 1);
{
setState(71);
match(T__0);
setState(72);
iri();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OutContext extends ParserRuleContext {
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public OutContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_out; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterOut(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitOut(this);
}
}
public final OutContext out() throws RecognitionException {
OutContext _localctx = new OutContext(_ctx, getState());
enterRule(_localctx, 8, RULE_out);
try {
enterOuterAlt(_localctx, 1);
{
setState(74);
match(T__1);
setState(75);
iri();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ResourceContext extends ParserRuleContext {
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public BnodeContext bnode() {
return getRuleContext(BnodeContext.class,0);
}
public ResourceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_resource; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterResource(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitResource(this);
}
}
public final ResourceContext resource() throws RecognitionException {
ResourceContext _localctx = new ResourceContext(_ctx, getState());
enterRule(_localctx, 10, RULE_resource);
try {
setState(79);
switch (_input.LA(1)) {
case T__21:
case T__25:
case LETTER:
enterOuterAlt(_localctx, 1);
{
setState(77);
iri();
}
break;
case T__31:
enterOuterAlt(_localctx, 2);
{
setState(78);
bnode();
}
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 FilterContext extends ParserRuleContext {
public List hasStep() {
return getRuleContexts(HasStepContext.class);
}
public HasStepContext hasStep(int i) {
return getRuleContext(HasStepContext.class,i);
}
public List WS() { return getTokens(PathParser.WS); }
public TerminalNode WS(int i) {
return getToken(PathParser.WS, i);
}
public FilterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_filter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterFilter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitFilter(this);
}
}
public final FilterContext filter() throws RecognitionException {
FilterContext _localctx = new FilterContext(_ctx, getState());
enterRule(_localctx, 12, RULE_filter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(81);
match(T__2);
setState(83);
_la = _input.LA(1);
if (_la==WS) {
{
setState(82);
match(WS);
}
}
setState(85);
hasStep();
setState(87);
_la = _input.LA(1);
if (_la==WS) {
{
setState(86);
match(WS);
}
}
setState(96);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__3) {
{
{
setState(89);
match(T__3);
setState(91);
_la = _input.LA(1);
if (_la==WS) {
{
setState(90);
match(WS);
}
}
setState(93);
hasStep();
}
}
setState(98);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(99);
match(T__4);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HasStepContext extends ParserRuleContext {
public HasPredicateContext hasPredicate() {
return getRuleContext(HasPredicateContext.class,0);
}
public HasStepSpaceContext hasStepSpace() {
return getRuleContext(HasStepSpaceContext.class,0);
}
public HasValueContext hasValue() {
return getRuleContext(HasValueContext.class,0);
}
public HasStepContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hasStep; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterHasStep(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitHasStep(this);
}
}
public final HasStepContext hasStep() throws RecognitionException {
HasStepContext _localctx = new HasStepContext(_ctx, getState());
enterRule(_localctx, 14, RULE_hasStep);
try {
enterOuterAlt(_localctx, 1);
{
setState(101);
hasPredicate();
setState(102);
hasStepSpace();
setState(103);
hasValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HasStepSpaceContext extends ParserRuleContext {
public List WS() { return getTokens(PathParser.WS); }
public TerminalNode WS(int i) {
return getToken(PathParser.WS, i);
}
public HasStepSpaceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hasStepSpace; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterHasStepSpace(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitHasStepSpace(this);
}
}
public final HasStepSpaceContext hasStepSpace() throws RecognitionException {
HasStepSpaceContext _localctx = new HasStepSpaceContext(_ctx, getState());
enterRule(_localctx, 16, RULE_hasStepSpace);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(106);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(105);
match(WS);
}
}
setState(108);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WS );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HasPredicateContext extends ParserRuleContext {
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public HasPredicateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hasPredicate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterHasPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitHasPredicate(this);
}
}
public final HasPredicateContext hasPredicate() throws RecognitionException {
HasPredicateContext _localctx = new HasPredicateContext(_ctx, getState());
enterRule(_localctx, 18, RULE_hasPredicate);
try {
enterOuterAlt(_localctx, 1);
{
setState(110);
iri();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HasValueContext extends ParserRuleContext {
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public HasValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hasValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterHasValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitHasValue(this);
}
}
public final HasValueContext hasValue() throws RecognitionException {
HasValueContext _localctx = new HasValueContext(_ctx, getState());
enterRule(_localctx, 20, RULE_hasValue);
try {
setState(114);
switch (_input.LA(1)) {
case T__21:
case T__25:
case LETTER:
enterOuterAlt(_localctx, 1);
{
setState(112);
iri();
}
break;
case T__5:
case TRUE:
case FALSE:
case DIGIT:
enterOuterAlt(_localctx, 2);
{
setState(113);
literal();
}
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 BooleanLiteralContext booleanLiteral() {
return getRuleContext(BooleanLiteralContext.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 PathListener ) ((PathListener)listener).enterLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitLiteral(this);
}
}
public final LiteralContext literal() throws RecognitionException {
LiteralContext _localctx = new LiteralContext(_ctx, getState());
enterRule(_localctx, 22, RULE_literal);
try {
setState(119);
switch (_input.LA(1)) {
case DIGIT:
enterOuterAlt(_localctx, 1);
{
setState(116);
numericLiteral();
}
break;
case T__5:
enterOuterAlt(_localctx, 2);
{
setState(117);
stringLiteral();
}
break;
case TRUE:
case FALSE:
enterOuterAlt(_localctx, 3);
{
setState(118);
booleanLiteral();
}
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 BooleanLiteralContext extends ParserRuleContext {
public TerminalNode TRUE() { return getToken(PathParser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(PathParser.FALSE, 0); }
public BooleanLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_booleanLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterBooleanLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitBooleanLiteral(this);
}
}
public final BooleanLiteralContext booleanLiteral() throws RecognitionException {
BooleanLiteralContext _localctx = new BooleanLiteralContext(_ctx, getState());
enterRule(_localctx, 24, RULE_booleanLiteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(121);
_la = _input.LA(1);
if ( !(_la==TRUE || _la==FALSE) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
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 StringContentContext stringContent() {
return getRuleContext(StringContentContext.class,0);
}
public StringModifierContext stringModifier() {
return getRuleContext(StringModifierContext.class,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 PathListener ) ((PathListener)listener).enterStringLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitStringLiteral(this);
}
}
public final StringLiteralContext stringLiteral() throws RecognitionException {
StringLiteralContext _localctx = new StringLiteralContext(_ctx, getState());
enterRule(_localctx, 26, RULE_stringLiteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(123);
match(T__5);
setState(124);
stringContent();
setState(125);
match(T__5);
setState(127);
_la = _input.LA(1);
if (_la==T__0 || _la==T__6) {
{
setState(126);
stringModifier();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StringModifierContext extends ParserRuleContext {
public StringTypeContext stringType() {
return getRuleContext(StringTypeContext.class,0);
}
public LanguageCodeContext languageCode() {
return getRuleContext(LanguageCodeContext.class,0);
}
public StringModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stringModifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterStringModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitStringModifier(this);
}
}
public final StringModifierContext stringModifier() throws RecognitionException {
StringModifierContext _localctx = new StringModifierContext(_ctx, getState());
enterRule(_localctx, 28, RULE_stringModifier);
try {
setState(133);
switch (_input.LA(1)) {
case T__0:
enterOuterAlt(_localctx, 1);
{
setState(129);
match(T__0);
setState(130);
stringType();
}
break;
case T__6:
enterOuterAlt(_localctx, 2);
{
setState(131);
match(T__6);
setState(132);
languageCode();
}
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 StringTypeContext extends ParserRuleContext {
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public StringTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stringType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterStringType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitStringType(this);
}
}
public final StringTypeContext stringType() throws RecognitionException {
StringTypeContext _localctx = new StringTypeContext(_ctx, getState());
enterRule(_localctx, 30, RULE_stringType);
try {
enterOuterAlt(_localctx, 1);
{
setState(135);
iri();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LanguageCodeContext extends ParserRuleContext {
public List LETTER() { return getTokens(PathParser.LETTER); }
public TerminalNode LETTER(int i) {
return getToken(PathParser.LETTER, i);
}
public LanguageCodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_languageCode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterLanguageCode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitLanguageCode(this);
}
}
public final LanguageCodeContext languageCode() throws RecognitionException {
LanguageCodeContext _localctx = new LanguageCodeContext(_ctx, getState());
enterRule(_localctx, 32, RULE_languageCode);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(138);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(137);
match(LETTER);
}
}
setState(140);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==LETTER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StringContentContext extends ParserRuleContext {
public List stringChar() {
return getRuleContexts(StringCharContext.class);
}
public StringCharContext stringChar(int i) {
return getRuleContext(StringCharContext.class,i);
}
public StringContentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stringContent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterStringContent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitStringContent(this);
}
}
public final StringContentContext stringContent() throws RecognitionException {
StringContentContext _localctx = new StringContentContext(_ctx, getState());
enterRule(_localctx, 34, RULE_stringContent);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(145);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__10) | (1L << T__11) | (1L << T__12) | (1L << T__13) | (1L << T__14) | (1L << T__15) | (1L << T__16) | (1L << T__17) | (1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__24) | (1L << T__25) | (1L << T__26) | (1L << T__27) | (1L << T__28) | (1L << T__29) | (1L << T__30) | (1L << UNICODE) | (1L << LETTER) | (1L << DIGIT) | (1L << WS))) != 0)) {
{
{
setState(142);
stringChar();
}
}
setState(147);
_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 StringCharContext extends ParserRuleContext {
public AsciiCharContext asciiChar() {
return getRuleContext(AsciiCharContext.class,0);
}
public TerminalNode UNICODE() { return getToken(PathParser.UNICODE, 0); }
public StringCharContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stringChar; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterStringChar(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitStringChar(this);
}
}
public final StringCharContext stringChar() throws RecognitionException {
StringCharContext _localctx = new StringCharContext(_ctx, getState());
enterRule(_localctx, 36, RULE_stringChar);
try {
setState(150);
switch (_input.LA(1)) {
case T__0:
case T__1:
case T__2:
case T__3:
case T__4:
case T__6:
case T__7:
case T__8:
case T__9:
case T__10:
case T__11:
case T__12:
case T__13:
case T__14:
case T__15:
case T__16:
case T__17:
case T__18:
case T__19:
case T__20:
case T__21:
case T__22:
case T__23:
case T__24:
case T__25:
case T__26:
case T__27:
case T__28:
case T__29:
case T__30:
case LETTER:
case DIGIT:
case WS:
enterOuterAlt(_localctx, 1);
{
setState(148);
asciiChar();
}
break;
case UNICODE:
enterOuterAlt(_localctx, 2);
{
setState(149);
match(UNICODE);
}
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 AsciiCharContext extends ParserRuleContext {
public TerminalNode LETTER() { return getToken(PathParser.LETTER, 0); }
public TerminalNode DIGIT() { return getToken(PathParser.DIGIT, 0); }
public TerminalNode WS() { return getToken(PathParser.WS, 0); }
public AsciiCharContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_asciiChar; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterAsciiChar(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitAsciiChar(this);
}
}
public final AsciiCharContext asciiChar() throws RecognitionException {
AsciiCharContext _localctx = new AsciiCharContext(_ctx, getState());
enterRule(_localctx, 38, RULE_asciiChar);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(152);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__10) | (1L << T__11) | (1L << T__12) | (1L << T__13) | (1L << T__14) | (1L << T__15) | (1L << T__16) | (1L << T__17) | (1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__24) | (1L << T__25) | (1L << T__26) | (1L << T__27) | (1L << T__28) | (1L << T__29) | (1L << T__30) | (1L << LETTER) | (1L << DIGIT) | (1L << WS))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
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 List DIGIT() { return getTokens(PathParser.DIGIT); }
public TerminalNode DIGIT(int i) {
return getToken(PathParser.DIGIT, i);
}
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 PathListener ) ((PathListener)listener).enterNumericLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitNumericLiteral(this);
}
}
public final NumericLiteralContext numericLiteral() throws RecognitionException {
NumericLiteralContext _localctx = new NumericLiteralContext(_ctx, getState());
enterRule(_localctx, 40, RULE_numericLiteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(155);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(154);
match(DIGIT);
}
}
setState(157);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==DIGIT );
setState(165);
_la = _input.LA(1);
if (_la==T__19) {
{
setState(159);
match(T__19);
setState(161);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(160);
match(DIGIT);
}
}
setState(163);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==DIGIT );
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IriContext extends ParserRuleContext {
public FullIriContext fullIri() {
return getRuleContext(FullIriContext.class,0);
}
public QnameContext qname() {
return getRuleContext(QnameContext.class,0);
}
public BareLocalNameContext bareLocalName() {
return getRuleContext(BareLocalNameContext.class,0);
}
public IriContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_iri; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterIri(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitIri(this);
}
}
public final IriContext iri() throws RecognitionException {
IriContext _localctx = new IriContext(_ctx, getState());
enterRule(_localctx, 42, RULE_iri);
try {
setState(170);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(167);
fullIri();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(168);
qname();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(169);
bareLocalName();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FullIriContext extends ParserRuleContext {
public RawIriContext rawIri() {
return getRuleContext(RawIriContext.class,0);
}
public FullIriContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fullIri; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterFullIri(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitFullIri(this);
}
}
public final FullIriContext fullIri() throws RecognitionException {
FullIriContext _localctx = new FullIriContext(_ctx, getState());
enterRule(_localctx, 44, RULE_fullIri);
try {
enterOuterAlt(_localctx, 1);
{
setState(172);
match(T__21);
setState(173);
rawIri();
setState(174);
match(T__23);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RawIriContext extends ParserRuleContext {
public List LETTER() { return getTokens(PathParser.LETTER); }
public TerminalNode LETTER(int i) {
return getToken(PathParser.LETTER, i);
}
public List DIGIT() { return getTokens(PathParser.DIGIT); }
public TerminalNode DIGIT(int i) {
return getToken(PathParser.DIGIT, i);
}
public RawIriContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rawIri; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterRawIri(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitRawIri(this);
}
}
public final RawIriContext rawIri() throws RecognitionException {
RawIriContext _localctx = new RawIriContext(_ctx, getState());
enterRule(_localctx, 46, RULE_rawIri);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(177);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(176);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__10) | (1L << T__11) | (1L << T__12) | (1L << T__13) | (1L << T__14) | (1L << T__15) | (1L << T__16) | (1L << T__17) | (1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__22) | (1L << T__24) | (1L << T__25) | (1L << T__26) | (1L << T__27) | (1L << T__28) | (1L << T__29) | (1L << T__30) | (1L << LETTER) | (1L << DIGIT))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
setState(179);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__10) | (1L << T__11) | (1L << T__12) | (1L << T__13) | (1L << T__14) | (1L << T__15) | (1L << T__16) | (1L << T__17) | (1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__22) | (1L << T__24) | (1L << T__25) | (1L << T__26) | (1L << T__27) | (1L << T__28) | (1L << T__29) | (1L << T__30) | (1L << LETTER) | (1L << DIGIT))) != 0) );
}
}
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 PrefixContext prefix() {
return getRuleContext(PrefixContext.class,0);
}
public LocalNameContext localName() {
return getRuleContext(LocalNameContext.class,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 PathListener ) ((PathListener)listener).enterQname(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitQname(this);
}
}
public final QnameContext qname() throws RecognitionException {
QnameContext _localctx = new QnameContext(_ctx, getState());
enterRule(_localctx, 48, RULE_qname);
try {
enterOuterAlt(_localctx, 1);
{
setState(181);
prefix();
setState(182);
match(T__20);
setState(183);
localName();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrefixContext extends ParserRuleContext {
public List LETTER() { return getTokens(PathParser.LETTER); }
public TerminalNode LETTER(int i) {
return getToken(PathParser.LETTER, i);
}
public List DIGIT() { return getTokens(PathParser.DIGIT); }
public TerminalNode DIGIT(int i) {
return getToken(PathParser.DIGIT, i);
}
public PrefixContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_prefix; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterPrefix(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitPrefix(this);
}
}
public final PrefixContext prefix() throws RecognitionException {
PrefixContext _localctx = new PrefixContext(_ctx, getState());
enterRule(_localctx, 50, RULE_prefix);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(185);
match(LETTER);
setState(187);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(186);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__18) | (1L << T__25) | (1L << LETTER) | (1L << DIGIT))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
setState(189);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__18) | (1L << T__25) | (1L << LETTER) | (1L << DIGIT))) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LocalNameContext extends ParserRuleContext {
public List LETTER() { return getTokens(PathParser.LETTER); }
public TerminalNode LETTER(int i) {
return getToken(PathParser.LETTER, i);
}
public List DIGIT() { return getTokens(PathParser.DIGIT); }
public TerminalNode DIGIT(int i) {
return getToken(PathParser.DIGIT, i);
}
public LocalNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_localName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterLocalName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitLocalName(this);
}
}
public final LocalNameContext localName() throws RecognitionException {
LocalNameContext _localctx = new LocalNameContext(_ctx, getState());
enterRule(_localctx, 52, RULE_localName);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(199);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
setState(199);
switch (_input.LA(1)) {
case LETTER:
{
setState(191);
match(LETTER);
}
break;
case DIGIT:
{
setState(192);
match(DIGIT);
}
break;
case T__25:
{
setState(194);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(193);
match(T__25);
}
}
setState(196);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==T__25 );
setState(198);
match(T__18);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(201);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,23,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BareLocalNameContext extends ParserRuleContext {
public LocalNameContext localName() {
return getRuleContext(LocalNameContext.class,0);
}
public TerminalNode LETTER() { return getToken(PathParser.LETTER, 0); }
public BareLocalNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bareLocalName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterBareLocalName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitBareLocalName(this);
}
}
public final BareLocalNameContext bareLocalName() throws RecognitionException {
BareLocalNameContext _localctx = new BareLocalNameContext(_ctx, getState());
enterRule(_localctx, 54, RULE_bareLocalName);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(203);
_la = _input.LA(1);
if ( !(_la==T__25 || _la==LETTER) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(204);
localName();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BnodeContext extends ParserRuleContext {
public LocalNameContext localName() {
return getRuleContext(LocalNameContext.class,0);
}
public BnodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bnode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).enterBnode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PathListener ) ((PathListener)listener).exitBnode(this);
}
}
public final BnodeContext bnode() throws RecognitionException {
BnodeContext _localctx = new BnodeContext(_ctx, getState());
enterRule(_localctx, 56, RULE_bnode);
try {
enterOuterAlt(_localctx, 1);
{
setState(206);
match(T__31);
setState(207);
localName();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN =
"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3(\u00d4\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\3\2\6\2>\n\2\r\2\16"+
"\2?\3\3\3\3\3\3\3\3\5\3F\n\3\3\4\3\4\3\5\3\5\3\5\3\6\3\6\3\6\3\7\3\7\5"+
"\7R\n\7\3\b\3\b\5\bV\n\b\3\b\3\b\5\bZ\n\b\3\b\3\b\5\b^\n\b\3\b\7\ba\n"+
"\b\f\b\16\bd\13\b\3\b\3\b\3\t\3\t\3\t\3\t\3\n\6\nm\n\n\r\n\16\nn\3\13"+
"\3\13\3\f\3\f\5\fu\n\f\3\r\3\r\3\r\5\rz\n\r\3\16\3\16\3\17\3\17\3\17\3"+
"\17\5\17\u0082\n\17\3\20\3\20\3\20\3\20\5\20\u0088\n\20\3\21\3\21\3\22"+
"\6\22\u008d\n\22\r\22\16\22\u008e\3\23\7\23\u0092\n\23\f\23\16\23\u0095"+
"\13\23\3\24\3\24\5\24\u0099\n\24\3\25\3\25\3\26\6\26\u009e\n\26\r\26\16"+
"\26\u009f\3\26\3\26\6\26\u00a4\n\26\r\26\16\26\u00a5\5\26\u00a8\n\26\3"+
"\27\3\27\3\27\5\27\u00ad\n\27\3\30\3\30\3\30\3\30\3\31\6\31\u00b4\n\31"+
"\r\31\16\31\u00b5\3\32\3\32\3\32\3\32\3\33\3\33\6\33\u00be\n\33\r\33\16"+
"\33\u00bf\3\34\3\34\3\34\6\34\u00c5\n\34\r\34\16\34\u00c6\3\34\6\34\u00ca"+
"\n\34\r\34\16\34\u00cb\3\35\3\35\3\35\3\36\3\36\3\36\3\36\2\2\37\2\4\6"+
"\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:\2\7\3\2#$\5\2"+
"\3\7\t!&(\6\2\3\27\31\31\33!&\'\5\2\25\25\34\34&\'\4\2\34\34&&\u00d3\2"+
"=\3\2\2\2\4E\3\2\2\2\6G\3\2\2\2\bI\3\2\2\2\nL\3\2\2\2\fQ\3\2\2\2\16S\3"+
"\2\2\2\20g\3\2\2\2\22l\3\2\2\2\24p\3\2\2\2\26t\3\2\2\2\30y\3\2\2\2\32"+
"{\3\2\2\2\34}\3\2\2\2\36\u0087\3\2\2\2 \u0089\3\2\2\2\"\u008c\3\2\2\2"+
"$\u0093\3\2\2\2&\u0098\3\2\2\2(\u009a\3\2\2\2*\u009d\3\2\2\2,\u00ac\3"+
"\2\2\2.\u00ae\3\2\2\2\60\u00b3\3\2\2\2\62\u00b7\3\2\2\2\64\u00bb\3\2\2"+
"\2\66\u00c9\3\2\2\28\u00cd\3\2\2\2:\u00d0\3\2\2\2<>\5\4\3\2=<\3\2\2\2"+
">?\3\2\2\2?=\3\2\2\2?@\3\2\2\2@\3\3\2\2\2AF\5\6\4\2BF\5\b\5\2CF\5\n\6"+
"\2DF\5\16\b\2EA\3\2\2\2EB\3\2\2\2EC\3\2\2\2ED\3\2\2\2F\5\3\2\2\2GH\5,"+
"\27\2H\7\3\2\2\2IJ\7\3\2\2JK\5,\27\2K\t\3\2\2\2LM\7\4\2\2MN\5,\27\2N\13"+
"\3\2\2\2OR\5,\27\2PR\5:\36\2QO\3\2\2\2QP\3\2\2\2R\r\3\2\2\2SU\7\5\2\2"+
"TV\7(\2\2UT\3\2\2\2UV\3\2\2\2VW\3\2\2\2WY\5\20\t\2XZ\7(\2\2YX\3\2\2\2"+
"YZ\3\2\2\2Zb\3\2\2\2[]\7\6\2\2\\^\7(\2\2]\\\3\2\2\2]^\3\2\2\2^_\3\2\2"+
"\2_a\5\20\t\2`[\3\2\2\2ad\3\2\2\2b`\3\2\2\2bc\3\2\2\2ce\3\2\2\2db\3\2"+
"\2\2ef\7\7\2\2f\17\3\2\2\2gh\5\24\13\2hi\5\22\n\2ij\5\26\f\2j\21\3\2\2"+
"\2km\7(\2\2lk\3\2\2\2mn\3\2\2\2nl\3\2\2\2no\3\2\2\2o\23\3\2\2\2pq\5,\27"+
"\2q\25\3\2\2\2ru\5,\27\2su\5\30\r\2tr\3\2\2\2ts\3\2\2\2u\27\3\2\2\2vz"+
"\5*\26\2wz\5\34\17\2xz\5\32\16\2yv\3\2\2\2yw\3\2\2\2yx\3\2\2\2z\31\3\2"+
"\2\2{|\t\2\2\2|\33\3\2\2\2}~\7\b\2\2~\177\5$\23\2\177\u0081\7\b\2\2\u0080"+
"\u0082\5\36\20\2\u0081\u0080\3\2\2\2\u0081\u0082\3\2\2\2\u0082\35\3\2"+
"\2\2\u0083\u0084\7\3\2\2\u0084\u0088\5 \21\2\u0085\u0086\7\t\2\2\u0086"+
"\u0088\5\"\22\2\u0087\u0083\3\2\2\2\u0087\u0085\3\2\2\2\u0088\37\3\2\2"+
"\2\u0089\u008a\5,\27\2\u008a!\3\2\2\2\u008b\u008d\7&\2\2\u008c\u008b\3"+
"\2\2\2\u008d\u008e\3\2\2\2\u008e\u008c\3\2\2\2\u008e\u008f\3\2\2\2\u008f"+
"#\3\2\2\2\u0090\u0092\5&\24\2\u0091\u0090\3\2\2\2\u0092\u0095\3\2\2\2"+
"\u0093\u0091\3\2\2\2\u0093\u0094\3\2\2\2\u0094%\3\2\2\2\u0095\u0093\3"+
"\2\2\2\u0096\u0099\5(\25\2\u0097\u0099\7%\2\2\u0098\u0096\3\2\2\2\u0098"+
"\u0097\3\2\2\2\u0099\'\3\2\2\2\u009a\u009b\t\3\2\2\u009b)\3\2\2\2\u009c"+
"\u009e\7\'\2\2\u009d\u009c\3\2\2\2\u009e\u009f\3\2\2\2\u009f\u009d\3\2"+
"\2\2\u009f\u00a0\3\2\2\2\u00a0\u00a7\3\2\2\2\u00a1\u00a3\7\26\2\2\u00a2"+
"\u00a4\7\'\2\2\u00a3\u00a2\3\2\2\2\u00a4\u00a5\3\2\2\2\u00a5\u00a3\3\2"+
"\2\2\u00a5\u00a6\3\2\2\2\u00a6\u00a8\3\2\2\2\u00a7\u00a1\3\2\2\2\u00a7"+
"\u00a8\3\2\2\2\u00a8+\3\2\2\2\u00a9\u00ad\5.\30\2\u00aa\u00ad\5\62\32"+
"\2\u00ab\u00ad\58\35\2\u00ac\u00a9\3\2\2\2\u00ac\u00aa\3\2\2\2\u00ac\u00ab"+
"\3\2\2\2\u00ad-\3\2\2\2\u00ae\u00af\7\30\2\2\u00af\u00b0\5\60\31\2\u00b0"+
"\u00b1\7\32\2\2\u00b1/\3\2\2\2\u00b2\u00b4\t\4\2\2\u00b3\u00b2\3\2\2\2"+
"\u00b4\u00b5\3\2\2\2\u00b5\u00b3\3\2\2\2\u00b5\u00b6\3\2\2\2\u00b6\61"+
"\3\2\2\2\u00b7\u00b8\5\64\33\2\u00b8\u00b9\7\27\2\2\u00b9\u00ba\5\66\34"+
"\2\u00ba\63\3\2\2\2\u00bb\u00bd\7&\2\2\u00bc\u00be\t\5\2\2\u00bd\u00bc"+
"\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf\u00bd\3\2\2\2\u00bf\u00c0\3\2\2\2\u00c0"+
"\65\3\2\2\2\u00c1\u00ca\7&\2\2\u00c2\u00ca\7\'\2\2\u00c3\u00c5\7\34\2"+
"\2\u00c4\u00c3\3\2\2\2\u00c5\u00c6\3\2\2\2\u00c6\u00c4\3\2\2\2\u00c6\u00c7"+
"\3\2\2\2\u00c7\u00c8\3\2\2\2\u00c8\u00ca\7\25\2\2\u00c9\u00c1\3\2\2\2"+
"\u00c9\u00c2\3\2\2\2\u00c9\u00c4\3\2\2\2\u00ca\u00cb\3\2\2\2\u00cb\u00c9"+
"\3\2\2\2\u00cb\u00cc\3\2\2\2\u00cc\67\3\2\2\2\u00cd\u00ce\t\6\2\2\u00ce"+
"\u00cf\5\66\34\2\u00cf9\3\2\2\2\u00d0\u00d1\7\"\2\2\u00d1\u00d2\5\66\34"+
"\2\u00d2;\3\2\2\2\32?EQUY]bnty\u0081\u0087\u008e\u0093\u0098\u009f\u00a5"+
"\u00a7\u00ac\u00b5\u00bf\u00c6\u00c9\u00cb";
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);
}
}
}
