minijava.cup

/* Minijava Grammar */

import java_cup.runtime.ComplexSymbolFactory;
import java_cup.runtime.ScannerBuffer;

import java.io.*;

parser code {:
  public Parser(Lexer lex, ComplexSymbolFactory sf) {
    super(lex,sf);
  }
  public static void main(String[] args) throws Exception {
      // initialize the symbol factory
      ComplexSymbolFactory csf = new ComplexSymbolFactory();
      // create a buffering scanner wrapper
      ScannerBuffer lexer = new ScannerBuffer(new Lexer(new BufferedReader(new FileReader(args[0])),csf));
      // start parsing
      Parser p = new Parser(lexer,csf);
      System.out.println(p.parse().value.toString());
  }
:};

// terminals
terminal CLASS, WHILE, READLN, PRINTLN, IF, ELSE, THIS, NEW, NULL;
terminal Integer INTCONST;
terminal Boolean BOOLCONST;
terminal String STRING_LITERAL;
terminal MAINFUNC;
terminal PLUS, MINUS, TIMES, DIV, UMINUS;
terminal LT, GT, GEQ, LEQ, EQ, NEQ;
terminal OR, AND, NOT;
terminal LPAREN, RPAREN, LBLOCK, RBLOCK;
terminal COMMA, DOT, ENDSTMT;
terminal RETURN;
terminal ASSIGN;
terminal String IDNAME, CLASSNAME;

// non-terminals
non terminal ProgramAST program;
non terminal ClassAST mainclass;
non terminal FuncDeclAST mainfunction;
non terminal ListAST<ClassAST> classes;
non terminal Pair<ListAST<VarDeclAST>, ListAST<FuncDeclAST>> varsmethods, vars;
non terminal ListAST<FuncDeclAST> methods;
non terminal ListAST<VarDeclAST> params, paramlist, nonemptyparamlist, restparamlist;
non terminal BlockAST block;
non terminal Pair<ListAST<VarDeclAST>, ListAST<StmtAST>> blockvars;
non terminal ListAST<StmtAST> stmts, reststmts, whileblock;
non terminal AST atom;
non terminal AST exp, aexp, bexp, bop;
non terminal ListAST<AST> explist, nonemptyexplist, restexplist;
non terminal IntAST intconst;
non terminal BoolAST boolconst;
non terminal StringAST stringliteral;

// precedence
precedence left ASSIGN;
precedence left AND;
precedence left OR;
precedence left NOT;
precedence left LT, GT, LEQ, GEQ, EQ, NEQ;
precedence left PLUS, MINUS;
precedence left TIMES, DIV;
precedence left UMINUS;
precedence left LPAREN, RPAREN;

// program handling
program ::= mainclass:mc classes:cs {:  RESULT = new ProgramAST(mc, cs); :};

// main class handling
mainclass ::= CLASS CLASSNAME:c LBLOCK mainfunction:f RBLOCK {: RESULT = new ClassAST(c, new ListAST<VarDeclAST>(), new ListAST(f)); :} ;
mainfunction ::= MAINFUNC params:ps block:b {: RESULT = new FuncDeclAST("Void", "main", ps, b); :};

// general class handling
classes ::= {: RESULT = new ListAST<ClassAST>(); :}
  | CLASS CLASSNAME:c varsmethods:r classes:cs {: RESULT = new ListAST(new ClassAST(c, r.head, r.tail), cs); :}
  ;

varsmethods ::= LBLOCK vars:vs {: RESULT = vs; :}
  ;
vars ::= CLASSNAME:c IDNAME:i ENDSTMT vars:r {: RESULT = new Pair(new ListAST(new VarDeclAST(c, i), r.head), r.tail); :}
  | methods:m {: RESULT = new Pair(new ListAST<VarDeclAST>(), m); :}
  ;
methods ::= RBLOCK {: RESULT = new ListAST<FuncDeclAST>(); :}
  | CLASSNAME:c IDNAME:i params:ps block:b methods:m {: RESULT = new ListAST(new FuncDeclAST(c, i, ps, b), m); :}
  ;

params ::= LPAREN paramlist:ps RPAREN {: RESULT = ps; :}
  ;
paramlist ::= {: RESULT = new ListAST<VarDeclAST>(); :}
  | nonemptyparamlist:ps {: RESULT = ps; :}
  ;
nonemptyparamlist ::= CLASSNAME:t IDNAME:x restparamlist:ps {: RESULT = new ListAST(new VarDeclAST(t, x), ps); :}
  ;
restparamlist ::= {: RESULT = new ListAST<VarDeclAST>(); :}
 | COMMA nonemptyparamlist:ps {: RESULT = ps; :}
 ;

// method body handling
block ::= LBLOCK blockvars:bv RBLOCK {: RESULT = new BlockAST(bv.head, bv.tail); :};
blockvars ::= stmts:s {: RESULT = new Pair(new ListAST<VarDeclAST>(), s); :}
  |   CLASSNAME:c IDNAME:i ENDSTMT blockvars:r {: RESULT = new Pair(new ListAST(new VarDeclAST(c, i), r.head), r.tail); :}
  ;

