static { RuntimeMetaData.checkVersion("4.4", RuntimeMetaData.VERSION); }

protected static final DFA[] _decisionToDFA;

protected static final PredictionContextCache _sharedContextCache =

new PredictionContextCache();

public static final int

T__19=1, T__18=2, T__17=3, T__16=4, T__15=5, T__14=6, T__13=7, T__12=8,

T__11=9, T__10=10, T__9=11, T__8=12, T__7=13, T__6=14, T__5=15, T__4=16,

T__3=17, T__2=18, T__1=19, T__0=20, AND=21, LT=22, PLUS=23, MINUS=24,

TIMES=25, POWER=26, NOT=27, LSB=28, RSB=29, DOTLENGTH=30, LP=31, RP=32,

RETURN=33, EQ=34, BooleanLiteral=35, Identifier=36, IntegerLiteral=37,

WS=38, MULTILINE_COMMENT=39, LINE_COMMENT=40;

public static final String[] tokenNames = {

"<INVALID>", "'System.out.println'", "'public'", "'.'", "','", "'while'",

"'if'", "'int'", "'main'", "'String'", "';'", "'void'", "'this'", "'{'",

"'extends'", "'new'", "'else'", "'}'", "'class'", "'boolean'", "'static'",

"'&&'", "'<'", "'+'", "'-'", "'*'", "'**'", "'!'", "'['", "']'", "'.length'",

"'('", "')'", "'return'", "'='", "BooleanLiteral", "Identifier", "IntegerLiteral",

"WS", "MULTILINE_COMMENT", "LINE_COMMENT"

};

public static final int

RULE_goal = 0, RULE_mainClass = 1, RULE_classDeclaration = 2, RULE_fieldDeclaration = 3,

RULE_localDeclaration = 4, RULE_varDeclaration = 5, RULE_methodDeclaration = 6,

RULE_parameterList = 7, RULE_parameter = 8, RULE_methodBody = 9, RULE_type = 10,

RULE_statement = 11, RULE_ifBlock = 12, RULE_elseBlock = 13, RULE_whileBlock = 14,

RULE_expression = 15;

public static final String[] ruleNames = {

"goal", "mainClass", "classDeclaration", "fieldDeclaration", "localDeclaration",

"varDeclaration", "methodDeclaration", "parameterList", "parameter", "methodBody",

"type", "statement", "ifBlock", "elseBlock", "whileBlock", "expression"

};

@Override

public String getGrammarFileName() { return "Minijava.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 MinijavaParser(TokenStream input) {

super(input);

_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);

}

public static class GoalContext extends ParserRuleContext {

public MainClassContext mainClass() {

return getRuleContext(MainClassContext.class,0);

}

public ClassDeclarationContext classDeclaration(int i) {

return getRuleContext(ClassDeclarationContext.class,i);

}

public TerminalNode EOF() { return getToken(MinijavaParser.EOF, 0); }

public List<ClassDeclarationContext> classDeclaration() {

return getRuleContexts(ClassDeclarationContext.class);

}

public GoalContext(ParserRuleContext parent, int invokingState) {

super(parent, invokingState);

}

@Override public int getRuleIndex() { return RULE_goal; }

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).enterGoal(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).exitGoal(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof MinijavaVisitor ) return ((MinijavaVisitor<? extends T>)visitor).visitGoal(this);

else return visitor.visitChildren(this);

}

}

public final GoalContext goal() throws RecognitionException {

GoalContext _localctx = new GoalContext(_ctx, getState());

enterRule(_localctx, 0, RULE_goal);

int _la;

try {

enterOuterAlt(_localctx, 1);

{

setState(32); mainClass();

setState(36);

_errHandler.sync(this);

_la = _input.LA(1);

while (_la==T__2) {

{

{

setState(33); classDeclaration();

}

}

setState(38);

_errHandler.sync(this);

_la = _input.LA(1);

}

setState(39); match(EOF);

}

}

catch (RecognitionException re) {

_localctx.exception = re;

_errHandler.reportError(this, re);

_errHandler.recover(this, re);

}

finally {

exitRule();

}

return _localctx;

}

