com.signalfx.signalflow.grammar.SignalFlowV2Parser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of signalflow-grammar Show documentation
Show all versions of signalflow-grammar Show documentation
SignalFx SignalFlow language grammar
// Generated from grammar/SignalFlowV2Parser.g4 by ANTLR 4.5.2
package com.signalfx.signalflow.grammar;
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 SignalFlowV2Parser extends Parser {
static { RuntimeMetaData.checkVersion("4.5.2", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
DEF=1, RETURN=2, FROM=3, IMPORT=4, AS=5, LAMBDA=6, NONE=7, TRUE=8, FALSE=9,
IF=10, ELSE=11, INT=12, FLOAT=13, STRING=14, LE=15, GE=16, EQ=17, NE=18,
LT=19, GT=20, OR=21, AND=22, NOT=23, IS=24, ID=25, OPEN_PAREN=26, CLOSE_PAREN=27,
LSQUARE=28, RSQUARE=29, LBRACE=30, RBRACE=31, COMMA=32, SEMICOLON=33,
COLON=34, PLUS=35, MINUS=36, MUL=37, DIV=38, POW=39, BINDING=40, DOT=41,
NEWLINE=42, SKIP_=43, COMMENT=44, INDENT=45, DEDENT=46;
public static final int
RULE_program = 0, RULE_eval_input = 1, RULE_function_definition = 2, RULE_parameters = 3,
RULE_var_args_list = 4, RULE_var_args_list_param_def = 5, RULE_var_args_list_param_name = 6,
RULE_statement = 7, RULE_simple_statement = 8, RULE_small_statement = 9,
RULE_expr_statement = 10, RULE_id_list = 11, RULE_import_statement = 12,
RULE_import_name = 13, RULE_import_from = 14, RULE_import_as_name = 15,
RULE_dotted_as_name = 16, RULE_import_as_names = 17, RULE_dotted_as_names = 18,
RULE_dotted_name = 19, RULE_return_statement = 20, RULE_flow_statement = 21,
RULE_compound_statement = 22, RULE_suite = 23, RULE_test = 24, RULE_lambdef = 25,
RULE_or_test = 26, RULE_and_test = 27, RULE_not_test = 28, RULE_comparison = 29,
RULE_expr = 30, RULE_term = 31, RULE_factor = 32, RULE_power = 33, RULE_atom_expr = 34,
RULE_atom = 35, RULE_list_expr = 36, RULE_tuple_expr = 37, RULE_testlist = 38,
RULE_trailer = 39, RULE_actual_args = 40, RULE_argument = 41;
public static final String[] ruleNames = {
"program", "eval_input", "function_definition", "parameters", "var_args_list",
"var_args_list_param_def", "var_args_list_param_name", "statement", "simple_statement",
"small_statement", "expr_statement", "id_list", "import_statement", "import_name",
"import_from", "import_as_name", "dotted_as_name", "import_as_names",
"dotted_as_names", "dotted_name", "return_statement", "flow_statement",
"compound_statement", "suite", "test", "lambdef", "or_test", "and_test",
"not_test", "comparison", "expr", "term", "factor", "power", "atom_expr",
"atom", "list_expr", "tuple_expr", "testlist", "trailer", "actual_args",
"argument"
};
private static final String[] _LITERAL_NAMES = {
null, "'def'", "'return'", "'from'", "'import'", "'as'", "'lambda'", "'None'",
"'True'", "'False'", "'if'", "'else'", null, null, null, "'<='", "'>='",
"'=='", "'!='", "'<'", "'>'", "'or'", "'and'", "'not'", "'is'", null,
"'('", "')'", "'['", "']'", "'{'", "'}'", "','", "';'", "':'", "'+'",
"'-'", "'*'", "'/'", "'**'", "'='", "'.'"
};
private static final String[] _SYMBOLIC_NAMES = {
null, "DEF", "RETURN", "FROM", "IMPORT", "AS", "LAMBDA", "NONE", "TRUE",
"FALSE", "IF", "ELSE", "INT", "FLOAT", "STRING", "LE", "GE", "EQ", "NE",
"LT", "GT", "OR", "AND", "NOT", "IS", "ID", "OPEN_PAREN", "CLOSE_PAREN",
"LSQUARE", "RSQUARE", "LBRACE", "RBRACE", "COMMA", "SEMICOLON", "COLON",
"PLUS", "MINUS", "MUL", "DIV", "POW", "BINDING", "DOT", "NEWLINE", "SKIP_",
"COMMENT", "INDENT", "DEDENT"
};
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 "SignalFlowV2Parser.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public SignalFlowV2Parser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class ProgramContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(SignalFlowV2Parser.EOF, 0); }
public List NEWLINE() { return getTokens(SignalFlowV2Parser.NEWLINE); }
public TerminalNode NEWLINE(int i) {
return getToken(SignalFlowV2Parser.NEWLINE, i);
}
public List statement() {
return getRuleContexts(StatementContext.class);
}
public StatementContext statement(int i) {
return getRuleContext(StatementContext.class,i);
}
public ProgramContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_program; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterProgram(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitProgram(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitProgram(this);
else return visitor.visitChildren(this);
}
}
public final ProgramContext program() throws RecognitionException {
ProgramContext _localctx = new ProgramContext(_ctx, getState());
enterRule(_localctx, 0, RULE_program);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(88);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << DEF) | (1L << RETURN) | (1L << FROM) | (1L << IMPORT) | (1L << LAMBDA) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << INT) | (1L << FLOAT) | (1L << STRING) | (1L << NOT) | (1L << ID) | (1L << OPEN_PAREN) | (1L << LSQUARE) | (1L << PLUS) | (1L << MINUS) | (1L << NEWLINE))) != 0)) {
{
setState(86);
switch (_input.LA(1)) {
case NEWLINE:
{
setState(84);
match(NEWLINE);
}
break;
case DEF:
case RETURN:
case FROM:
case IMPORT:
case LAMBDA:
case NONE:
case TRUE:
case FALSE:
case INT:
case FLOAT:
case STRING:
case NOT:
case ID:
case OPEN_PAREN:
case LSQUARE:
case PLUS:
case MINUS:
{
setState(85);
statement();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(90);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(91);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Eval_inputContext extends ParserRuleContext {
public TestlistContext testlist() {
return getRuleContext(TestlistContext.class,0);
}
public TerminalNode EOF() { return getToken(SignalFlowV2Parser.EOF, 0); }
public List NEWLINE() { return getTokens(SignalFlowV2Parser.NEWLINE); }
public TerminalNode NEWLINE(int i) {
return getToken(SignalFlowV2Parser.NEWLINE, i);
}
public Eval_inputContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_eval_input; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterEval_input(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitEval_input(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitEval_input(this);
else return visitor.visitChildren(this);
}
}
public final Eval_inputContext eval_input() throws RecognitionException {
Eval_inputContext _localctx = new Eval_inputContext(_ctx, getState());
enterRule(_localctx, 2, RULE_eval_input);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(93);
testlist();
setState(97);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NEWLINE) {
{
{
setState(94);
match(NEWLINE);
}
}
setState(99);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(100);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Function_definitionContext extends ParserRuleContext {
public TerminalNode DEF() { return getToken(SignalFlowV2Parser.DEF, 0); }
public TerminalNode ID() { return getToken(SignalFlowV2Parser.ID, 0); }
public ParametersContext parameters() {
return getRuleContext(ParametersContext.class,0);
}
public SuiteContext suite() {
return getRuleContext(SuiteContext.class,0);
}
public Function_definitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_function_definition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterFunction_definition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitFunction_definition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitFunction_definition(this);
else return visitor.visitChildren(this);
}
}
public final Function_definitionContext function_definition() throws RecognitionException {
Function_definitionContext _localctx = new Function_definitionContext(_ctx, getState());
enterRule(_localctx, 4, RULE_function_definition);
try {
enterOuterAlt(_localctx, 1);
{
setState(102);
match(DEF);
setState(103);
match(ID);
setState(104);
parameters();
setState(105);
match(COLON);
setState(106);
suite();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParametersContext extends ParserRuleContext {
public TerminalNode OPEN_PAREN() { return getToken(SignalFlowV2Parser.OPEN_PAREN, 0); }
public TerminalNode CLOSE_PAREN() { return getToken(SignalFlowV2Parser.CLOSE_PAREN, 0); }
public Var_args_listContext var_args_list() {
return getRuleContext(Var_args_listContext.class,0);
}
public ParametersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameters; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitParameters(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitParameters(this);
else return visitor.visitChildren(this);
}
}
public final ParametersContext parameters() throws RecognitionException {
ParametersContext _localctx = new ParametersContext(_ctx, getState());
enterRule(_localctx, 6, RULE_parameters);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(108);
match(OPEN_PAREN);
setState(110);
_la = _input.LA(1);
if (_la==ID) {
{
setState(109);
var_args_list();
}
}
setState(112);
match(CLOSE_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Var_args_listContext extends ParserRuleContext {
public List var_args_list_param_def() {
return getRuleContexts(Var_args_list_param_defContext.class);
}
public Var_args_list_param_defContext var_args_list_param_def(int i) {
return getRuleContext(Var_args_list_param_defContext.class,i);
}
public Var_args_listContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_var_args_list; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterVar_args_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitVar_args_list(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitVar_args_list(this);
else return visitor.visitChildren(this);
}
}
public final Var_args_listContext var_args_list() throws RecognitionException {
Var_args_listContext _localctx = new Var_args_listContext(_ctx, getState());
enterRule(_localctx, 8, RULE_var_args_list);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(114);
var_args_list_param_def();
setState(119);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(115);
match(COMMA);
setState(116);
var_args_list_param_def();
}
}
setState(121);
_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 Var_args_list_param_defContext extends ParserRuleContext {
public Var_args_list_param_nameContext var_args_list_param_name() {
return getRuleContext(Var_args_list_param_nameContext.class,0);
}
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public Var_args_list_param_defContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_var_args_list_param_def; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterVar_args_list_param_def(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitVar_args_list_param_def(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitVar_args_list_param_def(this);
else return visitor.visitChildren(this);
}
}
public final Var_args_list_param_defContext var_args_list_param_def() throws RecognitionException {
Var_args_list_param_defContext _localctx = new Var_args_list_param_defContext(_ctx, getState());
enterRule(_localctx, 10, RULE_var_args_list_param_def);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(122);
var_args_list_param_name();
setState(125);
_la = _input.LA(1);
if (_la==BINDING) {
{
setState(123);
match(BINDING);
setState(124);
test();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Var_args_list_param_nameContext extends ParserRuleContext {
public TerminalNode ID() { return getToken(SignalFlowV2Parser.ID, 0); }
public Var_args_list_param_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_var_args_list_param_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterVar_args_list_param_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitVar_args_list_param_name(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitVar_args_list_param_name(this);
else return visitor.visitChildren(this);
}
}
public final Var_args_list_param_nameContext var_args_list_param_name() throws RecognitionException {
Var_args_list_param_nameContext _localctx = new Var_args_list_param_nameContext(_ctx, getState());
enterRule(_localctx, 12, RULE_var_args_list_param_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(127);
match(ID);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StatementContext extends ParserRuleContext {
public Simple_statementContext simple_statement() {
return getRuleContext(Simple_statementContext.class,0);
}
public Compound_statementContext compound_statement() {
return getRuleContext(Compound_statementContext.class,0);
}
public StatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitStatement(this);
else return visitor.visitChildren(this);
}
}
public final StatementContext statement() throws RecognitionException {
StatementContext _localctx = new StatementContext(_ctx, getState());
enterRule(_localctx, 14, RULE_statement);
try {
setState(131);
switch (_input.LA(1)) {
case RETURN:
case FROM:
case IMPORT:
case LAMBDA:
case NONE:
case TRUE:
case FALSE:
case INT:
case FLOAT:
case STRING:
case NOT:
case ID:
case OPEN_PAREN:
case LSQUARE:
case PLUS:
case MINUS:
enterOuterAlt(_localctx, 1);
{
setState(129);
simple_statement();
}
break;
case DEF:
enterOuterAlt(_localctx, 2);
{
setState(130);
compound_statement();
}
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 Simple_statementContext extends ParserRuleContext {
public List small_statement() {
return getRuleContexts(Small_statementContext.class);
}
public Small_statementContext small_statement(int i) {
return getRuleContext(Small_statementContext.class,i);
}
public TerminalNode NEWLINE() { return getToken(SignalFlowV2Parser.NEWLINE, 0); }
public TerminalNode EOF() { return getToken(SignalFlowV2Parser.EOF, 0); }
public Simple_statementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simple_statement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterSimple_statement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitSimple_statement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitSimple_statement(this);
else return visitor.visitChildren(this);
}
}
public final Simple_statementContext simple_statement() throws RecognitionException {
Simple_statementContext _localctx = new Simple_statementContext(_ctx, getState());
enterRule(_localctx, 16, RULE_simple_statement);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(133);
small_statement();
setState(138);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(134);
match(SEMICOLON);
setState(135);
small_statement();
}
}
}
setState(140);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
}
setState(142);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(141);
match(SEMICOLON);
}
}
setState(144);
_la = _input.LA(1);
if ( !(_la==EOF || _la==NEWLINE) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Small_statementContext extends ParserRuleContext {
public Expr_statementContext expr_statement() {
return getRuleContext(Expr_statementContext.class,0);
}
public Flow_statementContext flow_statement() {
return getRuleContext(Flow_statementContext.class,0);
}
public Import_statementContext import_statement() {
return getRuleContext(Import_statementContext.class,0);
}
public Small_statementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_small_statement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterSmall_statement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitSmall_statement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitSmall_statement(this);
else return visitor.visitChildren(this);
}
}
public final Small_statementContext small_statement() throws RecognitionException {
Small_statementContext _localctx = new Small_statementContext(_ctx, getState());
enterRule(_localctx, 18, RULE_small_statement);
try {
setState(149);
switch (_input.LA(1)) {
case LAMBDA:
case NONE:
case TRUE:
case FALSE:
case INT:
case FLOAT:
case STRING:
case NOT:
case ID:
case OPEN_PAREN:
case LSQUARE:
case PLUS:
case MINUS:
enterOuterAlt(_localctx, 1);
{
setState(146);
expr_statement();
}
break;
case RETURN:
enterOuterAlt(_localctx, 2);
{
setState(147);
flow_statement();
}
break;
case FROM:
case IMPORT:
enterOuterAlt(_localctx, 3);
{
setState(148);
import_statement();
}
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 Expr_statementContext extends ParserRuleContext {
public TestlistContext testlist() {
return getRuleContext(TestlistContext.class,0);
}
public Id_listContext id_list() {
return getRuleContext(Id_listContext.class,0);
}
public TerminalNode BINDING() { return getToken(SignalFlowV2Parser.BINDING, 0); }
public Expr_statementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_statement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterExpr_statement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitExpr_statement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitExpr_statement(this);
else return visitor.visitChildren(this);
}
}
public final Expr_statementContext expr_statement() throws RecognitionException {
Expr_statementContext _localctx = new Expr_statementContext(_ctx, getState());
enterRule(_localctx, 20, RULE_expr_statement);
try {
enterOuterAlt(_localctx, 1);
{
setState(154);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
{
setState(151);
id_list();
setState(152);
match(BINDING);
}
break;
}
setState(156);
testlist();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Id_listContext extends ParserRuleContext {
public List ID() { return getTokens(SignalFlowV2Parser.ID); }
public TerminalNode ID(int i) {
return getToken(SignalFlowV2Parser.ID, i);
}
public Id_listContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_id_list; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterId_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitId_list(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitId_list(this);
else return visitor.visitChildren(this);
}
}
public final Id_listContext id_list() throws RecognitionException {
Id_listContext _localctx = new Id_listContext(_ctx, getState());
enterRule(_localctx, 22, RULE_id_list);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(158);
match(ID);
setState(163);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,11,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(159);
match(COMMA);
setState(160);
match(ID);
}
}
}
setState(165);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,11,_ctx);
}
setState(167);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(166);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Import_statementContext extends ParserRuleContext {
public Import_nameContext import_name() {
return getRuleContext(Import_nameContext.class,0);
}
public Import_fromContext import_from() {
return getRuleContext(Import_fromContext.class,0);
}
public Import_statementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_import_statement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterImport_statement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitImport_statement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitImport_statement(this);
else return visitor.visitChildren(this);
}
}
public final Import_statementContext import_statement() throws RecognitionException {
Import_statementContext _localctx = new Import_statementContext(_ctx, getState());
enterRule(_localctx, 24, RULE_import_statement);
try {
setState(171);
switch (_input.LA(1)) {
case IMPORT:
enterOuterAlt(_localctx, 1);
{
setState(169);
import_name();
}
break;
case FROM:
enterOuterAlt(_localctx, 2);
{
setState(170);
import_from();
}
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 Import_nameContext extends ParserRuleContext {
public TerminalNode IMPORT() { return getToken(SignalFlowV2Parser.IMPORT, 0); }
public Dotted_as_namesContext dotted_as_names() {
return getRuleContext(Dotted_as_namesContext.class,0);
}
public Import_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_import_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterImport_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitImport_name(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitImport_name(this);
else return visitor.visitChildren(this);
}
}
public final Import_nameContext import_name() throws RecognitionException {
Import_nameContext _localctx = new Import_nameContext(_ctx, getState());
enterRule(_localctx, 26, RULE_import_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(173);
match(IMPORT);
setState(174);
dotted_as_names();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Import_fromContext extends ParserRuleContext {
public TerminalNode FROM() { return getToken(SignalFlowV2Parser.FROM, 0); }
public Dotted_nameContext dotted_name() {
return getRuleContext(Dotted_nameContext.class,0);
}
public TerminalNode IMPORT() { return getToken(SignalFlowV2Parser.IMPORT, 0); }
public Import_as_namesContext import_as_names() {
return getRuleContext(Import_as_namesContext.class,0);
}
public Import_fromContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_import_from; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterImport_from(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitImport_from(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitImport_from(this);
else return visitor.visitChildren(this);
}
}
public final Import_fromContext import_from() throws RecognitionException {
Import_fromContext _localctx = new Import_fromContext(_ctx, getState());
enterRule(_localctx, 28, RULE_import_from);
try {
enterOuterAlt(_localctx, 1);
{
setState(176);
match(FROM);
setState(177);
dotted_name();
setState(178);
match(IMPORT);
setState(185);
switch (_input.LA(1)) {
case MUL:
{
setState(179);
match(MUL);
}
break;
case OPEN_PAREN:
{
setState(180);
match(OPEN_PAREN);
setState(181);
import_as_names();
setState(182);
match(CLOSE_PAREN);
}
break;
case ID:
{
setState(184);
import_as_names();
}
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 Import_as_nameContext extends ParserRuleContext {
public List ID() { return getTokens(SignalFlowV2Parser.ID); }
public TerminalNode ID(int i) {
return getToken(SignalFlowV2Parser.ID, i);
}
public TerminalNode AS() { return getToken(SignalFlowV2Parser.AS, 0); }
public Import_as_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_import_as_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterImport_as_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitImport_as_name(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitImport_as_name(this);
else return visitor.visitChildren(this);
}
}
public final Import_as_nameContext import_as_name() throws RecognitionException {
Import_as_nameContext _localctx = new Import_as_nameContext(_ctx, getState());
enterRule(_localctx, 30, RULE_import_as_name);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(187);
match(ID);
setState(190);
_la = _input.LA(1);
if (_la==AS) {
{
setState(188);
match(AS);
setState(189);
match(ID);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Dotted_as_nameContext extends ParserRuleContext {
public Dotted_nameContext dotted_name() {
return getRuleContext(Dotted_nameContext.class,0);
}
public TerminalNode AS() { return getToken(SignalFlowV2Parser.AS, 0); }
public TerminalNode ID() { return getToken(SignalFlowV2Parser.ID, 0); }
public Dotted_as_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dotted_as_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterDotted_as_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitDotted_as_name(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitDotted_as_name(this);
else return visitor.visitChildren(this);
}
}
public final Dotted_as_nameContext dotted_as_name() throws RecognitionException {
Dotted_as_nameContext _localctx = new Dotted_as_nameContext(_ctx, getState());
enterRule(_localctx, 32, RULE_dotted_as_name);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(192);
dotted_name();
setState(195);
_la = _input.LA(1);
if (_la==AS) {
{
setState(193);
match(AS);
setState(194);
match(ID);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Import_as_namesContext extends ParserRuleContext {
public List import_as_name() {
return getRuleContexts(Import_as_nameContext.class);
}
public Import_as_nameContext import_as_name(int i) {
return getRuleContext(Import_as_nameContext.class,i);
}
public Import_as_namesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_import_as_names; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterImport_as_names(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitImport_as_names(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitImport_as_names(this);
else return visitor.visitChildren(this);
}
}
public final Import_as_namesContext import_as_names() throws RecognitionException {
Import_as_namesContext _localctx = new Import_as_namesContext(_ctx, getState());
enterRule(_localctx, 34, RULE_import_as_names);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(197);
import_as_name();
setState(202);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,17,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(198);
match(COMMA);
setState(199);
import_as_name();
}
}
}
setState(204);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,17,_ctx);
}
setState(206);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(205);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Dotted_as_namesContext extends ParserRuleContext {
public List dotted_as_name() {
return getRuleContexts(Dotted_as_nameContext.class);
}
public Dotted_as_nameContext dotted_as_name(int i) {
return getRuleContext(Dotted_as_nameContext.class,i);
}
public Dotted_as_namesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dotted_as_names; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterDotted_as_names(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitDotted_as_names(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitDotted_as_names(this);
else return visitor.visitChildren(this);
}
}
public final Dotted_as_namesContext dotted_as_names() throws RecognitionException {
Dotted_as_namesContext _localctx = new Dotted_as_namesContext(_ctx, getState());
enterRule(_localctx, 36, RULE_dotted_as_names);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(208);
dotted_as_name();
setState(213);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(209);
match(COMMA);
setState(210);
dotted_as_name();
}
}
setState(215);
_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 Dotted_nameContext extends ParserRuleContext {
public List ID() { return getTokens(SignalFlowV2Parser.ID); }
public TerminalNode ID(int i) {
return getToken(SignalFlowV2Parser.ID, i);
}
public Dotted_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dotted_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterDotted_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitDotted_name(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitDotted_name(this);
else return visitor.visitChildren(this);
}
}
public final Dotted_nameContext dotted_name() throws RecognitionException {
Dotted_nameContext _localctx = new Dotted_nameContext(_ctx, getState());
enterRule(_localctx, 38, RULE_dotted_name);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(216);
match(ID);
setState(221);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(217);
match(DOT);
setState(218);
match(ID);
}
}
setState(223);
_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 Return_statementContext extends ParserRuleContext {
public TerminalNode RETURN() { return getToken(SignalFlowV2Parser.RETURN, 0); }
public TestlistContext testlist() {
return getRuleContext(TestlistContext.class,0);
}
public Return_statementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_return_statement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterReturn_statement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitReturn_statement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitReturn_statement(this);
else return visitor.visitChildren(this);
}
}
public final Return_statementContext return_statement() throws RecognitionException {
Return_statementContext _localctx = new Return_statementContext(_ctx, getState());
enterRule(_localctx, 40, RULE_return_statement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(224);
match(RETURN);
setState(226);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LAMBDA) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << INT) | (1L << FLOAT) | (1L << STRING) | (1L << NOT) | (1L << ID) | (1L << OPEN_PAREN) | (1L << LSQUARE) | (1L << PLUS) | (1L << MINUS))) != 0)) {
{
setState(225);
testlist();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Flow_statementContext extends ParserRuleContext {
public Return_statementContext return_statement() {
return getRuleContext(Return_statementContext.class,0);
}
public Flow_statementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_flow_statement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterFlow_statement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitFlow_statement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitFlow_statement(this);
else return visitor.visitChildren(this);
}
}
public final Flow_statementContext flow_statement() throws RecognitionException {
Flow_statementContext _localctx = new Flow_statementContext(_ctx, getState());
enterRule(_localctx, 42, RULE_flow_statement);
try {
enterOuterAlt(_localctx, 1);
{
setState(228);
return_statement();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Compound_statementContext extends ParserRuleContext {
public Function_definitionContext function_definition() {
return getRuleContext(Function_definitionContext.class,0);
}
public Compound_statementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_compound_statement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterCompound_statement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitCompound_statement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitCompound_statement(this);
else return visitor.visitChildren(this);
}
}
public final Compound_statementContext compound_statement() throws RecognitionException {
Compound_statementContext _localctx = new Compound_statementContext(_ctx, getState());
enterRule(_localctx, 44, RULE_compound_statement);
try {
enterOuterAlt(_localctx, 1);
{
setState(230);
function_definition();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SuiteContext extends ParserRuleContext {
public Simple_statementContext simple_statement() {
return getRuleContext(Simple_statementContext.class,0);
}
public TerminalNode NEWLINE() { return getToken(SignalFlowV2Parser.NEWLINE, 0); }
public TerminalNode INDENT() { return getToken(SignalFlowV2Parser.INDENT, 0); }
public TerminalNode DEDENT() { return getToken(SignalFlowV2Parser.DEDENT, 0); }
public List statement() {
return getRuleContexts(StatementContext.class);
}
public StatementContext statement(int i) {
return getRuleContext(StatementContext.class,i);
}
public SuiteContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_suite; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterSuite(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitSuite(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitSuite(this);
else return visitor.visitChildren(this);
}
}
public final SuiteContext suite() throws RecognitionException {
SuiteContext _localctx = new SuiteContext(_ctx, getState());
enterRule(_localctx, 46, RULE_suite);
int _la;
try {
setState(242);
switch (_input.LA(1)) {
case RETURN:
case FROM:
case IMPORT:
case LAMBDA:
case NONE:
case TRUE:
case FALSE:
case INT:
case FLOAT:
case STRING:
case NOT:
case ID:
case OPEN_PAREN:
case LSQUARE:
case PLUS:
case MINUS:
enterOuterAlt(_localctx, 1);
{
setState(232);
simple_statement();
}
break;
case NEWLINE:
enterOuterAlt(_localctx, 2);
{
setState(233);
match(NEWLINE);
setState(234);
match(INDENT);
setState(236);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(235);
statement();
}
}
setState(238);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << DEF) | (1L << RETURN) | (1L << FROM) | (1L << IMPORT) | (1L << LAMBDA) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << INT) | (1L << FLOAT) | (1L << STRING) | (1L << NOT) | (1L << ID) | (1L << OPEN_PAREN) | (1L << LSQUARE) | (1L << PLUS) | (1L << MINUS))) != 0) );
setState(240);
match(DEDENT);
}
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 TestContext extends ParserRuleContext {
public List or_test() {
return getRuleContexts(Or_testContext.class);
}
public Or_testContext or_test(int i) {
return getRuleContext(Or_testContext.class,i);
}
public TerminalNode IF() { return getToken(SignalFlowV2Parser.IF, 0); }
public TerminalNode ELSE() { return getToken(SignalFlowV2Parser.ELSE, 0); }
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public LambdefContext lambdef() {
return getRuleContext(LambdefContext.class,0);
}
public TestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_test; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterTest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitTest(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitTest(this);
else return visitor.visitChildren(this);
}
}
public final TestContext test() throws RecognitionException {
TestContext _localctx = new TestContext(_ctx, getState());
enterRule(_localctx, 48, RULE_test);
int _la;
try {
setState(253);
switch (_input.LA(1)) {
case NONE:
case TRUE:
case FALSE:
case INT:
case FLOAT:
case STRING:
case NOT:
case ID:
case OPEN_PAREN:
case LSQUARE:
case PLUS:
case MINUS:
enterOuterAlt(_localctx, 1);
{
setState(244);
or_test();
setState(250);
_la = _input.LA(1);
if (_la==IF) {
{
setState(245);
match(IF);
setState(246);
or_test();
setState(247);
match(ELSE);
setState(248);
test();
}
}
}
break;
case LAMBDA:
enterOuterAlt(_localctx, 2);
{
setState(252);
lambdef();
}
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 LambdefContext extends ParserRuleContext {
public TerminalNode LAMBDA() { return getToken(SignalFlowV2Parser.LAMBDA, 0); }
public TerminalNode ID() { return getToken(SignalFlowV2Parser.ID, 0); }
public TerminalNode COLON() { return getToken(SignalFlowV2Parser.COLON, 0); }
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public LambdefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lambdef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterLambdef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitLambdef(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitLambdef(this);
else return visitor.visitChildren(this);
}
}
public final LambdefContext lambdef() throws RecognitionException {
LambdefContext _localctx = new LambdefContext(_ctx, getState());
enterRule(_localctx, 50, RULE_lambdef);
try {
enterOuterAlt(_localctx, 1);
{
setState(255);
match(LAMBDA);
setState(256);
match(ID);
setState(257);
match(COLON);
setState(258);
test();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Or_testContext extends ParserRuleContext {
public List and_test() {
return getRuleContexts(And_testContext.class);
}
public And_testContext and_test(int i) {
return getRuleContext(And_testContext.class,i);
}
public List OR() { return getTokens(SignalFlowV2Parser.OR); }
public TerminalNode OR(int i) {
return getToken(SignalFlowV2Parser.OR, i);
}
public Or_testContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_or_test; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterOr_test(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitOr_test(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitOr_test(this);
else return visitor.visitChildren(this);
}
}
public final Or_testContext or_test() throws RecognitionException {
Or_testContext _localctx = new Or_testContext(_ctx, getState());
enterRule(_localctx, 52, RULE_or_test);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(260);
and_test();
setState(265);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OR) {
{
{
setState(261);
match(OR);
setState(262);
and_test();
}
}
setState(267);
_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 And_testContext extends ParserRuleContext {
public List not_test() {
return getRuleContexts(Not_testContext.class);
}
public Not_testContext not_test(int i) {
return getRuleContext(Not_testContext.class,i);
}
public List AND() { return getTokens(SignalFlowV2Parser.AND); }
public TerminalNode AND(int i) {
return getToken(SignalFlowV2Parser.AND, i);
}
public And_testContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_and_test; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterAnd_test(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitAnd_test(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitAnd_test(this);
else return visitor.visitChildren(this);
}
}
public final And_testContext and_test() throws RecognitionException {
And_testContext _localctx = new And_testContext(_ctx, getState());
enterRule(_localctx, 54, RULE_and_test);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(268);
not_test();
setState(273);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AND) {
{
{
setState(269);
match(AND);
setState(270);
not_test();
}
}
setState(275);
_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 Not_testContext extends ParserRuleContext {
public TerminalNode NOT() { return getToken(SignalFlowV2Parser.NOT, 0); }
public Not_testContext not_test() {
return getRuleContext(Not_testContext.class,0);
}
public ComparisonContext comparison() {
return getRuleContext(ComparisonContext.class,0);
}
public Not_testContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_not_test; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterNot_test(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitNot_test(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitNot_test(this);
else return visitor.visitChildren(this);
}
}
public final Not_testContext not_test() throws RecognitionException {
Not_testContext _localctx = new Not_testContext(_ctx, getState());
enterRule(_localctx, 56, RULE_not_test);
try {
setState(279);
switch (_input.LA(1)) {
case NOT:
enterOuterAlt(_localctx, 1);
{
setState(276);
match(NOT);
setState(277);
not_test();
}
break;
case NONE:
case TRUE:
case FALSE:
case INT:
case FLOAT:
case STRING:
case ID:
case OPEN_PAREN:
case LSQUARE:
case PLUS:
case MINUS:
enterOuterAlt(_localctx, 2);
{
setState(278);
comparison();
}
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 ComparisonContext extends ParserRuleContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public List LT() { return getTokens(SignalFlowV2Parser.LT); }
public TerminalNode LT(int i) {
return getToken(SignalFlowV2Parser.LT, i);
}
public List LE() { return getTokens(SignalFlowV2Parser.LE); }
public TerminalNode LE(int i) {
return getToken(SignalFlowV2Parser.LE, i);
}
public List EQ() { return getTokens(SignalFlowV2Parser.EQ); }
public TerminalNode EQ(int i) {
return getToken(SignalFlowV2Parser.EQ, i);
}
public List NE() { return getTokens(SignalFlowV2Parser.NE); }
public TerminalNode NE(int i) {
return getToken(SignalFlowV2Parser.NE, i);
}
public List GT() { return getTokens(SignalFlowV2Parser.GT); }
public TerminalNode GT(int i) {
return getToken(SignalFlowV2Parser.GT, i);
}
public List GE() { return getTokens(SignalFlowV2Parser.GE); }
public TerminalNode GE(int i) {
return getToken(SignalFlowV2Parser.GE, i);
}
public List IS() { return getTokens(SignalFlowV2Parser.IS); }
public TerminalNode IS(int i) {
return getToken(SignalFlowV2Parser.IS, i);
}
public List NOT() { return getTokens(SignalFlowV2Parser.NOT); }
public TerminalNode NOT(int i) {
return getToken(SignalFlowV2Parser.NOT, i);
}
public ComparisonContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comparison; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterComparison(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitComparison(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitComparison(this);
else return visitor.visitChildren(this);
}
}
public final ComparisonContext comparison() throws RecognitionException {
ComparisonContext _localctx = new ComparisonContext(_ctx, getState());
enterRule(_localctx, 58, RULE_comparison);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(281);
expr();
setState(296);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LE) | (1L << GE) | (1L << EQ) | (1L << NE) | (1L << LT) | (1L << GT) | (1L << IS))) != 0)) {
{
{
setState(291);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,29,_ctx) ) {
case 1:
{
setState(282);
match(LT);
}
break;
case 2:
{
setState(283);
match(LE);
}
break;
case 3:
{
setState(284);
match(EQ);
}
break;
case 4:
{
setState(285);
match(NE);
}
break;
case 5:
{
setState(286);
match(GT);
}
break;
case 6:
{
setState(287);
match(GE);
}
break;
case 7:
{
setState(288);
match(IS);
}
break;
case 8:
{
setState(289);
match(IS);
setState(290);
match(NOT);
}
break;
}
setState(293);
expr();
}
}
setState(298);
_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 ExprContext extends ParserRuleContext {
public List term() {
return getRuleContexts(TermContext.class);
}
public TermContext term(int i) {
return getRuleContext(TermContext.class,i);
}
public List PLUS() { return getTokens(SignalFlowV2Parser.PLUS); }
public TerminalNode PLUS(int i) {
return getToken(SignalFlowV2Parser.PLUS, i);
}
public List MINUS() { return getTokens(SignalFlowV2Parser.MINUS); }
public TerminalNode MINUS(int i) {
return getToken(SignalFlowV2Parser.MINUS, i);
}
public ExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitExpr(this);
else return visitor.visitChildren(this);
}
}
public final ExprContext expr() throws RecognitionException {
ExprContext _localctx = new ExprContext(_ctx, getState());
enterRule(_localctx, 60, RULE_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(299);
term();
setState(304);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==PLUS || _la==MINUS) {
{
{
setState(300);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==MINUS) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(301);
term();
}
}
setState(306);
_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 TermContext extends ParserRuleContext {
public List factor() {
return getRuleContexts(FactorContext.class);
}
public FactorContext factor(int i) {
return getRuleContext(FactorContext.class,i);
}
public List MUL() { return getTokens(SignalFlowV2Parser.MUL); }
public TerminalNode MUL(int i) {
return getToken(SignalFlowV2Parser.MUL, i);
}
public List DIV() { return getTokens(SignalFlowV2Parser.DIV); }
public TerminalNode DIV(int i) {
return getToken(SignalFlowV2Parser.DIV, i);
}
public TermContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_term; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitTerm(this);
else return visitor.visitChildren(this);
}
}
public final TermContext term() throws RecognitionException {
TermContext _localctx = new TermContext(_ctx, getState());
enterRule(_localctx, 62, RULE_term);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(307);
factor();
setState(312);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==MUL || _la==DIV) {
{
{
setState(308);
_la = _input.LA(1);
if ( !(_la==MUL || _la==DIV) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(309);
factor();
}
}
setState(314);
_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 FactorContext extends ParserRuleContext {
public FactorContext factor() {
return getRuleContext(FactorContext.class,0);
}
public TerminalNode PLUS() { return getToken(SignalFlowV2Parser.PLUS, 0); }
public TerminalNode MINUS() { return getToken(SignalFlowV2Parser.MINUS, 0); }
public PowerContext power() {
return getRuleContext(PowerContext.class,0);
}
public FactorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_factor; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterFactor(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitFactor(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitFactor(this);
else return visitor.visitChildren(this);
}
}
public final FactorContext factor() throws RecognitionException {
FactorContext _localctx = new FactorContext(_ctx, getState());
enterRule(_localctx, 64, RULE_factor);
int _la;
try {
setState(318);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
enterOuterAlt(_localctx, 1);
{
setState(315);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==MINUS) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(316);
factor();
}
break;
case NONE:
case TRUE:
case FALSE:
case INT:
case FLOAT:
case STRING:
case ID:
case OPEN_PAREN:
case LSQUARE:
enterOuterAlt(_localctx, 2);
{
setState(317);
power();
}
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 PowerContext extends ParserRuleContext {
public Atom_exprContext atom_expr() {
return getRuleContext(Atom_exprContext.class,0);
}
public TerminalNode POW() { return getToken(SignalFlowV2Parser.POW, 0); }
public FactorContext factor() {
return getRuleContext(FactorContext.class,0);
}
public PowerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_power; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterPower(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitPower(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitPower(this);
else return visitor.visitChildren(this);
}
}
public final PowerContext power() throws RecognitionException {
PowerContext _localctx = new PowerContext(_ctx, getState());
enterRule(_localctx, 66, RULE_power);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(320);
atom_expr();
setState(323);
_la = _input.LA(1);
if (_la==POW) {
{
setState(321);
match(POW);
setState(322);
factor();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Atom_exprContext extends ParserRuleContext {
public AtomContext atom() {
return getRuleContext(AtomContext.class,0);
}
public List trailer() {
return getRuleContexts(TrailerContext.class);
}
public TrailerContext trailer(int i) {
return getRuleContext(TrailerContext.class,i);
}
public Atom_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_atom_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterAtom_expr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitAtom_expr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitAtom_expr(this);
else return visitor.visitChildren(this);
}
}
public final Atom_exprContext atom_expr() throws RecognitionException {
Atom_exprContext _localctx = new Atom_exprContext(_ctx, getState());
enterRule(_localctx, 68, RULE_atom_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(325);
atom();
setState(329);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OPEN_PAREN || _la==DOT) {
{
{
setState(326);
trailer();
}
}
setState(331);
_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 AtomContext extends ParserRuleContext {
public List_exprContext list_expr() {
return getRuleContext(List_exprContext.class,0);
}
public Tuple_exprContext tuple_expr() {
return getRuleContext(Tuple_exprContext.class,0);
}
public TerminalNode ID() { return getToken(SignalFlowV2Parser.ID, 0); }
public TerminalNode INT() { return getToken(SignalFlowV2Parser.INT, 0); }
public TerminalNode FLOAT() { return getToken(SignalFlowV2Parser.FLOAT, 0); }
public List STRING() { return getTokens(SignalFlowV2Parser.STRING); }
public TerminalNode STRING(int i) {
return getToken(SignalFlowV2Parser.STRING, i);
}
public TerminalNode NONE() { return getToken(SignalFlowV2Parser.NONE, 0); }
public TerminalNode TRUE() { return getToken(SignalFlowV2Parser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(SignalFlowV2Parser.FALSE, 0); }
public AtomContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_atom; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterAtom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitAtom(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitAtom(this);
else return visitor.visitChildren(this);
}
}
public final AtomContext atom() throws RecognitionException {
AtomContext _localctx = new AtomContext(_ctx, getState());
enterRule(_localctx, 70, RULE_atom);
int _la;
try {
setState(345);
switch (_input.LA(1)) {
case LSQUARE:
enterOuterAlt(_localctx, 1);
{
setState(332);
list_expr();
}
break;
case OPEN_PAREN:
enterOuterAlt(_localctx, 2);
{
setState(333);
tuple_expr();
}
break;
case ID:
enterOuterAlt(_localctx, 3);
{
setState(334);
match(ID);
}
break;
case INT:
enterOuterAlt(_localctx, 4);
{
setState(335);
match(INT);
}
break;
case FLOAT:
enterOuterAlt(_localctx, 5);
{
setState(336);
match(FLOAT);
}
break;
case STRING:
enterOuterAlt(_localctx, 6);
{
setState(338);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(337);
match(STRING);
}
}
setState(340);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==STRING );
}
break;
case NONE:
enterOuterAlt(_localctx, 7);
{
setState(342);
match(NONE);
}
break;
case TRUE:
enterOuterAlt(_localctx, 8);
{
setState(343);
match(TRUE);
}
break;
case FALSE:
enterOuterAlt(_localctx, 9);
{
setState(344);
match(FALSE);
}
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 List_exprContext extends ParserRuleContext {
public TerminalNode LSQUARE() { return getToken(SignalFlowV2Parser.LSQUARE, 0); }
public TerminalNode RSQUARE() { return getToken(SignalFlowV2Parser.RSQUARE, 0); }
public List test() {
return getRuleContexts(TestContext.class);
}
public TestContext test(int i) {
return getRuleContext(TestContext.class,i);
}
public List COMMA() { return getTokens(SignalFlowV2Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SignalFlowV2Parser.COMMA, i);
}
public List_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_list_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterList_expr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitList_expr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitList_expr(this);
else return visitor.visitChildren(this);
}
}
public final List_exprContext list_expr() throws RecognitionException {
List_exprContext _localctx = new List_exprContext(_ctx, getState());
enterRule(_localctx, 72, RULE_list_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(347);
match(LSQUARE);
setState(356);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LAMBDA) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << INT) | (1L << FLOAT) | (1L << STRING) | (1L << NOT) | (1L << ID) | (1L << OPEN_PAREN) | (1L << LSQUARE) | (1L << PLUS) | (1L << MINUS))) != 0)) {
{
setState(348);
test();
setState(353);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(349);
match(COMMA);
setState(350);
test();
}
}
setState(355);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(358);
match(RSQUARE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Tuple_exprContext extends ParserRuleContext {
public TerminalNode OPEN_PAREN() { return getToken(SignalFlowV2Parser.OPEN_PAREN, 0); }
public TerminalNode CLOSE_PAREN() { return getToken(SignalFlowV2Parser.CLOSE_PAREN, 0); }
public TestlistContext testlist() {
return getRuleContext(TestlistContext.class,0);
}
public Tuple_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tuple_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterTuple_expr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitTuple_expr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitTuple_expr(this);
else return visitor.visitChildren(this);
}
}
public final Tuple_exprContext tuple_expr() throws RecognitionException {
Tuple_exprContext _localctx = new Tuple_exprContext(_ctx, getState());
enterRule(_localctx, 74, RULE_tuple_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(360);
match(OPEN_PAREN);
setState(362);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LAMBDA) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << INT) | (1L << FLOAT) | (1L << STRING) | (1L << NOT) | (1L << ID) | (1L << OPEN_PAREN) | (1L << LSQUARE) | (1L << PLUS) | (1L << MINUS))) != 0)) {
{
setState(361);
testlist();
}
}
setState(364);
match(CLOSE_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TestlistContext extends ParserRuleContext {
public List test() {
return getRuleContexts(TestContext.class);
}
public TestContext test(int i) {
return getRuleContext(TestContext.class,i);
}
public List COMMA() { return getTokens(SignalFlowV2Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SignalFlowV2Parser.COMMA, i);
}
public TestlistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_testlist; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterTestlist(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitTestlist(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitTestlist(this);
else return visitor.visitChildren(this);
}
}
public final TestlistContext testlist() throws RecognitionException {
TestlistContext _localctx = new TestlistContext(_ctx, getState());
enterRule(_localctx, 76, RULE_testlist);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(366);
test();
setState(371);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,41,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(367);
match(COMMA);
setState(368);
test();
}
}
}
setState(373);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,41,_ctx);
}
setState(375);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(374);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TrailerContext extends ParserRuleContext {
public TerminalNode OPEN_PAREN() { return getToken(SignalFlowV2Parser.OPEN_PAREN, 0); }
public TerminalNode CLOSE_PAREN() { return getToken(SignalFlowV2Parser.CLOSE_PAREN, 0); }
public Actual_argsContext actual_args() {
return getRuleContext(Actual_argsContext.class,0);
}
public TerminalNode DOT() { return getToken(SignalFlowV2Parser.DOT, 0); }
public TerminalNode ID() { return getToken(SignalFlowV2Parser.ID, 0); }
public TrailerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_trailer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterTrailer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitTrailer(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitTrailer(this);
else return visitor.visitChildren(this);
}
}
public final TrailerContext trailer() throws RecognitionException {
TrailerContext _localctx = new TrailerContext(_ctx, getState());
enterRule(_localctx, 78, RULE_trailer);
int _la;
try {
setState(384);
switch (_input.LA(1)) {
case OPEN_PAREN:
enterOuterAlt(_localctx, 1);
{
setState(377);
match(OPEN_PAREN);
setState(379);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LAMBDA) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << INT) | (1L << FLOAT) | (1L << STRING) | (1L << NOT) | (1L << ID) | (1L << OPEN_PAREN) | (1L << LSQUARE) | (1L << PLUS) | (1L << MINUS))) != 0)) {
{
setState(378);
actual_args();
}
}
setState(381);
match(CLOSE_PAREN);
}
break;
case DOT:
enterOuterAlt(_localctx, 2);
{
setState(382);
match(DOT);
setState(383);
match(ID);
}
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 Actual_argsContext extends ParserRuleContext {
public List argument() {
return getRuleContexts(ArgumentContext.class);
}
public ArgumentContext argument(int i) {
return getRuleContext(ArgumentContext.class,i);
}
public List COMMA() { return getTokens(SignalFlowV2Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SignalFlowV2Parser.COMMA, i);
}
public Actual_argsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_actual_args; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterActual_args(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitActual_args(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitActual_args(this);
else return visitor.visitChildren(this);
}
}
public final Actual_argsContext actual_args() throws RecognitionException {
Actual_argsContext _localctx = new Actual_argsContext(_ctx, getState());
enterRule(_localctx, 80, RULE_actual_args);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(386);
argument();
setState(391);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(387);
match(COMMA);
setState(388);
argument();
}
}
setState(393);
_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 ArgumentContext extends ParserRuleContext {
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public TerminalNode ID() { return getToken(SignalFlowV2Parser.ID, 0); }
public TerminalNode BINDING() { return getToken(SignalFlowV2Parser.BINDING, 0); }
public ArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_argument; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).enterArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SignalFlowV2ParserListener ) ((SignalFlowV2ParserListener)listener).exitArgument(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SignalFlowV2ParserVisitor ) return ((SignalFlowV2ParserVisitor)visitor).visitArgument(this);
else return visitor.visitChildren(this);
}
}
public final ArgumentContext argument() throws RecognitionException {
ArgumentContext _localctx = new ArgumentContext(_ctx, getState());
enterRule(_localctx, 82, RULE_argument);
try {
enterOuterAlt(_localctx, 1);
{
setState(396);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) {
case 1:
{
setState(394);
match(ID);
setState(395);
match(BINDING);
}
break;
}
setState(398);
test();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN =
"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\60\u0193\4\2\t\2"+
"\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\3"+
"\2\3\2\7\2Y\n\2\f\2\16\2\\\13\2\3\2\3\2\3\3\3\3\7\3b\n\3\f\3\16\3e\13"+
"\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\3\5\3\5\5\5q\n\5\3\5\3\5\3\6\3\6\3"+
"\6\7\6x\n\6\f\6\16\6{\13\6\3\7\3\7\3\7\5\7\u0080\n\7\3\b\3\b\3\t\3\t\5"+
"\t\u0086\n\t\3\n\3\n\3\n\7\n\u008b\n\n\f\n\16\n\u008e\13\n\3\n\5\n\u0091"+
"\n\n\3\n\3\n\3\13\3\13\3\13\5\13\u0098\n\13\3\f\3\f\3\f\5\f\u009d\n\f"+
"\3\f\3\f\3\r\3\r\3\r\7\r\u00a4\n\r\f\r\16\r\u00a7\13\r\3\r\5\r\u00aa\n"+
"\r\3\16\3\16\5\16\u00ae\n\16\3\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3"+
"\20\3\20\3\20\3\20\5\20\u00bc\n\20\3\21\3\21\3\21\5\21\u00c1\n\21\3\22"+
"\3\22\3\22\5\22\u00c6\n\22\3\23\3\23\3\23\7\23\u00cb\n\23\f\23\16\23\u00ce"+
"\13\23\3\23\5\23\u00d1\n\23\3\24\3\24\3\24\7\24\u00d6\n\24\f\24\16\24"+
"\u00d9\13\24\3\25\3\25\3\25\7\25\u00de\n\25\f\25\16\25\u00e1\13\25\3\26"+
"\3\26\5\26\u00e5\n\26\3\27\3\27\3\30\3\30\3\31\3\31\3\31\3\31\6\31\u00ef"+
"\n\31\r\31\16\31\u00f0\3\31\3\31\5\31\u00f5\n\31\3\32\3\32\3\32\3\32\3"+
"\32\3\32\5\32\u00fd\n\32\3\32\5\32\u0100\n\32\3\33\3\33\3\33\3\33\3\33"+
"\3\34\3\34\3\34\7\34\u010a\n\34\f\34\16\34\u010d\13\34\3\35\3\35\3\35"+
"\7\35\u0112\n\35\f\35\16\35\u0115\13\35\3\36\3\36\3\36\5\36\u011a\n\36"+
"\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\5\37\u0126\n\37\3\37"+
"\7\37\u0129\n\37\f\37\16\37\u012c\13\37\3 \3 \3 \7 \u0131\n \f \16 \u0134"+
"\13 \3!\3!\3!\7!\u0139\n!\f!\16!\u013c\13!\3\"\3\"\3\"\5\"\u0141\n\"\3"+
"#\3#\3#\5#\u0146\n#\3$\3$\7$\u014a\n$\f$\16$\u014d\13$\3%\3%\3%\3%\3%"+
"\3%\6%\u0155\n%\r%\16%\u0156\3%\3%\3%\5%\u015c\n%\3&\3&\3&\3&\7&\u0162"+
"\n&\f&\16&\u0165\13&\5&\u0167\n&\3&\3&\3\'\3\'\5\'\u016d\n\'\3\'\3\'\3"+
"(\3(\3(\7(\u0174\n(\f(\16(\u0177\13(\3(\5(\u017a\n(\3)\3)\5)\u017e\n)"+
"\3)\3)\3)\5)\u0183\n)\3*\3*\3*\7*\u0188\n*\f*\16*\u018b\13*\3+\3+\5+\u018f"+
"\n+\3+\3+\3+\2\2,\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62"+
"\64\668:<>@BDFHJLNPRT\2\5\3\3,,\3\2%&\3\2\'(\u01a6\2Z\3\2\2\2\4_\3\2\2"+
"\2\6h\3\2\2\2\bn\3\2\2\2\nt\3\2\2\2\f|\3\2\2\2\16\u0081\3\2\2\2\20\u0085"+
"\3\2\2\2\22\u0087\3\2\2\2\24\u0097\3\2\2\2\26\u009c\3\2\2\2\30\u00a0\3"+
"\2\2\2\32\u00ad\3\2\2\2\34\u00af\3\2\2\2\36\u00b2\3\2\2\2 \u00bd\3\2\2"+
"\2\"\u00c2\3\2\2\2$\u00c7\3\2\2\2&\u00d2\3\2\2\2(\u00da\3\2\2\2*\u00e2"+
"\3\2\2\2,\u00e6\3\2\2\2.\u00e8\3\2\2\2\60\u00f4\3\2\2\2\62\u00ff\3\2\2"+
"\2\64\u0101\3\2\2\2\66\u0106\3\2\2\28\u010e\3\2\2\2:\u0119\3\2\2\2<\u011b"+
"\3\2\2\2>\u012d\3\2\2\2@\u0135\3\2\2\2B\u0140\3\2\2\2D\u0142\3\2\2\2F"+
"\u0147\3\2\2\2H\u015b\3\2\2\2J\u015d\3\2\2\2L\u016a\3\2\2\2N\u0170\3\2"+
"\2\2P\u0182\3\2\2\2R\u0184\3\2\2\2T\u018e\3\2\2\2VY\7,\2\2WY\5\20\t\2"+
"XV\3\2\2\2XW\3\2\2\2Y\\\3\2\2\2ZX\3\2\2\2Z[\3\2\2\2[]\3\2\2\2\\Z\3\2\2"+
"\2]^\7\2\2\3^\3\3\2\2\2_c\5N(\2`b\7,\2\2a`\3\2\2\2be\3\2\2\2ca\3\2\2\2"+
"cd\3\2\2\2df\3\2\2\2ec\3\2\2\2fg\7\2\2\3g\5\3\2\2\2hi\7\3\2\2ij\7\33\2"+
"\2jk\5\b\5\2kl\7$\2\2lm\5\60\31\2m\7\3\2\2\2np\7\34\2\2oq\5\n\6\2po\3"+
"\2\2\2pq\3\2\2\2qr\3\2\2\2rs\7\35\2\2s\t\3\2\2\2ty\5\f\7\2uv\7\"\2\2v"+
"x\5\f\7\2wu\3\2\2\2x{\3\2\2\2yw\3\2\2\2yz\3\2\2\2z\13\3\2\2\2{y\3\2\2"+
"\2|\177\5\16\b\2}~\7*\2\2~\u0080\5\62\32\2\177}\3\2\2\2\177\u0080\3\2"+
"\2\2\u0080\r\3\2\2\2\u0081\u0082\7\33\2\2\u0082\17\3\2\2\2\u0083\u0086"+
"\5\22\n\2\u0084\u0086\5.\30\2\u0085\u0083\3\2\2\2\u0085\u0084\3\2\2\2"+
"\u0086\21\3\2\2\2\u0087\u008c\5\24\13\2\u0088\u0089\7#\2\2\u0089\u008b"+
"\5\24\13\2\u008a\u0088\3\2\2\2\u008b\u008e\3\2\2\2\u008c\u008a\3\2\2\2"+
"\u008c\u008d\3\2\2\2\u008d\u0090\3\2\2\2\u008e\u008c\3\2\2\2\u008f\u0091"+
"\7#\2\2\u0090\u008f\3\2\2\2\u0090\u0091\3\2\2\2\u0091\u0092\3\2\2\2\u0092"+
"\u0093\t\2\2\2\u0093\23\3\2\2\2\u0094\u0098\5\26\f\2\u0095\u0098\5,\27"+
"\2\u0096\u0098\5\32\16\2\u0097\u0094\3\2\2\2\u0097\u0095\3\2\2\2\u0097"+
"\u0096\3\2\2\2\u0098\25\3\2\2\2\u0099\u009a\5\30\r\2\u009a\u009b\7*\2"+
"\2\u009b\u009d\3\2\2\2\u009c\u0099\3\2\2\2\u009c\u009d\3\2\2\2\u009d\u009e"+
"\3\2\2\2\u009e\u009f\5N(\2\u009f\27\3\2\2\2\u00a0\u00a5\7\33\2\2\u00a1"+
"\u00a2\7\"\2\2\u00a2\u00a4\7\33\2\2\u00a3\u00a1\3\2\2\2\u00a4\u00a7\3"+
"\2\2\2\u00a5\u00a3\3\2\2\2\u00a5\u00a6\3\2\2\2\u00a6\u00a9\3\2\2\2\u00a7"+
"\u00a5\3\2\2\2\u00a8\u00aa\7\"\2\2\u00a9\u00a8\3\2\2\2\u00a9\u00aa\3\2"+
"\2\2\u00aa\31\3\2\2\2\u00ab\u00ae\5\34\17\2\u00ac\u00ae\5\36\20\2\u00ad"+
"\u00ab\3\2\2\2\u00ad\u00ac\3\2\2\2\u00ae\33\3\2\2\2\u00af\u00b0\7\6\2"+
"\2\u00b0\u00b1\5&\24\2\u00b1\35\3\2\2\2\u00b2\u00b3\7\5\2\2\u00b3\u00b4"+
"\5(\25\2\u00b4\u00bb\7\6\2\2\u00b5\u00bc\7\'\2\2\u00b6\u00b7\7\34\2\2"+
"\u00b7\u00b8\5$\23\2\u00b8\u00b9\7\35\2\2\u00b9\u00bc\3\2\2\2\u00ba\u00bc"+
"\5$\23\2\u00bb\u00b5\3\2\2\2\u00bb\u00b6\3\2\2\2\u00bb\u00ba\3\2\2\2\u00bc"+
"\37\3\2\2\2\u00bd\u00c0\7\33\2\2\u00be\u00bf\7\7\2\2\u00bf\u00c1\7\33"+
"\2\2\u00c0\u00be\3\2\2\2\u00c0\u00c1\3\2\2\2\u00c1!\3\2\2\2\u00c2\u00c5"+
"\5(\25\2\u00c3\u00c4\7\7\2\2\u00c4\u00c6\7\33\2\2\u00c5\u00c3\3\2\2\2"+
"\u00c5\u00c6\3\2\2\2\u00c6#\3\2\2\2\u00c7\u00cc\5 \21\2\u00c8\u00c9\7"+
"\"\2\2\u00c9\u00cb\5 \21\2\u00ca\u00c8\3\2\2\2\u00cb\u00ce\3\2\2\2\u00cc"+
"\u00ca\3\2\2\2\u00cc\u00cd\3\2\2\2\u00cd\u00d0\3\2\2\2\u00ce\u00cc\3\2"+
"\2\2\u00cf\u00d1\7\"\2\2\u00d0\u00cf\3\2\2\2\u00d0\u00d1\3\2\2\2\u00d1"+
"%\3\2\2\2\u00d2\u00d7\5\"\22\2\u00d3\u00d4\7\"\2\2\u00d4\u00d6\5\"\22"+
"\2\u00d5\u00d3\3\2\2\2\u00d6\u00d9\3\2\2\2\u00d7\u00d5\3\2\2\2\u00d7\u00d8"+
"\3\2\2\2\u00d8\'\3\2\2\2\u00d9\u00d7\3\2\2\2\u00da\u00df\7\33\2\2\u00db"+
"\u00dc\7+\2\2\u00dc\u00de\7\33\2\2\u00dd\u00db\3\2\2\2\u00de\u00e1\3\2"+
"\2\2\u00df\u00dd\3\2\2\2\u00df\u00e0\3\2\2\2\u00e0)\3\2\2\2\u00e1\u00df"+
"\3\2\2\2\u00e2\u00e4\7\4\2\2\u00e3\u00e5\5N(\2\u00e4\u00e3\3\2\2\2\u00e4"+
"\u00e5\3\2\2\2\u00e5+\3\2\2\2\u00e6\u00e7\5*\26\2\u00e7-\3\2\2\2\u00e8"+
"\u00e9\5\6\4\2\u00e9/\3\2\2\2\u00ea\u00f5\5\22\n\2\u00eb\u00ec\7,\2\2"+
"\u00ec\u00ee\7/\2\2\u00ed\u00ef\5\20\t\2\u00ee\u00ed\3\2\2\2\u00ef\u00f0"+
"\3\2\2\2\u00f0\u00ee\3\2\2\2\u00f0\u00f1\3\2\2\2\u00f1\u00f2\3\2\2\2\u00f2"+
"\u00f3\7\60\2\2\u00f3\u00f5\3\2\2\2\u00f4\u00ea\3\2\2\2\u00f4\u00eb\3"+
"\2\2\2\u00f5\61\3\2\2\2\u00f6\u00fc\5\66\34\2\u00f7\u00f8\7\f\2\2\u00f8"+
"\u00f9\5\66\34\2\u00f9\u00fa\7\r\2\2\u00fa\u00fb\5\62\32\2\u00fb\u00fd"+
"\3\2\2\2\u00fc\u00f7\3\2\2\2\u00fc\u00fd\3\2\2\2\u00fd\u0100\3\2\2\2\u00fe"+
"\u0100\5\64\33\2\u00ff\u00f6\3\2\2\2\u00ff\u00fe\3\2\2\2\u0100\63\3\2"+
"\2\2\u0101\u0102\7\b\2\2\u0102\u0103\7\33\2\2\u0103\u0104\7$\2\2\u0104"+
"\u0105\5\62\32\2\u0105\65\3\2\2\2\u0106\u010b\58\35\2\u0107\u0108\7\27"+
"\2\2\u0108\u010a\58\35\2\u0109\u0107\3\2\2\2\u010a\u010d\3\2\2\2\u010b"+
"\u0109\3\2\2\2\u010b\u010c\3\2\2\2\u010c\67\3\2\2\2\u010d\u010b\3\2\2"+
"\2\u010e\u0113\5:\36\2\u010f\u0110\7\30\2\2\u0110\u0112\5:\36\2\u0111"+
"\u010f\3\2\2\2\u0112\u0115\3\2\2\2\u0113\u0111\3\2\2\2\u0113\u0114\3\2"+
"\2\2\u01149\3\2\2\2\u0115\u0113\3\2\2\2\u0116\u0117\7\31\2\2\u0117\u011a"+
"\5:\36\2\u0118\u011a\5<\37\2\u0119\u0116\3\2\2\2\u0119\u0118\3\2\2\2\u011a"+
";\3\2\2\2\u011b\u012a\5> \2\u011c\u0126\7\25\2\2\u011d\u0126\7\21\2\2"+
"\u011e\u0126\7\23\2\2\u011f\u0126\7\24\2\2\u0120\u0126\7\26\2\2\u0121"+
"\u0126\7\22\2\2\u0122\u0126\7\32\2\2\u0123\u0124\7\32\2\2\u0124\u0126"+
"\7\31\2\2\u0125\u011c\3\2\2\2\u0125\u011d\3\2\2\2\u0125\u011e\3\2\2\2"+
"\u0125\u011f\3\2\2\2\u0125\u0120\3\2\2\2\u0125\u0121\3\2\2\2\u0125\u0122"+
"\3\2\2\2\u0125\u0123\3\2\2\2\u0126\u0127\3\2\2\2\u0127\u0129\5> \2\u0128"+
"\u0125\3\2\2\2\u0129\u012c\3\2\2\2\u012a\u0128\3\2\2\2\u012a\u012b\3\2"+
"\2\2\u012b=\3\2\2\2\u012c\u012a\3\2\2\2\u012d\u0132\5@!\2\u012e\u012f"+
"\t\3\2\2\u012f\u0131\5@!\2\u0130\u012e\3\2\2\2\u0131\u0134\3\2\2\2\u0132"+
"\u0130\3\2\2\2\u0132\u0133\3\2\2\2\u0133?\3\2\2\2\u0134\u0132\3\2\2\2"+
"\u0135\u013a\5B\"\2\u0136\u0137\t\4\2\2\u0137\u0139\5B\"\2\u0138\u0136"+
"\3\2\2\2\u0139\u013c\3\2\2\2\u013a\u0138\3\2\2\2\u013a\u013b\3\2\2\2\u013b"+
"A\3\2\2\2\u013c\u013a\3\2\2\2\u013d\u013e\t\3\2\2\u013e\u0141\5B\"\2\u013f"+
"\u0141\5D#\2\u0140\u013d\3\2\2\2\u0140\u013f\3\2\2\2\u0141C\3\2\2\2\u0142"+
"\u0145\5F$\2\u0143\u0144\7)\2\2\u0144\u0146\5B\"\2\u0145\u0143\3\2\2\2"+
"\u0145\u0146\3\2\2\2\u0146E\3\2\2\2\u0147\u014b\5H%\2\u0148\u014a\5P)"+
"\2\u0149\u0148\3\2\2\2\u014a\u014d\3\2\2\2\u014b\u0149\3\2\2\2\u014b\u014c"+
"\3\2\2\2\u014cG\3\2\2\2\u014d\u014b\3\2\2\2\u014e\u015c\5J&\2\u014f\u015c"+
"\5L\'\2\u0150\u015c\7\33\2\2\u0151\u015c\7\16\2\2\u0152\u015c\7\17\2\2"+
"\u0153\u0155\7\20\2\2\u0154\u0153\3\2\2\2\u0155\u0156\3\2\2\2\u0156\u0154"+
"\3\2\2\2\u0156\u0157\3\2\2\2\u0157\u015c\3\2\2\2\u0158\u015c\7\t\2\2\u0159"+
"\u015c\7\n\2\2\u015a\u015c\7\13\2\2\u015b\u014e\3\2\2\2\u015b\u014f\3"+
"\2\2\2\u015b\u0150\3\2\2\2\u015b\u0151\3\2\2\2\u015b\u0152\3\2\2\2\u015b"+
"\u0154\3\2\2\2\u015b\u0158\3\2\2\2\u015b\u0159\3\2\2\2\u015b\u015a\3\2"+
"\2\2\u015cI\3\2\2\2\u015d\u0166\7\36\2\2\u015e\u0163\5\62\32\2\u015f\u0160"+
"\7\"\2\2\u0160\u0162\5\62\32\2\u0161\u015f\3\2\2\2\u0162\u0165\3\2\2\2"+
"\u0163\u0161\3\2\2\2\u0163\u0164\3\2\2\2\u0164\u0167\3\2\2\2\u0165\u0163"+
"\3\2\2\2\u0166\u015e\3\2\2\2\u0166\u0167\3\2\2\2\u0167\u0168\3\2\2\2\u0168"+
"\u0169\7\37\2\2\u0169K\3\2\2\2\u016a\u016c\7\34\2\2\u016b\u016d\5N(\2"+
"\u016c\u016b\3\2\2\2\u016c\u016d\3\2\2\2\u016d\u016e\3\2\2\2\u016e\u016f"+
"\7\35\2\2\u016fM\3\2\2\2\u0170\u0175\5\62\32\2\u0171\u0172\7\"\2\2\u0172"+
"\u0174\5\62\32\2\u0173\u0171\3\2\2\2\u0174\u0177\3\2\2\2\u0175\u0173\3"+
"\2\2\2\u0175\u0176\3\2\2\2\u0176\u0179\3\2\2\2\u0177\u0175\3\2\2\2\u0178"+
"\u017a\7\"\2\2\u0179\u0178\3\2\2\2\u0179\u017a\3\2\2\2\u017aO\3\2\2\2"+
"\u017b\u017d\7\34\2\2\u017c\u017e\5R*\2\u017d\u017c\3\2\2\2\u017d\u017e"+
"\3\2\2\2\u017e\u017f\3\2\2\2\u017f\u0183\7\35\2\2\u0180\u0181\7+\2\2\u0181"+
"\u0183\7\33\2\2\u0182\u017b\3\2\2\2\u0182\u0180\3\2\2\2\u0183Q\3\2\2\2"+
"\u0184\u0189\5T+\2\u0185\u0186\7\"\2\2\u0186\u0188\5T+\2\u0187\u0185\3"+
"\2\2\2\u0188\u018b\3\2\2\2\u0189\u0187\3\2\2\2\u0189\u018a\3\2\2\2\u018a"+
"S\3\2\2\2\u018b\u0189\3\2\2\2\u018c\u018d\7\33\2\2\u018d\u018f\7*\2\2"+
"\u018e\u018c\3\2\2\2\u018e\u018f\3\2\2\2\u018f\u0190\3\2\2\2\u0190\u0191"+
"\5\62\32\2\u0191U\3\2\2\2\61XZcpy\177\u0085\u008c\u0090\u0097\u009c\u00a5"+
"\u00a9\u00ad\u00bb\u00c0\u00c5\u00cc\u00d0\u00d7\u00df\u00e4\u00f0\u00f4"+
"\u00fc\u00ff\u010b\u0113\u0119\u0125\u012a\u0132\u013a\u0140\u0145\u014b"+
"\u0156\u015b\u0163\u0166\u016c\u0175\u0179\u017d\u0182\u0189\u018e";
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