-- 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_internal Program
%name pDef_internal Def
%name pListDef_internal ListDef
%name pArg_internal Arg
%name pListArg_internal ListArg
%name pStm_internal Stm
%name pListStm_internal ListStm
%name pExp15_internal Exp15
%name pExp14_internal Exp14
%name pExp13_internal Exp13
%name pExp12_internal Exp12
%name pExp11_internal Exp11
%name pExp9_internal Exp9
%name pExp8_internal Exp8
%name pExp4_internal Exp4
%name pExp3_internal Exp3
%name pExp2_internal Exp2
%name pExp_internal Exp
%name pExp1_internal Exp1
%name pExp5_internal Exp5
%name pExp6_internal Exp6
%name pExp7_internal Exp7
%name pExp10_internal Exp10
%name pListExp_internal ListExp
%name pType_internal Type
%name pListId_internal 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 :: { (AbsCpp.BNFC'Position, Double) }
Double  : L_doubl  { (uncurry AbsCpp.BNFC'Position (tokenLineCol $1), (read (tokenText $1) ) :: Double) }

Integer :: { (AbsCpp.BNFC'Position, Integer) }
Integer  : L_integ  { (uncurry AbsCpp.BNFC'Position (tokenLineCol $1), (read (tokenText $1) ) :: Integer) }

String :: { (AbsCpp.BNFC'Position, String) }
String  : L_quoted { (uncurry AbsCpp.BNFC'Position (tokenLineCol $1), ((\(PT _ (TL s)) -> s) $1)) }

Id :: { (AbsCpp.BNFC'Position, AbsCpp.Id) }
Id : L_Id { (uncurry AbsCpp.BNFC'Position (tokenLineCol $1), AbsCpp.Id (tokenText $1)) }

Program :: { (AbsCpp.BNFC'Position, AbsCpp.Program) }
Program
  : ListDef { (fst $1, AbsCpp.PDefs (fst $1) (snd $1)) }

Def :: { (AbsCpp.BNFC'Position, AbsCpp.Def) }
Def
  : Type Id '(' ListArg ')' '{' ListStm '}' { (fst $1, AbsCpp.DFun (fst $1) (snd $1) (snd $2) (snd $4) (snd $7)) }

ListDef :: { (AbsCpp.BNFC'Position, [AbsCpp.Def]) }
ListDef
  : {- empty -} { (AbsCpp.BNFC'NoPosition, []) }
  | Def ListDef { (fst $1, (:) (snd $1) (snd $2)) }

Arg :: { (AbsCpp.BNFC'Position, AbsCpp.Arg) }
Arg
  : Type Id { (fst $1, AbsCpp.ADecl (fst $1) (snd $1) (snd $2)) }

ListArg :: { (AbsCpp.BNFC'Position, [AbsCpp.Arg]) }
ListArg
  : {- empty -} { (AbsCpp.BNFC'NoPosition, []) }
  | Arg { (fst $1, (:[]) (snd $1)) }
  | Arg ',' ListArg { (fst $1, (:) (snd $1) (snd $3)) }

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

ListStm :: { (AbsCpp.BNFC'Position, [AbsCpp.Stm]) }
ListStm
  : {- empty -} { (AbsCpp.BNFC'NoPosition, []) }
  | Stm ListStm { (fst $1, (:) (snd $1) (snd $2)) }

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

Exp14 :: { (AbsCpp.BNFC'Position, AbsCpp.Exp) }
Exp14
  : Exp15 { (fst $1, (snd $1)) }
  | Exp15 '++' { (fst $1, AbsCpp.EPIncr (fst $1) (snd $1)) }
  | Exp15 '--' { (fst $1, AbsCpp.EPDecr (fst $1) (snd $1)) }

Exp13 :: { (AbsCpp.BNFC'Position, AbsCpp.Exp) }
Exp13
  : '++' Exp14 { (uncurry AbsCpp.BNFC'Position (tokenLineCol $1), AbsCpp.EIncr (uncurry AbsCpp.BNFC'Position (tokenLineCol $1)) (snd $2)) }
  | '--' Exp14 { (uncurry AbsCpp.BNFC'Position (tokenLineCol $1), AbsCpp.EDecr (uncurry AbsCpp.BNFC'Position (tokenLineCol $1)) (snd $2)) }
  | Exp14 { (fst $1, (snd $1)) }

Exp12 :: { (AbsCpp.BNFC'Position, AbsCpp.Exp) }
Exp12
  : Exp12 '*' Exp13 { (fst $1, AbsCpp.ETimes (fst $1) (snd $1) (snd $3)) }
  | Exp12 '/' Exp13 { (fst $1, AbsCpp.EDiv (fst $1) (snd $1) (snd $3)) }
  | Exp13 { (fst $1, (snd $1)) }

Exp11 :: { (AbsCpp.BNFC'Position, AbsCpp.Exp) }
Exp11
  : Exp11 '+' Exp12 { (fst $1, AbsCpp.EPlus (fst $1) (snd $1) (snd $3)) }
  | Exp11 '-' Exp12 { (fst $1, AbsCpp.EMinus (fst $1) (snd $1) (snd $3)) }
  | Exp12 { (fst $1, (snd $1)) }

Exp9 :: { (AbsCpp.BNFC'Position, AbsCpp.Exp) }
Exp9
  : Exp9 '<' Exp10 { (fst $1, AbsCpp.ELt (fst $1) (snd $1) (snd $3)) }
  | Exp9 '<=' Exp10 { (fst $1, AbsCpp.ELtEq (fst $1) (snd $1) (snd $3)) }
  | Exp9 '>' Exp10 { (fst $1, AbsCpp.EGt (fst $1) (snd $1) (snd $3)) }
  | Exp9 '>=' Exp10 { (fst $1, AbsCpp.EGtEq (fst $1) (snd $1) (snd $3)) }
  | Exp10 { (fst $1, (snd $1)) }

Exp8 :: { (AbsCpp.BNFC'Position, AbsCpp.Exp) }
Exp8
  : Exp8 '!=' Exp9 { (fst $1, AbsCpp.ENEq (fst $1) (snd $1) (snd $3)) }
  | Exp8 '==' Exp9 { (fst $1, AbsCpp.EEq (fst $1) (snd $1) (snd $3)) }
  | Exp9 { (fst $1, (snd $1)) }

Exp4 :: { (AbsCpp.BNFC'Position, AbsCpp.Exp) }
Exp4
  : Exp4 '&&' Exp5 { (fst $1, AbsCpp.EAnd (fst $1) (snd $1) (snd $3)) }
  | Exp5 { (fst $1, (snd $1)) }

Exp3 :: { (AbsCpp.BNFC'Position, AbsCpp.Exp) }
Exp3
  : Exp3 '||' Exp4 { (fst $1, AbsCpp.EOr (fst $1) (snd $1) (snd $3)) }
  | Exp4 { (fst $1, (snd $1)) }

Exp2 :: { (AbsCpp.BNFC'Position, AbsCpp.Exp) }
Exp2
  : Exp3 { (fst $1, (snd $1)) }
  | Exp3 '=' Exp2 { (fst $1, AbsCpp.EAss (fst $1) (snd $1) (snd $3)) }

Exp :: { (AbsCpp.BNFC'Position, AbsCpp.Exp) }
Exp
  : Exp1 { (fst $1, (snd $1)) }

Exp1 :: { (AbsCpp.BNFC'Position, AbsCpp.Exp) }
Exp1
  : Exp2 { (fst $1, (snd $1)) }

Exp5 :: { (AbsCpp.BNFC'Position, AbsCpp.Exp) }
Exp5
  : Exp6 { (fst $1, (snd $1)) }

Exp6 :: { (AbsCpp.BNFC'Position, AbsCpp.Exp) }
Exp6
  : Exp7 { (fst $1, (snd $1)) }

Exp7 :: { (AbsCpp.BNFC'Position, AbsCpp.Exp) }
Exp7
  : Exp8 { (fst $1, (snd $1)) }

Exp10 :: { (AbsCpp.BNFC'Position, AbsCpp.Exp) }
Exp10
  : Exp11 { (fst $1, (snd $1)) }

ListExp :: { (AbsCpp.BNFC'Position, [AbsCpp.Exp]) }
ListExp
  : {- empty -} { (AbsCpp.BNFC'NoPosition, []) }
  | Exp { (fst $1, (:[]) (snd $1)) }
  | Exp ',' ListExp { (fst $1, (:) (snd $1) (snd $3)) }

Type :: { (AbsCpp.BNFC'Position, AbsCpp.Type) }
Type
  : 'bool' { (uncurry AbsCpp.BNFC'Position (tokenLineCol $1), AbsCpp.Type_bool (uncurry AbsCpp.BNFC'Position (tokenLineCol $1))) }
  | 'double' { (uncurry AbsCpp.BNFC'Position (tokenLineCol $1), AbsCpp.Type_double (uncurry AbsCpp.BNFC'Position (tokenLineCol $1))) }
  | 'int' { (uncurry AbsCpp.BNFC'Position (tokenLineCol $1), AbsCpp.Type_int (uncurry AbsCpp.BNFC'Position (tokenLineCol $1))) }
  | 'string' { (uncurry AbsCpp.BNFC'Position (tokenLineCol $1), AbsCpp.Type_string (uncurry AbsCpp.BNFC'Position (tokenLineCol $1))) }
  | 'void' { (uncurry AbsCpp.BNFC'Position (tokenLineCol $1), AbsCpp.Type_void (uncurry AbsCpp.BNFC'Position (tokenLineCol $1))) }

ListId :: { (AbsCpp.BNFC'Position, [AbsCpp.Id]) }
ListId
  : Id { (fst $1, (:[]) (snd $1)) }
  | Id ',' ListId { (fst $1, (:) (snd $1) (snd $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

-- Entrypoints

pProgram :: [Token] -> Err AbsCpp.Program
pProgram = fmap snd . pProgram_internal

pDef :: [Token] -> Err AbsCpp.Def
pDef = fmap snd . pDef_internal

pListDef :: [Token] -> Err [AbsCpp.Def]
pListDef = fmap snd . pListDef_internal

pArg :: [Token] -> Err AbsCpp.Arg
pArg = fmap snd . pArg_internal

pListArg :: [Token] -> Err [AbsCpp.Arg]
pListArg = fmap snd . pListArg_internal

pStm :: [Token] -> Err AbsCpp.Stm
pStm = fmap snd . pStm_internal

pListStm :: [Token] -> Err [AbsCpp.Stm]
pListStm = fmap snd . pListStm_internal

pExp15 :: [Token] -> Err AbsCpp.Exp
pExp15 = fmap snd . pExp15_internal

pExp14 :: [Token] -> Err AbsCpp.Exp
pExp14 = fmap snd . pExp14_internal

pExp13 :: [Token] -> Err AbsCpp.Exp
pExp13 = fmap snd . pExp13_internal

pExp12 :: [Token] -> Err AbsCpp.Exp
pExp12 = fmap snd . pExp12_internal

pExp11 :: [Token] -> Err AbsCpp.Exp
pExp11 = fmap snd . pExp11_internal

pExp9 :: [Token] -> Err AbsCpp.Exp
pExp9 = fmap snd . pExp9_internal

pExp8 :: [Token] -> Err AbsCpp.Exp
pExp8 = fmap snd . pExp8_internal

pExp4 :: [Token] -> Err AbsCpp.Exp
pExp4 = fmap snd . pExp4_internal

pExp3 :: [Token] -> Err AbsCpp.Exp
pExp3 = fmap snd . pExp3_internal

pExp2 :: [Token] -> Err AbsCpp.Exp
pExp2 = fmap snd . pExp2_internal

pExp :: [Token] -> Err AbsCpp.Exp
pExp = fmap snd . pExp_internal

pExp1 :: [Token] -> Err AbsCpp.Exp
pExp1 = fmap snd . pExp1_internal

pExp5 :: [Token] -> Err AbsCpp.Exp
pExp5 = fmap snd . pExp5_internal

pExp6 :: [Token] -> Err AbsCpp.Exp
pExp6 = fmap snd . pExp6_internal

pExp7 :: [Token] -> Err AbsCpp.Exp
pExp7 = fmap snd . pExp7_internal

pExp10 :: [Token] -> Err AbsCpp.Exp
pExp10 = fmap snd . pExp10_internal

pListExp :: [Token] -> Err [AbsCpp.Exp]
pListExp = fmap snd . pListExp_internal

pType :: [Token] -> Err AbsCpp.Type
pType = fmap snd . pType_internal

pListId :: [Token] -> Err [AbsCpp.Id]
pListId = fmap snd . pListId_internal
}