public static class MainClassContext extends ParserRuleContext {

public StatementContext statement() {

return getRuleContext(StatementContext.class,0);

}

public TerminalNode Identifier(int i) {

return getToken(MinijavaParser.Identifier, i);

}

public List<TerminalNode> Identifier() { return getTokens(MinijavaParser.Identifier); }

public MainClassContext(ParserRuleContext parent, int invokingState) {

super(parent, invokingState);

}

@Override public int getRuleIndex() { return RULE_mainClass; }

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).enterMainClass(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).exitMainClass(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof MinijavaVisitor ) return ((MinijavaVisitor<? extends T>)visitor).visitMainClass(this);

else return visitor.visitChildren(this);

}

}

public final MainClassContext mainClass() throws RecognitionException {

MainClassContext _localctx = new MainClassContext(_ctx, getState());

enterRule(_localctx, 2, RULE_mainClass);

try {

enterOuterAlt(_localctx, 1);

{

setState(41); match(T__2);

setState(42); match(Identifier);

setState(43); match(T__7);

setState(44); match(T__18);

setState(45); match(T__0);

setState(46); match(T__9);

setState(47); match(T__12);

setState(48); match(LP);

setState(49); match(T__11);

setState(50); match(LSB);

setState(51); match(RSB);

setState(52); match(Identifier);

setState(53); match(RP);

setState(54); match(T__7);

setState(55); statement();

setState(56); match(T__3);

setState(57); match(T__3);

}

}

catch (RecognitionException re) {

_localctx.exception = re;

_errHandler.reportError(this, re);

_errHandler.recover(this, re);

}

finally {

exitRule();

}

return _localctx;

}

public static class ClassDeclarationContext extends ParserRuleContext {

public MethodDeclarationContext methodDeclaration(int i) {

return getRuleContext(MethodDeclarationContext.class,i);

}

public TerminalNode Identifier(int i) {

return getToken(MinijavaParser.Identifier, i);

}

public List<TerminalNode> Identifier() { return getTokens(MinijavaParser.Identifier); }

public List<FieldDeclarationContext> fieldDeclaration() {

return getRuleContexts(FieldDeclarationContext.class);

}

public List<MethodDeclarationContext> methodDeclaration() {

return getRuleContexts(MethodDeclarationContext.class);

}

public FieldDeclarationContext fieldDeclaration(int i) {

return getRuleContext(FieldDeclarationContext.class,i);

}

public ClassDeclarationContext(ParserRuleContext parent, int invokingState) {

super(parent, invokingState);

}

@Override public int getRuleIndex() { return RULE_classDeclaration; }

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).enterClassDeclaration(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).exitClassDeclaration(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof MinijavaVisitor ) return ((MinijavaVisitor<? extends T>)visitor).visitClassDeclaration(this);

else return visitor.visitChildren(this);

}

}

public final ClassDeclarationContext classDeclaration() throws RecognitionException {

ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState());

enterRule(_localctx, 4, RULE_classDeclaration);

int _la;

try {

enterOuterAlt(_localctx, 1);

{

setState(59); match(T__2);

setState(60); match(Identifier);

setState(63);

_la = _input.LA(1);

if (_la==T__6) {

{

setState(61); match(T__6);

setState(62); match(Identifier);

}

}

setState(65); match(T__7);

setState(69);

_errHandler.sync(this);

_la = _input.LA(1);

while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__13) | (1L << T__1) | (1L << Identifier))) != 0)) {

{

{

setState(66); fieldDeclaration();

}

}

setState(71);

_errHandler.sync(this);

_la = _input.LA(1);

}

setState(75);

_errHandler.sync(this);

_la = _input.LA(1);

while (_la==T__18) {

{

{

setState(72); methodDeclaration();

}

}

setState(77);

_errHandler.sync(this);

_la = _input.LA(1);

}

setState(78); match(T__3);

}

}

catch (RecognitionException re) {

_localctx.exception = re;

_errHandler.reportError(this, re);

_errHandler.recover(this, re);

}

finally {

exitRule();

}

return _localctx;

}

public static class FieldDeclarationContext extends ParserRuleContext {

public VarDeclarationContext varDeclaration() {

return getRuleContext(VarDeclarationContext.class,0);

}

public FieldDeclarationContext(ParserRuleContext parent, int invokingState) {

super(parent, invokingState);

}

@Override public int getRuleIndex() { return RULE_fieldDeclaration; }

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).enterFieldDeclaration(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).exitFieldDeclaration(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof MinijavaVisitor ) return ((MinijavaVisitor<? extends T>)visitor).visitFieldDeclaration(this);

else return visitor.visitChildren(this);

}

}

