{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeFamilies #-}

module BNFC.Backend.Haskell where

import BNFC.CF
import BNFC.Prelude

import BNFC.Options.GlobalOptions
import BNFC.Options.Target

import BNFC.Backend.CommonInterface.Backend

import BNFC.Backend.Haskell.AbstractSyntax
import BNFC.Backend.Haskell.GADT.AbstractSyntax
import BNFC.Backend.Haskell.InitState
import BNFC.Backend.Haskell.Lexer
import BNFC.Backend.Haskell.Makefile
import BNFC.Backend.Haskell.Options
import BNFC.Backend.Haskell.Parser
import BNFC.Backend.Haskell.Test
import BNFC.Backend.Haskell.Printer
import BNFC.Backend.Haskell.State

import Control.Monad.Except
import Control.Monad.State

import Options.Applicative

instance Backend 'TargetHaskell where
  type BackendOptions 'TargetHaskell = HaskellBackendOptions
  type BackendState 'TargetHaskell = HaskellBackendState
  parseOpts :: Parser HaskellBackendOptions
  parseOpts = haskellOptionsParser
  initState :: LBNF -> GlobalOptions -> BackendOptions 'TargetHaskell -> Except String (BackendState 'TargetHaskell)
  initState = haskellInitState
  abstractSyntax :: LBNF -> State (BackendState 'TargetHaskell) Result
  abstractSyntax lbnf = do
    st <- get
    if gadt $ haskellOpts st
    then haskellAbstractSyntaxGADT lbnf
    else haskellAbstractSyntax lbnf
  printer :: LBNF -> State (BackendState 'TargetHaskell) Result
  printer = haskellPrinter
  lexer :: LBNF -> State (BackendState 'TargetHaskell) Result
  lexer = haskellLexer
  parser :: LBNF -> State (BackendState 'TargetHaskell) Result
  parser = haskellParser
  parserTest :: LBNF -> State (BackendState 'TargetHaskell) Result
  parserTest = haskellParserTest
  makefile :: LBNF -> State (BackendState 'TargetHaskell) Result
  makefile = haskellmakefile