-- 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 ParCpp
  ( happyError
  , myLexer
  , pProgram
  , pDef
  , pListDef
  , pArg
  , pListArg
  , pStm
  , pListStm
  , pExp15
  , pExp14
  , pExp13
  , pExp12
  , pExp11
  , pExp9
  , pExp8
  , pExp4
  , pExp3
  , pExp2
  , pExp
  , pExp1
  , pExp5
  , pExp6
  , pExp7
  , pExp10
  , pListExp
  , pType
  , pListId
  ) where

import Prelude

import qualified AbsCpp
import LexCpp

}

%name pProgram Program
%name pDef Def
%name pListDef ListDef
%name pArg Arg
%name pListArg ListArg
%name pStm Stm
%name pListStm ListStm
%name pExp15 Exp15
%name pExp14 Exp14
%name pExp13 Exp13
%name pExp12 Exp12
%name pExp11 Exp11
%name pExp9 Exp9
%name pExp8 Exp8
%name pExp4 Exp4
%name pExp3 Exp3
%name pExp2 Exp2
%name pExp Exp
%name pExp1 Exp1
%name pExp5 Exp5
%name pExp6 Exp6
%name pExp7 Exp7
%name pExp10 Exp10
%name pListExp ListExp
%name pType Type
%name pListId ListId
%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) }
  '=' { PT _ (TS _ 15) }
  '==' { PT _ (TS _ 16) }
  '>' { PT _ (TS _ 17) }
  '>=' { PT _ (TS _ 18) }
  'bool' { PT _ (TS _ 19) }
  'double' { PT _ (TS _ 20) }
  'else' { PT _ (TS _ 21) }
  'false' { PT _ (TS _ 22) }
  'if' { PT _ (TS _ 23) }
  'int' { PT _ (TS _ 24) }
  'return' { PT _ (TS _ 25) }
  'string' { PT _ (TS _ 26) }
  'true' { PT _ (TS _ 27) }
  'void' { PT _ (TS _ 28) }
  'while' { PT _ (TS _ 29) }
  '{' { PT _ (TS _ 30) }
  '||' { PT _ (TS _ 31) }
  '}' { PT _ (TS _ 32) }
  L_doubl { PT _ (TD $$) }
  L_integ { PT _ (TI $$) }
  L_quoted { PT _ (TL $$) }
  L_Id { PT _ (T_Id $$) }

%%

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

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

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

Id :: { AbsCpp.Id }
Id : L_Id { AbsCpp.Id $1 }

Program :: { AbsCpp.Program }
Program
  : ListDef { AbsCpp.PDefs $1 }

Def :: { AbsCpp.Def }
Def
  : Type Id '(' ListArg ')' '{' ListStm '}' { AbsCpp.DFun $1 $2 $4 $7 }

ListDef :: { [AbsCpp.Def] }
ListDef
  : {- empty -} { [] }
  | Def ListDef { (:) $1 $2 }

Arg :: { AbsCpp.Arg }
Arg
  : Type Id { AbsCpp.ADecl $1 $2 }

ListArg :: { [AbsCpp.Arg] }
ListArg
  : {- empty -} { [] }
  | Arg { (:[]) $1 }
  | Arg ',' ListArg { (:) $1 $3 }

Stm :: { AbsCpp.Stm }
Stm
  : 'if' '(' Exp ')' Stm 'else' Stm { AbsCpp.SIfElse $3 $5 $7 }
  | 'return' ';' { AbsCpp.SReturnVoid }
  | 'return' Exp ';' { AbsCpp.SReturn $2 }
  | 'while' '(' Exp ')' Stm { AbsCpp.SWhile $3 $5 }
  | '{' ListStm '}' { AbsCpp.SBlock $2 }
  | Exp ';' { AbsCpp.SExp $1 }
  | Type Id '=' Exp ';' { AbsCpp.SInit $1 $2 $4 }
  | Type ListId ';' { AbsCpp.SDecls $1 $2 }

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

