----------------------------------------------------
--    BNF syntax for DYNAMO programs              --
--                                                --
--    Jan van Eijck                               --
--                                                --
--                                                --
--    November 1998                               --
--                                                --
----------------------------------------------------

{
module D
 
where 

import L
}
  
%name parse
%tokentype { Token }

%token 
             program         { TokenProgram }
             begin           { TokenBegin }
             end             { TokenEnd }
             skip            { TokenSkip }
             fail            { TokenFail }
             do              { TokenDo }
             times           { TokenIterations }
             find            { TokenFind }
             in              { TokenIn }  
             with            { TokenWith }
             either          { TokenEither }
             orelse          { TokenOrelse }
             if              { TokenIf }
             then            { TokenThen }
             else            { TokenElse }
             test            { TokenTest }
             some            { TokenSome } 
             donot           { TokenDonot } 
             int             { TokenInt $$ }
             name            { TokenName $$ }
             true            { TokenTrue }
             false           { TokenFalse }
             not             { TokenNeg }
             and             { TokenAnd }
             or              { TokenOr }
             '='             { TokenEq }
             '>'             { TokenMore }
             '<'             { TokenLess }
             '+'             { TokenPlus }
             '-'             { TokenMinus }
             '*'             { TokenTimes }
             '/'             { TokenDiv }
             '('             { TokenOB }
             ')'             { TokenCB }
             ';'             { TokenSC }
             '['             { TokenOSB }
             ']'             { TokenCSB }
             '.'             { TokenDot }
             ','             { TokenComma }
        

%%

Pgm  : Stmt                              { (False,[],$1)   } 
     | program Name ';' Stmt             { (False,[],$4)   } 
     | program Name Vdecl ';' Stmt       { (True,$3,$5)    } 

Name : name                              { } 

Vdecl : '(' Vschemes ')'                 { $2 } 

Vschemes : Vschemes ',' Vscheme      { $3 : $1 }
         | Vscheme                   { [$1]    }
         | {- empty -}               { []      } 
  
Vscheme : name                       { ($1,0)  }
        | name '[' ']'               { ($1,1)  }
        | name '[' ']' '[' ']'       { ($1,2)  }

Stmt : some Var  { Some $2 }
     | some Vars { Comp [ (Some x) | x <- (reverse $2) ] }
     | skip                          { Skip }
     | fail                          { Fail }
     | Exp '=' Exp                   { Iseq $1 $3 } 
     | Var '>' '>' Var '=' Exp       { Put $1 $4 $6 }
     | test Bexp                     { Test $2 }
     | if Bexp then Stmt else Stmt   { If $2 $4 $6 } 
     | either Stmt orelse Stmt       { Either $2 $4 }
     | do Exp times Stmt             { Do $2 $4 }
     | find Var in Rng with Stmt     { Find $2 $4 $6 }
     | donot Stmt                    { Not $2 }
     | begin Stmts end               { Comp (reverse $2)  }
     | {- empty -}                   { Skip } 

Stmts : Stmts ';' Stmt               { $3 : $1 }
      | Stmt                         { [$1] } 

Vars  : Vars ',' Var                 { $3 : $1 }
      | Var  ',' Var                 { [$3,$1] } 

Var   : name                         { Svar $1        }
      | name '[' Exp ']'             { Ivar $1 $3     }
      | name '[' Exp ']' '[' Exp ']' { Divar $1 $3 $6 }

Rng   : '[' Exp '.' '.' Exp ']' { ($2,$5) }

Exp   : Exp '+' Term            { Plus $1 $3 }
      | Exp '-' Term            { Minus $1 $3 }
      | Term                    { Term $1 }

Term  : Term '*' Factor         { Times $1 $3 }
      | Term '/' Factor         { Div $1 $3 }
      | Factor                  { Factor $1 }

Factor                    
      : int                         { Int $1         }
      | Var                         { Var $1         }
      | '(' Exp ')'                 { Brack $2       }

Bexp : true                     { Bool True }
     | false                    { Bool False } 
     | Exp '=' Exp              { Eq $1 $3 }
     | Exp '>' Exp              { Gr $1 $3 }
     | Exp '>' '=' Exp          { Geq $1 $4 }
     | Exp '<' Exp              { Less $1 $3 }
     | Exp '<' '=' Exp          { Leq $1 $4 }
     | Exp '<' '>' Exp          { Neq $1 $4 }
     | not Bexp                 { Neg $2 }
     | '(' Bexp and Bexp ')'    { Conj $2 $4 }
     | '(' Bexp or Bexp ')'     { Disj $2 $4 }

{

happyError :: [Token] -> a
happyError _ = error "Parse error"


}