public final FieldDeclarationContext fieldDeclaration() throws RecognitionException {

FieldDeclarationContext _localctx = new FieldDeclarationContext(_ctx, getState());

enterRule(_localctx, 6, RULE_fieldDeclaration);

try {

enterOuterAlt(_localctx, 1);

{

setState(80); varDeclaration();

}

}

catch (RecognitionException re) {

_localctx.exception = re;

_errHandler.reportError(this, re);

_errHandler.recover(this, re);

}

finally {

exitRule();

}

return _localctx;

}

public static class LocalDeclarationContext extends ParserRuleContext {

public VarDeclarationContext varDeclaration() {

return getRuleContext(VarDeclarationContext.class,0);

}

public LocalDeclarationContext(ParserRuleContext parent, int invokingState) {

super(parent, invokingState);

}

@Override public int getRuleIndex() { return RULE_localDeclaration; }

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).enterLocalDeclaration(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).exitLocalDeclaration(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof MinijavaVisitor ) return ((MinijavaVisitor<? extends T>)visitor).visitLocalDeclaration(this);

else return visitor.visitChildren(this);

}

}

public final LocalDeclarationContext localDeclaration() throws RecognitionException {

LocalDeclarationContext _localctx = new LocalDeclarationContext(_ctx, getState());

enterRule(_localctx, 8, RULE_localDeclaration);

try {

enterOuterAlt(_localctx, 1);

{

setState(82); varDeclaration();

}

}

catch (RecognitionException re) {

_localctx.exception = re;

_errHandler.reportError(this, re);

_errHandler.recover(this, re);

}

finally {

exitRule();

}

return _localctx;

}

public static class VarDeclarationContext extends ParserRuleContext {

public TerminalNode Identifier() { return getToken(MinijavaParser.Identifier, 0); }

public TypeContext type() {

return getRuleContext(TypeContext.class,0);

}

public VarDeclarationContext(ParserRuleContext parent, int invokingState) {

super(parent, invokingState);

}

@Override public int getRuleIndex() { return RULE_varDeclaration; }

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).enterVarDeclaration(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).exitVarDeclaration(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof MinijavaVisitor ) return ((MinijavaVisitor<? extends T>)visitor).visitVarDeclaration(this);

else return visitor.visitChildren(this);

}

}

public final VarDeclarationContext varDeclaration() throws RecognitionException {

VarDeclarationContext _localctx = new VarDeclarationContext(_ctx, getState());

enterRule(_localctx, 10, RULE_varDeclaration);

try {

enterOuterAlt(_localctx, 1);

{

setState(84); type();

setState(85); match(Identifier);

setState(86); match(T__10);

}

}

catch (RecognitionException re) {

_localctx.exception = re;

_errHandler.reportError(this, re);

_errHandler.recover(this, re);

}

finally {

exitRule();

}

return _localctx;

}

public static class MethodDeclarationContext extends ParserRuleContext {

public MethodBodyContext methodBody() {

return getRuleContext(MethodBodyContext.class,0);

}

public TerminalNode Identifier() { return getToken(MinijavaParser.Identifier, 0); }

public TypeContext type() {

return getRuleContext(TypeContext.class,0);

}

public ParameterListContext parameterList() {

return getRuleContext(ParameterListContext.class,0);

}

public MethodDeclarationContext(ParserRuleContext parent, int invokingState) {

super(parent, invokingState);

}

@Override public int getRuleIndex() { return RULE_methodDeclaration; }

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).enterMethodDeclaration(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).exitMethodDeclaration(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof MinijavaVisitor ) return ((MinijavaVisitor<? extends T>)visitor).visitMethodDeclaration(this);

else return visitor.visitChildren(this);

}

}

public final MethodDeclarationContext methodDeclaration() throws RecognitionException {

MethodDeclarationContext _localctx = new MethodDeclarationContext(_ctx, getState());

enterRule(_localctx, 12, RULE_methodDeclaration);

int _la;

try {

enterOuterAlt(_localctx, 1);

{

setState(88); match(T__18);

setState(89); type();

setState(90); match(Identifier);

setState(91); match(LP);

setState(93);

_la = _input.LA(1);

if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__13) | (1L << T__1) | (1L << Identifier))) != 0)) {

{

setState(92); parameterList();

}

}

setState(95); match(RP);

setState(96); match(T__7);

setState(97); methodBody();

