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 #include "MachDeps.h"
   9
  10 module Addr
  11         ( Addr
  12
  13         , module Addr
  14 #ifndef __HUGS__
  15         , module Word
  16         , module Int
  17         , module PrelAddr
  18 #endif
  19
  20         -- (non-standard) coercions
  21         , addrToInt             -- :: Addr -> Int
  22         , intToAddr             -- :: Int  -> Addr
  23
  24         ) where
  25
  26 #ifdef __HUGS__
  27 import PreludeBuiltin
  28 #else
  29 import PrelAddr
  30 import PrelForeign
  31 import PrelStable
  32 import PrelBase
  33 import NumExts
  34 import PrelIOBase ( IO(..) )
  35 import Word     ( indexWord8OffAddr,  indexWord16OffAddr
  36                 , indexWord32OffAddr, indexWord64OffAddr
  37                 , readWord8OffAddr,   readWord16OffAddr
  38                 , readWord32OffAddr,  readWord64OffAddr
  39                 , writeWord8OffAddr,  writeWord16OffAddr
  40                 , writeWord32OffAddr, writeWord64OffAddr
  41                 )
  42
  43 import Int      ( indexInt8OffAddr,  indexInt16OffAddr
  44                 , indexInt32OffAddr, indexInt64OffAddr
  45                 , readInt8OffAddr,   readInt16OffAddr
  46                 , readInt32OffAddr,  readInt64OffAddr
  47                 , writeInt8OffAddr,  writeInt16OffAddr
  48                 , writeInt32OffAddr, writeInt64OffAddr
  49                 )
  50 #endif
  51
  52 \end{code}
  53
  54 \begin{code}
  55 instance Show Addr where
  56    showsPrec p (A# a) rs = pad_out (showHex int "") rs
  57      where
  58         -- want 0s prefixed to pad it out to a fixed length.
  59        pad_out ('0':'x':ls) rs =
  60           '0':'x':(replicate (2*ADDR_SIZE_IN_BYTES - length ls) '0') ++ ls ++ rs
  61
  62        int =
  63         case word2Integer# (int2Word# (addr2Int# a)) of
  64           (# s, d #) -> J# s d
  65
  66 \end{code}
  67
  68
  69 Coercing between machine ints and words
  70
  71 \begin{code}
  72 addrToInt :: Addr -> Int
  73 intToAddr :: Int -> Addr
  74
  75 #ifdef __HUGS__
  76 addrToInt = primAddrToInt
  77 intToAddr = primIntToAddr
  78 #else
  79 addrToInt (A# a#) = I# (addr2Int# a#)
  80 intToAddr (I# i#) = A# (int2Addr# i#)
  81 #endif
  82 \end{code}
  83
  84 Indexing immutable memory:
  85
  86 \begin{code}
  87 indexCharOffAddr   :: Addr -> Int -> Char
  88 indexIntOffAddr    :: Addr -> Int -> Int
  89 indexWordOffAddr   :: Addr -> Int -> Word
  90 --in PrelAddr: indexAddrOffAddr   :: Addr -> Int -> Addr
  91 indexFloatOffAddr  :: Addr -> Int -> Float
  92 indexDoubleOffAddr :: Addr -> Int -> Double
  93 indexStablePtrOffAddr :: Addr -> Int -> StablePtr a
  94
  95 #ifdef __HUGS__
  96 indexCharOffAddr   = primIndexCharOffAddr
  97 indexIntOffAddr    = primIndexIntOffAddr
  98 indexWordOffAddr   = primIndexWordOffAddr
  99 indexAddrOffAddr   = primIndexAddrOffAddr
 100 indexFloatOffAddr  = primIndexFloatOffAddr
 101 indexDoubleOffAddr = primIndexDoubleOffAddr
 102 #else
 103 indexCharOffAddr (A# addr#) n
 104   = case n                              of { I# n# ->
 105     case indexCharOffAddr# addr# n#     of { r# ->
 106     (C# r#)}}
 107
 108 indexIntOffAddr (A# addr#) n
 109   = case n                              of { I# n# ->
 110     case indexIntOffAddr# addr# n#      of { r# ->
 111     (I# r#)}}
 112
 113 indexWordOffAddr (A# addr#) n
 114   = case n                              of { I# n# ->
 115     case indexWordOffAddr# addr# n#     of { r# ->
 116     (W# r#)}}
 117
 118 indexFloatOffAddr (A# addr#) n
 119   = case n                              of { I# n# ->
 120     case indexFloatOffAddr# addr# n#    of { r# ->
 121     (F# r#)}}
 122
 123 indexDoubleOffAddr (A# addr#) n
 124   = case n                              of { I# n# ->
 125     case indexDoubleOffAddr# addr# n#   of { r# ->
 126     (D# r#)}}
 127
 128 indexStablePtrOffAddr (A# addr#) n
 129   = case n                               of { I# n# ->
 130     case indexStablePtrOffAddr# addr# n# of { r# ->
 131     (StablePtr r#)}}
 132 #endif
 133 \end{code}
 134
 135 Indexing mutable memory:
 136
 137 \begin{code}
 138 readCharOffAddr    :: Addr -> Int -> IO Char
 139 readIntOffAddr     :: Addr -> Int -> IO Int
 140 readWordOffAddr    :: Addr -> Int -> IO Word
 141 readAddrOffAddr    :: Addr -> Int -> IO Addr
 142 readFloatOffAddr   :: Addr -> Int -> IO Float
 143 readDoubleOffAddr  :: Addr -> Int -> IO Double
 144 readStablePtrOffAddr  :: Addr -> Int -> IO (StablePtr a)
 145
 146 #ifdef __HUGS__
 147 readCharOffAddr    = primReadCharOffAddr
 148 readIntOffAddr     = primReadIntOffAddr
 149 readWordOffAddr    = primReadWordOffAddr
 150 readAddrOffAddr    = primReadAddrOffAddr
 151 readFloatOffAddr   = primReadFloatOffAddr
 152 readDoubleOffAddr  = primReadDoubleOffAddr
 153 #else
 154 readCharOffAddr a i = case indexCharOffAddr a i of { C# o# -> return (C# o#) }
 155 readIntOffAddr a i  = case indexIntOffAddr a i of { I# o# -> return (I# o#) }
 156 readWordOffAddr a i = case indexWordOffAddr a i of { W# o# -> return (W# o#) }
 157 readAddrOffAddr a i = case indexAddrOffAddr a i of { A# o# -> return (A# o#) }
 158 readFloatOffAddr a i = case indexFloatOffAddr a i of { F# o# -> return (F# o#) }
 159 readDoubleOffAddr a i = case indexDoubleOffAddr a i of { D# o# -> return (D# o#) }
 160 readStablePtrOffAddr a i = case indexStablePtrOffAddr a i of { StablePtr x -> return (StablePtr x) }
 161 #endif
 162 \end{code}
 163
 164
 165 \begin{code}
 166 writeCharOffAddr   :: Addr -> Int -> Char   -> IO ()
 167 writeIntOffAddr    :: Addr -> Int -> Int    -> IO ()
 168 writeWordOffAddr   :: Addr -> Int -> Word  -> IO ()
 169 writeAddrOffAddr   :: Addr -> Int -> Addr   -> IO ()
 170 writeFloatOffAddr  :: Addr -> Int -> Float  -> IO ()
 171 writeDoubleOffAddr :: Addr -> Int -> Double -> IO ()
 172
 173 #ifdef __HUGS__
 174 writeCharOffAddr    = primWriteCharOffAddr
 175 writeIntOffAddr     = primWriteIntOffAddr
 176 writeWordOffAddr    = primWriteWordOffAddr
 177 writeAddrOffAddr    = primWriteAddrOffAddr
 178 writeFloatOffAddr   = primWriteFloatOffAddr
 179 writeDoubleOffAddr  = primWriteDoubleOffAddr
 180 #else
 181 writeCharOffAddr (A# a#) (I# i#) (C# c#) = IO $ \ s# ->
 182       case (writeCharOffAddr#  a# i# c# s#) of s2# -> (# s2#, () #)
 183
 184 writeIntOffAddr (A# a#) (I# i#) (I# e#) = IO $ \ s# ->
 185       case (writeIntOffAddr#  a# i# e# s#) of s2# -> (# s2#, () #)
 186
 187 writeWordOffAddr (A# a#) (I# i#) (W# e#) = IO $ \ s# ->
 188       case (writeWordOffAddr#  a# i# e# s#) of s2# -> (# s2#, () #)
 189
 190 writeAddrOffAddr (A# a#) (I# i#) (A# e#) = IO $ \ s# ->
 191       case (writeAddrOffAddr#  a# i# e# s#) of s2# -> (# s2#, () #)
 192
 193 writeFloatOffAddr (A# a#) (I# i#) (F# e#) = IO $ \ s# ->
 194       case (writeFloatOffAddr#  a# i# e# s#) of s2# -> (# s2#, () #)
 195
 196 writeDoubleOffAddr (A# a#) (I# i#) (D# e#) = IO $ \ s# ->
 197       case (writeDoubleOffAddr#  a# i# e# s#) of s2# -> (# s2#, () #)
 198
 199 #ifndef __PARALLEL_HASKELL__
 200 writeForeignObjOffAddr   :: Addr -> Int -> ForeignObj -> IO ()
 201 writeForeignObjOffAddr (A# a#) (I# i#) (ForeignObj e#) = IO $ \ s# ->
 202       case (writeForeignObjOffAddr#  a# i# e# s#) of s2# -> (# s2#, () #)
 203 #endif
 204
 205 writeStablePtrOffAddr    :: Addr -> Int -> StablePtr a -> IO ()
 206 writeStablePtrOffAddr (A# a#) (I# i#) (StablePtr e#) = IO $ \ s# ->
 207       case (writeStablePtrOffAddr#  a# i# e# s#) of s2# -> (# s2# , () #)
 208
 209 #endif
 210 \end{code}