-- 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_internal Database
%name pClause_internal Clause
%name pPredicate_internal Predicate
%name pTerm_internal Term
%name pAtom_internal Atom
%name pVar_internal Var
%name pList_internal List
%name pListClause_internal ListClause
%name pListPredicate_internal ListPredicate
%name pListTerm_internal 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.BNFC'Position, AbsProlog.Ident) }
Ident  : L_Ident { (uncurry AbsProlog.BNFC'Position (tokenLineCol $1), AbsProlog.Ident (tokenText $1)) }

UIdent :: { (AbsProlog.BNFC'Position, AbsProlog.UIdent) }
UIdent : L_UIdent { (uncurry AbsProlog.BNFC'Position (tokenLineCol $1), AbsProlog.UIdent (tokenText $1)) }

LIdent :: { (AbsProlog.BNFC'Position, AbsProlog.LIdent) }
LIdent : L_LIdent { (uncurry AbsProlog.BNFC'Position (tokenLineCol $1), AbsProlog.LIdent (tokenText $1)) }

Wild :: { (AbsProlog.BNFC'Position, AbsProlog.Wild) }
Wild : L_Wild { (uncurry AbsProlog.BNFC'Position (tokenLineCol $1), AbsProlog.Wild (tokenText $1)) }

Database :: { (AbsProlog.BNFC'Position, AbsProlog.Database) }
Database
  : ListClause { (fst $1, AbsProlog.Db (fst $1) (snd $1)) }

Clause :: { (AbsProlog.BNFC'Position, AbsProlog.Clause) }
Clause
  : ':-' ListPredicate { (uncurry AbsProlog.BNFC'Position (tokenLineCol $1), AbsProlog.Directive (uncurry AbsProlog.BNFC'Position (tokenLineCol $1)) (snd $2)) }
  | Predicate { (fst $1, AbsProlog.Fact (fst $1) (snd $1)) }
  | Predicate ':-' ListPredicate { (fst $1, AbsProlog.Rule (fst $1) (snd $1) (snd $3)) }

Predicate :: { (AbsProlog.BNFC'Position, AbsProlog.Predicate) }
Predicate
  : Atom { (fst $1, AbsProlog.APred (fst $1) (snd $1)) }
  | Atom '(' ListTerm ')' { (fst $1, AbsProlog.CPred (fst $1) (snd $1) (snd $3)) }

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

Atom :: { (AbsProlog.BNFC'Position, AbsProlog.Atom) }
Atom
  : '\'' Ident '\'' { (uncurry AbsProlog.BNFC'Position (tokenLineCol $1), AbsProlog.EAtm (uncurry AbsProlog.BNFC'Position (tokenLineCol $1)) (snd $2)) }
  | LIdent { (fst $1, AbsProlog.Atm (fst $1) (snd $1)) }

Var :: { (AbsProlog.BNFC'Position, AbsProlog.Var) }
Var
  : UIdent { (fst $1, AbsProlog.V (fst $1) (snd $1)) }
  | Wild { (fst $1, AbsProlog.A (fst $1) (snd $1)) }

List :: { (AbsProlog.BNFC'Position, AbsProlog.List) }
List
  : '[' ']' { (uncurry AbsProlog.BNFC'Position (tokenLineCol $1), AbsProlog.Empty (uncurry AbsProlog.BNFC'Position (tokenLineCol $1))) }
  | '[' ListTerm ']' { (uncurry AbsProlog.BNFC'Position (tokenLineCol $1), AbsProlog.Enum (uncurry AbsProlog.BNFC'Position (tokenLineCol $1)) (snd $2)) }
  | '[' ListTerm '|' List ']' { (uncurry AbsProlog.BNFC'Position (tokenLineCol $1), AbsProlog.Cons (uncurry AbsProlog.BNFC'Position (tokenLineCol $1)) (snd $2) (snd $4)) }
  | '[' ListTerm '|' Var ']' { (uncurry AbsProlog.BNFC'Position (tokenLineCol $1), AbsProlog.ConsV (uncurry AbsProlog.BNFC'Position (tokenLineCol $1)) (snd $2) (snd $4)) }

ListClause :: { (AbsProlog.BNFC'Position, [AbsProlog.Clause]) }
ListClause
  : {- empty -} { (AbsProlog.BNFC'NoPosition, []) }
  | Clause '.' ListClause { (fst $1, (:) (snd $1) (snd $3)) }

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

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

-- Entrypoints

pDatabase :: [Token] -> Err AbsProlog.Database
pDatabase = fmap snd . pDatabase_internal

pClause :: [Token] -> Err AbsProlog.Clause
pClause = fmap snd . pClause_internal

pPredicate :: [Token] -> Err AbsProlog.Predicate
pPredicate = fmap snd . pPredicate_internal

pTerm :: [Token] -> Err AbsProlog.Term
pTerm = fmap snd . pTerm_internal

pAtom :: [Token] -> Err AbsProlog.Atom
pAtom = fmap snd . pAtom_internal

pVar :: [Token] -> Err AbsProlog.Var
pVar = fmap snd . pVar_internal

pList :: [Token] -> Err AbsProlog.List
pList = fmap snd . pList_internal

pListClause :: [Token] -> Err [AbsProlog.Clause]
pListClause = fmap snd . pListClause_internal

pListPredicate :: [Token] -> Err [AbsProlog.Predicate]
pListPredicate = fmap snd . pListPredicate_internal

pListTerm :: [Token] -> Err [AbsProlog.Term]
pListTerm = fmap snd . pListTerm_internal
}