Data/Array/IO.hs

{-# OPTIONS_GHC -#include "HsBase.h" #-}
{-# OPTIONS_GHC -w #-} --tmp
-----------------------------------------------------------------------------
-- |
-- Module : Data.Array.IO
-- Copyright : (c) The University of Glasgow 2001
-- License : BSD-style (see the file libraries/base/LICENSE)
-- 
-- Maintainer : libraries@haskell.org
-- Stability : experimental
-- Portability : non-portable (uses Data.Array.MArray)
--
-- Mutable boxed and unboxed arrays in the IO monad.
--
-----------------------------------------------------------------------------

module Data.Array.IO (
 -- * @IO@ arrays with boxed elements
 IOArray,		-- instance of: Eq, Typeable

 -- * @IO@ arrays with unboxed elements
 IOUArray,		-- instance of: Eq, Typeable
 castIOUArray,	-- :: IOUArray i a -> IO (IOUArray i b)

 -- * Overloaded mutable array interface
 module Data.Array.MArray,

 -- * Doing I\/O with @IOUArray@s
 hGetArray,		-- :: Handle -> IOUArray Int Word8 -> Int -> IO Int
 hPutArray,		-- :: Handle -> IOUArray Int Word8 -> Int -> IO ()
 ) where

import Data.Array.Base
import Data.Array.IO.Internals
import Data.Array.MArray
import System.IO.Error

#ifdef __GLASGOW_HASKELL__
import Foreign
import Foreign.C

import GHC.Exts (MutableByteArray#, RealWorld)
import GHC.Arr
import GHC.IORef
import GHC.IO.Handle
import GHC.IO.Buffer
import GHC.IO.Exception

#else
import Data.Char
import Data.Word ( Word8 )
import System.IO
#endif

#ifdef __GLASGOW_HASKELL__
-- ---------------------------------------------------------------------------
-- hGetArray

-- | Reads a number of 'Word8's from the specified 'Handle' directly
-- into an array.
hGetArray
 	:: Handle		-- ^ Handle to read from
	-> IOUArray Int Word8	-- ^ Array in which to place the values
	-> Int			-- ^ Number of 'Word8's to read
	-> IO Int
		-- ^ Returns: the number of 'Word8's actually 
		-- read, which might be smaller than the number requested
		-- if the end of file was reached.

hGetArray handle (IOUArray (STUArray _l _u n ptr)) count
 | count == 0 = return 0
 | count < 0 || count > n = illegalBufferSize handle "hGetArray" count
 | otherwise = do
 -- we would like to read directly into the buffer, but we can't
 -- be sure that the MutableByteArray# is pinned, so we have to
 -- allocate a separate area of memory and copy.
 allocaBytes n $ \p -> do
 r <- hGetBuf handle p n
 memcpy_ba_ptr ptr p (fromIntegral r)
 return r

foreign import ccall unsafe "memcpy"
 memcpy_ba_ptr :: MutableByteArray# RealWorld -> Ptr a -> CSize -> IO (Ptr ())

-- ---------------------------------------------------------------------------
-- hPutArray

-- | Writes an array of 'Word8' to the specified 'Handle'.
hPutArray
	:: Handle			-- ^ Handle to write to
	-> IOUArray Int Word8		-- ^ Array to write from
	-> Int				-- ^ Number of 'Word8's to write
	-> IO ()

hPutArray handle (IOUArray (STUArray _l _u n raw)) count
 | count == 0 = return ()
 | count < 0 || count > n = illegalBufferSize handle "hPutArray" count
 | otherwise = do
 -- as in hGetArray, we would like to use the array directly, but
 -- we can't be sure that the MutableByteArray# is pinned.
 allocaBytes n $ \p -> do
 memcpy_ptr_ba p raw (fromIntegral n)
 hPutBuf handle p n

foreign import ccall unsafe "memcpy"
 memcpy_ptr_ba :: Ptr a -> MutableByteArray# RealWorld -> CSize -> IO (Ptr ())

-- ---------------------------------------------------------------------------
-- Internal Utils

illegalBufferSize :: Handle -> String -> Int -> IO a
illegalBufferSize handle fn sz = 
	ioException (ioeSetErrorString
		 (mkIOError InvalidArgument fn (Just handle) Nothing)
		 ("illegal buffer size " ++ showsPrec 9 (sz::Int) []))

#else /* !__GLASGOW_HASKELL__ */
hGetArray :: Handle -> IOUArray Int Word8 -> Int -> IO Int
hGetArray handle arr count = do
	bds <- getBounds arr
	if count < 0 || count > rangeSize bds
	 then illegalBufferSize handle "hGetArray" count
	 else get 0
 where
 get i | i == count = return i
	| otherwise = do
		error_or_c <- try (hGetChar handle)
		case error_or_c of
		 Left ex
			| isEOFError ex -> return i
			| otherwise -> ioError ex
		 Right c -> do
			unsafeWrite arr i (fromIntegral (ord c))
			get (i+1)

hPutArray :: Handle -> IOUArray Int Word8 -> Int -> IO ()
hPutArray handle arr count = do
	bds <- getBounds arr
	if count < 0 || count > rangeSize bds
	 then illegalBufferSize handle "hPutArray" count
	 else put 0
 where
 put i | i == count = return ()
	| otherwise = do
		w <- unsafeRead arr i
		hPutChar handle (chr (fromIntegral w))
		put (i+1)

illegalBufferSize :: Handle -> String -> Int -> IO a
illegalBufferSize _ fn sz = ioError $
	userError (fn ++ ": illegal buffer size " ++ showsPrec 9 (sz::Int) [])
#endif /* !__GLASGOW_HASKELL__ */