-- File generated by the BNF Converter.
-- Parser definition for use with Happy.
{
{-# OPTIONS_GHC -fno-warn-incomplete-patterns -fno-warn-overlapping-patterns #-}
{-# LANGUAGE PatternSynonyms #-}

module ParLBNF
  ( happyError
  , myLexer
  , pGrammar
  , pListDef
  , pListItem
  , pDef
  , pItem
  , pCat
  , pLabel
  , pLabelId
  , pProfItem
  , pIntList
  , pListInteger
  , pListIntList
  , pListProfItem
  , pListString
  , pListRHS
  , pRHS
  , pMinimumSize
  , pReg2
  , pReg1
  , pReg3
  , pReg
  , pListIdent
  ) where

import Prelude

import qualified AbsLBNF
import LexLBNF

}

%name pGrammar Grammar
%name pListDef ListDef
%name pListItem ListItem
%name pDef Def
%name pItem Item
%name pCat Cat
%name pLabel Label
%name pLabelId LabelId
%name pProfItem ProfItem
%name pIntList IntList
%name pListInteger ListInteger
%name pListIntList ListIntList
%name pListProfItem ListProfItem
%name pListString ListString
%name pListRHS ListRHS
%name pRHS RHS
%name pMinimumSize MinimumSize
%name pReg2 Reg2
%name pReg1 Reg1
%name pReg3 Reg3
%name pReg Reg
%name pListIdent ListIdent
%monad { Err } { (>>=) } { return }
%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) }
  'char' { PT _ (TS _ 15) }
  'coercions' { PT _ (TS _ 16) }
  'comment' { PT _ (TS _ 17) }
  'digit' { PT _ (TS _ 18) }
  'entrypoints' { PT _ (TS _ 19) }
  'eps' { PT _ (TS _ 20) }
  'internal' { PT _ (TS _ 21) }
  'layout' { PT _ (TS _ 22) }
  'letter' { PT _ (TS _ 23) }
  'lower' { PT _ (TS _ 24) }
  'nonempty' { PT _ (TS _ 25) }
  'position' { PT _ (TS _ 26) }
  'rules' { PT _ (TS _ 27) }
  'separator' { PT _ (TS _ 28) }
  'stop' { PT _ (TS _ 29) }
  'terminator' { PT _ (TS _ 30) }
  'token' { PT _ (TS _ 31) }
  'toplevel' { PT _ (TS _ 32) }
  'upper' { PT _ (TS _ 33) }
  '{' { PT _ (TS _ 34) }
  '|' { PT _ (TS _ 35) }
  '}' { PT _ (TS _ 36) }
  L_Ident { PT _ (TV $$) }
  L_charac { PT _ (TC $$) }
  L_integ { PT _ (TI $$) }
  L_quoted { PT _ (TL $$) }

%%

Ident :: { AbsLBNF.Ident }
Ident  : L_Ident { AbsLBNF.Ident $1 }

Char :: { Char }
Char  : L_charac { (read $1 ) :: Char }

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

String :: { String }
String  : L_quoted { $1 }

Grammar :: { AbsLBNF.Grammar }
Grammar
  : ListDef { AbsLBNF.MkGrammar $1 }

ListDef :: { [AbsLBNF.Def] }
ListDef
  : {- empty -} { [] }
  | Def ';' ListDef { (:) $1 $3 }

ListItem :: { [AbsLBNF.Item] }
ListItem
  : {- empty -} { [] }
  | Item ListItem { (:) $1 $2 }

Def :: { AbsLBNF.Def }
Def
  : 'coercions' Ident Integer { AbsLBNF.Coercions $2 $3 }
  | 'comment' String { AbsLBNF.Comment $2 }
  | 'comment' String String { AbsLBNF.Comments $2 $3 }
  | 'entrypoints' ListIdent { AbsLBNF.Entryp $2 }
  | 'internal' Label '.' Cat '::=' ListItem { AbsLBNF.Internal $2 $4 $6 }
  | 'layout' 'stop' ListString { AbsLBNF.LayoutStop $3 }
  | 'layout' 'toplevel' { AbsLBNF.LayoutTop }
  | 'layout' ListString { AbsLBNF.Layout $2 }
  | 'position' 'token' Ident Reg { AbsLBNF.PosToken $3 $4 }
  | 'rules' Ident '::=' ListRHS { AbsLBNF.Rules $2 $4 }
  | 'separator' MinimumSize Cat String { AbsLBNF.Separator $2 $3 $4 }
  | 'terminator' MinimumSize Cat String { AbsLBNF.Terminator $2 $3 $4 }
  | 'token' Ident Reg { AbsLBNF.Token $2 $3 }
  | Label '.' Cat '::=' ListItem { AbsLBNF.Rule $1 $3 $5 }

