blob: 2413e30c96aa5103fce5b19e948813a362837bb4 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
% -----------------------------------------------------------------------------
% $Id: PrelCString.lhs,v 1.3 2001/04/14 22:28:46 qrczak Exp $
%
% (c) The FFI task force, 2000
%
Utilities for primitive marshaling
\begin{code}
module PrelCString where
import Monad
import PrelMarshalArray
import PrelPtr
import PrelStorable
import PrelCTypes
import PrelWord
import PrelByteArr
import PrelPack
import PrelBase
#ifdef __GLASGOW_HASKELL__
import PrelIOBase hiding (malloc, _malloc)
#endif
-----------------------------------------------------------------------------
-- Strings
-- representation of strings in C
-- ------------------------------
type CString = Ptr CChar -- conventional NUL terminates strings
type CStringLen = (CString, Int) -- strings with explicit length
-- exported functions
-- ------------------
--
-- * the following routines apply the default conversion when converting the
-- C-land character encoding into the Haskell-land character encoding
--
-- ** NOTE: The current implementation doesn't handle conversions yet! **
--
-- * the routines using an explicit length tolerate NUL characters in the
-- middle of a string
--
-- marshal a NUL terminated C string into a Haskell string
--
peekCString :: CString -> IO String
peekCString cp = liftM cCharsToChars $ peekArray0 nUL cp
-- marshal a C string with explicit length into a Haskell string
--
peekCStringLen :: CStringLen -> IO String
peekCStringLen (cp, len) = liftM cCharsToChars $ peekArray len cp
-- marshal a Haskell string into a NUL terminated C strings
--
-- * the Haskell string may *not* contain any NUL characters
--
-- * new storage is allocated for the C string and must be explicitly freed
--
newCString :: String -> IO CString
newCString = newArray0 nUL . charsToCChars
-- marshal a Haskell string into a C string (ie, character array) with
-- explicit length information
--
-- * 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)
-- marshal a Haskell string into a NUL terminated C strings using temporary
-- storage
--
-- * the Haskell string may *not* contain any NUL characters
--
-- * see the lifetime constraints of `MarshalAlloc.alloca'
--
withCString :: String -> (CString -> IO a) -> IO a
withCString = withArray0 nUL . charsToCChars
-- marshal a Haskell string into a NUL terminated C strings using temporary
-- storage
--
-- * the Haskell string may *not* contain any NUL characters
--
-- * see the lifetime constraints of `MarshalAlloc.alloca'
--
withCStringLen :: String -> (CStringLen -> IO a) -> IO a
withCStringLen str act = withArray (charsToCChars str) $ act . pairLength str
-- auxilliary definitions
-- ----------------------
-- C's end of string character
--
nUL :: CChar
nUL = 0
-- pair a C string with the length of the given Haskell string
--
pairLength :: String -> CString -> CStringLen
pairLength = flip (,) . length
-- cast [CChar] to [Char]
--
cCharsToChars :: [CChar] -> [Char]
cCharsToChars = map castCCharToChar
-- cast [Char] to [CChar]
--
charsToCChars :: [Char] -> [CChar]
charsToCChars = map castCharToCChar
castCCharToChar :: CChar -> Char
castCCharToChar ch = unsafeChr (fromIntegral (fromIntegral ch :: Word8))
castCharToCChar :: Char -> CChar
castCharToCChar ch = fromIntegral (ord ch)
-- unsafe CStrings
-- ---------------
withUnsafeCString :: String -> (UnsafeCString -> IO a) -> IO a
#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}
|
