diff --git a/ChangeLog b/ChangeLog new file mode 100644 --- /dev/null +++ b/ChangeLog @@ -0,0 +1,11 @@ +0.1.0.4: 2017-03-19 + * fixed build on `i686` related to non-fixed size integers + +0.1.0.2: 2016-10-10 + * fixed build problems because of TemplateHaskell 2.11 + +0.1.0.1: 2016-08-10 + * fixed build issue: added bitfn.h to cabal file + +0.1.0.0: 2016-08-09 + * initial release diff --git a/cbits/md5.c b/cbits/md5.c --- a/cbits/md5.c +++ b/cbits/md5.c @@ -152,42 +152,42 @@ memcpy(ctx->buf + index, data, len); } -void md5_update_char(struct md5_ctx *ctx, char data) +void md5_update_char(struct md5_ctx *ctx, int8_t data) { md5_update(ctx, (uint8_t *)&data, sizeof(data)); } -void md5_update_uchar(struct md5_ctx *ctx, unsigned char data) +void md5_update_uchar(struct md5_ctx *ctx, uint8_t data) { - md5_update(ctx, (uint8_t *)&data, sizeof(data)); + md5_update(ctx, &data, sizeof(data)); } -void md5_update_short(struct md5_ctx *ctx, short data) +void md5_update_short(struct md5_ctx *ctx, int16_t data) { md5_update(ctx, (uint8_t *)&data, sizeof(data)); } -void md5_update_ushort(struct md5_ctx *ctx, unsigned short data) +void md5_update_ushort(struct md5_ctx *ctx, uint16_t data) { md5_update(ctx, (uint8_t *)&data, sizeof(data)); } -void md5_update_int(struct md5_ctx *ctx, int data) +void md5_update_int(struct md5_ctx *ctx, int32_t data) { md5_update(ctx, (uint8_t *)&data, sizeof(data)); } -void md5_update_uint(struct md5_ctx *ctx, unsigned int data) +void md5_update_uint(struct md5_ctx *ctx, uint32_t data) { md5_update(ctx, (uint8_t *)&data, sizeof(data)); } -void md5_update_long(struct md5_ctx *ctx, long data) +void md5_update_long(struct md5_ctx *ctx, int64_t data) { md5_update(ctx, (uint8_t *)&data, sizeof(data)); } -void md5_update_ulong(struct md5_ctx *ctx, unsigned long data) +void md5_update_ulong(struct md5_ctx *ctx, uint64_t data) { md5_update(ctx, (uint8_t *)&data, sizeof(data)); } diff --git a/cbits/md5.h b/cbits/md5.h --- a/cbits/md5.h +++ b/cbits/md5.h @@ -38,14 +38,14 @@ void md5_init(struct md5_ctx *ctx); void md5_update(struct md5_ctx *ctx, uint8_t *data, uint32_t len); -void md5_update_char(struct md5_ctx *ctx, char data); -void md5_update_uchar(struct md5_ctx *ctx, unsigned char data); -void md5_update_short(struct md5_ctx *ctx, short data); -void md5_update_ushort(struct md5_ctx *ctx, unsigned short data); -void md5_update_int(struct md5_ctx *ctx, int data); -void md5_update_uint(struct md5_ctx *ctx, unsigned int data); -void md5_update_long(struct md5_ctx *ctx, long data); -void md5_update_ulong(struct md5_ctx *ctx, unsigned long data); +void md5_update_char(struct md5_ctx *ctx, int8_t data); +void md5_update_uchar(struct md5_ctx *ctx, uint8_t data); +void md5_update_short(struct md5_ctx *ctx, int16_t data); +void md5_update_ushort(struct md5_ctx *ctx, uint16_t data); +void md5_update_int(struct md5_ctx *ctx, int32_t data); +void md5_update_uint(struct md5_ctx *ctx, uint32_t data); +void md5_update_long(struct md5_ctx *ctx, int64_t data); +void md5_update_ulong(struct md5_ctx *ctx, uint64_t data); void md5_finalize(struct md5_ctx *ctx, uint8_t *out); #endif diff --git a/default.nix b/default.nix new file mode 100644 --- /dev/null +++ b/default.nix @@ -0,0 +1,2 @@ +let pkgs = import { }; +in pkgs.haskellPackages.callPackage ./large-hashable.nix { } diff --git a/large-hashable.cabal b/large-hashable.cabal --- a/large-hashable.cabal +++ b/large-hashable.cabal @@ -1,5 +1,5 @@ name: large-hashable -version: 0.1.0.3 +version: 0.1.0.4 synopsis: Efficiently hash (large) Haskell values description: Please see README.md homepage: https://github.com/factisresearch/large-hashable @@ -7,7 +7,7 @@ license-file: LICENSE author: Stefan Wehr, Lukas Epple maintainer: Stefan Wehr -copyright: 2015 - 2016 factis research GmbH +copyright: 2015 - 2017 factis research GmbH category: Web build-type: Simple cabal-version: >=1.10 @@ -15,7 +15,8 @@ cbits/md5.h cbits/bitfn.h README.md - shell.nix + ChangeLog + default.nix stack.yaml library diff --git a/shell.nix b/shell.nix deleted file mode 100644 --- a/shell.nix +++ /dev/null @@ -1,43 +0,0 @@ -{ nixpkgs ? import {}, compiler ? "default" }: - -let - - inherit (nixpkgs) pkgs; - - f = { mkDerivation, base, base16-bytestring, byteable, bytes - , bytestring, cereal, containers, cryptohash, deepseq, hashable - , HTF, QuickCheck, safecopy, stdenv, template-haskell, text, time - , transformers, unordered-containers - }: - mkDerivation { - pname = "large-hashable"; - version = "0.1.0.0"; - src = ./.; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base base16-bytestring bytes bytestring containers template-haskell - text time transformers unordered-containers - ]; - executableHaskellDepends = [ - base byteable bytes bytestring cereal cryptohash deepseq safecopy - text transformers - ]; - testHaskellDepends = [ - base bytes bytestring containers hashable HTF QuickCheck text - unordered-containers - ]; - homepage = "http://github.com/githubuser/large-hashable#readme"; - description = "Initial project template from stack"; - license = stdenv.lib.licenses.bsd3; - }; - - haskellPackages = if compiler == "default" - then pkgs.haskellPackages - else pkgs.haskell.packages.${compiler}; - - drv = haskellPackages.callPackage f {}; - -in - - if pkgs.lib.inNixShell then drv.env else drv diff --git a/src/Data/LargeHashable/Class.hs b/src/Data/LargeHashable/Class.hs --- a/src/Data/LargeHashable/Class.hs +++ b/src/Data/LargeHashable/Class.hs @@ -162,61 +162,61 @@ ioInLH $ f updates x instance LargeHashable Int where - updateHash i = updateHashWithFun hu_updateLong (fromIntegral i) + updateHash = updateHashWithFun hu_updateLong . fromIntegral instance LargeHashable Int8 where - updateHash = updateHashWithFun hu_updateChar . CChar + updateHash = updateHashWithFun hu_updateChar instance LargeHashable Int16 where - updateHash = updateHashWithFun hu_updateShort . CShort + updateHash = updateHashWithFun hu_updateShort instance LargeHashable Int32 where - updateHash = updateHashWithFun hu_updateInt . CInt + updateHash = updateHashWithFun hu_updateInt instance LargeHashable Int64 where - updateHash = updateHashWithFun hu_updateLong . CLong + updateHash = updateHashWithFun hu_updateLong instance LargeHashable Word where - updateHash i = updateHashWithFun hu_updateLong (fromIntegral i) + updateHash = updateHashWithFun hu_updateLong . fromIntegral instance LargeHashable Word8 where - updateHash = updateHashWithFun hu_updateUChar . CUChar + updateHash = updateHashWithFun hu_updateUChar instance LargeHashable Word16 where - updateHash = updateHashWithFun hu_updateUShort . CUShort + updateHash = updateHashWithFun hu_updateUShort instance LargeHashable Word32 where - updateHash = updateHashWithFun hu_updateUInt . CUInt + updateHash = updateHashWithFun hu_updateUInt instance LargeHashable Word64 where - updateHash = updateHashWithFun hu_updateULong . CULong + updateHash = updateHashWithFun hu_updateULong . fromIntegral instance LargeHashable CChar where - updateHash = updateHashWithFun hu_updateChar + updateHash (CChar i) = updateHashWithFun hu_updateChar i instance LargeHashable CShort where - updateHash = updateHashWithFun hu_updateShort + updateHash (CShort i) = updateHashWithFun hu_updateShort i instance LargeHashable CInt where - updateHash = updateHashWithFun hu_updateInt + updateHash (CInt i) = updateHashWithFun hu_updateInt i instance LargeHashable CLong where - updateHash = updateHashWithFun hu_updateLong + updateHash (CLong i) = updateHashWithFun hu_updateLong (fromIntegral i) instance LargeHashable CUChar where - updateHash = updateHashWithFun hu_updateUChar + updateHash (CUChar w) = updateHashWithFun hu_updateUChar w instance LargeHashable CUShort where - updateHash = updateHashWithFun hu_updateUShort + updateHash (CUShort w) = updateHashWithFun hu_updateUShort w instance LargeHashable CUInt where - updateHash = updateHashWithFun hu_updateUInt + updateHash (CUInt w) = updateHashWithFun hu_updateUInt w instance LargeHashable CULong where - updateHash = updateHashWithFun hu_updateULong + updateHash (CULong w) = updateHashWithFun hu_updateULong (fromIntegral w) instance LargeHashable Char where - updateHash = updateHashWithFun hu_updateUInt . CUInt . Utf8.c2w + updateHash = updateHashWithFun hu_updateUInt . Utf8.c2w {-# INLINE updateHashInteger #-} updateHashInteger :: Integer -> LH () diff --git a/src/Data/LargeHashable/Intern.hs b/src/Data/LargeHashable/Intern.hs --- a/src/Data/LargeHashable/Intern.hs +++ b/src/Data/LargeHashable/Intern.hs @@ -18,8 +18,8 @@ -- keep imports in alphabetic order (in Emacs, use "M-x sort-lines") import Control.Monad +import Data.Int import Data.Word -import Foreign.C.Types import Foreign.Ptr import System.IO.Unsafe (unsafePerformIO) @@ -28,14 +28,14 @@ data HashUpdates = HashUpdates { hu_updatePtr :: {-# NOUNPACK #-} !(Ptr Word8 -> Int -> IO ()) -- ^ adds a byte array to the hash - , hu_updateChar :: {-# NOUNPACK #-} !(CChar -> IO ()) -- Int8 - , hu_updateUChar :: {-# NOUNPACK #-} !(CUChar -> IO ()) -- Word8 - , hu_updateShort :: {-# NOUNPACK #-} !(CShort -> IO ()) -- Int16 - , hu_updateUShort :: {-# NOUNPACK #-} !(CUShort -> IO ()) -- Word16 - , hu_updateInt :: {-# NOUNPACK #-} !(CInt -> IO ()) -- Int32 - , hu_updateUInt :: {-# NOUNPACK #-} !(CUInt -> IO ()) -- Word32 - , hu_updateLong :: {-# NOUNPACK #-} !(CLong -> IO ()) -- Int64 - , hu_updateULong :: {-# NOUNPACK #-} !(CULong -> IO ()) -- Word64 + , hu_updateChar :: {-# NOUNPACK #-} !(Int8 -> IO ()) -- Int8 + , hu_updateUChar :: {-# NOUNPACK #-} !(Word8 -> IO ()) -- Word8 + , hu_updateShort :: {-# NOUNPACK #-} !(Int16 -> IO ()) -- Int16 + , hu_updateUShort :: {-# NOUNPACK #-} !(Word16 -> IO ()) -- Word16 + , hu_updateInt :: {-# NOUNPACK #-} !(Int32 -> IO ()) -- Int32 + , hu_updateUInt :: {-# NOUNPACK #-} !(Word32 -> IO ()) -- Word32 + , hu_updateLong :: {-# NOUNPACK #-} !(Int64 -> IO ()) -- Int64 + , hu_updateULong :: {-# NOUNPACK #-} !(Word64 -> IO ()) -- Word64 } -- | The interface for a hashing algorithm. The interface contains a simple run diff --git a/src/Data/LargeHashable/MD5.hs b/src/Data/LargeHashable/MD5.hs --- a/src/Data/LargeHashable/MD5.hs +++ b/src/Data/LargeHashable/MD5.hs @@ -8,10 +8,10 @@ ) where -- keep imports in alphabetic order (in Emacs, use "M-x sort-lines") +import Data.Int import Data.LargeHashable.Intern import Data.LargeHashable.LargeWord import Data.Word -import Foreign.C.Types import Foreign.Marshal.Alloc import Foreign.Ptr import Foreign.Storable @@ -32,28 +32,28 @@ c_md5_update :: Ptr RawCtx -> Ptr Word8 -> Int -> IO () foreign import ccall unsafe "md5.h md5_update_char" - c_md5_update_char :: Ptr RawCtx -> CChar -> IO () + c_md5_update_char :: Ptr RawCtx -> Int8 -> IO () foreign import ccall unsafe "md5.h md5_update_uchar" - c_md5_update_uchar :: Ptr RawCtx -> CUChar -> IO () + c_md5_update_uchar :: Ptr RawCtx -> Word8 -> IO () foreign import ccall unsafe "md5.h md5_update_short" - c_md5_update_short :: Ptr RawCtx -> CShort -> IO () + c_md5_update_short :: Ptr RawCtx -> Int16 -> IO () foreign import ccall unsafe "md5.h md5_update_ushort" - c_md5_update_ushort :: Ptr RawCtx -> CUShort -> IO () + c_md5_update_ushort :: Ptr RawCtx -> Word16 -> IO () foreign import ccall unsafe "md5.h md5_update_int" - c_md5_update_int :: Ptr RawCtx -> CInt -> IO () + c_md5_update_int :: Ptr RawCtx -> Int32 -> IO () foreign import ccall unsafe "md5.h md5_update_uint" - c_md5_update_uint :: Ptr RawCtx -> CUInt -> IO () + c_md5_update_uint :: Ptr RawCtx -> Word32 -> IO () foreign import ccall unsafe "md5.h md5_update_long" - c_md5_update_long :: Ptr RawCtx -> CLong -> IO () + c_md5_update_long :: Ptr RawCtx -> Int64 -> IO () foreign import ccall unsafe "md5.h md5_update_ulong" - c_md5_update_ulong :: Ptr RawCtx -> CULong -> IO () + c_md5_update_ulong :: Ptr RawCtx -> Word64 -> IO () foreign import ccall unsafe "md5.h md5_finalize" c_md5_finalize :: Ptr RawCtx -> Ptr Word8 -> IO () @@ -93,7 +93,7 @@ where xorMD5 (MD5Hash h1) (MD5Hash h2) = MD5Hash (h1 `xorW128` h2) updateHash updates (MD5Hash h) = - let f = hu_updateULong updates . CULong + let f = hu_updateULong updates in do f (w128_first h) f (w128_second h) run f =