org.graylog.plugins.pipelineprocessor.parser.RuleLangParser Maven / Gradle / Ivy
// Generated from org/graylog/plugins/pipelineprocessor/parser/RuleLang.g4 by ANTLR 4.13.1
package org.graylog.plugins.pipelineprocessor.parser;
import org.graylog.plugins.pipelineprocessor.ast.expressions.Expression;
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", "CheckReturnValue"})
public class RuleLangParser extends Parser {
static { RuntimeMetaData.checkVersion("4.13.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, T__6=7, T__7=8, T__8=9,
T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17,
T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, All=23, Either=24, Pass=25,
And=26, Or=27, Not=28, Pipeline=29, Rule=30, During=31, Stage=32, When=33,
Then=34, End=35, Let=36, Match=37, MessageRef=38, Boolean=39, Integer=40,
Float=41, Char=42, String=43, Identifier=44, WS=45, COMMENT=46, LINE_COMMENT=47;
public static final int
RULE_file = 0, RULE_pipelineDecls = 1, RULE_pipeline = 2, RULE_pipelineDeclaration = 3,
RULE_stageDeclaration = 4, RULE_ruleRef = 5, RULE_ruleDecls = 6, RULE_ruleDeclaration = 7,
RULE_expression = 8, RULE_propAssignment = 9, RULE_statement = 10, RULE_functionCall = 11,
RULE_arguments = 12, RULE_literal = 13;
private static String[] makeRuleNames() {
return new String[] {
"file", "pipelineDecls", "pipeline", "pipelineDeclaration", "stageDeclaration",
"ruleRef", "ruleDecls", "ruleDeclaration", "expression", "propAssignment",
"statement", "functionCall", "arguments", "literal"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "';'", "'('", "')'", "'['", "','", "']'", "'{'", "'}'", "'.'",
"'+'", "'-'", "'*'", "'/'", "'%'", "'<='", "'>='", "'>'", "'<'", "'=='",
"'!='", "':'", "'='", null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, "'$message'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, "All",
"Either", "Pass", "And", "Or", "Not", "Pipeline", "Rule", "During", "Stage",
"When", "Then", "End", "Let", "Match", "MessageRef", "Boolean", "Integer",
"Float", "Char", "String", "Identifier", "WS", "COMMENT", "LINE_COMMENT"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
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 "RuleLang.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public RuleLangParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
@SuppressWarnings("CheckReturnValue")
public static class FileContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(RuleLangParser.EOF, 0); }
public List ruleDeclaration() {
return getRuleContexts(RuleDeclarationContext.class);
}
public RuleDeclarationContext ruleDeclaration(int i) {
return getRuleContext(RuleDeclarationContext.class,i);
}
public List pipelineDeclaration() {
return getRuleContexts(PipelineDeclarationContext.class);
}
public PipelineDeclarationContext pipelineDeclaration(int i) {
return getRuleContext(PipelineDeclarationContext.class,i);
}
public FileContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_file; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterFile(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitFile(this);
}
}
public final FileContext file() throws RecognitionException {
FileContext _localctx = new FileContext(_ctx, getState());
enterRule(_localctx, 0, RULE_file);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(30);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
setState(30);
_errHandler.sync(this);
switch (_input.LA(1)) {
case Rule:
{
setState(28);
ruleDeclaration();
}
break;
case Pipeline:
{
setState(29);
pipelineDeclaration();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(32);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==Pipeline || _la==Rule );
setState(34);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PipelineDeclsContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(RuleLangParser.EOF, 0); }
public List pipelineDeclaration() {
return getRuleContexts(PipelineDeclarationContext.class);
}
public PipelineDeclarationContext pipelineDeclaration(int i) {
return getRuleContext(PipelineDeclarationContext.class,i);
}
public PipelineDeclsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pipelineDecls; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterPipelineDecls(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitPipelineDecls(this);
}
}
public final PipelineDeclsContext pipelineDecls() throws RecognitionException {
PipelineDeclsContext _localctx = new PipelineDeclsContext(_ctx, getState());
enterRule(_localctx, 2, RULE_pipelineDecls);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(37);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(36);
pipelineDeclaration();
}
}
setState(39);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==Pipeline );
setState(41);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PipelineContext extends ParserRuleContext {
public PipelineDeclarationContext pipelineDeclaration() {
return getRuleContext(PipelineDeclarationContext.class,0);
}
public TerminalNode EOF() { return getToken(RuleLangParser.EOF, 0); }
public PipelineContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pipeline; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterPipeline(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitPipeline(this);
}
}
public final PipelineContext pipeline() throws RecognitionException {
PipelineContext _localctx = new PipelineContext(_ctx, getState());
enterRule(_localctx, 4, RULE_pipeline);
try {
enterOuterAlt(_localctx, 1);
{
setState(43);
pipelineDeclaration();
setState(44);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PipelineDeclarationContext extends ParserRuleContext {
public Token name;
public TerminalNode Pipeline() { return getToken(RuleLangParser.Pipeline, 0); }
public TerminalNode End() { return getToken(RuleLangParser.End, 0); }
public TerminalNode String() { return getToken(RuleLangParser.String, 0); }
public List stageDeclaration() {
return getRuleContexts(StageDeclarationContext.class);
}
public StageDeclarationContext stageDeclaration(int i) {
return getRuleContext(StageDeclarationContext.class,i);
}
public PipelineDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pipelineDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterPipelineDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitPipelineDeclaration(this);
}
}
public final PipelineDeclarationContext pipelineDeclaration() throws RecognitionException {
PipelineDeclarationContext _localctx = new PipelineDeclarationContext(_ctx, getState());
enterRule(_localctx, 6, RULE_pipelineDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(46);
match(Pipeline);
setState(47);
((PipelineDeclarationContext)_localctx).name = match(String);
setState(49);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(48);
stageDeclaration();
}
}
setState(51);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==Stage );
setState(53);
match(End);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StageDeclarationContext extends ParserRuleContext {
public Token stage;
public Token modifier;
public TerminalNode Stage() { return getToken(RuleLangParser.Stage, 0); }
public TerminalNode Match() { return getToken(RuleLangParser.Match, 0); }
public TerminalNode Integer() { return getToken(RuleLangParser.Integer, 0); }
public TerminalNode All() { return getToken(RuleLangParser.All, 0); }
public TerminalNode Either() { return getToken(RuleLangParser.Either, 0); }
public TerminalNode Pass() { return getToken(RuleLangParser.Pass, 0); }
public List ruleRef() {
return getRuleContexts(RuleRefContext.class);
}
public RuleRefContext ruleRef(int i) {
return getRuleContext(RuleRefContext.class,i);
}
public StageDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stageDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterStageDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitStageDeclaration(this);
}
}
public final StageDeclarationContext stageDeclaration() throws RecognitionException {
StageDeclarationContext _localctx = new StageDeclarationContext(_ctx, getState());
enterRule(_localctx, 8, RULE_stageDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(55);
match(Stage);
setState(56);
((StageDeclarationContext)_localctx).stage = match(Integer);
setState(57);
match(Match);
setState(58);
((StageDeclarationContext)_localctx).modifier = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 58720256L) != 0)) ) {
((StageDeclarationContext)_localctx).modifier = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(62);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==Rule) {
{
{
setState(59);
ruleRef();
}
}
setState(64);
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class RuleRefContext extends ParserRuleContext {
public Token name;
public TerminalNode Rule() { return getToken(RuleLangParser.Rule, 0); }
public TerminalNode String() { return getToken(RuleLangParser.String, 0); }
public RuleRefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ruleRef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterRuleRef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitRuleRef(this);
}
}
public final RuleRefContext ruleRef() throws RecognitionException {
RuleRefContext _localctx = new RuleRefContext(_ctx, getState());
enterRule(_localctx, 10, RULE_ruleRef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(65);
match(Rule);
setState(66);
((RuleRefContext)_localctx).name = match(String);
setState(68);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__0) {
{
setState(67);
match(T__0);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RuleDeclsContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(RuleLangParser.EOF, 0); }
public List ruleDeclaration() {
return getRuleContexts(RuleDeclarationContext.class);
}
public RuleDeclarationContext ruleDeclaration(int i) {
return getRuleContext(RuleDeclarationContext.class,i);
}
public RuleDeclsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ruleDecls; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterRuleDecls(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitRuleDecls(this);
}
}
public final RuleDeclsContext ruleDecls() throws RecognitionException {
RuleDeclsContext _localctx = new RuleDeclsContext(_ctx, getState());
enterRule(_localctx, 12, RULE_ruleDecls);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(71);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(70);
ruleDeclaration();
}
}
setState(73);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==Rule );
setState(75);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RuleDeclarationContext extends ParserRuleContext {
public Token name;
public ExpressionContext condition;
public StatementContext actions;
public TerminalNode Rule() { return getToken(RuleLangParser.Rule, 0); }
public TerminalNode When() { return getToken(RuleLangParser.When, 0); }
public TerminalNode End() { return getToken(RuleLangParser.End, 0); }
public TerminalNode String() { return getToken(RuleLangParser.String, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode Then() { return getToken(RuleLangParser.Then, 0); }
public List statement() {
return getRuleContexts(StatementContext.class);
}
public StatementContext statement(int i) {
return getRuleContext(StatementContext.class,i);
}
public RuleDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ruleDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterRuleDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitRuleDeclaration(this);
}
}
public final RuleDeclarationContext ruleDeclaration() throws RecognitionException {
RuleDeclarationContext _localctx = new RuleDeclarationContext(_ctx, getState());
enterRule(_localctx, 14, RULE_ruleDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(77);
match(Rule);
setState(78);
((RuleDeclarationContext)_localctx).name = match(String);
setState(79);
match(When);
setState(80);
((RuleDeclarationContext)_localctx).condition = expression(0);
setState(88);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Then) {
{
setState(81);
match(Then);
setState(85);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 17660905521154L) != 0)) {
{
{
setState(82);
((RuleDeclarationContext)_localctx).actions = statement();
}
}
setState(87);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(90);
match(End);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExpressionContext extends ParserRuleContext {
public ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
public ExpressionContext() { }
public void copyFrom(ExpressionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class MultiplicationContext extends ExpressionContext {
public ExpressionContext left;
public Token mult;
public ExpressionContext right;
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public MultiplicationContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterMultiplication(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitMultiplication(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AdditionContext extends ExpressionContext {
public ExpressionContext left;
public Token add;
public ExpressionContext right;
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public AdditionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterAddition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitAddition(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class OrContext extends ExpressionContext {
public ExpressionContext left;
public Token or;
public ExpressionContext right;
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode Or() { return getToken(RuleLangParser.Or, 0); }
public OrContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterOr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitOr(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class FuncContext extends ExpressionContext {
public FunctionCallContext functionCall() {
return getRuleContext(FunctionCallContext.class,0);
}
public FuncContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterFunc(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitFunc(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class MessageRefContext extends ExpressionContext {
public ExpressionContext field;
public TerminalNode MessageRef() { return getToken(RuleLangParser.MessageRef, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public MessageRefContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterMessageRef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitMessageRef(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NestedContext extends ExpressionContext {
public ExpressionContext fieldSet;
public ExpressionContext field;
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public NestedContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterNested(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitNested(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NotContext extends ExpressionContext {
public TerminalNode Not() { return getToken(RuleLangParser.Not, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public NotContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterNot(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitNot(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class IndexedAccessContext extends ExpressionContext {
public ExpressionContext array;
public ExpressionContext index;
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public IndexedAccessContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterIndexedAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitIndexedAccess(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class IdentifierContext extends ExpressionContext {
public TerminalNode Identifier() { return getToken(RuleLangParser.Identifier, 0); }
public IdentifierContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitIdentifier(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ComparisonContext extends ExpressionContext {
public ExpressionContext left;
public Token comparison;
public ExpressionContext right;
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public ComparisonContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterComparison(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitComparison(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class LiteralPrimaryContext extends ExpressionContext {
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public LiteralPrimaryContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterLiteralPrimary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitLiteralPrimary(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AndContext extends ExpressionContext {
public ExpressionContext left;
public Token and;
public ExpressionContext right;
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode And() { return getToken(RuleLangParser.And, 0); }
public AndContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterAnd(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitAnd(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ArrayLiteralExprContext extends ExpressionContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public ArrayLiteralExprContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterArrayLiteralExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitArrayLiteralExpr(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class MapLiteralExprContext extends ExpressionContext {
public List propAssignment() {
return getRuleContexts(PropAssignmentContext.class);
}
public PropAssignmentContext propAssignment(int i) {
return getRuleContext(PropAssignmentContext.class,i);
}
public MapLiteralExprContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterMapLiteralExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitMapLiteralExpr(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class EqualityContext extends ExpressionContext {
public ExpressionContext left;
public Token equality;
public ExpressionContext right;
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public EqualityContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterEquality(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitEquality(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ParenExprContext extends ExpressionContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ParenExprContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterParenExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitParenExpr(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SignedExpressionContext extends ExpressionContext {
public Token sign;
public ExpressionContext expr;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public SignedExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterSignedExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitSignedExpression(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
return expression(0);
}
private ExpressionContext expression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
ExpressionContext _prevctx = _localctx;
int _startState = 16;
enterRecursionRule(_localctx, 16, RULE_expression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(138);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
case 1:
{
_localctx = new ParenExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(93);
match(T__1);
setState(94);
expression(0);
setState(95);
match(T__2);
}
break;
case 2:
{
_localctx = new LiteralPrimaryContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(97);
literal();
}
break;
case 3:
{
_localctx = new FuncContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(98);
functionCall();
}
break;
case 4:
{
_localctx = new IdentifierContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(99);
match(Identifier);
}
break;
case 5:
{
_localctx = new ArrayLiteralExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(100);
match(T__3);
setState(111);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 34909762620564L) != 0)) {
{
{
setState(101);
expression(0);
setState(106);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__4) {
{
{
setState(102);
match(T__4);
setState(103);
expression(0);
}
}
setState(108);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(113);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(114);
match(T__5);
}
break;
case 6:
{
_localctx = new MapLiteralExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(115);
match(T__6);
setState(126);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==Identifier) {
{
{
setState(116);
propAssignment();
setState(121);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__4) {
{
{
setState(117);
match(T__4);
setState(118);
propAssignment();
}
}
setState(123);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(128);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(129);
match(T__7);
}
break;
case 7:
{
_localctx = new MessageRefContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(130);
match(MessageRef);
setState(131);
match(T__8);
setState(132);
((MessageRefContext)_localctx).field = expression(12);
}
break;
case 8:
{
_localctx = new MessageRefContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(133);
match(MessageRef);
}
break;
case 9:
{
_localctx = new SignedExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(134);
((SignedExpressionContext)_localctx).sign = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==T__9 || _la==T__10) ) {
((SignedExpressionContext)_localctx).sign = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(135);
((SignedExpressionContext)_localctx).expr = expression(8);
}
break;
case 10:
{
_localctx = new NotContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(136);
match(Not);
setState(137);
expression(7);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(168);
_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;
{
setState(166);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
case 1:
{
_localctx = new NestedContext(new ExpressionContext(_parentctx, _parentState));
((NestedContext)_localctx).fieldSet = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(140);
if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)");
setState(141);
match(T__8);
setState(142);
((NestedContext)_localctx).field = expression(11);
}
break;
case 2:
{
_localctx = new MultiplicationContext(new ExpressionContext(_parentctx, _parentState));
((MultiplicationContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(143);
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
setState(144);
((MultiplicationContext)_localctx).mult = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 28672L) != 0)) ) {
((MultiplicationContext)_localctx).mult = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(145);
((MultiplicationContext)_localctx).right = expression(7);
}
break;
case 3:
{
_localctx = new AdditionContext(new ExpressionContext(_parentctx, _parentState));
((AdditionContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(146);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(147);
((AdditionContext)_localctx).add = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==T__9 || _la==T__10) ) {
((AdditionContext)_localctx).add = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(148);
((AdditionContext)_localctx).right = expression(6);
}
break;
case 4:
{
_localctx = new ComparisonContext(new ExpressionContext(_parentctx, _parentState));
((ComparisonContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(149);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(150);
((ComparisonContext)_localctx).comparison = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 491520L) != 0)) ) {
((ComparisonContext)_localctx).comparison = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(151);
((ComparisonContext)_localctx).right = expression(5);
}
break;
case 5:
{
_localctx = new EqualityContext(new ExpressionContext(_parentctx, _parentState));
((EqualityContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(152);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(153);
((EqualityContext)_localctx).equality = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==T__18 || _la==T__19) ) {
((EqualityContext)_localctx).equality = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(154);
((EqualityContext)_localctx).right = expression(4);
}
break;
case 6:
{
_localctx = new AndContext(new ExpressionContext(_parentctx, _parentState));
((AndContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(155);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(156);
((AndContext)_localctx).and = match(And);
setState(157);
((AndContext)_localctx).right = expression(3);
}
break;
case 7:
{
_localctx = new OrContext(new ExpressionContext(_parentctx, _parentState));
((OrContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(158);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(159);
((OrContext)_localctx).or = match(Or);
setState(160);
((OrContext)_localctx).right = expression(2);
}
break;
case 8:
{
_localctx = new IndexedAccessContext(new ExpressionContext(_parentctx, _parentState));
((IndexedAccessContext)_localctx).array = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(161);
if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
setState(162);
match(T__3);
setState(163);
((IndexedAccessContext)_localctx).index = expression(0);
setState(164);
match(T__5);
}
break;
}
}
}
setState(170);
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class PropAssignmentContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(RuleLangParser.Identifier, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public PropAssignmentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propAssignment; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterPropAssignment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitPropAssignment(this);
}
}
public final PropAssignmentContext propAssignment() throws RecognitionException {
PropAssignmentContext _localctx = new PropAssignmentContext(_ctx, getState());
enterRule(_localctx, 18, RULE_propAssignment);
try {
enterOuterAlt(_localctx, 1);
{
setState(171);
match(Identifier);
setState(172);
match(T__20);
setState(173);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StatementContext extends ParserRuleContext {
public StatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statement; }
public StatementContext() { }
public void copyFrom(StatementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class VarAssignStmtContext extends StatementContext {
public Token varName;
public TerminalNode Let() { return getToken(RuleLangParser.Let, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode Identifier() { return getToken(RuleLangParser.Identifier, 0); }
public VarAssignStmtContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterVarAssignStmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitVarAssignStmt(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class FuncStmtContext extends StatementContext {
public FunctionCallContext functionCall() {
return getRuleContext(FunctionCallContext.class,0);
}
public FuncStmtContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterFuncStmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitFuncStmt(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class EmptyStmtContext extends StatementContext {
public EmptyStmtContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterEmptyStmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitEmptyStmt(this);
}
}
public final StatementContext statement() throws RecognitionException {
StatementContext _localctx = new StatementContext(_ctx, getState());
enterRule(_localctx, 20, RULE_statement);
try {
setState(185);
_errHandler.sync(this);
switch (_input.LA(1)) {
case Identifier:
_localctx = new FuncStmtContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(175);
functionCall();
setState(176);
match(T__0);
}
break;
case Let:
_localctx = new VarAssignStmtContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(178);
match(Let);
setState(179);
((VarAssignStmtContext)_localctx).varName = match(Identifier);
setState(180);
match(T__21);
setState(181);
expression(0);
setState(182);
match(T__0);
}
break;
case T__0:
_localctx = new EmptyStmtContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(184);
match(T__0);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionCallContext extends ParserRuleContext {
public Token funcName;
public TerminalNode Identifier() { return getToken(RuleLangParser.Identifier, 0); }
public ArgumentsContext arguments() {
return getRuleContext(ArgumentsContext.class,0);
}
public FunctionCallContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionCall; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterFunctionCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitFunctionCall(this);
}
}
public final FunctionCallContext functionCall() throws RecognitionException {
FunctionCallContext _localctx = new FunctionCallContext(_ctx, getState());
enterRule(_localctx, 22, RULE_functionCall);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(187);
((FunctionCallContext)_localctx).funcName = match(Identifier);
setState(188);
match(T__1);
setState(190);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 34909762620564L) != 0)) {
{
setState(189);
arguments();
}
}
setState(192);
match(T__2);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ArgumentsContext extends ParserRuleContext {
public ArgumentsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arguments; }
public ArgumentsContext() { }
public void copyFrom(ArgumentsContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PositionalArgsContext extends ArgumentsContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public PositionalArgsContext(ArgumentsContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterPositionalArgs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitPositionalArgs(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NamedArgsContext extends ArgumentsContext {
public List propAssignment() {
return getRuleContexts(PropAssignmentContext.class);
}
public PropAssignmentContext propAssignment(int i) {
return getRuleContext(PropAssignmentContext.class,i);
}
public NamedArgsContext(ArgumentsContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterNamedArgs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitNamedArgs(this);
}
}
public final ArgumentsContext arguments() throws RecognitionException {
ArgumentsContext _localctx = new ArgumentsContext(_ctx, getState());
enterRule(_localctx, 24, RULE_arguments);
int _la;
try {
setState(210);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
case 1:
_localctx = new NamedArgsContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(194);
propAssignment();
setState(199);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__4) {
{
{
setState(195);
match(T__4);
setState(196);
propAssignment();
}
}
setState(201);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 2:
_localctx = new PositionalArgsContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(202);
expression(0);
setState(207);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__4) {
{
{
setState(203);
match(T__4);
setState(204);
expression(0);
}
}
setState(209);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LiteralContext extends ParserRuleContext {
public LiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literal; }
public LiteralContext() { }
public void copyFrom(LiteralContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class IntegerContext extends LiteralContext {
public TerminalNode Integer() { return getToken(RuleLangParser.Integer, 0); }
public IntegerContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterInteger(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitInteger(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class FloatContext extends LiteralContext {
public TerminalNode Float() { return getToken(RuleLangParser.Float, 0); }
public FloatContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterFloat(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitFloat(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CharContext extends LiteralContext {
public TerminalNode Char() { return getToken(RuleLangParser.Char, 0); }
public CharContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterChar(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitChar(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class StringContext extends LiteralContext {
public TerminalNode String() { return getToken(RuleLangParser.String, 0); }
public StringContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterString(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitString(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BooleanContext extends LiteralContext {
public TerminalNode Boolean() { return getToken(RuleLangParser.Boolean, 0); }
public BooleanContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).enterBoolean(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RuleLangListener ) ((RuleLangListener)listener).exitBoolean(this);
}
}
public final LiteralContext literal() throws RecognitionException {
LiteralContext _localctx = new LiteralContext(_ctx, getState());
enterRule(_localctx, 26, RULE_literal);
try {
setState(217);
_errHandler.sync(this);
switch (_input.LA(1)) {
case Integer:
_localctx = new IntegerContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(212);
match(Integer);
}
break;
case Float:
_localctx = new FloatContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(213);
match(Float);
}
break;
case Char:
_localctx = new CharContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(214);
match(Char);
}
break;
case String:
_localctx = new StringContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(215);
match(String);
}
break;
case Boolean:
_localctx = new BooleanContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(216);
match(Boolean);
}
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 boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 8:
return expression_sempred((ExpressionContext)_localctx, predIndex);
}
return true;
}
private boolean expression_sempred(ExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 10);
case 1:
return precpred(_ctx, 6);
case 2:
return precpred(_ctx, 5);
case 3:
return precpred(_ctx, 4);
case 4:
return precpred(_ctx, 3);
case 5:
return precpred(_ctx, 2);
case 6:
return precpred(_ctx, 1);
case 7:
return precpred(_ctx, 9);
}
return true;
}
public static final String _serializedATN =
"\u0004\u0001/\u00dc\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002"+
"\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002"+
"\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002"+
"\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b\u0002"+
"\f\u0007\f\u0002\r\u0007\r\u0001\u0000\u0001\u0000\u0004\u0000\u001f\b"+
"\u0000\u000b\u0000\f\u0000 \u0001\u0000\u0001\u0000\u0001\u0001\u0004"+
"\u0001&\b\u0001\u000b\u0001\f\u0001\'\u0001\u0001\u0001\u0001\u0001\u0002"+
"\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001\u0003\u0004\u0003"+
"2\b\u0003\u000b\u0003\f\u00033\u0001\u0003\u0001\u0003\u0001\u0004\u0001"+
"\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0005\u0004=\b\u0004\n\u0004"+
"\f\u0004@\t\u0004\u0001\u0005\u0001\u0005\u0001\u0005\u0003\u0005E\b\u0005"+
"\u0001\u0006\u0004\u0006H\b\u0006\u000b\u0006\f\u0006I\u0001\u0006\u0001"+
"\u0006\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001"+
"\u0007\u0005\u0007T\b\u0007\n\u0007\f\u0007W\t\u0007\u0003\u0007Y\b\u0007"+
"\u0001\u0007\u0001\u0007\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+
"\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0005\bi\b\b\n\b\f"+
"\bl\t\b\u0005\bn\b\b\n\b\f\bq\t\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+
"\b\u0005\bx\b\b\n\b\f\b{\t\b\u0005\b}\b\b\n\b\f\b\u0080\t\b\u0001\b\u0001"+
"\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0003\b\u008b"+
"\b\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+
"\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+
"\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0005"+
"\b\u00a7\b\b\n\b\f\b\u00aa\t\b\u0001\t\u0001\t\u0001\t\u0001\t\u0001\n"+
"\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001"+
"\n\u0003\n\u00ba\b\n\u0001\u000b\u0001\u000b\u0001\u000b\u0003\u000b\u00bf"+
"\b\u000b\u0001\u000b\u0001\u000b\u0001\f\u0001\f\u0001\f\u0005\f\u00c6"+
"\b\f\n\f\f\f\u00c9\t\f\u0001\f\u0001\f\u0001\f\u0005\f\u00ce\b\f\n\f\f"+
"\f\u00d1\t\f\u0003\f\u00d3\b\f\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r"+
"\u0003\r\u00da\b\r\u0001\r\u0000\u0001\u0010\u000e\u0000\u0002\u0004\u0006"+
"\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a\u0000\u0005\u0001\u0000"+
"\u0017\u0019\u0001\u0000\n\u000b\u0001\u0000\f\u000e\u0001\u0000\u000f"+
"\u0012\u0001\u0000\u0013\u0014\u00f5\u0000\u001e\u0001\u0000\u0000\u0000"+
"\u0002%\u0001\u0000\u0000\u0000\u0004+\u0001\u0000\u0000\u0000\u0006."+
"\u0001\u0000\u0000\u0000\b7\u0001\u0000\u0000\u0000\nA\u0001\u0000\u0000"+
"\u0000\fG\u0001\u0000\u0000\u0000\u000eM\u0001\u0000\u0000\u0000\u0010"+
"\u008a\u0001\u0000\u0000\u0000\u0012\u00ab\u0001\u0000\u0000\u0000\u0014"+
"\u00b9\u0001\u0000\u0000\u0000\u0016\u00bb\u0001\u0000\u0000\u0000\u0018"+
"\u00d2\u0001\u0000\u0000\u0000\u001a\u00d9\u0001\u0000\u0000\u0000\u001c"+
"\u001f\u0003\u000e\u0007\u0000\u001d\u001f\u0003\u0006\u0003\u0000\u001e"+
"\u001c\u0001\u0000\u0000\u0000\u001e\u001d\u0001\u0000\u0000\u0000\u001f"+
" \u0001\u0000\u0000\u0000 \u001e\u0001\u0000\u0000\u0000 !\u0001\u0000"+
"\u0000\u0000!\"\u0001\u0000\u0000\u0000\"#\u0005\u0000\u0000\u0001#\u0001"+
"\u0001\u0000\u0000\u0000$&\u0003\u0006\u0003\u0000%$\u0001\u0000\u0000"+
"\u0000&\'\u0001\u0000\u0000\u0000\'%\u0001\u0000\u0000\u0000\'(\u0001"+
"\u0000\u0000\u0000()\u0001\u0000\u0000\u0000)*\u0005\u0000\u0000\u0001"+
"*\u0003\u0001\u0000\u0000\u0000+,\u0003\u0006\u0003\u0000,-\u0005\u0000"+
"\u0000\u0001-\u0005\u0001\u0000\u0000\u0000./\u0005\u001d\u0000\u0000"+
"/1\u0005+\u0000\u000002\u0003\b\u0004\u000010\u0001\u0000\u0000\u0000"+
"23\u0001\u0000\u0000\u000031\u0001\u0000\u0000\u000034\u0001\u0000\u0000"+
"\u000045\u0001\u0000\u0000\u000056\u0005#\u0000\u00006\u0007\u0001\u0000"+
"\u0000\u000078\u0005 \u0000\u000089\u0005(\u0000\u00009:\u0005%\u0000"+
"\u0000:>\u0007\u0000\u0000\u0000;=\u0003\n\u0005\u0000<;\u0001\u0000\u0000"+
"\u0000=@\u0001\u0000\u0000\u0000><\u0001\u0000\u0000\u0000>?\u0001\u0000"+
"\u0000\u0000?\t\u0001\u0000\u0000\u0000@>\u0001\u0000\u0000\u0000AB\u0005"+
"\u001e\u0000\u0000BD\u0005+\u0000\u0000CE\u0005\u0001\u0000\u0000DC\u0001"+
"\u0000\u0000\u0000DE\u0001\u0000\u0000\u0000E\u000b\u0001\u0000\u0000"+
"\u0000FH\u0003\u000e\u0007\u0000GF\u0001\u0000\u0000\u0000HI\u0001\u0000"+
"\u0000\u0000IG\u0001\u0000\u0000\u0000IJ\u0001\u0000\u0000\u0000JK\u0001"+
"\u0000\u0000\u0000KL\u0005\u0000\u0000\u0001L\r\u0001\u0000\u0000\u0000"+
"MN\u0005\u001e\u0000\u0000NO\u0005+\u0000\u0000OP\u0005!\u0000\u0000P"+
"X\u0003\u0010\b\u0000QU\u0005\"\u0000\u0000RT\u0003\u0014\n\u0000SR\u0001"+
"\u0000\u0000\u0000TW\u0001\u0000\u0000\u0000US\u0001\u0000\u0000\u0000"+
"UV\u0001\u0000\u0000\u0000VY\u0001\u0000\u0000\u0000WU\u0001\u0000\u0000"+
"\u0000XQ\u0001\u0000\u0000\u0000XY\u0001\u0000\u0000\u0000YZ\u0001\u0000"+
"\u0000\u0000Z[\u0005#\u0000\u0000[\u000f\u0001\u0000\u0000\u0000\\]\u0006"+
"\b\uffff\uffff\u0000]^\u0005\u0002\u0000\u0000^_\u0003\u0010\b\u0000_"+
"`\u0005\u0003\u0000\u0000`\u008b\u0001\u0000\u0000\u0000a\u008b\u0003"+
"\u001a\r\u0000b\u008b\u0003\u0016\u000b\u0000c\u008b\u0005,\u0000\u0000"+
"do\u0005\u0004\u0000\u0000ej\u0003\u0010\b\u0000fg\u0005\u0005\u0000\u0000"+
"gi\u0003\u0010\b\u0000hf\u0001\u0000\u0000\u0000il\u0001\u0000\u0000\u0000"+
"jh\u0001\u0000\u0000\u0000jk\u0001\u0000\u0000\u0000kn\u0001\u0000\u0000"+
"\u0000lj\u0001\u0000\u0000\u0000me\u0001\u0000\u0000\u0000nq\u0001\u0000"+
"\u0000\u0000om\u0001\u0000\u0000\u0000op\u0001\u0000\u0000\u0000pr\u0001"+
"\u0000\u0000\u0000qo\u0001\u0000\u0000\u0000r\u008b\u0005\u0006\u0000"+
"\u0000s~\u0005\u0007\u0000\u0000ty\u0003\u0012\t\u0000uv\u0005\u0005\u0000"+
"\u0000vx\u0003\u0012\t\u0000wu\u0001\u0000\u0000\u0000x{\u0001\u0000\u0000"+
"\u0000yw\u0001\u0000\u0000\u0000yz\u0001\u0000\u0000\u0000z}\u0001\u0000"+
"\u0000\u0000{y\u0001\u0000\u0000\u0000|t\u0001\u0000\u0000\u0000}\u0080"+
"\u0001\u0000\u0000\u0000~|\u0001\u0000\u0000\u0000~\u007f\u0001\u0000"+
"\u0000\u0000\u007f\u0081\u0001\u0000\u0000\u0000\u0080~\u0001\u0000\u0000"+
"\u0000\u0081\u008b\u0005\b\u0000\u0000\u0082\u0083\u0005&\u0000\u0000"+
"\u0083\u0084\u0005\t\u0000\u0000\u0084\u008b\u0003\u0010\b\f\u0085\u008b"+
"\u0005&\u0000\u0000\u0086\u0087\u0007\u0001\u0000\u0000\u0087\u008b\u0003"+
"\u0010\b\b\u0088\u0089\u0005\u001c\u0000\u0000\u0089\u008b\u0003\u0010"+
"\b\u0007\u008a\\\u0001\u0000\u0000\u0000\u008aa\u0001\u0000\u0000\u0000"+
"\u008ab\u0001\u0000\u0000\u0000\u008ac\u0001\u0000\u0000\u0000\u008ad"+
"\u0001\u0000\u0000\u0000\u008as\u0001\u0000\u0000\u0000\u008a\u0082\u0001"+
"\u0000\u0000\u0000\u008a\u0085\u0001\u0000\u0000\u0000\u008a\u0086\u0001"+
"\u0000\u0000\u0000\u008a\u0088\u0001\u0000\u0000\u0000\u008b\u00a8\u0001"+
"\u0000\u0000\u0000\u008c\u008d\n\n\u0000\u0000\u008d\u008e\u0005\t\u0000"+
"\u0000\u008e\u00a7\u0003\u0010\b\u000b\u008f\u0090\n\u0006\u0000\u0000"+
"\u0090\u0091\u0007\u0002\u0000\u0000\u0091\u00a7\u0003\u0010\b\u0007\u0092"+
"\u0093\n\u0005\u0000\u0000\u0093\u0094\u0007\u0001\u0000\u0000\u0094\u00a7"+
"\u0003\u0010\b\u0006\u0095\u0096\n\u0004\u0000\u0000\u0096\u0097\u0007"+
"\u0003\u0000\u0000\u0097\u00a7\u0003\u0010\b\u0005\u0098\u0099\n\u0003"+
"\u0000\u0000\u0099\u009a\u0007\u0004\u0000\u0000\u009a\u00a7\u0003\u0010"+
"\b\u0004\u009b\u009c\n\u0002\u0000\u0000\u009c\u009d\u0005\u001a\u0000"+
"\u0000\u009d\u00a7\u0003\u0010\b\u0003\u009e\u009f\n\u0001\u0000\u0000"+
"\u009f\u00a0\u0005\u001b\u0000\u0000\u00a0\u00a7\u0003\u0010\b\u0002\u00a1"+
"\u00a2\n\t\u0000\u0000\u00a2\u00a3\u0005\u0004\u0000\u0000\u00a3\u00a4"+
"\u0003\u0010\b\u0000\u00a4\u00a5\u0005\u0006\u0000\u0000\u00a5\u00a7\u0001"+
"\u0000\u0000\u0000\u00a6\u008c\u0001\u0000\u0000\u0000\u00a6\u008f\u0001"+
"\u0000\u0000\u0000\u00a6\u0092\u0001\u0000\u0000\u0000\u00a6\u0095\u0001"+
"\u0000\u0000\u0000\u00a6\u0098\u0001\u0000\u0000\u0000\u00a6\u009b\u0001"+
"\u0000\u0000\u0000\u00a6\u009e\u0001\u0000\u0000\u0000\u00a6\u00a1\u0001"+
"\u0000\u0000\u0000\u00a7\u00aa\u0001\u0000\u0000\u0000\u00a8\u00a6\u0001"+
"\u0000\u0000\u0000\u00a8\u00a9\u0001\u0000\u0000\u0000\u00a9\u0011\u0001"+
"\u0000\u0000\u0000\u00aa\u00a8\u0001\u0000\u0000\u0000\u00ab\u00ac\u0005"+
",\u0000\u0000\u00ac\u00ad\u0005\u0015\u0000\u0000\u00ad\u00ae\u0003\u0010"+
"\b\u0000\u00ae\u0013\u0001\u0000\u0000\u0000\u00af\u00b0\u0003\u0016\u000b"+
"\u0000\u00b0\u00b1\u0005\u0001\u0000\u0000\u00b1\u00ba\u0001\u0000\u0000"+
"\u0000\u00b2\u00b3\u0005$\u0000\u0000\u00b3\u00b4\u0005,\u0000\u0000\u00b4"+
"\u00b5\u0005\u0016\u0000\u0000\u00b5\u00b6\u0003\u0010\b\u0000\u00b6\u00b7"+
"\u0005\u0001\u0000\u0000\u00b7\u00ba\u0001\u0000\u0000\u0000\u00b8\u00ba"+
"\u0005\u0001\u0000\u0000\u00b9\u00af\u0001\u0000\u0000\u0000\u00b9\u00b2"+
"\u0001\u0000\u0000\u0000\u00b9\u00b8\u0001\u0000\u0000\u0000\u00ba\u0015"+
"\u0001\u0000\u0000\u0000\u00bb\u00bc\u0005,\u0000\u0000\u00bc\u00be\u0005"+
"\u0002\u0000\u0000\u00bd\u00bf\u0003\u0018\f\u0000\u00be\u00bd\u0001\u0000"+
"\u0000\u0000\u00be\u00bf\u0001\u0000\u0000\u0000\u00bf\u00c0\u0001\u0000"+
"\u0000\u0000\u00c0\u00c1\u0005\u0003\u0000\u0000\u00c1\u0017\u0001\u0000"+
"\u0000\u0000\u00c2\u00c7\u0003\u0012\t\u0000\u00c3\u00c4\u0005\u0005\u0000"+
"\u0000\u00c4\u00c6\u0003\u0012\t\u0000\u00c5\u00c3\u0001\u0000\u0000\u0000"+
"\u00c6\u00c9\u0001\u0000\u0000\u0000\u00c7\u00c5\u0001\u0000\u0000\u0000"+
"\u00c7\u00c8\u0001\u0000\u0000\u0000\u00c8\u00d3\u0001\u0000\u0000\u0000"+
"\u00c9\u00c7\u0001\u0000\u0000\u0000\u00ca\u00cf\u0003\u0010\b\u0000\u00cb"+
"\u00cc\u0005\u0005\u0000\u0000\u00cc\u00ce\u0003\u0010\b\u0000\u00cd\u00cb"+
"\u0001\u0000\u0000\u0000\u00ce\u00d1\u0001\u0000\u0000\u0000\u00cf\u00cd"+
"\u0001\u0000\u0000\u0000\u00cf\u00d0\u0001\u0000\u0000\u0000\u00d0\u00d3"+
"\u0001\u0000\u0000\u0000\u00d1\u00cf\u0001\u0000\u0000\u0000\u00d2\u00c2"+
"\u0001\u0000\u0000\u0000\u00d2\u00ca\u0001\u0000\u0000\u0000\u00d3\u0019"+
"\u0001\u0000\u0000\u0000\u00d4\u00da\u0005(\u0000\u0000\u00d5\u00da\u0005"+
")\u0000\u0000\u00d6\u00da\u0005*\u0000\u0000\u00d7\u00da\u0005+\u0000"+
"\u0000\u00d8\u00da\u0005\'\u0000\u0000\u00d9\u00d4\u0001\u0000\u0000\u0000"+
"\u00d9\u00d5\u0001\u0000\u0000\u0000\u00d9\u00d6\u0001\u0000\u0000\u0000"+
"\u00d9\u00d7\u0001\u0000\u0000\u0000\u00d9\u00d8\u0001\u0000\u0000\u0000"+
"\u00da\u001b\u0001\u0000\u0000\u0000\u0016\u001e \'3>DIUXjoy~\u008a\u00a6"+
"\u00a8\u00b9\u00be\u00c7\u00cf\u00d2\u00d9";
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 - 2024 Weber Informatics LLC | Privacy Policy