851 lines
29 KiB
Java
851 lines
29 KiB
Java
// Generated from c:/Users/Thibaut/Documents/Git/PDS/tp2-vsl-pds/src/main/antlr/VSLParser.g by ANTLR 4.13.1
|
|
|
|
package TP2;
|
|
import TP2.asd.Program.*;
|
|
import TP2.asd.*;
|
|
import TP2.asd.Interface.*;
|
|
|
|
import org.antlr.v4.runtime.atn.*;
|
|
import org.antlr.v4.runtime.dfa.DFA;
|
|
import org.antlr.v4.runtime.*;
|
|
import org.antlr.v4.runtime.misc.*;
|
|
import org.antlr.v4.runtime.tree.*;
|
|
import java.util.List;
|
|
import java.util.Iterator;
|
|
import java.util.ArrayList;
|
|
|
|
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"})
|
|
public class VSLParser extends Parser {
|
|
static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); }
|
|
|
|
protected static final DFA[] _decisionToDFA;
|
|
protected static final PredictionContextCache _sharedContextCache =
|
|
new PredictionContextCache();
|
|
public static final int
|
|
FUNCTION=1, PROTOTYPE=2, TYPE_INT=3, TYPE_VOID=4, LE=5, LT=6, GE=7, GT=8,
|
|
ASSIGN=9, IF=10, THEN=11, ELSE=12, FIN=13, WHILE=14, DO=15, DONE=16, READ=17,
|
|
PRINT=18, RETURN=19, TEXT=20, NUMBER=21, ParO=22, ParF=23, PLUS=24, MINUS=25,
|
|
DIV=26, TIMES=27, MOD=28, IDENT=29, WS=30, COMMENT=31;
|
|
public static final int
|
|
RULE_program = 0, RULE_function = 1, RULE_prototype = 2, RULE_list_instr = 3,
|
|
RULE_instruction = 4, RULE_expression = 5, RULE_td_expression = 6, RULE_lit = 7,
|
|
RULE_ident = 8, RULE_type = 9;
|
|
private static String[] makeRuleNames() {
|
|
return new String[] {
|
|
"program", "function", "prototype", "list_instr", "instruction", "expression",
|
|
"td_expression", "lit", "ident", "type"
|
|
};
|
|
}
|
|
public static final String[] ruleNames = makeRuleNames();
|
|
|
|
private static String[] makeLiteralNames() {
|
|
return new String[] {
|
|
null, "'FUNC'", "'PROTO'", "'INT'", "'VOID'", "'<='", "'<'", "'>='",
|
|
"'>'", "':='", "'IF'", "'THEN'", "'ELSE'", "'FI'", "'WHILE'", "'DO'",
|
|
"'DONE'", "'READ'", "'PRINT'", "'RETURN'", null, null, "'('", "')'",
|
|
"'+'", "'-'", "'/'", "'*'", "'%'"
|
|
};
|
|
}
|
|
private static final String[] _LITERAL_NAMES = makeLiteralNames();
|
|
private static String[] makeSymbolicNames() {
|
|
return new String[] {
|
|
null, "FUNCTION", "PROTOTYPE", "TYPE_INT", "TYPE_VOID", "LE", "LT", "GE",
|
|
"GT", "ASSIGN", "IF", "THEN", "ELSE", "FIN", "WHILE", "DO", "DONE", "READ",
|
|
"PRINT", "RETURN", "TEXT", "NUMBER", "ParO", "ParF", "PLUS", "MINUS",
|
|
"DIV", "TIMES", "MOD", "IDENT", "WS", "COMMENT"
|
|
};
|
|
}
|
|
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
|
|
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
|
|
|
|
/**
|
|
* @deprecated Use {@link #VOCABULARY} instead.
|
|
*/
|
|
@Deprecated
|
|
public static final String[] tokenNames;
|
|
static {
|
|
tokenNames = new String[_SYMBOLIC_NAMES.length];
|
|
for (int i = 0; i < tokenNames.length; i++) {
|
|
tokenNames[i] = VOCABULARY.getLiteralName(i);
|
|
if (tokenNames[i] == null) {
|
|
tokenNames[i] = VOCABULARY.getSymbolicName(i);
|
|
}
|
|
|
|
if (tokenNames[i] == null) {
|
|
tokenNames[i] = "<INVALID>";
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
@Deprecated
|
|
public String[] getTokenNames() {
|
|
return tokenNames;
|
|
}
|
|
|
|
@Override
|
|
|
|
public Vocabulary getVocabulary() {
|
|
return VOCABULARY;
|
|
}
|
|
|
|
@Override
|
|
public String getGrammarFileName() { return "VSLParser.g"; }
|
|
|
|
@Override
|
|
public String[] getRuleNames() { return ruleNames; }
|
|
|
|
@Override
|
|
public String getSerializedATN() { return _serializedATN; }
|
|
|
|
@Override
|
|
public ATN getATN() { return _ATN; }
|
|
|
|
public VSLParser(TokenStream input) {
|
|
super(input);
|
|
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ProgramContext extends ParserRuleContext {
|
|
public ProgramImp p;
|
|
public FunctionContext func;
|
|
public TerminalNode EOF() { return getToken(VSLParser.EOF, 0); }
|
|
public FunctionContext function() {
|
|
return getRuleContext(FunctionContext.class,0);
|
|
}
|
|
public ProgramContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_program; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof VSLParserListener ) ((VSLParserListener)listener).enterProgram(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof VSLParserListener ) ((VSLParserListener)listener).exitProgram(this);
|
|
}
|
|
}
|
|
|
|
public final ProgramContext program() throws RecognitionException {
|
|
ProgramContext _localctx = new ProgramContext(_ctx, getState());
|
|
enterRule(_localctx, 0, RULE_program);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(20);
|
|
((ProgramContext)_localctx).func = function();
|
|
setState(21);
|
|
match(EOF);
|
|
((ProgramContext)_localctx).p = new ProgramImp(((ProgramContext)_localctx).func.out);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FunctionContext extends ParserRuleContext {
|
|
public ArrayList<Function> out;
|
|
public TypeContext t;
|
|
public IdentContext i;
|
|
public List_instrContext instrs;
|
|
public List<TerminalNode> FUNCTION() { return getTokens(VSLParser.FUNCTION); }
|
|
public TerminalNode FUNCTION(int i) {
|
|
return getToken(VSLParser.FUNCTION, i);
|
|
}
|
|
public List<TerminalNode> ParO() { return getTokens(VSLParser.ParO); }
|
|
public TerminalNode ParO(int i) {
|
|
return getToken(VSLParser.ParO, i);
|
|
}
|
|
public List<TerminalNode> ParF() { return getTokens(VSLParser.ParF); }
|
|
public TerminalNode ParF(int i) {
|
|
return getToken(VSLParser.ParF, i);
|
|
}
|
|
public List<TypeContext> type() {
|
|
return getRuleContexts(TypeContext.class);
|
|
}
|
|
public TypeContext type(int i) {
|
|
return getRuleContext(TypeContext.class,i);
|
|
}
|
|
public List<IdentContext> ident() {
|
|
return getRuleContexts(IdentContext.class);
|
|
}
|
|
public IdentContext ident(int i) {
|
|
return getRuleContext(IdentContext.class,i);
|
|
}
|
|
public List<List_instrContext> list_instr() {
|
|
return getRuleContexts(List_instrContext.class);
|
|
}
|
|
public List_instrContext list_instr(int i) {
|
|
return getRuleContext(List_instrContext.class,i);
|
|
}
|
|
public FunctionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_function; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof VSLParserListener ) ((VSLParserListener)listener).enterFunction(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof VSLParserListener ) ((VSLParserListener)listener).exitFunction(this);
|
|
}
|
|
}
|
|
|
|
public final FunctionContext function() throws RecognitionException {
|
|
FunctionContext _localctx = new FunctionContext(_ctx, getState());
|
|
enterRule(_localctx, 2, RULE_function);
|
|
|
|
SymTable sym_table = new SymTable();
|
|
((FunctionContext)_localctx).out = new ArrayList<Function>();
|
|
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(34);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==FUNCTION) {
|
|
{
|
|
{
|
|
setState(24);
|
|
match(FUNCTION);
|
|
setState(25);
|
|
((FunctionContext)_localctx).t = type();
|
|
setState(26);
|
|
((FunctionContext)_localctx).i = ident();
|
|
setState(27);
|
|
match(ParO);
|
|
setState(28);
|
|
match(ParF);
|
|
setState(29);
|
|
((FunctionContext)_localctx).instrs = list_instr(sym_table);
|
|
|
|
_localctx.out.add(new FunctionImp(((FunctionContext)_localctx).t.return_type, ((FunctionContext)_localctx).i.out, ((FunctionContext)_localctx).instrs.out));
|
|
|
|
}
|
|
}
|
|
setState(36);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrototypeContext extends ParserRuleContext {
|
|
public Program p;
|
|
public PrototypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_prototype; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof VSLParserListener ) ((VSLParserListener)listener).enterPrototype(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof VSLParserListener ) ((VSLParserListener)listener).exitPrototype(this);
|
|
}
|
|
}
|
|
|
|
public final PrototypeContext prototype() throws RecognitionException {
|
|
PrototypeContext _localctx = new PrototypeContext(_ctx, getState());
|
|
enterRule(_localctx, 4, RULE_prototype);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class List_instrContext extends ParserRuleContext {
|
|
public SymTable table;
|
|
public ArrayList<Instruction> out;
|
|
public InstructionContext instruction;
|
|
public List<InstructionContext> instruction() {
|
|
return getRuleContexts(InstructionContext.class);
|
|
}
|
|
public InstructionContext instruction(int i) {
|
|
return getRuleContext(InstructionContext.class,i);
|
|
}
|
|
public List_instrContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
|
|
public List_instrContext(ParserRuleContext parent, int invokingState, SymTable table) {
|
|
super(parent, invokingState);
|
|
this.table = table;
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_list_instr; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof VSLParserListener ) ((VSLParserListener)listener).enterList_instr(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof VSLParserListener ) ((VSLParserListener)listener).exitList_instr(this);
|
|
}
|
|
}
|
|
|
|
public final List_instrContext list_instr(SymTable table) throws RecognitionException {
|
|
List_instrContext _localctx = new List_instrContext(_ctx, getState(), table);
|
|
enterRule(_localctx, 6, RULE_list_instr);
|
|
|
|
((List_instrContext)_localctx).out = new ArrayList<>();
|
|
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(42);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
setState(39);
|
|
((List_instrContext)_localctx).instruction = instruction(table);
|
|
|
|
_localctx.out.add(((List_instrContext)_localctx).instruction.out);
|
|
|
|
}
|
|
}
|
|
setState(44);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
} while ( _la==RETURN );
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class InstructionContext extends ParserRuleContext {
|
|
public SymTable table;
|
|
public Instruction out;
|
|
public ExpressionContext e;
|
|
public TerminalNode RETURN() { return getToken(VSLParser.RETURN, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public InstructionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
|
|
public InstructionContext(ParserRuleContext parent, int invokingState, SymTable table) {
|
|
super(parent, invokingState);
|
|
this.table = table;
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_instruction; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof VSLParserListener ) ((VSLParserListener)listener).enterInstruction(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof VSLParserListener ) ((VSLParserListener)listener).exitInstruction(this);
|
|
}
|
|
}
|
|
|
|
public final InstructionContext instruction(SymTable table) throws RecognitionException {
|
|
InstructionContext _localctx = new InstructionContext(_ctx, getState(), table);
|
|
enterRule(_localctx, 8, RULE_instruction);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(46);
|
|
match(RETURN);
|
|
setState(47);
|
|
((InstructionContext)_localctx).e = expression(table);
|
|
|
|
((InstructionContext)_localctx).out = new Return_instrImp(((InstructionContext)_localctx).e.out);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ExpressionContext extends ParserRuleContext {
|
|
public SymTable table;
|
|
public Type return_Type;
|
|
public Expression out;
|
|
public Td_expressionContext left;
|
|
public Token op;
|
|
public Td_expressionContext right;
|
|
public List<Td_expressionContext> td_expression() {
|
|
return getRuleContexts(Td_expressionContext.class);
|
|
}
|
|
public Td_expressionContext td_expression(int i) {
|
|
return getRuleContext(Td_expressionContext.class,i);
|
|
}
|
|
public List<TerminalNode> PLUS() { return getTokens(VSLParser.PLUS); }
|
|
public TerminalNode PLUS(int i) {
|
|
return getToken(VSLParser.PLUS, i);
|
|
}
|
|
public List<TerminalNode> MINUS() { return getTokens(VSLParser.MINUS); }
|
|
public TerminalNode MINUS(int i) {
|
|
return getToken(VSLParser.MINUS, i);
|
|
}
|
|
public ExpressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
|
|
public ExpressionContext(ParserRuleContext parent, int invokingState, SymTable table) {
|
|
super(parent, invokingState);
|
|
this.table = table;
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_expression; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof VSLParserListener ) ((VSLParserListener)listener).enterExpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof VSLParserListener ) ((VSLParserListener)listener).exitExpression(this);
|
|
}
|
|
}
|
|
|
|
public final ExpressionContext expression(SymTable table) throws RecognitionException {
|
|
ExpressionContext _localctx = new ExpressionContext(_ctx, getState(), table);
|
|
enterRule(_localctx, 10, RULE_expression);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(50);
|
|
((ExpressionContext)_localctx).left = td_expression(table);
|
|
|
|
((ExpressionContext)_localctx).out = ((ExpressionContext)_localctx).left.out;
|
|
((ExpressionContext)_localctx).return_Type = ((ExpressionContext)_localctx).left.return_Type;
|
|
|
|
setState(58);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==PLUS || _la==MINUS) {
|
|
{
|
|
{
|
|
setState(52);
|
|
((ExpressionContext)_localctx).op = _input.LT(1);
|
|
_la = _input.LA(1);
|
|
if ( !(_la==PLUS || _la==MINUS) ) {
|
|
((ExpressionContext)_localctx).op = (Token)_errHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
|
|
_errHandler.reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(53);
|
|
((ExpressionContext)_localctx).right = td_expression(table);
|
|
|
|
((ExpressionContext)_localctx).out = new BinopExpressionImp(
|
|
switch(((ExpressionContext)_localctx).op.getType()) {
|
|
case PLUS -> Op.PLUS;
|
|
case MINUS -> Op.MINUS;
|
|
default -> throw new IllegalArgumentException("Unknown operator");
|
|
},
|
|
_localctx.out,
|
|
((ExpressionContext)_localctx).right.out
|
|
);
|
|
((ExpressionContext)_localctx).return_Type = ((ExpressionContext)_localctx).left.return_Type;
|
|
|
|
}
|
|
}
|
|
setState(60);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class Td_expressionContext extends ParserRuleContext {
|
|
public SymTable table;
|
|
public Type return_Type;
|
|
public Expression out;
|
|
public LitContext left;
|
|
public Token op;
|
|
public LitContext right;
|
|
public List<LitContext> lit() {
|
|
return getRuleContexts(LitContext.class);
|
|
}
|
|
public LitContext lit(int i) {
|
|
return getRuleContext(LitContext.class,i);
|
|
}
|
|
public List<TerminalNode> TIMES() { return getTokens(VSLParser.TIMES); }
|
|
public TerminalNode TIMES(int i) {
|
|
return getToken(VSLParser.TIMES, i);
|
|
}
|
|
public List<TerminalNode> DIV() { return getTokens(VSLParser.DIV); }
|
|
public TerminalNode DIV(int i) {
|
|
return getToken(VSLParser.DIV, i);
|
|
}
|
|
public List<TerminalNode> MOD() { return getTokens(VSLParser.MOD); }
|
|
public TerminalNode MOD(int i) {
|
|
return getToken(VSLParser.MOD, i);
|
|
}
|
|
public Td_expressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
|
|
public Td_expressionContext(ParserRuleContext parent, int invokingState, SymTable table) {
|
|
super(parent, invokingState);
|
|
this.table = table;
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_td_expression; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof VSLParserListener ) ((VSLParserListener)listener).enterTd_expression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof VSLParserListener ) ((VSLParserListener)listener).exitTd_expression(this);
|
|
}
|
|
}
|
|
|
|
public final Td_expressionContext td_expression(SymTable table) throws RecognitionException {
|
|
Td_expressionContext _localctx = new Td_expressionContext(_ctx, getState(), table);
|
|
enterRule(_localctx, 12, RULE_td_expression);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(61);
|
|
((Td_expressionContext)_localctx).left = lit(table);
|
|
|
|
((Td_expressionContext)_localctx).out = ((Td_expressionContext)_localctx).left.out;
|
|
((Td_expressionContext)_localctx).return_Type = ((Td_expressionContext)_localctx).left.return_Type;
|
|
|
|
setState(69);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 469762048L) != 0)) {
|
|
{
|
|
{
|
|
setState(63);
|
|
((Td_expressionContext)_localctx).op = _input.LT(1);
|
|
_la = _input.LA(1);
|
|
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 469762048L) != 0)) ) {
|
|
((Td_expressionContext)_localctx).op = (Token)_errHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
|
|
_errHandler.reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(64);
|
|
((Td_expressionContext)_localctx).right = lit(table);
|
|
|
|
((Td_expressionContext)_localctx).out = new Program.BinopExpressionImp(
|
|
switch(((Td_expressionContext)_localctx).op.getType()) {
|
|
case TIMES -> Op.TIMES;
|
|
case DIV -> Op.DIV;
|
|
case MOD -> Op.MOD;
|
|
default -> throw new IllegalArgumentException("Unknown operator");
|
|
},
|
|
_localctx.out,
|
|
((Td_expressionContext)_localctx).right.out
|
|
);
|
|
((Td_expressionContext)_localctx).return_Type = ((Td_expressionContext)_localctx).left.return_Type;
|
|
|
|
}
|
|
}
|
|
setState(71);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LitContext extends ParserRuleContext {
|
|
public SymTable table;
|
|
public Expression out;
|
|
public Type return_Type;
|
|
public Token NUMBER;
|
|
public ExpressionContext e;
|
|
public TerminalNode NUMBER() { return getToken(VSLParser.NUMBER, 0); }
|
|
public TerminalNode ParO() { return getToken(VSLParser.ParO, 0); }
|
|
public TerminalNode ParF() { return getToken(VSLParser.ParF, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public LitContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
|
|
public LitContext(ParserRuleContext parent, int invokingState, SymTable table) {
|
|
super(parent, invokingState);
|
|
this.table = table;
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_lit; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof VSLParserListener ) ((VSLParserListener)listener).enterLit(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof VSLParserListener ) ((VSLParserListener)listener).exitLit(this);
|
|
}
|
|
}
|
|
|
|
public final LitContext lit(SymTable table) throws RecognitionException {
|
|
LitContext _localctx = new LitContext(_ctx, getState(), table);
|
|
enterRule(_localctx, 14, RULE_lit);
|
|
try {
|
|
setState(79);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case NUMBER:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(72);
|
|
((LitContext)_localctx).NUMBER = match(NUMBER);
|
|
|
|
((LitContext)_localctx).return_Type = new Type_intImp();
|
|
((LitContext)_localctx).out = new ConstImp((((LitContext)_localctx).NUMBER!=null?Integer.valueOf(((LitContext)_localctx).NUMBER.getText()):0));
|
|
|
|
}
|
|
break;
|
|
case ParO:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(74);
|
|
match(ParO);
|
|
setState(75);
|
|
((LitContext)_localctx).e = expression(table);
|
|
setState(76);
|
|
match(ParF);
|
|
|
|
((LitContext)_localctx).out = ((LitContext)_localctx).e.out;
|
|
((LitContext)_localctx).return_Type = ((LitContext)_localctx).e.return_Type;
|
|
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class IdentContext extends ParserRuleContext {
|
|
public String out;
|
|
public Token IDENT;
|
|
public TerminalNode IDENT() { return getToken(VSLParser.IDENT, 0); }
|
|
public IdentContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_ident; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof VSLParserListener ) ((VSLParserListener)listener).enterIdent(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof VSLParserListener ) ((VSLParserListener)listener).exitIdent(this);
|
|
}
|
|
}
|
|
|
|
public final IdentContext ident() throws RecognitionException {
|
|
IdentContext _localctx = new IdentContext(_ctx, getState());
|
|
enterRule(_localctx, 16, RULE_ident);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(81);
|
|
((IdentContext)_localctx).IDENT = match(IDENT);
|
|
((IdentContext)_localctx).out = ((IdentContext)_localctx).IDENT.getText();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TypeContext extends ParserRuleContext {
|
|
public Type return_type;
|
|
public TerminalNode TYPE_INT() { return getToken(VSLParser.TYPE_INT, 0); }
|
|
public TerminalNode TYPE_VOID() { return getToken(VSLParser.TYPE_VOID, 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 VSLParserListener ) ((VSLParserListener)listener).enterType(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof VSLParserListener ) ((VSLParserListener)listener).exitType(this);
|
|
}
|
|
}
|
|
|
|
public final TypeContext type() throws RecognitionException {
|
|
TypeContext _localctx = new TypeContext(_ctx, getState());
|
|
enterRule(_localctx, 18, RULE_type);
|
|
try {
|
|
setState(88);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case TYPE_INT:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(84);
|
|
match(TYPE_INT);
|
|
((TypeContext)_localctx).return_type = new Type_intImp();
|
|
}
|
|
break;
|
|
case TYPE_VOID:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(86);
|
|
match(TYPE_VOID);
|
|
((TypeContext)_localctx).return_type = new Type_voidImp();
|
|
}
|
|
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 final String _serializedATN =
|
|
"\u0004\u0001\u001f[\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002"+
|
|
"\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002"+
|
|
"\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002"+
|
|
"\b\u0007\b\u0002\t\u0007\t\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000"+
|
|
"\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+
|
|
"\u0001\u0001\u0001\u0001\u0005\u0001!\b\u0001\n\u0001\f\u0001$\t\u0001"+
|
|
"\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001\u0003\u0004\u0003"+
|
|
"+\b\u0003\u000b\u0003\f\u0003,\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+
|
|
"\u0004\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001"+
|
|
"\u0005\u0005\u00059\b\u0005\n\u0005\f\u0005<\t\u0005\u0001\u0006\u0001"+
|
|
"\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0005\u0006D\b"+
|
|
"\u0006\n\u0006\f\u0006G\t\u0006\u0001\u0007\u0001\u0007\u0001\u0007\u0001"+
|
|
"\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0003\u0007P\b\u0007\u0001"+
|
|
"\b\u0001\b\u0001\b\u0001\t\u0001\t\u0001\t\u0001\t\u0003\tY\b\t\u0001"+
|
|
"\t\u0000\u0000\n\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0000"+
|
|
"\u0002\u0001\u0000\u0018\u0019\u0001\u0000\u001a\u001cV\u0000\u0014\u0001"+
|
|
"\u0000\u0000\u0000\u0002\"\u0001\u0000\u0000\u0000\u0004%\u0001\u0000"+
|
|
"\u0000\u0000\u0006*\u0001\u0000\u0000\u0000\b.\u0001\u0000\u0000\u0000"+
|
|
"\n2\u0001\u0000\u0000\u0000\f=\u0001\u0000\u0000\u0000\u000eO\u0001\u0000"+
|
|
"\u0000\u0000\u0010Q\u0001\u0000\u0000\u0000\u0012X\u0001\u0000\u0000\u0000"+
|
|
"\u0014\u0015\u0003\u0002\u0001\u0000\u0015\u0016\u0005\u0000\u0000\u0001"+
|
|
"\u0016\u0017\u0006\u0000\uffff\uffff\u0000\u0017\u0001\u0001\u0000\u0000"+
|
|
"\u0000\u0018\u0019\u0005\u0001\u0000\u0000\u0019\u001a\u0003\u0012\t\u0000"+
|
|
"\u001a\u001b\u0003\u0010\b\u0000\u001b\u001c\u0005\u0016\u0000\u0000\u001c"+
|
|
"\u001d\u0005\u0017\u0000\u0000\u001d\u001e\u0003\u0006\u0003\u0000\u001e"+
|
|
"\u001f\u0006\u0001\uffff\uffff\u0000\u001f!\u0001\u0000\u0000\u0000 \u0018"+
|
|
"\u0001\u0000\u0000\u0000!$\u0001\u0000\u0000\u0000\" \u0001\u0000\u0000"+
|
|
"\u0000\"#\u0001\u0000\u0000\u0000#\u0003\u0001\u0000\u0000\u0000$\"\u0001"+
|
|
"\u0000\u0000\u0000%&\u0001\u0000\u0000\u0000&\u0005\u0001\u0000\u0000"+
|
|
"\u0000\'(\u0003\b\u0004\u0000()\u0006\u0003\uffff\uffff\u0000)+\u0001"+
|
|
"\u0000\u0000\u0000*\'\u0001\u0000\u0000\u0000+,\u0001\u0000\u0000\u0000"+
|
|
",*\u0001\u0000\u0000\u0000,-\u0001\u0000\u0000\u0000-\u0007\u0001\u0000"+
|
|
"\u0000\u0000./\u0005\u0013\u0000\u0000/0\u0003\n\u0005\u000001\u0006\u0004"+
|
|
"\uffff\uffff\u00001\t\u0001\u0000\u0000\u000023\u0003\f\u0006\u00003:"+
|
|
"\u0006\u0005\uffff\uffff\u000045\u0007\u0000\u0000\u000056\u0003\f\u0006"+
|
|
"\u000067\u0006\u0005\uffff\uffff\u000079\u0001\u0000\u0000\u000084\u0001"+
|
|
"\u0000\u0000\u00009<\u0001\u0000\u0000\u0000:8\u0001\u0000\u0000\u0000"+
|
|
":;\u0001\u0000\u0000\u0000;\u000b\u0001\u0000\u0000\u0000<:\u0001\u0000"+
|
|
"\u0000\u0000=>\u0003\u000e\u0007\u0000>E\u0006\u0006\uffff\uffff\u0000"+
|
|
"?@\u0007\u0001\u0000\u0000@A\u0003\u000e\u0007\u0000AB\u0006\u0006\uffff"+
|
|
"\uffff\u0000BD\u0001\u0000\u0000\u0000C?\u0001\u0000\u0000\u0000DG\u0001"+
|
|
"\u0000\u0000\u0000EC\u0001\u0000\u0000\u0000EF\u0001\u0000\u0000\u0000"+
|
|
"F\r\u0001\u0000\u0000\u0000GE\u0001\u0000\u0000\u0000HI\u0005\u0015\u0000"+
|
|
"\u0000IP\u0006\u0007\uffff\uffff\u0000JK\u0005\u0016\u0000\u0000KL\u0003"+
|
|
"\n\u0005\u0000LM\u0005\u0017\u0000\u0000MN\u0006\u0007\uffff\uffff\u0000"+
|
|
"NP\u0001\u0000\u0000\u0000OH\u0001\u0000\u0000\u0000OJ\u0001\u0000\u0000"+
|
|
"\u0000P\u000f\u0001\u0000\u0000\u0000QR\u0005\u001d\u0000\u0000RS\u0006"+
|
|
"\b\uffff\uffff\u0000S\u0011\u0001\u0000\u0000\u0000TU\u0005\u0003\u0000"+
|
|
"\u0000UY\u0006\t\uffff\uffff\u0000VW\u0005\u0004\u0000\u0000WY\u0006\t"+
|
|
"\uffff\uffff\u0000XT\u0001\u0000\u0000\u0000XV\u0001\u0000\u0000\u0000"+
|
|
"Y\u0013\u0001\u0000\u0000\u0000\u0006\",:EOX";
|
|
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);
|
|
}
|
|
}
|
|
} |