-- This Happy file was machine-generated by the BNF converter
{
module Parsyntax where
import Abssyntax
import Lexsyntax
import ErrM
}

%name pProgram Program

-- no lexer declaration
%monad { Err } { thenM } { returnM }
%tokentype { Token }

%token 
 ';' { PT _ (TS ";") }
 '{' { PT _ (TS "{") }
 '}' { PT _ (TS "}") }
 '=' { PT _ (TS "=") }
 '(' { PT _ (TS "(") }
 ')' { PT _ (TS ")") }
 '++' { PT _ (TS "++") }
 '--' { PT _ (TS "--") }
 '-' { PT _ (TS "-") }
 '!' { PT _ (TS "!") }
 ',' { PT _ (TS ",") }
 '<' { PT _ (TS "<") }
 '<=' { PT _ (TS "<=") }
 '>' { PT _ (TS ">") }
 '>=' { PT _ (TS ">=") }
 '==' { PT _ (TS "==") }
 '!=' { PT _ (TS "!=") }
 '+' { PT _ (TS "+") }
 '*' { PT _ (TS "*") }
 '/' { PT _ (TS "/") }
 'bool' { PT _ (TS "bool") }
 'else' { PT _ (TS "else") }
 'false' { PT _ (TS "false") }
 'if' { PT _ (TS "if") }
 'int' { PT _ (TS "int") }
 'print' { PT _ (TS "print") }
 'readBool' { PT _ (TS "readBool") }
 'readInt' { PT _ (TS "readInt") }
 'return' { PT _ (TS "return") }
 'true' { PT _ (TS "true") }
 'while' { PT _ (TS "while") }

L_ident  { PT _ (TV $$) }
L_integ  { PT _ (TI $$) }
L_err    { _ }


%%

Ident   :: { Ident }   : L_ident  { Ident $1 }
Integer :: { Integer } : L_integ  { (read $1) :: Integer }

Bool :: { Bool }
Bool : 'true' { True } 
  | 'false' { False }


Type :: { Type }
Type : 'int' { TInt } 
  | 'bool' { TBool }


Program :: { Program }
Program : ListFuncStm { Program (reverse $1) } 


Stm :: { Stm }
Stm : Exp ';' { SExp $1 } 
  | '{' ListStm '}' { SBlock (reverse $2) }
  | Type Ident '=' Exp ';' { SDecl $1 $2 $4 }
  | Type Ident ';' { SDeclD $1 $2 }
  | 'while' '(' Exp ')' Stm { SWhile $3 $5 }
  | 'if' '(' Exp ')' Stm 'else' Stm { SIf $3 $5 $7 }
  | 'if' '(' Exp ')' Stm { if_ $3 $5 }
  | 'print' Exp ';' { SPrint $2 }
  | 'return' Exp ';' { SReturn $2 }


Exp :: { Exp }
Exp : Ident '=' Exp { EAss $1 $3 } 
  | Exp1 Op0 Exp1 { compExp_ $1 $2 $3 }
  | Exp1 { $1 }


Exp1 :: { Exp }
Exp1 : Exp1 Op1 Exp2 { op1_ $1 $2 $3 } 
  | Exp2 { $1 }


Exp2 :: { Exp }
Exp2 : Exp2 Op2 Exp3 { op2_ $1 $2 $3 } 
  | Exp3 { $1 }


Exp3 :: { Exp }
Exp3 : Ident '++' { postIncr_ $1 } 
  | Ident '--' { postDecr_ $1 }
  | Ident { EVar $1 }
  | Integer { EInt $1 }
  | Bool { EBool $1 }
  | '-' Exp3 { ENeg $2 }
  | '!' Exp3 { ENot $2 }
  | 'readInt' { EReadI }
  | 'readBool' { EReadB }
  | Ident '(' ListExp ')' { EFunc $1 $3 }
  | '(' Exp ')' { $2 }


ListStm :: { [Stm] }
ListStm : {- empty -} { [] } 
  | ListStm Stm { flip (:) $1 $2 }


ListExp :: { [Exp] }
ListExp : {- empty -} { [] } 
  | Exp { (:[]) $1 }
  | Exp ',' ListExp { (:) $1 $3 }


Decl :: { Decl }
Decl : Type Ident { Decl $1 $2 } 


ListDecl :: { [Decl] }
ListDecl : {- empty -} { [] } 
  | Decl { (:[]) $1 }
  | Decl ',' ListDecl { (:) $1 $3 }


Func :: { Func }
Func : Type Ident '(' ListDecl ')' '{' ListStm '}' { Func $1 $2 $4 (reverse $7) } 


ListFunc :: { [Func] }
ListFunc : {- empty -} { [] } 
  | ListFunc Func { flip (:) $1 $2 }


FuncStm :: { FuncStm }
FuncStm : Stm { S $1 } 
  | Func { F $1 }


ListFuncStm :: { [FuncStm] }
ListFuncStm : {- empty -} { [] } 
  | ListFuncStm FuncStm { flip (:) $1 $2 }


Op0 :: { Op }
Op0 : '<' { Lt } 
  | '<=' { ELt }
  | '>' { Gt }
  | '>=' { EGt }
  | '==' { Eq }
  | '!=' { NEq }


Op1 :: { Op }
Op1 : '+' { Plus } 
  | '-' { Minus }


Op2 :: { Op }
Op2 : '*' { Times } 
  | '/' { Div }


Op :: { Op }
Op : Op1 { $1 } 
  | Op2 { $1 }
  | Op0 { $1 }



{

returnM :: a -> Err a
returnM = return

thenM :: Err a -> (a -> Err b) -> Err b
thenM = (>>=)

happyError :: [Token] -> Err a
happyError ts =
  Bad $ "syntax error at " ++ tokenPos ts ++ if null ts then [] else (" before " ++ unwords (map prToken (take 4 ts)))

myLexer = tokens
if_ e_ s_ = SIf e_ s_ SNoop
compExp_ e1_ o_ e2_ = BiOpExp e1_ o_ e2_
op1_ e1_ o_ e2_ = BiOpExp e1_ o_ e2_
op2_ e1_ o_ e2_ = BiOpExp e1_ o_ e2_
postIncr_ i_ = EPost i_ Plus
postDecr_ i_ = EPost i_ Minus
}