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

}

%name pSrl Srl
%name pBlk Blk
%name pStep Step
%name pExp Exp
%name pOtime Otime
%name pOplus Oplus
%name pVar Var
-- 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) }
  'do' { PT _ (TS _ 14) }
  'else' { PT _ (TS _ 15) }
  'empty' { PT _ (TS _ 16) }
  'fi' { PT _ (TS _ 17) }
  'from' { PT _ (TS _ 18) }
  'if' { PT _ (TS _ 19) }
  'loop' { PT _ (TS _ 20) }
  'pop' { PT _ (TS _ 21) }
  'push' { PT _ (TS _ 22) }
  'skip' { PT _ (TS _ 23) }
  'then' { PT _ (TS _ 24) }
  'top' { PT _ (TS _ 25) }
  'until' { PT _ (TS _ 26) }

L_integ  { PT _ (TI $$) }
L_ident  { PT _ (TV $$) }


%%

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

Srl :: { Srl }
Srl : Blk { AbsSrl.SBLK $1 }
Blk :: { Blk }
Blk : Step { AbsSrl.SStep $1 }
    | 'if' Exp 'then' Blk 'else' Blk 'fi' Exp { AbsSrl.SIf $2 $4 $6 $8 }
    | Blk Blk { AbsSrl.SCon $1 $2 }
    | 'from' Exp 'do' Blk 'loop' Blk 'until' Exp { AbsSrl.SFrom $2 $4 $6 $8 }
Step :: { Step }
Step : Var Oplus '=' Exp { AbsSrl.Plus_Eq $1 $2 $4 }
     | Var '[' Exp ']' Oplus '=' Exp { AbsSrl.Plus_In $1 $3 $5 $7 }
     | 'push' Var Var { AbsSrl.Push $2 $3 }
     | 'pop' Var Var { AbsSrl.Pop $2 $3 }
     | 'skip' { AbsSrl.Skip }
Exp :: { Exp }
Exp : Integer { AbsSrl.EConst $1 }
    | Ident { AbsSrl.EVar $1 }
    | Var '[' Exp ']' { AbsSrl.EIn $1 $3 }
    | Exp Otime Exp { AbsSrl.ETime $1 $2 $3 }
    | 'top' Var Var { AbsSrl.ETop $2 $3 }
    | 'empty' Var Var { AbsSrl.EEmpty $2 $3 }
Otime :: { Otime }
Otime : Oplus { AbsSrl.OPlus $1 }
      | '*' { AbsSrl.Time }
      | '/' { AbsSrl.Div }
      | '=' { AbsSrl.Equal }
      | '<' { AbsSrl.Less }
      | '>' { AbsSrl.Greater }
      | '<=' { AbsSrl.Less_Eq }
      | '>=' { AbsSrl.Greater_Eq }
      | '!=' { AbsSrl.Not_Eq }
Oplus :: { Oplus }
Oplus : '+' { AbsSrl.Plus }
      | '-' { AbsSrl.Minus }
      | '^' { AbsSrl.Caret }
Var :: { Var }
Var : Ident { AbsSrl.Var $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"
    t:_ -> " before `" ++ id(prToken t) ++ "'"

myLexer = tokens
}