Item :: { AbsLBNF.Item }
Item
  : String { AbsLBNF.Terminal $1 }
  | Cat { AbsLBNF.NTerminal $1 }

Cat :: { AbsLBNF.Cat }
Cat
  : '[' Cat ']' { AbsLBNF.ListCat $2 }
  | Ident { AbsLBNF.IdCat $1 }

Label :: { AbsLBNF.Label }
Label
  : LabelId { AbsLBNF.LabNoP $1 }
  | LabelId LabelId { AbsLBNF.LabF $1 $2 }
  | LabelId LabelId ListProfItem { AbsLBNF.LabPF $1 $2 $3 }
  | LabelId ListProfItem { AbsLBNF.LabP $1 $2 }

LabelId :: { AbsLBNF.LabelId }
LabelId
  : '(' ':' ')' { AbsLBNF.ListCons }
  | '(' ':' '[' ']' ')' { AbsLBNF.ListOne }
  | '[' ']' { AbsLBNF.ListE }
  | '_' { AbsLBNF.Wild }
  | Ident { AbsLBNF.Id $1 }

ProfItem :: { AbsLBNF.ProfItem }
ProfItem
  : '(' '[' ListIntList ']' ',' '[' ListInteger ']' ')' { AbsLBNF.ProfIt $3 $7 }

IntList :: { AbsLBNF.IntList }
IntList
  : '[' ListInteger ']' { AbsLBNF.Ints $2 }

ListInteger :: { [Integer] }
ListInteger
  : {- empty -} { [] }
  | Integer { (:[]) $1 }
  | Integer ',' ListInteger { (:) $1 $3 }

ListIntList :: { [AbsLBNF.IntList] }
ListIntList
  : {- empty -} { [] }
  | IntList { (:[]) $1 }
  | IntList ',' ListIntList { (:) $1 $3 }

ListProfItem :: { [AbsLBNF.ProfItem] }
ListProfItem
  : ProfItem { (:[]) $1 }
  | ProfItem ListProfItem { (:) $1 $2 }

ListString :: { [String] }
ListString
  : String { (:[]) $1 }
  | String ',' ListString { (:) $1 $3 }

ListRHS :: { [AbsLBNF.RHS] }
ListRHS
  : RHS { (:[]) $1 }
  | RHS '|' ListRHS { (:) $1 $3 }

RHS :: { AbsLBNF.RHS }
RHS
  : ListItem { AbsLBNF.MkRHS $1 }

MinimumSize :: { AbsLBNF.MinimumSize }
MinimumSize
  : {- empty -} { AbsLBNF.MEmpty }
  | 'nonempty' { AbsLBNF.MNonempty }

Reg2 :: { AbsLBNF.Reg }
Reg2
  : Reg2 Reg3 { AbsLBNF.RSeq $1 $2 }
  | Reg3 { $1 }

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

Reg3 :: { AbsLBNF.Reg }
Reg3
  : '(' Reg ')' { $2 }
  | '[' String ']' { AbsLBNF.RAlts $2 }
  | 'char' { AbsLBNF.RAny }
  | 'digit' { AbsLBNF.RDigit }
  | 'eps' { AbsLBNF.REps }
  | 'letter' { AbsLBNF.RLetter }
  | 'lower' { AbsLBNF.RLower }
  | 'upper' { AbsLBNF.RUpper }
  | '{' String '}' { AbsLBNF.RSeqs $2 }
  | Char { AbsLBNF.RChar $1 }
  | Reg3 '*' { AbsLBNF.RStar $1 }
  | Reg3 '+' { AbsLBNF.RPlus $1 }
  | Reg3 '?' { AbsLBNF.ROpt $1 }

Reg :: { AbsLBNF.Reg }
Reg
  : Reg1 { $1 }

ListIdent :: { [AbsLBNF.Ident] }
ListIdent
  : Ident { (:[]) $1 }
  | Ident ',' ListIdent { (:) $1 $3 }

{

type Err = Either String

happyError :: [Token] -> Err a
happyError ts = Left $
  "syntax error at " ++ tokenPos ts ++ 
  case ts of
    []      -> []
    [Err _] -> " due to lexer error"
    t:_     -> " before `" ++ (prToken t) ++ "'"

myLexer :: String -> [Token]
myLexer = tokens

}