setState(98); match(T__3);

}

}

catch (RecognitionException re) {

_localctx.exception = re;

_errHandler.reportError(this, re);

_errHandler.recover(this, re);

}

finally {

exitRule();

}

return _localctx;

}

public static class ParameterListContext extends ParserRuleContext {

public List<ParameterContext> parameter() {

return getRuleContexts(ParameterContext.class);

}

public ParameterContext parameter(int i) {

return getRuleContext(ParameterContext.class,i);

}

public ParameterListContext(ParserRuleContext parent, int invokingState) {

super(parent, invokingState);

}

@Override public int getRuleIndex() { return RULE_parameterList; }

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).enterParameterList(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).exitParameterList(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof MinijavaVisitor ) return ((MinijavaVisitor<? extends T>)visitor).visitParameterList(this);

else return visitor.visitChildren(this);

}

}

public final ParameterListContext parameterList() throws RecognitionException {

ParameterListContext _localctx = new ParameterListContext(_ctx, getState());

enterRule(_localctx, 14, RULE_parameterList);

int _la;

try {

enterOuterAlt(_localctx, 1);

{

setState(100); parameter();

setState(105);

_errHandler.sync(this);

_la = _input.LA(1);

while (_la==T__16) {

{

{

setState(101); match(T__16);

setState(102); parameter();

}

}

setState(107);

_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 ParameterContext extends ParserRuleContext {

public TerminalNode Identifier() { return getToken(MinijavaParser.Identifier, 0); }

public TypeContext type() {

return getRuleContext(TypeContext.class,0);

}

public ParameterContext(ParserRuleContext parent, int invokingState) {

super(parent, invokingState);

}

@Override public int getRuleIndex() { return RULE_parameter; }

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).enterParameter(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).exitParameter(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof MinijavaVisitor ) return ((MinijavaVisitor<? extends T>)visitor).visitParameter(this);

else return visitor.visitChildren(this);

}

}

public final ParameterContext parameter() throws RecognitionException {

ParameterContext _localctx = new ParameterContext(_ctx, getState());

enterRule(_localctx, 16, RULE_parameter);

try {

enterOuterAlt(_localctx, 1);

{

setState(108); type();

setState(109); match(Identifier);

}

}

catch (RecognitionException re) {

_localctx.exception = re;

_errHandler.reportError(this, re);

_errHandler.recover(this, re);

}

finally {

exitRule();

}

return _localctx;

}

public static class MethodBodyContext extends ParserRuleContext {

public List<StatementContext> statement() {

return getRuleContexts(StatementContext.class);

}

public TerminalNode RETURN() { return getToken(MinijavaParser.RETURN, 0); }

public LocalDeclarationContext localDeclaration(int i) {

return getRuleContext(LocalDeclarationContext.class,i);

}

public ExpressionContext expression() {

return getRuleContext(ExpressionContext.class,0);

}

public StatementContext statement(int i) {

return getRuleContext(StatementContext.class,i);

}

public List<LocalDeclarationContext> localDeclaration() {

return getRuleContexts(LocalDeclarationContext.class);

}

public MethodBodyContext(ParserRuleContext parent, int invokingState) {

super(parent, invokingState);

}

@Override public int getRuleIndex() { return RULE_methodBody; }

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).enterMethodBody(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).exitMethodBody(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof MinijavaVisitor ) return ((MinijavaVisitor<? extends T>)visitor).visitMethodBody(this);

else return visitor.visitChildren(this);

}

}

public final MethodBodyContext methodBody() throws RecognitionException {

MethodBodyContext _localctx = new MethodBodyContext(_ctx, getState());

enterRule(_localctx, 18, RULE_methodBody);

int _la;

try {

int _alt;

enterOuterAlt(_localctx, 1);

{

setState(114);

_errHandler.sync(this);

_alt = getInterpreter().adaptivePredict(_input,6,_ctx);

while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {

if ( _alt==1 ) {

{

{

setState(111); localDeclaration();

}

}

}

setState(116);

_errHandler.sync(this);

_alt = getInterpreter().adaptivePredict(_input,6,_ctx);

}

setState(120);

_errHandler.sync(this);

_la = _input.LA(1);

while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__19) | (1L << T__15) | (1L << T__14) | (1L << T__7) | (1L << Identifier))) != 0)) {

{

{

setState(117); statement();

}

}

setState(122);

_errHandler.sync(this);

_la = _input.LA(1);

}

