net.ossindex.version.parser.VersionParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of heuristic-version Show documentation
Show all versions of heuristic-version Show documentation
Utility classes that help parse and compare version strings
The newest version!
// 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, T__14=15, T__15=16, T__16=17,
T__17=18, OR=19, NUMBER=20, ANY=21, WS=22;
public static final int
RULE_range = 0, RULE_maven_ranges = 1, RULE_maven_range = 2, RULE_broken_range = 3,
RULE_range_type = 4, RULE_semantic_range = 5, RULE_union_range = 6, RULE_logical_range = 7,
RULE_version_set = 8, RULE_simple_range = 9, RULE_version = 10, RULE_stream = 11,
RULE_prefixed_version = 12, RULE_postfix_version = 13, RULE_numeric_version = 14,
RULE_sep = 15, RULE_dot = 16, RULE_named_version = 17, RULE_valid_named_version = 18,
RULE_identifier = 19, RULE_any = 20;
public static final String[] ruleNames = {
"range", "maven_ranges", "maven_range", "broken_range", "range_type",
"semantic_range", "union_range", "logical_range", "version_set", "simple_range",
"version", "stream", "prefixed_version", "postfix_version", "numeric_version",
"sep", "dot", "named_version", "valid_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, 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; }
/**
* 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);
}
/**
* No whitespace in the HIDDEN channel
*/
private boolean nw() {
return !whitespace();
}
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(57);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(42);
maven_ranges();
setState(43);
match(EOF);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(45);
version_set(0);
setState(46);
match(EOF);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(48);
union_range();
setState(49);
match(EOF);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(51);
range_type();
setState(52);
match(EOF);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(54);
broken_range();
setState(55);
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);
int _la;
try {
setState(84);
switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(59);
maven_range();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(60);
maven_range();
setState(61);
match(T__0);
setState(62);
maven_ranges();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(64);
match(T__1);
setState(66);
_la = _input.LA(1);
if (_la==T__2) {
{
setState(65);
match(T__2);
}
}
setState(68);
match(T__3);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(69);
match(T__4);
setState(71);
_la = _input.LA(1);
if (_la==T__2) {
{
setState(70);
match(T__2);
}
}
setState(73);
match(T__5);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(74);
match(T__1);
setState(76);
_la = _input.LA(1);
if (_la==T__2) {
{
setState(75);
match(T__2);
}
}
setState(78);
match(T__5);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(79);
match(T__4);
setState(81);
_la = _input.LA(1);
if (_la==T__2) {
{
setState(80);
match(T__2);
}
}
setState(83);
match(T__3);
}
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(86);
_la = _input.LA(1);
if ( !(_la==T__1 || _la==T__4) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(98);
switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
case 1:
{
}
break;
case 2:
{
setState(88);
version();
setState(89);
match(T__0);
setState(90);
version();
}
break;
case 3:
{
setState(92);
version();
setState(93);
match(T__0);
}
break;
case 4:
{
setState(95);
version();
}
break;
case 5:
{
setState(96);
match(T__0);
setState(97);
version();
}
break;
}
setState(100);
_la = _input.LA(1);
if ( !(_la==T__3 || _la==T__5) ) {
_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(116);
switch (_input.LA(1)) {
case T__8:
case T__9:
case T__10:
case T__11:
case T__12:
enterOuterAlt(_localctx, 1);
{
setState(102);
simple_range();
setState(106);
_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 << OR) | (1L << NUMBER) | (1L << ANY) | (1L << WS))) != 0)) {
{
{
setState(103);
matchWildcard();
}
}
setState(108);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case T__2:
case T__13:
case T__15:
case T__16:
case T__17:
case NUMBER:
case ANY:
enterOuterAlt(_localctx, 2);
{
setState(109);
version();
setState(113);
_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 << OR) | (1L << NUMBER) | (1L << ANY) | (1L << WS))) != 0)) {
{
{
setState(110);
matchWildcard();
}
}
setState(115);
_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 Semantic_rangeContext semantic_range() {
return getRuleContext(Semantic_rangeContext.class,0);
}
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(121);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(118);
semantic_range();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(119);
logical_range(0);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(120);
simple_range();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Semantic_rangeContext extends ParserRuleContext {
public VersionContext version() {
return getRuleContext(VersionContext.class,0);
}
public Semantic_rangeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_semantic_range; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).enterSemantic_range(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).exitSemantic_range(this);
}
}
public final Semantic_rangeContext semantic_range() throws RecognitionException {
Semantic_rangeContext _localctx = new Semantic_rangeContext(_ctx, getState());
enterRule(_localctx, 10, RULE_semantic_range);
try {
enterOuterAlt(_localctx, 1);
{
setState(123);
match(T__6);
setState(124);
version();
}
}
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, 12, RULE_union_range);
try {
setState(150);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(126);
version();
setState(127);
match(OR);
setState(128);
union_range();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(130);
version();
setState(131);
match(OR);
setState(132);
version();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(134);
version();
setState(135);
match(OR);
setState(136);
range_type();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(138);
range_type();
setState(139);
match(OR);
setState(140);
union_range();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(142);
range_type();
setState(143);
match(OR);
setState(144);
range_type();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(146);
range_type();
setState(147);
match(OR);
setState(148);
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 Union_rangeContext union_range() {
return getRuleContext(Union_rangeContext.class,0);
}
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 = 14;
enterRecursionRule(_localctx, 14, RULE_logical_range, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(177);
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
case 1:
{
setState(153);
match(T__4);
setState(154);
logical_range(0);
setState(155);
match(T__5);
}
break;
case 2:
{
setState(157);
match(T__4);
setState(158);
simple_range();
setState(159);
match(T__5);
}
break;
case 3:
{
setState(161);
match(T__4);
setState(162);
union_range();
setState(163);
match(T__5);
}
break;
case 4:
{
setState(165);
simple_range();
whitespace();
setState(167);
simple_range();
}
break;
case 5:
{
setState(169);
simple_range();
setState(170);
match(T__0);
setState(171);
simple_range();
}
break;
case 6:
{
setState(173);
simple_range();
setState(174);
match(T__7);
setState(175);
simple_range();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(199);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(197);
switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
case 1:
{
_localctx = new Logical_rangeContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_logical_range);
setState(179);
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
whitespace();
setState(181);
logical_range(8);
}
break;
case 2:
{
_localctx = new Logical_rangeContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_logical_range);
setState(182);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(183);
match(T__0);
setState(184);
logical_range(5);
}
break;
case 3:
{
_localctx = new Logical_rangeContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_logical_range);
setState(185);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(186);
match(T__7);
setState(187);
logical_range(2);
}
break;
case 4:
{
_localctx = new Logical_rangeContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_logical_range);
setState(188);
if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
whitespace();
setState(190);
simple_range();
}
break;
case 5:
{
_localctx = new Logical_rangeContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_logical_range);
setState(191);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(192);
match(T__0);
setState(193);
simple_range();
}
break;
case 6:
{
_localctx = new Logical_rangeContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_logical_range);
setState(194);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(195);
match(T__7);
setState(196);
simple_range();
}
break;
}
}
}
setState(201);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class 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 = 16;
enterRecursionRule(_localctx, 16, RULE_version_set, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(203);
version();
}
_ctx.stop = _input.LT(-1);
setState(210);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,15,_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(205);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(206);
match(T__0);
setState(207);
version();
}
}
}
setState(212);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,15,_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, 18, RULE_simple_range);
try {
setState(223);
switch (_input.LA(1)) {
case T__8:
enterOuterAlt(_localctx, 1);
{
setState(213);
match(T__8);
setState(214);
version();
}
break;
case T__9:
enterOuterAlt(_localctx, 2);
{
setState(215);
match(T__9);
setState(216);
version();
}
break;
case T__10:
enterOuterAlt(_localctx, 3);
{
setState(217);
match(T__10);
setState(218);
version();
}
break;
case T__11:
enterOuterAlt(_localctx, 4);
{
setState(219);
match(T__11);
setState(220);
version();
}
break;
case T__12:
enterOuterAlt(_localctx, 5);
{
setState(221);
match(T__12);
setState(222);
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 StreamContext stream() {
return getRuleContext(StreamContext.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, 20, RULE_version);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(226);
_la = _input.LA(1);
if (_la==T__13) {
{
setState(225);
match(T__13);
}
}
setState(229);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
{
setState(228);
stream();
}
break;
}
setState(235);
switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
case 1:
{
setState(231);
numeric_version();
}
break;
case 2:
{
setState(232);
postfix_version();
}
break;
case 3:
{
setState(233);
prefixed_version();
}
break;
case 4:
{
setState(234);
named_version();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StreamContext extends ParserRuleContext {
public TerminalNode NUMBER() { return getToken(VersionParser.NUMBER, 0); }
public StreamContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stream; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).enterStream(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).exitStream(this);
}
}
public final StreamContext stream() throws RecognitionException {
StreamContext _localctx = new StreamContext(_ctx, getState());
enterRule(_localctx, 22, RULE_stream);
try {
enterOuterAlt(_localctx, 1);
{
setState(237);
match(NUMBER);
setState(238);
match(T__14);
}
}
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, 24, RULE_prefixed_version);
try {
int _alt;
setState(254);
switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(243);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,20,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(240);
any();
}
}
}
setState(245);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,20,_ctx);
}
setState(246);
numeric_version();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(250);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,21,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(247);
any();
}
}
}
setState(252);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,21,_ctx);
}
setState(253);
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 List dot() {
return getRuleContexts(DotContext.class);
}
public DotContext dot(int i) {
return getRuleContext(DotContext.class,i);
}
public SepContext sep() {
return getRuleContext(SepContext.class,0);
}
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, 26, RULE_postfix_version);
try {
setState(304);
switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(256);
match(NUMBER);
setState(257);
dot();
setState(258);
match(NUMBER);
setState(259);
dot();
setState(260);
match(NUMBER);
setState(261);
dot();
setState(262);
match(NUMBER);
setState(263);
sep();
setState(264);
identifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(266);
match(NUMBER);
setState(267);
dot();
setState(268);
match(NUMBER);
setState(269);
dot();
setState(270);
match(NUMBER);
setState(271);
dot();
setState(272);
match(NUMBER);
setState(273);
if (!(nw())) throw new FailedPredicateException(this, "nw()");
setState(274);
identifier();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(276);
match(NUMBER);
setState(277);
dot();
setState(278);
match(NUMBER);
setState(279);
dot();
setState(280);
match(NUMBER);
setState(281);
sep();
setState(282);
identifier();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(284);
match(NUMBER);
setState(285);
dot();
setState(286);
match(NUMBER);
setState(287);
dot();
setState(288);
match(NUMBER);
setState(289);
if (!(nw())) throw new FailedPredicateException(this, "nw()");
setState(290);
identifier();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(292);
match(NUMBER);
setState(293);
dot();
setState(294);
match(NUMBER);
setState(295);
sep();
setState(296);
identifier();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(298);
match(NUMBER);
setState(299);
dot();
setState(300);
match(NUMBER);
setState(301);
if (!(nw())) throw new FailedPredicateException(this, "nw()");
setState(302);
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 List dot() {
return getRuleContexts(DotContext.class);
}
public DotContext dot(int i) {
return getRuleContext(DotContext.class,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, 28, RULE_numeric_version);
try {
setState(334);
switch ( getInterpreter().adaptivePredict(_input,28,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(306);
match(NUMBER);
setState(307);
dot();
setState(308);
match(NUMBER);
setState(309);
dot();
setState(310);
match(NUMBER);
setState(311);
dot();
setState(312);
match(NUMBER);
setState(314);
switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
case 1:
{
setState(313);
dot();
}
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(316);
match(NUMBER);
setState(317);
dot();
setState(318);
match(NUMBER);
setState(319);
dot();
setState(320);
match(NUMBER);
setState(322);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
{
setState(321);
dot();
}
break;
}
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(324);
match(NUMBER);
setState(325);
dot();
setState(326);
match(NUMBER);
setState(328);
switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
case 1:
{
setState(327);
dot();
}
break;
}
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(330);
match(NUMBER);
setState(332);
switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
case 1:
{
setState(331);
dot();
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SepContext extends ParserRuleContext {
public SepContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sep; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).enterSep(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).exitSep(this);
}
}
public final SepContext sep() throws RecognitionException {
SepContext _localctx = new SepContext(_ctx, getState());
enterRule(_localctx, 30, RULE_sep);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(336);
if (!(nw())) throw new FailedPredicateException(this, "nw()");
setState(337);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__15) | (1L << T__16))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(338);
if (!(nw())) throw new FailedPredicateException(this, "nw()");
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DotContext extends ParserRuleContext {
public DotContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dot; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).enterDot(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).exitDot(this);
}
}
public final DotContext dot() throws RecognitionException {
DotContext _localctx = new DotContext(_ctx, getState());
enterRule(_localctx, 32, RULE_dot);
try {
enterOuterAlt(_localctx, 1);
{
setState(340);
if (!(nw())) throw new FailedPredicateException(this, "nw()");
setState(341);
match(T__15);
setState(342);
if (!(nw())) throw new FailedPredicateException(this, "nw()");
}
}
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 Valid_named_versionContext valid_named_version() {
return getRuleContext(Valid_named_versionContext.class,0);
}
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, 34, RULE_named_version);
try {
enterOuterAlt(_localctx, 1);
{
setState(344);
valid_named_version();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Valid_named_versionContext extends ParserRuleContext {
public AnyContext any() {
return getRuleContext(AnyContext.class,0);
}
public Valid_named_versionContext valid_named_version() {
return getRuleContext(Valid_named_versionContext.class,0);
}
public Valid_named_versionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_valid_named_version; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).enterValid_named_version(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof VersionListener ) ((VersionListener)listener).exitValid_named_version(this);
}
}
public final Valid_named_versionContext valid_named_version() throws RecognitionException {
Valid_named_versionContext _localctx = new Valid_named_versionContext(_ctx, getState());
enterRule(_localctx, 36, RULE_valid_named_version);
try {
setState(351);
switch ( getInterpreter().adaptivePredict(_input,29,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(346);
any();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(347);
any();
setState(348);
if (!(nw())) throw new FailedPredicateException(this, "nw()");
setState(349);
valid_named_version();
}
break;
}
}
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 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, 38, RULE_identifier);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(353);
_la = _input.LA(1);
if ( _la <= 0 || ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__2) | (1L << T__7) | (1L << T__15) | (1L << OR))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(357);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,30,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(354);
any();
}
}
}
setState(359);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,30,_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, 40, RULE_any);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(360);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__15) | (1L << T__16) | (1L << T__17) | (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 7:
return logical_range_sempred((Logical_rangeContext)_localctx, predIndex);
case 8:
return version_set_sempred((Version_setContext)_localctx, predIndex);
case 13:
return postfix_version_sempred((Postfix_versionContext)_localctx, predIndex);
case 15:
return sep_sempred((SepContext)_localctx, predIndex);
case 16:
return dot_sempred((DotContext)_localctx, predIndex);
case 18:
return valid_named_version_sempred((Valid_named_versionContext)_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;
}
private boolean postfix_version_sempred(Postfix_versionContext _localctx, int predIndex) {
switch (predIndex) {
case 7:
return nw();
case 8:
return nw();
case 9:
return nw();
}
return true;
}
private boolean sep_sempred(SepContext _localctx, int predIndex) {
switch (predIndex) {
case 10:
return nw();
case 11:
return nw();
}
return true;
}
private boolean dot_sempred(DotContext _localctx, int predIndex) {
switch (predIndex) {
case 12:
return nw();
case 13:
return nw();
}
return true;
}
private boolean valid_named_version_sempred(Valid_named_versionContext _localctx, int predIndex) {
switch (predIndex) {
case 14:
return nw();
}
return true;
}
public static final String _serializedATN =
"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\30\u016d\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\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<\n\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\5"+
"\3E\n\3\3\3\3\3\3\3\5\3J\n\3\3\3\3\3\3\3\5\3O\n\3\3\3\3\3\3\3\5\3T\n\3"+
"\3\3\5\3W\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\4e\n\4"+
"\3\4\3\4\3\5\3\5\7\5k\n\5\f\5\16\5n\13\5\3\5\3\5\7\5r\n\5\f\5\16\5u\13"+
"\5\5\5w\n\5\3\6\3\6\3\6\5\6|\n\6\3\7\3\7\3\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\3\b\3\b\3\b"+
"\5\b\u0099\n\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t"+
"\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\5\t\u00b4\n\t\3\t\3\t\3\t"+
"\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\7\t\u00c8"+
"\n\t\f\t\16\t\u00cb\13\t\3\n\3\n\3\n\3\n\3\n\3\n\7\n\u00d3\n\n\f\n\16"+
"\n\u00d6\13\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\5\13\u00e2"+
"\n\13\3\f\5\f\u00e5\n\f\3\f\5\f\u00e8\n\f\3\f\3\f\3\f\3\f\5\f\u00ee\n"+
"\f\3\r\3\r\3\r\3\16\7\16\u00f4\n\16\f\16\16\16\u00f7\13\16\3\16\3\16\7"+
"\16\u00fb\n\16\f\16\16\16\u00fe\13\16\3\16\5\16\u0101\n\16\3\17\3\17\3"+
"\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3"+
"\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3"+
"\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3"+
"\17\3\17\3\17\3\17\5\17\u0133\n\17\3\20\3\20\3\20\3\20\3\20\3\20\3\20"+
"\3\20\5\20\u013d\n\20\3\20\3\20\3\20\3\20\3\20\3\20\5\20\u0145\n\20\3"+
"\20\3\20\3\20\3\20\5\20\u014b\n\20\3\20\3\20\5\20\u014f\n\20\5\20\u0151"+
"\n\20\3\21\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3\23\3\23\3\24\3\24\3\24"+
"\3\24\3\24\5\24\u0162\n\24\3\25\3\25\7\25\u0166\n\25\f\25\16\25\u0169"+
"\13\25\3\26\3\26\3\26\5\u00f5\u00fc\u0167\4\20\22\27\2\4\6\b\n\f\16\20"+
"\22\24\26\30\32\34\36 \"$&(*\2\7\4\2\4\4\7\7\4\2\6\6\b\b\4\2\5\5\22\23"+
"\7\2\3\3\5\5\n\n\22\22\25\25\5\2\5\5\22\24\26\27\u0198\2;\3\2\2\2\4V\3"+
"\2\2\2\6X\3\2\2\2\bv\3\2\2\2\n{\3\2\2\2\f}\3\2\2\2\16\u0098\3\2\2\2\20"+
"\u00b3\3\2\2\2\22\u00cc\3\2\2\2\24\u00e1\3\2\2\2\26\u00e4\3\2\2\2\30\u00ef"+
"\3\2\2\2\32\u0100\3\2\2\2\34\u0132\3\2\2\2\36\u0150\3\2\2\2 \u0152\3\2"+
"\2\2\"\u0156\3\2\2\2$\u015a\3\2\2\2&\u0161\3\2\2\2(\u0163\3\2\2\2*\u016a"+
"\3\2\2\2,-\5\4\3\2-.\7\2\2\3.<\3\2\2\2/\60\5\22\n\2\60\61\7\2\2\3\61<"+
"\3\2\2\2\62\63\5\16\b\2\63\64\7\2\2\3\64<\3\2\2\2\65\66\5\n\6\2\66\67"+
"\7\2\2\3\67<\3\2\2\289\5\b\5\29:\7\2\2\3:<\3\2\2\2;,\3\2\2\2;/\3\2\2\2"+
";\62\3\2\2\2;\65\3\2\2\2;8\3\2\2\2<\3\3\2\2\2=W\5\6\4\2>?\5\6\4\2?@\7"+
"\3\2\2@A\5\4\3\2AW\3\2\2\2BD\7\4\2\2CE\7\5\2\2DC\3\2\2\2DE\3\2\2\2EF\3"+
"\2\2\2FW\7\6\2\2GI\7\7\2\2HJ\7\5\2\2IH\3\2\2\2IJ\3\2\2\2JK\3\2\2\2KW\7"+
"\b\2\2LN\7\4\2\2MO\7\5\2\2NM\3\2\2\2NO\3\2\2\2OP\3\2\2\2PW\7\b\2\2QS\7"+
"\7\2\2RT\7\5\2\2SR\3\2\2\2ST\3\2\2\2TU\3\2\2\2UW\7\6\2\2V=\3\2\2\2V>\3"+
"\2\2\2VB\3\2\2\2VG\3\2\2\2VL\3\2\2\2VQ\3\2\2\2W\5\3\2\2\2Xd\t\2\2\2Ye"+
"\3\2\2\2Z[\5\26\f\2[\\\7\3\2\2\\]\5\26\f\2]e\3\2\2\2^_\5\26\f\2_`\7\3"+
"\2\2`e\3\2\2\2ae\5\26\f\2bc\7\3\2\2ce\5\26\f\2dY\3\2\2\2dZ\3\2\2\2d^\3"+
"\2\2\2da\3\2\2\2db\3\2\2\2ef\3\2\2\2fg\t\3\2\2g\7\3\2\2\2hl\5\24\13\2"+
"ik\13\2\2\2ji\3\2\2\2kn\3\2\2\2lj\3\2\2\2lm\3\2\2\2mw\3\2\2\2nl\3\2\2"+
"\2os\5\26\f\2pr\13\2\2\2qp\3\2\2\2ru\3\2\2\2sq\3\2\2\2st\3\2\2\2tw\3\2"+
"\2\2us\3\2\2\2vh\3\2\2\2vo\3\2\2\2w\t\3\2\2\2x|\5\f\7\2y|\5\20\t\2z|\5"+
"\24\13\2{x\3\2\2\2{y\3\2\2\2{z\3\2\2\2|\13\3\2\2\2}~\7\t\2\2~\177\5\26"+
"\f\2\177\r\3\2\2\2\u0080\u0081\5\26\f\2\u0081\u0082\7\25\2\2\u0082\u0083"+
"\5\16\b\2\u0083\u0099\3\2\2\2\u0084\u0085\5\26\f\2\u0085\u0086\7\25\2"+
"\2\u0086\u0087\5\26\f\2\u0087\u0099\3\2\2\2\u0088\u0089\5\26\f\2\u0089"+
"\u008a\7\25\2\2\u008a\u008b\5\n\6\2\u008b\u0099\3\2\2\2\u008c\u008d\5"+
"\n\6\2\u008d\u008e\7\25\2\2\u008e\u008f\5\16\b\2\u008f\u0099\3\2\2\2\u0090"+
"\u0091\5\n\6\2\u0091\u0092\7\25\2\2\u0092\u0093\5\n\6\2\u0093\u0099\3"+
"\2\2\2\u0094\u0095\5\n\6\2\u0095\u0096\7\25\2\2\u0096\u0097\5\26\f\2\u0097"+
"\u0099\3\2\2\2\u0098\u0080\3\2\2\2\u0098\u0084\3\2\2\2\u0098\u0088\3\2"+
"\2\2\u0098\u008c\3\2\2\2\u0098\u0090\3\2\2\2\u0098\u0094\3\2\2\2\u0099"+
"\17\3\2\2\2\u009a\u009b\b\t\1\2\u009b\u009c\7\7\2\2\u009c\u009d\5\20\t"+
"\2\u009d\u009e\7\b\2\2\u009e\u00b4\3\2\2\2\u009f\u00a0\7\7\2\2\u00a0\u00a1"+
"\5\24\13\2\u00a1\u00a2\7\b\2\2\u00a2\u00b4\3\2\2\2\u00a3\u00a4\7\7\2\2"+
"\u00a4\u00a5\5\16\b\2\u00a5\u00a6\7\b\2\2\u00a6\u00b4\3\2\2\2\u00a7\u00a8"+
"\5\24\13\2\u00a8\u00a9\b\t\1\2\u00a9\u00aa\5\24\13\2\u00aa\u00b4\3\2\2"+
"\2\u00ab\u00ac\5\24\13\2\u00ac\u00ad\7\3\2\2\u00ad\u00ae\5\24\13\2\u00ae"+
"\u00b4\3\2\2\2\u00af\u00b0\5\24\13\2\u00b0\u00b1\7\n\2\2\u00b1\u00b2\5"+
"\24\13\2\u00b2\u00b4\3\2\2\2\u00b3\u009a\3\2\2\2\u00b3\u009f\3\2\2\2\u00b3"+
"\u00a3\3\2\2\2\u00b3\u00a7\3\2\2\2\u00b3\u00ab\3\2\2\2\u00b3\u00af\3\2"+
"\2\2\u00b4\u00c9\3\2\2\2\u00b5\u00b6\f\t\2\2\u00b6\u00b7\b\t\1\2\u00b7"+
"\u00c8\5\20\t\n\u00b8\u00b9\f\6\2\2\u00b9\u00ba\7\3\2\2\u00ba\u00c8\5"+
"\20\t\7\u00bb\u00bc\f\3\2\2\u00bc\u00bd\7\n\2\2\u00bd\u00c8\5\20\t\4\u00be"+
"\u00bf\f\n\2\2\u00bf\u00c0\b\t\1\2\u00c0\u00c8\5\24\13\2\u00c1\u00c2\f"+
"\7\2\2\u00c2\u00c3\7\3\2\2\u00c3\u00c8\5\24\13\2\u00c4\u00c5\f\4\2\2\u00c5"+
"\u00c6\7\n\2\2\u00c6\u00c8\5\24\13\2\u00c7\u00b5\3\2\2\2\u00c7\u00b8\3"+
"\2\2\2\u00c7\u00bb\3\2\2\2\u00c7\u00be\3\2\2\2\u00c7\u00c1\3\2\2\2\u00c7"+
"\u00c4\3\2\2\2\u00c8\u00cb\3\2\2\2\u00c9\u00c7\3\2\2\2\u00c9\u00ca\3\2"+
"\2\2\u00ca\21\3\2\2\2\u00cb\u00c9\3\2\2\2\u00cc\u00cd\b\n\1\2\u00cd\u00ce"+
"\5\26\f\2\u00ce\u00d4\3\2\2\2\u00cf\u00d0\f\3\2\2\u00d0\u00d1\7\3\2\2"+
"\u00d1\u00d3\5\26\f\2\u00d2\u00cf\3\2\2\2\u00d3\u00d6\3\2\2\2\u00d4\u00d2"+
"\3\2\2\2\u00d4\u00d5\3\2\2\2\u00d5\23\3\2\2\2\u00d6\u00d4\3\2\2\2\u00d7"+
"\u00d8\7\13\2\2\u00d8\u00e2\5\26\f\2\u00d9\u00da\7\f\2\2\u00da\u00e2\5"+
"\26\f\2\u00db\u00dc\7\r\2\2\u00dc\u00e2\5\26\f\2\u00dd\u00de\7\16\2\2"+
"\u00de\u00e2\5\26\f\2\u00df\u00e0\7\17\2\2\u00e0\u00e2\5\26\f\2\u00e1"+
"\u00d7\3\2\2\2\u00e1\u00d9\3\2\2\2\u00e1\u00db\3\2\2\2\u00e1\u00dd\3\2"+
"\2\2\u00e1\u00df\3\2\2\2\u00e2\25\3\2\2\2\u00e3\u00e5\7\20\2\2\u00e4\u00e3"+
"\3\2\2\2\u00e4\u00e5\3\2\2\2\u00e5\u00e7\3\2\2\2\u00e6\u00e8\5\30\r\2"+
"\u00e7\u00e6\3\2\2\2\u00e7\u00e8\3\2\2\2\u00e8\u00ed\3\2\2\2\u00e9\u00ee"+
"\5\36\20\2\u00ea\u00ee\5\34\17\2\u00eb\u00ee\5\32\16\2\u00ec\u00ee\5$"+
"\23\2\u00ed\u00e9\3\2\2\2\u00ed\u00ea\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ed"+
"\u00ec\3\2\2\2\u00ee\27\3\2\2\2\u00ef\u00f0\7\26\2\2\u00f0\u00f1\7\21"+
"\2\2\u00f1\31\3\2\2\2\u00f2\u00f4\5*\26\2\u00f3\u00f2\3\2\2\2\u00f4\u00f7"+
"\3\2\2\2\u00f5\u00f6\3\2\2\2\u00f5\u00f3\3\2\2\2\u00f6\u00f8\3\2\2\2\u00f7"+
"\u00f5\3\2\2\2\u00f8\u0101\5\36\20\2\u00f9\u00fb\5*\26\2\u00fa\u00f9\3"+
"\2\2\2\u00fb\u00fe\3\2\2\2\u00fc\u00fd\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fd"+
"\u00ff\3\2\2\2\u00fe\u00fc\3\2\2\2\u00ff\u0101\5\34\17\2\u0100\u00f5\3"+
"\2\2\2\u0100\u00fc\3\2\2\2\u0101\33\3\2\2\2\u0102\u0103\7\26\2\2\u0103"+
"\u0104\5\"\22\2\u0104\u0105\7\26\2\2\u0105\u0106\5\"\22\2\u0106\u0107"+
"\7\26\2\2\u0107\u0108\5\"\22\2\u0108\u0109\7\26\2\2\u0109\u010a\5 \21"+
"\2\u010a\u010b\5(\25\2\u010b\u0133\3\2\2\2\u010c\u010d\7\26\2\2\u010d"+
"\u010e\5\"\22\2\u010e\u010f\7\26\2\2\u010f\u0110\5\"\22\2\u0110\u0111"+
"\7\26\2\2\u0111\u0112\5\"\22\2\u0112\u0113\7\26\2\2\u0113\u0114\6\17\t"+
"\2\u0114\u0115\5(\25\2\u0115\u0133\3\2\2\2\u0116\u0117\7\26\2\2\u0117"+
"\u0118\5\"\22\2\u0118\u0119\7\26\2\2\u0119\u011a\5\"\22\2\u011a\u011b"+
"\7\26\2\2\u011b\u011c\5 \21\2\u011c\u011d\5(\25\2\u011d\u0133\3\2\2\2"+
"\u011e\u011f\7\26\2\2\u011f\u0120\5\"\22\2\u0120\u0121\7\26\2\2\u0121"+
"\u0122\5\"\22\2\u0122\u0123\7\26\2\2\u0123\u0124\6\17\n\2\u0124\u0125"+
"\5(\25\2\u0125\u0133\3\2\2\2\u0126\u0127\7\26\2\2\u0127\u0128\5\"\22\2"+
"\u0128\u0129\7\26\2\2\u0129\u012a\5 \21\2\u012a\u012b\5(\25\2\u012b\u0133"+
"\3\2\2\2\u012c\u012d\7\26\2\2\u012d\u012e\5\"\22\2\u012e\u012f\7\26\2"+
"\2\u012f\u0130\6\17\13\2\u0130\u0131\5(\25\2\u0131\u0133\3\2\2\2\u0132"+
"\u0102\3\2\2\2\u0132\u010c\3\2\2\2\u0132\u0116\3\2\2\2\u0132\u011e\3\2"+
"\2\2\u0132\u0126\3\2\2\2\u0132\u012c\3\2\2\2\u0133\35\3\2\2\2\u0134\u0135"+
"\7\26\2\2\u0135\u0136\5\"\22\2\u0136\u0137\7\26\2\2\u0137\u0138\5\"\22"+
"\2\u0138\u0139\7\26\2\2\u0139\u013a\5\"\22\2\u013a\u013c\7\26\2\2\u013b"+
"\u013d\5\"\22\2\u013c\u013b\3\2\2\2\u013c\u013d\3\2\2\2\u013d\u0151\3"+
"\2\2\2\u013e\u013f\7\26\2\2\u013f\u0140\5\"\22\2\u0140\u0141\7\26\2\2"+
"\u0141\u0142\5\"\22\2\u0142\u0144\7\26\2\2\u0143\u0145\5\"\22\2\u0144"+
"\u0143\3\2\2\2\u0144\u0145\3\2\2\2\u0145\u0151\3\2\2\2\u0146\u0147\7\26"+
"\2\2\u0147\u0148\5\"\22\2\u0148\u014a\7\26\2\2\u0149\u014b\5\"\22\2\u014a"+
"\u0149\3\2\2\2\u014a\u014b\3\2\2\2\u014b\u0151\3\2\2\2\u014c\u014e\7\26"+
"\2\2\u014d\u014f\5\"\22\2\u014e\u014d\3\2\2\2\u014e\u014f\3\2\2\2\u014f"+
"\u0151\3\2\2\2\u0150\u0134\3\2\2\2\u0150\u013e\3\2\2\2\u0150\u0146\3\2"+
"\2\2\u0150\u014c\3\2\2\2\u0151\37\3\2\2\2\u0152\u0153\6\21\f\2\u0153\u0154"+
"\t\4\2\2\u0154\u0155\6\21\r\2\u0155!\3\2\2\2\u0156\u0157\6\22\16\2\u0157"+
"\u0158\7\22\2\2\u0158\u0159\6\22\17\2\u0159#\3\2\2\2\u015a\u015b\5&\24"+
"\2\u015b%\3\2\2\2\u015c\u0162\5*\26\2\u015d\u015e\5*\26\2\u015e\u015f"+
"\6\24\20\2\u015f\u0160\5&\24\2\u0160\u0162\3\2\2\2\u0161\u015c\3\2\2\2"+
"\u0161\u015d\3\2\2\2\u0162\'\3\2\2\2\u0163\u0167\n\5\2\2\u0164\u0166\5"+
"*\26\2\u0165\u0164\3\2\2\2\u0166\u0169\3\2\2\2\u0167\u0168\3\2\2\2\u0167"+
"\u0165\3\2\2\2\u0168)\3\2\2\2\u0169\u0167\3\2\2\2\u016a\u016b\t\6\2\2"+
"\u016b+\3\2\2\2!;DINSVdlsv{\u0098\u00b3\u00c7\u00c9\u00d4\u00e1\u00e4"+
"\u00e7\u00ed\u00f5\u00fc\u0100\u0132\u013c\u0144\u014a\u014e\u0150\u0161"+
"\u0167";
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