GHC/Storable.lhs

   1 \begin{code}
   2 {-# OPTIONS -fno-implicit-prelude #-}
   3 -----------------------------------------------------------------------------
   4 -- |
   5 -- Module      :  GHC.Storable
   6 -- Copyright   :  (c) The FFI task force, 2000-2002
   7 -- License     :  see libraries/base/LICENSE
   8 --
   9 -- Maintainer  :  ffi@haskell.org
  10 -- Stability   :  internal
  11 -- Portability :  non-portable (GHC Extensions)
  12 --
  13 -- The 'Storable' class.
  14 --
  15 -----------------------------------------------------------------------------
  16
  17 module GHC.Storable
  18         ( readWideCharOffPtr
  19         , readIntOffPtr
  20         , readWordOffPtr
  21         , readPtrOffPtr
  22         , readFunPtrOffPtr
  23         , readFloatOffPtr
  24         , readDoubleOffPtr
  25         , readStablePtrOffPtr
  26         , readInt8OffPtr
  27         , readInt16OffPtr
  28         , readInt32OffPtr
  29         , readInt64OffPtr
  30         , readWord8OffPtr
  31         , readWord16OffPtr
  32         , readWord32OffPtr
  33         , readWord64OffPtr
  34         , writeWideCharOffPtr
  35         , writeIntOffPtr
  36         , writeWordOffPtr
  37         , writePtrOffPtr
  38         , writeFunPtrOffPtr
  39         , writeFloatOffPtr
  40         , writeDoubleOffPtr
  41         , writeStablePtrOffPtr
  42         , writeInt8OffPtr
  43         , writeInt16OffPtr
  44         , writeInt32OffPtr
  45         , writeInt64OffPtr
  46         , writeWord8OffPtr
  47         , writeWord16OffPtr
  48         , writeWord32OffPtr
  49         , writeWord64OffPtr
  50         ) where
  51 \end{code}
  52
  53 \begin{code}
  54 import Control.Monad            ( liftM )
  55 import Foreign.C.Types
  56 import Foreign.C.TypesISO
  57
  58 #ifdef __GLASGOW_HASKELL__
  59 import GHC.Stable       ( StablePtr )
  60 import GHC.Num
  61 import GHC.Int
  62 import GHC.Word
  63 import GHC.Stable
  64 import GHC.Ptr
  65 import GHC.Float
  66 import GHC.Err
  67 import GHC.IOBase
  68 import GHC.Base
  69 #endif
  70 \end{code}
  71
  72 Helper functions for Foreign.Storable
  73
  74 \begin{code}
  75
  76 readWideCharOffPtr  :: Ptr Char          -> Int -> IO Char
  77 readIntOffPtr       :: Ptr Int           -> Int -> IO Int
  78 readWordOffPtr      :: Ptr Word          -> Int -> IO Word
  79 readPtrOffPtr       :: Ptr (Ptr a)       -> Int -> IO (Ptr a)
  80 readFunPtrOffPtr    :: Ptr (FunPtr a)    -> Int -> IO (FunPtr a)
  81 readFloatOffPtr     :: Ptr Float         -> Int -> IO Float
  82 readDoubleOffPtr    :: Ptr Double        -> Int -> IO Double
  83 readStablePtrOffPtr :: Ptr (StablePtr a) -> Int -> IO (StablePtr a)
  84 readInt8OffPtr      :: Ptr Int8          -> Int -> IO Int8
  85 readInt16OffPtr     :: Ptr Int16         -> Int -> IO Int16
  86 readInt32OffPtr     :: Ptr Int32         -> Int -> IO Int32
  87 readInt64OffPtr     :: Ptr Int64         -> Int -> IO Int64
  88 readWord8OffPtr     :: Ptr Word8         -> Int -> IO Word8
  89 readWord16OffPtr    :: Ptr Word16        -> Int -> IO Word16
  90 readWord32OffPtr    :: Ptr Word32        -> Int -> IO Word32
  91 readWord64OffPtr    :: Ptr Word64        -> Int -> IO Word64
  92
  93 readWideCharOffPtr (Ptr a) (I# i)
  94   = IO $ \s -> case readWideCharOffAddr# a i s  of (# s2, x #) -> (# s2, C# x #)
  95 readIntOffPtr (Ptr a) (I# i)
  96   = IO $ \s -> case readIntOffAddr# a i s       of (# s2, x #) -> (# s2, I# x #)
  97 readWordOffPtr (Ptr a) (I# i)
  98   = IO $ \s -> case readWordOffAddr# a i s      of (# s2, x #) -> (# s2, W# x #)
  99 readPtrOffPtr (Ptr a) (I# i)
 100   = IO $ \s -> case readAddrOffAddr# a i s      of (# s2, x #) -> (# s2, Ptr x #)
 101 readFunPtrOffPtr (Ptr a) (I# i)
 102   = IO $ \s -> case readAddrOffAddr# a i s      of (# s2, x #) -> (# s2, FunPtr x #)
 103 readFloatOffPtr (Ptr a) (I# i)
 104   = IO $ \s -> case readFloatOffAddr# a i s     of (# s2, x #) -> (# s2, F# x #)
 105 readDoubleOffPtr (Ptr a) (I# i)
 106   = IO $ \s -> case readDoubleOffAddr# a i s    of (# s2, x #) -> (# s2, D# x #)
 107 readStablePtrOffPtr (Ptr a) (I# i)
 108   = IO $ \s -> case readStablePtrOffAddr# a i s of (# s2, x #) -> (# s2, StablePtr x #)
 109 readInt8OffPtr (Ptr a) (I# i)
 110   = IO $ \s -> case readInt8OffAddr# a i s      of (# s2, x #) -> (# s2, I8# x #)
 111 readWord8OffPtr (Ptr a) (I# i)
 112   = IO $ \s -> case readWord8OffAddr# a i s     of (# s2, x #) -> (# s2, W8# x #)
 113 readInt16OffPtr (Ptr a) (I# i)
 114   = IO $ \s -> case readInt16OffAddr# a i s     of (# s2, x #) -> (# s2, I16# x #)
 115 readWord16OffPtr (Ptr a) (I# i)
 116   = IO $ \s -> case readWord16OffAddr# a i s    of (# s2, x #) -> (# s2, W16# x #)
 117 readInt32OffPtr (Ptr a) (I# i)
 118   = IO $ \s -> case readInt32OffAddr# a i s     of (# s2, x #) -> (# s2, I32# x #)
 119 readWord32OffPtr (Ptr a) (I# i)
 120   = IO $ \s -> case readWord32OffAddr# a i s    of (# s2, x #) -> (# s2, W32# x #)
 121 readInt64OffPtr (Ptr a) (I# i)
 122   = IO $ \s -> case readInt64OffAddr# a i s     of (# s2, x #) -> (# s2, I64# x #)
 123 readWord64OffPtr (Ptr a) (I# i)
 124   = IO $ \s -> case readWord64OffAddr# a i s    of (# s2, x #) -> (# s2, W64# x #)
 125
 126 writeWideCharOffPtr  :: Ptr Char          -> Int -> Char        -> IO ()
 127 writeIntOffPtr       :: Ptr Int           -> Int -> Int         -> IO ()
 128 writeWordOffPtr      :: Ptr Word          -> Int -> Word        -> IO ()
 129 writePtrOffPtr       :: Ptr (Ptr a)       -> Int -> Ptr a       -> IO ()
 130 writeFunPtrOffPtr    :: Ptr (FunPtr a)    -> Int -> FunPtr a    -> IO ()
 131 writeFloatOffPtr     :: Ptr Float         -> Int -> Float       -> IO ()
 132 writeDoubleOffPtr    :: Ptr Double        -> Int -> Double      -> IO ()
 133 writeStablePtrOffPtr :: Ptr (StablePtr a) -> Int -> StablePtr a -> IO ()
 134 writeInt8OffPtr      :: Ptr Int8          -> Int -> Int8        -> IO ()
 135 writeInt16OffPtr     :: Ptr Int16         -> Int -> Int16       -> IO ()
 136 writeInt32OffPtr     :: Ptr Int32         -> Int -> Int32       -> IO ()
 137 writeInt64OffPtr     :: Ptr Int64         -> Int -> Int64       -> IO ()
 138 writeWord8OffPtr     :: Ptr Word8         -> Int -> Word8       -> IO ()
 139 writeWord16OffPtr    :: Ptr Word16        -> Int -> Word16      -> IO ()
 140 writeWord32OffPtr    :: Ptr Word32        -> Int -> Word32      -> IO ()
 141 writeWord64OffPtr    :: Ptr Word64        -> Int -> Word64      -> IO ()
 142
 143 writeWideCharOffPtr (Ptr a) (I# i) (C# x)
 144   = IO $ \s -> case writeWideCharOffAddr# a i x s  of s2 -> (# s2, () #)
 145 writeIntOffPtr (Ptr a) (I# i) (I# x)
 146   = IO $ \s -> case writeIntOffAddr# a i x s       of s2 -> (# s2, () #)
 147 writeWordOffPtr (Ptr a) (I# i) (W# x)
 148   = IO $ \s -> case writeWordOffAddr# a i x s      of s2 -> (# s2, () #)
 149 writePtrOffPtr (Ptr a) (I# i) (Ptr x)
 150   = IO $ \s -> case writeAddrOffAddr# a i x s      of s2 -> (# s2, () #)
 151 writeFunPtrOffPtr (Ptr a) (I# i) (FunPtr x)
 152   = IO $ \s -> case writeAddrOffAddr# a i x s      of s2 -> (# s2, () #)
 153 writeFloatOffPtr (Ptr a) (I# i) (F# x)
 154   = IO $ \s -> case writeFloatOffAddr# a i x s     of s2 -> (# s2, () #)
 155 writeDoubleOffPtr (Ptr a) (I# i) (D# x)
 156   = IO $ \s -> case writeDoubleOffAddr# a i x s    of s2 -> (# s2, () #)
 157 writeStablePtrOffPtr (Ptr a) (I# i) (StablePtr x)
 158   = IO $ \s -> case writeStablePtrOffAddr# a i x s of s2 -> (# s2 , () #)
 159 writeInt8OffPtr (Ptr a) (I# i) (I8# x)
 160   = IO $ \s -> case writeInt8OffAddr# a i x s      of s2 -> (# s2, () #)
 161 writeWord8OffPtr (Ptr a) (I# i) (W8# x)
 162   = IO $ \s -> case writeWord8OffAddr# a i x s     of s2 -> (# s2, () #)
 163 writeInt16OffPtr (Ptr a) (I# i) (I16# x)
 164   = IO $ \s -> case writeInt16OffAddr# a i x s     of s2 -> (# s2, () #)
 165 writeWord16OffPtr (Ptr a) (I# i) (W16# x)
 166   = IO $ \s -> case writeWord16OffAddr# a i x s    of s2 -> (# s2, () #)
 167 writeInt32OffPtr (Ptr a) (I# i) (I32# x)
 168   = IO $ \s -> case writeInt32OffAddr# a i x s     of s2 -> (# s2, () #)
 169 writeWord32OffPtr (Ptr a) (I# i) (W32# x)
 170   = IO $ \s -> case writeWord32OffAddr# a i x s    of s2 -> (# s2, () #)
 171 writeInt64OffPtr (Ptr a) (I# i) (I64# x)
 172   = IO $ \s -> case writeInt64OffAddr# a i x s     of s2 -> (# s2, () #)
 173 writeWord64OffPtr (Ptr a) (I# i) (W64# x)
 174   = IO $ \s -> case writeWord64OffAddr# a i x s    of s2 -> (# s2, () #)
 175
 176 \end{code}