etagen-lang.1.2.1.source-code.LambdasParser Maven / Gradle / Ivy
The newest version!
// Generated from Lambdas.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 LambdasParser 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, INTEGER=7, LONG=8, FLOAT=9,
DOUBLE=10, NEWLINE=11, COMPOSE=12, OUTPUTTYPE=13, INPUTTYPE=14, ASSIGN=15,
SSTRING_LITERAL=16, DSTRING_LITERAL=17, ID=18, IDPART=19, WS=20;
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_longValue = 12,
RULE_doubleValue = 13, RULE_integerValue = 14, RULE_floatValue = 15, RULE_specend = 16;
public static final String[] ruleNames = {
"metagenRecipe", "metagenFlow", "expression", "metagenCall", "lvalue",
"inputType", "funcName", "outputType", "arg", "ref", "value", "stringValue",
"longValue", "doubleValue", "integerValue", "floatValue", "specend"
};
private static final String[] _LITERAL_NAMES = {
null, "';'", "'('", "','", "')'", "'$'", "';;'", null, null, null, null,
null, "'compose'", "'->'", "'>-'", "'='"
};
private static final String[] _SYMBOLIC_NAMES = {
null, null, null, null, null, null, null, "INTEGER", "LONG", "FLOAT",
"DOUBLE", "NEWLINE", "COMPOSE", "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 "Lambdas.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public LambdasParser(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(LambdasParser.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 LambdasListener ) ((LambdasListener)listener).enterMetagenRecipe(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LambdasListener ) ((LambdasListener)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(34);
metagenFlow();
setState(41);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__5 || _la==NEWLINE) {
{
{
setState(35);
specend();
setState(37);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMPOSE || _la==ID) {
{
setState(36);
metagenFlow();
}
}
}
}
setState(43);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(44);
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 TerminalNode COMPOSE() { return getToken(LambdasParser.COMPOSE, 0); }
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 LambdasListener ) ((LambdasListener)listener).enterMetagenFlow(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LambdasListener ) ((LambdasListener)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(47);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMPOSE) {
{
setState(46);
match(COMPOSE);
}
}
setState(49);
expression();
setState(56);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__0) {
{
{
setState(50);
match(T__0);
setState(52);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ID) {
{
setState(51);
expression();
}
}
}
}
setState(58);
_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 ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LambdasListener ) ((LambdasListener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LambdasListener ) ((LambdasListener)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(59);
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 List OUTPUTTYPE() { return getTokens(LambdasParser.OUTPUTTYPE); }
public TerminalNode OUTPUTTYPE(int i) {
return getToken(LambdasParser.OUTPUTTYPE, i);
}
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 LambdasListener ) ((LambdasListener)listener).enterMetagenCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LambdasListener ) ((LambdasListener)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(64);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
case 1:
{
setState(61);
inputType();
setState(62);
match(OUTPUTTYPE);
}
break;
}
{
setState(66);
funcName();
setState(67);
match(T__1);
setState(76);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << INTEGER) | (1L << LONG) | (1L << FLOAT) | (1L << DOUBLE) | (1L << SSTRING_LITERAL) | (1L << DSTRING_LITERAL))) != 0)) {
{
setState(68);
arg();
setState(73);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__2) {
{
{
setState(69);
match(T__2);
setState(70);
arg();
}
}
setState(75);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(78);
match(T__3);
}
setState(82);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTPUTTYPE) {
{
setState(80);
match(OUTPUTTYPE);
setState(81);
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(LambdasParser.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 LambdasListener ) ((LambdasListener)listener).enterLvalue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LambdasListener ) ((LambdasListener)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(84);
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(LambdasParser.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 LambdasListener ) ((LambdasListener)listener).enterInputType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LambdasListener ) ((LambdasListener)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(86);
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(LambdasParser.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 LambdasListener ) ((LambdasListener)listener).enterFuncName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LambdasListener ) ((LambdasListener)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(88);
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(LambdasParser.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 LambdasListener ) ((LambdasListener)listener).enterOutputType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LambdasListener ) ((LambdasListener)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(90);
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 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 LambdasListener ) ((LambdasListener)listener).enterArg(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LambdasListener ) ((LambdasListener)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(92);
value();
}
}
}
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(LambdasParser.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 LambdasListener ) ((LambdasListener)listener).enterRef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LambdasListener ) ((LambdasListener)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(94);
match(T__4);
setState(95);
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 DoubleValueContext doubleValue() {
return getRuleContext(DoubleValueContext.class,0);
}
public IntegerValueContext integerValue() {
return getRuleContext(IntegerValueContext.class,0);
}
public LongValueContext longValue() {
return getRuleContext(LongValueContext.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 LambdasListener ) ((LambdasListener)listener).enterValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LambdasListener ) ((LambdasListener)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(102);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FLOAT:
{
setState(97);
floatValue();
}
break;
case DOUBLE:
{
setState(98);
doubleValue();
}
break;
case INTEGER:
{
setState(99);
integerValue();
}
break;
case LONG:
{
setState(100);
longValue();
}
break;
case SSTRING_LITERAL:
case DSTRING_LITERAL:
{
setState(101);
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(LambdasParser.SSTRING_LITERAL, 0); }
public TerminalNode DSTRING_LITERAL() { return getToken(LambdasParser.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 LambdasListener ) ((LambdasListener)listener).enterStringValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LambdasListener ) ((LambdasListener)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(104);
_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 LongValueContext extends ParserRuleContext {
public TerminalNode LONG() { return getToken(LambdasParser.LONG, 0); }
public LongValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_longValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LambdasListener ) ((LambdasListener)listener).enterLongValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LambdasListener ) ((LambdasListener)listener).exitLongValue(this);
}
}
public final LongValueContext longValue() throws RecognitionException {
LongValueContext _localctx = new LongValueContext(_ctx, getState());
enterRule(_localctx, 24, RULE_longValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(106);
match(LONG);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DoubleValueContext extends ParserRuleContext {
public TerminalNode DOUBLE() { return getToken(LambdasParser.DOUBLE, 0); }
public DoubleValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_doubleValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LambdasListener ) ((LambdasListener)listener).enterDoubleValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LambdasListener ) ((LambdasListener)listener).exitDoubleValue(this);
}
}
public final DoubleValueContext doubleValue() throws RecognitionException {
DoubleValueContext _localctx = new DoubleValueContext(_ctx, getState());
enterRule(_localctx, 26, RULE_doubleValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(108);
match(DOUBLE);
}
}
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(LambdasParser.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 LambdasListener ) ((LambdasListener)listener).enterIntegerValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LambdasListener ) ((LambdasListener)listener).exitIntegerValue(this);
}
}
public final IntegerValueContext integerValue() throws RecognitionException {
IntegerValueContext _localctx = new IntegerValueContext(_ctx, getState());
enterRule(_localctx, 28, RULE_integerValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(110);
match(INTEGER);
}
}
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(LambdasParser.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 LambdasListener ) ((LambdasListener)listener).enterFloatValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LambdasListener ) ((LambdasListener)listener).exitFloatValue(this);
}
}
public final FloatValueContext floatValue() throws RecognitionException {
FloatValueContext _localctx = new FloatValueContext(_ctx, getState());
enterRule(_localctx, 30, RULE_floatValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(112);
match(FLOAT);
}
}
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(LambdasParser.NEWLINE); }
public TerminalNode NEWLINE(int i) {
return getToken(LambdasParser.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 LambdasListener ) ((LambdasListener)listener).enterSpecend(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LambdasListener ) ((LambdasListener)listener).exitSpecend(this);
}
}
public final SpecendContext specend() throws RecognitionException {
SpecendContext _localctx = new SpecendContext(_ctx, getState());
enterRule(_localctx, 32, RULE_specend);
try {
int _alt;
setState(126);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
{
setState(114);
match(T__5);
setState(116);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(115);
match(NEWLINE);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(118);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,10,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(120);
match(T__5);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(122);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(121);
match(NEWLINE);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(124);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,11,_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\26\u0083\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"+
"\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\5\3\62\n\3\3"+
"\3\3\3\3\3\5\3\67\n\3\7\39\n\3\f\3\16\3<\13\3\3\4\3\4\3\5\3\5\3\5\5\5"+
"C\n\5\3\5\3\5\3\5\3\5\3\5\7\5J\n\5\f\5\16\5M\13\5\5\5O\n\5\3\5\3\5\3\5"+
"\3\5\5\5U\n\5\3\6\3\6\3\7\3\7\3\b\3\b\3\t\3\t\3\n\3\n\3\13\3\13\3\13\3"+
"\f\3\f\3\f\3\f\3\f\5\fi\n\f\3\r\3\r\3\16\3\16\3\17\3\17\3\20\3\20\3\21"+
"\3\21\3\22\3\22\6\22w\n\22\r\22\16\22x\3\22\3\22\6\22}\n\22\r\22\16\22"+
"~\5\22\u0081\n\22\3\22\2\2\23\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 "+
"\"\2\3\3\2\22\23\2\u0082\2$\3\2\2\2\4\61\3\2\2\2\6=\3\2\2\2\bB\3\2\2\2"+
"\nV\3\2\2\2\fX\3\2\2\2\16Z\3\2\2\2\20\\\3\2\2\2\22^\3\2\2\2\24`\3\2\2"+
"\2\26h\3\2\2\2\30j\3\2\2\2\32l\3\2\2\2\34n\3\2\2\2\36p\3\2\2\2 r\3\2\2"+
"\2\"\u0080\3\2\2\2$+\5\4\3\2%\'\5\"\22\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\60\62\7\16\2\2\61\60\3\2\2\2\61\62\3\2\2\2\62"+
"\63\3\2\2\2\63:\5\6\4\2\64\66\7\3\2\2\65\67\5\6\4\2\66\65\3\2\2\2\66\67"+
"\3\2\2\2\679\3\2\2\28\64\3\2\2\29<\3\2\2\2:8\3\2\2\2:;\3\2\2\2;\5\3\2"+
"\2\2<:\3\2\2\2=>\5\b\5\2>\7\3\2\2\2?@\5\f\7\2@A\7\17\2\2AC\3\2\2\2B?\3"+
"\2\2\2BC\3\2\2\2CD\3\2\2\2DE\5\16\b\2EN\7\4\2\2FK\5\22\n\2GH\7\5\2\2H"+
"J\5\22\n\2IG\3\2\2\2JM\3\2\2\2KI\3\2\2\2KL\3\2\2\2LO\3\2\2\2MK\3\2\2\2"+
"NF\3\2\2\2NO\3\2\2\2OP\3\2\2\2PQ\7\6\2\2QT\3\2\2\2RS\7\17\2\2SU\5\20\t"+
"\2TR\3\2\2\2TU\3\2\2\2U\t\3\2\2\2VW\7\24\2\2W\13\3\2\2\2XY\7\24\2\2Y\r"+
"\3\2\2\2Z[\7\24\2\2[\17\3\2\2\2\\]\7\24\2\2]\21\3\2\2\2^_\5\26\f\2_\23"+
"\3\2\2\2`a\7\7\2\2ab\7\24\2\2b\25\3\2\2\2ci\5 \21\2di\5\34\17\2ei\5\36"+
"\20\2fi\5\32\16\2gi\5\30\r\2hc\3\2\2\2hd\3\2\2\2he\3\2\2\2hf\3\2\2\2h"+
"g\3\2\2\2i\27\3\2\2\2jk\t\2\2\2k\31\3\2\2\2lm\7\n\2\2m\33\3\2\2\2no\7"+
"\f\2\2o\35\3\2\2\2pq\7\t\2\2q\37\3\2\2\2rs\7\13\2\2s!\3\2\2\2tv\7\b\2"+
"\2uw\7\r\2\2vu\3\2\2\2wx\3\2\2\2xv\3\2\2\2xy\3\2\2\2y\u0081\3\2\2\2z\u0081"+
"\7\b\2\2{}\7\r\2\2|{\3\2\2\2}~\3\2\2\2~|\3\2\2\2~\177\3\2\2\2\177\u0081"+
"\3\2\2\2\u0080t\3\2\2\2\u0080z\3\2\2\2\u0080|\3\2\2\2\u0081#\3\2\2\2\17"+
"\'+\61\66:BKNThx~\u0080";
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