-- File generated by the BNF Converter.
-- Parser definition for use with Happy.
{
{-# OPTIONS_GHC -fno-warn-incomplete-patterns -fno-warn-overlapping-patterns #-}
{-# LANGUAGE PatternSynonyms #-}

module ParC4
  ( happyError
  , myLexer
  , pProgr
  , pListDec
  , pListStm
  , pDec
  , pListIdent
  , pStm
  , pExp
  , pExp0
  , pExp1
  , pExp2
  , pExp3
  , pOp1
  , pOp2
  , pOp0
  , pOp
  , pTyp
  ) where

import Prelude

import qualified AbsC4
import LexC4

}

%name pProgr Progr
%name pListDec ListDec
%name pListStm ListStm
%name pDec Dec
%name pListIdent ListIdent
%name pStm Stm
%name pExp Exp
%name pExp0 Exp0
%name pExp1 Exp1
%name pExp2 Exp2
%name pExp3 Exp3
%name pOp1 Op1
%name pOp2 Op2
%name pOp0 Op0
%name pOp Op
%name pTyp Typ
%monad { Err } { (>>=) } { return }
%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) }
  'double' { PT _ (TS _ 15) }
  'else' { PT _ (TS _ 16) }
  'if' { PT _ (TS _ 17) }
  'int' { PT _ (TS _ 18) }
  'main' { PT _ (TS _ 19) }
  'printInt' { PT _ (TS _ 20) }
  'return' { PT _ (TS _ 21) }
  'while' { PT _ (TS _ 22) }
  '{' { PT _ (TS _ 23) }
  '||' { PT _ (TS _ 24) }
  '}' { PT _ (TS _ 25) }
  L_Ident { PT _ (TV $$) }
  L_charac { PT _ (TC $$) }
  L_doubl { PT _ (TD $$) }
  L_integ { PT _ (TI $$) }
  L_quoted { PT _ (TL $$) }

%%

Ident :: { AbsC4.Ident }
Ident  : L_Ident { AbsC4.Ident $1 }

Char :: { Char }
Char  : L_charac { (read $1 ) :: Char }

Double :: { Double }
Double  : L_doubl  { (read $1 ) :: Double }

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

String :: { String }
String  : L_quoted { $1 }

Progr :: { AbsC4.Progr }
Progr
  : 'int' 'main' '(' ')' '{' ListDec ListStm '}' { AbsC4.Program $6 $7 }

ListDec :: { [AbsC4.Dec] }
ListDec
  : {- empty -} { [] }
  | Dec ';' ListDec { (:) $1 $3 }

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

Dec :: { AbsC4.Dec }
Dec
  : Typ ListIdent { AbsC4.Decl $1 $2 }

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

Stm :: { AbsC4.Stm }
Stm
  : 'if' '(' Exp ')' Stm 'else' Stm { AbsC4.SIf $3 $5 $7 }
  | 'printInt' '(' Exp ')' ';' { AbsC4.SPrint $3 }
  | 'return' Exp ';' { AbsC4.SReturn $2 }
  | 'while' '(' Exp ')' Stm { AbsC4.SWhile $3 $5 }
  | '{' ListDec ListStm '}' { AbsC4.SBlock $2 $3 }
  | Ident '++' ';' { AbsC4.SIncr $1 }
  | Ident '--' ';' { AbsC4.SDecr $1 }
  | Ident '=' Exp ';' { AbsC4.SAss $1 $3 }
  | Stm ';' { $1 }

Exp :: { AbsC4.Exp }
Exp
  : Exp0 { $1 }
  | Exp0 Op Exp0 { AbsC4.EOpA $1 $2 $3 }
  | Exp1 Op Exp1 { AbsC4.EOpE $1 $2 $3 }

Exp0 :: { AbsC4.Exp }
Exp0
  : Exp1 { $1 }
  | Exp1 Op0 Exp1 { AbsC4.EOpB $1 $2 $3 }

Exp1 :: { AbsC4.Exp }
Exp1
  : Exp1 Op1 Exp2 { AbsC4.EOpC $1 $2 $3 }
  | Exp2 { $1 }

Exp2 :: { AbsC4.Exp }
Exp2
  : Exp2 Op2 Exp3 { AbsC4.EOpD $1 $2 $3 }
  | Exp3 { $1 }

Exp3 :: { AbsC4.Exp }
Exp3
  : '(' Exp ')' { $2 }
  | Char { AbsC4.EChar $1 }
  | Double { AbsC4.EDouble $1 }
  | Integer { AbsC4.EInt $1 }
  | String { AbsC4.EString $1 }
  | Ident { AbsC4.EVar $1 }

Op1 :: { AbsC4.Op }
Op1
  : '+' { AbsC4.OPlus }
  | '-' { AbsC4.OMinus }

Op2 :: { AbsC4.Op }
Op2
  : '*' { AbsC4.OTimes }

Op0 :: { AbsC4.Op }
Op0
  : '<' { AbsC4.OLt }
  | '==' { AbsC4.OEq }
  | '>' { AbsC4.OGt }

Op :: { AbsC4.Op }
Op
  : '&&' { AbsC4.OAnd }
  | '||' { AbsC4.OOr }

Typ :: { AbsC4.Typ }
Typ
  : 'double' { AbsC4.TDouble }
  | 'int' { AbsC4.TInt }

{

type Err = Either String

happyError :: [Token] -> Err a
happyError ts = Left $
  "syntax error at " ++ tokenPos ts ++ 
  case ts of
    []      -> []
    [Err _] -> " due to lexer error"
    t:_     -> " before `" ++ (prToken t) ++ "'"

myLexer :: String -> [Token]
myLexer = tokens

}