diff --git a/CHANGELOG.md b/CHANGELOG.md index e1ccfc8..17b7614 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,20 @@ +## 0.21.0 + ++ `Data.ByteArray.Encoding`: replaced custom Base16/Base32/Base64 encode/decode + with `base16`, `base32`, and `base64` library calls. Input is converted to + `ByteString` via `B.convert`, the library function is applied, and the result + is converted back. `Base64OpenBSD` retains its custom implementation (no + library equivalent exists). ++ `Data.ByteArray.Bytes`: replaced low-level `GHC.Prim` `MutableByteArray#` + implementation with `newtype Bytes = Bytes ByteString`. Both use GHC's pinned + allocator; `ByteString` already implements `ByteArrayAccess` / `ByteArray`. ++ `Data.Memory.Hash.FNV`: replaced `readWord8OffAddr#` (GHC.Prim) with + `Foreign.Storable.peekByteOff` — portable and equivalent. ++ `Data.Memory.Internal.CompatPrim64`: deleted (was entirely unreferenced). ++ New dependencies: `base16 >=1.0 && <2`, `base32 >=0.4 && <1`, + `base64 >=1.0 && <2`, `text >=1.0 && <3`. ++ Net reduction: ~350 lines removed. + ## 0.20.1 + Remove `WITH_BYTESTRING_SUPPORT` CPP flag. `ByteString` instances for `ByteArrayAccess` and `ByteArray` are now always compiled in, since diff --git a/Data/ByteArray.hs b/Data/ByteArray.hs index 32455c6..ea0f414 100644 --- a/Data/ByteArray.hs +++ b/Data/ByteArray.hs @@ -9,9 +9,6 @@ -- -- This module should be imported qualified. -- -{-# LANGUAGE BangPatterns #-} -{-# LANGUAGE MagicHash #-} -{-# LANGUAGE UnboxedTuples #-} {-# LANGUAGE NoImplicitPrelude #-} module Data.ByteArray ( diff --git a/Data/ByteArray/Bytes.hs b/Data/ByteArray/Bytes.hs index d0b29a3..80c8abf 100644 --- a/Data/ByteArray/Bytes.hs +++ b/Data/ByteArray/Bytes.hs @@ -7,191 +7,50 @@ -- -- Simple and efficient byte array types -- -{-# LANGUAGE BangPatterns #-} -{-# LANGUAGE MagicHash #-} -{-# LANGUAGE UnboxedTuples #-} -{-# LANGUAGE DeriveDataTypeable #-} module Data.ByteArray.Bytes ( Bytes ) where -import Control.DeepSeq(NFData(..)) -import GHC.Exts (unsafeCoerce#) -import GHC.Word -import GHC.Char (chr) -import GHC.Types -import GHC.Prim -import GHC.Ptr -import Data.Semigroup -import Data.Foldable (toList) -import Data.Memory.PtrMethods -import Data.Memory.Internal.CompatPrim -import Data.Memory.Internal.Compat (unsafeDoIO) +import Control.DeepSeq (NFData(..)) import Data.ByteArray.Types +import Data.Char (chr) +import Data.Foldable (toList) +import Data.Semigroup import Data.Typeable - +import qualified Data.ByteString as BS +import qualified Data.ByteString.Internal as BSI +import Foreign.ForeignPtr (withForeignPtr) +import Foreign.Ptr (castPtr) -- | Simplest Byte Array -data Bytes = Bytes (MutableByteArray# RealWorld) +newtype Bytes = Bytes BS.ByteString deriving (Typeable) instance NFData Bytes where rnf b = b `seq` () instance Show Bytes where - showsPrec p b r = showsPrec p (bytesUnpackChars b []) r + showsPrec p (Bytes b) = showsPrec p (map (chr . fromIntegral) (BS.unpack b)) + instance Eq Bytes where - (==) = bytesEq + Bytes a == Bytes b = a == b + instance Ord Bytes where - compare = bytesCompare + compare (Bytes a) (Bytes b) = compare a b + instance Semigroup Bytes where - b1 <> b2 = unsafeDoIO $ bytesAppend b1 b2 - sconcat = unsafeDoIO . bytesConcat . toList + Bytes a <> Bytes b = Bytes (a <> b) + sconcat bs = Bytes $ BS.concat [b | Bytes b <- toList bs] + instance Monoid Bytes where - mempty = unsafeDoIO (newBytes 0) + mempty = Bytes BS.empty instance ByteArrayAccess Bytes where - length = bytesLength - withByteArray = withBytes -instance ByteArray Bytes where - allocRet = bytesAllocRet - ------------------------------------------------------------------------- -newBytes :: Int -> IO Bytes -newBytes (I# sz) - | booleanPrim (sz <# 0#) = error "Bytes: size must be >= 0" - | otherwise = IO $ \s -> - case newAlignedPinnedByteArray# sz 8# s of - (# s', mbarr #) -> (# s', Bytes mbarr #) - -touchBytes :: Bytes -> IO () -touchBytes (Bytes mba) = IO $ \s -> case touch# mba s of s' -> (# s', () #) -{-# INLINE touchBytes #-} - -sizeofBytes :: Bytes -> Int -sizeofBytes (Bytes mba) = I# (sizeofMutableByteArray# mba) -{-# INLINE sizeofBytes #-} - -withPtr :: Bytes -> (Ptr p -> IO a) -> IO a -withPtr b@(Bytes mba) f = do - a <- f (Ptr (byteArrayContents# (unsafeCoerce# mba))) - touchBytes b - return a ------------------------------------------------------------------------- - -bytesAlloc :: Int -> (Ptr p -> IO ()) -> IO Bytes -bytesAlloc sz f = do - ba <- newBytes sz - withPtr ba f - return ba - -bytesConcat :: [Bytes] -> IO Bytes -bytesConcat l = bytesAlloc retLen (copy l) - where - !retLen = sum $ map bytesLength l + length (Bytes b) = BS.length b + withByteArray (Bytes b) = withByteArray b - copy [] _ = return () - copy (x:xs) dst = do - withPtr x $ \src -> memCopy dst src chunkLen - copy xs (dst `plusPtr` chunkLen) - where - !chunkLen = bytesLength x - -bytesAppend :: Bytes -> Bytes -> IO Bytes -bytesAppend b1 b2 = bytesAlloc retLen $ \dst -> do - withPtr b1 $ \s1 -> memCopy dst s1 len1 - withPtr b2 $ \s2 -> memCopy (dst `plusPtr` len1) s2 len2 - where - !len1 = bytesLength b1 - !len2 = bytesLength b2 - !retLen = len1 + len2 - -bytesAllocRet :: Int -> (Ptr p -> IO a) -> IO (a, Bytes) -bytesAllocRet sz f = do - ba <- newBytes sz - r <- withPtr ba f - return (r, ba) - -bytesLength :: Bytes -> Int -bytesLength = sizeofBytes -{-# LANGUAGE bytesLength #-} - -withBytes :: Bytes -> (Ptr p -> IO a) -> IO a -withBytes = withPtr - -bytesEq :: Bytes -> Bytes -> Bool -bytesEq b1@(Bytes m1) b2@(Bytes m2) - | l1 /= l2 = False - | otherwise = unsafeDoIO $ IO $ \s -> loop 0# s - where - !l1@(I# len) = bytesLength b1 - !l2 = bytesLength b2 - - loop i s - | booleanPrim (i ==# len) = (# s, True #) - | otherwise = - case readWord8Array# m1 i s of - (# s', e1 #) -> case readWord8Array# m2 i s' of - (# s'', e2 #) -> - if (W8# e1) == (W8# e2) - then loop (i +# 1#) s'' - else (# s'', False #) - {-# INLINE loop #-} - -bytesCompare :: Bytes -> Bytes -> Ordering -bytesCompare b1@(Bytes m1) b2@(Bytes m2) = unsafeDoIO $ loop 0 - where - !l1 = bytesLength b1 - !l2 = bytesLength b2 - !len = min l1 l2 - - loop !i - | i == len = - if l1 == l2 - then pure EQ - else if l1 > l2 then pure GT - else pure LT - | otherwise = do - e1 <- read8 m1 i - e2 <- read8 m2 i - if e1 == e2 - then loop (i+1) - else if e1 < e2 then pure LT - else pure GT - - read8 m (I# i) = IO $ \s -> case readWord8Array# m i s of - (# s2, e #) -> (# s2, W8# e #) - -bytesUnpackChars :: Bytes -> String -> String -bytesUnpackChars (Bytes mba) xs = chunkLoop 0# - where - !len = sizeofMutableByteArray# mba - -- chunk 64 bytes at a time - chunkLoop :: Int# -> [Char] - chunkLoop idx - | booleanPrim (len ==# idx) = [] - | booleanPrim ((len -# idx) ># 63#) = - bytesLoop idx 64# (chunkLoop (idx +# 64#)) - | otherwise = - bytesLoop idx (len -# idx) xs - - bytesLoop idx chunkLenM1 paramAcc = unsafeDoIO $ - loop (idx +# chunkLenM1 -# 1#) paramAcc - where loop i acc - | booleanPrim (i ==# idx) = do - c <- rChar i - return (c : acc) - | otherwise = do - c <- rChar i - loop (i -# 1#) (c : acc) - - rChar :: Int# -> IO Char - rChar idx = IO $ \s -> - case readWord8Array# mba idx s of - (# s2, w #) -> (# s2, chr (fromIntegral (W8# w)) #) - -{- -bytesShowHex :: Bytes -> String -bytesShowHex b = showHexadecimal (withPtr b) (bytesLength b) -{-# NOINLINE bytesShowHex #-} --} +instance ByteArray Bytes where + allocRet n f = do + fptr <- BSI.mallocByteString n + r <- withForeignPtr fptr (f . castPtr) + return (r, Bytes (BSI.PS fptr 0 n)) diff --git a/Data/ByteArray/Encoding.hs b/Data/ByteArray/Encoding.hs index 3210fb9..01ddd49 100644 --- a/Data/ByteArray/Encoding.hs +++ b/Data/ByteArray/Encoding.hs @@ -16,10 +16,17 @@ module Data.ByteArray.Encoding import Data.ByteArray.Types import qualified Data.ByteArray.Types as B import qualified Data.ByteArray.Methods as B -import Data.Memory.Internal.Compat -import Data.Memory.Encoding.Base16 -import Data.Memory.Encoding.Base32 -import Data.Memory.Encoding.Base64 +import qualified Data.ByteString as BS +import qualified Data.ByteString.Base16 as B16 +import qualified Data.ByteString.Base32 as B32 +import qualified Data.ByteString.Base64 as B64 +import qualified Data.ByteString.Base64.URL as B64URL +import Data.Base16.Types (extractBase16) +import Data.Base64.Types (extractBase64) +import qualified Data.Text as T +import Data.Memory.Encoding.Base64 (toBase64OpenBSD, fromBase64OpenBSD, + unBase64LengthUnpadded) +import Data.Memory.Internal.Compat (unsafeDoIO) -- $setup -- >>> :set -XOverloadedStrings @@ -74,27 +81,20 @@ data Base = Base16 -- ^ similar to hexadecimal -- "Zm9vYmFy" -- convertToBase :: (ByteArrayAccess bin, ByteArray bout) => Base -> bin -> bout -convertToBase base b = case base of - Base16 -> doConvert (binLength * 2) toHexadecimal - Base32 -> let (q,r) = binLength `divMod` 5 - outLen = 8 * (if r == 0 then q else q + 1) - in doConvert outLen toBase32 - Base64 -> doConvert base64Length toBase64 - -- Base64URL -> doConvert base64Length (toBase64URL True) - Base64URLUnpadded -> doConvert base64UnpaddedLength (toBase64URL False) - Base64OpenBSD -> doConvert base64UnpaddedLength toBase64OpenBSD - where - binLength = B.length b - - base64Length = let (q,r) = binLength `divMod` 3 - in 4 * (if r == 0 then q else q+1) - - base64UnpaddedLength = let (q,r) = binLength `divMod` 3 - in 4 * q + (if r == 0 then 0 else r+1) - doConvert l f = - B.unsafeCreate l $ \bout -> - B.withByteArray b $ \bin -> - f bout bin binLength +convertToBase base b = + let bs = B.convert b :: BS.ByteString + in case base of + Base16 -> B.convert $ extractBase16 (B16.encodeBase16' bs) + Base32 -> B.convert $ B32.encodeBase32' bs + Base64 -> B.convert $ extractBase64 (B64.encodeBase64' bs) + Base64URLUnpadded -> B.convert $ extractBase64 (B64URL.encodeBase64Unpadded' bs) + Base64OpenBSD -> + let binLength = B.length b + (q, r) = binLength `divMod` 3 + outLen = 4 * q + (if r == 0 then 0 else r + 1) + in B.unsafeCreate outLen $ \bout -> + withByteArray b $ \bin -> + toBase64OpenBSD bout bin binLength -- | Try to decode some bytes from the equivalent representation in a specific 'Base'. -- @@ -108,55 +108,27 @@ convertToBase base b = case base of -- Trying to decode invalid data will return an error string: -- -- >>> convertFromBase Base64 ("!!!" :: ByteString) :: Either String ByteString --- Left "base64: input: invalid length" +-- Left "Base64-encoded bytestring requires padding" -- convertFromBase :: (ByteArrayAccess bin, ByteArray bout) => Base -> bin -> Either String bout -convertFromBase Base16 b - | odd (B.length b) = Left "base16: input: invalid length" - | otherwise = unsafeDoIO $ do - (ret, out) <- - B.allocRet (B.length b `div` 2) $ \bout -> - B.withByteArray b $ \bin -> - fromHexadecimal bout bin (B.length b) - case ret of - Nothing -> return $ Right out - Just ofs -> return $ Left ("base16: input: invalid encoding at offset: " ++ show ofs) -convertFromBase Base32 b = unsafeDoIO $ - withByteArray b $ \bin -> do - mDstLen <- unBase32Length bin (B.length b) - case mDstLen of - Nothing -> return $ Left "base32: input: invalid length" - Just dstLen -> do - (ret, out) <- B.allocRet dstLen $ \bout -> fromBase32 bout bin (B.length b) - case ret of - Nothing -> return $ Right out - Just ofs -> return $ Left ("base32: input: invalid encoding at offset: " ++ show ofs) -convertFromBase Base64 b = unsafeDoIO $ - withByteArray b $ \bin -> do - mDstLen <- unBase64Length bin (B.length b) - case mDstLen of - Nothing -> return $ Left "base64: input: invalid length" - Just dstLen -> do - (ret, out) <- B.allocRet dstLen $ \bout -> fromBase64 bout bin (B.length b) - case ret of - Nothing -> return $ Right out - Just ofs -> return $ Left ("base64: input: invalid encoding at offset: " ++ show ofs) -convertFromBase Base64URLUnpadded b = unsafeDoIO $ - withByteArray b $ \bin -> - case unBase64LengthUnpadded (B.length b) of - Nothing -> return $ Left "base64URL unpadded: input: invalid length" - Just dstLen -> do - (ret, out) <- B.allocRet dstLen $ \bout -> fromBase64URLUnpadded bout bin (B.length b) - case ret of - Nothing -> return $ Right out - Just ofs -> return $ Left ("base64URL unpadded: input: invalid encoding at offset: " ++ show ofs) -convertFromBase Base64OpenBSD b = unsafeDoIO $ - withByteArray b $ \bin -> - case unBase64LengthUnpadded (B.length b) of - Nothing -> return $ Left "base64 unpadded: input: invalid length" - Just dstLen -> do - (ret, out) <- B.allocRet dstLen $ \bout -> fromBase64OpenBSD bout bin (B.length b) - case ret of - Nothing -> return $ Right out - Just ofs -> return $ Left ("base64 unpadded: input: invalid encoding at offset: " ++ show ofs) +convertFromBase base b = + let bs = B.convert b :: BS.ByteString + run = fmap B.convert . mapLeft T.unpack + in case base of + Base16 -> run $ B16.decodeBase16Untyped bs + Base32 -> run $ B32.decodeBase32 bs + Base64 -> run $ B64.decodeBase64Untyped bs + Base64URLUnpadded -> run $ B64URL.decodeBase64UnpaddedUntyped bs + Base64OpenBSD -> unsafeDoIO $ + withByteArray b $ \bin -> + case unBase64LengthUnpadded (B.length b) of + Nothing -> return $ Left "base64 unpadded: input: invalid length" + Just dstLen -> do + (ret, out) <- B.allocRet dstLen $ \bout -> fromBase64OpenBSD bout bin (B.length b) + return $ case ret of + Nothing -> Right out + Just ofs -> Left ("base64 unpadded: input: invalid encoding at offset: " ++ show ofs) +mapLeft :: (a -> b) -> Either a c -> Either b c +mapLeft f (Left a) = Left (f a) +mapLeft _ (Right c) = Right c diff --git a/Data/Memory/Hash/FNV.hs b/Data/Memory/Hash/FNV.hs index d311b1f..6fd9dc5 100644 --- a/Data/Memory/Hash/FNV.hs +++ b/Data/Memory/Hash/FNV.hs @@ -9,8 +9,6 @@ -- -- {-# LANGUAGE GeneralizedNewtypeDeriving #-} -{-# LANGUAGE MagicHash #-} -{-# LANGUAGE UnboxedTuples #-} {-# LANGUAGE BangPatterns #-} module Data.Memory.Hash.FNV ( @@ -24,14 +22,11 @@ module Data.Memory.Hash.FNV , fnv1a_64 ) where -import Data.Bits (xor) -import Data.Memory.Internal.Compat () -import Data.Memory.Internal.Imports -import GHC.Word -import GHC.Prim hiding (Word64#, Int64#) -import GHC.Types -import GHC.Ptr -import Control.DeepSeq(NFData(..)) +import Data.Bits (xor) +import Data.Word (Word8, Word32, Word64) +import Foreign.Ptr (Ptr) +import Foreign.Storable (peekByteOff) +import Control.DeepSeq (NFData(..)) -- | FNV1(a) hash (32 bit variants) newtype FnvHash32 = FnvHash32 Word32 @@ -59,48 +54,32 @@ fnv1a_64_Mix8 !w (FnvHash64 acc) = FnvHash64 (0x100000001b3 * xor acc (fromInteg -- | compute FNV1 (32 bit variant) of a raw piece of memory fnv1 :: Ptr Word8 -> Int -> IO FnvHash32 -fnv1 (Ptr addr) n = loop (FnvHash32 0x811c9dc5) 0 - where - loop :: FnvHash32 -> Int -> IO FnvHash32 +fnv1 ptr n = loop (FnvHash32 0x811c9dc5) 0 + where loop !acc !i - | i == n = pure $ acc - | otherwise = do - v <- read8 addr i - loop (fnv1_32_Mix8 v acc) (i + 1) + | i == n = pure acc + | otherwise = peekByteOff ptr i >>= \v -> loop (fnv1_32_Mix8 v acc) (i + 1) -- | compute FNV1a (32 bit variant) of a raw piece of memory fnv1a :: Ptr Word8 -> Int -> IO FnvHash32 -fnv1a (Ptr addr) n = loop (FnvHash32 0x811c9dc5) 0 - where - loop :: FnvHash32 -> Int -> IO FnvHash32 +fnv1a ptr n = loop (FnvHash32 0x811c9dc5) 0 + where loop !acc !i - | i == n = pure $ acc - | otherwise = do - v <- read8 addr i - loop (fnv1a_32_Mix8 v acc) (i + 1) + | i == n = pure acc + | otherwise = peekByteOff ptr i >>= \v -> loop (fnv1a_32_Mix8 v acc) (i + 1) -- | compute FNV1 (64 bit variant) of a raw piece of memory fnv1_64 :: Ptr Word8 -> Int -> IO FnvHash64 -fnv1_64 (Ptr addr) n = loop (FnvHash64 0xcbf29ce484222325) 0 - where - loop :: FnvHash64 -> Int -> IO FnvHash64 +fnv1_64 ptr n = loop (FnvHash64 0xcbf29ce484222325) 0 + where loop !acc !i - | i == n = pure $ acc - | otherwise = do - v <- read8 addr i - loop (fnv1_64_Mix8 v acc) (i + 1) + | i == n = pure acc + | otherwise = peekByteOff ptr i >>= \v -> loop (fnv1_64_Mix8 v acc) (i + 1) -- | compute FNV1a (64 bit variant) of a raw piece of memory fnv1a_64 :: Ptr Word8 -> Int -> IO FnvHash64 -fnv1a_64 (Ptr addr) n = loop (FnvHash64 0xcbf29ce484222325) 0 - where - loop :: FnvHash64 -> Int -> IO FnvHash64 +fnv1a_64 ptr n = loop (FnvHash64 0xcbf29ce484222325) 0 + where loop !acc !i - | i == n = pure $ acc - | otherwise = do - v <- read8 addr i - loop (fnv1a_64_Mix8 v acc) (i + 1) - -read8 :: Addr# -> Int -> IO Word8 -read8 addr (I# i) = IO $ \s -> case readWord8OffAddr# addr i s of - (# s2, e #) -> (# s2, W8# e #) + | i == n = pure acc + | otherwise = peekByteOff ptr i >>= \v -> loop (fnv1a_64_Mix8 v acc) (i + 1) diff --git a/Data/Memory/Internal/CompatPrim64.hs b/Data/Memory/Internal/CompatPrim64.hs deleted file mode 100644 index b9eef8a..0000000 --- a/Data/Memory/Internal/CompatPrim64.hs +++ /dev/null @@ -1,169 +0,0 @@ --- | --- Module : Data.Memory.Internal.CompatPrim --- License : BSD-style --- Maintainer : Vincent Hanquez --- Stability : stable --- Portability : Compat --- --- This module try to keep all the difference between versions of ghc primitive --- or other needed packages, so that modules don't need to use CPP. --- --- Note that MagicHash and CPP conflicts in places, making it "more interesting" --- to write compat code for primitives --- -{-# LANGUAGE CPP #-} -{-# LANGUAGE BangPatterns #-} -{-# LANGUAGE MagicHash #-} -{-# LANGUAGE UnboxedTuples #-} -#include "MachDeps.h" -module Data.Memory.Internal.CompatPrim64 - ( Word64# - , Int64# - , eqInt64# - , neInt64# - , ltInt64# - , leInt64# - , gtInt64# - , geInt64# - , quotInt64# - , remInt64# - , eqWord64# - , neWord64# - , ltWord64# - , leWord64# - , gtWord64# - , geWord64# - , and64# - , or64# - , xor64# - , not64# - , timesWord64# - , uncheckedShiftL64# - , uncheckedShiftRL64# - - , int64ToWord64# - , word64ToInt64# - , intToInt64# - , int64ToInt# - , wordToWord64# - , word64ToWord# - , w64# - ) where - - -#if WORD_SIZE_IN_BITS == 64 -import GHC.Prim hiding (Word64#, Int64#) - -#if __GLASGOW_HASKELL__ >= 708 -type OutBool = Int# -#else -type OutBool = Bool -#endif - -type Word64# = Word# -type Int64# = Int# - -#if __GLASGOW_HASKELL__ < 904 -eqWord64# :: Word64# -> Word64# -> OutBool -eqWord64# = eqWord# - -neWord64# :: Word64# -> Word64# -> OutBool -neWord64# = neWord# - -ltWord64# :: Word64# -> Word64# -> OutBool -ltWord64# = ltWord# - -leWord64# :: Word64# -> Word64# -> OutBool -leWord64# = leWord# - -gtWord64# :: Word64# -> Word64# -> OutBool -gtWord64# = gtWord# - -geWord64# :: Word64# -> Word64# -> OutBool -geWord64# = geWord# - -eqInt64# :: Int64# -> Int64# -> OutBool -eqInt64# = (==#) - -neInt64# :: Int64# -> Int64# -> OutBool -neInt64# = (/=#) - -ltInt64# :: Int64# -> Int64# -> OutBool -ltInt64# = (<#) - -leInt64# :: Int64# -> Int64# -> OutBool -leInt64# = (<=#) - -gtInt64# :: Int64# -> Int64# -> OutBool -gtInt64# = (>#) - -geInt64# :: Int64# -> Int64# -> OutBool -geInt64# = (<=#) - -quotInt64# :: Int64# -> Int64# -> Int64# -quotInt64# = quotInt# - -remInt64# :: Int64# -> Int64# -> Int64# -remInt64# = remInt# - -and64# :: Word64# -> Word64# -> Word64# -and64# = and# - -or64# :: Word64# -> Word64# -> Word64# -or64# = or# - -xor64# :: Word64# -> Word64# -> Word64# -xor64# = xor# - -not64# :: Word64# -> Word64# -not64# = not# - -uncheckedShiftL64# :: Word64# -> Int# -> Word64# -uncheckedShiftL64# = uncheckedShiftL# - -uncheckedShiftRL64# :: Word64# -> Int# -> Word64# -uncheckedShiftRL64# = uncheckedShiftL# - -int64ToWord64# :: Int64# -> Word64# -int64ToWord64# = int2Word# - -word64ToInt64# :: Word64# -> Int64# -word64ToInt64# = word2Int# - -intToInt64# :: Int# -> Int64# -intToInt64# w = w - -int64ToInt# :: Int64# -> Int# -int64ToInt# w = w - -wordToWord64# :: Word# -> Word64# -wordToWord64# w = w - -word64ToWord# :: Word64# -> Word# -word64ToWord# w = w - -timesWord64# :: Word64# -> Word64# -> Word64# -timesWord64# = timesWord# -#endif - -w64# :: Word# -> Word# -> Word# -> Word64# -w64# w _ _ = w - -#elif WORD_SIZE_IN_BITS == 32 -import GHC.IntWord64 -import GHC.Prim (Word#) - -timesWord64# :: Word64# -> Word64# -> Word64# -timesWord64# a b = - let !ai = word64ToInt64# a - !bi = word64ToInt64# b - in int64ToWord64# (timesInt64# ai bi) - -w64# :: Word# -> Word# -> Word# -> Word64# -w64# _ hw lw = - let !h = wordToWord64# hw - !l = wordToWord64# lw - in or64# (uncheckedShiftL64# h 32#) l -#else -#error "not a supported architecture. supported WORD_SIZE_IN_BITS is 32 bits or 64 bits" -#endif diff --git a/ram.cabal b/ram.cabal index 9388d50..618383d 100644 --- a/ram.cabal +++ b/ram.cabal @@ -1,6 +1,6 @@ cabal-version: 3.0 name: ram -version: 0.20.1 +version: 0.21.0 synopsis: memory and related abstraction stuff description: This is a fork of memory. It's open to accept changes from anyone, @@ -20,6 +20,10 @@ description: * Hashing : FNV, SipHash + Legacy note: This package shouldn't be used for new software. + It only exists and is maintained to give other packages time to + rewrite their software to use better libraries. + license: BSD-3-Clause license-file: LICENSE copyright: Vincent Hanquez @@ -65,15 +69,18 @@ library Data.Memory.Hash.SipHash Data.Memory.Internal.Compat Data.Memory.Internal.CompatPrim - Data.Memory.Internal.CompatPrim64 Data.Memory.Internal.Imports exposed-modules: Data.ByteArray.Sized build-depends: , base <4.23 + , base16 >=1.0 && <2 + , base32 >=0.4 && <1 + , base64 >=1.0 && <2 , bytestring <0.13 , deepseq >=1.1 && <1.17 , ghc-prim <0.14 + , text >=1.0 && <3 -- FIXME armel or mispel is also little endian. -- might be a good idea to also add a runtime autodetect mode.