-- GENERATED by C->Haskell Compiler, version 0.28.6 Switcheroo, 25 November 2017 (Haskell)
-- Edit the ORIGNAL .chs file instead!


{-# LINE 1 "src/Codec/Bz3/Foreign.chs" #-}
module Codec.Bz3.Foreign ( Bz3St
                         , Bz3Error (..)
                         , bz3New
                         , bz3Free
                         , bz3Bound
                         , bz3Strerror
                         , bz3DecodeBlock
                         , bz3EncodeBlock
                         ) where
import qualified Foreign.C.String as C2HSImp
import qualified Foreign.C.Types as C2HSImp
import qualified Foreign.ForeignPtr as C2HSImp
import qualified Foreign.Ptr as C2HSImp
import qualified System.IO.Unsafe as C2HSImp



import Data.Int (Int32)
import Foreign.Ptr (Ptr)
import Foreign.C.Types (CSize)



data Bz3Error = Bz3ErrInit
              | Bz3ErrDataTooBig
              | Bz3ErrTruncatedData
              | Bz3ErrMalformedHeader
              | Bz3ErrCrc
              | Bz3ErrBwt
              | Bz3ErrOutOfBounds
              | Bz3Ok
  deriving (Bz3Error -> Bz3Error -> Bool
(Bz3Error -> Bz3Error -> Bool)
-> (Bz3Error -> Bz3Error -> Bool) -> Eq Bz3Error
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Bz3Error -> Bz3Error -> Bool
== :: Bz3Error -> Bz3Error -> Bool
$c/= :: Bz3Error -> Bz3Error -> Bool
/= :: Bz3Error -> Bz3Error -> Bool
Eq)
instance Enum Bz3Error where
  succ :: Bz3Error -> Bz3Error
succ Bz3Error
Bz3ErrInit = Bz3Error
Bz3ErrDataTooBig
  succ Bz3Error
Bz3ErrDataTooBig = Bz3Error
Bz3ErrTruncatedData
  succ Bz3Error
Bz3ErrTruncatedData = Bz3Error
Bz3ErrMalformedHeader
  succ Bz3Error
Bz3ErrMalformedHeader = Bz3Error
Bz3ErrCrc
  succ Bz3Error
Bz3ErrCrc = Bz3Error
Bz3ErrBwt
  succ Bz3Error
Bz3ErrBwt = Bz3Error
Bz3ErrOutOfBounds
  succ Bz3Error
Bz3ErrOutOfBounds = Bz3Error
Bz3Ok
  succ Bz3Ok = error "Bz3Error.succ: Bz3Ok has no successor"

  pred Bz3ErrDataTooBig = Bz3ErrInit
  pred Bz3ErrTruncatedData = Bz3ErrDataTooBig
  pred Bz3ErrMalformedHeader = Bz3ErrTruncatedData
  pred Bz3ErrCrc = Bz3ErrMalformedHeader
  pred Bz3ErrBwt = Bz3ErrCrc
  pred Bz3ErrOutOfBounds = Bz3ErrBwt
  pred Bz3Ok = Bz3ErrOutOfBounds
  pred Bz3ErrInit = error "Bz3Error.pred: Bz3ErrInit has no predecessor"

  enumFromTo from to = go from
    where
      end = fromEnum to
      go v = case compare (fromEnum v) end of
                 LT -> v : go (succ v)
                 EQ -> [v]
                 GT -> []

  enumFrom from = enumFromTo from Bz3Ok

  fromEnum :: Bz3Error -> Int
fromEnum Bz3Error
Bz3ErrInit = (-Int
7)
  fromEnum Bz3ErrDataTooBig = (-6)
  fromEnum Bz3ErrTruncatedData = (-5)
  fromEnum Bz3Error
Bz3ErrMalformedHeader = (-Int
4)
  fromEnum Bz3ErrCrc = (-3)
  fromEnum Bz3ErrBwt = (-2)
  fromEnum Bz3Error
Bz3ErrOutOfBounds = (-Int
1)
  fromEnum Bz3Error
Bz3Ok = Int
0

  toEnum :: Int -> Bz3Error
toEnum (-7) = Bz3Error
Bz3ErrInit
  toEnum (-6) = Bz3Error
Bz3ErrDataTooBig
  toEnum (-5) = Bz3Error
Bz3ErrTruncatedData
  toEnum (-4) = Bz3Error
Bz3ErrMalformedHeader
  toEnum (-3) = Bz3Error
Bz3ErrCrc
  toEnum (-2) = Bz3Error
Bz3ErrBwt
  toEnum (-1) = Bz3Error
Bz3ErrOutOfBounds
  toEnum Int
0 = Bz3Error
Bz3Ok
  toEnum Int
unmatched = [Char] -> Bz3Error
forall a. HasCallStack => [Char] -> a
error ([Char]
"Bz3Error.toEnum: Cannot match " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
unmatched)

{-# LINE 26 "src/Codec/Bz3/Foreign.chs" #-}


data Bz3St

type Bz3StPtr = C2HSImp.ForeignPtr (Bz3St)
{-# LINE 30 "src/Codec/Bz3/Foreign.chs" #-}


type UInt8 = (C2HSImp.CUChar)
{-# LINE 32 "src/Codec/Bz3/Foreign.chs" #-}


{-# LINE 33 "src/Codec/Bz3/Foreign.chs" #-}


{-# LINE 34 "src/Codec/Bz3/Foreign.chs" #-}



{-# LINE 36 "src/Codec/Bz3/Foreign.chs" #-}



{-# LINE 38 "src/Codec/Bz3/Foreign.chs" #-}


{-# LINE 39 "src/Codec/Bz3/Foreign.chs" #-}


bz3New :: (Int32) -> IO ((Ptr Bz3St))
bz3New a1 =
  let {a1' = id a1} in 
  bz3New'_ a1' >>= \res ->
  let {res' = id res} in
  return (res')

{-# LINE 41 "src/Codec/Bz3/Foreign.chs" #-}

bz3Bound :: (CSize) -> (CSize)
bz3Bound a1 =
  C2HSImp.unsafePerformIO $
  let {a1' = id a1} in 
  bz3Bound'_ a1' >>= \res ->
  let {res' = id res} in
  return (res')

{-# LINE 42 "src/Codec/Bz3/Foreign.chs" #-}

bz3Strerror :: (Bz3StPtr) -> IO ((String))
bz3Strerror a1 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  bz3Strerror'_ a1' >>= \res ->
  C2HSImp.peekCString res >>= \res' ->
  return (res')

{-# LINE 43 "src/Codec/Bz3/Foreign.chs" #-}

bz3DecodeBlock :: (Bz3StPtr) -> (Ptr UInt8) -> (CSize) -> (Int32) -> (Int32) -> IO ((Either Bz3Error Int32))
bz3DecodeBlock a1 a2 a3 a4 a5 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  let {a2' = id a2} in 
  let {a3' = id a3} in 
  let {a4' = id a4} in 
  let {a5' = id a5} in 
  bz3DecodeBlock'_ a1' a2' a3' a4' a5' >>= \res ->
  let {res' = bz3Err res} in
  return (res')

{-# LINE 44 "src/Codec/Bz3/Foreign.chs" #-}

bz3EncodeBlock :: (Bz3StPtr) -> (Ptr UInt8) -> (Int32) -> IO ((Int32))
bz3EncodeBlock a1 a2 a3 =
  C2HSImp.withForeignPtr a1 $ \a1' -> 
  let {a2' = id a2} in 
  let {a3' = id a3} in 
  bz3EncodeBlock'_ a1' a2' a3' >>= \res ->
  let {res' = id res} in
  return (res')

{-# LINE 45 "src/Codec/Bz3/Foreign.chs" #-}


bz3Err :: Int32 -> Either Bz3Error Int32
bz3Err i | i > 0 = Right i
         | otherwise = Left$toEnum (fromIntegral i)

foreign import ccall "Codec/Bz3/Foreign.chs.h &bz3_free"
  bz3Free :: C2HSImp.FinalizerPtr ()

foreign import ccall safe "Codec/Bz3/Foreign.chs.h bz3_new"
  bz3New'_ :: (Int32 -> (IO (C2HSImp.Ptr (Bz3St))))

foreign import ccall safe "Codec/Bz3/Foreign.chs.h bz3_bound"
  bz3Bound'_ :: (CSize -> (IO CSize))

foreign import ccall safe "Codec/Bz3/Foreign.chs.h bz3_strerror"
  bz3Strerror'_ :: ((C2HSImp.Ptr (Bz3St)) -> (IO (C2HSImp.Ptr C2HSImp.CChar)))

foreign import ccall safe "Codec/Bz3/Foreign.chs.h bz3_decode_block"
  bz3DecodeBlock'_ :: ((C2HSImp.Ptr (Bz3St)) -> ((C2HSImp.Ptr UInt8) -> (CSize -> (Int32 -> (Int32 -> (IO Int32))))))

foreign import ccall safe "Codec/Bz3/Foreign.chs.h bz3_encode_block"
  bz3EncodeBlock'_ :: ((C2HSImp.Ptr (Bz3St)) -> ((C2HSImp.Ptr UInt8) -> (Int32 -> (IO Int32))))