zlib-core (empty) → 0.1.0.0

raw patch · 12 files changed

+608/−0 lines, 12 filesdep +basedep +c-enumdep +c-structsetup-changed

Dependencies added: base, c-enum, c-struct, exception-hierarchy, primitive, tools-yj, zlib-core

Files

• CHANGELOG.md +11/−0
• LICENSE +26/−0
• README.md +3/−0
• Setup.hs +2/−0
• src/Codec/Compression/Zlib/Advanced/Core.hsc +62/−0
• src/Codec/Compression/Zlib/Basic/Core.hsc +56/−0
• src/Codec/Compression/Zlib/Constant/Core.hsc +113/−0
• src/Codec/Compression/Zlib/Gzip/Core.hsc +30/−0
• src/Codec/Compression/Zlib/Structure/Core.hsc +208/−0
• src/Codec/Compression/Zlib/Utility/Core.hsc +24/−0
• test/Spec.hs +2/−0
• zlib-core.cabal +71/−0

@@ -0,0 +1,11 @@+# Changelog for `zlib-core`++All notable changes to this project will be documented in this file.++The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),+and this project adheres to the+[Haskell Package Versioning Policy](https://pvp.haskell.org/).++## Unreleased++## 0.1.0.0 - YYYY-MM-DD

@@ -0,0 +1,26 @@+Copyright 2025 Yoshikuni Jujo++Redistribution and use in source and binary forms, with or without+modification, are permitted provided that the following conditions are met:++1.  Redistributions of source code must retain the above copyright notice, this+    list of conditions and the following disclaimer.++2.  Redistributions in binary form must reproduce the above copyright notice,+    this list of conditions and the following disclaimer in the documentation+    and/or other materials provided with the distribution.++3.  Neither the name of the copyright holder nor the names of its contributors+    may be used to endorse or promote products derived from this software+    without specific prior written permission.++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

@@ -0,0 +1,3 @@+# zlib-core++This package used by package zlib-yaftee.

@@ -0,0 +1,2 @@+import Distribution.Simple+main = defaultMain

