/*
 * parser.cup -- SPL parser specification
 */

package parse;

import java_cup.runtime.*;
import absyn.*;
import sym.*;

parser code {:

  public void syntax_error(Symbol currToken) {
    System.out.println(
      "**** Error: syntax error" +
      " in line " + currToken.left +
      ", column " + currToken.right
    );
    System.exit(0);
  }
:}

/* Terminals (tokens returned by lexer). */

terminal		LPAREN, RPAREN, LBRACK, RBRACK, LCURL, RCURL;
terminal		EQ, NE, LT, LE, GT, GE;
terminal		ASGN, COLON, COMMA, SEMIC;
terminal		PLUS, MINUS, STAR, SLASH;
terminal String	IDENT;
terminal Integer INTLIT;
terminal		WHILE, ELSE, OF, IF, ARRAY, PROC, REF, TYPE, VAR;

/*non terminals*/

non terminal	DecList		program, typoderProcDef, parameterListe, varDeks, funkSignatur;
non terminal	TypeDec 	typDef;
non terminal	ExpList		argumentenListe, argument;
non terminal	ParDec 		parameter;
non terminal	ProcDec 	procDef;
non terminal	VarDec 		varDeklaration;
non terminal	StmList 	anweisungen;
non terminal	Stm			anweisung, funkAufruf, elif, schleife, zuweisung, folge, optElse;
non terminal	Exp			ausdruck, bedingung, faktor, term, uminus;
non terminal	Ty			feldTyp;
non terminal	Var 		einfachVar, feldVar, variable, konstVar;
non terminal	Integer		verglOp;

/* Startzeichen*/

start with program;

/*Regeln*/
program			::= typoderProcDef:e1 program:e2
				{: RESULT = new DecList(e1, e2); :}
				| typoderProcDef:e3
				{: RESULT = new DecList(e3, new DecList()); :};

typoderProcDef 	::= typDef:e1
				{: RESULT = e1; :}
				| procDef:e2
				{: RESULT = e2; :};

typDef			::= TYPE:t IDENT:e1 EQ feldTyp:e2 SEMIC
				{: RESULT = new TypeDec(tleft, tright, e1, e2); :};

procDef			::= PROC:p IDENT:e1 funkSignatur:e2 LCURL varDeks:e3 anweisungen:e4 RCURL
				{: RESULT = new ProcDec(pleft, pright, newSym(e1), e2, e3, e4); :};

