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

}

%name pGrammar Grammar
%name pListDef ListDef
%name pDef Def
%name pEnv Env
%name pBinding Binding
%name pListBinding ListBinding
%name pPattern Pattern
%name pItem Item
%name pPatt1 Patt1
%name pPatt Patt
%name pListPatt1 ListPatt1
%name pHead Head
%name pListPattern ListPattern
%name pListItem ListItem
%name pConstraint Constraint
%name pCLogic CLogic
%name pCLogic1 CLogic1
%name pUnique Unique
%name pPosition Position
%name pPos Pos
%name pLogic Logic
%name pLogic1 Logic1
%name pReg Reg
%name pReg1 Reg1
%name pReg2 Reg2

-- 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) }
 '[' { PT _ (TS _ 14) }
 ']' { PT _ (TS _ 15) }
 '_' { PT _ (TS _ 16) }
 'char' { PT _ (TS _ 17) }
 'context' { PT _ (TS _ 18) }
 'digit' { PT _ (TS _ 19) }
 'eps' { PT _ (TS _ 20) }
 'letter' { PT _ (TS _ 21) }
 'lower' { PT _ (TS _ 22) }
 'paradigm' { PT _ (TS _ 23) }
 'regexp' { PT _ (TS _ 24) }
 'rule' { PT _ (TS _ 25) }
 'upper' { PT _ (TS _ 26) }
 '{' { PT _ (TS _ 27) }
 '|' { PT _ (TS _ 28) }
 '}' { PT _ (TS _ 29) }
 '~' { PT _ (TS _ 30) }

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


%%

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

Grammar :: { Grammar }
Grammar : ListDef { Grammar (reverse $1) } 


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


Def :: { Def }
Def : 'paradigm' Ident Env '=' Head '{' Logic '}' { Paradigm $2 $3 $5 $7 } 
  | 'rule' Ident Env '=' Head '{' Logic '}' { RParadigm $2 $3 $5 $7 }
  | 'regexp' Ident '=' Reg { Regdef $2 $4 }
  | 'context' Ident '=' CLogic { Cxtdef $2 $4 }


Env :: { Env }
Env : '[' ListBinding ']' { Env $2 } 
  | {- empty -} { Empty }


Binding :: { Binding }
Binding : Ident ':' Reg { Assoc $1 $3 } 


ListBinding :: { [Binding] }
ListBinding : {- empty -} { [] } 
  | Binding { (:[]) $1 }
  | Binding ',' ListBinding { (:) $1 $3 }


Pattern :: { Pattern }
Pattern : ListItem Constraint { CWord $1 $2 } 


Item :: { Item }
Item : String { StrC $1 } 
  | Ident { Var $1 }


Patt1 :: { Patt }
Patt1 : '_' { PWild } 
  | Ident { PId $1 }
  | '(' Patt ')' { $2 }


Patt :: { Patt }
Patt : Ident ListPatt1 { PC $1 $2 } 
  | Patt1 { $1 }


ListPatt1 :: { [Patt] }
ListPatt1 : Patt1 { (:[]) $1 } 
  | Patt1 ListPatt1 { (:) $1 $2 }


Head :: { Head }
Head : ListPattern { Head $1 } 


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


ListItem :: { [Item] }
ListItem : Item { (:[]) $1 } 
  | Item '+' ListItem { (:) $1 $3 }


Constraint :: { Constraint }
Constraint : '[' CLogic ']' { Cons $2 } 
  | '[' Ident ']' { ConsId $2 }
  | {- empty -} { NoCons }


CLogic :: { CLogic }
CLogic : CLogic '&' CLogic1 { CConj $1 $3 } 
  | CLogic '|' CLogic1 { CDisj $1 $3 }
  | CLogic1 { $1 }


CLogic1 :: { CLogic }
CLogic1 : '~' CLogic1 { CNeg $2 } 
  | '_' { CLWild }
  | '(' Position ',' Reg ',' Unique Patt ')' { CAtom $2 $4 $6 $7 }
  | '(' CLogic ')' { $2 }


Unique :: { Unique }
Unique : '!' { U } 
  | {- empty -} { NU }


Position :: { Position }
Position : '_' { WPos } 
  | Pos { Pos $1 }
  | Ident '@' Pos { VPos $1 $3 }
  | Ident '@' Ident Pos { RVPos $1 $3 $4 }
  | Ident Pos { Rel $1 $2 }


Pos :: { Pos }
Pos : Integer { P $1 } 
  | '+' Integer { PP $2 }
  | '-' Integer { NP $2 }
  | '+' Integer '*' { PStar $2 }
  | '-' Integer '*' { NPStar $2 }
  | '*' { Star }


Logic :: { Logic }
Logic : Logic '&' Logic1 { Conj $1 $3 } 
  | Logic '|' Logic1 { Disj $1 $3 }
  | Logic1 { $1 }


Logic1 :: { Logic }
Logic1 : '~' Logic1 { Neg $2 } 
  | '_' { LWild }
  | Pattern { Atom $1 }
  | '(' Logic ')' { $2 }


Reg :: { Reg }
Reg : Reg '|' Reg1 { RAlt $1 $3 } 
  | Reg1 '-' Reg1 { RMinus $1 $3 }
  | Reg1 { $1 }


Reg1 :: { Reg }
Reg1 : Reg1 Reg2 { RSeq $1 $2 } 
  | Reg2 { $1 }


Reg2 :: { Reg }
Reg2 : Reg2 '*' { RStar $1 } 
  | Reg2 '+' { RPlus $1 }
  | Reg2 '?' { ROpt $1 }
  | 'eps' { REps }
  | Char { RChar $1 }
  | '[' String ']' { RAlts $2 }
  | 'digit' { RDigit }
  | 'letter' { RLetter }
  | 'upper' { RUpper }
  | 'lower' { RLower }
  | 'char' { RAny }
  | '_' { Wild }
  | String { RStr $1 }
  | Ident { RegVar $1 }
  | '(' Reg ')' { $2 }



{

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
}