stmts ::= RETURN ENDSTMT reststmts:ss {: RESULT = new ListAST(new ReturnStmtAST(), ss); :}
  | RETURN exp:e ENDSTMT reststmts:ss {: RESULT = new ListAST(new ReturnStmtAST(e), ss); :}
  | IDNAME:i ASSIGN exp:e ENDSTMT reststmts:ss {: RESULT = new ListAST(new AssignStmtAST(new RefAST(i), e), ss); :}
  | atom:a DOT IDNAME:i ASSIGN exp:e ENDSTMT reststmts:ss {: RESULT = new ListAST(new AssignStmtAST(new MemberAccessAST(a, i), e), ss); :}
  | atom:a LPAREN explist:es RPAREN ENDSTMT reststmts:ss {: RESULT = new ListAST(new FuncCallAST(a, es), ss); :}
  | IF LPAREN exp:e RPAREN LBLOCK stmts:ssif RBLOCK ELSE LBLOCK stmts:sselse RBLOCK reststmts:ss {: RESULT = new ListAST(new IfStmtAST(e, ssif, sselse), ss); :}
  | WHILE LPAREN exp:e RPAREN whileblock:blk reststmts:ss {: RESULT = new ListAST(new WhileStmtAST(e, blk), ss); :}
  | READLN LPAREN IDNAME:i RPAREN ENDSTMT reststmts:ss {: RESULT = new ListAST(new ReadlnAST(new RefAST(i)), ss); :}
  | PRINTLN LPAREN exp:e RPAREN ENDSTMT reststmts:ss {: RESULT = new ListAST(new PrintlnAST(e), ss); :}
  ;
reststmts ::= {: RESULT = new ListAST<StmtAST>(); :}
  | stmts:ss {: RESULT = ss; :}
  ;
whileblock ::= LBLOCK RBLOCK {: RESULT = new ListAST<StmtAST>(); :}
  | LBLOCK stmts:ss RBLOCK {: RESULT = ss; :}
  ;

exp ::= atom:a {: RESULT = a; :}
  | stringliteral:s {: RESULT = s; :}
  | intconst:n {: RESULT = n; :}
  | boolconst:b {: RESULT = b; :}
  | aexp:e {: RESULT = e; :}
  | bexp:e {: RESULT = e; :}
  | bop:e {: RESULT = e; :}
  ;

explist ::= {: RESULT = new ListAST<AST>(); :}
  | nonemptyexplist:es {: RESULT = es; :}
  ;
nonemptyexplist ::= exp:e restexplist:es {: RESULT = new ListAST<AST>(e, es); :}
  ;
restexplist ::= {: RESULT = new ListAST<AST>(); :}
  | COMMA nonemptyexplist:es {: RESULT = es; :}
  ;

aexp ::= MINUS exp:e {: RESULT = new UnOpAST("-", e); :} %prec UMINUS
  | exp:a PLUS exp:b {: RESULT = new BinOpAST("+", a, b); :}
  | exp:a MINUS exp:b {: RESULT = new BinOpAST("-", a, b); :}
  | exp:a TIMES exp:b {: RESULT = new BinOpAST("*", a, b); :}
  | exp:a DIV exp:b {: RESULT = new BinOpAST("/", a, b); :}
  ;

bexp ::= NOT exp:e {: RESULT = new UnOpAST("!", e); :}
  | exp:a AND exp:b {: RESULT = new BinOpAST("&&", a, b); :}
  | exp:a OR exp:b {: RESULT = new BinOpAST("||", a, b); :}
  ;

bop ::= exp:a LT exp:b {: RESULT = new BinOpAST("<", a, b); :}
  | exp:a GT exp:b {: RESULT = new BinOpAST(">", a, b); :}
  | exp:a LEQ exp:b {: RESULT = new BinOpAST("<=", a, b); :}
  | exp:a GEQ exp:b {: RESULT = new BinOpAST(">=", a, b); :}
  | exp:a EQ exp:b {: RESULT = new BinOpAST("==", a, b); :}
  | exp:a NEQ exp:b {: RESULT = new BinOpAST("!=", a, b); :}
  ;

atom ::= NULL {: RESULT = new NullPtrAST(); :}
  | THIS {: RESULT = new ThisPtrAST(); :}
  | NEW CLASSNAME:c LPAREN RPAREN {: RESULT = new ConstructionAST(c); :}
  | LPAREN exp:e RPAREN {: RESULT = e; :}
  | IDNAME:i {: RESULT = new RefAST(i); :}
  | atom:a LPAREN explist:es RPAREN {: RESULT = new FuncCallAST(a, es); :}
  | atom:a DOT IDNAME:i {: RESULT = new MemberAccessAST(a, i); :}
  ;

intconst ::= INTCONST:n {: RESULT = new IntAST(n); :}
  ;
boolconst ::= BOOLCONST:b {: RESULT = new BoolAST(b); :}
  ;
stringliteral ::= STRING_LITERAL:s {: RESULT = new StringAST(s); :}
  ;