| Safe Haskell | Safe | 
|---|
Foreign.Ptr
Contents
Description
The module Foreign.Ptr provides typed pointers to foreign entities. We distinguish two kinds of pointers: pointers to data and pointers to functions. It is understood that these two kinds of pointers may be represented differently as they may be references to data and text segments, respectively.
- data Ptr a
- nullPtr :: Ptr a
- castPtr :: Ptr a -> Ptr b
- plusPtr :: Ptr a -> Int -> Ptr b
- alignPtr :: Ptr a -> Int -> Ptr a
- minusPtr :: Ptr a -> Ptr b -> Int
- data FunPtr a
- nullFunPtr :: FunPtr a
- castFunPtr :: FunPtr a -> FunPtr b
- castFunPtrToPtr :: FunPtr a -> Ptr b
- castPtrToFunPtr :: Ptr a -> FunPtr b
- freeHaskellFunPtr :: FunPtr a -> IO ()
- data IntPtr
- ptrToIntPtr :: Ptr a -> IntPtr
- intPtrToPtr :: IntPtr -> Ptr a
- data WordPtr
- ptrToWordPtr :: Ptr a -> WordPtr
- wordPtrToPtr :: WordPtr -> Ptr a
Data pointers
A value of type Ptr aa.
The type a will often be an instance of class
 Storable which provides the marshalling operations.
 However this is not essential, and you can provide your own operations
 to access the pointer.  For example you might write small foreign
 functions to get or set the fields of a C struct.
alignPtr :: Ptr a -> Int -> Ptr aSource
Given an arbitrary address and an alignment constraint,
 alignPtr yields the next higher address that fulfills the
 alignment constraint.  An alignment constraint x is fulfilled by
 any address divisible by x.  This operation is idempotent.
minusPtr :: Ptr a -> Ptr b -> IntSource
Computes the offset required to get from the second to the first argument. We have
p2 == p1 `plusPtr` (p2 `minusPtr` p1)
Function pointers
A value of type FunPtr aa will normally be a foreign type,
 a function type with zero or more arguments where
-  the argument types are marshallable foreign types,
   i.e. Char,Int,Double,Float,Bool,Int8,Int16,Int32,Int64,Word8,Word16,Word32,Word64,PtraFunPtraStablePtranewtype.
-  the return type is either a marshallable foreign type or has the form
   IOttis a marshallable foreign type or().
A value of type FunPtr a
foreign import ccall "stdlib.h &free" p_free :: FunPtr (Ptr a -> IO ())
or a pointer to a Haskell function created using a wrapper stub
 declared to produce a FunPtr of the correct type.  For example:
type Compare = Int -> Int -> Bool foreign import ccall "wrapper" mkCompare :: Compare -> IO (FunPtr Compare)
Calls to wrapper stubs like mkCompare allocate storage, which
 should be released with freeHaskellFunPtr when no
 longer required.
To convert FunPtr values to corresponding Haskell functions, one
 can define a dynamic stub for the specific foreign type, e.g.
type IntFunction = CInt -> IO () foreign import ccall "dynamic" mkFun :: FunPtr IntFunction -> IntFunction
nullFunPtr :: FunPtr aSource
The constant nullFunPtr contains a
 distinguished value of FunPtr that is not
 associated with a valid memory location.
castFunPtrToPtr :: FunPtr a -> Ptr bSource
castPtrToFunPtr :: Ptr a -> FunPtr bSource
freeHaskellFunPtr :: FunPtr a -> IO ()Source
Release the storage associated with the given FunPtr, which
 must have been obtained from a wrapper stub.  This should be called
 whenever the return value from a foreign import wrapper function is
 no longer required; otherwise, the storage it uses will leak.
Integral types with lossless conversion to and from pointers
A signed integral type that can be losslessly converted to and from
 Ptr.  This type is also compatible with the C99 type intptr_t, and
 can be marshalled to and from that type safely.
ptrToIntPtr :: Ptr a -> IntPtrSource
casts a Ptr to an IntPtr
intPtrToPtr :: IntPtr -> Ptr aSource
casts an IntPtr to a Ptr
An unsigned integral type that can be losslessly converted to and from
 Ptr. This type is also compatible with the C99 type uintptr_t, and
 can be marshalled to and from that type safely.
ptrToWordPtr :: Ptr a -> WordPtrSource
casts a Ptr to a WordPtr
wordPtrToPtr :: WordPtr -> Ptr aSource
casts a WordPtr to a Ptr