-{-# OPTIONS -fno-implicit-prelude #-}
+{-# OPTIONS_GHC -fno-implicit-prelude #-}
-----------------------------------------------------------------------------
-- |
-- Module : GHC.Word
#include "MachDeps.h"
+-- #hide
module GHC.Word (
Word(..), Word8(..), Word16(..), Word32(..), Word64(..),
toEnumError, fromEnumError, succError, predError)
instance Bounded Word where
minBound = 0
+
+ -- use unboxed literals for maxBound, because GHC doesn't optimise
+ -- (fromInteger 0xffffffff :: Word).
#if WORD_SIZE_IN_BITS == 31
- maxBound = 0x7FFFFFFF
+ maxBound = W# (int2Word# 0x7FFFFFFF#)
#elif WORD_SIZE_IN_BITS == 32
- maxBound = 0xFFFFFFFF
+ maxBound = W# (int2Word# 0xFFFFFFFF#)
#else
- maxBound = 0xFFFFFFFFFFFFFFFF
+ maxBound = W# (int2Word# 0xFFFFFFFFFFFFFFFF#)
#endif
instance Ix Word where
range (m,n) = [m..n]
unsafeIndex b@(m,_) i = fromIntegral (i - m)
inRange (m,n) i = m <= i && i <= n
- unsafeRangeSize b@(_l,h) = unsafeIndex b h + 1
instance Read Word where
readsPrec p s = [(fromInteger x, r) | (x, r) <- readsPrec p s]
instance Bits Word where
+ {-# INLINE shift #-}
+
(W# x#) .&. (W# y#) = W# (x# `and#` y#)
(W# x#) .|. (W# y#) = W# (x# `or#` y#)
(W# x#) `xor` (W# y#) = W# (x# `xor#` y#)
| otherwise = W# (x# `shiftRL#` negateInt# i#)
(W# x#) `rotate` (I# i#)
| i'# ==# 0# = W# x#
- | otherwise = W# ((x# `shiftL#` i'#) `or#` (x# `shiftRL#` (wsib -# i'#)))
+ | otherwise = W# ((x# `uncheckedShiftL#` i'#) `or#` (x# `uncheckedShiftRL#` (wsib -# i'#)))
where
i'# = word2Int# (int2Word# i# `and#` int2Word# (wsib -# 1#))
wsib = WORD_SIZE_IN_BITS# {- work around preprocessor problem (??) -}
range (m,n) = [m..n]
unsafeIndex b@(m,_) i = fromIntegral (i - m)
inRange (m,n) i = m <= i && i <= n
- unsafeRangeSize b@(_l,h) = unsafeIndex b h + 1
instance Read Word8 where
readsPrec p s = [(fromIntegral (x::Int), r) | (x, r) <- readsPrec p s]
instance Bits Word8 where
+ {-# INLINE shift #-}
+
(W8# x#) .&. (W8# y#) = W8# (x# `and#` y#)
(W8# x#) .|. (W8# y#) = W8# (x# `or#` y#)
(W8# x#) `xor` (W8# y#) = W8# (x# `xor#` y#)
| otherwise = W8# (x# `shiftRL#` negateInt# i#)
(W8# x#) `rotate` (I# i#)
| i'# ==# 0# = W8# x#
- | otherwise = W8# (narrow8Word# ((x# `shiftL#` i'#) `or#`
- (x# `shiftRL#` (8# -# i'#))))
+ | otherwise = W8# (narrow8Word# ((x# `uncheckedShiftL#` i'#) `or#`
+ (x# `uncheckedShiftRL#` (8# -# i'#))))
where
i'# = word2Int# (int2Word# i# `and#` int2Word# 7#)
bitSize _ = 8
range (m,n) = [m..n]
unsafeIndex b@(m,_) i = fromIntegral (i - m)
inRange (m,n) i = m <= i && i <= n
- unsafeRangeSize b@(_l,h) = unsafeIndex b h + 1
instance Read Word16 where
readsPrec p s = [(fromIntegral (x::Int), r) | (x, r) <- readsPrec p s]
instance Bits Word16 where
+ {-# INLINE shift #-}
+
(W16# x#) .&. (W16# y#) = W16# (x# `and#` y#)
(W16# x#) .|. (W16# y#) = W16# (x# `or#` y#)
(W16# x#) `xor` (W16# y#) = W16# (x# `xor#` y#)
| otherwise = W16# (x# `shiftRL#` negateInt# i#)
(W16# x#) `rotate` (I# i#)
| i'# ==# 0# = W16# x#
- | otherwise = W16# (narrow16Word# ((x# `shiftL#` i'#) `or#`
- (x# `shiftRL#` (16# -# i'#))))
+ | otherwise = W16# (narrow16Word# ((x# `uncheckedShiftL#` i'#) `or#`
+ (x# `uncheckedShiftRL#` (16# -# i'#))))
where
i'# = word2Int# (int2Word# i# `and#` int2Word# 15#)
bitSize _ = 16
| otherwise = case word32ToInteger# x# of (# s, d #) -> J# s d
instance Bits Word32 where
+ {-# INLINE shift #-}
+
(W32# x#) .&. (W32# y#) = W32# (x# `and32#` y#)
(W32# x#) .|. (W32# y#) = W32# (x# `or32#` y#)
(W32# x#) `xor` (W32# y#) = W32# (x# `xor32#` y#)
#endif
instance Bits Word32 where
+ {-# INLINE shift #-}
+
(W32# x#) .&. (W32# y#) = W32# (x# `and#` y#)
(W32# x#) .|. (W32# y#) = W32# (x# `or#` y#)
(W32# x#) `xor` (W32# y#) = W32# (x# `xor#` y#)
| otherwise = W32# (x# `shiftRL#` negateInt# i#)
(W32# x#) `rotate` (I# i#)
| i'# ==# 0# = W32# x#
- | otherwise = W32# (narrow32Word# ((x# `shiftL#` i'#) `or#`
- (x# `shiftRL#` (32# -# i'#))))
+ | otherwise = W32# (narrow32Word# ((x# `uncheckedShiftL#` i'#) `or#`
+ (x# `uncheckedShiftRL#` (32# -# i'#))))
where
i'# = word2Int# (int2Word# i# `and#` int2Word# 31#)
bitSize _ = 32
range (m,n) = [m..n]
unsafeIndex b@(m,_) i = fromIntegral (i - m)
inRange (m,n) i = m <= i && i <= n
- unsafeRangeSize b@(_l,h) = unsafeIndex b h + 1
instance Read Word32 where
#if WORD_SIZE_IN_BITS < 33
| otherwise = case word64ToInteger# x# of (# s, d #) -> J# s d
instance Bits Word64 where
+ {-# INLINE shift #-}
+
(W64# x#) .&. (W64# y#) = W64# (x# `and64#` y#)
(W64# x#) .|. (W64# y#) = W64# (x# `or64#` y#)
(W64# x#) `xor` (W64# y#) = W64# (x# `xor64#` y#)
i# = word2Int# x#
instance Bits Word64 where
+ {-# INLINE shift #-}
+
(W64# x#) .&. (W64# y#) = W64# (x# `and#` y#)
(W64# x#) .|. (W64# y#) = W64# (x# `or#` y#)
(W64# x#) `xor` (W64# y#) = W64# (x# `xor#` y#)
| otherwise = W64# (x# `shiftRL#` negateInt# i#)
(W64# x#) `rotate` (I# i#)
| i'# ==# 0# = W64# x#
- | otherwise = W64# ((x# `shiftL#` i'#) `or#`
- (x# `shiftRL#` (64# -# i'#)))
+ | otherwise = W64# ((x# `uncheckedShiftL#` i'#) `or#`
+ (x# `uncheckedShiftRL#` (64# -# i'#)))
where
i'# = word2Int# (int2Word# i# `and#` int2Word# 63#)
bitSize _ = 64
range (m,n) = [m..n]
unsafeIndex b@(m,_) i = fromIntegral (i - m)
inRange (m,n) i = m <= i && i <= n
- unsafeRangeSize b@(_l,h) = unsafeIndex b h + 1
instance Read Word64 where
readsPrec p s = [(fromInteger x, r) | (x, r) <- readsPrec p s]