tiny.cup

/*
  Created by: Fei Song
  File Name: tiny.cup
  To Build: java java_cup.Main < tiny.cup
*/

/* ----------------------Preliminary Declarations Section--------------------*/

/* Import the class java_cup.runtime.*  */
//import java_cup.runtime.*;
import absyn.*;

/* Parser code to change the way the parser reports errors (include
   line and column number of the error). */
parser code {:

    /* Change the method report_error so it will display the line and
       column of where the error occurred in the input as well as the
       reason for the error which is passed into the method in the
       String 'message'. */
    public void report_error(String message, Object info) {

        /* Create a StringBuffer called 'm' with the string 'Error' in it. */
        StringBuffer m = new StringBuffer("Error");

        /* Check if the information passed to the method is the same
           type as the type java_cup.runtime.Symbol. */
        if (info instanceof java_cup.runtime.Symbol) {
            /* Declare a java_cup.runtime.Symbol object 's' with the
               information in the object info that is being typecasted
               as a java_cup.runtime.Symbol object. */
            java_cup.runtime.Symbol s = ((java_cup.runtime.Symbol) info);

            /* Check if the line number in the input is greater or
               equal to zero. */
            if (s.left >= 0) {
                /* Add to the end of the StringBuffer error message
                   the line number of the error in the input. */
                m.append(" in line "+(s.left+1));
                /* Check if the column number in the input is greater
                   or equal to zero. */
                if (s.right >= 0)
                    /* Add to the end of the StringBuffer error message
                       the column number of the error in the input. */
                    m.append(", column "+(s.right+1));
            }
        }

        /* Add to the end of the StringBuffer error message created in
           this method the message that was passed into this method. */
        m.append(" : "+message);

        /* Print the contents of the StringBuffer 'm', which contains
           an error message, out on a line. */
        System.err.println(m);
    }

    /* Change the method report_fatal_error so when it reports a fatal
       error it will display the line and column number of where the
       fatal error occurred in the input as well as the reason for the
       fatal error which is passed into the method in the object
       'message' and then exit.*/
    public void report_fatal_error(String message, Object info) {
        report_error(message, info);
        System.exit(1);
    }
:};


/* ------------Declaration of Terminals and Non Terminals Section----------- */

terminal IF, ELSE, RETURN, WHILE;
terminal ASSIGN, PLUS, MINUS, MULTIPLY, DIVIDE, LT, LE, GT, GE, EQ, NE, SEMICOLON, COMMA, LPAREN, RPAREN, LSQUARE, RSQUARE, LCURL, RCURL;
terminal String ID, NUM;
terminal String INT, VOID;
terminal ERROR;

non terminal ExpList program, declaration_list, params_list, params, local_declarations, statement_list, arg_list, args;
non terminal Exp declaration, var_declaration, fun_declaration, param, compound_stmt, statement, expression, expression_stmt, selection_stmt, iteration_stmt, return_stmt, var, simple_expression, additive_expression, term, factor, call;
non terminal String type_specifier;
non terminal Integer relop, addop, mulop;

precedence left ELSE;

/* ----------------------------Grammar Section-------------------- */
program             ::= declaration_list:dl
                        {:
                          RESULT = dl;
                        :};

declaration_list    ::= declaration_list:dl declaration:d
                        {:ExpList t = dl; //loop to end of dl then add d to tail
                          while(t.tail != null)
                          {
                            t = t.tail;
                          }
                          t.tail = new ExpList(d, null);
                          RESULT = dl;
                        :}
                        |
                        declaration:d
                        {: RESULT = new ExpList(d, null); :};

declaration         ::= var_declaration:vd
                        {: RESULT = vd; :}
                        |
                        fun_declaration:fd
                        {: RESULT = fd; :};

var_declaration     ::= type_specifier:t ID:i SEMICOLON
                        {: RESULT = new VarDec(tleft, t, i); :}
                        |
                        type_specifier:t ID:i LSQUARE NUM:s RSQUARE SEMICOLON
                        {: RESULT = new ArrDec(tleft, t, i, s); :};

type_specifier      ::= INT:i
                        {: RESULT = "int"; :}
                        |
                        VOID:v
                        {: RESULT = "void"; :};

fun_declaration     ::= type_specifier:t ID:i LPAREN params:p RPAREN compound_stmt:cs
                        {: RESULT = new FunDec( tleft, t, i, p, cs); :};

params              ::= params_list:pl
                        {: RESULT = pl; :}
                        |
                        VOID:v
                        {: RESULT = null; :};

params_list         ::= params_list:pl COMMA param:p
                        {:ExpList t = pl;
                          while (t.tail != null)
                          {
                            t = t.tail;
                          }
                          t.tail = new ExpList(p, null);
                          RESULT = pl;
                        :}
                        |
                        param:p
                        {:
                          RESULT = new ExpList(p, null);
                        :};

param               ::= type_specifier:t ID:i
                        {:
                          RESULT = new VarDec(tleft, t, i);
                        :}
                        |
                        type_specifier:t ID:i LSQUARE RSQUARE
                        {:
                          RESULT = new ArrDec(tleft, t, i, null);
                        :};

