% -----------------------------------------------------------------------------
-% $Id: PrelCString.lhs,v 1.2 2001/01/11 19:48:28 qrczak Exp $
+% $Id: PrelCString.lhs,v 1.5 2001/08/10 13:48:06 simonmar Exp $
%
% (c) The FFI task force, 2000
%
Utilities for primitive marshaling
\begin{code}
-module PrelCString where
+{-# OPTIONS -fno-implicit-prelude #-}
-import Monad
+module PrelCString where
+#ifdef __GLASGOW_HASKELL__
import PrelMarshalArray
-import PrelMarshalAlloc
-import PrelException
import PrelPtr
import PrelStorable
import PrelCTypes
-import PrelCTypesISO
-import PrelInt
+import PrelWord
import PrelByteArr
import PrelPack
+import PrelList
+import PrelReal
+import PrelNum
+import PrelIOBase
import PrelBase
-
-#ifdef __GLASGOW_HASKELL__
-import PrelIOBase hiding (malloc, _malloc)
#endif
-----------------------------------------------------------------------------
-- marshal a NUL terminated C string into a Haskell string
--
peekCString :: CString -> IO String
-peekCString cp = liftM cCharsToChars $ peekArray0 nUL cp
+peekCString cp = do cs <- peekArray0 nUL cp; return (cCharsToChars cs)
-- marshal a C string with explicit length into a Haskell string
--
peekCStringLen :: CStringLen -> IO String
-peekCStringLen (cp, len) = liftM cCharsToChars $ peekArray len cp
+peekCStringLen (cp, len) = do cs <- peekArray len cp; return (cCharsToChars cs)
-- marshal a Haskell string into a NUL terminated C strings
--
-- * new storage is allocated for the C string and must be explicitly freed
--
newCStringLen :: String -> IO CStringLen
-newCStringLen str = liftM (pairLength str) $ newArray (charsToCChars str)
+newCStringLen str = do a <- newArray (charsToCChars str)
+ return (pairLength str a)
-- marshal a Haskell string into a NUL terminated C strings using temporary
-- storage
charsToCChars = map castCharToCChar
castCCharToChar :: CChar -> Char
--- castCCharToChar ch = chr (fromIntegral (fromIntegral ch :: Word8))
--- The above produces horrible code. Word and Int modules really
--- should be cleaned up... Here is an ugly but fast version:
-castCCharToChar ch = case fromIntegral (fromIntegral ch :: Int32) of
- I# i# -> C# (chr# (word2Int# (int2Word# i# `and#` int2Word# 0xFF#)))
+castCCharToChar ch = unsafeChr (fromIntegral (fromIntegral ch :: Word8))
castCharToCChar :: Char -> CChar
castCharToCChar ch = fromIntegral (ord ch)
-
-
--- unsafe CStrings
--- ---------------
-
-#if __GLASGOW_HASKELL__
-newtype UnsafeCString = UnsafeCString (ByteArray Int)
-withUnsafeCString s f = f (UnsafeCString (packString s))
-#else
-newtype UnsafeCString = UnsafeCString (Ptr CChar)
-withUnsafeCString s f = withCString s (\p -> f (UnsafeCString p))
-#endif
\end{code}