GHC/Storable.lhs

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