1251 lines
39 KiB
Java
1251 lines
39 KiB
Java
// Generated from de/hsrm/compiler/Klang/Klang.g4 by ANTLR 4.5
|
|
package de.hsrm.compiler.Klang;
|
|
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 KlangParser extends Parser {
|
|
static { RuntimeMetaData.checkVersion("4.5", RuntimeMetaData.VERSION); }
|
|
|
|
protected static final DFA[] _decisionToDFA;
|
|
protected static final PredictionContextCache _sharedContextCache =
|
|
new PredictionContextCache();
|
|
public static final int
|
|
OR=1, AND=2, EQ=3, NEQ=4, GT=5, LT=6, GTEQ=7, LTEQ=8, PLUS=9, MINUS=10,
|
|
MULT=11, DIV=12, MOD=13, POW=14, NOT=15, SCOL=16, ASSIGN=17, OPAR=18,
|
|
CPAR=19, OBRACE=20, CBRACE=21, TRUE=22, FALSE=23, NIL=24, IF=25, ELSE=26,
|
|
WHILE=27, LOG=28, ID=29, INT=30, FLOAT=31, STRING=32, COMMENT=33, SPACE=34,
|
|
OTHER=35;
|
|
public static final int
|
|
RULE_parse = 0, RULE_block = 1, RULE_stat = 2, RULE_assignment = 3, RULE_if_stat = 4,
|
|
RULE_condition_block = 5, RULE_stat_block = 6, RULE_while_stat = 7, RULE_log = 8,
|
|
RULE_expr = 9, RULE_atom = 10;
|
|
public static final String[] ruleNames = {
|
|
"parse", "block", "stat", "assignment", "if_stat", "condition_block",
|
|
"stat_block", "while_stat", "log", "expr", "atom"
|
|
};
|
|
|
|
private static final String[] _LITERAL_NAMES = {
|
|
null, "'||'", "'&&'", "'=='", "'!='", "'>'", "'<'", "'>='", "'<='", "'+'",
|
|
"'-'", "'*'", "'/'", "'%'", "'^'", "'!'", "';'", "'='", "'('", "')'",
|
|
"'{'", "'}'", "'true'", "'false'", "'nil'", "'if'", "'else'", "'while'",
|
|
"'log'"
|
|
};
|
|
private static final String[] _SYMBOLIC_NAMES = {
|
|
null, "OR", "AND", "EQ", "NEQ", "GT", "LT", "GTEQ", "LTEQ", "PLUS", "MINUS",
|
|
"MULT", "DIV", "MOD", "POW", "NOT", "SCOL", "ASSIGN", "OPAR", "CPAR",
|
|
"OBRACE", "CBRACE", "TRUE", "FALSE", "NIL", "IF", "ELSE", "WHILE", "LOG",
|
|
"ID", "INT", "FLOAT", "STRING", "COMMENT", "SPACE", "OTHER"
|
|
};
|
|
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] = "<INVALID>";
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
@Deprecated
|
|
public String[] getTokenNames() {
|
|
return tokenNames;
|
|
}
|
|
|
|
@Override
|
|
|
|
public Vocabulary getVocabulary() {
|
|
return VOCABULARY;
|
|
}
|
|
|
|
@Override
|
|
public String getGrammarFileName() { return "Klang.g4"; }
|
|
|
|
@Override
|
|
public String[] getRuleNames() { return ruleNames; }
|
|
|
|
@Override
|
|
public String getSerializedATN() { return _serializedATN; }
|
|
|
|
@Override
|
|
public ATN getATN() { return _ATN; }
|
|
|
|
public KlangParser(TokenStream input) {
|
|
super(input);
|
|
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
|
|
}
|
|
public static class ParseContext extends ParserRuleContext {
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public TerminalNode EOF() { return getToken(KlangParser.EOF, 0); }
|
|
public ParseContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_parse; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterParse(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitParse(this);
|
|
}
|
|
}
|
|
|
|
public final ParseContext parse() throws RecognitionException {
|
|
ParseContext _localctx = new ParseContext(_ctx, getState());
|
|
enterRule(_localctx, 0, RULE_parse);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(22);
|
|
block();
|
|
setState(23);
|
|
match(EOF);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public static class BlockContext extends ParserRuleContext {
|
|
public List<StatContext> stat() {
|
|
return getRuleContexts(StatContext.class);
|
|
}
|
|
public StatContext stat(int i) {
|
|
return getRuleContext(StatContext.class,i);
|
|
}
|
|
public BlockContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_block; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterBlock(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitBlock(this);
|
|
}
|
|
}
|
|
|
|
public final BlockContext block() throws RecognitionException {
|
|
BlockContext _localctx = new BlockContext(_ctx, getState());
|
|
enterRule(_localctx, 2, RULE_block);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(28);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IF) | (1L << WHILE) | (1L << LOG) | (1L << ID) | (1L << OTHER))) != 0)) {
|
|
{
|
|
{
|
|
setState(25);
|
|
stat();
|
|
}
|
|
}
|
|
setState(30);
|
|
_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 StatContext extends ParserRuleContext {
|
|
public Token OTHER;
|
|
public AssignmentContext assignment() {
|
|
return getRuleContext(AssignmentContext.class,0);
|
|
}
|
|
public If_statContext if_stat() {
|
|
return getRuleContext(If_statContext.class,0);
|
|
}
|
|
public While_statContext while_stat() {
|
|
return getRuleContext(While_statContext.class,0);
|
|
}
|
|
public LogContext log() {
|
|
return getRuleContext(LogContext.class,0);
|
|
}
|
|
public TerminalNode OTHER() { return getToken(KlangParser.OTHER, 0); }
|
|
public StatContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_stat; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterStat(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitStat(this);
|
|
}
|
|
}
|
|
|
|
public final StatContext stat() throws RecognitionException {
|
|
StatContext _localctx = new StatContext(_ctx, getState());
|
|
enterRule(_localctx, 4, RULE_stat);
|
|
try {
|
|
setState(37);
|
|
switch (_input.LA(1)) {
|
|
case ID:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(31);
|
|
assignment();
|
|
}
|
|
break;
|
|
case IF:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(32);
|
|
if_stat();
|
|
}
|
|
break;
|
|
case WHILE:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(33);
|
|
while_stat();
|
|
}
|
|
break;
|
|
case LOG:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(34);
|
|
log();
|
|
}
|
|
break;
|
|
case OTHER:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(35);
|
|
((StatContext)_localctx).OTHER = match(OTHER);
|
|
System.err.println("unknown char: " + (((StatContext)_localctx).OTHER!=null?((StatContext)_localctx).OTHER.getText():null));
|
|
}
|
|
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 AssignmentContext extends ParserRuleContext {
|
|
public TerminalNode ID() { return getToken(KlangParser.ID, 0); }
|
|
public TerminalNode ASSIGN() { return getToken(KlangParser.ASSIGN, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode SCOL() { return getToken(KlangParser.SCOL, 0); }
|
|
public AssignmentContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_assignment; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterAssignment(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitAssignment(this);
|
|
}
|
|
}
|
|
|
|
public final AssignmentContext assignment() throws RecognitionException {
|
|
AssignmentContext _localctx = new AssignmentContext(_ctx, getState());
|
|
enterRule(_localctx, 6, RULE_assignment);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(39);
|
|
match(ID);
|
|
setState(40);
|
|
match(ASSIGN);
|
|
setState(41);
|
|
expr(0);
|
|
setState(42);
|
|
match(SCOL);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public static class If_statContext extends ParserRuleContext {
|
|
public List<TerminalNode> IF() { return getTokens(KlangParser.IF); }
|
|
public TerminalNode IF(int i) {
|
|
return getToken(KlangParser.IF, i);
|
|
}
|
|
public List<Condition_blockContext> condition_block() {
|
|
return getRuleContexts(Condition_blockContext.class);
|
|
}
|
|
public Condition_blockContext condition_block(int i) {
|
|
return getRuleContext(Condition_blockContext.class,i);
|
|
}
|
|
public List<TerminalNode> ELSE() { return getTokens(KlangParser.ELSE); }
|
|
public TerminalNode ELSE(int i) {
|
|
return getToken(KlangParser.ELSE, i);
|
|
}
|
|
public Stat_blockContext stat_block() {
|
|
return getRuleContext(Stat_blockContext.class,0);
|
|
}
|
|
public If_statContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_if_stat; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterIf_stat(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitIf_stat(this);
|
|
}
|
|
}
|
|
|
|
public final If_statContext if_stat() throws RecognitionException {
|
|
If_statContext _localctx = new If_statContext(_ctx, getState());
|
|
enterRule(_localctx, 8, RULE_if_stat);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(44);
|
|
match(IF);
|
|
setState(45);
|
|
condition_block();
|
|
setState(51);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(46);
|
|
match(ELSE);
|
|
setState(47);
|
|
match(IF);
|
|
setState(48);
|
|
condition_block();
|
|
}
|
|
}
|
|
}
|
|
setState(53);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
|
|
}
|
|
setState(56);
|
|
switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(54);
|
|
match(ELSE);
|
|
setState(55);
|
|
stat_block();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public static class Condition_blockContext extends ParserRuleContext {
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public Stat_blockContext stat_block() {
|
|
return getRuleContext(Stat_blockContext.class,0);
|
|
}
|
|
public Condition_blockContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_condition_block; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterCondition_block(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitCondition_block(this);
|
|
}
|
|
}
|
|
|
|
public final Condition_blockContext condition_block() throws RecognitionException {
|
|
Condition_blockContext _localctx = new Condition_blockContext(_ctx, getState());
|
|
enterRule(_localctx, 10, RULE_condition_block);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(58);
|
|
expr(0);
|
|
setState(59);
|
|
stat_block();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public static class Stat_blockContext extends ParserRuleContext {
|
|
public TerminalNode OBRACE() { return getToken(KlangParser.OBRACE, 0); }
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public TerminalNode CBRACE() { return getToken(KlangParser.CBRACE, 0); }
|
|
public StatContext stat() {
|
|
return getRuleContext(StatContext.class,0);
|
|
}
|
|
public Stat_blockContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_stat_block; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterStat_block(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitStat_block(this);
|
|
}
|
|
}
|
|
|
|
public final Stat_blockContext stat_block() throws RecognitionException {
|
|
Stat_blockContext _localctx = new Stat_blockContext(_ctx, getState());
|
|
enterRule(_localctx, 12, RULE_stat_block);
|
|
try {
|
|
setState(66);
|
|
switch (_input.LA(1)) {
|
|
case OBRACE:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(61);
|
|
match(OBRACE);
|
|
setState(62);
|
|
block();
|
|
setState(63);
|
|
match(CBRACE);
|
|
}
|
|
break;
|
|
case IF:
|
|
case WHILE:
|
|
case LOG:
|
|
case ID:
|
|
case OTHER:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(65);
|
|
stat();
|
|
}
|
|
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 While_statContext extends ParserRuleContext {
|
|
public TerminalNode WHILE() { return getToken(KlangParser.WHILE, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public Stat_blockContext stat_block() {
|
|
return getRuleContext(Stat_blockContext.class,0);
|
|
}
|
|
public While_statContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_while_stat; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterWhile_stat(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitWhile_stat(this);
|
|
}
|
|
}
|
|
|
|
public final While_statContext while_stat() throws RecognitionException {
|
|
While_statContext _localctx = new While_statContext(_ctx, getState());
|
|
enterRule(_localctx, 14, RULE_while_stat);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(68);
|
|
match(WHILE);
|
|
setState(69);
|
|
expr(0);
|
|
setState(70);
|
|
stat_block();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public static class LogContext extends ParserRuleContext {
|
|
public TerminalNode LOG() { return getToken(KlangParser.LOG, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode SCOL() { return getToken(KlangParser.SCOL, 0); }
|
|
public LogContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_log; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterLog(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitLog(this);
|
|
}
|
|
}
|
|
|
|
public final LogContext log() throws RecognitionException {
|
|
LogContext _localctx = new LogContext(_ctx, getState());
|
|
enterRule(_localctx, 16, RULE_log);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(72);
|
|
match(LOG);
|
|
setState(73);
|
|
expr(0);
|
|
setState(74);
|
|
match(SCOL);
|
|
}
|
|
}
|
|
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 ExprContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_expr; }
|
|
|
|
public ExprContext() { }
|
|
public void copyFrom(ExprContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
public static class NotExprContext extends ExprContext {
|
|
public TerminalNode NOT() { return getToken(KlangParser.NOT, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public NotExprContext(ExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterNotExpr(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitNotExpr(this);
|
|
}
|
|
}
|
|
public static class UnaryMinusExprContext extends ExprContext {
|
|
public TerminalNode MINUS() { return getToken(KlangParser.MINUS, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public UnaryMinusExprContext(ExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterUnaryMinusExpr(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitUnaryMinusExpr(this);
|
|
}
|
|
}
|
|
public static class MultiplicationExprContext extends ExprContext {
|
|
public Token op;
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode MULT() { return getToken(KlangParser.MULT, 0); }
|
|
public TerminalNode DIV() { return getToken(KlangParser.DIV, 0); }
|
|
public TerminalNode MOD() { return getToken(KlangParser.MOD, 0); }
|
|
public MultiplicationExprContext(ExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterMultiplicationExpr(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitMultiplicationExpr(this);
|
|
}
|
|
}
|
|
public static class AtomExprContext extends ExprContext {
|
|
public AtomContext atom() {
|
|
return getRuleContext(AtomContext.class,0);
|
|
}
|
|
public AtomExprContext(ExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterAtomExpr(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitAtomExpr(this);
|
|
}
|
|
}
|
|
public static class OrExprContext extends ExprContext {
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode OR() { return getToken(KlangParser.OR, 0); }
|
|
public OrExprContext(ExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterOrExpr(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitOrExpr(this);
|
|
}
|
|
}
|
|
public static class AdditiveExprContext extends ExprContext {
|
|
public Token op;
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode PLUS() { return getToken(KlangParser.PLUS, 0); }
|
|
public TerminalNode MINUS() { return getToken(KlangParser.MINUS, 0); }
|
|
public AdditiveExprContext(ExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterAdditiveExpr(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitAdditiveExpr(this);
|
|
}
|
|
}
|
|
public static class PowExprContext extends ExprContext {
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode POW() { return getToken(KlangParser.POW, 0); }
|
|
public PowExprContext(ExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterPowExpr(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitPowExpr(this);
|
|
}
|
|
}
|
|
public static class RelationalExprContext extends ExprContext {
|
|
public Token op;
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode LTEQ() { return getToken(KlangParser.LTEQ, 0); }
|
|
public TerminalNode GTEQ() { return getToken(KlangParser.GTEQ, 0); }
|
|
public TerminalNode LT() { return getToken(KlangParser.LT, 0); }
|
|
public TerminalNode GT() { return getToken(KlangParser.GT, 0); }
|
|
public RelationalExprContext(ExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterRelationalExpr(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitRelationalExpr(this);
|
|
}
|
|
}
|
|
public static class EqualityExprContext extends ExprContext {
|
|
public Token op;
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode EQ() { return getToken(KlangParser.EQ, 0); }
|
|
public TerminalNode NEQ() { return getToken(KlangParser.NEQ, 0); }
|
|
public EqualityExprContext(ExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterEqualityExpr(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitEqualityExpr(this);
|
|
}
|
|
}
|
|
public static class AndExprContext extends ExprContext {
|
|
public List<ExprContext> expr() {
|
|
return getRuleContexts(ExprContext.class);
|
|
}
|
|
public ExprContext expr(int i) {
|
|
return getRuleContext(ExprContext.class,i);
|
|
}
|
|
public TerminalNode AND() { return getToken(KlangParser.AND, 0); }
|
|
public AndExprContext(ExprContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterAndExpr(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitAndExpr(this);
|
|
}
|
|
}
|
|
|
|
public final ExprContext expr() throws RecognitionException {
|
|
return expr(0);
|
|
}
|
|
|
|
private ExprContext expr(int _p) throws RecognitionException {
|
|
ParserRuleContext _parentctx = _ctx;
|
|
int _parentState = getState();
|
|
ExprContext _localctx = new ExprContext(_ctx, _parentState);
|
|
ExprContext _prevctx = _localctx;
|
|
int _startState = 18;
|
|
enterRecursionRule(_localctx, 18, RULE_expr, _p);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(82);
|
|
switch (_input.LA(1)) {
|
|
case MINUS:
|
|
{
|
|
_localctx = new UnaryMinusExprContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
|
|
setState(77);
|
|
match(MINUS);
|
|
setState(78);
|
|
expr(9);
|
|
}
|
|
break;
|
|
case NOT:
|
|
{
|
|
_localctx = new NotExprContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(79);
|
|
match(NOT);
|
|
setState(80);
|
|
expr(8);
|
|
}
|
|
break;
|
|
case OPAR:
|
|
case TRUE:
|
|
case FALSE:
|
|
case NIL:
|
|
case ID:
|
|
case INT:
|
|
case FLOAT:
|
|
case STRING:
|
|
{
|
|
_localctx = new AtomExprContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(81);
|
|
atom();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(107);
|
|
_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 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
setState(105);
|
|
switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
|
|
case 1:
|
|
{
|
|
_localctx = new PowExprContext(new ExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expr);
|
|
setState(84);
|
|
if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)");
|
|
setState(85);
|
|
match(POW);
|
|
setState(86);
|
|
expr(11);
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
_localctx = new MultiplicationExprContext(new ExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expr);
|
|
setState(87);
|
|
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
|
|
setState(88);
|
|
((MultiplicationExprContext)_localctx).op = _input.LT(1);
|
|
_la = _input.LA(1);
|
|
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << MULT) | (1L << DIV) | (1L << MOD))) != 0)) ) {
|
|
((MultiplicationExprContext)_localctx).op = (Token)_errHandler.recoverInline(this);
|
|
} else {
|
|
consume();
|
|
}
|
|
setState(89);
|
|
expr(8);
|
|
}
|
|
break;
|
|
case 3:
|
|
{
|
|
_localctx = new AdditiveExprContext(new ExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expr);
|
|
setState(90);
|
|
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
|
|
setState(91);
|
|
((AdditiveExprContext)_localctx).op = _input.LT(1);
|
|
_la = _input.LA(1);
|
|
if ( !(_la==PLUS || _la==MINUS) ) {
|
|
((AdditiveExprContext)_localctx).op = (Token)_errHandler.recoverInline(this);
|
|
} else {
|
|
consume();
|
|
}
|
|
setState(92);
|
|
expr(7);
|
|
}
|
|
break;
|
|
case 4:
|
|
{
|
|
_localctx = new RelationalExprContext(new ExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expr);
|
|
setState(93);
|
|
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
|
|
setState(94);
|
|
((RelationalExprContext)_localctx).op = _input.LT(1);
|
|
_la = _input.LA(1);
|
|
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << GT) | (1L << LT) | (1L << GTEQ) | (1L << LTEQ))) != 0)) ) {
|
|
((RelationalExprContext)_localctx).op = (Token)_errHandler.recoverInline(this);
|
|
} else {
|
|
consume();
|
|
}
|
|
setState(95);
|
|
expr(6);
|
|
}
|
|
break;
|
|
case 5:
|
|
{
|
|
_localctx = new EqualityExprContext(new ExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expr);
|
|
setState(96);
|
|
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
|
|
setState(97);
|
|
((EqualityExprContext)_localctx).op = _input.LT(1);
|
|
_la = _input.LA(1);
|
|
if ( !(_la==EQ || _la==NEQ) ) {
|
|
((EqualityExprContext)_localctx).op = (Token)_errHandler.recoverInline(this);
|
|
} else {
|
|
consume();
|
|
}
|
|
setState(98);
|
|
expr(5);
|
|
}
|
|
break;
|
|
case 6:
|
|
{
|
|
_localctx = new AndExprContext(new ExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expr);
|
|
setState(99);
|
|
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
|
|
setState(100);
|
|
match(AND);
|
|
setState(101);
|
|
expr(4);
|
|
}
|
|
break;
|
|
case 7:
|
|
{
|
|
_localctx = new OrExprContext(new ExprContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expr);
|
|
setState(102);
|
|
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
|
|
setState(103);
|
|
match(OR);
|
|
setState(104);
|
|
expr(3);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
setState(109);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public static class AtomContext extends ParserRuleContext {
|
|
public AtomContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_atom; }
|
|
|
|
public AtomContext() { }
|
|
public void copyFrom(AtomContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
public static class ParExprContext extends AtomContext {
|
|
public TerminalNode OPAR() { return getToken(KlangParser.OPAR, 0); }
|
|
public ExprContext expr() {
|
|
return getRuleContext(ExprContext.class,0);
|
|
}
|
|
public TerminalNode CPAR() { return getToken(KlangParser.CPAR, 0); }
|
|
public ParExprContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterParExpr(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitParExpr(this);
|
|
}
|
|
}
|
|
public static class BooleanAtomContext extends AtomContext {
|
|
public TerminalNode TRUE() { return getToken(KlangParser.TRUE, 0); }
|
|
public TerminalNode FALSE() { return getToken(KlangParser.FALSE, 0); }
|
|
public BooleanAtomContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterBooleanAtom(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitBooleanAtom(this);
|
|
}
|
|
}
|
|
public static class IdAtomContext extends AtomContext {
|
|
public TerminalNode ID() { return getToken(KlangParser.ID, 0); }
|
|
public IdAtomContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterIdAtom(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitIdAtom(this);
|
|
}
|
|
}
|
|
public static class StringAtomContext extends AtomContext {
|
|
public TerminalNode STRING() { return getToken(KlangParser.STRING, 0); }
|
|
public StringAtomContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterStringAtom(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitStringAtom(this);
|
|
}
|
|
}
|
|
public static class NilAtomContext extends AtomContext {
|
|
public TerminalNode NIL() { return getToken(KlangParser.NIL, 0); }
|
|
public NilAtomContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterNilAtom(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitNilAtom(this);
|
|
}
|
|
}
|
|
public static class NumberAtomContext extends AtomContext {
|
|
public TerminalNode INT() { return getToken(KlangParser.INT, 0); }
|
|
public TerminalNode FLOAT() { return getToken(KlangParser.FLOAT, 0); }
|
|
public NumberAtomContext(AtomContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).enterNumberAtom(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof KlangListener ) ((KlangListener)listener).exitNumberAtom(this);
|
|
}
|
|
}
|
|
|
|
public final AtomContext atom() throws RecognitionException {
|
|
AtomContext _localctx = new AtomContext(_ctx, getState());
|
|
enterRule(_localctx, 20, RULE_atom);
|
|
int _la;
|
|
try {
|
|
setState(119);
|
|
switch (_input.LA(1)) {
|
|
case OPAR:
|
|
_localctx = new ParExprContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(110);
|
|
match(OPAR);
|
|
setState(111);
|
|
expr(0);
|
|
setState(112);
|
|
match(CPAR);
|
|
}
|
|
break;
|
|
case INT:
|
|
case FLOAT:
|
|
_localctx = new NumberAtomContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(114);
|
|
_la = _input.LA(1);
|
|
if ( !(_la==INT || _la==FLOAT) ) {
|
|
_errHandler.recoverInline(this);
|
|
} else {
|
|
consume();
|
|
}
|
|
}
|
|
break;
|
|
case TRUE:
|
|
case FALSE:
|
|
_localctx = new BooleanAtomContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(115);
|
|
_la = _input.LA(1);
|
|
if ( !(_la==TRUE || _la==FALSE) ) {
|
|
_errHandler.recoverInline(this);
|
|
} else {
|
|
consume();
|
|
}
|
|
}
|
|
break;
|
|
case ID:
|
|
_localctx = new IdAtomContext(_localctx);
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(116);
|
|
match(ID);
|
|
}
|
|
break;
|
|
case STRING:
|
|
_localctx = new StringAtomContext(_localctx);
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(117);
|
|
match(STRING);
|
|
}
|
|
break;
|
|
case NIL:
|
|
_localctx = new NilAtomContext(_localctx);
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(118);
|
|
match(NIL);
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
|
|
switch (ruleIndex) {
|
|
case 9:
|
|
return expr_sempred((ExprContext)_localctx, predIndex);
|
|
}
|
|
return true;
|
|
}
|
|
private boolean expr_sempred(ExprContext _localctx, int predIndex) {
|
|
switch (predIndex) {
|
|
case 0:
|
|
return precpred(_ctx, 10);
|
|
case 1:
|
|
return precpred(_ctx, 7);
|
|
case 2:
|
|
return precpred(_ctx, 6);
|
|
case 3:
|
|
return precpred(_ctx, 5);
|
|
case 4:
|
|
return precpred(_ctx, 4);
|
|
case 5:
|
|
return precpred(_ctx, 3);
|
|
case 6:
|
|
return precpred(_ctx, 2);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static final String _serializedATN =
|
|
"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3%|\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\3\2\3\2\3\2\3\3\7\3\35\n\3\f\3\16\3 \13\3\3\4\3\4\3\4\3\4\3\4\3\4"+
|
|
"\5\4(\n\4\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\7\6\64\n\6\f\6\16\6"+
|
|
"\67\13\6\3\6\3\6\5\6;\n\6\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b\5\bE\n\b\3\t"+
|
|
"\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\13\5\13U\n\13"+
|
|
"\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13"+
|
|
"\3\13\3\13\3\13\3\13\3\13\3\13\3\13\7\13l\n\13\f\13\16\13o\13\13\3\f\3"+
|
|
"\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\5\fz\n\f\3\f\2\3\24\r\2\4\6\b\n\f\16\20"+
|
|
"\22\24\26\2\b\3\2\r\17\3\2\13\f\3\2\7\n\3\2\5\6\3\2 !\3\2\30\31\u0086"+
|
|
"\2\30\3\2\2\2\4\36\3\2\2\2\6\'\3\2\2\2\b)\3\2\2\2\n.\3\2\2\2\f<\3\2\2"+
|
|
"\2\16D\3\2\2\2\20F\3\2\2\2\22J\3\2\2\2\24T\3\2\2\2\26y\3\2\2\2\30\31\5"+
|
|
"\4\3\2\31\32\7\2\2\3\32\3\3\2\2\2\33\35\5\6\4\2\34\33\3\2\2\2\35 \3\2"+
|
|
"\2\2\36\34\3\2\2\2\36\37\3\2\2\2\37\5\3\2\2\2 \36\3\2\2\2!(\5\b\5\2\""+
|
|
"(\5\n\6\2#(\5\20\t\2$(\5\22\n\2%&\7%\2\2&(\b\4\1\2\'!\3\2\2\2\'\"\3\2"+
|
|
"\2\2\'#\3\2\2\2\'$\3\2\2\2\'%\3\2\2\2(\7\3\2\2\2)*\7\37\2\2*+\7\23\2\2"+
|
|
"+,\5\24\13\2,-\7\22\2\2-\t\3\2\2\2./\7\33\2\2/\65\5\f\7\2\60\61\7\34\2"+
|
|
"\2\61\62\7\33\2\2\62\64\5\f\7\2\63\60\3\2\2\2\64\67\3\2\2\2\65\63\3\2"+
|
|
"\2\2\65\66\3\2\2\2\66:\3\2\2\2\67\65\3\2\2\289\7\34\2\29;\5\16\b\2:8\3"+
|
|
"\2\2\2:;\3\2\2\2;\13\3\2\2\2<=\5\24\13\2=>\5\16\b\2>\r\3\2\2\2?@\7\26"+
|
|
"\2\2@A\5\4\3\2AB\7\27\2\2BE\3\2\2\2CE\5\6\4\2D?\3\2\2\2DC\3\2\2\2E\17"+
|
|
"\3\2\2\2FG\7\35\2\2GH\5\24\13\2HI\5\16\b\2I\21\3\2\2\2JK\7\36\2\2KL\5"+
|
|
"\24\13\2LM\7\22\2\2M\23\3\2\2\2NO\b\13\1\2OP\7\f\2\2PU\5\24\13\13QR\7"+
|
|
"\21\2\2RU\5\24\13\nSU\5\26\f\2TN\3\2\2\2TQ\3\2\2\2TS\3\2\2\2Um\3\2\2\2"+
|
|
"VW\f\f\2\2WX\7\20\2\2Xl\5\24\13\rYZ\f\t\2\2Z[\t\2\2\2[l\5\24\13\n\\]\f"+
|
|
"\b\2\2]^\t\3\2\2^l\5\24\13\t_`\f\7\2\2`a\t\4\2\2al\5\24\13\bbc\f\6\2\2"+
|
|
"cd\t\5\2\2dl\5\24\13\7ef\f\5\2\2fg\7\4\2\2gl\5\24\13\6hi\f\4\2\2ij\7\3"+
|
|
"\2\2jl\5\24\13\5kV\3\2\2\2kY\3\2\2\2k\\\3\2\2\2k_\3\2\2\2kb\3\2\2\2ke"+
|
|
"\3\2\2\2kh\3\2\2\2lo\3\2\2\2mk\3\2\2\2mn\3\2\2\2n\25\3\2\2\2om\3\2\2\2"+
|
|
"pq\7\24\2\2qr\5\24\13\2rs\7\25\2\2sz\3\2\2\2tz\t\6\2\2uz\t\7\2\2vz\7\37"+
|
|
"\2\2wz\7\"\2\2xz\7\32\2\2yp\3\2\2\2yt\3\2\2\2yu\3\2\2\2yv\3\2\2\2yw\3"+
|
|
"\2\2\2yx\3\2\2\2z\27\3\2\2\2\13\36\'\65:DTkmy";
|
|
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);
|
|
}
|
|
}
|
|
} |