compound_stmt       ::= LCURL:c local_declarations:l statement_list:s RCURL
                        {:
                          RESULT = new ComStmt(cleft, l, s);
                        :};

local_declarations  ::= local_declarations:ld var_declaration:v
                        {:
                          ExpList t = ld;
                          RESULT = null;
                          if(t != null)
                          {
                            while (t.tail != null)
                            {
                              t = t.tail;
                            }
                            if (v != null)
                            {
                              t.tail = new ExpList(v, null);
                            }
                            RESULT = ld;
                          }
                          else
                          {
                            if (v != null)
                            {
                              RESULT = new ExpList(v, null);
                            }
                          }
                        :}
                        |
                        {:RESULT = null; :} ;
statement_list      ::= statement_list:sl statement:s
                        {:
                          ExpList t = sl;
                          RESULT = null;
                          if (t != null)
                          {
                            while (t.tail != null)
                            {
                              t = t.tail;
                            }
                            if (s != null)
                            {
                              t.tail = new ExpList(s, null);
                            }
                            RESULT = sl;
                          }
                          else
                          {
                            if (s != null)
                            {
                              RESULT = new ExpList(s, null);
                            }
                          }
                        :}
                        |
                        {:RESULT = null; :} ;

statement           ::= expression_stmt:e
                        {:RESULT = e; :}
                        |
                        compound_stmt:c
                        {:RESULT = c; :}
                        |
                        selection_stmt:s
                        {:RESULT = s; :}
                        |
                        iteration_stmt:i
                        {:RESULT = i; :}
                        |
                        return_stmt:r
                        {:RESULT = r; :};

expression_stmt     ::= expression:e SEMICOLON
                        {: RESULT = e; :}
                        |
                        SEMICOLON
                        {: RESULT = null; :};

selection_stmt      ::= IF:i LPAREN expression:e RPAREN statement:s
                        {:RESULT = new IfExp(ileft, e, s, null ); :}
                        |
                        IF:i LPAREN expression:e RPAREN statement:th ELSE statement:el
                        {:RESULT = new IfExp(ileft, e, th, el); :};

iteration_stmt      ::= WHILE:i LPAREN expression:e RPAREN statement:s
                        {: RESULT = new WhileExp( ileft, e, s ); :};

return_stmt         ::= RETURN:i SEMICOLON
                        {: RESULT = new RetExp(ileft, null); :}
                        |
                        RETURN:i expression:e SEMICOLON
                        {:  RESULT = new RetExp(ileft, e); :};

expression          ::= var:v ASSIGN expression:e
                        {:RESULT = new AssignExp( vleft, v, e); :}
                        |
                        simple_expression:s
                        {:RESULT = s; :};

var                 ::= ID:i
                        {: RESULT = new VarExp(ileft, i); :}
                        |
                        ID:i LSQUARE expression:e RSQUARE
                        {: RESULT = new ArrExp(ileft, i, e); :};

simple_expression   ::= additive_expression:e1 relop:r additive_expression:e2
                        {:RESULT = new RelOp(e1left, e1, r, e2); :}
                        |
                        additive_expression:a
                        {:RESULT = a; :};

relop               ::= LE
                        {: RESULT = RelOp.LE; :}
                        |
                        LT
                        {: RESULT = RelOp.LT; :}
                        |
                        GT
                        {: RESULT = RelOp.GT; :}
                        |
                        GE
                        {: RESULT = RelOp.GE; :}
                        |
                        EQ
                        {: RESULT = RelOp.EQ; :}
                        |
                        NE
                        {: RESULT = RelOp.NE; :};

additive_expression ::= additive_expression:e addop:a term:t
                        {: RESULT = new BinOp(eleft, e, a, t); :}
                        |
                        term:t
                        {: RESULT = t; :};

addop               ::= PLUS
                        {: RESULT = BinOp.PLUS; :}
                        |
                        MINUS
                        {: RESULT = BinOp.MINUS; :};

term                ::= term:t mulop:m factor:f
                        {: RESULT = new BinOp(tleft, t, m, f); :}
                        |
                        factor:f
                        {: RESULT = f; :};

mulop               ::= MULTIPLY
                        {: RESULT = BinOp.MULTIPLY; :}
                        |
                        DIVIDE
                        {: RESULT = BinOp.DIVIDE; :};

factor              ::= LPAREN expression:e RPAREN
                        {: RESULT = e; :}
                        |
                        var:v
                        {: RESULT = v; :}
                        |
                        call:c
                        {: RESULT = c; :}
                        |
                        NUM:n
                        {: RESULT = new IntVal(nleft, n); :};

call                ::= ID:i LPAREN args:a RPAREN
                        {: RESULT = new FunCall(ileft, i, a); :};

args                ::= arg_list:a
                        {: RESULT = a; :}
                        |
                        {: RESULT = (ExpList)null; :};

arg_list            ::= arg_list:a COMMA expression:e
                        {:
                          ExpList t = a;
                          while (t.tail != null)
                          {
                            t = t.tail;
                          }
                          t.tail = new ExpList( e, null );
                          RESULT = a;
                        :}
                        |
                        expression:e
                        {: RESULT = new ExpList( e, null); :};