Exp15 :: { AbsCpp.Exp }
Exp15
  : '(' Exp ')' { $2 }
  | 'false' { AbsCpp.EFalse }
  | 'true' { AbsCpp.ETrue }
  | Double { AbsCpp.EDouble $1 }
  | Integer { AbsCpp.EInt $1 }
  | String { AbsCpp.EString $1 }
  | Id { AbsCpp.EId $1 }
  | Id '(' ListExp ')' { AbsCpp.EApp $1 $3 }

Exp14 :: { AbsCpp.Exp }
Exp14
  : Exp15 { $1 }
  | Exp15 '++' { AbsCpp.EPIncr $1 }
  | Exp15 '--' { AbsCpp.EPDecr $1 }

Exp13 :: { AbsCpp.Exp }
Exp13
  : '++' Exp14 { AbsCpp.EIncr $2 }
  | '--' Exp14 { AbsCpp.EDecr $2 }
  | Exp14 { $1 }

Exp12 :: { AbsCpp.Exp }
Exp12
  : Exp12 '*' Exp13 { AbsCpp.ETimes $1 $3 }
  | Exp12 '/' Exp13 { AbsCpp.EDiv $1 $3 }
  | Exp13 { $1 }

Exp11 :: { AbsCpp.Exp }
Exp11
  : Exp11 '+' Exp12 { AbsCpp.EPlus $1 $3 }
  | Exp11 '-' Exp12 { AbsCpp.EMinus $1 $3 }
  | Exp12 { $1 }

Exp9 :: { AbsCpp.Exp }
Exp9
  : Exp9 '<' Exp10 { AbsCpp.ELt $1 $3 }
  | Exp9 '<=' Exp10 { AbsCpp.ELtEq $1 $3 }
  | Exp9 '>' Exp10 { AbsCpp.EGt $1 $3 }
  | Exp9 '>=' Exp10 { AbsCpp.EGtEq $1 $3 }
  | Exp10 { $1 }

Exp8 :: { AbsCpp.Exp }
Exp8
  : Exp8 '!=' Exp9 { AbsCpp.ENEq $1 $3 }
  | Exp8 '==' Exp9 { AbsCpp.EEq $1 $3 }
  | Exp9 { $1 }

Exp4 :: { AbsCpp.Exp }
Exp4
  : Exp4 '&&' Exp5 { AbsCpp.EAnd $1 $3 }
  | Exp5 { $1 }

Exp3 :: { AbsCpp.Exp }
Exp3
  : Exp3 '||' Exp4 { AbsCpp.EOr $1 $3 }
  | Exp4 { $1 }

Exp2 :: { AbsCpp.Exp }
Exp2
  : Exp3 { $1 }
  | Exp3 '=' Exp2 { AbsCpp.EAss $1 $3 }

Exp :: { AbsCpp.Exp }
Exp
  : Exp1 { $1 }

Exp1 :: { AbsCpp.Exp }
Exp1
  : Exp2 { $1 }

Exp5 :: { AbsCpp.Exp }
Exp5
  : Exp6 { $1 }

Exp6 :: { AbsCpp.Exp }
Exp6
  : Exp7 { $1 }

Exp7 :: { AbsCpp.Exp }
Exp7
  : Exp8 { $1 }

Exp10 :: { AbsCpp.Exp }
Exp10
  : Exp11 { $1 }

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

Type :: { AbsCpp.Type }
Type
  : 'bool' { AbsCpp.Type_bool }
  | 'double' { AbsCpp.Type_double }
  | 'int' { AbsCpp.Type_int }
  | 'string' { AbsCpp.Type_string }
  | 'void' { AbsCpp.Type_void }

ListId :: { [AbsCpp.Id] }
ListId
  : Id { (:[]) $1 }
  | Id ',' ListId { (:) $1 $3 }

{

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

}