-- This Happy file was machine-generated by the BNF converter
{
{-# OPTIONS_GHC -fno-warn-incomplete-patterns -fno-warn-overlapping-patterns #-}
module MiniJS.Par where
import MiniJS.Abs
import MiniJS.Lex
import MiniJS.ErrM
}

%name pProgram Program
%name pStm Stm
%name pListStm ListStm
%name pExp2 Exp2
%name pExp1 Exp1
%name pExp Exp
-- 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) }
  'console.log' { PT _ (TS _ 9) }
  L_ident  { PT _ (TV $$) }
  L_integ  { PT _ (TI $$) }
  L_doubl  { PT _ (TD $$) }

%%

Ident   :: { Ident }
Ident    : L_ident  { Ident $1 }

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

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

Program :: { Program }
Program : ListStm { MiniJS.Abs.Prg (reverse $1) }
Stm :: { Stm }
Stm : Ident '=' Exp { MiniJS.Abs.SAssign $1 $3 }
    | 'console.log' '(' Exp ')' { MiniJS.Abs.SPrint $3 }
ListStm :: { [Stm] }
ListStm : {- empty -} { [] } | ListStm Stm ';' { flip (:) $1 $2 }
Exp2 :: { Exp }
Exp2 : Ident { MiniJS.Abs.EVar $1 }
     | Integer { MiniJS.Abs.EInt $1 }
     | Double { MiniJS.Abs.EDouble $1 }
     | '(' Exp ')' { $2 }
Exp1 :: { Exp }
Exp1 : Exp1 '*' Exp2 { MiniJS.Abs.ETimes $1 $3 }
     | Exp1 '/' Exp2 { MiniJS.Abs.EDiv $1 $3 }
     | Exp2 { $1 }
Exp :: { Exp }
Exp : Exp '+' Exp1 { MiniJS.Abs.EPlus $1 $3 }
    | Exp '-' Exp1 { MiniJS.Abs.EMinus $1 $3 }
    | Exp1 { $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 `" ++ (prToken t) ++ "'"

myLexer = tokens
}