parser.cup

package com.jc;

import java_cup.runtime.*;
import java.io.IOException;
import java.io.File;
import java.io.FileInputStream;
import java.lang.Object;
import java.util.*;
import com.jc.node.*;

parser code {:

    protected Lexer lexer;
    private FileInputStream fis;
    private HashMap<String, String> symbolTable;
    private HashMap<String, String> tempTable;
    private Node tree;
    private int tempSequence;

    public Parser(String filename) {
        symbolTable = new HashMap<>();
        tempTable = new HashMap<>();
        tempSequence = 1;

        File file = new File(filename);
        try {
            fis = new FileInputStream(file);
            
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public Node getTree() {
        return tree;
    }

    public HashMap<String, String> getSymbolTable() {
        return symbolTable;
    }

    public HashMap<String, String> getTempTable() {
        return tempTable;
    }

    private void declare(String name, String type) throws Exception {
        if (symbolTable.containsKey(name)) {
            throw new Exception(String.format("Variable already declared: '%s'", name));
        }
        symbolTable.put(name, type);
    }

    private String newTemp(String type) {
        String tempName = "t" + tempSequence++;
        tempTable.put(tempName, type);
        return tempName;
    }

    private void verifyVar(String name) throws Exception {
        if (!symbolTable.containsKey(name)) {
            throw new Exception(String.format("Variable not already declared: '%s'", name));
        }
    }

    private String getVarType(String name) throws Exception {
        verifyVar(name);
        return symbolTable.get(name);
    }

    private Variable newVariableExpr(String name, String type) {
        Variable variable = new Variable();
        variable.name = name;
        variable.type = type;
        return variable;
    }

    private Literal newLiteralExpr(String type, Object value) {
        Literal literal = new Literal();
        literal.type = type;
        literal.value = value;
        return literal;
    }

    private Operation newOperationExpr(String op, Expression left, Expression right) throws Exception {
        Operation operation = new Operation();
        operation.type = widen(left.type, right.type);
        operation.operation = op;
        operation.temp = newTemp(operation.type);
        return (Operation) pushBackChildren(operation, left, right);
    }

    private Operation newIncrementOperationExpr(String op, String varName) throws Exception {
        Increment increment = new Increment();
        increment.variable = varName;
        increment.operation = op;
        increment.type = getVarType(varName);
        increment.temp = newTemp(increment.type);
        return (Operation) pushBackChildren(increment, newVariableExpr(varName, getVarType(varName)));
    }

    private Operation newRelOperationExpr(String op, Expression left, Expression right) throws Exception {
        Operation operation = new Operation();
        operation.type = Constants.T_BOOL;
        operation.operation = op;
        operation.temp = newTemp(operation.type);
        return (Operation) pushBackChildren(operation, left, right);
    }

    private Operation newUnaryOperationExpr(String op, Expression exp) throws Exception {
        Operation operation = new Operation();
        operation.type = exp.type;
        operation.operation = op;
        operation.temp = newTemp(operation.type);
        return (Operation) pushBackChildren(operation, exp);
    }

    private Assignment newAssignmentNode(String name, Expression exp) throws Exception {
        verifyVar(name);
        Assignment assignment = new Assignment();
        assignment.variable = name;
        return (Assignment) pushBackChildren(assignment, exp);
    }

    private Declaration newDeclarationNode(String name, String type) {
        Declaration declaration = new Declaration();
        declaration.type = type;
        declaration.name = name;
        return declaration;
    }

    private Node newDeclarationNode(String name, String type, Expression value) throws Exception {
        Declaration declaration = newDeclarationNode(name, type);
        Assignment assignment = newAssignmentNode(name, value);
        Node node = new Node();

        return pushBackChildren(node, declaration, assignment);
    }

    private Print newPrintNode(Expression expression) {
        Print print = new Print();
        return (Print) pushBackChildren(print, expression);
    }

    private Conditional newConditionalNode(Expression test, Node block, Node conditionalAlt) {
        Conditional conditional = new Conditional();
        conditional.test = test;
        conditional = (Conditional) pushBackChildren(conditional, block);
        if (conditionalAlt != null) {
            conditional = (Conditional) pushBackChildren(conditional, conditionalAlt);
        }
        return conditional;
    }

    private WhileLoop newWhileLoopNode(Expression test, Node block) {
        WhileLoop whileLoop = new WhileLoop();
        whileLoop.test = test;
        whileLoop = (WhileLoop) pushBackChildren(whileLoop, block);
        return whileLoop;
    }

    private DoWhileLoop newDoWhileLoopNode(Expression test, Node block) {
        DoWhileLoop doWhileLoop = new DoWhileLoop();
        doWhileLoop.test = test;
        doWhileLoop = (DoWhileLoop) pushBackChildren(doWhileLoop, block);
        return doWhileLoop;
    }

    private ForLoop newForLoopNode(Node declaration, Expression test, Node increment, Node block) {
        ForLoop forLoop = new ForLoop();
        forLoop.declaration = declaration;
        forLoop.test = test;
        forLoop.increment = increment;
        return (ForLoop) pushBackChildren(forLoop, block);
    }

    private String widen(String type1, String type2) throws Exception {
        if (type1.equals(Constants.T_REAL) || type2.equals(Constants.T_REAL)) return Constants.T_REAL;
        if (type1.equals(Constants.T_INT) || type2.equals(Constants.T_INT)) return Constants.T_INT;
        if (type1.equals(Constants.T_BOOL) || type2.equals(Constants.T_BOOL)) return Constants.T_BOOL;
        return "";
    }

    private void verifyAritTypes(String type1, String type2) throws Exception {
        if (!type1.equals(Constants.T_REAL) && !type1.equals(Constants.T_INT) || 
            !type2.equals(Constants.T_REAL) && !type2.equals(Constants.T_INT)) {
            throw new Exception(String.format("Invalid operation with types '%s' and '%s'", type1, type2)); 
        }
    }

    public void verifyLogicTypes(String type1, String type2) throws Exception {
        if (!type1.equals(Constants.T_BOOL) || !type2.equals(Constants.T_BOOL)) {
            throw new Exception(String.format("Invalid operation with types '%s' and '%s'", type1, type2)); 
        }
    }

    public void verifyUnaryLogicTypes(String type) throws Exception {
        if (!type.equals(Constants.T_BOOL)) {
            throw new Exception(String.format("Invalid unary operation with type '%s'", type));
        }
    }

    private void verifyAssignTypes(String type1, String type2) throws Exception {
        if (!type1.equals(type2)) {
            throw new Exception(String.format(
                "Cannot assign expression with type '%s' in variable with type '%s'", type2, type1));
        }
    }

    private void verifyBooleanType(String type) throws Exception {
        if (!type.equals(Constants.T_BOOL)) {
            throw new Exception(String.format("Invalid type '%s', must be 'bool'", type));
        }
    }

    private void verifyRelationalTypes(String type1, String type2) throws Exception {
        if (!type1.equals(type2)) {
            throw new Exception(String.format(
                "Cannot compare expressions with types '%s' and '%s'", type2, type1));
        }
    }

    private void verifyUnaryAritType(String type) throws Exception {
        if (!type.equals(Constants.T_INT) && !type.equals(Constants.T_REAL)) {
            throw new Exception(String.format("Cannot use operation with type '%s'", type));
        }
    }

    private Node pushBackChildren(Node parent, Node... children) {
        if (parent.children == null) {
            parent.children = new ArrayList<>();
        }
        parent.children.addAll(List.of(children));
        return parent;
    }

    private Node pushFrontChild(Node parent, Node child) {
        if (parent.children == null) {
            parent.children = new ArrayList<>();
        }
        parent.children.add(0, child);
        return parent;
    }

    private String trimString(String string) {
        return string.substring(1, string.length()-1);
    }
:};

init with {:
    ComplexSymbolFactory factory = new ComplexSymbolFactory();
    symbolFactory = factory;
    lexer = new Lexer(factory, fis);
:};

scan with {:
    return lexer.yylex();
:};

terminal String     ID;
terminal String     TYPE;
terminal Double     REAL;
terminal Integer    INT;
terminal String     STRING;
terminal Boolean    BOOL;
terminal            ASSIGN;
terminal            ADD;
terminal            SUB;
terminal            MULT;
terminal            DIV;
terminal            POW;
terminal            INC;
terminal            DEC;
terminal            OR;
terminal            AND;
terminal            NOT;
terminal            EQ;
terminal            NEQ;
terminal            GT;
terminal            GTE;
terminal            LT;
terminal            LTE;
terminal            SMC; // semicolon
terminal            L_PTH; // open parenthesis
terminal            R_PTH; // close parenthesis
terminal            L_CRL; // left curly brackets
terminal            R_CRL; // right curly brackets 
terminal            PRINT;
terminal            IF;
terminal            ELSE;
terminal            WHILE;
terminal            DO;
terminal            FOR;

non terminal Node           S;
non terminal Node           _COMMANDS;
non terminal Node           _COMMAND;
non terminal Node           _DECL;
non terminal Node           _ASSIGN;
non terminal Expression     _EXP;
non terminal Node           _PRINT;
non terminal Node           _CONDITIONAL;
non terminal Node           _CONDITIONAL_ALT;
non terminal Node           _WHILE_LOOP;
non terminal Node           _FOR_LOOP;

precedence left EQ, NEQ, GT, GTE, LT, LTE;

precedence left ADD, SUB;
precedence left MULT, DIV;
precedence left POW;

precedence left OR;
precedence left AND;
precedence left NOT;

S ::= _COMMANDS:cmds     {: tree = cmds; RESULT = cmds; :}
    ;

_COMMANDS ::= _COMMAND:cmd SMC _COMMANDS:cmds   {: RESULT = pushFrontChild(cmds, cmd); :}
            | _CONDITIONAL:cond _COMMANDS:cmds  {: RESULT = pushFrontChild(cmds, cond); :}
            | _WHILE_LOOP:loop _COMMANDS:cmds   {: RESULT = pushFrontChild(cmds, loop); :}
            | _FOR_LOOP:loop _COMMANDS:cmds     {: RESULT = pushFrontChild(cmds, loop); :}
            |                   {: RESULT = new Node(); :}
            ;

_COMMAND ::= _DECL:node         {: RESULT = node; :}
           | _ASSIGN:node       {: RESULT = node; :}
           | _PRINT:node        {: RESULT = node; :}
           | _EXP:e             {: RESULT = e; :}
           ;

_PRINT ::= PRINT L_PTH _EXP:e R_PTH {: RESULT = newPrintNode(e); :};

_DECL ::= TYPE:t ID:id          {: declare(id, t); RESULT = newDeclarationNode(id, t); :}
        | TYPE:t ID:id ASSIGN _EXP:e {: 
            declare(id, t); verifyAssignTypes(t, e.type); RESULT = newDeclarationNode(id, t, e); :}
        ;

_ASSIGN ::= ID:id ASSIGN _EXP:e {: verifyAssignTypes(getVarType(id), e.type); RESULT = newAssignmentNode(id, e); :};

_EXP ::= ID:id                  {: RESULT = newVariableExpr(id, getVarType(id)); :}
       | REAL:val               {: RESULT = newLiteralExpr(Constants.T_REAL, val); :}
       | INT:val                {: RESULT = newLiteralExpr(Constants.T_INT, val); :}
       | BOOL:val               {: RESULT = newLiteralExpr(Constants.T_BOOL, val); :}
       | STRING:val             {: RESULT = newLiteralExpr(Constants.T_STR, trimString(val)); :}
       | _EXP:e1 ADD _EXP:e2    {: verifyAritTypes(e1.type, e2.type); RESULT = newOperationExpr(Constants.OP_ADD, e1, e2); :}
       | _EXP:e1 SUB _EXP:e2    {: verifyAritTypes(e1.type, e2.type); RESULT = newOperationExpr(Constants.OP_SUB, e1, e2); :}
       | _EXP:e1 MULT _EXP:e2   {: verifyAritTypes(e1.type, e2.type); RESULT = newOperationExpr(Constants.OP_MULT, e1, e2); :}
       | _EXP:e1 DIV _EXP:e2    {: verifyAritTypes(e1.type, e2.type); RESULT = newOperationExpr(Constants.OP_DIV, e1, e2); :}
       | _EXP:e1 POW _EXP:e2    {: verifyAritTypes(e1.type, e2.type); RESULT = newOperationExpr(Constants.OP_POW, e1, e2); :}
       | ID:id INC              {: verifyUnaryAritType(getVarType(id)); RESULT = newIncrementOperationExpr(Constants.OP_INC, id); :}
       | ID:id DEC              {: verifyUnaryAritType(getVarType(id)); RESULT = newIncrementOperationExpr(Constants.OP_DEC, id); :}
       | _EXP:e1 OR _EXP:e2     {: verifyLogicTypes(e1.type, e2.type); RESULT = newOperationExpr(Constants.OP_OR, e1, e2); :}
       | _EXP:e1 AND _EXP:e2    {: verifyLogicTypes(e1.type, e2.type); RESULT = newOperationExpr(Constants.OP_AND, e1, e2); :}
       | NOT _EXP:e             {: verifyUnaryLogicTypes(e.type); RESULT = newUnaryOperationExpr(Constants.OP_NOT, e); :}
       | _EXP:e1 EQ _EXP:e2     {: verifyRelationalTypes(e1.type, e2.type); RESULT = newRelOperationExpr(Constants.OP_EQ, e1, e2); :}
       | _EXP:e1 NEQ _EXP:e2    {: verifyRelationalTypes(e1.type, e2.type); RESULT = newRelOperationExpr(Constants.OP_NEQ, e1, e2); :}
       | _EXP:e1 GT _EXP:e2     {: verifyRelationalTypes(e1.type, e2.type); RESULT = newRelOperationExpr(Constants.OP_GT, e1, e2); :}
       | _EXP:e1 GTE _EXP:e2    {: verifyRelationalTypes(e1.type, e2.type); RESULT = newRelOperationExpr(Constants.OP_GTE, e1, e2); :}
       | _EXP:e1 LT _EXP:e2     {: verifyRelationalTypes(e1.type, e2.type); RESULT = newRelOperationExpr(Constants.OP_LT, e1, e2); :}
       | _EXP:e1 LTE _EXP:e2    {: verifyRelationalTypes(e1.type, e2.type); RESULT = newRelOperationExpr(Constants.OP_LTE, e1, e2); :}
       | L_PTH _EXP:e R_PTH     {: RESULT = e; :}
       ;

_CONDITIONAL ::= IF L_PTH _EXP:e R_PTH L_CRL _COMMANDS:cmds R_CRL _CONDITIONAL_ALT:alt {: 
                    verifyBooleanType(e.type); RESULT = newConditionalNode(e, cmds, alt); :}
               ;

_CONDITIONAL_ALT ::= ELSE L_CRL _COMMANDS:cmds R_CRL    {: RESULT = cmds; :}
                   | ELSE _CONDITIONAL:cond             {: RESULT = cond; :}
                   |
                   ;

_WHILE_LOOP ::= WHILE L_PTH _EXP:e R_PTH L_CRL _COMMANDS:cmds R_CRL {:
                    verifyBooleanType(e.type); RESULT = newWhileLoopNode(e, cmds); :}
              | DO L_CRL _COMMANDS:cmds R_CRL WHILE L_PTH _EXP:e R_PTH {: 
                    verifyBooleanType(e.type); RESULT = newDoWhileLoopNode(e, cmds); :}
              ;

_FOR_LOOP ::= FOR L_PTH _DECL:decl SMC _EXP:e SMC _COMMAND:cmd R_PTH 
                L_CRL _COMMANDS:cmds R_CRL {: 
                    verifyBooleanType(e.type); RESULT = newForLoopNode(decl, e, cmd, cmds); :};