| Copyright | (c) The FFI task force 2001 |
|---|---|
| License | BSD-style (see the file libraries/base/LICENSE) |
| Maintainer | ffi@haskell.org |
| Stability | provisional |
| Portability | portable |
| Safe Haskell | Trustworthy |
| Language | Haskell2010 |
Foreign.Ptr
Description
This module provides typed pointers to foreign data. It is part of the Foreign Function Interface (FFI) and will normally be imported via the Foreign module.
- 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.
Instances
| Eq (Ptr a) # | |
| Data a => Data (Ptr a) # | |
| Functor (URec (Ptr ())) # | |
| Ord (Ptr a) # | |
| Show (Ptr a) # | |
| Foldable (URec (Ptr ())) # | |
| Traversable (URec (Ptr ())) # | |
| Generic1 (URec (Ptr ())) # | |
| Storable (Ptr a) # | |
| Eq (URec (Ptr ()) p) # | |
| Ord (URec (Ptr ()) p) # | |
| Generic (URec (Ptr ()) p) # | |
| type Rep1 (URec (Ptr ())) # | |
| data URec (Ptr ()) # | Used for marking occurrences of |
| type Rep (URec (Ptr ()) p) # | |
alignPtr :: Ptr a -> Int -> Ptr a Source #
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 -> Int Source #
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 a Source #
The constant nullFunPtr contains a
distinguished value of FunPtr that is not
associated with a valid memory location.
castFunPtrToPtr :: FunPtr a -> Ptr b Source #
castPtrToFunPtr :: Ptr a -> FunPtr b Source #
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 -> IntPtr Source #
casts a Ptr to an IntPtr
intPtrToPtr :: IntPtr -> Ptr a Source #
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 -> WordPtr Source #
casts a Ptr to a WordPtr
wordPtrToPtr :: WordPtr -> Ptr a Source #
casts a WordPtr to a Ptr