-- 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 ParJavaletteLight
  ( happyError
  , myLexer
  , pProg
  , pStm
  , pExp
  , pExp1
  , pExp2
  , pExp3
  , pListStm
  , pTyp
  ) where

import Prelude

import qualified AbsJavaletteLight
import LexJavaletteLight

}

%name pProg Prog
%name pStm Stm
%name pExp Exp
%name pExp1 Exp1
%name pExp2 Exp2
%name pExp3 Exp3
%name pListStm ListStm
%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) }
  'double' { PT _ (TS _ 9) }
  'int' { PT _ (TS _ 10) }
  'while' { PT _ (TS _ 11) }
  '{' { PT _ (TS _ 12) }
  '}' { PT _ (TS _ 13) }
  L_Ident { PT _ (TV $$) }
  L_doubl { PT _ (TD $$) }
  L_integ { PT _ (TI $$) }

%%

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

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

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

Prog :: { AbsJavaletteLight.Prog }
Prog
  : Typ Ident '(' ')' '{' ListStm '}' { AbsJavaletteLight.Fun $1 $2 $6 }

Stm :: { AbsJavaletteLight.Stm }
Stm
  : 'while' '(' Exp ')' '{' ListStm '}' { AbsJavaletteLight.SWhile $3 $6 }
  | Ident '++' ';' { AbsJavaletteLight.SIncr $1 }
  | Ident '=' Exp ';' { AbsJavaletteLight.SAss $1 $3 }
  | Stm ';' { $1 }
  | Typ Ident ';' { AbsJavaletteLight.SDecl $1 $2 }

Exp :: { AbsJavaletteLight.Exp }
Exp
  : Exp1 { $1 }
  | Exp1 '<' Exp1 { AbsJavaletteLight.ELt $1 $3 }

Exp1 :: { AbsJavaletteLight.Exp }
Exp1
  : Exp1 '+' Exp2 { AbsJavaletteLight.EPlus $1 $3 }
  | Exp2 { $1 }

Exp2 :: { AbsJavaletteLight.Exp }
Exp2
  : Exp2 '*' Exp3 { AbsJavaletteLight.ETimes $1 $3 }
  | Exp3 { $1 }

Exp3 :: { AbsJavaletteLight.Exp }
Exp3
  : '(' Exp ')' { $2 }
  | Double { AbsJavaletteLight.EDouble $1 }
  | Integer { AbsJavaletteLight.EInt $1 }
  | Ident { AbsJavaletteLight.EVar $1 }

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

Typ :: { AbsJavaletteLight.Typ }
Typ
  : 'double' { AbsJavaletteLight.TDouble }
  | 'int' { AbsJavaletteLight.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

}