net.ossindex.version.parser.VersionParser Maven / Gradle / Ivy
// Generated from net\ossindex\version\parser\Version.g4 by ANTLR 4.5
package net.ossindex.version.parser;
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 VersionParser extends Parser {
static { RuntimeMetaData.checkVersion("4.5", 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, OR=15, NUMBER=16, ANY=17,
WS=18;
public static final int
RULE_range = 0, RULE_maven_ranges = 1, RULE_maven_range = 2, RULE_broken_range = 3,
RULE_range_type = 4, RULE_union_range = 5, RULE_logical_range = 6, RULE_version_set = 7,
RULE_simple_range = 8, RULE_version = 9, RULE_prefixed_version = 10, RULE_postfix_version = 11,
RULE_numeric_version = 12, RULE_named_version = 13, RULE_identifier = 14,
RULE_any = 15;
public static final String[] ruleNames = {
"range", "maven_ranges", "maven_range", "broken_range", "range_type",
"union_range", "logical_range", "version_set", "simple_range", "version",
"prefixed_version", "postfix_version", "numeric_version", "named_version",
"identifier", "any"
};
private static final String[] _LITERAL_NAMES = {
null, "','", "'['", "'('", "']'", "')'", "'&'", "'<'", "'<='", "'>'",
"'>='", "'~>'", "'='", "'.'", "'-'"
};
private static final String[] _SYMBOLIC_NAMES = {
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, "OR", "NUMBER", "ANY", "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 "Version.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
// From: http://stackoverflow.com/questions/29060496/allow-whitespace-sections-antlr4/29115489#29115489
/** We can enable and disable whitespace, which is required for some special
* parsing rules.
*/
/*
public void enableWs() {
if (_input instanceof MultiChannelTokenStream) {
((MultiChannelTokenStream) _input).enable(HIDDEN);
}
}
public void disableWs() {
if (_input instanceof MultiChannelTokenStream) {
((MultiChannelTokenStream) _input).disable(HIDDEN);
}
}
*/
/**
* Returns true if there is whitespace ahead in the HIDDEN channel.
*/
private boolean whitespace() {
// Get the token ahead of the current index
int index = this.getCurrentToken().getTokenIndex() - 1;
Token ahead = _input.get(index);
// If the next token is not hidden then we don't care
if(ahead.getChannel() != Lexer.HIDDEN) return false;
int type = ahead.getType();
return (type == WS);
}
public VersionParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class RangeContext extends ParserRuleContext {
public Maven_rangesContext maven_ranges() {
return getRuleContext(Maven_rangesContext.class,0);
}
public TerminalNode EOF() { return getToken(VersionParser.EOF, 0); }
public Version_setContext version_set() {
return getRuleContext(Version_setContext.class,0);
}
public Union_rangeContext union_range() {
return getRuleContext(Union_rangeContext.class,0);
}
public Range_typeContext range_type() {
return getRuleContext(Range_typeContext.class,0);
}
public Broken_rangeContext broken_range() {
return getRuleContext(Broken_rangeContext.class,0);
}
public RangeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_range; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).enterRange(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).exitRange(this);
}
}
public final RangeContext range() throws RecognitionException {
RangeContext _localctx = new RangeContext(_ctx, getState());
enterRule(_localctx, 0, RULE_range);
try {
setState(47);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(32);
maven_ranges();
setState(33);
match(EOF);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(35);
version_set(0);
setState(36);
match(EOF);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(38);
union_range();
setState(39);
match(EOF);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(41);
range_type();
setState(42);
match(EOF);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(44);
broken_range();
setState(45);
match(EOF);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Maven_rangesContext extends ParserRuleContext {
public Maven_rangeContext maven_range() {
return getRuleContext(Maven_rangeContext.class,0);
}
public Maven_rangesContext maven_ranges() {
return getRuleContext(Maven_rangesContext.class,0);
}
public Maven_rangesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_maven_ranges; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).enterMaven_ranges(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).exitMaven_ranges(this);
}
}
public final Maven_rangesContext maven_ranges() throws RecognitionException {
Maven_rangesContext _localctx = new Maven_rangesContext(_ctx, getState());
enterRule(_localctx, 2, RULE_maven_ranges);
try {
setState(54);
switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(49);
maven_range();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(50);
maven_range();
setState(51);
match(T__0);
setState(52);
maven_ranges();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Maven_rangeContext extends ParserRuleContext {
public List version() {
return getRuleContexts(VersionContext.class);
}
public VersionContext version(int i) {
return getRuleContext(VersionContext.class,i);
}
public Maven_rangeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_maven_range; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).enterMaven_range(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).exitMaven_range(this);
}
}
public final Maven_rangeContext maven_range() throws RecognitionException {
Maven_rangeContext _localctx = new Maven_rangeContext(_ctx, getState());
enterRule(_localctx, 4, RULE_maven_range);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(56);
_la = _input.LA(1);
if ( !(_la==T__1 || _la==T__2) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(68);
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
case 1:
{
}
break;
case 2:
{
setState(58);
version();
setState(59);
match(T__0);
setState(60);
version();
}
break;
case 3:
{
setState(62);
version();
setState(63);
match(T__0);
}
break;
case 4:
{
setState(65);
version();
}
break;
case 5:
{
setState(66);
match(T__0);
setState(67);
version();
}
break;
}
setState(70);
_la = _input.LA(1);
if ( !(_la==T__3 || _la==T__4) ) {
_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 Broken_rangeContext extends ParserRuleContext {
public Simple_rangeContext simple_range() {
return getRuleContext(Simple_rangeContext.class,0);
}
public VersionContext version() {
return getRuleContext(VersionContext.class,0);
}
public Broken_rangeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_broken_range; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).enterBroken_range(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).exitBroken_range(this);
}
}
public final Broken_rangeContext broken_range() throws RecognitionException {
Broken_rangeContext _localctx = new Broken_rangeContext(_ctx, getState());
enterRule(_localctx, 6, RULE_broken_range);
int _la;
try {
setState(86);
switch (_input.LA(1)) {
case T__6:
case T__7:
case T__8:
case T__9:
case T__10:
enterOuterAlt(_localctx, 1);
{
setState(72);
simple_range();
setState(76);
_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 << OR) | (1L << NUMBER) | (1L << ANY) | (1L << WS))) != 0)) {
{
{
setState(73);
matchWildcard();
}
}
setState(78);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case T__11:
case T__12:
case T__13:
case NUMBER:
case ANY:
enterOuterAlt(_localctx, 2);
{
setState(79);
version();
setState(83);
_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 << OR) | (1L << NUMBER) | (1L << ANY) | (1L << WS))) != 0)) {
{
{
setState(80);
matchWildcard();
}
}
setState(85);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
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 Range_typeContext extends ParserRuleContext {
public Logical_rangeContext logical_range() {
return getRuleContext(Logical_rangeContext.class,0);
}
public Simple_rangeContext simple_range() {
return getRuleContext(Simple_rangeContext.class,0);
}
public Range_typeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_range_type; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).enterRange_type(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).exitRange_type(this);
}
}
public final Range_typeContext range_type() throws RecognitionException {
Range_typeContext _localctx = new Range_typeContext(_ctx, getState());
enterRule(_localctx, 8, RULE_range_type);
try {
setState(90);
switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(88);
logical_range(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(89);
simple_range();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Union_rangeContext extends ParserRuleContext {
public List version() {
return getRuleContexts(VersionContext.class);
}
public VersionContext version(int i) {
return getRuleContext(VersionContext.class,i);
}
public TerminalNode OR() { return getToken(VersionParser.OR, 0); }
public Union_rangeContext union_range() {
return getRuleContext(Union_rangeContext.class,0);
}
public List range_type() {
return getRuleContexts(Range_typeContext.class);
}
public Range_typeContext range_type(int i) {
return getRuleContext(Range_typeContext.class,i);
}
public Union_rangeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_union_range; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).enterUnion_range(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).exitUnion_range(this);
}
}
public final Union_rangeContext union_range() throws RecognitionException {
Union_rangeContext _localctx = new Union_rangeContext(_ctx, getState());
enterRule(_localctx, 10, RULE_union_range);
try {
setState(116);
switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(92);
version();
setState(93);
match(OR);
setState(94);
union_range();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(96);
version();
setState(97);
match(OR);
setState(98);
version();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(100);
version();
setState(101);
match(OR);
setState(102);
range_type();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(104);
range_type();
setState(105);
match(OR);
setState(106);
union_range();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(108);
range_type();
setState(109);
match(OR);
setState(110);
range_type();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(112);
range_type();
setState(113);
match(OR);
setState(114);
version();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Logical_rangeContext extends ParserRuleContext {
public List logical_range() {
return getRuleContexts(Logical_rangeContext.class);
}
public Logical_rangeContext logical_range(int i) {
return getRuleContext(Logical_rangeContext.class,i);
}
public List simple_range() {
return getRuleContexts(Simple_rangeContext.class);
}
public Simple_rangeContext simple_range(int i) {
return getRuleContext(Simple_rangeContext.class,i);
}
public Logical_rangeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_logical_range; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).enterLogical_range(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).exitLogical_range(this);
}
}
public final Logical_rangeContext logical_range() throws RecognitionException {
return logical_range(0);
}
private Logical_rangeContext logical_range(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
Logical_rangeContext _localctx = new Logical_rangeContext(_ctx, _parentState);
Logical_rangeContext _prevctx = _localctx;
int _startState = 12;
enterRecursionRule(_localctx, 12, RULE_logical_range, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(139);
switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
case 1:
{
setState(119);
match(T__2);
setState(120);
logical_range(0);
setState(121);
match(T__4);
}
break;
case 2:
{
setState(123);
match(T__2);
setState(124);
simple_range();
setState(125);
match(T__4);
}
break;
case 3:
{
setState(127);
simple_range();
whitespace();
setState(129);
simple_range();
}
break;
case 4:
{
setState(131);
simple_range();
setState(132);
match(T__0);
setState(133);
simple_range();
}
break;
case 5:
{
setState(135);
simple_range();
setState(136);
match(T__5);
setState(137);
simple_range();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(161);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,10,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(159);
switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
case 1:
{
_localctx = new Logical_rangeContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_logical_range);
setState(141);
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
whitespace();
setState(143);
logical_range(8);
}
break;
case 2:
{
_localctx = new Logical_rangeContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_logical_range);
setState(144);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(145);
match(T__0);
setState(146);
logical_range(5);
}
break;
case 3:
{
_localctx = new Logical_rangeContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_logical_range);
setState(147);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(148);
match(T__5);
setState(149);
logical_range(2);
}
break;
case 4:
{
_localctx = new Logical_rangeContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_logical_range);
setState(150);
if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
whitespace();
setState(152);
simple_range();
}
break;
case 5:
{
_localctx = new Logical_rangeContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_logical_range);
setState(153);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(154);
match(T__0);
setState(155);
simple_range();
}
break;
case 6:
{
_localctx = new Logical_rangeContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_logical_range);
setState(156);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(157);
match(T__5);
setState(158);
simple_range();
}
break;
}
}
}
setState(163);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,10,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class Version_setContext extends ParserRuleContext {
public VersionContext version() {
return getRuleContext(VersionContext.class,0);
}
public Version_setContext version_set() {
return getRuleContext(Version_setContext.class,0);
}
public Version_setContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_version_set; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).enterVersion_set(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).exitVersion_set(this);
}
}
public final Version_setContext version_set() throws RecognitionException {
return version_set(0);
}
private Version_setContext version_set(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
Version_setContext _localctx = new Version_setContext(_ctx, _parentState);
Version_setContext _prevctx = _localctx;
int _startState = 14;
enterRecursionRule(_localctx, 14, RULE_version_set, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(165);
version();
}
_ctx.stop = _input.LT(-1);
setState(172);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,11,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new Version_setContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_version_set);
setState(167);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(168);
match(T__0);
setState(169);
version();
}
}
}
setState(174);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,11,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class Simple_rangeContext extends ParserRuleContext {
public VersionContext version() {
return getRuleContext(VersionContext.class,0);
}
public Simple_rangeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simple_range; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).enterSimple_range(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).exitSimple_range(this);
}
}
public final Simple_rangeContext simple_range() throws RecognitionException {
Simple_rangeContext _localctx = new Simple_rangeContext(_ctx, getState());
enterRule(_localctx, 16, RULE_simple_range);
try {
setState(185);
switch (_input.LA(1)) {
case T__6:
enterOuterAlt(_localctx, 1);
{
setState(175);
match(T__6);
setState(176);
version();
}
break;
case T__7:
enterOuterAlt(_localctx, 2);
{
setState(177);
match(T__7);
setState(178);
version();
}
break;
case T__8:
enterOuterAlt(_localctx, 3);
{
setState(179);
match(T__8);
setState(180);
version();
}
break;
case T__9:
enterOuterAlt(_localctx, 4);
{
setState(181);
match(T__9);
setState(182);
version();
}
break;
case T__10:
enterOuterAlt(_localctx, 5);
{
setState(183);
match(T__10);
setState(184);
version();
}
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 VersionContext extends ParserRuleContext {
public Numeric_versionContext numeric_version() {
return getRuleContext(Numeric_versionContext.class,0);
}
public Postfix_versionContext postfix_version() {
return getRuleContext(Postfix_versionContext.class,0);
}
public Prefixed_versionContext prefixed_version() {
return getRuleContext(Prefixed_versionContext.class,0);
}
public Named_versionContext named_version() {
return getRuleContext(Named_versionContext.class,0);
}
public VersionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_version; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).enterVersion(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).exitVersion(this);
}
}
public final VersionContext version() throws RecognitionException {
VersionContext _localctx = new VersionContext(_ctx, getState());
enterRule(_localctx, 18, RULE_version);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(188);
_la = _input.LA(1);
if (_la==T__11) {
{
setState(187);
match(T__11);
}
}
setState(194);
switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
case 1:
{
setState(190);
numeric_version();
}
break;
case 2:
{
setState(191);
postfix_version();
}
break;
case 3:
{
setState(192);
prefixed_version();
}
break;
case 4:
{
setState(193);
named_version();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Prefixed_versionContext extends ParserRuleContext {
public Numeric_versionContext numeric_version() {
return getRuleContext(Numeric_versionContext.class,0);
}
public List any() {
return getRuleContexts(AnyContext.class);
}
public AnyContext any(int i) {
return getRuleContext(AnyContext.class,i);
}
public Postfix_versionContext postfix_version() {
return getRuleContext(Postfix_versionContext.class,0);
}
public Prefixed_versionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_prefixed_version; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).enterPrefixed_version(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).exitPrefixed_version(this);
}
}
public final Prefixed_versionContext prefixed_version() throws RecognitionException {
Prefixed_versionContext _localctx = new Prefixed_versionContext(_ctx, getState());
enterRule(_localctx, 20, RULE_prefixed_version);
try {
int _alt;
setState(210);
switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(199);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,15,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(196);
any();
}
}
}
setState(201);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,15,_ctx);
}
setState(202);
numeric_version();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(206);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,16,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(203);
any();
}
}
}
setState(208);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,16,_ctx);
}
setState(209);
postfix_version();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Postfix_versionContext extends ParserRuleContext {
public List NUMBER() { return getTokens(VersionParser.NUMBER); }
public TerminalNode NUMBER(int i) {
return getToken(VersionParser.NUMBER, i);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public Postfix_versionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_postfix_version; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).enterPostfix_version(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).exitPostfix_version(this);
}
}
public final Postfix_versionContext postfix_version() throws RecognitionException {
Postfix_versionContext _localctx = new Postfix_versionContext(_ctx, getState());
enterRule(_localctx, 22, RULE_postfix_version);
try {
setState(246);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(212);
match(NUMBER);
setState(213);
match(T__12);
setState(214);
match(NUMBER);
setState(215);
match(T__12);
setState(216);
match(NUMBER);
setState(217);
identifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(218);
match(NUMBER);
setState(219);
match(T__12);
setState(220);
match(NUMBER);
setState(221);
match(T__12);
setState(222);
match(NUMBER);
setState(223);
match(T__12);
setState(224);
identifier();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(225);
match(NUMBER);
setState(226);
match(T__12);
setState(227);
match(NUMBER);
setState(228);
match(T__12);
setState(229);
match(NUMBER);
setState(230);
match(T__13);
setState(231);
identifier();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(232);
match(NUMBER);
setState(233);
match(T__12);
setState(234);
match(NUMBER);
setState(235);
identifier();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(236);
match(NUMBER);
setState(237);
match(T__12);
setState(238);
match(NUMBER);
setState(239);
match(T__12);
setState(240);
identifier();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(241);
match(NUMBER);
setState(242);
match(T__12);
setState(243);
match(NUMBER);
setState(244);
match(T__13);
setState(245);
identifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Numeric_versionContext extends ParserRuleContext {
public List NUMBER() { return getTokens(VersionParser.NUMBER); }
public TerminalNode NUMBER(int i) {
return getToken(VersionParser.NUMBER, i);
}
public Numeric_versionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_numeric_version; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).enterNumeric_version(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).exitNumeric_version(this);
}
}
public final Numeric_versionContext numeric_version() throws RecognitionException {
Numeric_versionContext _localctx = new Numeric_versionContext(_ctx, getState());
enterRule(_localctx, 24, RULE_numeric_version);
try {
setState(276);
switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(248);
match(NUMBER);
setState(249);
match(T__12);
setState(250);
match(NUMBER);
setState(251);
match(T__12);
setState(252);
match(NUMBER);
setState(253);
match(T__12);
setState(254);
match(NUMBER);
setState(256);
switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
case 1:
{
setState(255);
match(T__12);
}
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(258);
match(NUMBER);
setState(259);
match(T__12);
setState(260);
match(NUMBER);
setState(261);
match(T__12);
setState(262);
match(NUMBER);
setState(264);
switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
case 1:
{
setState(263);
match(T__12);
}
break;
}
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(266);
match(NUMBER);
setState(267);
match(T__12);
setState(268);
match(NUMBER);
setState(270);
switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
case 1:
{
setState(269);
match(T__12);
}
break;
}
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(272);
match(NUMBER);
setState(274);
switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
case 1:
{
setState(273);
match(T__12);
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Named_versionContext extends ParserRuleContext {
public List any() {
return getRuleContexts(AnyContext.class);
}
public AnyContext any(int i) {
return getRuleContext(AnyContext.class,i);
}
public Named_versionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_named_version; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).enterNamed_version(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).exitNamed_version(this);
}
}
public final Named_versionContext named_version() throws RecognitionException {
Named_versionContext _localctx = new Named_versionContext(_ctx, getState());
enterRule(_localctx, 26, RULE_named_version);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(279);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(278);
any();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(281);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,24,_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 IdentifierContext extends ParserRuleContext {
public TerminalNode NUMBER() { return getToken(VersionParser.NUMBER, 0); }
public TerminalNode OR() { return getToken(VersionParser.OR, 0); }
public List any() {
return getRuleContexts(AnyContext.class);
}
public AnyContext any(int i) {
return getRuleContext(AnyContext.class,i);
}
public IdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).enterIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).exitIdentifier(this);
}
}
public final IdentifierContext identifier() throws RecognitionException {
IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
enterRule(_localctx, 28, RULE_identifier);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(283);
_la = _input.LA(1);
if ( _la <= 0 || ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__5) | (1L << T__12) | (1L << T__13) | (1L << OR) | (1L << NUMBER))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(287);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,25,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(284);
any();
}
}
}
setState(289);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,25,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnyContext extends ParserRuleContext {
public TerminalNode ANY() { return getToken(VersionParser.ANY, 0); }
public TerminalNode NUMBER() { return getToken(VersionParser.NUMBER, 0); }
public AnyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_any; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).enterAny(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).exitAny(this);
}
}
public final AnyContext any() throws RecognitionException {
AnyContext _localctx = new AnyContext(_ctx, getState());
enterRule(_localctx, 30, RULE_any);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(290);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__12) | (1L << T__13) | (1L << NUMBER) | (1L << ANY))) != 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 boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 6:
return logical_range_sempred((Logical_rangeContext)_localctx, predIndex);
case 7:
return version_set_sempred((Version_setContext)_localctx, predIndex);
}
return true;
}
private boolean logical_range_sempred(Logical_rangeContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 7);
case 1:
return precpred(_ctx, 4);
case 2:
return precpred(_ctx, 1);
case 3:
return precpred(_ctx, 8);
case 4:
return precpred(_ctx, 5);
case 5:
return precpred(_ctx, 2);
}
return true;
}
private boolean version_set_sempred(Version_setContext _localctx, int predIndex) {
switch (predIndex) {
case 6:
return precpred(_ctx, 1);
}
return true;
}
public static final String _serializedATN =
"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\24\u0127\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\3\2\3\2"+
"\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\5\2\62\n\2\3\3\3"+
"\3\3\3\3\3\3\3\5\39\n\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3"+
"\4\5\4G\n\4\3\4\3\4\3\5\3\5\7\5M\n\5\f\5\16\5P\13\5\3\5\3\5\7\5T\n\5\f"+
"\5\16\5W\13\5\5\5Y\n\5\3\6\3\6\5\6]\n\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3"+
"\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\5\7"+
"w\n\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b"+
"\3\b\3\b\3\b\3\b\3\b\5\b\u008e\n\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b"+
"\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\7\b\u00a2\n\b\f\b\16\b\u00a5\13\b"+
"\3\t\3\t\3\t\3\t\3\t\3\t\7\t\u00ad\n\t\f\t\16\t\u00b0\13\t\3\n\3\n\3\n"+
"\3\n\3\n\3\n\3\n\3\n\3\n\3\n\5\n\u00bc\n\n\3\13\5\13\u00bf\n\13\3\13\3"+
"\13\3\13\3\13\5\13\u00c5\n\13\3\f\7\f\u00c8\n\f\f\f\16\f\u00cb\13\f\3"+
"\f\3\f\7\f\u00cf\n\f\f\f\16\f\u00d2\13\f\3\f\5\f\u00d5\n\f\3\r\3\r\3\r"+
"\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3"+
"\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\5\r\u00f9\n\r\3"+
"\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\5\16\u0103\n\16\3\16\3\16\3\16"+
"\3\16\3\16\3\16\5\16\u010b\n\16\3\16\3\16\3\16\3\16\5\16\u0111\n\16\3"+
"\16\3\16\5\16\u0115\n\16\5\16\u0117\n\16\3\17\6\17\u011a\n\17\r\17\16"+
"\17\u011b\3\20\3\20\7\20\u0120\n\20\f\20\16\20\u0123\13\20\3\21\3\21\3"+
"\21\5\u00c9\u00d0\u0121\4\16\20\22\2\4\6\b\n\f\16\20\22\24\26\30\32\34"+
"\36 \2\6\3\2\4\5\3\2\6\7\5\2\3\3\b\b\17\22\4\2\17\20\22\23\u014c\2\61"+
"\3\2\2\2\48\3\2\2\2\6:\3\2\2\2\bX\3\2\2\2\n\\\3\2\2\2\fv\3\2\2\2\16\u008d"+
"\3\2\2\2\20\u00a6\3\2\2\2\22\u00bb\3\2\2\2\24\u00be\3\2\2\2\26\u00d4\3"+
"\2\2\2\30\u00f8\3\2\2\2\32\u0116\3\2\2\2\34\u0119\3\2\2\2\36\u011d\3\2"+
"\2\2 \u0124\3\2\2\2\"#\5\4\3\2#$\7\2\2\3$\62\3\2\2\2%&\5\20\t\2&\'\7\2"+
"\2\3\'\62\3\2\2\2()\5\f\7\2)*\7\2\2\3*\62\3\2\2\2+,\5\n\6\2,-\7\2\2\3"+
"-\62\3\2\2\2./\5\b\5\2/\60\7\2\2\3\60\62\3\2\2\2\61\"\3\2\2\2\61%\3\2"+
"\2\2\61(\3\2\2\2\61+\3\2\2\2\61.\3\2\2\2\62\3\3\2\2\2\639\5\6\4\2\64\65"+
"\5\6\4\2\65\66\7\3\2\2\66\67\5\4\3\2\679\3\2\2\28\63\3\2\2\28\64\3\2\2"+
"\29\5\3\2\2\2:F\t\2\2\2;G\3\2\2\2<=\5\24\13\2=>\7\3\2\2>?\5\24\13\2?G"+
"\3\2\2\2@A\5\24\13\2AB\7\3\2\2BG\3\2\2\2CG\5\24\13\2DE\7\3\2\2EG\5\24"+
"\13\2F;\3\2\2\2F<\3\2\2\2F@\3\2\2\2FC\3\2\2\2FD\3\2\2\2GH\3\2\2\2HI\t"+
"\3\2\2I\7\3\2\2\2JN\5\22\n\2KM\13\2\2\2LK\3\2\2\2MP\3\2\2\2NL\3\2\2\2"+
"NO\3\2\2\2OY\3\2\2\2PN\3\2\2\2QU\5\24\13\2RT\13\2\2\2SR\3\2\2\2TW\3\2"+
"\2\2US\3\2\2\2UV\3\2\2\2VY\3\2\2\2WU\3\2\2\2XJ\3\2\2\2XQ\3\2\2\2Y\t\3"+
"\2\2\2Z]\5\16\b\2[]\5\22\n\2\\Z\3\2\2\2\\[\3\2\2\2]\13\3\2\2\2^_\5\24"+
"\13\2_`\7\21\2\2`a\5\f\7\2aw\3\2\2\2bc\5\24\13\2cd\7\21\2\2de\5\24\13"+
"\2ew\3\2\2\2fg\5\24\13\2gh\7\21\2\2hi\5\n\6\2iw\3\2\2\2jk\5\n\6\2kl\7"+
"\21\2\2lm\5\f\7\2mw\3\2\2\2no\5\n\6\2op\7\21\2\2pq\5\n\6\2qw\3\2\2\2r"+
"s\5\n\6\2st\7\21\2\2tu\5\24\13\2uw\3\2\2\2v^\3\2\2\2vb\3\2\2\2vf\3\2\2"+
"\2vj\3\2\2\2vn\3\2\2\2vr\3\2\2\2w\r\3\2\2\2xy\b\b\1\2yz\7\5\2\2z{\5\16"+
"\b\2{|\7\7\2\2|\u008e\3\2\2\2}~\7\5\2\2~\177\5\22\n\2\177\u0080\7\7\2"+
"\2\u0080\u008e\3\2\2\2\u0081\u0082\5\22\n\2\u0082\u0083\b\b\1\2\u0083"+
"\u0084\5\22\n\2\u0084\u008e\3\2\2\2\u0085\u0086\5\22\n\2\u0086\u0087\7"+
"\3\2\2\u0087\u0088\5\22\n\2\u0088\u008e\3\2\2\2\u0089\u008a\5\22\n\2\u008a"+
"\u008b\7\b\2\2\u008b\u008c\5\22\n\2\u008c\u008e\3\2\2\2\u008dx\3\2\2\2"+
"\u008d}\3\2\2\2\u008d\u0081\3\2\2\2\u008d\u0085\3\2\2\2\u008d\u0089\3"+
"\2\2\2\u008e\u00a3\3\2\2\2\u008f\u0090\f\t\2\2\u0090\u0091\b\b\1\2\u0091"+
"\u00a2\5\16\b\n\u0092\u0093\f\6\2\2\u0093\u0094\7\3\2\2\u0094\u00a2\5"+
"\16\b\7\u0095\u0096\f\3\2\2\u0096\u0097\7\b\2\2\u0097\u00a2\5\16\b\4\u0098"+
"\u0099\f\n\2\2\u0099\u009a\b\b\1\2\u009a\u00a2\5\22\n\2\u009b\u009c\f"+
"\7\2\2\u009c\u009d\7\3\2\2\u009d\u00a2\5\22\n\2\u009e\u009f\f\4\2\2\u009f"+
"\u00a0\7\b\2\2\u00a0\u00a2\5\22\n\2\u00a1\u008f\3\2\2\2\u00a1\u0092\3"+
"\2\2\2\u00a1\u0095\3\2\2\2\u00a1\u0098\3\2\2\2\u00a1\u009b\3\2\2\2\u00a1"+
"\u009e\3\2\2\2\u00a2\u00a5\3\2\2\2\u00a3\u00a1\3\2\2\2\u00a3\u00a4\3\2"+
"\2\2\u00a4\17\3\2\2\2\u00a5\u00a3\3\2\2\2\u00a6\u00a7\b\t\1\2\u00a7\u00a8"+
"\5\24\13\2\u00a8\u00ae\3\2\2\2\u00a9\u00aa\f\3\2\2\u00aa\u00ab\7\3\2\2"+
"\u00ab\u00ad\5\24\13\2\u00ac\u00a9\3\2\2\2\u00ad\u00b0\3\2\2\2\u00ae\u00ac"+
"\3\2\2\2\u00ae\u00af\3\2\2\2\u00af\21\3\2\2\2\u00b0\u00ae\3\2\2\2\u00b1"+
"\u00b2\7\t\2\2\u00b2\u00bc\5\24\13\2\u00b3\u00b4\7\n\2\2\u00b4\u00bc\5"+
"\24\13\2\u00b5\u00b6\7\13\2\2\u00b6\u00bc\5\24\13\2\u00b7\u00b8\7\f\2"+
"\2\u00b8\u00bc\5\24\13\2\u00b9\u00ba\7\r\2\2\u00ba\u00bc\5\24\13\2\u00bb"+
"\u00b1\3\2\2\2\u00bb\u00b3\3\2\2\2\u00bb\u00b5\3\2\2\2\u00bb\u00b7\3\2"+
"\2\2\u00bb\u00b9\3\2\2\2\u00bc\23\3\2\2\2\u00bd\u00bf\7\16\2\2\u00be\u00bd"+
"\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf\u00c4\3\2\2\2\u00c0\u00c5\5\32\16\2"+
"\u00c1\u00c5\5\30\r\2\u00c2\u00c5\5\26\f\2\u00c3\u00c5\5\34\17\2\u00c4"+
"\u00c0\3\2\2\2\u00c4\u00c1\3\2\2\2\u00c4\u00c2\3\2\2\2\u00c4\u00c3\3\2"+
"\2\2\u00c5\25\3\2\2\2\u00c6\u00c8\5 \21\2\u00c7\u00c6\3\2\2\2\u00c8\u00cb"+
"\3\2\2\2\u00c9\u00ca\3\2\2\2\u00c9\u00c7\3\2\2\2\u00ca\u00cc\3\2\2\2\u00cb"+
"\u00c9\3\2\2\2\u00cc\u00d5\5\32\16\2\u00cd\u00cf\5 \21\2\u00ce\u00cd\3"+
"\2\2\2\u00cf\u00d2\3\2\2\2\u00d0\u00d1\3\2\2\2\u00d0\u00ce\3\2\2\2\u00d1"+
"\u00d3\3\2\2\2\u00d2\u00d0\3\2\2\2\u00d3\u00d5\5\30\r\2\u00d4\u00c9\3"+
"\2\2\2\u00d4\u00d0\3\2\2\2\u00d5\27\3\2\2\2\u00d6\u00d7\7\22\2\2\u00d7"+
"\u00d8\7\17\2\2\u00d8\u00d9\7\22\2\2\u00d9\u00da\7\17\2\2\u00da\u00db"+
"\7\22\2\2\u00db\u00f9\5\36\20\2\u00dc\u00dd\7\22\2\2\u00dd\u00de\7\17"+
"\2\2\u00de\u00df\7\22\2\2\u00df\u00e0\7\17\2\2\u00e0\u00e1\7\22\2\2\u00e1"+
"\u00e2\7\17\2\2\u00e2\u00f9\5\36\20\2\u00e3\u00e4\7\22\2\2\u00e4\u00e5"+
"\7\17\2\2\u00e5\u00e6\7\22\2\2\u00e6\u00e7\7\17\2\2\u00e7\u00e8\7\22\2"+
"\2\u00e8\u00e9\7\20\2\2\u00e9\u00f9\5\36\20\2\u00ea\u00eb\7\22\2\2\u00eb"+
"\u00ec\7\17\2\2\u00ec\u00ed\7\22\2\2\u00ed\u00f9\5\36\20\2\u00ee\u00ef"+
"\7\22\2\2\u00ef\u00f0\7\17\2\2\u00f0\u00f1\7\22\2\2\u00f1\u00f2\7\17\2"+
"\2\u00f2\u00f9\5\36\20\2\u00f3\u00f4\7\22\2\2\u00f4\u00f5\7\17\2\2\u00f5"+
"\u00f6\7\22\2\2\u00f6\u00f7\7\20\2\2\u00f7\u00f9\5\36\20\2\u00f8\u00d6"+
"\3\2\2\2\u00f8\u00dc\3\2\2\2\u00f8\u00e3\3\2\2\2\u00f8\u00ea\3\2\2\2\u00f8"+
"\u00ee\3\2\2\2\u00f8\u00f3\3\2\2\2\u00f9\31\3\2\2\2\u00fa\u00fb\7\22\2"+
"\2\u00fb\u00fc\7\17\2\2\u00fc\u00fd\7\22\2\2\u00fd\u00fe\7\17\2\2\u00fe"+
"\u00ff\7\22\2\2\u00ff\u0100\7\17\2\2\u0100\u0102\7\22\2\2\u0101\u0103"+
"\7\17\2\2\u0102\u0101\3\2\2\2\u0102\u0103\3\2\2\2\u0103\u0117\3\2\2\2"+
"\u0104\u0105\7\22\2\2\u0105\u0106\7\17\2\2\u0106\u0107\7\22\2\2\u0107"+
"\u0108\7\17\2\2\u0108\u010a\7\22\2\2\u0109\u010b\7\17\2\2\u010a\u0109"+
"\3\2\2\2\u010a\u010b\3\2\2\2\u010b\u0117\3\2\2\2\u010c\u010d\7\22\2\2"+
"\u010d\u010e\7\17\2\2\u010e\u0110\7\22\2\2\u010f\u0111\7\17\2\2\u0110"+
"\u010f\3\2\2\2\u0110\u0111\3\2\2\2\u0111\u0117\3\2\2\2\u0112\u0114\7\22"+
"\2\2\u0113\u0115\7\17\2\2\u0114\u0113\3\2\2\2\u0114\u0115\3\2\2\2\u0115"+
"\u0117\3\2\2\2\u0116\u00fa\3\2\2\2\u0116\u0104\3\2\2\2\u0116\u010c\3\2"+
"\2\2\u0116\u0112\3\2\2\2\u0117\33\3\2\2\2\u0118\u011a\5 \21\2\u0119\u0118"+
"\3\2\2\2\u011a\u011b\3\2\2\2\u011b\u0119\3\2\2\2\u011b\u011c\3\2\2\2\u011c"+
"\35\3\2\2\2\u011d\u0121\n\4\2\2\u011e\u0120\5 \21\2\u011f\u011e\3\2\2"+
"\2\u0120\u0123\3\2\2\2\u0121\u0122\3\2\2\2\u0121\u011f\3\2\2\2\u0122\37"+
"\3\2\2\2\u0123\u0121\3\2\2\2\u0124\u0125\t\5\2\2\u0125!\3\2\2\2\34\61"+
"8FNUX\\v\u008d\u00a1\u00a3\u00ae\u00bb\u00be\u00c4\u00c9\u00d0\u00d4\u00f8"+
"\u0102\u010a\u0110\u0114\u0116\u011b\u0121";
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