Physics.Bullet.Raw.C2HS

Re-export the language-independent component of the FFI

module Foreign

Re-export the C language component of the FFI

module Foreign.C

Composite marshalling functions

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

peekCStringLenIntConv :: Integral a => (Ptr CChar, a) -> 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, Num b) => [a] -> b

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

extractBitMasks :: (Bits a, Enum b, Bounded b, Num a) => 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 :: (Eq a, 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.