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

}

%name pInput Input
%name pData Data
%name pTokD TokD
%name pPattern Pattern
%name pPattern1 Pattern1
%name pListData ListData
%name pListTokD ListTokD
%name pListPattern1 ListPattern1
%name pListPattern ListPattern

-- 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) }

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


%%

String  :: { String }  : L_quoted {  $1 }
Ident   :: { Ident }   : L_ident  { Ident $1 }

Input :: { Input }
Input : ListData { Input (reverse $1) } 


Data :: { Data }
Data : '{' ListTokD '}' { D (reverse $2) } 


TokD :: { TokD }
TokD : '(' String ',' ListPattern ')' { T $2 $4 } 


Pattern :: { Pattern }
Pattern : Ident ListPattern1 { PC $1 $2 } 
  | Pattern1 { $1 }


Pattern1 :: { Pattern }
Pattern1 : Ident { Id $1 } 
  | '(' Pattern ')' { $2 }


ListData :: { [Data] }
ListData : {- empty -} { [] } 
  | ListData Data { flip (:) $1 $2 }


ListTokD :: { [TokD] }
ListTokD : {- empty -} { [] } 
  | ListTokD TokD { flip (:) $1 $2 }


ListPattern1 :: { [Pattern] }
ListPattern1 : Pattern1 { (:[]) $1 } 
  | Pattern1 ListPattern1 { (:) $1 $2 }


ListPattern :: { [Pattern] }
ListPattern : {- empty -} { [] } 
  | Pattern { (:[]) $1 }
  | Pattern '|' ListPattern { (:) $1 $3 }



{

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 (id . prToken) (take 4 ts))

myLexer = tokens
}