setState(123); match(RETURN);

setState(124); expression(0);

setState(125); match(T__10);

}

}

catch (RecognitionException re) {

_localctx.exception = re;

_errHandler.reportError(this, re);

_errHandler.recover(this, re);

}

finally {

exitRule();

}

return _localctx;

}

public static class TypeContext extends ParserRuleContext {

public TerminalNode Identifier() { return getToken(MinijavaParser.Identifier, 0); }

public TypeContext(ParserRuleContext parent, int invokingState) {

super(parent, invokingState);

}

@Override public int getRuleIndex() { return RULE_type; }

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).enterType(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).exitType(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof MinijavaVisitor ) return ((MinijavaVisitor<? extends T>)visitor).visitType(this);

else return visitor.visitChildren(this);

}

}

public final TypeContext type() throws RecognitionException {

TypeContext _localctx = new TypeContext(_ctx, getState());

enterRule(_localctx, 20, RULE_type);

try {

setState(133);

switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {

case 1:

enterOuterAlt(_localctx, 1);

{

setState(127); match(T__13);

setState(128); match(LSB);

setState(129); match(RSB);

}

break;

case 2:

enterOuterAlt(_localctx, 2);

{

setState(130); match(T__1);

}

break;

case 3:

enterOuterAlt(_localctx, 3);

{

setState(131); match(T__13);

}

break;

case 4:

enterOuterAlt(_localctx, 4);

{

setState(132); match(Identifier);

}

break;

}

}

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 StatementContext(ParserRuleContext parent, int invokingState) {

super(parent, invokingState);

}

@Override public int getRuleIndex() { return RULE_statement; }

public StatementContext() { }

public void copyFrom(StatementContext ctx) {

super.copyFrom(ctx);

}

}

public static class VariableAssignmentStatementContext extends StatementContext {

public TerminalNode Identifier() { return getToken(MinijavaParser.Identifier, 0); }

public ExpressionContext expression() {

return getRuleContext(ExpressionContext.class,0);

}

public TerminalNode EQ() { return getToken(MinijavaParser.EQ, 0); }

public VariableAssignmentStatementContext(StatementContext ctx) { copyFrom(ctx); }

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).enterVariableAssignmentStatement(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).exitVariableAssignmentStatement(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof MinijavaVisitor ) return ((MinijavaVisitor<? extends T>)visitor).visitVariableAssignmentStatement(this);

else return visitor.visitChildren(this);

}

}

public static class WhileStatementContext extends StatementContext {

public WhileBlockContext whileBlock() {

return getRuleContext(WhileBlockContext.class,0);

}

public TerminalNode LP() { return getToken(MinijavaParser.LP, 0); }

public TerminalNode RP() { return getToken(MinijavaParser.RP, 0); }

public ExpressionContext expression() {

return getRuleContext(ExpressionContext.class,0);

}

public WhileStatementContext(StatementContext ctx) { copyFrom(ctx); }

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).enterWhileStatement(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).exitWhileStatement(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof MinijavaVisitor ) return ((MinijavaVisitor<? extends T>)visitor).visitWhileStatement(this);

else return visitor.visitChildren(this);

}

}

public static class NestedStatementContext extends StatementContext {

public List<StatementContext> statement() {

return getRuleContexts(StatementContext.class);

}

public StatementContext statement(int i) {

return getRuleContext(StatementContext.class,i);

}

public NestedStatementContext(StatementContext ctx) { copyFrom(ctx); }

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).enterNestedStatement(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).exitNestedStatement(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof MinijavaVisitor ) return ((MinijavaVisitor<? extends T>)visitor).visitNestedStatement(this);

else return visitor.visitChildren(this);

}

}

public static class ArrayAssignmentStatementContext extends StatementContext {

public ExpressionContext expression(int i) {

return getRuleContext(ExpressionContext.class,i);

}

public TerminalNode RSB() { return getToken(MinijavaParser.RSB, 0); }

public TerminalNode Identifier() { return getToken(MinijavaParser.Identifier, 0); }

public List<ExpressionContext> expression() {

return getRuleContexts(ExpressionContext.class);

}

public TerminalNode LSB() { return getToken(MinijavaParser.LSB, 0); }

public TerminalNode EQ() { return getToken(MinijavaParser.EQ, 0); }

public ArrayAssignmentStatementContext(StatementContext ctx) { copyFrom(ctx); }

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).enterArrayAssignmentStatement(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).exitArrayAssignmentStatement(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof MinijavaVisitor ) return ((MinijavaVisitor<? extends T>)visitor).visitArrayAssignmentStatement(this);

