[project @ 2002-08-03 20:14:23 by reid]
[packages/base.git] / 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}