projects
/
haskell-directory.git
/ blobdiff
commit
grep
author
committer
pickaxe
?
search:
re
summary
|
shortlog
|
log
|
commit
|
commitdiff
|
tree
raw
|
inline
| side by side
put 'unsafeCoerce' in a standard location
[haskell-directory.git]
/
GHC
/
Word.hs
diff --git
a/GHC/Word.hs
b/GHC/Word.hs
index
1850161
..
694a9df
100644
(file)
--- a/
GHC/Word.hs
+++ b/
GHC/Word.hs
@@
-1,4
+1,4
@@
-{-# OPTIONS -fno-implicit-prelude #-}
+{-# OPTIONS_GHC -fno-implicit-prelude #-}
-----------------------------------------------------------------------------
-- |
-- Module : GHC.Word
-----------------------------------------------------------------------------
-- |
-- Module : GHC.Word
@@
-16,13
+16,15
@@
#include "MachDeps.h"
#include "MachDeps.h"
+-- #hide
module GHC.Word (
Word(..), Word8(..), Word16(..), Word32(..), Word64(..),
module GHC.Word (
Word(..), Word8(..), Word16(..), Word32(..), Word64(..),
- divZeroError, toEnumError, fromEnumError, succError, predError)
+ toEnumError, fromEnumError, succError, predError)
where
import Data.Bits
where
import Data.Bits
+import {-# SOURCE #-} GHC.Err
import GHC.Base
import GHC.Enum
import GHC.Num
import GHC.Base
import GHC.Enum
import GHC.Num
@@
-35,11
+37,6
@@
import GHC.Show
-- Helper functions
------------------------------------------------------------------------
-- Helper functions
------------------------------------------------------------------------
-{-# NOINLINE divZeroError #-}
-divZeroError :: (Show a) => String -> a -> b
-divZeroError meth x =
- error $ "Integral." ++ meth ++ ": divide by 0 (" ++ show x ++ " / 0)"
-
{-# NOINLINE toEnumError #-}
toEnumError :: (Show a) => String -> Int -> (a,a) -> b
toEnumError inst_ty i bnds =
{-# NOINLINE toEnumError #-}
toEnumError :: (Show a) => String -> Int -> (a,a) -> b
toEnumError inst_ty i bnds =
@@
-70,13
+67,9
@@
predError inst_ty =
-- type Word
------------------------------------------------------------------------
-- type Word
------------------------------------------------------------------------
--- A Word is an unsigned integral type, with the same size as Int.
-
+-- |A 'Word' is an unsigned integral type, with the same size as 'Int'.
data Word = W# Word# deriving (Eq, Ord)
data Word = W# Word# deriving (Eq, Ord)
-instance CCallable Word
-instance CReturnable Word
-
instance Show Word where
showsPrec p x = showsPrec p (toInteger x)
instance Show Word where
showsPrec p x = showsPrec p (toInteger x)
@@
-116,22
+109,22
@@
instance Enum Word where
instance Integral Word where
quot x@(W# x#) y@(W# y#)
| y /= 0 = W# (x# `quotWord#` y#)
instance Integral Word where
quot x@(W# x#) y@(W# y#)
| y /= 0 = W# (x# `quotWord#` y#)
- | otherwise = divZeroError "quot{Word}" x
+ | otherwise = divZeroError
rem x@(W# x#) y@(W# y#)
| y /= 0 = W# (x# `remWord#` y#)
rem x@(W# x#) y@(W# y#)
| y /= 0 = W# (x# `remWord#` y#)
- | otherwise = divZeroError "rem{Word}" x
+ | otherwise = divZeroError
div x@(W# x#) y@(W# y#)
| y /= 0 = W# (x# `quotWord#` y#)
div x@(W# x#) y@(W# y#)
| y /= 0 = W# (x# `quotWord#` y#)
- | otherwise = divZeroError "div{Word}" x
+ | otherwise = divZeroError
mod x@(W# x#) y@(W# y#)
| y /= 0 = W# (x# `remWord#` y#)
mod x@(W# x#) y@(W# y#)
| y /= 0 = W# (x# `remWord#` y#)
- | otherwise = divZeroError "mod{Word}" x
+ | otherwise = divZeroError
quotRem x@(W# x#) y@(W# y#)
| y /= 0 = (W# (x# `quotWord#` y#), W# (x# `remWord#` y#))
quotRem x@(W# x#) y@(W# y#)
| y /= 0 = (W# (x# `quotWord#` y#), W# (x# `remWord#` y#))
- | otherwise = divZeroError "quotRem{Word}" x
+ | otherwise = divZeroError
divMod x@(W# x#) y@(W# y#)
| y /= 0 = (W# (x# `quotWord#` y#), W# (x# `remWord#` y#))
divMod x@(W# x#) y@(W# y#)
| y /= 0 = (W# (x# `quotWord#` y#), W# (x# `remWord#` y#))
- | otherwise = divZeroError "divMod{Word}" x
+ | otherwise = divZeroError
toInteger (W# x#)
| i# >=# 0# = S# i#
| otherwise = case word2Integer# x# of (# s, d #) -> J# s d
toInteger (W# x#)
| i# >=# 0# = S# i#
| otherwise = case word2Integer# x# of (# s, d #) -> J# s d
@@
-140,24
+133,28
@@
instance Integral Word where
instance Bounded Word where
minBound = 0
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
#if WORD_SIZE_IN_BITS == 31
- maxBound = 0x7FFFFFFF
+ maxBound = W# (int2Word# 0x7FFFFFFF#)
#elif WORD_SIZE_IN_BITS == 32
#elif WORD_SIZE_IN_BITS == 32
- maxBound = 0xFFFFFFFF
+ maxBound = W# (int2Word# 0xFFFFFFFF#)
#else
#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
#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
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#)
(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#)
@@
-167,7
+164,7
@@
instance Bits Word where
| otherwise = W# (x# `shiftRL#` negateInt# i#)
(W# x#) `rotate` (I# i#)
| i'# ==# 0# = W# x#
| 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 (??) -}
where
i'# = word2Int# (int2Word# i# `and#` int2Word# (wsib -# 1#))
wsib = WORD_SIZE_IN_BITS# {- work around preprocessor problem (??) -}
@@
-188,9
+185,7
@@
instance Bits Word where
-- and must ensure that it holds only values from its logical range.
data Word8 = W8# Word# deriving (Eq, Ord)
-- and must ensure that it holds only values from its logical range.
data Word8 = W8# Word# deriving (Eq, Ord)
-
-instance CCallable Word8
-instance CReturnable Word8
+-- ^ 8-bit unsigned integer type
instance Show Word8 where
showsPrec p x = showsPrec p (fromIntegral x :: Int)
instance Show Word8 where
showsPrec p x = showsPrec p (fromIntegral x :: Int)
@@
-227,22
+222,22
@@
instance Enum Word8 where
instance Integral Word8 where
quot x@(W8# x#) y@(W8# y#)
| y /= 0 = W8# (x# `quotWord#` y#)
instance Integral Word8 where
quot x@(W8# x#) y@(W8# y#)
| y /= 0 = W8# (x# `quotWord#` y#)
- | otherwise = divZeroError "quot{Word8}" x
+ | otherwise = divZeroError
rem x@(W8# x#) y@(W8# y#)
| y /= 0 = W8# (x# `remWord#` y#)
rem x@(W8# x#) y@(W8# y#)
| y /= 0 = W8# (x# `remWord#` y#)
- | otherwise = divZeroError "rem{Word8}" x
+ | otherwise = divZeroError
div x@(W8# x#) y@(W8# y#)
| y /= 0 = W8# (x# `quotWord#` y#)
div x@(W8# x#) y@(W8# y#)
| y /= 0 = W8# (x# `quotWord#` y#)
- | otherwise = divZeroError "div{Word8}" x
+ | otherwise = divZeroError
mod x@(W8# x#) y@(W8# y#)
| y /= 0 = W8# (x# `remWord#` y#)
mod x@(W8# x#) y@(W8# y#)
| y /= 0 = W8# (x# `remWord#` y#)
- | otherwise = divZeroError "mod{Word8}" x
+ | otherwise = divZeroError
quotRem x@(W8# x#) y@(W8# y#)
| y /= 0 = (W8# (x# `quotWord#` y#), W8# (x# `remWord#` y#))
quotRem x@(W8# x#) y@(W8# y#)
| y /= 0 = (W8# (x# `quotWord#` y#), W8# (x# `remWord#` y#))
- | otherwise = divZeroError "quotRem{Word8}" x
+ | otherwise = divZeroError
divMod x@(W8# x#) y@(W8# y#)
| y /= 0 = (W8# (x# `quotWord#` y#), W8# (x# `remWord#` y#))
divMod x@(W8# x#) y@(W8# y#)
| y /= 0 = (W8# (x# `quotWord#` y#), W8# (x# `remWord#` y#))
- | otherwise = divZeroError "quotRem{Word8}" x
+ | otherwise = divZeroError
toInteger (W8# x#) = S# (word2Int# x#)
instance Bounded Word8 where
toInteger (W8# x#) = S# (word2Int# x#)
instance Bounded Word8 where
@@
-253,12
+248,13
@@
instance Ix Word8 where
range (m,n) = [m..n]
unsafeIndex b@(m,_) i = fromIntegral (i - m)
inRange (m,n) i = m <= i && i <= n
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
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#)
(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#)
@@
-268,8
+264,8
@@
instance Bits Word8 where
| otherwise = W8# (x# `shiftRL#` negateInt# i#)
(W8# x#) `rotate` (I# i#)
| i'# ==# 0# = W8# x#
| 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
where
i'# = word2Int# (int2Word# i# `and#` int2Word# 7#)
bitSize _ = 8
@@
-290,9
+286,7
@@
instance Bits Word8 where
-- and must ensure that it holds only values from its logical range.
data Word16 = W16# Word# deriving (Eq, Ord)
-- and must ensure that it holds only values from its logical range.
data Word16 = W16# Word# deriving (Eq, Ord)
-
-instance CCallable Word16
-instance CReturnable Word16
+-- ^ 16-bit unsigned integer type
instance Show Word16 where
showsPrec p x = showsPrec p (fromIntegral x :: Int)
instance Show Word16 where
showsPrec p x = showsPrec p (fromIntegral x :: Int)
@@
-329,22
+323,22
@@
instance Enum Word16 where
instance Integral Word16 where
quot x@(W16# x#) y@(W16# y#)
| y /= 0 = W16# (x# `quotWord#` y#)
instance Integral Word16 where
quot x@(W16# x#) y@(W16# y#)
| y /= 0 = W16# (x# `quotWord#` y#)
- | otherwise = divZeroError "quot{Word16}" x
+ | otherwise = divZeroError
rem x@(W16# x#) y@(W16# y#)
| y /= 0 = W16# (x# `remWord#` y#)
rem x@(W16# x#) y@(W16# y#)
| y /= 0 = W16# (x# `remWord#` y#)
- | otherwise = divZeroError "rem{Word16}" x
+ | otherwise = divZeroError
div x@(W16# x#) y@(W16# y#)
| y /= 0 = W16# (x# `quotWord#` y#)
div x@(W16# x#) y@(W16# y#)
| y /= 0 = W16# (x# `quotWord#` y#)
- | otherwise = divZeroError "div{Word16}" x
+ | otherwise = divZeroError
mod x@(W16# x#) y@(W16# y#)
| y /= 0 = W16# (x# `remWord#` y#)
mod x@(W16# x#) y@(W16# y#)
| y /= 0 = W16# (x# `remWord#` y#)
- | otherwise = divZeroError "mod{Word16}" x
+ | otherwise = divZeroError
quotRem x@(W16# x#) y@(W16# y#)
| y /= 0 = (W16# (x# `quotWord#` y#), W16# (x# `remWord#` y#))
quotRem x@(W16# x#) y@(W16# y#)
| y /= 0 = (W16# (x# `quotWord#` y#), W16# (x# `remWord#` y#))
- | otherwise = divZeroError "quotRem{Word16}" x
+ | otherwise = divZeroError
divMod x@(W16# x#) y@(W16# y#)
| y /= 0 = (W16# (x# `quotWord#` y#), W16# (x# `remWord#` y#))
divMod x@(W16# x#) y@(W16# y#)
| y /= 0 = (W16# (x# `quotWord#` y#), W16# (x# `remWord#` y#))
- | otherwise = divZeroError "quotRem{Word16}" x
+ | otherwise = divZeroError
toInteger (W16# x#) = S# (word2Int# x#)
instance Bounded Word16 where
toInteger (W16# x#) = S# (word2Int# x#)
instance Bounded Word16 where
@@
-355,12
+349,13
@@
instance Ix Word16 where
range (m,n) = [m..n]
unsafeIndex b@(m,_) i = fromIntegral (i - m)
inRange (m,n) i = m <= i && i <= n
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
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#)
(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#)
@@
-370,8
+365,8
@@
instance Bits Word16 where
| otherwise = W16# (x# `shiftRL#` negateInt# i#)
(W16# x#) `rotate` (I# i#)
| i'# ==# 0# = W16# x#
| 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
where
i'# = word2Int# (int2Word# i# `and#` int2Word# 15#)
bitSize _ = 16
@@
-392,6
+387,7
@@
instance Bits Word16 where
#if WORD_SIZE_IN_BITS < 32
data Word32 = W32# Word32#
#if WORD_SIZE_IN_BITS < 32
data Word32 = W32# Word32#
+-- ^ 32-bit unsigned integer type
instance Eq Word32 where
(W32# x#) == (W32# y#) = x# `eqWord32#` y#
instance Eq Word32 where
(W32# x#) == (W32# y#) = x# `eqWord32#` y#
@@
-436,27
+432,29
@@
instance Enum Word32 where
instance Integral Word32 where
quot x@(W32# x#) y@(W32# y#)
| y /= 0 = W32# (x# `quotWord32#` y#)
instance Integral Word32 where
quot x@(W32# x#) y@(W32# y#)
| y /= 0 = W32# (x# `quotWord32#` y#)
- | otherwise = divZeroError "quot{Word32}" x
+ | otherwise = divZeroError
rem x@(W32# x#) y@(W32# y#)
| y /= 0 = W32# (x# `remWord32#` y#)
rem x@(W32# x#) y@(W32# y#)
| y /= 0 = W32# (x# `remWord32#` y#)
- | otherwise = divZeroError "rem{Word32}" x
+ | otherwise = divZeroError
div x@(W32# x#) y@(W32# y#)
| y /= 0 = W32# (x# `quotWord32#` y#)
div x@(W32# x#) y@(W32# y#)
| y /= 0 = W32# (x# `quotWord32#` y#)
- | otherwise = divZeroError "div{Word32}" x
+ | otherwise = divZeroError
mod x@(W32# x#) y@(W32# y#)
| y /= 0 = W32# (x# `remWord32#` y#)
mod x@(W32# x#) y@(W32# y#)
| y /= 0 = W32# (x# `remWord32#` y#)
- | otherwise = divZeroError "mod{Word32}" x
+ | otherwise = divZeroError
quotRem x@(W32# x#) y@(W32# y#)
| y /= 0 = (W32# (x# `quotWord32#` y#), W32# (x# `remWord32#` y#))
quotRem x@(W32# x#) y@(W32# y#)
| y /= 0 = (W32# (x# `quotWord32#` y#), W32# (x# `remWord32#` y#))
- | otherwise = divZeroError "quotRem{Word32}" x
+ | otherwise = divZeroError
divMod x@(W32# x#) y@(W32# y#)
| y /= 0 = (W32# (x# `quotWord32#` y#), W32# (x# `remWord32#` y#))
divMod x@(W32# x#) y@(W32# y#)
| y /= 0 = (W32# (x# `quotWord32#` y#), W32# (x# `remWord32#` y#))
- | otherwise = divZeroError "quotRem{Word32}" x
+ | otherwise = divZeroError
toInteger x@(W32# x#)
| x <= fromIntegral (maxBound::Int) = S# (word2Int# (word32ToWord# x#))
| otherwise = case word32ToInteger# x# of (# s, d #) -> J# s d
instance Bits Word32 where
toInteger x@(W32# x#)
| x <= fromIntegral (maxBound::Int) = S# (word2Int# (word32ToWord# x#))
| 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#)
(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#)
@@
-514,6
+512,7
@@
foreign import unsafe "stg_shiftRL32" shiftRL32# :: Word32# -> Int# -> W
#endif
data Word32 = W32# Word# deriving (Eq, Ord)
#endif
data Word32 = W32# Word# deriving (Eq, Ord)
+-- ^ 32-bit unsigned integer type
instance Num Word32 where
(W32# x#) + (W32# y#) = W32# (narrow32Word# (x# `plusWord#` y#))
instance Num Word32 where
(W32# x#) + (W32# y#) = W32# (narrow32Word# (x# `plusWord#` y#))
@@
-558,22
+557,22
@@
instance Enum Word32 where
instance Integral Word32 where
quot x@(W32# x#) y@(W32# y#)
| y /= 0 = W32# (x# `quotWord#` y#)
instance Integral Word32 where
quot x@(W32# x#) y@(W32# y#)
| y /= 0 = W32# (x# `quotWord#` y#)
- | otherwise = divZeroError "quot{Word32}" x
+ | otherwise = divZeroError
rem x@(W32# x#) y@(W32# y#)
| y /= 0 = W32# (x# `remWord#` y#)
rem x@(W32# x#) y@(W32# y#)
| y /= 0 = W32# (x# `remWord#` y#)
- | otherwise = divZeroError "rem{Word32}" x
+ | otherwise = divZeroError
div x@(W32# x#) y@(W32# y#)
| y /= 0 = W32# (x# `quotWord#` y#)
div x@(W32# x#) y@(W32# y#)
| y /= 0 = W32# (x# `quotWord#` y#)
- | otherwise = divZeroError "div{Word32}" x
+ | otherwise = divZeroError
mod x@(W32# x#) y@(W32# y#)
| y /= 0 = W32# (x# `remWord#` y#)
mod x@(W32# x#) y@(W32# y#)
| y /= 0 = W32# (x# `remWord#` y#)
- | otherwise = divZeroError "mod{Word32}" x
+ | otherwise = divZeroError
quotRem x@(W32# x#) y@(W32# y#)
| y /= 0 = (W32# (x# `quotWord#` y#), W32# (x# `remWord#` y#))
quotRem x@(W32# x#) y@(W32# y#)
| y /= 0 = (W32# (x# `quotWord#` y#), W32# (x# `remWord#` y#))
- | otherwise = divZeroError "quotRem{Word32}" x
+ | otherwise = divZeroError
divMod x@(W32# x#) y@(W32# y#)
| y /= 0 = (W32# (x# `quotWord#` y#), W32# (x# `remWord#` y#))
divMod x@(W32# x#) y@(W32# y#)
| y /= 0 = (W32# (x# `quotWord#` y#), W32# (x# `remWord#` y#))
- | otherwise = divZeroError "quotRem{Word32}" x
+ | otherwise = divZeroError
toInteger (W32# x#)
#if WORD_SIZE_IN_BITS == 32
| i# >=# 0# = S# i#
toInteger (W32# x#)
#if WORD_SIZE_IN_BITS == 32
| i# >=# 0# = S# i#
@@
-585,6
+584,8
@@
instance Integral Word32 where
#endif
instance Bits Word32 where
#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#)
(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#)
@@
-594,8
+595,8
@@
instance Bits Word32 where
| otherwise = W32# (x# `shiftRL#` negateInt# i#)
(W32# x#) `rotate` (I# i#)
| i'# ==# 0# = W32# x#
| 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
where
i'# = word2Int# (int2Word# i# `and#` int2Word# 31#)
bitSize _ = 32
@@
-612,9
+613,6
@@
instance Bits Word32 where
#endif
#endif
-instance CCallable Word32
-instance CReturnable Word32
-
instance Show Word32 where
#if WORD_SIZE_IN_BITS < 33
showsPrec p x = showsPrec p (toInteger x)
instance Show Word32 where
#if WORD_SIZE_IN_BITS < 33
showsPrec p x = showsPrec p (toInteger x)
@@
-634,7
+632,6
@@
instance Ix Word32 where
range (m,n) = [m..n]
unsafeIndex b@(m,_) i = fromIntegral (i - m)
inRange (m,n) i = m <= i && i <= n
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
instance Read Word32 where
#if WORD_SIZE_IN_BITS < 33
@@
-650,6
+647,7
@@
instance Read Word32 where
#if WORD_SIZE_IN_BITS < 64
data Word64 = W64# Word64#
#if WORD_SIZE_IN_BITS < 64
data Word64 = W64# Word64#
+-- ^ 64-bit unsigned integer type
instance Eq Word64 where
(W64# x#) == (W64# y#) = x# `eqWord64#` y#
instance Eq Word64 where
(W64# x#) == (W64# y#) = x# `eqWord64#` y#
@@
-694,27
+692,29
@@
instance Enum Word64 where
instance Integral Word64 where
quot x@(W64# x#) y@(W64# y#)
| y /= 0 = W64# (x# `quotWord64#` y#)
instance Integral Word64 where
quot x@(W64# x#) y@(W64# y#)
| y /= 0 = W64# (x# `quotWord64#` y#)
- | otherwise = divZeroError "quot{Word64}" x
+ | otherwise = divZeroError
rem x@(W64# x#) y@(W64# y#)
| y /= 0 = W64# (x# `remWord64#` y#)
rem x@(W64# x#) y@(W64# y#)
| y /= 0 = W64# (x# `remWord64#` y#)
- | otherwise = divZeroError "rem{Word64}" x
+ | otherwise = divZeroError
div x@(W64# x#) y@(W64# y#)
| y /= 0 = W64# (x# `quotWord64#` y#)
div x@(W64# x#) y@(W64# y#)
| y /= 0 = W64# (x# `quotWord64#` y#)
- | otherwise = divZeroError "div{Word64}" x
+ | otherwise = divZeroError
mod x@(W64# x#) y@(W64# y#)
| y /= 0 = W64# (x# `remWord64#` y#)
mod x@(W64# x#) y@(W64# y#)
| y /= 0 = W64# (x# `remWord64#` y#)
- | otherwise = divZeroError "mod{Word64}" x
+ | otherwise = divZeroError
quotRem x@(W64# x#) y@(W64# y#)
| y /= 0 = (W64# (x# `quotWord64#` y#), W64# (x# `remWord64#` y#))
quotRem x@(W64# x#) y@(W64# y#)
| y /= 0 = (W64# (x# `quotWord64#` y#), W64# (x# `remWord64#` y#))
- | otherwise = divZeroError "quotRem{Word64}" x
+ | otherwise = divZeroError
divMod x@(W64# x#) y@(W64# y#)
| y /= 0 = (W64# (x# `quotWord64#` y#), W64# (x# `remWord64#` y#))
divMod x@(W64# x#) y@(W64# y#)
| y /= 0 = (W64# (x# `quotWord64#` y#), W64# (x# `remWord64#` y#))
- | otherwise = divZeroError "quotRem{Word64}" x
+ | otherwise = divZeroError
toInteger x@(W64# x#)
| x <= 0x7FFFFFFF = S# (word2Int# (word64ToWord# x#))
| otherwise = case word64ToInteger# x# of (# s, d #) -> J# s d
instance Bits Word64 where
toInteger x@(W64# x#)
| x <= 0x7FFFFFFF = S# (word2Int# (word64ToWord# x#))
| 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#)
(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#)
@@
-787,6
+787,7
@@
foreign import ccall unsafe "stg_integerToWord64" integerToWord64# :: Int# -> By
-- from its logical range.
data Word64 = W64# Word# deriving (Eq, Ord)
-- from its logical range.
data Word64 = W64# Word# deriving (Eq, Ord)
+-- ^ 64-bit unsigned integer type
instance Num Word64 where
(W64# x#) + (W64# y#) = W64# (x# `plusWord#` y#)
instance Num Word64 where
(W64# x#) + (W64# y#) = W64# (x# `plusWord#` y#)
@@
-821,22
+822,22
@@
instance Enum Word64 where
instance Integral Word64 where
quot x@(W64# x#) y@(W64# y#)
| y /= 0 = W64# (x# `quotWord#` y#)
instance Integral Word64 where
quot x@(W64# x#) y@(W64# y#)
| y /= 0 = W64# (x# `quotWord#` y#)
- | otherwise = divZeroError "quot{Word64}" x
+ | otherwise = divZeroError
rem x@(W64# x#) y@(W64# y#)
| y /= 0 = W64# (x# `remWord#` y#)
rem x@(W64# x#) y@(W64# y#)
| y /= 0 = W64# (x# `remWord#` y#)
- | otherwise = divZeroError "rem{Word64}" x
+ | otherwise = divZeroError
div x@(W64# x#) y@(W64# y#)
| y /= 0 = W64# (x# `quotWord#` y#)
div x@(W64# x#) y@(W64# y#)
| y /= 0 = W64# (x# `quotWord#` y#)
- | otherwise = divZeroError "div{Word64}" x
+ | otherwise = divZeroError
mod x@(W64# x#) y@(W64# y#)
| y /= 0 = W64# (x# `remWord#` y#)
mod x@(W64# x#) y@(W64# y#)
| y /= 0 = W64# (x# `remWord#` y#)
- | otherwise = divZeroError "mod{Word64}" x
+ | otherwise = divZeroError
quotRem x@(W64# x#) y@(W64# y#)
| y /= 0 = (W64# (x# `quotWord#` y#), W64# (x# `remWord#` y#))
quotRem x@(W64# x#) y@(W64# y#)
| y /= 0 = (W64# (x# `quotWord#` y#), W64# (x# `remWord#` y#))
- | otherwise = divZeroError "quotRem{Word64}" x
+ | otherwise = divZeroError
divMod x@(W64# x#) y@(W64# y#)
| y /= 0 = (W64# (x# `quotWord#` y#), W64# (x# `remWord#` y#))
divMod x@(W64# x#) y@(W64# y#)
| y /= 0 = (W64# (x# `quotWord#` y#), W64# (x# `remWord#` y#))
- | otherwise = divZeroError "quotRem{Word64}" x
+ | otherwise = divZeroError
toInteger (W64# x#)
| i# >=# 0# = S# i#
| otherwise = case word2Integer# x# of (# s, d #) -> J# s d
toInteger (W64# x#)
| i# >=# 0# = S# i#
| otherwise = case word2Integer# x# of (# s, d #) -> J# s d
@@
-844,6
+845,8
@@
instance Integral Word64 where
i# = word2Int# x#
instance Bits Word64 where
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#)
(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#)
@@
-853,8
+856,8
@@
instance Bits Word64 where
| otherwise = W64# (x# `shiftRL#` negateInt# i#)
(W64# x#) `rotate` (I# i#)
| i'# ==# 0# = W64# x#
| 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
where
i'# = word2Int# (int2Word# i# `and#` int2Word# 63#)
bitSize _ = 64
@@
-867,9
+870,6
@@
instance Bits Word64 where
#endif
#endif
-instance CCallable Word64
-instance CReturnable Word64
-
instance Show Word64 where
showsPrec p x = showsPrec p (toInteger x)
instance Show Word64 where
showsPrec p x = showsPrec p (toInteger x)
@@
-884,7
+884,6
@@
instance Ix Word64 where
range (m,n) = [m..n]
unsafeIndex b@(m,_) i = fromIntegral (i - m)
inRange (m,n) i = m <= i && i <= n
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]
instance Read Word64 where
readsPrec p s = [(fromInteger x, r) | (x, r) <- readsPrec p s]