@@ -0,0 +1,62 @@+{-# LANGUAGE CApiFFI #-}+{-# LANGUAGE PatternSynonyms, ViewPatterns #-}+{-# OPTIONS_GHC -Wall -fno-warn-tabs #-}++module Codec.Compression.Zlib.Advanced.Core (++	deflateInit2,+	inflateInit2,++	WindowBits,+	pattern WindowBitsZlibHeader,+	pattern WindowBitsZlib, pattern WindowBitsRaw,+	pattern WindowBitsGzip, pattern WindowBitsZlibAndGzip,++	) where++import Foreign.Ptr+import Control.Monad.Primitive+import Data.Word.ToolsYj+import Data.Int++import Codec.Compression.Zlib.Structure.Core+import Codec.Compression.Zlib.Constant.Core++newtype WindowBits = WindowBits #{type int} deriving Show++pattern WindowBitsZlibHeader :: WindowBits+pattern WindowBitsZlibHeader = WindowBits 0++pattern WindowBitsZlib :: Word4 -> WindowBits+pattern WindowBitsZlib bs <- WindowBits (fromIntegral -> bs) where+	WindowBitsZlib bs = WindowBits $ fromIntegral bs++pattern WindowBitsRaw :: Word4 -> WindowBits+pattern WindowBitsRaw bs <- WindowBits (fromIntegral . negate -> bs) where+	WindowBitsRaw bs = WindowBits . negate $ fromIntegral bs++pattern WindowBitsGzip :: Word4 -> WindowBits+pattern WindowBitsGzip bs <- WindowBits (fromIntegral . subtract 16 -> bs) where+	WindowBitsGzip bs = WindowBits $ fromIntegral bs + 16++pattern WindowBitsZlibAndGzip :: Word4 -> WindowBits+pattern WindowBitsZlibAndGzip bs <- WindowBits (fromIntegral . subtract 32 -> bs) where+	WindowBitsZlibAndGzip bs = WindowBits $ fromIntegral bs + 32++deflateInit2 :: PrimBase m =>+	StreamPrim (PrimState m) -> CompressionLevel -> CompressionMethod ->+	WindowBits -> MemLevel -> CompressionStrategy -> m ReturnCode+deflateInit2 strm lvl mtd wbs ml str = withStreamPtr strm+	$ unsafeIOToPrim . (\pstrm -> c_deflateInit2 pstrm lvl mtd wbs ml str)++foreign import capi "zlib.h deflateInit2" c_deflateInit2 ::+	Ptr Stream -> CompressionLevel -> CompressionMethod -> WindowBits ->+	MemLevel -> CompressionStrategy -> IO ReturnCode++inflateInit2 :: PrimBase m =>+	StreamPrim (PrimState m) -> WindowBits -> m ReturnCode+inflateInit2 strm wbs =+	withStreamPtr strm $ unsafeIOToPrim . (`c_inflateInit2` wbs)++foreign import capi "zlib.h inflateInit2" c_inflateInit2 ::+	Ptr Stream -> WindowBits -> IO ReturnCode

@@ -0,0 +1,56 @@+{-# LANGUAGE CApiFFI #-}+{-# LANGUAGE BlockArguments #-}+{-# OPTIONS_GHC -Wall -fno-warn-tabs #-}++module Codec.Compression.Zlib.Basic.Core (++	zlibVersion,++	deflateInit, deflate, deflateEnd,+	inflateInit, inflate, inflateEnd++	) where++import Foreign.Ptr+import Foreign.C.String+import Control.Monad.Primitive+import System.IO.Unsafe++import Codec.Compression.Zlib.Structure.Core+import Codec.Compression.Zlib.Constant.Core++zlibVersion :: String+zlibVersion = unsafePerformIO $ peekCString c_zlibVersion++deflateInit :: PrimBase m =>+	StreamPrim (PrimState m) -> CompressionLevel -> m ReturnCode+deflateInit strm cl = withStreamPtr strm $ unsafeIOToPrim . (`c_deflateInit` cl)++deflate :: PrimBase m => StreamPrim (PrimState m) -> Flush -> m ReturnCode+deflate strm fls = withStreamPtr strm $ unsafeIOToPrim . (`c_deflate` fls)++deflateEnd :: PrimBase m => StreamPrim (PrimState m) -> m ReturnCode+deflateEnd strm = withStreamPtr strm $ unsafeIOToPrim . c_deflateEnd++inflateInit :: PrimBase m => StreamPrim (PrimState m) -> m ReturnCode+inflateInit strm = withStreamPtr strm $ unsafeIOToPrim . c_inflateInit++inflate :: PrimBase m => StreamPrim (PrimState m) -> Flush -> m ReturnCode+inflate strm fls = withStreamPtr strm \s -> unsafeIOToPrim $ c_inflate s fls++inflateEnd :: PrimBase m => StreamPrim (PrimState m) -> m ReturnCode+inflateEnd strm = withStreamPtr strm $ unsafeIOToPrim . c_inflateEnd++foreign import ccall "zlibVersion" c_zlibVersion :: CString++foreign import capi "zlib.h deflateInit" c_deflateInit :: Ptr Stream -> CompressionLevel -> IO ReturnCode++foreign import ccall "deflate" c_deflate :: Ptr Stream -> Flush -> IO ReturnCode++foreign import ccall "deflateEnd" c_deflateEnd :: Ptr Stream -> IO ReturnCode++foreign import capi "zlib.h inflateInit" c_inflateInit :: Ptr Stream -> IO ReturnCode++foreign import ccall "inflate" c_inflate :: Ptr Stream -> Flush -> IO ReturnCode++foreign import ccall "inflateEnd" c_inflateEnd :: Ptr Stream -> IO ReturnCode

@@ -0,0 +1,113 @@+{-# LANGUAGE ImportQualifiedPost #-}+{-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE PatternSynonyms #-}+{-# OPTIONS_GHC -Wall -fno-warn-tabs #-}++module Codec.Compression.Zlib.Constant.Core (++	-- * RETURN CODE++	ReturnCode(..),+	pattern Ok,+	pattern StreamEnd,+	pattern NeedDict,+	pattern Errno,+	pattern StreamError,+	pattern DataError,+	pattern MemError,+	pattern BufError,+	pattern VersionError,++	-- * FLUSH++	Flush(..),+	pattern NoFlush,+	pattern PartialFlush,+	pattern SyncFlush,+	pattern FullFlush,+	pattern Finish,+	pattern Block,+	pattern Trees,+++	-- * MEM LEVEL++	MemLevel(..),++	-- * COMPRESSION STRATEGY++	CompressionStrategy(..),+	pattern Filtered,+	pattern HuffmanOnly,+	pattern Rle,+	pattern Fixed,+	pattern DefaultStrategy,++	-- * COMPRESSION LEVEL++	CompressionLevel(..),+	pattern NoCompression,+	pattern BestSpeed,+	pattern BestCompression,+	pattern DefaultCompression,++	-- * COMPRESSION METHOD++	CompressionMethod(..),+	pattern Deflated++	) where++import Foreign.Storable+import Foreign.C.Enum+import Control.Exception.Hierarchy+import Data.Int++#include <zlib.h>++enum "Flush" ''#{type int} [''Show, ''Read, ''Eq] [+	("NoFlush", #{const Z_NO_FLUSH}),+	("PartialFlush", #{const Z_PARTIAL_FLUSH}),+	("SyncFlush", #{const Z_SYNC_FLUSH}),+	("FullFlush", #{const Z_FULL_FLUSH}),+	("Finish", #{const Z_FINISH}),+	("Block", #{const Z_BLOCK}),+	("Trees", #{const Z_TREES}) ]++enum "ReturnCode" ''#{type int} [''Show, ''Read, ''Eq] [+	("Ok", #{const Z_OK}),+	("StreamEnd", #{const Z_STREAM_END}),+	("NeedDict", #{const Z_NEED_DICT}),+	("Errno", #{const Z_ERRNO}),+	("StreamError", #{const Z_STREAM_ERROR}),+	("DataError", #{const Z_DATA_ERROR}),+	("MemError", #{const Z_MEM_ERROR}),+	("BufError", #{const Z_BUF_ERROR}),+	("VersionError", #{const Z_VERSION_ERROR}) ]++exceptionHierarchy Nothing (ExType ''ReturnCode)++enum "CompressionLevel" ''#{type int} [''Show, ''Read, ''Eq] [+	("NoCompression", #{const Z_NO_COMPRESSION}),+	("BestSpeed", #{const Z_BEST_SPEED}),+	("BestCompression", #{const Z_BEST_COMPRESSION}),+	("DefaultCompression", #{const Z_DEFAULT_COMPRESSION}) ]++enum "CompressionStrategy" ''#{type int} [''Show, ''Read, ''Eq] [+	("Filtered", #{const Z_FILTERED}),+	("HuffmanOnly", #{const Z_HUFFMAN_ONLY}),+	("Rle", #{const Z_RLE}),+	("Fixed", #{const Z_FIXED}),+	("DefaultStrategy", #{const Z_DEFAULT_STRATEGY}) ]++enum "DataType" ''#{type int} [''Show, ''Read, ''Eq, ''Storable] [+	("Binary", #{const Z_BINARY}),+	("Text", #{const Z_TEXT}),+	("Ascii", #{const Z_ASCII}),+	("Unknown", #{const Z_UNKNOWN}) ]++enum "CompressionMethod" ''#{type int} [''Show, ''Read, ''Eq] [+	("Deflated", #{const Z_DEFLATED}) ]++enum "MemLevel" ''#{type int} [''Show, ''Read, ''Eq] [+	]

@@ -0,0 +1,30 @@+{-# LANGUAGE ImportQualifiedPost #-}+{-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE PatternSynonyms #-}+{-# OPTIONS_GHC -Wall -fno-warn-tabs #-}++module Codec.Compression.Zlib.Gzip.Core (++	GzFile,+	c_gzopen, c_gzgets, c_gzclose++) where++import Foreign.Ptr+import Foreign.C.String+import Data.Int++import Codec.Compression.Zlib.Constant.Core++#include <zlib.h>++data GzFileTag++type GzFile = Ptr GzFileTag++foreign import ccall "gzopen" c_gzopen :: CString -> CString -> IO GzFile++foreign import ccall "gzgets" c_gzgets ::+	GzFile -> CString -> #{type int} -> IO CString++foreign import ccall "gzclose" c_gzclose :: GzFile -> IO ReturnCode

@@ -0,0 +1,208 @@+{-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE BlockArguments, TupleSections #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE PatternSynonyms, ViewPatterns #-}+{-# OPTIONS_GHC -Wall -fno-warn-tabs #-}++module Codec.Compression.Zlib.Structure.Core (++	-- * STRUCTURE++	-- ** IMMUTABLE++	Stream, streamInitial,+	PAllocFunc, AllocFunc, PFreeFunc, FreeFunc, PtrBytef,++	streamNextIn, streamAvailIn, streamNextOut, streamAvailOut,+	streamAlloc, streamFree, streamOpaque,+++	-- ** MUTABLE++	StreamIO, StreamST, StreamPrim,+	withStreamPtr, streamFreeze, streamThaw, streamCopy,++	-- * IN/OUT++	nextIn, availIn, nextOut, availOut, msg,+	setNextIn, setNextOut,++	) where++import Foreign.Ptr+import Foreign.ForeignPtr+import Foreign.Marshal.Alloc+import Foreign.Storable+import Foreign.C.String+import Foreign.C.Struct+import Foreign.C.Struct.TypeSynonyms+import Control.Monad.Primitive+import Data.Word+import Data.Int++-- import Codec.Compression.Zlib.Constant.Core++#include <zlib.h>++type AllocFunc = Ptr () -> #{type uInt} -> #{type uInt} -> IO (Ptr ())+type FreeFunc = Ptr () -> Ptr () -> IO ()++type PAllocFunc = FunPtr AllocFunc+type PFreeFunc = FunPtr FreeFunc++type PtrBytef = Ptr #{type Bytef}++struct "Stream" #{size z_stream} #{alignment z_stream}+	[	("nextIn", ''PtrBytef,+			[| #{peek z_stream, next_in} |],+			[| #{poke z_stream, next_in} |]),+		("availIn", ''#{type uInt},+			[| #{peek z_stream, avail_in} |],+			[| #{poke z_stream, avail_in} |]),+			{-+		("totalIn", ''#{type uLong},+			[| #{peek z_stream, total_in} |],+			[| #{poke z_stream, total_in} |]),+			-}++		("nextOut", ''PtrBytef,+			[| #{peek z_stream, next_out} |],+			[| #{poke z_stream, next_out} |]),+		("availOut", ''#{type uInt},+			[| #{peek z_stream, avail_out} |],+			[| #{poke z_stream, avail_out} |]),+			{-+		("totalOut", ''#{type uLong},+			[| #{peek z_stream, total_out} |],+			[| #{poke z_stream, total_out} |]),+			-}++{-+		("msg", ''CString,+			[| #{peek z_stream, msg} |],+			[| #{poke z_stream, msg} |]),+			-}++		("alloc", ''PAllocFunc,+			[| #{peek z_stream, zalloc} |],+			[| #{poke z_stream, zalloc} |]),+		("free", ''PFreeFunc,+			[| #{peek z_stream, zfree} |],+			[| #{poke z_stream, zfree} |]),+		("opaque", ''PtrVoid,+			[| #{peek z_stream, opaque} |],+			[| #{poke z_stream, opaque} |])++{-+		("dataType", ''DataType,+			[| #{peek z_stream, data_type} |],+			[| #{poke z_stream, data_type} |]),++		("adler", ''#{type uLong},+			[| #{peek z_stream, adler} |],+			[| #{poke z_stream, adler} |])+			-}+		]+	[''Show, ''Eq, ''Storable]++streamInitial :: Stream+streamInitial = Stream {+	streamNextIn = nullPtr,+	streamAvailIn = 0,+	streamNextOut = nullPtr,+	streamAvailOut = 0,+	streamAlloc = nullFunPtr,+	streamFree = nullFunPtr,+	streamOpaque = nullPtr }++streamCopyPtr :: Ptr Stream -> IO (Ptr Stream)+streamCopyPtr src = do+	dst <- malloc++	(ni :: PtrBytef) <- #{peek z_stream, next_in} src+	#{poke z_stream, next_in} dst ni+	(ai :: #{type uInt}) <- #{peek z_stream, avail_in} src+	#{poke z_stream, avail_in} dst ai+	(ti :: #{type uLong}) <- #{peek z_stream, total_in} src+	#{poke z_stream, total_in} dst ti++	(no :: PtrBytef) <- #{peek z_stream, next_out} src+	#{poke z_stream, next_out} dst no+	(ao :: #{type uInt}) <- #{peek z_stream, avail_out} src+	#{poke z_stream, avail_out} dst ao+	(to :: #{type uLong}) <- #{peek z_stream, total_out} src+	#{poke z_stream, total_out} dst to++	(msg :: CString) <- #{peek z_stream, msg} src+	#{poke z_stream, msg} dst msg+	(stt :: Ptr ()) <- #{peek z_stream, state} src+	#{poke z_stream, state} dst stt++	(allc :: PAllocFunc) <- #{peek z_stream, zalloc} src+	#{poke z_stream, zalloc} dst allc+	(fr :: PFreeFunc) <- #{peek z_stream, zfree} src+	#{poke z_stream, zfree} dst fr+	(opq :: Ptr ()) <- #{peek z_stream, opaque} src+	#{poke z_stream, opaque} dst opq++	(dt :: #{type int}) <- #{peek z_stream, data_type} src+	#{poke z_stream, data_type} dst dt++	(ad :: #{type uLong}) <- #{peek z_stream, adler} src+	#{poke z_stream, adler} dst ad+	(rs :: #{type uLong}) <- #{peek z_stream, reserved} src+	#{poke z_stream, reserved} dst rs++	pure dst++streamFreePtr :: Ptr Stream -> IO ()+streamFreePtr = free++structPrim "Stream" 'streamCopyPtr 'streamFreePtr [''Show]++withStreamPtr ::+	PrimBase m => StreamPrim (PrimState m) -> (Ptr Stream -> m a) -> m a+withStreamPtr (StreamPrim s) f =+	unsafeIOToPrim $ withForeignPtr s (unsafePrimToIO . f)++nextIn :: PrimMonad m => StreamPrim (PrimState m) -> m (Ptr Word8)+nextIn (StreamPrim s) = unsafeIOToPrim $ withForeignPtr s nextInPtr++availIn :: PrimMonad m => StreamPrim (PrimState m) -> m #{type uInt}+availIn (StreamPrim s) = unsafeIOToPrim $ withForeignPtr s availInPtr++nextInPtr :: Ptr Stream -> IO (Ptr Word8)+nextInPtr = #{peek z_stream, next_in}++availInPtr :: Ptr Stream -> IO #{type uInt}+availInPtr = #{peek z_stream, avail_in}++nextOut :: PrimMonad m => StreamPrim (PrimState m) -> m (Ptr Word8)+nextOut (StreamPrim s) = unsafeIOToPrim $ withForeignPtr s nextOutPtr++availOut :: PrimMonad m => StreamPrim (PrimState m) -> m #{type uInt}+availOut (StreamPrim s) = unsafeIOToPrim $ withForeignPtr s availOutPtr++nextOutPtr :: Ptr Stream -> IO (Ptr Word8)+nextOutPtr = #{peek z_stream, next_out}++availOutPtr :: Ptr Stream -> IO #{type uInt}+availOutPtr = #{peek z_stream, avail_out}++msg :: PrimMonad m => StreamPrim (PrimState m) -> m CString+msg (StreamPrim s) = unsafeIOToPrim $ withForeignPtr s msgPtr++msgPtr :: Ptr Stream -> IO CString+msgPtr = #{peek z_stream, msg}++setNextIn :: PrimMonad m =>+	StreamPrim (PrimState m) -> PtrBytef -> #{type uInt} -> m ()+setNextIn (StreamPrim s) ni ai = unsafeIOToPrim $ withForeignPtr s \p -> do+	#{poke z_stream, next_in} p ni+	#{poke z_stream, avail_in} p ai++setNextOut :: PrimMonad m =>+	StreamPrim (PrimState m) -> PtrBytef -> #{type uInt} -> m ()+setNextOut (StreamPrim s) no ao = unsafeIOToPrim $ withForeignPtr s \p -> do+	#{poke z_stream, next_out} p no+	#{poke z_stream, avail_out} p ao

@@ -0,0 +1,24 @@+{-# LANGUAGE ImportQualifiedPost #-}+{-# OPTIONS_GHC -Wall -fno-warn-tabs #-}++module Codec.Compression.Zlib.Utility.Core (+	c_compress, c_compressBound, c_uncompress+	) where++import Foreign.Ptr+import Data.Word++import Codec.Compression.Zlib.Constant.Core++#include <zlib.h>++foreign import ccall "compress" c_compress ::+	Ptr #{type Bytef} -> Ptr #{type uLongf} ->+	Ptr #{type Bytef} -> #{type uLong} -> IO ReturnCode++foreign import ccall "compressBound" c_compressBound ::+	#{type uLong} -> #{type uLong}++foreign import ccall "uncompress" c_uncompress ::+	Ptr #{type Bytef} -> Ptr #{type uLongf} ->+	Ptr #{type Bytef} -> #{type uLong} -> IO ReturnCode

@@ -0,0 +1,2 @@+main :: IO ()+main = putStrLn "Test suite not yet implemented"

@@ -0,0 +1,71 @@+cabal-version: 2.2++-- This file has been generated from package.yaml by hpack version 0.38.1.+--+-- see: https://github.com/sol/hpack++name:           zlib-core+version:        0.1.0.0+synopsis:       Thin wrapper for zlib+description:    Please see the README on GitHub at <https://github.com/YoshikuniJujo/zlib-core#readme>+category:       Codec+homepage:       https://github.com/YoshikuniJujo/zlib-core#readme+bug-reports:    https://github.com/YoshikuniJujo/zlib-core/issues+author:         Yoshikuni Jujo+maintainer:     yoshikuni.jujo@gmail.com+copyright:      (c) 2025 Yoshikuni Jujo+license:        BSD-3-Clause+license-file:   LICENSE+build-type:     Simple+extra-source-files:+    README.md+extra-doc-files:+    CHANGELOG.md++source-repository head+  type: git+  location: https://github.com/YoshikuniJujo/zlib-core++library+  exposed-modules:+      Codec.Compression.Zlib.Advanced.Core+      Codec.Compression.Zlib.Basic.Core+      Codec.Compression.Zlib.Constant.Core+      Codec.Compression.Zlib.Gzip.Core+      Codec.Compression.Zlib.Structure.Core+      Codec.Compression.Zlib.Utility.Core+  other-modules:+      Paths_zlib_core+  autogen-modules:+      Paths_zlib_core+  hs-source-dirs:+      src+  ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints+  build-depends:+      base >=4.7 && <5+    , c-enum ==0.1.*+    , c-struct ==0.1.*+    , exception-hierarchy ==0.1.*+    , primitive ==0.9.*+    , tools-yj ==0.1.*+  default-language: Haskell2010++test-suite zlib-core-test+  type: exitcode-stdio-1.0+  main-is: Spec.hs+  other-modules:+      Paths_zlib_core+  autogen-modules:+      Paths_zlib_core+  hs-source-dirs:+      test+  ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints -threaded -rtsopts -with-rtsopts=-N+  build-depends:+      base >=4.7 && <5+    , c-enum ==0.1.*+    , c-struct ==0.1.*+    , exception-hierarchy ==0.1.*+    , primitive ==0.9.*+    , tools-yj ==0.1.*+    , zlib-core+  default-language: Haskell2010