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 #ifndef __PARALLEL_HASKELL__
  41 import PrelForeign ( ForeignObj(..), StablePtr(..) )
  42 #endif
  43
  44 \end{code}
  45
  46 Coercing between machine ints and words
  47
  48 \begin{code}
  49 addrToInt :: Addr -> Int
  50 addrToInt (A# a#) = I# (addr2Int# a#)
  51
  52 intToAddr :: Int -> Addr
  53 intToAddr (I# i#) = A# (int2Addr# i#)
  54 \end{code}
  55
  56 Indexing immutable memory:
  57
  58 \begin{code}
  59 indexCharOffAddr   :: Addr -> Int -> Char
  60 indexIntOffAddr    :: Addr -> Int -> Int
  61 indexWordOffAddr   :: Addr -> Int -> Word
  62 --in PrelAddr: indexAddrOffAddr   :: Addr -> Int -> Addr
  63 indexFloatOffAddr  :: Addr -> Int -> Float
  64 indexDoubleOffAddr :: Addr -> Int -> Double
  65
  66 indexCharOffAddr (A# addr#) n
  67   = case n                              of { I# n# ->
  68     case indexCharOffAddr# addr# n#     of { r# ->
  69     (C# r#)}}
  70
  71 indexIntOffAddr (A# addr#) n
  72   = case n                              of { I# n# ->
  73     case indexIntOffAddr# addr# n#      of { r# ->
  74     (I# r#)}}
  75
  76 indexWordOffAddr (A# addr#) n
  77   = case n                              of { I# n# ->
  78     case indexWordOffAddr# addr# n#     of { r# ->
  79     (W# r#)}}
  80
  81 indexFloatOffAddr (A# addr#) n
  82   = case n                              of { I# n# ->
  83     case indexFloatOffAddr# addr# n#    of { r# ->
  84     (F# r#)}}
  85
  86 indexDoubleOffAddr (A# addr#) n
  87   = case n                              of { I# n# ->
  88     case indexDoubleOffAddr# addr# n#   of { r# ->
  89     (D# r#)}}
  90 \end{code}
  91
  92 Indexing mutable memory:
  93
  94 \begin{code}
  95 readCharOffAddr    :: Addr -> Int -> IO Char
  96 readCharOffAddr a i = _casm_ `` %r=(StgChar)(((StgChar*)%0)[(StgInt)%1]); '' a i
  97
  98 readIntOffAddr    :: Addr -> Int -> IO Int
  99 readIntOffAddr a i = _casm_ `` %r=(StgInt)(((StgInt*)%0)[(StgInt)%1]); '' a i
 100
 101 readStablePtrOffAddr    :: Addr -> Int -> IO (StablePtr a)
 102 readStablePtrOffAddr a i = _casm_ `` %r=(StgStablePtr)(((StgStablePtr*)%0)[(StgInt)%1]); '' a i
 103
 104 readWordOffAddr    :: Addr -> Int -> IO Word
 105 readWordOffAddr a i = _casm_ `` %r=(StgWord)(((StgWord*)%0)[(StgInt)%1]); '' a i
 106
 107 readAddrOffAddr    :: Addr -> Int -> IO Addr
 108 readAddrOffAddr a i = _casm_ `` %r=(StgAddr)(((StgAddr*)%0)[(StgInt)%1]); '' a i
 109
 110 readFloatOffAddr    :: Addr -> Int -> IO Float
 111 readFloatOffAddr a i = _casm_ `` %r=(StgFloat)(((StgFloat*)%0)[(StgInt)%1]); '' a i
 112
 113 readDoubleOffAddr  :: Addr -> Int -> IO Double
 114 readDoubleOffAddr a i = _casm_ `` %r=(StgDouble)(((StgDouble*)%0)[(StgInt)%1]); '' a i
 115 \end{code}
 116
 117
 118 \begin{code}
 119 writeCharOffAddr   :: Addr -> Int -> Char   -> IO ()
 120 writeCharOffAddr (A# a#) (I# i#) (C# c#) = IO $ \ s# ->
 121       case (writeCharOffAddr#  a# i# c# s#) of s2# -> IOok s2# ()
 122
 123 writeIntOffAddr    :: Addr -> Int -> Int    -> IO ()
 124 writeIntOffAddr (A# a#) (I# i#) (I# e#) = IO $ \ s# ->
 125       case (writeIntOffAddr#  a# i# e# s#) of s2# -> IOok s2# ()
 126
 127 writeStablePtrOffAddr    :: Addr -> Int -> StablePtr a -> IO ()
 128 writeStablePtrOffAddr (A# a#) (I# i#) (StablePtr e#) = IO $ \ s# ->
 129       case (writeStablePtrOffAddr#  a# i# e# s#) of s2# -> IOok s2# ()
 130
 131 writeWordOffAddr    :: Addr -> Int -> Word  -> IO ()
 132 writeWordOffAddr (A# a#) (I# i#) (W# e#) = IO $ \ s# ->
 133       case (writeWordOffAddr#  a# i# e# s#) of s2# -> IOok s2# ()
 134
 135 writeAddrOffAddr   :: Addr -> Int -> Addr   -> IO ()
 136 writeAddrOffAddr (A# a#) (I# i#) (A# e#) = IO $ \ s# ->
 137       case (writeAddrOffAddr#  a# i# e# s#) of s2# -> IOok s2# ()
 138
 139 #ifndef __PARALLEL_HASKELL__
 140 writeForeignObjOffAddr   :: Addr -> Int -> ForeignObj -> IO ()
 141 writeForeignObjOffAddr (A# a#) (I# i#) (ForeignObj e#) = IO $ \ s# ->
 142       case (writeForeignObjOffAddr#  a# i# e# s#) of s2# -> IOok s2# ()
 143 #endif
 144
 145 writeFloatOffAddr  :: Addr -> Int -> Float  -> IO ()
 146 writeFloatOffAddr (A# a#) (I# i#) (F# e#) = IO $ \ s# ->
 147       case (writeFloatOffAddr#  a# i# e# s#) of s2# -> IOok s2# ()
 148
 149 writeDoubleOffAddr :: Addr -> Int -> Double -> IO ()
 150 writeDoubleOffAddr (A# a#) (I# i#) (D# e#) = IO $ \ s# ->
 151       case (writeDoubleOffAddr#  a# i# e# s#) of s2# -> IOok s2# ()
 152
 153 \end{code}