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

%name pDictionary Dictionary
%name pListEntry ListEntry
%name pListArg ListArg
%name pListTerm ListTerm
%name pEntry Entry
%name pTerm Term
%name pArg Arg

-- no lexer declaration
%monad { Err } { thenM } { returnM }
%tokentype { Token }

%token 
 ';' { PT _ (TS ";") }
 ',' { PT _ (TS ",") }
 '{' { PT _ (TS "{") }
 '}' { PT _ (TS "}") }
 '(' { PT _ (TS "(") }
 ')' { PT _ (TS ")") }

L_ident  { PT _ (TV $$) }
L_integ  { PT _ (TI $$) }
L_quoted { PT _ (TL $$) }
L_err    { _ }


%%

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

Dictionary :: { Dictionary }
Dictionary : ListEntry { Dict (reverse $1) } 


ListEntry :: { [Entry] }
ListEntry : {- empty -} { [] } 
  | ListEntry Entry ';' { flip (:) $1 $2 }


ListArg :: { [Arg] }
ListArg : {- empty -} { [] } 
  | ListArg Arg { flip (:) $1 $2 }


ListTerm :: { [Term] }
ListTerm : {- empty -} { [] } 
  | Term { (:[]) $1 }
  | Term ',' ListTerm { (:) $1 $3 }


Entry :: { Entry }
Entry : Ident ListArg { E $1 (reverse $2) } 
  | Ident ListArg '{' ListTerm '}' { EA $1 (reverse $2) $4 }


Term :: { Term }
Term : Ident '(' ListTerm ')' { TermC $1 $3 } 
  | Arg { TermA $1 }


Arg :: { Arg }
Arg : Ident { NId $1 } 
  | Integer { NArg $1 }
  | String { NStr $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"
    _ -> " before " ++ unwords (map prToken (take 4 ts))

myLexer = tokens
}