else return visitor.visitChildren(this);

}

}

public static class IfElseStatementContext extends StatementContext {

public TerminalNode LP() { return getToken(MinijavaParser.LP, 0); }

public TerminalNode RP() { return getToken(MinijavaParser.RP, 0); }

public ExpressionContext expression() {

return getRuleContext(ExpressionContext.class,0);

}

public ElseBlockContext elseBlock() {

return getRuleContext(ElseBlockContext.class,0);

}

public IfBlockContext ifBlock() {

return getRuleContext(IfBlockContext.class,0);

}

public IfElseStatementContext(StatementContext ctx) { copyFrom(ctx); }

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).enterIfElseStatement(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).exitIfElseStatement(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof MinijavaVisitor ) return ((MinijavaVisitor<? extends T>)visitor).visitIfElseStatement(this);

else return visitor.visitChildren(this);

}

}

public static class PrintStatementContext extends StatementContext {

public TerminalNode LP() { return getToken(MinijavaParser.LP, 0); }

public TerminalNode RP() { return getToken(MinijavaParser.RP, 0); }

public ExpressionContext expression() {

return getRuleContext(ExpressionContext.class,0);

}

public PrintStatementContext(StatementContext ctx) { copyFrom(ctx); }

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).enterPrintStatement(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof MinijavaListener ) ((MinijavaListener)listener).exitPrintStatement(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof MinijavaVisitor ) return ((MinijavaVisitor<? extends T>)visitor).visitPrintStatement(this);

else return visitor.visitChildren(this);

}

}

public final StatementContext statement() throws RecognitionException {

StatementContext _localctx = new StatementContext(_ctx, getState());

enterRule(_localctx, 22, RULE_statement);

int _la;

try {

setState(176);

switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {

case 1:

_localctx = new NestedStatementContext(_localctx);

enterOuterAlt(_localctx, 1);

{

setState(135); match(T__7);

setState(139);

_errHandler.sync(this);

_la = _input.LA(1);

while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__19) | (1L << T__15) | (1L << T__14) | (1L << T__7) | (1L << Identifier))) != 0)) {

{

{

setState(136); statement();

}

}

setState(141);

_errHandler.sync(this);

_la = _input.LA(1);

}

setState(142); match(T__3);

}

break;

case 2:

_localctx = new IfElseStatementContext(_localctx);

enterOuterAlt(_localctx, 2);

{

setState(143); match(T__14);

setState(144); match(LP);

setState(145); expression(0);

setState(146); match(RP);

setState(147); ifBlock();

setState(148); match(T__4);

setState(149); elseBlock();

}

break;

case 3:

_localctx = new WhileStatementContext(_localctx);

enterOuterAlt(_localctx, 3);

{

setState(151); match(T__15);

setState(152); match(LP);

setState(153); expression(0);

setState(154); match(RP);

setState(155); whileBlock();

}

break;

case 4:

_localctx = new PrintStatementContext(_localctx);

enterOuterAlt(_localctx, 4);

{

setState(157); match(T__19);

setState(158); match(LP);

setState(159); expression(0);

setState(160); match(RP);

setState(161); match(T__10);

}

break;

case 5:

_localctx = new VariableAssignmentStatementContext(_localctx);

enterOuterAlt(_localctx, 5);

{

setState(163); match(Identifier);

setState(164); match(EQ);

setState(165); expression(0);

setState(166); match(T__10);

}

break;

case 6:

_localctx = new ArrayAssignmentStatementContext(_localctx);

enterOuterAlt(_localctx, 6);

{

setState(168); match(Identifier);

setState(169); match(LSB);

setState(170); expression(0);

setState(171); match(RSB);

setState(172); match(EQ);

setState(173); expression(0);

setState(174); match(T__10);

}

break;

}

}

catch (RecognitionException re) {

_localctx.exception = re;

_errHandler.reportError(this, re);

_errHandler.recover(this, re);

}

finally {

exitRule();

}

return _localctx;

}

public static class IfBlockContext extends ParserRuleContext {

public StatementContext statement() {

return getRuleContext(StatementContext.class,0);

}