// Generated from grammar/Form2.g4 by ANTLR 4.2
package Form2;
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 Form2Parser extends Parser {
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__18=1, T__17=2, T__16=3, T__15=4, T__14=5, T__13=6, T__12=7, T__11=8,
T__10=9, T__9=10, T__8=11, T__7=12, T__6=13, T__5=14, T__4=15, T__3=16,
T__2=17, T__1=18, T__0=19, TYPE=20, IF=21, ELSEIF=22, ELSE=23, BOOLEAN=24,
IDENTIFIER=25, STRING=26, DEC=27, INT=28, WS=29;
public static final String[] tokenNames = {
"<INVALID>", "')'", "'+'", "'-'", "'*'", "'('", "':'", "'<'", "'!='",
"';'", "'<='", "'&&'", "'||'", "'{'", "'>'", "'/'", "'=='", "'}'", "'>='",
"'!'", "TYPE", "'if'", "'elseif'", "'else'", "BOOLEAN", "IDENTIFIER",
"STRING", "DEC", "INT", "WS"
};
public static final int
RULE_form = 0, RULE_structures = 1, RULE_structure = 2, RULE_ifcondition = 3,
RULE_elseifcondition = 4, RULE_elsecondition = 5, RULE_question = 6, RULE_expression = 7,
RULE_label = 8;
public static final String[] ruleNames = {
"form", "structures", "structure", "ifcondition", "elseifcondition", "elsecondition",
"question", "expression", "label"
};
@Override
public String getGrammarFileName() { return "Form2.g4"; }
@Override
public String[] getTokenNames() { return tokenNames; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public Form2Parser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class FormContext extends ParserRuleContext {
public StructuresContext structures() {
return getRuleContext(StructuresContext.class,0);
}
public FormContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_form; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).enterForm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).exitForm(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof Form2Visitor ) return ((Form2Visitor<? extends T>)visitor).visitForm(this);
else return visitor.visitChildren(this);
}
}
public final FormContext form() throws RecognitionException {
FormContext _localctx = new FormContext(_ctx, getState());
enterRule(_localctx, 0, RULE_form);
try {
enterOuterAlt(_localctx, 1);
{
setState(18); structures();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StructuresContext extends ParserRuleContext {
public StructureContext structure(int i) {
return getRuleContext(StructureContext.class,i);
}
public List<StructureContext> structure() {
return getRuleContexts(StructureContext.class);
}
public StructuresContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_structures; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).enterStructures(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).exitStructures(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof Form2Visitor ) return ((Form2Visitor<? extends T>)visitor).visitStructures(this);
else return visitor.visitChildren(this);
}
}
public final StructuresContext structures() throws RecognitionException {
StructuresContext _localctx = new StructuresContext(_ctx, getState());
enterRule(_localctx, 2, RULE_structures);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(21);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(20); structure();
}
}
setState(23);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==IF || _la==IDENTIFIER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StructureContext extends ParserRuleContext {
public ElseconditionContext elsecondition() {
return getRuleContext(ElseconditionContext.class,0);
}
public List<ElseifconditionContext> elseifcondition() {
return getRuleContexts(ElseifconditionContext.class);
}
public IfconditionContext ifcondition() {
return getRuleContext(IfconditionContext.class,0);
}
public ElseifconditionContext elseifcondition(int i) {
return getRuleContext(ElseifconditionContext.class,i);
}
public StructuresContext structures(int i) {
return getRuleContext(StructuresContext.class,i);
}
public QuestionContext question() {
return getRuleContext(QuestionContext.class,0);
}
public List<StructuresContext> structures() {
return getRuleContexts(StructuresContext.class);
}
public StructureContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_structure; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).enterStructure(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).exitStructure(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof Form2Visitor ) return ((Form2Visitor<? extends T>)visitor).visitStructure(this);
else return visitor.visitChildren(this);
}
}
public final StructureContext structure() throws RecognitionException {
StructureContext _localctx = new StructureContext(_ctx, getState());
enterRule(_localctx, 4, RULE_structure);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(71);
switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
case 1:
{
setState(25); question();
}
break;
case 2:
{
setState(26); ifcondition();
setState(27); match(13);
setState(28); structures();
setState(29); match(17);
setState(35);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(30); elseifcondition();
setState(31); match(13);
setState(32); structures();
setState(33); match(17);
}
}
setState(37);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==ELSEIF );
setState(39); elsecondition();
setState(40); match(13);
setState(41); structures();
setState(42); match(17);
}
break;
case 3:
{
setState(44); ifcondition();
setState(45); match(13);
setState(46); structures();
setState(47); match(17);
setState(53);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(48); elseifcondition();
setState(49); match(13);
setState(50); structures();
setState(51); match(17);
}
}
setState(55);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==ELSEIF );
}
break;
case 4:
{
setState(57); ifcondition();
setState(58); match(13);
setState(59); structures();
setState(60); match(17);
setState(61); elsecondition();
setState(62); match(13);
setState(63); structures();
setState(64); match(17);
}
break;
case 5:
{
setState(66); ifcondition();
setState(67); match(13);
setState(68); structures();
setState(69); match(17);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IfconditionContext extends ParserRuleContext {
public TerminalNode IF() { return getToken(Form2Parser.IF, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public IfconditionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ifcondition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).enterIfcondition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).exitIfcondition(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof Form2Visitor ) return ((Form2Visitor<? extends T>)visitor).visitIfcondition(this);
else return visitor.visitChildren(this);
}
}
public final IfconditionContext ifcondition() throws RecognitionException {
IfconditionContext _localctx = new IfconditionContext(_ctx, getState());
enterRule(_localctx, 6, RULE_ifcondition);
try {
enterOuterAlt(_localctx, 1);
{
setState(73); match(IF);
setState(74); expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElseifconditionContext extends ParserRuleContext {
public TerminalNode ELSEIF() { return getToken(Form2Parser.ELSEIF, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ElseifconditionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elseifcondition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).enterElseifcondition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).exitElseifcondition(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof Form2Visitor ) return ((Form2Visitor<? extends T>)visitor).visitElseifcondition(this);
else return visitor.visitChildren(this);
}
}
public final ElseifconditionContext elseifcondition() throws RecognitionException {
ElseifconditionContext _localctx = new ElseifconditionContext(_ctx, getState());
enterRule(_localctx, 8, RULE_elseifcondition);
try {
enterOuterAlt(_localctx, 1);
{
setState(76); match(ELSEIF);
setState(77); expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElseconditionContext extends ParserRuleContext {
public TerminalNode ELSE() { return getToken(Form2Parser.ELSE, 0); }
public ElseconditionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elsecondition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).enterElsecondition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).exitElsecondition(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof Form2Visitor ) return ((Form2Visitor<? extends T>)visitor).visitElsecondition(this);
else return visitor.visitChildren(this);
}
}
public final ElseconditionContext elsecondition() throws RecognitionException {
ElseconditionContext _localctx = new ElseconditionContext(_ctx, getState());
enterRule(_localctx, 10, RULE_elsecondition);
try {
enterOuterAlt(_localctx, 1);
{
setState(79); match(ELSE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QuestionContext extends ParserRuleContext {
public TerminalNode IDENTIFIER() { return getToken(Form2Parser.IDENTIFIER, 0); }
public LabelContext label() {
return getRuleContext(LabelContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode TYPE() { return getToken(Form2Parser.TYPE, 0); }
public QuestionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_question; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).enterQuestion(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).exitQuestion(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof Form2Visitor ) return ((Form2Visitor<? extends T>)visitor).visitQuestion(this);
else return visitor.visitChildren(this);
}
}
public final QuestionContext question() throws RecognitionException {
QuestionContext _localctx = new QuestionContext(_ctx, getState());
enterRule(_localctx, 12, RULE_question);
try {
setState(98);
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(81); match(IDENTIFIER);
setState(82); match(6);
setState(83); label();
setState(84); match(6);
setState(85); match(TYPE);
setState(86); match(9);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(88); match(IDENTIFIER);
setState(89); match(6);
setState(90); label();
setState(91); match(6);
setState(92); match(TYPE);
setState(93); match(5);
setState(94); expression(0);
setState(95); match(1);
setState(96); match(9);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionContext extends ParserRuleContext {
public ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
public ExpressionContext() { }
public void copyFrom(ExpressionContext ctx) {
super.copyFrom(ctx);
}
}
public static class DecExprContext extends ExpressionContext {
public TerminalNode DEC() { return getToken(Form2Parser.DEC, 0); }
public DecExprContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).enterDecExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).exitDecExpr(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof Form2Visitor ) return ((Form2Visitor<? extends T>)visitor).visitDecExpr(this);
else return visitor.visitChildren(this);
}
}
public static class MultExprContext extends ExpressionContext {
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public MultExprContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).enterMultExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).exitMultExpr(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof Form2Visitor ) return ((Form2Visitor<? extends T>)visitor).visitMultExpr(this);
else return visitor.visitChildren(this);
}
}
public static class IntExprContext extends ExpressionContext {
public TerminalNode INT() { return getToken(Form2Parser.INT, 0); }
public IntExprContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).enterIntExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).exitIntExpr(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof Form2Visitor ) return ((Form2Visitor<? extends T>)visitor).visitIntExpr(this);
else return visitor.visitChildren(this);
}
}
public static class WrapExprContext extends ExpressionContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public WrapExprContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).enterWrapExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).exitWrapExpr(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof Form2Visitor ) return ((Form2Visitor<? extends T>)visitor).visitWrapExpr(this);
else return visitor.visitChildren(this);
}
}
public static class IdentExprContext extends ExpressionContext {
public TerminalNode IDENTIFIER() { return getToken(Form2Parser.IDENTIFIER, 0); }
public IdentExprContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).enterIdentExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).exitIdentExpr(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof Form2Visitor ) return ((Form2Visitor<? extends T>)visitor).visitIdentExpr(this);
else return visitor.visitChildren(this);
}
}
public static class LogExprContext extends ExpressionContext {
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public LogExprContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).enterLogExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).exitLogExpr(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof Form2Visitor ) return ((Form2Visitor<? extends T>)visitor).visitLogExpr(this);
else return visitor.visitChildren(this);
}
}
public static class NegExprContext extends ExpressionContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public NegExprContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).enterNegExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).exitNegExpr(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof Form2Visitor ) return ((Form2Visitor<? extends T>)visitor).visitNegExpr(this);
else return visitor.visitChildren(this);
}
}
public static class BoolExprContext extends ExpressionContext {
public TerminalNode BOOLEAN() { return getToken(Form2Parser.BOOLEAN, 0); }
public BoolExprContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).enterBoolExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).exitBoolExpr(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof Form2Visitor ) return ((Form2Visitor<? extends T>)visitor).visitBoolExpr(this);
else return visitor.visitChildren(this);
}
}
public static class PlusExprContext extends ExpressionContext {
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public PlusExprContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).enterPlusExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).exitPlusExpr(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof Form2Visitor ) return ((Form2Visitor<? extends T>)visitor).visitPlusExpr(this);
else return visitor.visitChildren(this);
}
}
public static class CompExprContext extends ExpressionContext {
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public CompExprContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).enterCompExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).exitCompExpr(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof Form2Visitor ) return ((Form2Visitor<? extends T>)visitor).visitCompExpr(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
return expression(0);
}
private ExpressionContext expression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
ExpressionContext _prevctx = _localctx;
int _startState = 14;
enterRecursionRule(_localctx, 14, RULE_expression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(111);
switch (_input.LA(1)) {
case 19:
{
_localctx = new NegExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(101); match(19);
setState(102); expression(7);
}
break;
case 5:
{
_localctx = new WrapExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(103); match(5);
setState(104); expression(0);
setState(105); match(1);
}
break;
case BOOLEAN:
{
_localctx = new BoolExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(107); match(BOOLEAN);
}
break;
case DEC:
{
_localctx = new DecExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(108); match(DEC);
}
break;
case INT:
{
_localctx = new IntExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(109); match(INT);
}
break;
case IDENTIFIER:
{
_localctx = new IdentExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(110); match(IDENTIFIER);
}
break;
default:
throw new NoViableAltException(this);
}
_ctx.stop = _input.LT(-1);
setState(127);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
while ( _alt!=2 && _alt!=-1 ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(125);
switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
case 1:
{
_localctx = new MultExprContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(113);
if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
setState(114);
_la = _input.LA(1);
if ( !(_la==4 || _la==15) ) {
_errHandler.recoverInline(this);
}
consume();
setState(115); expression(10);
}
break;
case 2:
{
_localctx = new PlusExprContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(116);
if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
setState(117);
_la = _input.LA(1);
if ( !(_la==2 || _la==3) ) {
_errHandler.recoverInline(this);
}
consume();
setState(118); expression(9);
}
break;
case 3:
{
_localctx = new LogExprContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(119);
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
setState(120);
_la = _input.LA(1);
if ( !(_la==11 || _la==12) ) {
_errHandler.recoverInline(this);
}
consume();
setState(121); expression(7);
}
break;
case 4:
{
_localctx = new CompExprContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(122);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(123);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 7) | (1L << 8) | (1L << 10) | (1L << 14) | (1L << 16) | (1L << 18))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
setState(124); expression(6);
}
break;
}
}
}
setState(129);
_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 LabelContext extends ParserRuleContext {
public TerminalNode STRING() { return getToken(Form2Parser.STRING, 0); }
public LabelContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_label; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).enterLabel(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Form2Listener ) ((Form2Listener)listener).exitLabel(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof Form2Visitor ) return ((Form2Visitor<? extends T>)visitor).visitLabel(this);
else return visitor.visitChildren(this);
}
}
public final LabelContext label() throws RecognitionException {
LabelContext _localctx = new LabelContext(_ctx, getState());
enterRule(_localctx, 16, RULE_label);
try {
enterOuterAlt(_localctx, 1);
{
setState(130); match(STRING);
}
}
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 7: return expression_sempred((ExpressionContext)_localctx, predIndex);
}
return true;
}
private boolean expression_sempred(ExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 0: return precpred(_ctx, 9);
case 1: return precpred(_ctx, 8);
case 2: return precpred(_ctx, 6);
case 3: return precpred(_ctx, 5);
}
return true;
}
public static final String _serializedATN =
"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\37\u0087\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\3\2\3"+
"\2\3\3\6\3\30\n\3\r\3\16\3\31\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4"+
"\6\4&\n\4\r\4\16\4\'\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3"+
"\4\3\4\6\48\n\4\r\4\16\49\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4"+
"\3\4\3\4\3\4\5\4J\n\4\3\5\3\5\3\5\3\6\3\6\3\6\3\7\3\7\3\b\3\b\3\b\3\b"+
"\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\5\be\n\b\3\t\3\t"+
"\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\5\tr\n\t\3\t\3\t\3\t\3\t\3\t\3\t"+
"\3\t\3\t\3\t\3\t\3\t\3\t\7\t\u0080\n\t\f\t\16\t\u0083\13\t\3\n\3\n\3\n"+
"\2\3\20\13\2\4\6\b\n\f\16\20\22\2\6\4\2\6\6\21\21\3\2\4\5\3\2\r\16\7\2"+
"\t\n\f\f\20\20\22\22\24\24\u008e\2\24\3\2\2\2\4\27\3\2\2\2\6I\3\2\2\2"+
"\bK\3\2\2\2\nN\3\2\2\2\fQ\3\2\2\2\16d\3\2\2\2\20q\3\2\2\2\22\u0084\3\2"+
"\2\2\24\25\5\4\3\2\25\3\3\2\2\2\26\30\5\6\4\2\27\26\3\2\2\2\30\31\3\2"+
"\2\2\31\27\3\2\2\2\31\32\3\2\2\2\32\5\3\2\2\2\33J\5\16\b\2\34\35\5\b\5"+
"\2\35\36\7\17\2\2\36\37\5\4\3\2\37%\7\23\2\2 !\5\n\6\2!\"\7\17\2\2\"#"+
"\5\4\3\2#$\7\23\2\2$&\3\2\2\2% \3\2\2\2&\'\3\2\2\2\'%\3\2\2\2\'(\3\2\2"+
"\2()\3\2\2\2)*\5\f\7\2*+\7\17\2\2+,\5\4\3\2,-\7\23\2\2-J\3\2\2\2./\5\b"+
"\5\2/\60\7\17\2\2\60\61\5\4\3\2\61\67\7\23\2\2\62\63\5\n\6\2\63\64\7\17"+
"\2\2\64\65\5\4\3\2\65\66\7\23\2\2\668\3\2\2\2\67\62\3\2\2\289\3\2\2\2"+
"9\67\3\2\2\29:\3\2\2\2:J\3\2\2\2;<\5\b\5\2<=\7\17\2\2=>\5\4\3\2>?\7\23"+
"\2\2?@\5\f\7\2@A\7\17\2\2AB\5\4\3\2BC\7\23\2\2CJ\3\2\2\2DE\5\b\5\2EF\7"+
"\17\2\2FG\5\4\3\2GH\7\23\2\2HJ\3\2\2\2I\33\3\2\2\2I\34\3\2\2\2I.\3\2\2"+
"\2I;\3\2\2\2ID\3\2\2\2J\7\3\2\2\2KL\7\27\2\2LM\5\20\t\2M\t\3\2\2\2NO\7"+
"\30\2\2OP\5\20\t\2P\13\3\2\2\2QR\7\31\2\2R\r\3\2\2\2ST\7\33\2\2TU\7\b"+
"\2\2UV\5\22\n\2VW\7\b\2\2WX\7\26\2\2XY\7\13\2\2Ye\3\2\2\2Z[\7\33\2\2["+
"\\\7\b\2\2\\]\5\22\n\2]^\7\b\2\2^_\7\26\2\2_`\7\7\2\2`a\5\20\t\2ab\7\3"+
"\2\2bc\7\13\2\2ce\3\2\2\2dS\3\2\2\2dZ\3\2\2\2e\17\3\2\2\2fg\b\t\1\2gh"+
"\7\25\2\2hr\5\20\t\tij\7\7\2\2jk\5\20\t\2kl\7\3\2\2lr\3\2\2\2mr\7\32\2"+
"\2nr\7\35\2\2or\7\36\2\2pr\7\33\2\2qf\3\2\2\2qi\3\2\2\2qm\3\2\2\2qn\3"+
"\2\2\2qo\3\2\2\2qp\3\2\2\2r\u0081\3\2\2\2st\f\13\2\2tu\t\2\2\2u\u0080"+
"\5\20\t\fvw\f\n\2\2wx\t\3\2\2x\u0080\5\20\t\13yz\f\b\2\2z{\t\4\2\2{\u0080"+
"\5\20\t\t|}\f\7\2\2}~\t\5\2\2~\u0080\5\20\t\b\177s\3\2\2\2\177v\3\2\2"+
"\2\177y\3\2\2\2\177|\3\2\2\2\u0080\u0083\3\2\2\2\u0081\177\3\2\2\2\u0081"+
"\u0082\3\2\2\2\u0082\21\3\2\2\2\u0083\u0081\3\2\2\2\u0084\u0085\7\34\2"+
"\2\u0085\23\3\2\2\2\n\31\'9Idq\177\u0081";
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);
}
}
}