C2HS

Re-export the language-independent component of the FFI

module Foreign

Re-export the C language component of the FFI

module CForeign

Composite marshalling functions

withCStringLenIntConv :: Integral b => String -> ((Ptr CChar, b) -> IO a) -> IO a

peekCStringLenIntConv :: Integral t => (Ptr CChar, t) -> IO String

withIntConv :: (Storable b, Integral a, Integral b) => a -> (Ptr b -> IO c) -> IO c

withFloatConv :: (Storable b, RealFloat a, RealFloat b) => a -> (Ptr b -> IO c) -> IO c

peekIntConv :: (Storable a, Integral a, Integral b) => Ptr a -> IO b

peekFloatConv :: (Storable a, RealFloat a, RealFloat b) => Ptr a -> IO b

withBool :: (Integral a, Storable a) => Bool -> (Ptr a -> IO b) -> IO b

peekBool :: (Integral a, Storable a) => Ptr a -> IO Bool

withEnum :: (Enum a, Integral b, Storable b) => a -> (Ptr b -> IO c) -> IO c

peekEnum :: (Enum a, Integral b, Storable b) => Ptr b -> IO a

Conditional results using Maybe

nothingIf :: (a -> Bool) -> (a -> b) -> a -> Maybe b

nothingIfNull :: (Ptr a -> b) -> Ptr a -> Maybe b

Instance for special casing null pointers.

Bit masks

combineBitMasks :: (Enum a, Bits b) => [a] -> b

containsBitMask :: (Bits a, Enum b) => a -> b -> Bool

extractBitMasks :: (Bits a, Enum b, Bounded b) => a -> [b]

Given a bit pattern, yield all bit masks that it contains.

• This does *not* attempt to compute a minimal set of bit masks that when combined yield the bit pattern, instead all contained bit masks are produced.

Conversion between C and Haskell types

cIntConv :: (Integral a, Integral b) => a -> b

Integral conversion

cFloatConv :: (RealFloat a, RealFloat b) => a -> b

Floating conversion

cToBool :: Num a => a -> Bool

Obtain Haskell Bool from C value.

cFromBool :: Num a => Bool -> a

Obtain C value from Haskell Bool.

cToEnum :: (Integral i, Enum e) => i -> e

Convert a C enumeration to Haskell.

cFromEnum :: (Enum e, Integral i) => e -> i

Convert a Haskell enumeration to C.