Chapter 35
Foreign.Ptr

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.

35.1 データポインタ

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 Foreign.Storable.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.

instance Eq (Ptr a)

instance Ord (Ptr a)

instance Show (Ptr a)

instance Storable (Ptr a)

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 second to the first argument. We have

 p2 == p1 ‘plusPtr‘ (p2 ‘minusPtr‘ p1)

35.2 関数ポインタ

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, Data.Int.Int8, Data.Int.Int16, Data.Int.Int32, Data.Int.Int64, Data.Word.Word8, Data.Word.Word16, Data.Word.Word32, Data.Word.Word64, Ptr a, FunPtr a, Foreign.StablePtr.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 Foreign.Ptr.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

instance Eq (FunPtr a)

instance Ord (FunPtr a)

instance Show (FunPtr a)

instance Storable (FunPtr a)

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.

35.3 情報落ちのない整数とポインタの間の変換

data IntPtr

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.

instance Bounded IntPtr

instance Enum IntPtr

instance Eq IntPtr

instance Integral IntPtr

instance Num IntPtr

instance Ord IntPtr

instance Read IntPtr

instance Real IntPtr

instance Show IntPtr

instance Storable IntPtr

instance Bits 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. This type is also compatible with the C99 type uintptr_t, and can be marshalled to and from that type safely.

instance Bounded WordPtr

instance Enum WordPtr

instance Eq WordPtr

instance Integral WordPtr

instance Num WordPtr

instance Ord WordPtr

instance Read WordPtr

instance Real WordPtr

instance Show WordPtr

instance Storable WordPtr

instance Bits WordPtr

ptrToWordPtr :: Ptr a -> WordPtr

casts a Ptr to a WordPtr

wordPtrToPtr :: WordPtr -> Ptr a

casts a WordPtr to a Ptr