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