ParAssignment.y

-- This Happy file was machine-generated by the BNF converter
{
{-# OPTIONS_GHC -fno-warn-incomplete-patterns -fno-warn-overlapping-patterns #-}
module ParAssignment where
import AbsAssignment
import LexAssignment
import ErrM

}

%name pProgram Program
%name pBlock Block
%name pPar Par
%name pFun Fun
%name pStm Stm
%name pListBlock ListBlock
%name pListStm ListStm
%name pListExp ListExp
%name pListIdent ListIdent
%name pListPar ListPar
%name pType Type
%name pExp Exp
%name pExp1 Exp1
%name pExp2 Exp2
%name pExp3 Exp3
%name pExp4 Exp4
%name pExp5 Exp5
%name pExp6 Exp6
%name pExp7 Exp7
%name pExp8 Exp8
%name pExp9 Exp9
%name pExp11 Exp11
%name pExp10 Exp10

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

%token
  '!=' { PT _ (TS _ 1) }
  '&&' { PT _ (TS _ 2) }
  '(' { PT _ (TS _ 3) }
  ')' { PT _ (TS _ 4) }
  '*' { PT _ (TS _ 5) }
  '+' { PT _ (TS _ 6) }
  '++' { PT _ (TS _ 7) }
  ',' { PT _ (TS _ 8) }
  '-' { PT _ (TS _ 9) }
  '--' { PT _ (TS _ 10) }
  '/' { PT _ (TS _ 11) }
  ';' { PT _ (TS _ 12) }
  '<' { PT _ (TS _ 13) }
  '<=' { PT _ (TS _ 14) }
  '=' { PT _ (TS _ 15) }
  '==' { PT _ (TS _ 16) }
  '>' { PT _ (TS _ 17) }
  '>=' { PT _ (TS _ 18) }
  'False' { PT _ (TS _ 19) }
  'True' { PT _ (TS _ 20) }
  'bool' { PT _ (TS _ 21) }
  'double' { PT _ (TS _ 22) }
  'else' { PT _ (TS _ 23) }
  'false' { PT _ (TS _ 24) }
  'if' { PT _ (TS _ 25) }
  'int' { PT _ (TS _ 26) }
  'print' { PT _ (TS _ 27) }
  'return' { PT _ (TS _ 28) }
  'string' { PT _ (TS _ 29) }
  'true' { PT _ (TS _ 30) }
  'void' { PT _ (TS _ 31) }
  'while' { PT _ (TS _ 32) }
  '{' { PT _ (TS _ 33) }
  '||' { PT _ (TS _ 34) }
  '}' { PT _ (TS _ 35) }

L_ident  { PT _ (TV $$) }
L_integ  { PT _ (TI $$) }
L_doubl  { PT _ (TD $$) }
L_quoted { PT _ (TL $$) }


%%

Ident   :: { Ident }   : L_ident  { Ident $1 }
Integer :: { Integer } : L_integ  { (read ( $1)) :: Integer }
Double  :: { Double }  : L_doubl  { (read ( $1)) :: Double }
String  :: { String }  : L_quoted {  $1 }

Program :: { Program }
Program : ListBlock { PBlocks (reverse $1) } 


Block :: { Block }
Block : Stm { BStm1 $1 } 
  | '{' ListStm '}' { BStms (reverse $2) }


Par :: { Par }
Par : Type Ident { Para $1 $2 } 


Fun :: { Fun }
Fun : Type Ident '(' ListPar ')' Block { Func $1 $2 $4 $6 } 


Stm :: { Stm }
Stm : Fun { SFunc $1 } 
  | Exp ';' { SExp $1 }
  | Type ListIdent ';' { SValDec $1 $2 }
  | Type ListExp ';' { SValInit $1 $2 }
  | 'return' Exp ';' { SReturn $2 }
  | 'return' ';' { SReturnE }
  | 'while' '(' Exp ')' Block { SWhile $3 $5 }
  | 'if' '(' Exp ')' Block 'else' Block { SIfElse $3 $5 $7 }
  | 'print' Exp ';' { SPrint $2 }


ListBlock :: { [Block] }
ListBlock : {- empty -} { [] } 
  | ListBlock Block { flip (:) $1 $2 }


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


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


ListIdent :: { [Ident] }
ListIdent : Ident { (:[]) $1 } 
  | Ident ',' ListIdent { (:) $1 $3 }


ListPar :: { [Par] }
ListPar : {- empty -} { [] } 
  | Par { (:[]) $1 }
  | Par ',' ListPar { (:) $1 $3 }


Type :: { Type }
Type : 'bool' { TypeBool } 
  | 'int' { TypeInt }
  | 'double' { TypeDouble }
  | 'string' { TypeString }
  | 'void' { TypeVoid }


Exp :: { Exp }
Exp : Ident '=' Exp1 { EAssign $1 $3 } 
  | Exp1 { $1 }


Exp1 :: { Exp }
Exp1 : Exp1 '||' Exp2 { EDisjunction $1 $3 } 
  | Exp2 { $1 }


Exp2 :: { Exp }
Exp2 : Exp2 '&&' Exp3 { EConjunction $1 $3 } 
  | Exp3 { $1 }


Exp3 :: { Exp }
Exp3 : Exp3 '==' Exp4 { EEq $1 $3 } 
  | Exp3 '!=' Exp4 { ENeq $1 $3 }
  | Exp4 { $1 }


Exp4 :: { Exp }
Exp4 : Exp4 '>' Exp5 { EGt $1 $3 } 
  | Exp4 '<' Exp5 { ELt $1 $3 }
  | Exp4 '>=' Exp5 { EGte $1 $3 }
  | Exp4 '<=' Exp5 { ELte $1 $3 }
  | Exp5 { $1 }


Exp5 :: { Exp }
Exp5 : Exp5 '+' Exp6 { EAdd $1 $3 } 
  | Exp5 '-' Exp6 { ESub $1 $3 }
  | Exp6 { $1 }


Exp6 :: { Exp }
Exp6 : Exp6 '*' Exp7 { EMul $1 $3 } 
  | Exp6 '/' Exp7 { EDiv $1 $3 }
  | Exp7 { $1 }


Exp7 :: { Exp }
Exp7 : '-' Exp8 { ENeg $2 } 
  | Exp8 { $1 }


Exp8 :: { Exp }
Exp8 : '++' Exp9 { EPreInc $2 } 
  | '--' Exp9 { EPreDec $2 }
  | Exp9 { $1 }


Exp9 :: { Exp }
Exp9 : Exp10 '++' { EPostInc $1 } 
  | Exp10 '--' { EPostDec $1 }
  | Exp10 { $1 }


Exp11 :: { Exp }
Exp11 : Ident { EId $1 } 
  | Integer { EInt $1 }
  | 'true' { ETrue }
  | 'false' { EFalse }
  | 'True' { ETrue }
  | 'False' { EFalse }
  | Double { EDouble $1 }
  | String { EString $1 }
  | Ident '(' ListExp ')' { EFunc $1 $3 }
  | '(' Exp ')' { $2 }


Exp10 :: { Exp }
Exp10 : Exp11 { $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 ++ 
  case ts of
    [] -> []
    [Err _] -> " due to lexer error"
    _ -> " before " ++ unwords (map (id . prToken) (take 4 ts))

myLexer = tokens
}