ghc/lib/exts/Addr.lhs

   1 %
   2 % (c) The AQUA Project, Glasgow University, 1994-1996
   3 %
   4
   5 \section[Addr]{Module @Addr@}
   6
   7 \begin{code}
   8 module Addr
   9         ( module PrelAddr
  10         , module Word
  11         , module Int
  12         , module Addr
  13
  14         -- (non-standard) coercions
  15         , addrToInt             -- :: Addr -> Int
  16         , intToAddr             -- :: Int  -> Addr
  17
  18         ) where
  19
  20 import PrelAddr
  21 import PrelCCall  ( Word(..) )
  22 import PrelBase
  23 import Word     ( indexWord8OffAddr,  indexWord16OffAddr
  24                 , indexWord32OffAddr, indexWord64OffAddr
  25                 , readWord8OffAddr,   readWord16OffAddr
  26                 , readWord32OffAddr,  readWord64OffAddr
  27                 , writeWord8OffAddr,  writeWord16OffAddr
  28                 , writeWord32OffAddr, writeWord64OffAddr
  29                 )
  30
  31 import Int      ( indexInt8OffAddr,  indexInt16OffAddr
  32                 , indexInt32OffAddr, indexInt64OffAddr
  33                 , readInt8OffAddr,   readInt16OffAddr
  34                 , readInt32OffAddr,  readInt64OffAddr
  35                 , writeInt8OffAddr,  writeInt16OffAddr
  36                 , writeInt32OffAddr, writeInt64OffAddr
  37                 )
  38 import PrelIOBase ( IO(..), IOResult(..) )
  39
  40 \end{code}
  41
  42 Coercing between machine ints and words
  43
  44 \begin{code}
  45 addrToInt :: Addr -> Int
  46 addrToInt (A# a#) = I# (addr2Int# a#)
  47
  48 intToAddr :: Int -> Addr
  49 intToAddr (I# i#) = A# (int2Addr# i#)
  50 \end{code}
  51
  52 Indexing immutable memory:
  53
  54 \begin{code}
  55 indexCharOffAddr   :: Addr -> Int -> Char
  56 indexIntOffAddr    :: Addr -> Int -> Int
  57 indexWordOffAddr   :: Addr -> Int -> Word
  58 --in PrelAddr: indexAddrOffAddr   :: Addr -> Int -> Addr
  59 indexFloatOffAddr  :: Addr -> Int -> Float
  60 indexDoubleOffAddr :: Addr -> Int -> Double
  61
  62 indexCharOffAddr (A# addr#) n
  63   = case n                              of { I# n# ->
  64     case indexCharOffAddr# addr# n#     of { r# ->
  65     (C# r#)}}
  66
  67 indexIntOffAddr (A# addr#) n
  68   = case n                              of { I# n# ->
  69     case indexIntOffAddr# addr# n#      of { r# ->
  70     (I# r#)}}
  71
  72 indexWordOffAddr (A# addr#) n
  73   = case n                              of { I# n# ->
  74     case indexWordOffAddr# addr# n#     of { r# ->
  75     (W# r#)}}
  76
  77 indexFloatOffAddr (A# addr#) n
  78   = case n                              of { I# n# ->
  79     case indexFloatOffAddr# addr# n#    of { r# ->
  80     (F# r#)}}
  81
  82 indexDoubleOffAddr (A# addr#) n
  83   = case n                              of { I# n# ->
  84     case indexDoubleOffAddr# addr# n#   of { r# ->
  85     (D# r#)}}
  86 \end{code}
  87
  88 Indexing mutable memory:
  89
  90 \begin{code}
  91 readCharOffAddr    :: Addr -> Int -> IO Char
  92 readCharOffAddr a i = _casm_ `` %r=(StgChar)(((StgChar*)%0)[(StgInt)%1]); '' a i
  93
  94 readIntOffAddr    :: Addr -> Int -> IO Int
  95 readIntOffAddr a i = _casm_ `` %r=(StgInt)(((StgInt*)%0)[(StgInt)%1]); '' a i
  96
  97 readWordOffAddr    :: Addr -> Int -> IO Word
  98 readWordOffAddr a i = _casm_ `` %r=(StgWord)(((StgWord*)%0)[(StgInt)%1]); '' a i
  99
 100 readAddrOffAddr    :: Addr -> Int -> IO Addr
 101 readAddrOffAddr a i = _casm_ `` %r=(StgAddr)(((StgAddr*)%0)[(StgInt)%1]); '' a i
 102
 103 readFloatOffAddr    :: Addr -> Int -> IO Float
 104 readFloatOffAddr a i = _casm_ `` %r=(StgFloat)(((StgFloat*)%0)[(StgInt)%1]); '' a i
 105
 106 readDoubleOffAddr  :: Addr -> Int -> IO Double
 107 readDoubleOffAddr a i = _casm_ `` %r=(StgDouble)(((StgDouble*)%0)[(StgInt)%1]); '' a i
 108 \end{code}
 109
 110
 111 \begin{code}
 112 writeCharOffAddr   :: Addr -> Int -> Char   -> IO ()
 113 writeCharOffAddr (A# a#) (I# i#) (C# c#) = IO $ \ s# ->
 114       case (writeCharOffAddr#  a# i# c# s#) of s2# -> IOok s2# ()
 115
 116 writeIntOffAddr    :: Addr -> Int -> Int    -> IO ()
 117 writeIntOffAddr (A# a#) (I# i#) (I# e#) = IO $ \ s# ->
 118       case (writeIntOffAddr#  a# i# e# s#) of s2# -> IOok s2# ()
 119
 120 writeWordOffAddr    :: Addr -> Int -> Word  -> IO ()
 121 writeWordOffAddr (A# a#) (I# i#) (W# e#) = IO $ \ s# ->
 122       case (writeWordOffAddr#  a# i# e# s#) of s2# -> IOok s2# ()
 123
 124 writeAddrOffAddr   :: Addr -> Int -> Addr   -> IO ()
 125 writeAddrOffAddr (A# a#) (I# i#) (A# e#) = IO $ \ s# ->
 126       case (writeAddrOffAddr#  a# i# e# s#) of s2# -> IOok s2# ()
 127
 128 writeFloatOffAddr  :: Addr -> Int -> Float  -> IO ()
 129 writeFloatOffAddr (A# a#) (I# i#) (F# e#) = IO $ \ s# ->
 130       case (writeFloatOffAddr#  a# i# e# s#) of s2# -> IOok s2# ()
 131
 132 writeDoubleOffAddr :: Addr -> Int -> Double -> IO ()
 133 writeDoubleOffAddr (A# a#) (I# i#) (D# e#) = IO $ \ s# ->
 134       case (writeDoubleOffAddr#  a# i# e# s#) of s2# -> IOok s2# ()
 135
 136 \end{code}