| Haskell Hierarchical Libraries (base package) | Source code | Contents | Index

Foreign.Ptr

Portability | portable
Stability | provisional
Maintainer | ffi@haskell.org

Contents

Data pointers
Function pointers
Integral types with lossless conversion to and from pointers

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.
Synopsis

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
data Ptr a

A value of type ``Ptr` a` represents a pointer to an object, or an array of objects, which may be marshalled to or from Haskell values of type `a`.

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

Typeable1 Ptr
IArray UArray (Ptr a)
MArray IOUArray (Ptr a) IO
Typeable a => Data (Ptr a)
Eq (Ptr a)
Ord (Ptr a)
Show (Ptr a)
Storable (Ptr a)
IArray (IOToDiffArray IOUArray) (Ptr a)
MArray (STUArray s) (Ptr a) (ST s)

nullPtr :: Ptr a
The constant `nullPtr` contains a distinguished value of `Ptr` that is not associated with a valid memory location.
castPtr :: Ptr a -> Ptr b
The `castPtr` function casts a pointer from one type to another.
plusPtr :: Ptr a -> Int -> Ptr b
Advances the given address by the given offset in bytes.
alignPtr :: Ptr a -> Int -> Ptr a
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

Computes the offset required to get from the first to the second argument. We have

     p2 == p1 `plusPtr` (p2 `minusPtr` p1)

Function pointers
data FunPtr a

A value of type ``FunPtr` a` is a pointer to a function callable from foreign code. The type `a` 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`, ``Ptr` a`, ``FunPtr` a`, ``StablePtr` a` or a renaming of any of these using `newtype`.
- the return type is either a marshallable foreign type or has the form ``IO` t` where `t` is a marshallable foreign type or `()`.

A value of type ``FunPtr` a` may be a pointer to a foreign function, either returned by another foreign function or imported with a a static address import like

     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

Instances

Typeable1 FunPtr
IArray UArray (FunPtr a)
MArray IOUArray (FunPtr a) IO
Eq (FunPtr a)
Ord (FunPtr a)
Show (FunPtr a)
Storable (FunPtr a)
IArray (IOToDiffArray IOUArray) (FunPtr a)
MArray (STUArray s) (FunPtr a) (ST s)

nullFunPtr :: FunPtr a
The constant `nullFunPtr` contains a distinguished value of `FunPtr` that is not associated with a valid memory location.
castFunPtr :: FunPtr a -> FunPtr b
Casts a `FunPtr` to a `FunPtr` of a different type.
castFunPtrToPtr :: FunPtr a -> Ptr b
Casts a `FunPtr` to a `Ptr`. Note: this is valid only on architectures where data and function pointers range over the same set of addresses, and should only be used for bindings to external libraries whose interface already relies on this assumption.
castPtrToFunPtr :: Ptr a -> FunPtr b
Casts a `Ptr` to a `FunPtr`. Note: this is valid only on architectures where data and function pointers range over the same set of addresses, and should only be used for bindings to external libraries whose interface already relies on this assumption.
freeHaskellFunPtr :: FunPtr a -> IO ()
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
data IntPtr

A signed integral type that can be losslessly converted to and from `Ptr`.
Instances

Bits IntPtr
Bounded IntPtr
Enum IntPtr
Eq IntPtr
Integral IntPtr
Num IntPtr
Ord IntPtr
Read IntPtr
Real IntPtr
Show IntPtr
Storable IntPtr
Typeable IntPtr

ptrToIntPtr :: Ptr a -> IntPtr
casts a `Ptr` to an `IntPtr`
intPtrToPtr :: IntPtr -> Ptr a
casts an `IntPtr` to a `Ptr`
data WordPtr

An unsigned integral type that can be losslessly converted to and from `Ptr`.
Instances

Bits WordPtr
Bounded WordPtr
Enum WordPtr
Eq WordPtr
Integral WordPtr
Num WordPtr
Ord WordPtr
Read WordPtr
Real WordPtr
Show WordPtr
Storable WordPtr
Typeable WordPtr

ptrToWordPtr :: Ptr a -> WordPtr
casts a `Ptr` to a `WordPtr`
wordPtrToPtr :: WordPtr -> Ptr a
casts a `WordPtr` to a `Ptr`
Produced by Haddock version 0.8