etagen-lang.1.2.1.source-code.MetagenParser Maven / Gradle / Ivy
The newest version!
// Generated from Metagen.g4 by ANTLR 4.7.1
package io.virtdata.generated;
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 MetagenParser extends Parser {
static { RuntimeMetaData.checkVersion("4.7.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, FLOAT=7, INTEGER=8, NEWLINE=9,
OUTPUTTYPE=10, INPUTTYPE=11, ASSIGN=12, SSTRING_LITERAL=13, DSTRING_LITERAL=14,
ID=15, IDPART=16, WS=17;
public static final int
RULE_metagenRecipe = 0, RULE_metagenFlow = 1, RULE_expression = 2, RULE_metagenCall = 3,
RULE_lvalue = 4, RULE_inputType = 5, RULE_funcName = 6, RULE_outputType = 7,
RULE_arg = 8, RULE_ref = 9, RULE_value = 10, RULE_stringValue = 11, RULE_floatValue = 12,
RULE_integerValue = 13, RULE_specend = 14;
public static final String[] ruleNames = {
"metagenRecipe", "metagenFlow", "expression", "metagenCall", "lvalue",
"inputType", "funcName", "outputType", "arg", "ref", "value", "stringValue",
"floatValue", "integerValue", "specend"
};
private static final String[] _LITERAL_NAMES = {
null, "';'", "'('", "','", "')'", "'$'", "';;'", null, null, null, "'->'",
"'>-'", "'='"
};
private static final String[] _SYMBOLIC_NAMES = {
null, null, null, null, null, null, null, "FLOAT", "INTEGER", "NEWLINE",
"OUTPUTTYPE", "INPUTTYPE", "ASSIGN", "SSTRING_LITERAL", "DSTRING_LITERAL",
"ID", "IDPART", "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 "Metagen.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public MetagenParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class MetagenRecipeContext extends ParserRuleContext {
public List metagenFlow() {
return getRuleContexts(MetagenFlowContext.class);
}
public MetagenFlowContext metagenFlow(int i) {
return getRuleContext(MetagenFlowContext.class,i);
}
public TerminalNode EOF() { return getToken(MetagenParser.EOF, 0); }
public List specend() {
return getRuleContexts(SpecendContext.class);
}
public SpecendContext specend(int i) {
return getRuleContext(SpecendContext.class,i);
}
public MetagenRecipeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_metagenRecipe; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).enterMetagenRecipe(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).exitMetagenRecipe(this);
}
}
public final MetagenRecipeContext metagenRecipe() throws RecognitionException {
MetagenRecipeContext _localctx = new MetagenRecipeContext(_ctx, getState());
enterRule(_localctx, 0, RULE_metagenRecipe);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(30);
metagenFlow();
setState(37);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__5 || _la==NEWLINE) {
{
{
setState(31);
specend();
setState(33);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ID) {
{
setState(32);
metagenFlow();
}
}
}
}
setState(39);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(40);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MetagenFlowContext extends ParserRuleContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public MetagenFlowContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_metagenFlow; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).enterMetagenFlow(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).exitMetagenFlow(this);
}
}
public final MetagenFlowContext metagenFlow() throws RecognitionException {
MetagenFlowContext _localctx = new MetagenFlowContext(_ctx, getState());
enterRule(_localctx, 2, RULE_metagenFlow);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(42);
expression();
setState(49);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__0) {
{
{
setState(43);
match(T__0);
setState(45);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ID) {
{
setState(44);
expression();
}
}
}
}
setState(51);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionContext extends ParserRuleContext {
public MetagenCallContext metagenCall() {
return getRuleContext(MetagenCallContext.class,0);
}
public LvalueContext lvalue() {
return getRuleContext(LvalueContext.class,0);
}
public TerminalNode ASSIGN() { return getToken(MetagenParser.ASSIGN, 0); }
public ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).exitExpression(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
enterRule(_localctx, 4, RULE_expression);
try {
enterOuterAlt(_localctx, 1);
{
setState(55);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
case 1:
{
setState(52);
lvalue();
setState(53);
match(ASSIGN);
}
break;
}
setState(57);
metagenCall();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MetagenCallContext extends ParserRuleContext {
public FuncNameContext funcName() {
return getRuleContext(FuncNameContext.class,0);
}
public InputTypeContext inputType() {
return getRuleContext(InputTypeContext.class,0);
}
public TerminalNode INPUTTYPE() { return getToken(MetagenParser.INPUTTYPE, 0); }
public TerminalNode OUTPUTTYPE() { return getToken(MetagenParser.OUTPUTTYPE, 0); }
public OutputTypeContext outputType() {
return getRuleContext(OutputTypeContext.class,0);
}
public List arg() {
return getRuleContexts(ArgContext.class);
}
public ArgContext arg(int i) {
return getRuleContext(ArgContext.class,i);
}
public MetagenCallContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_metagenCall; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).enterMetagenCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).exitMetagenCall(this);
}
}
public final MetagenCallContext metagenCall() throws RecognitionException {
MetagenCallContext _localctx = new MetagenCallContext(_ctx, getState());
enterRule(_localctx, 6, RULE_metagenCall);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(62);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
case 1:
{
setState(59);
inputType();
setState(60);
match(INPUTTYPE);
}
break;
}
{
setState(64);
funcName();
setState(65);
match(T__1);
setState(74);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__4) | (1L << FLOAT) | (1L << INTEGER) | (1L << SSTRING_LITERAL) | (1L << DSTRING_LITERAL) | (1L << ID))) != 0)) {
{
setState(66);
arg();
setState(71);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__2) {
{
{
setState(67);
match(T__2);
setState(68);
arg();
}
}
setState(73);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(76);
match(T__3);
}
setState(80);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTPUTTYPE) {
{
setState(78);
match(OUTPUTTYPE);
setState(79);
outputType();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LvalueContext extends ParserRuleContext {
public TerminalNode ID() { return getToken(MetagenParser.ID, 0); }
public LvalueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lvalue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).enterLvalue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).exitLvalue(this);
}
}
public final LvalueContext lvalue() throws RecognitionException {
LvalueContext _localctx = new LvalueContext(_ctx, getState());
enterRule(_localctx, 8, RULE_lvalue);
try {
enterOuterAlt(_localctx, 1);
{
setState(82);
match(ID);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InputTypeContext extends ParserRuleContext {
public TerminalNode ID() { return getToken(MetagenParser.ID, 0); }
public InputTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inputType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).enterInputType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).exitInputType(this);
}
}
public final InputTypeContext inputType() throws RecognitionException {
InputTypeContext _localctx = new InputTypeContext(_ctx, getState());
enterRule(_localctx, 10, RULE_inputType);
try {
enterOuterAlt(_localctx, 1);
{
setState(84);
match(ID);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FuncNameContext extends ParserRuleContext {
public TerminalNode ID() { return getToken(MetagenParser.ID, 0); }
public FuncNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_funcName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).enterFuncName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).exitFuncName(this);
}
}
public final FuncNameContext funcName() throws RecognitionException {
FuncNameContext _localctx = new FuncNameContext(_ctx, getState());
enterRule(_localctx, 12, RULE_funcName);
try {
enterOuterAlt(_localctx, 1);
{
setState(86);
match(ID);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OutputTypeContext extends ParserRuleContext {
public TerminalNode ID() { return getToken(MetagenParser.ID, 0); }
public OutputTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_outputType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).enterOutputType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).exitOutputType(this);
}
}
public final OutputTypeContext outputType() throws RecognitionException {
OutputTypeContext _localctx = new OutputTypeContext(_ctx, getState());
enterRule(_localctx, 14, RULE_outputType);
try {
enterOuterAlt(_localctx, 1);
{
setState(88);
match(ID);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArgContext extends ParserRuleContext {
public RefContext ref() {
return getRuleContext(RefContext.class,0);
}
public MetagenCallContext metagenCall() {
return getRuleContext(MetagenCallContext.class,0);
}
public ValueContext value() {
return getRuleContext(ValueContext.class,0);
}
public ArgContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arg; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).enterArg(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).exitArg(this);
}
}
public final ArgContext arg() throws RecognitionException {
ArgContext _localctx = new ArgContext(_ctx, getState());
enterRule(_localctx, 16, RULE_arg);
try {
enterOuterAlt(_localctx, 1);
{
setState(93);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__4:
{
setState(90);
ref();
}
break;
case ID:
{
setState(91);
metagenCall();
}
break;
case FLOAT:
case INTEGER:
case SSTRING_LITERAL:
case DSTRING_LITERAL:
{
setState(92);
value();
}
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 RefContext extends ParserRuleContext {
public TerminalNode ID() { return getToken(MetagenParser.ID, 0); }
public RefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ref; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).enterRef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).exitRef(this);
}
}
public final RefContext ref() throws RecognitionException {
RefContext _localctx = new RefContext(_ctx, getState());
enterRule(_localctx, 18, RULE_ref);
try {
enterOuterAlt(_localctx, 1);
{
{
setState(95);
match(T__4);
setState(96);
match(ID);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ValueContext extends ParserRuleContext {
public FloatValueContext floatValue() {
return getRuleContext(FloatValueContext.class,0);
}
public IntegerValueContext integerValue() {
return getRuleContext(IntegerValueContext.class,0);
}
public StringValueContext stringValue() {
return getRuleContext(StringValueContext.class,0);
}
public ValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_value; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).enterValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).exitValue(this);
}
}
public final ValueContext value() throws RecognitionException {
ValueContext _localctx = new ValueContext(_ctx, getState());
enterRule(_localctx, 20, RULE_value);
try {
enterOuterAlt(_localctx, 1);
{
setState(101);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FLOAT:
{
setState(98);
floatValue();
}
break;
case INTEGER:
{
setState(99);
integerValue();
}
break;
case SSTRING_LITERAL:
case DSTRING_LITERAL:
{
setState(100);
stringValue();
}
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 StringValueContext extends ParserRuleContext {
public TerminalNode SSTRING_LITERAL() { return getToken(MetagenParser.SSTRING_LITERAL, 0); }
public TerminalNode DSTRING_LITERAL() { return getToken(MetagenParser.DSTRING_LITERAL, 0); }
public StringValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stringValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).enterStringValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).exitStringValue(this);
}
}
public final StringValueContext stringValue() throws RecognitionException {
StringValueContext _localctx = new StringValueContext(_ctx, getState());
enterRule(_localctx, 22, RULE_stringValue);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(103);
_la = _input.LA(1);
if ( !(_la==SSTRING_LITERAL || _la==DSTRING_LITERAL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FloatValueContext extends ParserRuleContext {
public TerminalNode FLOAT() { return getToken(MetagenParser.FLOAT, 0); }
public FloatValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_floatValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).enterFloatValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).exitFloatValue(this);
}
}
public final FloatValueContext floatValue() throws RecognitionException {
FloatValueContext _localctx = new FloatValueContext(_ctx, getState());
enterRule(_localctx, 24, RULE_floatValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(105);
match(FLOAT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IntegerValueContext extends ParserRuleContext {
public TerminalNode INTEGER() { return getToken(MetagenParser.INTEGER, 0); }
public IntegerValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_integerValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).enterIntegerValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).exitIntegerValue(this);
}
}
public final IntegerValueContext integerValue() throws RecognitionException {
IntegerValueContext _localctx = new IntegerValueContext(_ctx, getState());
enterRule(_localctx, 26, RULE_integerValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(107);
match(INTEGER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SpecendContext extends ParserRuleContext {
public List NEWLINE() { return getTokens(MetagenParser.NEWLINE); }
public TerminalNode NEWLINE(int i) {
return getToken(MetagenParser.NEWLINE, i);
}
public SpecendContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_specend; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).enterSpecend(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof MetagenListener ) ((MetagenListener)listener).exitSpecend(this);
}
}
public final SpecendContext specend() throws RecognitionException {
SpecendContext _localctx = new SpecendContext(_ctx, getState());
enterRule(_localctx, 28, RULE_specend);
try {
int _alt;
setState(121);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
{
setState(109);
match(T__5);
setState(111);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(110);
match(NEWLINE);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(113);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,11,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(115);
match(T__5);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(117);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(116);
match(NEWLINE);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(119);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\23~\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\3\2\3\2\3\2\5\2$\n\2\7\2"+
"&\n\2\f\2\16\2)\13\2\3\2\3\2\3\3\3\3\3\3\5\3\60\n\3\7\3\62\n\3\f\3\16"+
"\3\65\13\3\3\4\3\4\3\4\5\4:\n\4\3\4\3\4\3\5\3\5\3\5\5\5A\n\5\3\5\3\5\3"+
"\5\3\5\3\5\7\5H\n\5\f\5\16\5K\13\5\5\5M\n\5\3\5\3\5\3\5\3\5\5\5S\n\5\3"+
"\6\3\6\3\7\3\7\3\b\3\b\3\t\3\t\3\n\3\n\3\n\5\n`\n\n\3\13\3\13\3\13\3\f"+
"\3\f\3\f\5\fh\n\f\3\r\3\r\3\16\3\16\3\17\3\17\3\20\3\20\6\20r\n\20\r\20"+
"\16\20s\3\20\3\20\6\20x\n\20\r\20\16\20y\5\20|\n\20\3\20\2\2\21\2\4\6"+
"\b\n\f\16\20\22\24\26\30\32\34\36\2\3\3\2\17\20\2\177\2 \3\2\2\2\4,\3"+
"\2\2\2\69\3\2\2\2\b@\3\2\2\2\nT\3\2\2\2\fV\3\2\2\2\16X\3\2\2\2\20Z\3\2"+
"\2\2\22_\3\2\2\2\24a\3\2\2\2\26g\3\2\2\2\30i\3\2\2\2\32k\3\2\2\2\34m\3"+
"\2\2\2\36{\3\2\2\2 \'\5\4\3\2!#\5\36\20\2\"$\5\4\3\2#\"\3\2\2\2#$\3\2"+
"\2\2$&\3\2\2\2%!\3\2\2\2&)\3\2\2\2\'%\3\2\2\2\'(\3\2\2\2(*\3\2\2\2)\'"+
"\3\2\2\2*+\7\2\2\3+\3\3\2\2\2,\63\5\6\4\2-/\7\3\2\2.\60\5\6\4\2/.\3\2"+
"\2\2/\60\3\2\2\2\60\62\3\2\2\2\61-\3\2\2\2\62\65\3\2\2\2\63\61\3\2\2\2"+
"\63\64\3\2\2\2\64\5\3\2\2\2\65\63\3\2\2\2\66\67\5\n\6\2\678\7\16\2\28"+
":\3\2\2\29\66\3\2\2\29:\3\2\2\2:;\3\2\2\2;<\5\b\5\2<\7\3\2\2\2=>\5\f\7"+
"\2>?\7\r\2\2?A\3\2\2\2@=\3\2\2\2@A\3\2\2\2AB\3\2\2\2BC\5\16\b\2CL\7\4"+
"\2\2DI\5\22\n\2EF\7\5\2\2FH\5\22\n\2GE\3\2\2\2HK\3\2\2\2IG\3\2\2\2IJ\3"+
"\2\2\2JM\3\2\2\2KI\3\2\2\2LD\3\2\2\2LM\3\2\2\2MN\3\2\2\2NO\7\6\2\2OR\3"+
"\2\2\2PQ\7\f\2\2QS\5\20\t\2RP\3\2\2\2RS\3\2\2\2S\t\3\2\2\2TU\7\21\2\2"+
"U\13\3\2\2\2VW\7\21\2\2W\r\3\2\2\2XY\7\21\2\2Y\17\3\2\2\2Z[\7\21\2\2["+
"\21\3\2\2\2\\`\5\24\13\2]`\5\b\5\2^`\5\26\f\2_\\\3\2\2\2_]\3\2\2\2_^\3"+
"\2\2\2`\23\3\2\2\2ab\7\7\2\2bc\7\21\2\2c\25\3\2\2\2dh\5\32\16\2eh\5\34"+
"\17\2fh\5\30\r\2gd\3\2\2\2ge\3\2\2\2gf\3\2\2\2h\27\3\2\2\2ij\t\2\2\2j"+
"\31\3\2\2\2kl\7\t\2\2l\33\3\2\2\2mn\7\n\2\2n\35\3\2\2\2oq\7\b\2\2pr\7"+
"\13\2\2qp\3\2\2\2rs\3\2\2\2sq\3\2\2\2st\3\2\2\2t|\3\2\2\2u|\7\b\2\2vx"+
"\7\13\2\2wv\3\2\2\2xy\3\2\2\2yw\3\2\2\2yz\3\2\2\2z|\3\2\2\2{o\3\2\2\2"+
"{u\3\2\2\2{w\3\2\2\2|\37\3\2\2\2\20#\'/\639@ILR_gsy{";
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