-- 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 ParProlog
  ( happyError
  , myLexer
  , pDatabase
  , pClause
  , pPredicate
  , pTerm
  , pAtom
  , pVar
  , pList
  , pListClause
  , pListPredicate
  , pListTerm
  ) where

import Prelude

import qualified AbsProlog
import LexProlog

}

%name pDatabase Database
%name pClause Clause
%name pPredicate Predicate
%name pTerm Term
%name pAtom Atom
%name pVar Var
%name pList List
%name pListClause ListClause
%name pListPredicate ListPredicate
%name pListTerm ListTerm
%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) }
  L_Ident { PT _ (TV $$) }
  L_UIdent { PT _ (T_UIdent $$) }
  L_LIdent { PT _ (T_LIdent $$) }
  L_Wild { PT _ (T_Wild $$) }

%%

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

UIdent :: { AbsProlog.UIdent }
UIdent : L_UIdent { AbsProlog.UIdent $1 }

LIdent :: { AbsProlog.LIdent }
LIdent : L_LIdent { AbsProlog.LIdent $1 }

Wild :: { AbsProlog.Wild }
Wild : L_Wild { AbsProlog.Wild $1 }

Database :: { AbsProlog.Database }
Database
  : ListClause { AbsProlog.Db $1 }

Clause :: { AbsProlog.Clause }
Clause
  : ':-' ListPredicate { AbsProlog.Directive $2 }
  | Predicate { AbsProlog.Fact $1 }
  | Predicate ':-' ListPredicate { AbsProlog.Rule $1 $3 }

Predicate :: { AbsProlog.Predicate }
Predicate
  : Atom { AbsProlog.APred $1 }
  | Atom '(' ListTerm ')' { AbsProlog.CPred $1 $3 }

Term :: { AbsProlog.Term }
Term
  : Atom { AbsProlog.TAtom $1 }
  | Atom '(' ListTerm ')' { AbsProlog.Complex $1 $3 }
  | List { AbsProlog.TList $1 }
  | Var { AbsProlog.VarT $1 }

Atom :: { AbsProlog.Atom }
Atom
  : '\'' Ident '\'' { AbsProlog.EAtm $2 }
  | LIdent { AbsProlog.Atm $1 }

Var :: { AbsProlog.Var }
Var
  : UIdent { AbsProlog.V $1 }
  | Wild { AbsProlog.A $1 }

List :: { AbsProlog.List }
List
  : '[' ']' { AbsProlog.Empty }
  | '[' ListTerm ']' { AbsProlog.Enum $2 }
  | '[' ListTerm '|' List ']' { AbsProlog.Cons $2 $4 }
  | '[' ListTerm '|' Var ']' { AbsProlog.ConsV $2 $4 }

ListClause :: { [AbsProlog.Clause] }
ListClause
  : {- empty -} { [] }
  | Clause '.' ListClause { (:) $1 $3 }

ListPredicate :: { [AbsProlog.Predicate] }
ListPredicate
  : Predicate { (:[]) $1 }
  | Predicate ',' ListPredicate { (:) $1 $3 }

ListTerm :: { [AbsProlog.Term] }
ListTerm
  : Term { (:[]) $1 }
  | Term ',' ListTerm { (:) $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

}