1 {-# OPTIONS_GHC -XNoImplicitPrelude #-}
2 -----------------------------------------------------------------------------
4 -- Module : Foreign.Marshal.Array
5 -- Copyright : (c) The FFI task force 2001
6 -- License : BSD-style (see the file libraries/base/LICENSE)
8 -- Maintainer : ffi@haskell.org
9 -- Stability : provisional
10 -- Portability : portable
12 -- Marshalling support: routines allocating, storing, and retrieving Haskell
13 -- lists that are represented as arrays in the foreign language
15 -----------------------------------------------------------------------------
17 module Foreign.Marshal.Array (
18 -- * Marshalling arrays
22 mallocArray, -- :: Storable a => Int -> IO (Ptr a)
23 mallocArray0, -- :: Storable a => Int -> IO (Ptr a)
25 allocaArray, -- :: Storable a => Int -> (Ptr a -> IO b) -> IO b
26 allocaArray0, -- :: Storable a => Int -> (Ptr a -> IO b) -> IO b
28 reallocArray, -- :: Storable a => Ptr a -> Int -> IO (Ptr a)
29 reallocArray0, -- :: Storable a => Ptr a -> Int -> IO (Ptr a)
33 peekArray, -- :: Storable a => Int -> Ptr a -> IO [a]
34 peekArray0, -- :: (Storable a, Eq a) => a -> Ptr a -> IO [a]
36 pokeArray, -- :: Storable a => Ptr a -> [a] -> IO ()
37 pokeArray0, -- :: Storable a => a -> Ptr a -> [a] -> IO ()
39 -- ** Combined allocation and marshalling
41 newArray, -- :: Storable a => [a] -> IO (Ptr a)
42 newArray0, -- :: Storable a => a -> [a] -> IO (Ptr a)
44 withArray, -- :: Storable a => [a] -> (Ptr a -> IO b) -> IO b
45 withArray0, -- :: Storable a => a -> [a] -> (Ptr a -> IO b) -> IO b
47 withArrayLen, -- :: Storable a => [a] -> (Int -> Ptr a -> IO b) -> IO b
48 withArrayLen0, -- :: Storable a => a -> [a] -> (Int -> Ptr a -> IO b) -> IO b
52 -- | (argument order: destination, source)
53 copyArray, -- :: Storable a => Ptr a -> Ptr a -> Int -> IO ()
54 moveArray, -- :: Storable a => Ptr a -> Ptr a -> Int -> IO ()
56 -- ** Finding the length
58 lengthArray0, -- :: (Storable a, Eq a) => a -> Ptr a -> IO Int
62 advancePtr, -- :: Storable a => Ptr a -> Int -> Ptr a
65 import Foreign.Ptr (Ptr, plusPtr)
66 import Foreign.Storable (Storable(alignment,sizeOf,peekElemOff,pokeElemOff))
67 import Foreign.Marshal.Alloc (mallocBytes, allocaBytesAligned, reallocBytes)
68 import Foreign.Marshal.Utils (copyBytes, moveBytes)
70 #ifdef __GLASGOW_HASKELL__
76 import Control.Monad (zipWithM_)
82 -- |Allocate storage for the given number of elements of a storable type
83 -- (like 'Foreign.Marshal.Alloc.malloc', but for multiple elements).
85 mallocArray :: Storable a => Int -> IO (Ptr a)
86 mallocArray = doMalloc undefined
88 doMalloc :: Storable a' => a' -> Int -> IO (Ptr a')
89 doMalloc dummy size = mallocBytes (size * sizeOf dummy)
91 -- |Like 'mallocArray', but add an extra position to hold a special
92 -- termination element.
94 mallocArray0 :: Storable a => Int -> IO (Ptr a)
95 mallocArray0 size = mallocArray (size + 1)
97 -- |Temporarily allocate space for the given number of elements
98 -- (like 'Foreign.Marshal.Alloc.alloca', but for multiple elements).
100 allocaArray :: Storable a => Int -> (Ptr a -> IO b) -> IO b
101 allocaArray = doAlloca undefined
103 doAlloca :: Storable a' => a' -> Int -> (Ptr a' -> IO b') -> IO b'
104 doAlloca dummy size = allocaBytesAligned (size * sizeOf dummy)
107 -- |Like 'allocaArray', but add an extra position to hold a special
108 -- termination element.
110 allocaArray0 :: Storable a => Int -> (Ptr a -> IO b) -> IO b
111 allocaArray0 size = allocaArray (size + 1)
112 {-# INLINE allocaArray0 #-}
113 -- needed to get allocaArray to inline into withCString, for unknown
114 -- reasons --SDM 23/4/2010, see #4004 for benchmark
116 -- |Adjust the size of an array
118 reallocArray :: Storable a => Ptr a -> Int -> IO (Ptr a)
119 reallocArray = doRealloc undefined
121 doRealloc :: Storable a' => a' -> Ptr a' -> Int -> IO (Ptr a')
122 doRealloc dummy ptr size = reallocBytes ptr (size * sizeOf dummy)
124 -- |Adjust the size of an array including an extra position for the end marker.
126 reallocArray0 :: Storable a => Ptr a -> Int -> IO (Ptr a)
127 reallocArray0 ptr size = reallocArray ptr (size + 1)
133 -- |Convert an array of given length into a Haskell list. The implementation
134 -- is tail-recursive and so uses constant stack space.
136 peekArray :: Storable a => Int -> Ptr a -> IO [a]
137 peekArray size ptr | size <= 0 = return []
138 | otherwise = f (size-1) []
140 f 0 acc = do e <- peekElemOff ptr 0; return (e:acc)
141 f n acc = do e <- peekElemOff ptr n; f (n-1) (e:acc)
143 -- |Convert an array terminated by the given end marker into a Haskell list
145 peekArray0 :: (Storable a, Eq a) => a -> Ptr a -> IO [a]
146 peekArray0 marker ptr = do
147 size <- lengthArray0 marker ptr
150 -- |Write the list elements consecutive into memory
152 pokeArray :: Storable a => Ptr a -> [a] -> IO ()
153 #ifndef __GLASGOW_HASKELL__
154 pokeArray ptr vals = zipWithM_ (pokeElemOff ptr) [0..] vals
156 pokeArray ptr vals0 = go vals0 0#
157 where go [] _ = return ()
158 go (val:vals) n# = do pokeElemOff ptr (I# n#) val; go vals (n# +# 1#)
161 -- |Write the list elements consecutive into memory and terminate them with the
162 -- given marker element
164 pokeArray0 :: Storable a => a -> Ptr a -> [a] -> IO ()
165 #ifndef __GLASGOW_HASKELL__
166 pokeArray0 marker ptr vals = do
168 pokeElemOff ptr (length vals) marker
170 pokeArray0 marker ptr vals0 = go vals0 0#
171 where go [] n# = pokeElemOff ptr (I# n#) marker
172 go (val:vals) n# = do pokeElemOff ptr (I# n#) val; go vals (n# +# 1#)
176 -- combined allocation and marshalling
177 -- -----------------------------------
179 -- |Write a list of storable elements into a newly allocated, consecutive
180 -- sequence of storable values
181 -- (like 'Foreign.Marshal.Utils.new', but for multiple elements).
183 newArray :: Storable a => [a] -> IO (Ptr a)
185 ptr <- mallocArray (length vals)
189 -- |Write a list of storable elements into a newly allocated, consecutive
190 -- sequence of storable values, where the end is fixed by the given end marker
192 newArray0 :: Storable a => a -> [a] -> IO (Ptr a)
193 newArray0 marker vals = do
194 ptr <- mallocArray0 (length vals)
195 pokeArray0 marker ptr vals
198 -- |Temporarily store a list of storable values in memory
199 -- (like 'Foreign.Marshal.Utils.with', but for multiple elements).
201 withArray :: Storable a => [a] -> (Ptr a -> IO b) -> IO b
202 withArray vals = withArrayLen vals . const
204 -- |Like 'withArray', but the action gets the number of values
205 -- as an additional parameter
207 withArrayLen :: Storable a => [a] -> (Int -> Ptr a -> IO b) -> IO b
208 withArrayLen vals f =
209 allocaArray len $ \ptr -> do
216 -- |Like 'withArray', but a terminator indicates where the array ends
218 withArray0 :: Storable a => a -> [a] -> (Ptr a -> IO b) -> IO b
219 withArray0 marker vals = withArrayLen0 marker vals . const
221 -- |Like 'withArrayLen', but a terminator indicates where the array ends
223 withArrayLen0 :: Storable a => a -> [a] -> (Int -> Ptr a -> IO b) -> IO b
224 withArrayLen0 marker vals f =
225 allocaArray0 len $ \ptr -> do
226 pokeArray0 marker ptr vals
233 -- copying (argument order: destination, source)
236 -- |Copy the given number of elements from the second array (source) into the
237 -- first array (destination); the copied areas may /not/ overlap
239 copyArray :: Storable a => Ptr a -> Ptr a -> Int -> IO ()
240 copyArray = doCopy undefined
242 doCopy :: Storable a' => a' -> Ptr a' -> Ptr a' -> Int -> IO ()
243 doCopy dummy dest src size = copyBytes dest src (size * sizeOf dummy)
245 -- |Copy the given number of elements from the second array (source) into the
246 -- first array (destination); the copied areas /may/ overlap
248 moveArray :: Storable a => Ptr a -> Ptr a -> Int -> IO ()
249 moveArray = doMove undefined
251 doMove :: Storable a' => a' -> Ptr a' -> Ptr a' -> Int -> IO ()
252 doMove dummy dest src size = moveBytes dest src (size * sizeOf dummy)
255 -- finding the length
256 -- ------------------
258 -- |Return the number of elements in an array, excluding the terminator
260 lengthArray0 :: (Storable a, Eq a) => a -> Ptr a -> IO Int
261 lengthArray0 marker ptr = loop 0
264 val <- peekElemOff ptr i
265 if val == marker then return i else loop (i+1)
271 -- |Advance a pointer into an array by the given number of elements
273 advancePtr :: Storable a => Ptr a -> Int -> Ptr a
274 advancePtr = doAdvance undefined
276 doAdvance :: Storable a' => a' -> Ptr a' -> Int -> Ptr a'
277 doAdvance dummy ptr i = ptr `plusPtr` (i * sizeOf dummy)