feldTyp			::= IDENT:e1
				{: RESULT = new NameTy(e1left, e1right, newSym(e1); :}
				| ARRAY:a LBRACK ausdruck:e2 RBRACK OF feldTyp:e3
				{: RESULT = new ArrayTy(aleft, aright, e2, e3); :};

funkSignatur	::= LPAREN parameterListe:e1 RPAREN
				{: RESULT = e1; :};

parameterListe 	::= parameter:e1
				{: RESULT = e1; :}
				| parameter:e1 COMMA parameterListe:e2
				{: RESULT = new DecList(e1, e2); :}
				|
				{: RESULT = new DecList(); :};

parameter		::= IDENT:e1 COLON IDENT:e2
				{: RESULT = new ParDec(e1left, e1right, e1,, e2 false); :}
				| REF:r IDENT:e1 COLON IDENT:e2
				{: RESULT = new ParDec(rleft, rright, e1, e2, true); :};

varDeks			::= varDeklaration:e1 varDeks:e2
				{: RESULT = new DecList(e1, e2); :};

varDeklaration	::= VAR:v IDENT:e1 COLON feldTyp:e2 SEMIC
				{: RESULT = new VarDec(vleft, vright, newSym(e1), e2); :};

anweisungen		::= anweisung:e1 anweisungen:e2
				{: RESULT = new StmList(e1, e2); :}
				|
				{: RESULT = new StmList(); :};

anweisung		::= zuweisung:e1
				{: RESULT = e1; :}
				| funkAufruf:e1
				{: RESULT = e1; :}
				| schleife:e1
				{: RESULT = e1; :}
				| elif:e1
				{: RESULT = e1; :}
				| folge:e1
				{: RESULT = e1; :}
				| SEMIC:e1
				{: RESULT = new EmptyStm(e1left, e1right); :};

funkAufruf		::= IDENT:e1 LPAREN argumentenListe:e2 RPAREN SEMIC
				{: RESULT = new CallStm(e1left, e1right, newSym(e1), e2); :};

folge			::= LCURL:l anweisungen:e1 RCURL
				{: RESULT = new CompStm(lleft, lright, e1); :};

argumentenListe	::= argument:e1
				{: RESULT = e1; :}
				|
				{: RESULT = new ExpList(); :};

argument		::= ausdruck:e1
				{: RESULT = new ExpList(e1, new ExpList()); :}
				| ausdruck:e1 COMMA argumentenListe:e2
				{: RESULT = new ExpList(e1, e2); :};

zuweisung 		::= variable:e1 ASGN ausdruck:e2 SEMIC
				{: RESULT = new AssignStm(e1left, e1right, e1, e2); :};



ausdruck		::= ausdruck:e1 PLUS term:e2
				{: RESULT = new OpExp(e1left, e1right, OpExp.ADD, e1, e2 ); :}

				| ausdruck:e1 MINUS term:e2
				{: RESULT = new OpExp(e1left, e1right, OpExp.SUB, e1, e2 ); :}
				| term:e1
				{: RESULT = e1; :};

term 			::= term:e1 STAR uminus:e2
				{: RESULT = new OpExp(e1left, e1right, OpExp.MUL, e1, e2 ); :}
				| term:e1 SLASH uminus:e2
				{: RESULT = new OpExp(e1left, e1right, OpExp.DIV, e1, e2 ); :}
				| uminus:e1
				{: RESULT = e1; :};

uminus			::= MINUS faktor:e1
				{: RESULT = e1; :}
				| faktor:e1
				{: RESULT = e1; :};

faktor			::= konstante:e1
				{: RESULT = e1; :}
				| variale:e1
				{: RESULT = e1; :}
				| LPAREN ausdruck:e1 RPAREN
				{: RESULT = e1; :};

konstante		INTLIT:e1
				{: RESULT = new IntExp(e1left, e1right, e1); :};

variable 		::= einfachVar:e1
				{: RESULT = e1; :}
				| feldVar:e1
				{: RESULT = e1; :};

einfachVar		::= IDENT:e1
				{: RESULT = new VarExp(e1left, e1right, new SimpleVar(e1left, e1right, newSym(e1)); :};

feldVar			::= variable:v LBRACK ausdruck:e1 RBRACK
				{: RESULT = new ArrayVar(vleft, vright, v, e1); :};

elif			::= IF:i LPAREN bedingung:e1 RPAREN anweisung:e2 optElse:e3
				{: RESULT = new IfStm(ileft, iright, e1, e2, e3); :};

optElse			::= ELSE anweisung:e1
				{: RESULT = e1; :}
				|
				{: RESULT = null; :};

bedingung		::= ausdruck:e1 verglOp:e2 ausdruck:e3
				{: RESULT = new OpExp(e1left, e1right, e2, e1, e3 ); :}
				| ausdruck:e1
				{: RESULT = e1; :};

verglOp			::= EQ
				{: RESULT = OpExp.EQU; :}
				| NE
				{: RESULT = OpExp.NEQ; :}
				| LT
				{: RESULT = OpExp.LST; :}
				| LE
				{: RESULT = OpExp.LSE; :}
				| GT
				{: RESULT = OpExp.GRT; :}
				| GE
				{: RESULT = OpExp.GRE; :};

schleife		::= WHILE:w LPAREN bedingung:e1 RPAREN anweisung:e2
				{: RESULT = new WhileStm(wleft, wright, e1, e2); :};