GHC/Int.hs

   1 {-# OPTIONS -fno-implicit-prelude #-}
   2 -----------------------------------------------------------------------------
   3 -- |
   4 -- Module      :  GHC.Int
   5 -- Copyright   :  (c) The University of Glasgow 1997-2002
   6 -- License     :  see libraries/base/LICENSE
   7 --
   8 -- Maintainer  :  cvs-ghc@haskell.org
   9 -- Stability   :  internal
  10 -- Portability :  non-portable (GHC Extensions)
  11 --
  12 -- The sized integral datatypes, 'Int8', 'Int16', 'Int32', and 'Int64'.
  13 --
  14 -----------------------------------------------------------------------------
  15
  16 #include "MachDeps.h"
  17
  18 module GHC.Int (
  19     Int8(..), Int16(..), Int32(..), Int64(..))
  20     where
  21
  22 import Data.Bits
  23
  24 import GHC.Base
  25 import GHC.Enum
  26 import GHC.Num
  27 import GHC.Real
  28 import GHC.Read
  29 import GHC.Arr
  30 import GHC.Word
  31 import GHC.Show
  32
  33 ------------------------------------------------------------------------
  34 -- type Int8
  35 ------------------------------------------------------------------------
  36
  37 -- Int8 is represented in the same way as Int. Operations may assume
  38 -- and must ensure that it holds only values from its logical range.
  39
  40 data Int8 = I8# Int# deriving (Eq, Ord)
  41
  42 instance CCallable Int8
  43 instance CReturnable Int8
  44
  45 instance Show Int8 where
  46     showsPrec p x = showsPrec p (fromIntegral x :: Int)
  47
  48 instance Num Int8 where
  49     (I8# x#) + (I8# y#)    = I8# (narrow8Int# (x# +# y#))
  50     (I8# x#) - (I8# y#)    = I8# (narrow8Int# (x# -# y#))
  51     (I8# x#) * (I8# y#)    = I8# (narrow8Int# (x# *# y#))
  52     negate (I8# x#)        = I8# (narrow8Int# (negateInt# x#))
  53     abs x | x >= 0         = x
  54           | otherwise      = negate x
  55     signum x | x > 0       = 1
  56     signum 0               = 0
  57     signum _               = -1
  58     fromInteger (S# i#)    = I8# (narrow8Int# i#)
  59     fromInteger (J# s# d#) = I8# (narrow8Int# (integer2Int# s# d#))
  60
  61 instance Real Int8 where
  62     toRational x = toInteger x % 1
  63
  64 instance Enum Int8 where
  65     succ x
  66         | x /= maxBound = x + 1
  67         | otherwise     = succError "Int8"
  68     pred x
  69         | x /= minBound = x - 1
  70         | otherwise     = predError "Int8"
  71     toEnum i@(I# i#)
  72         | i >= fromIntegral (minBound::Int8) && i <= fromIntegral (maxBound::Int8)
  73                         = I8# i#
  74         | otherwise     = toEnumError "Int8" i (minBound::Int8, maxBound::Int8)
  75     fromEnum (I8# x#)   = I# x#
  76     enumFrom            = boundedEnumFrom
  77     enumFromThen        = boundedEnumFromThen
  78
  79 instance Integral Int8 where
  80     quot    x@(I8# x#) y@(I8# y#)
  81         | y /= 0                  = I8# (narrow8Int# (x# `quotInt#` y#))
  82         | otherwise               = divZeroError "quot{Int8}" x
  83     rem     x@(I8# x#) y@(I8# y#)
  84         | y /= 0                  = I8# (narrow8Int# (x# `remInt#` y#))
  85         | otherwise               = divZeroError "rem{Int8}" x
  86     div     x@(I8# x#) y@(I8# y#)
  87         | y /= 0                  = I8# (narrow8Int# (x# `divInt#` y#))
  88         | otherwise               = divZeroError "div{Int8}" x
  89     mod     x@(I8# x#) y@(I8# y#)
  90         | y /= 0                  = I8# (narrow8Int# (x# `modInt#` y#))
  91         | otherwise               = divZeroError "mod{Int8}" x
  92     quotRem x@(I8# x#) y@(I8# y#)
  93         | y /= 0                  = (I8# (narrow8Int# (x# `quotInt#` y#)),
  94                                     I8# (narrow8Int# (x# `remInt#` y#)))
  95         | otherwise               = divZeroError "quotRem{Int8}" x
  96     divMod  x@(I8# x#) y@(I8# y#)
  97         | y /= 0                  = (I8# (narrow8Int# (x# `divInt#` y#)),
  98                                     I8# (narrow8Int# (x# `modInt#` y#)))
  99         | otherwise               = divZeroError "divMod{Int8}" x
 100     toInteger (I8# x#)            = S# x#
 101
 102 instance Bounded Int8 where
 103     minBound = -0x80
 104     maxBound =  0x7F
 105
 106 instance Ix Int8 where
 107     range (m,n)              = [m..n]
 108     unsafeIndex b@(m,_) i    = fromIntegral (i - m)
 109     inRange (m,n) i          = m <= i && i <= n
 110     unsafeRangeSize b@(_l,h) = unsafeIndex b h + 1
 111
 112 instance Read Int8 where
 113     readsPrec p s = [(fromIntegral (x::Int), r) | (x, r) <- readsPrec p s]
 114
 115 instance Bits Int8 where
 116     (I8# x#) .&.   (I8# y#)   = I8# (word2Int# (int2Word# x# `and#` int2Word# y#))
 117     (I8# x#) .|.   (I8# y#)   = I8# (word2Int# (int2Word# x# `or#`  int2Word# y#))
 118     (I8# x#) `xor` (I8# y#)   = I8# (word2Int# (int2Word# x# `xor#` int2Word# y#))
 119     complement (I8# x#)       = I8# (word2Int# (int2Word# x# `xor#` int2Word# (-1#)))
 120     (I8# x#) `shift` (I# i#)
 121         | i# >=# 0#           = I8# (narrow8Int# (x# `iShiftL#` i#))
 122         | otherwise           = I8# (x# `iShiftRA#` negateInt# i#)
 123     (I8# x#) `rotate` (I# i#)
 124         | i'# ==# 0#
 125         = I8# x#
 126         | otherwise
 127         = I8# (narrow8Int# (word2Int# ((x'# `shiftL#` i'#) `or#`
 128                                        (x'# `shiftRL#` (8# -# i'#)))))
 129         where
 130         x'# = narrow8Word# (int2Word# x#)
 131         i'# = word2Int# (int2Word# i# `and#` int2Word# 7#)
 132     bitSize  _                = 8
 133     isSigned _                = True
 134
 135 {-# RULES
 136 "fromIntegral/Int8->Int8" fromIntegral = id :: Int8 -> Int8
 137 "fromIntegral/a->Int8"    fromIntegral = \x -> case fromIntegral x of I# x# -> I8# (narrow8Int# x#)
 138 "fromIntegral/Int8->a"    fromIntegral = \(I8# x#) -> fromIntegral (I# x#)
 139   #-}
 140
 141 ------------------------------------------------------------------------
 142 -- type Int16
 143 ------------------------------------------------------------------------
 144
 145 -- Int16 is represented in the same way as Int. Operations may assume
 146 -- and must ensure that it holds only values from its logical range.
 147
 148 data Int16 = I16# Int# deriving (Eq, Ord)
 149
 150 instance CCallable Int16
 151 instance CReturnable Int16
 152
 153 instance Show Int16 where
 154     showsPrec p x = showsPrec p (fromIntegral x :: Int)
 155
 156 instance Num Int16 where
 157     (I16# x#) + (I16# y#)  = I16# (narrow16Int# (x# +# y#))
 158     (I16# x#) - (I16# y#)  = I16# (narrow16Int# (x# -# y#))
 159     (I16# x#) * (I16# y#)  = I16# (narrow16Int# (x# *# y#))
 160     negate (I16# x#)       = I16# (narrow16Int# (negateInt# x#))
 161     abs x | x >= 0         = x
 162           | otherwise      = negate x
 163     signum x | x > 0       = 1
 164     signum 0               = 0
 165     signum _               = -1
 166     fromInteger (S# i#)    = I16# (narrow16Int# i#)
 167     fromInteger (J# s# d#) = I16# (narrow16Int# (integer2Int# s# d#))
 168
 169 instance Real Int16 where
 170     toRational x = toInteger x % 1
 171
 172 instance Enum Int16 where
 173     succ x
 174         | x /= maxBound = x + 1
 175         | otherwise     = succError "Int16"
 176     pred x
 177         | x /= minBound = x - 1
 178         | otherwise     = predError "Int16"
 179     toEnum i@(I# i#)
 180         | i >= fromIntegral (minBound::Int16) && i <= fromIntegral (maxBound::Int16)
 181                         = I16# i#
 182         | otherwise     = toEnumError "Int16" i (minBound::Int16, maxBound::Int16)
 183     fromEnum (I16# x#)  = I# x#
 184     enumFrom            = boundedEnumFrom
 185     enumFromThen        = boundedEnumFromThen
 186
 187 instance Integral Int16 where
 188     quot    x@(I16# x#) y@(I16# y#)
 189         | y /= 0                  = I16# (narrow16Int# (x# `quotInt#` y#))
 190         | otherwise               = divZeroError "quot{Int16}" x
 191     rem     x@(I16# x#) y@(I16# y#)
 192         | y /= 0                  = I16# (narrow16Int# (x# `remInt#` y#))
 193         | otherwise               = divZeroError "rem{Int16}" x
 194     div     x@(I16# x#) y@(I16# y#)
 195         | y /= 0                  = I16# (narrow16Int# (x# `divInt#` y#))
 196         | otherwise               = divZeroError "div{Int16}" x
 197     mod     x@(I16# x#) y@(I16# y#)
 198         | y /= 0                  = I16# (narrow16Int# (x# `modInt#` y#))
 199         | otherwise               = divZeroError "mod{Int16}" x
 200     quotRem x@(I16# x#) y@(I16# y#)
 201         | y /= 0                  = (I16# (narrow16Int# (x# `quotInt#` y#)),
 202                                     I16# (narrow16Int# (x# `remInt#` y#)))
 203         | otherwise               = divZeroError "quotRem{Int16}" x
 204     divMod  x@(I16# x#) y@(I16# y#)
 205         | y /= 0                  = (I16# (narrow16Int# (x# `divInt#` y#)),
 206                                     I16# (narrow16Int# (x# `modInt#` y#)))
 207         | otherwise               = divZeroError "divMod{Int16}" x
 208     toInteger (I16# x#)           = S# x#
 209
 210 instance Bounded Int16 where
 211     minBound = -0x8000
 212     maxBound =  0x7FFF
 213
 214 instance Ix Int16 where
 215     range (m,n)              = [m..n]
 216     unsafeIndex b@(m,_) i    = fromIntegral (i - m)
 217     inRange (m,n) i          = m <= i && i <= n
 218     unsafeRangeSize b@(_l,h) = unsafeIndex b h + 1
 219
 220 instance Read Int16 where
 221     readsPrec p s = [(fromIntegral (x::Int), r) | (x, r) <- readsPrec p s]
 222
 223 instance Bits Int16 where
 224     (I16# x#) .&.   (I16# y#)  = I16# (word2Int# (int2Word# x# `and#` int2Word# y#))
 225     (I16# x#) .|.   (I16# y#)  = I16# (word2Int# (int2Word# x# `or#`  int2Word# y#))
 226     (I16# x#) `xor` (I16# y#)  = I16# (word2Int# (int2Word# x# `xor#` int2Word# y#))
 227     complement (I16# x#)       = I16# (word2Int# (int2Word# x# `xor#` int2Word# (-1#)))
 228     (I16# x#) `shift` (I# i#)
 229         | i# >=# 0#            = I16# (narrow16Int# (x# `iShiftL#` i#))
 230         | otherwise            = I16# (x# `iShiftRA#` negateInt# i#)
 231     (I16# x#) `rotate` (I# i#)
 232         | i'# ==# 0#
 233         = I16# x#
 234         | otherwise
 235         = I16# (narrow16Int# (word2Int# ((x'# `shiftL#` i'#) `or#`
 236                                          (x'# `shiftRL#` (16# -# i'#)))))
 237         where
 238         x'# = narrow16Word# (int2Word# x#)
 239         i'# = word2Int# (int2Word# i# `and#` int2Word# 15#)
 240     bitSize  _                 = 16
 241     isSigned _                 = True
 242
 243 {-# RULES
 244 "fromIntegral/Word8->Int16"  fromIntegral = \(W8# x#) -> I16# (word2Int# x#)
 245 "fromIntegral/Int8->Int16"   fromIntegral = \(I8# x#) -> I16# x#
 246 "fromIntegral/Int16->Int16"  fromIntegral = id :: Int16 -> Int16
 247 "fromIntegral/a->Int16"      fromIntegral = \x -> case fromIntegral x of I# x# -> I16# (narrow16Int# x#)
 248 "fromIntegral/Int16->a"      fromIntegral = \(I16# x#) -> fromIntegral (I# x#)
 249   #-}
 250
 251 ------------------------------------------------------------------------
 252 -- type Int32
 253 ------------------------------------------------------------------------
 254
 255 #if WORD_SIZE_IN_BITS < 32
 256
 257 data Int32 = I32# Int32#
 258
 259 instance Eq Int32 where
 260     (I32# x#) == (I32# y#) = x# `eqInt32#` y#
 261     (I32# x#) /= (I32# y#) = x# `neInt32#` y#
 262
 263 instance Ord Int32 where
 264     (I32# x#) <  (I32# y#) = x# `ltInt32#` y#
 265     (I32# x#) <= (I32# y#) = x# `leInt32#` y#
 266     (I32# x#) >  (I32# y#) = x# `gtInt32#` y#
 267     (I32# x#) >= (I32# y#) = x# `geInt32#` y#
 268
 269 instance Show Int32 where
 270     showsPrec p x = showsPrec p (toInteger x)
 271
 272 instance Num Int32 where
 273     (I32# x#) + (I32# y#)  = I32# (x# `plusInt32#`  y#)
 274     (I32# x#) - (I32# y#)  = I32# (x# `minusInt32#` y#)
 275     (I32# x#) * (I32# y#)  = I32# (x# `timesInt32#` y#)
 276     negate (I32# x#)       = I32# (negateInt32# x#)
 277     abs x | x >= 0         = x
 278           | otherwise      = negate x
 279     signum x | x > 0       = 1
 280     signum 0               = 0
 281     signum _               = -1
 282     fromInteger (S# i#)    = I32# (intToInt32# i#)
 283     fromInteger (J# s# d#) = I32# (integerToInt32# s# d#)
 284
 285 instance Enum Int32 where
 286     succ x
 287         | x /= maxBound = x + 1
 288         | otherwise     = succError "Int32"
 289     pred x
 290         | x /= minBound = x - 1
 291         | otherwise     = predError "Int32"
 292     toEnum (I# i#)      = I32# (intToInt32# i#)
 293     fromEnum x@(I32# x#)
 294         | x >= fromIntegral (minBound::Int) && x <= fromIntegral (maxBound::Int)
 295                         = I# (int32ToInt# x#)
 296         | otherwise     = fromEnumError "Int32" x
 297     enumFrom            = integralEnumFrom
 298     enumFromThen        = integralEnumFromThen
 299     enumFromTo          = integralEnumFromTo
 300     enumFromThenTo      = integralEnumFromThenTo
 301
 302 instance Integral Int32 where
 303     quot    x@(I32# x#) y@(I32# y#)
 304         | y /= 0                  = I32# (x# `quotInt32#` y#)
 305         | otherwise               = divZeroError "quot{Int32}" x
 306     rem     x@(I32# x#) y@(I32# y#)
 307         | y /= 0                  = I32# (x# `remInt32#` y#)
 308         | otherwise               = divZeroError "rem{Int32}" x
 309     div     x@(I32# x#) y@(I32# y#)
 310         | y /= 0                  = I32# (x# `divInt32#` y#)
 311         | otherwise               = divZeroError "div{Int32}" x
 312     mod     x@(I32# x#) y@(I32# y#)
 313         | y /= 0                  = I32# (x# `modInt32#` y#)
 314         | otherwise               = divZeroError "mod{Int32}" x
 315     quotRem x@(I32# x#) y@(I32# y#)
 316         | y /= 0                  = (I32# (x# `quotInt32#` y#), I32# (x# `remInt32#` y#))
 317         | otherwise               = divZeroError "quotRem{Int32}" x
 318     divMod  x@(I32# x#) y@(I32# y#)
 319         | y /= 0                  = (I32# (x# `divInt32#` y#), I32# (x# `modInt32#` y#))
 320         | otherwise               = divZeroError "divMod{Int32}" x
 321     toInteger x@(I32# x#)
 322         | x >= fromIntegral (minBound::Int) && x <= fromIntegral (maxBound::Int)
 323                                   = S# (int32ToInt# x#)
 324         | otherwise               = case int32ToInteger# x# of (# s, d #) -> J# s d
 325
 326 divInt32#, modInt32# :: Int32# -> Int32# -> Int32#
 327 x# `divInt32#` y#
 328     | (x# `gtInt32#` intToInt32# 0#) && (y# `ltInt32#` intToInt32# 0#)
 329         = ((x# `minusInt32#` y#) `minusInt32#` intToInt32# 1#) `quotInt32#` y#
 330     | (x# `ltInt32#` intToInt32# 0#) && (y# `gtInt32#` intToInt32# 0#)
 331         = ((x# `minusInt32#` y#) `plusInt32#` intToInt32# 1#) `quotInt32#` y#
 332     | otherwise                = x# `quotInt32#` y#
 333 x# `modInt32#` y#
 334     | (x# `gtInt32#` intToInt32# 0#) && (y# `ltInt32#` intToInt32# 0#) ||
 335       (x# `ltInt32#` intToInt32# 0#) && (y# `gtInt32#` intToInt32# 0#)
 336         = if r# `neInt32#` intToInt32# 0# then r# `plusInt32#` y# else intToInt32# 0#
 337     | otherwise = r#
 338     where
 339     r# = x# `remInt32#` y#
 340
 341 instance Read Int32 where
 342     readsPrec p s = [(fromInteger x, r) | (x, r) <- readsPrec p s]
 343
 344 instance Bits Int32 where
 345     (I32# x#) .&.   (I32# y#)  = I32# (word32ToInt32# (int32ToWord32# x# `and32#` int32ToWord32# y#))
 346     (I32# x#) .|.   (I32# y#)  = I32# (word32ToInt32# (int32ToWord32# x# `or32#`  int32ToWord32# y#))
 347     (I32# x#) `xor` (I32# y#)  = I32# (word32ToInt32# (int32ToWord32# x# `xor32#` int32ToWord32# y#))
 348     complement (I32# x#)       = I32# (word32ToInt32# (not32# (int32ToWord32# x#)))
 349     (I32# x#) `shift` (I# i#)
 350         | i# >=# 0#            = I32# (x# `iShiftL32#` i#)
 351         | otherwise            = I32# (x# `iShiftRA32#` negateInt# i#)
 352     (I32# x#) `rotate` (I# i#)
 353         | i'# ==# 0#
 354         = I32# x#
 355         | otherwise
 356         = I32# (word32ToInt32# ((x'# `shiftL32#` i'#) `or32#`
 357                                 (x'# `shiftRL32#` (32# -# i'#))))
 358         where
 359         x'# = int32ToWord32# x#
 360         i'# = word2Int# (int2Word# i# `and#` int2Word# 31#)
 361     bitSize  _                 = 32
 362     isSigned _                 = True
 363
 364 foreign import "stg_eqInt32"       unsafe eqInt32#       :: Int32# -> Int32# -> Bool
 365 foreign import "stg_neInt32"       unsafe neInt32#       :: Int32# -> Int32# -> Bool
 366 foreign import "stg_ltInt32"       unsafe ltInt32#       :: Int32# -> Int32# -> Bool
 367 foreign import "stg_leInt32"       unsafe leInt32#       :: Int32# -> Int32# -> Bool
 368 foreign import "stg_gtInt32"       unsafe gtInt32#       :: Int32# -> Int32# -> Bool
 369 foreign import "stg_geInt32"       unsafe geInt32#       :: Int32# -> Int32# -> Bool
 370 foreign import "stg_plusInt32"     unsafe plusInt32#     :: Int32# -> Int32# -> Int32#
 371 foreign import "stg_minusInt32"    unsafe minusInt32#    :: Int32# -> Int32# -> Int32#
 372 foreign import "stg_timesInt32"    unsafe timesInt32#    :: Int32# -> Int32# -> Int32#
 373 foreign import "stg_negateInt32"   unsafe negateInt32#   :: Int32# -> Int32#
 374 foreign import "stg_quotInt32"     unsafe quotInt32#     :: Int32# -> Int32# -> Int32#
 375 foreign import "stg_remInt32"      unsafe remInt32#      :: Int32# -> Int32# -> Int32#
 376 foreign import "stg_intToInt32"    unsafe intToInt32#    :: Int# -> Int32#
 377 foreign import "stg_int32ToInt"    unsafe int32ToInt#    :: Int32# -> Int#
 378 foreign import "stg_wordToWord32"  unsafe wordToWord32#  :: Word# -> Word32#
 379 foreign import "stg_int32ToWord32" unsafe int32ToWord32# :: Int32# -> Word32#
 380 foreign import "stg_word32ToInt32" unsafe word32ToInt32# :: Word32# -> Int32#
 381 foreign import "stg_and32"         unsafe and32#         :: Word32# -> Word32# -> Word32#
 382 foreign import "stg_or32"          unsafe or32#          :: Word32# -> Word32# -> Word32#
 383 foreign import "stg_xor32"         unsafe xor32#         :: Word32# -> Word32# -> Word32#
 384 foreign import "stg_not32"         unsafe not32#         :: Word32# -> Word32#
 385 foreign import "stg_iShiftL32"     unsafe iShiftL32#     :: Int32# -> Int# -> Int32#
 386 foreign import "stg_iShiftRA32"    unsafe iShiftRA32#    :: Int32# -> Int# -> Int32#
 387 foreign import "stg_shiftL32"      unsafe shiftL32#      :: Word32# -> Int# -> Word32#
 388 foreign import "stg_shiftRL32"     unsafe shiftRL32#     :: Word32# -> Int# -> Word32#
 389
 390 {-# RULES
 391 "fromIntegral/Int->Int32"    fromIntegral = \(I#   x#) -> I32# (intToInt32# x#)
 392 "fromIntegral/Word->Int32"   fromIntegral = \(W#   x#) -> I32# (word32ToInt32# (wordToWord32# x#))
 393 "fromIntegral/Word32->Int32" fromIntegral = \(W32# x#) -> I32# (word32ToInt32# x#)
 394 "fromIntegral/Int32->Int"    fromIntegral = \(I32# x#) -> I#   (int32ToInt# x#)
 395 "fromIntegral/Int32->Word"   fromIntegral = \(I32# x#) -> W#   (int2Word# (int32ToInt# x#))
 396 "fromIntegral/Int32->Word32" fromIntegral = \(I32# x#) -> W32# (int32ToWord32# x#)
 397 "fromIntegral/Int32->Int32"  fromIntegral = id :: Int32 -> Int32
 398   #-}
 399
 400 #else
 401
 402 -- Int32 is represented in the same way as Int.
 403 #if WORD_SIZE_IN_BITS > 32
 404 -- Operations may assume and must ensure that it holds only values
 405 -- from its logical range.
 406 #endif
 407
 408 data Int32 = I32# Int# deriving (Eq, Ord)
 409
 410 instance Show Int32 where
 411     showsPrec p x = showsPrec p (fromIntegral x :: Int)
 412
 413 instance Num Int32 where
 414     (I32# x#) + (I32# y#)  = I32# (narrow32Int# (x# +# y#))
 415     (I32# x#) - (I32# y#)  = I32# (narrow32Int# (x# -# y#))
 416     (I32# x#) * (I32# y#)  = I32# (narrow32Int# (x# *# y#))
 417     negate (I32# x#)       = I32# (narrow32Int# (negateInt# x#))
 418     abs x | x >= 0         = x
 419           | otherwise      = negate x
 420     signum x | x > 0       = 1
 421     signum 0               = 0
 422     signum _               = -1
 423     fromInteger (S# i#)    = I32# (narrow32Int# i#)
 424     fromInteger (J# s# d#) = I32# (narrow32Int# (integer2Int# s# d#))
 425
 426 instance Enum Int32 where
 427     succ x
 428         | x /= maxBound = x + 1
 429         | otherwise     = succError "Int32"
 430     pred x
 431         | x /= minBound = x - 1
 432         | otherwise     = predError "Int32"
 433 #if WORD_SIZE_IN_BITS == 32
 434     toEnum (I# i#)      = I32# i#
 435 #else
 436     toEnum i@(I# i#)
 437         | i >= fromIntegral (minBound::Int32) && i <= fromIntegral (maxBound::Int32)
 438                         = I32# i#
 439         | otherwise     = toEnumError "Int32" i (minBound::Int32, maxBound::Int32)
 440 #endif
 441     fromEnum (I32# x#)  = I# x#
 442     enumFrom            = boundedEnumFrom
 443     enumFromThen        = boundedEnumFromThen
 444
 445 instance Integral Int32 where
 446     quot    x@(I32# x#) y@(I32# y#)
 447         | y /= 0                  = I32# (narrow32Int# (x# `quotInt#` y#))
 448         | otherwise               = divZeroError "quot{Int32}" x
 449     rem     x@(I32# x#) y@(I32# y#)
 450         | y /= 0                  = I32# (narrow32Int# (x# `remInt#` y#))
 451         | otherwise               = divZeroError "rem{Int32}" x
 452     div     x@(I32# x#) y@(I32# y#)
 453         | y /= 0                  = I32# (narrow32Int# (x# `divInt#` y#))
 454         | otherwise               = divZeroError "div{Int32}" x
 455     mod     x@(I32# x#) y@(I32# y#)
 456         | y /= 0                  = I32# (narrow32Int# (x# `modInt#` y#))
 457         | otherwise               = divZeroError "mod{Int32}" x
 458     quotRem x@(I32# x#) y@(I32# y#)
 459         | y /= 0                  = (I32# (narrow32Int# (x# `quotInt#` y#)),
 460                                     I32# (narrow32Int# (x# `remInt#` y#)))
 461         | otherwise               = divZeroError "quotRem{Int32}" x
 462     divMod  x@(I32# x#) y@(I32# y#)
 463         | y /= 0                  = (I32# (narrow32Int# (x# `divInt#` y#)),
 464                                     I32# (narrow32Int# (x# `modInt#` y#)))
 465         | otherwise               = divZeroError "divMod{Int32}" x
 466     toInteger (I32# x#)           = S# x#
 467
 468 instance Read Int32 where
 469     readsPrec p s = [(fromIntegral (x::Int), r) | (x, r) <- readsPrec p s]
 470
 471 instance Bits Int32 where
 472     (I32# x#) .&.   (I32# y#)  = I32# (word2Int# (int2Word# x# `and#` int2Word# y#))
 473     (I32# x#) .|.   (I32# y#)  = I32# (word2Int# (int2Word# x# `or#`  int2Word# y#))
 474     (I32# x#) `xor` (I32# y#)  = I32# (word2Int# (int2Word# x# `xor#` int2Word# y#))
 475     complement (I32# x#)       = I32# (word2Int# (int2Word# x# `xor#` int2Word# (-1#)))
 476     (I32# x#) `shift` (I# i#)
 477         | i# >=# 0#            = I32# (narrow32Int# (x# `iShiftL#` i#))
 478         | otherwise            = I32# (x# `iShiftRA#` negateInt# i#)
 479     (I32# x#) `rotate` (I# i#)
 480         | i'# ==# 0#
 481         = I32# x#
 482         | otherwise
 483         = I32# (narrow32Int# (word2Int# ((x'# `shiftL#` i'#) `or#`
 484                                         (x'# `shiftRL#` (32# -# i'#)))))
 485         where
 486         x'# = narrow32Word# (int2Word# x#)
 487         i'# = word2Int# (int2Word# i# `and#` int2Word# 31#)
 488     bitSize  _                 = 32
 489     isSigned _                 = True
 490
 491 {-# RULES
 492 "fromIntegral/Word8->Int32"  fromIntegral = \(W8# x#) -> I32# (word2Int# x#)
 493 "fromIntegral/Word16->Int32" fromIntegral = \(W16# x#) -> I32# (word2Int# x#)
 494 "fromIntegral/Int8->Int32"   fromIntegral = \(I8# x#) -> I32# x#
 495 "fromIntegral/Int16->Int32"  fromIntegral = \(I16# x#) -> I32# x#
 496 "fromIntegral/Int32->Int32"  fromIntegral = id :: Int32 -> Int32
 497 "fromIntegral/a->Int32"      fromIntegral = \x -> case fromIntegral x of I# x# -> I32# (narrow32Int# x#)
 498 "fromIntegral/Int32->a"      fromIntegral = \(I32# x#) -> fromIntegral (I# x#)
 499   #-}
 500
 501 #endif
 502
 503 instance CCallable Int32
 504 instance CReturnable Int32
 505
 506 instance Real Int32 where
 507     toRational x = toInteger x % 1
 508
 509 instance Bounded Int32 where
 510     minBound = -0x80000000
 511     maxBound =  0x7FFFFFFF
 512
 513 instance Ix Int32 where
 514     range (m,n)              = [m..n]
 515     unsafeIndex b@(m,_) i    = fromIntegral (i - m)
 516     inRange (m,n) i          = m <= i && i <= n
 517     unsafeRangeSize b@(_l,h) = unsafeIndex b h + 1
 518
 519 ------------------------------------------------------------------------
 520 -- type Int64
 521 ------------------------------------------------------------------------
 522
 523 #if WORD_SIZE_IN_BITS < 64
 524
 525 data Int64 = I64# Int64#
 526
 527 instance Eq Int64 where
 528     (I64# x#) == (I64# y#) = x# `eqInt64#` y#
 529     (I64# x#) /= (I64# y#) = x# `neInt64#` y#
 530
 531 instance Ord Int64 where
 532     (I64# x#) <  (I64# y#) = x# `ltInt64#` y#
 533     (I64# x#) <= (I64# y#) = x# `leInt64#` y#
 534     (I64# x#) >  (I64# y#) = x# `gtInt64#` y#
 535     (I64# x#) >= (I64# y#) = x# `geInt64#` y#
 536
 537 instance Show Int64 where
 538     showsPrec p x = showsPrec p (toInteger x)
 539
 540 instance Num Int64 where
 541     (I64# x#) + (I64# y#)  = I64# (x# `plusInt64#`  y#)
 542     (I64# x#) - (I64# y#)  = I64# (x# `minusInt64#` y#)
 543     (I64# x#) * (I64# y#)  = I64# (x# `timesInt64#` y#)
 544     negate (I64# x#)       = I64# (negateInt64# x#)
 545     abs x | x >= 0         = x
 546           | otherwise      = negate x
 547     signum x | x > 0       = 1
 548     signum 0               = 0
 549     signum _               = -1
 550     fromInteger (S# i#)    = I64# (intToInt64# i#)
 551     fromInteger (J# s# d#) = I64# (integerToInt64# s# d#)
 552
 553 instance Enum Int64 where
 554     succ x
 555         | x /= maxBound = x + 1
 556         | otherwise     = succError "Int64"
 557     pred x
 558         | x /= minBound = x - 1
 559         | otherwise     = predError "Int64"
 560     toEnum (I# i#)      = I64# (intToInt64# i#)
 561     fromEnum x@(I64# x#)
 562         | x >= fromIntegral (minBound::Int) && x <= fromIntegral (maxBound::Int)
 563                         = I# (int64ToInt# x#)
 564         | otherwise     = fromEnumError "Int64" x
 565     enumFrom            = integralEnumFrom
 566     enumFromThen        = integralEnumFromThen
 567     enumFromTo          = integralEnumFromTo
 568     enumFromThenTo      = integralEnumFromThenTo
 569
 570 instance Integral Int64 where
 571     quot    x@(I64# x#) y@(I64# y#)
 572         | y /= 0                  = I64# (x# `quotInt64#` y#)
 573         | otherwise               = divZeroError "quot{Int64}" x
 574     rem     x@(I64# x#) y@(I64# y#)
 575         | y /= 0                  = I64# (x# `remInt64#` y#)
 576         | otherwise               = divZeroError "rem{Int64}" x
 577     div     x@(I64# x#) y@(I64# y#)
 578         | y /= 0                  = I64# (x# `divInt64#` y#)
 579         | otherwise               = divZeroError "div{Int64}" x
 580     mod     x@(I64# x#) y@(I64# y#)
 581         | y /= 0                  = I64# (x# `modInt64#` y#)
 582         | otherwise               = divZeroError "mod{Int64}" x
 583     quotRem x@(I64# x#) y@(I64# y#)
 584         | y /= 0                  = (I64# (x# `quotInt64#` y#), I64# (x# `remInt64#` y#))
 585         | otherwise               = divZeroError "quotRem{Int64}" x
 586     divMod  x@(I64# x#) y@(I64# y#)
 587         | y /= 0                  = (I64# (x# `divInt64#` y#), I64# (x# `modInt64#` y#))
 588         | otherwise               = divZeroError "divMod{Int64}" x
 589     toInteger x@(I64# x#)
 590         | x >= fromIntegral (minBound::Int) && x <= fromIntegral (maxBound::Int)
 591                                   = S# (int64ToInt# x#)
 592         | otherwise               = case int64ToInteger# x# of (# s, d #) -> J# s d
 593
 594
 595 divInt64#, modInt64# :: Int64# -> Int64# -> Int64#
 596 x# `divInt64#` y#
 597     | (x# `gtInt64#` intToInt64# 0#) && (y# `ltInt64#` intToInt64# 0#)
 598         = ((x# `minusInt64#` y#) `minusInt64#` intToInt64# 1#) `quotInt64#` y#
 599     | (x# `ltInt64#` intToInt64# 0#) && (y# `gtInt64#` intToInt64# 0#)
 600         = ((x# `minusInt64#` y#) `plusInt64#` intToInt64# 1#) `quotInt64#` y#
 601     | otherwise                = x# `quotInt64#` y#
 602 x# `modInt64#` y#
 603     | (x# `gtInt64#` intToInt64# 0#) && (y# `ltInt64#` intToInt64# 0#) ||
 604       (x# `ltInt64#` intToInt64# 0#) && (y# `gtInt64#` intToInt64# 0#)
 605         = if r# `neInt64#` intToInt64# 0# then r# `plusInt64#` y# else intToInt64# 0#
 606     | otherwise = r#
 607     where
 608     r# = x# `remInt64#` y#
 609
 610 instance Read Int64 where
 611     readsPrec p s = [(fromInteger x, r) | (x, r) <- readsPrec p s]
 612
 613 instance Bits Int64 where
 614     (I64# x#) .&.   (I64# y#)  = I64# (word64ToInt64# (int64ToWord64# x# `and64#` int64ToWord64# y#))
 615     (I64# x#) .|.   (I64# y#)  = I64# (word64ToInt64# (int64ToWord64# x# `or64#`  int64ToWord64# y#))
 616     (I64# x#) `xor` (I64# y#)  = I64# (word64ToInt64# (int64ToWord64# x# `xor64#` int64ToWord64# y#))
 617     complement (I64# x#)       = I64# (word64ToInt64# (not64# (int64ToWord64# x#)))
 618     (I64# x#) `shift` (I# i#)
 619         | i# >=# 0#            = I64# (x# `iShiftL64#` i#)
 620         | otherwise            = I64# (x# `iShiftRA64#` negateInt# i#)
 621     (I64# x#) `rotate` (I# i#)
 622         | i'# ==# 0#
 623         = I64# x#
 624         | otherwise
 625         = I64# (word64ToInt64# ((x'# `uncheckedShiftL64#` i'#) `or64#`
 626                                 (x'# `uncheckedShiftRL64#` (64# -# i'#))))
 627         where
 628         x'# = int64ToWord64# x#
 629         i'# = word2Int# (int2Word# i# `and#` int2Word# 63#)
 630     bitSize  _                 = 64
 631     isSigned _                 = True
 632
 633
 634 -- give the 64-bit shift operations the same treatment as the 32-bit
 635 -- ones (see GHC.Base), namely we wrap them in tests to catch the
 636 -- cases when we're shifting more than 64 bits to avoid unspecified
 637 -- behaviour in the C shift operations.
 638
 639 iShiftL64#, iShiftRA64# :: Int64# -> Int# -> Int64#
 640
 641 a `iShiftL64#` b  | b >=# 64# = intToInt64# 0#
 642                   | otherwise = a `uncheckedIShiftL64#` b
 643
 644 a `iShiftRA64#` b | b >=# 64# = if a `ltInt64#` (intToInt64# 0#)
 645                                         then intToInt64# (-1#)
 646                                         else intToInt64# 0#
 647                   | otherwise = a `uncheckedIShiftRA64#` b
 648
 649
 650 foreign import ccall unsafe "stg_eqInt64"       eqInt64#       :: Int64# -> Int64# -> Bool
 651 foreign import ccall unsafe "stg_neInt64"       neInt64#       :: Int64# -> Int64# -> Bool
 652 foreign import ccall unsafe "stg_ltInt64"       ltInt64#       :: Int64# -> Int64# -> Bool
 653 foreign import ccall unsafe "stg_leInt64"       leInt64#       :: Int64# -> Int64# -> Bool
 654 foreign import ccall unsafe "stg_gtInt64"       gtInt64#       :: Int64# -> Int64# -> Bool
 655 foreign import ccall unsafe "stg_geInt64"       geInt64#       :: Int64# -> Int64# -> Bool
 656 foreign import ccall unsafe "stg_plusInt64"     plusInt64#     :: Int64# -> Int64# -> Int64#
 657 foreign import ccall unsafe "stg_minusInt64"    minusInt64#    :: Int64# -> Int64# -> Int64#
 658 foreign import ccall unsafe "stg_timesInt64"    timesInt64#    :: Int64# -> Int64# -> Int64#
 659 foreign import ccall unsafe "stg_negateInt64"   negateInt64#   :: Int64# -> Int64#
 660 foreign import ccall unsafe "stg_quotInt64"     quotInt64#     :: Int64# -> Int64# -> Int64#
 661 foreign import ccall unsafe "stg_remInt64"      remInt64#      :: Int64# -> Int64# -> Int64#
 662 foreign import ccall unsafe "stg_intToInt64"    intToInt64#    :: Int# -> Int64#
 663 foreign import ccall unsafe "stg_int64ToInt"    int64ToInt#    :: Int64# -> Int#
 664 foreign import ccall unsafe "stg_wordToWord64"  wordToWord64#  :: Word# -> Word64#
 665 foreign import ccall unsafe "stg_int64ToWord64" int64ToWord64# :: Int64# -> Word64#
 666 foreign import ccall unsafe "stg_word64ToInt64" word64ToInt64# :: Word64# -> Int64#
 667 foreign import ccall unsafe "stg_and64"         and64#         :: Word64# -> Word64# -> Word64#
 668 foreign import ccall unsafe "stg_or64"          or64#          :: Word64# -> Word64# -> Word64#
 669 foreign import ccall unsafe "stg_xor64"         xor64#         :: Word64# -> Word64# -> Word64#
 670 foreign import ccall unsafe "stg_not64"         not64#         :: Word64# -> Word64#
 671 foreign import ccall unsafe "stg_uncheckedShiftL64"      uncheckedShiftL64#      :: Word64# -> Int# -> Word64#
 672 foreign import ccall unsafe "stg_uncheckedShiftRL64"     uncheckedShiftRL64#     :: Word64# -> Int# -> Word64#
 673 foreign import ccall unsafe "stg_uncheckedIShiftL64"     uncheckedIShiftL64#     :: Int64# -> Int# -> Int64#
 674 foreign import ccall unsafe "stg_uncheckedIShiftRA64"    uncheckedIShiftRA64#    :: Int64# -> Int# -> Int64#
 675
 676 foreign import ccall unsafe "stg_integerToInt64"  integerToInt64#  :: Int# -> ByteArray# -> Int64#
 677
 678 {-# RULES
 679 "fromIntegral/Int->Int64"    fromIntegral = \(I#   x#) -> I64# (intToInt64# x#)
 680 "fromIntegral/Word->Int64"   fromIntegral = \(W#   x#) -> I64# (word64ToInt64# (wordToWord64# x#))
 681 "fromIntegral/Word64->Int64" fromIntegral = \(W64# x#) -> I64# (word64ToInt64# x#)
 682 "fromIntegral/Int64->Int"    fromIntegral = \(I64# x#) -> I#   (int64ToInt# x#)
 683 "fromIntegral/Int64->Word"   fromIntegral = \(I64# x#) -> W#   (int2Word# (int64ToInt# x#))
 684 "fromIntegral/Int64->Word64" fromIntegral = \(I64# x#) -> W64# (int64ToWord64# x#)
 685 "fromIntegral/Int64->Int64"  fromIntegral = id :: Int64 -> Int64
 686   #-}
 687
 688 #else
 689
 690 -- Int64 is represented in the same way as Int.
 691 -- Operations may assume and must ensure that it holds only values
 692 -- from its logical range.
 693
 694 data Int64 = I64# Int# deriving (Eq, Ord)
 695
 696 instance Show Int64 where
 697     showsPrec p x = showsPrec p (fromIntegral x :: Int)
 698
 699 instance Num Int64 where
 700     (I64# x#) + (I64# y#)  = I64# (x# +# y#)
 701     (I64# x#) - (I64# y#)  = I64# (x# -# y#)
 702     (I64# x#) * (I64# y#)  = I64# (x# *# y#)
 703     negate (I64# x#)       = I64# (negateInt# x#)
 704     abs x | x >= 0         = x
 705           | otherwise      = negate x
 706     signum x | x > 0       = 1
 707     signum 0               = 0
 708     signum _               = -1
 709     fromInteger (S# i#)    = I64# i#
 710     fromInteger (J# s# d#) = I64# (integer2Int# s# d#)
 711
 712 instance Enum Int64 where
 713     succ x
 714         | x /= maxBound = x + 1
 715         | otherwise     = succError "Int64"
 716     pred x
 717         | x /= minBound = x - 1
 718         | otherwise     = predError "Int64"
 719     toEnum (I# i#)      = I64# i#
 720     fromEnum (I64# x#)  = I# x#
 721     enumFrom            = boundedEnumFrom
 722     enumFromThen        = boundedEnumFromThen
 723
 724 instance Integral Int64 where
 725     quot    x@(I64# x#) y@(I64# y#)
 726         | y /= 0                  = I64# (x# `quotInt#` y#)
 727         | otherwise               = divZeroError "quot{Int64}" x
 728     rem     x@(I64# x#) y@(I64# y#)
 729         | y /= 0                  = I64# (x# `remInt#` y#)
 730         | otherwise               = divZeroError "rem{Int64}" x
 731     div     x@(I64# x#) y@(I64# y#)
 732         | y /= 0                  = I64# (x# `divInt#` y#)
 733         | otherwise               = divZeroError "div{Int64}" x
 734     mod     x@(I64# x#) y@(I64# y#)
 735         | y /= 0                  = I64# (x# `modInt#` y#)
 736         | otherwise               = divZeroError "mod{Int64}" x
 737     quotRem x@(I64# x#) y@(I64# y#)
 738         | y /= 0                  = (I64# (x# `quotInt#` y#), I64# (x# `remInt#` y#))
 739         | otherwise               = divZeroError "quotRem{Int64}" x
 740     divMod  x@(I64# x#) y@(I64# y#)
 741         | y /= 0                  = (I64# (x# `divInt#` y#), I64# (x# `modInt#` y#))
 742         | otherwise               = divZeroError "divMod{Int64}" x
 743     toInteger (I64# x#)           = S# x#
 744
 745 instance Read Int64 where
 746     readsPrec p s = [(fromIntegral (x::Int), r) | (x, r) <- readsPrec p s]
 747
 748 instance Bits Int64 where
 749     (I64# x#) .&.   (I64# y#)  = I64# (word2Int# (int2Word# x# `and#` int2Word# y#))
 750     (I64# x#) .|.   (I64# y#)  = I64# (word2Int# (int2Word# x# `or#`  int2Word# y#))
 751     (I64# x#) `xor` (I64# y#)  = I64# (word2Int# (int2Word# x# `xor#` int2Word# y#))
 752     complement (I64# x#)       = I64# (word2Int# (int2Word# x# `xor#` int2Word# (-1#)))
 753     (I64# x#) `shift` (I# i#)
 754         | i# >=# 0#            = I64# (x# `iShiftL#` i#)
 755         | otherwise            = I64# (x# `iShiftRA#` negateInt# i#)
 756     (I64# x#) `rotate` (I# i#)
 757         | i'# ==# 0#
 758         = I64# x#
 759         | otherwise
 760         = I64# (word2Int# ((x'# `shiftL#` i'#) `or#`
 761                            (x'# `shiftRL#` (64# -# i'#))))
 762         where
 763         x'# = int2Word# x#
 764         i'# = word2Int# (int2Word# i# `and#` int2Word# 63#)
 765     bitSize  _                 = 64
 766     isSigned _                 = True
 767
 768 {-# RULES
 769 "fromIntegral/a->Int64" fromIntegral = \x -> case fromIntegral x of I# x# -> I64# x#
 770 "fromIntegral/Int64->a" fromIntegral = \(I64# x#) -> fromIntegral (I# x#)
 771   #-}
 772
 773 #endif
 774
 775 instance CCallable Int64
 776 instance CReturnable Int64
 777
 778 instance Real Int64 where
 779     toRational x = toInteger x % 1
 780
 781 instance Bounded Int64 where
 782     minBound = -0x8000000000000000
 783     maxBound =  0x7FFFFFFFFFFFFFFF
 784
 785 instance Ix Int64 where
 786     range (m,n)              = [m..n]
 787     unsafeIndex b@(m,_) i    = fromIntegral (i - m)
 788     inRange (m,n) i          = m <= i && i <= n
 789     unsafeRangeSize b@(_l,h) = unsafeIndex b h + 1