Foreign.ForeignPtr (original) (raw)
The type [ForeignPtr](Foreign-ForeignPtr.html#t:ForeignPtr "Foreign.ForeignPtr") represents references to objects that are maintained in a foreign language, i.e., that are not part of the data structures usually managed by the Haskell storage manager. The essential difference between [ForeignPtr](Foreign-ForeignPtr.html#t:ForeignPtr "Foreign.ForeignPtr")s and vanilla memory references of type Ptr a is that the former may be associated with finalizers. A finalizer is a routine that is invoked when the Haskell storage manager detects that - within the Haskell heap and stack - there are no more references left that are pointing to the [ForeignPtr](Foreign-ForeignPtr.html#t:ForeignPtr "Foreign.ForeignPtr"). Typically, the finalizer will, then, invoke routines in the foreign language that free the resources bound by the foreign object.
The [ForeignPtr](Foreign-ForeignPtr.html#t:ForeignPtr "Foreign.ForeignPtr") is parameterised in the same way as [Ptr](Foreign-Ptr.html#t:Ptr "Foreign.Ptr"). The type argument of [ForeignPtr](Foreign-ForeignPtr.html#t:ForeignPtr "Foreign.ForeignPtr") should normally be an instance of class [Storable](Foreign-Storable.html#t:Storable "Foreign.Storable").
type FinalizerPtr a = FunPtr (Ptr a -> IO ()) Source #
A finalizer is represented as a pointer to a foreign function that, at finalisation time, gets as an argument a plain pointer variant of the foreign pointer that the finalizer is associated with.
Note that the foreign function must use the ccall calling convention.
newForeignPtr :: FinalizerPtr a -> Ptr a -> IO (ForeignPtr a) Source #
Turns a plain memory reference into a foreign pointer, and associates a finalizer with the reference. The finalizer will be executed after the last reference to the foreign object is dropped. There is no guarantee of promptness, however the finalizer will be executed before the program exits.
withForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO b Source #
This is a way to look at the pointer living inside a foreign object. This function takes a function which is applied to that pointer. The resulting [IO](System-IO.html#t:IO "System.IO") action is then executed. The foreign object is kept alive at least during the whole action, even if it is not used directly inside. Note that it is not safe to return the pointer from the action and use it after the action completes. All uses of the pointer should be inside the[withForeignPtr](Foreign-ForeignPtr.html#v:withForeignPtr "Foreign.ForeignPtr") bracket. The reason for this unsafeness is the same as for[unsafeForeignPtrToPtr](Foreign-ForeignPtr-Unsafe.html#v:unsafeForeignPtrToPtr "Foreign.ForeignPtr.Unsafe") below: the finalizer may run earlier than expected, because the compiler can only track usage of the [ForeignPtr](Foreign-ForeignPtr.html#t:ForeignPtr "Foreign.ForeignPtr") object, not a [Ptr](Foreign-Ptr.html#t:Ptr "Foreign.Ptr") object made from it.
This function is normally used for marshalling data to or from the object pointed to by the[ForeignPtr](Foreign-ForeignPtr.html#t:ForeignPtr "Foreign.ForeignPtr"), using the operations from the[Storable](Foreign-Storable.html#t:Storable "Foreign.Storable") class.
finalizeForeignPtr :: ForeignPtr a -> IO () Source #
Causes the finalizers associated with a foreign pointer to be run immediately. The foreign pointer must not be used again after this function is called. If the foreign pointer does not support finalizers, this is a no-op.
touchForeignPtr :: ForeignPtr a -> IO () Source #
This function ensures that the foreign object in question is alive at the given place in the sequence of IO actions. However, this comes with a significant caveat: the contract above does not hold if GHC can demonstrate that the code preceedingtouchForeignPtr diverges (e.g. by looping infinitely or throwing an exception). For this reason, you are strongly advised to use instead[withForeignPtr](Foreign-ForeignPtr.html#v:withForeignPtr "Foreign.ForeignPtr") where possible.
Also, note that this function should not be used to express dependencies between finalizers on [ForeignPtr](Foreign-ForeignPtr.html#t:ForeignPtr "Foreign.ForeignPtr")s. For example, if the finalizer for a[ForeignPtr](Foreign-ForeignPtr.html#t:ForeignPtr "Foreign.ForeignPtr") F1 calls [touchForeignPtr](Foreign-ForeignPtr.html#v:touchForeignPtr "Foreign.ForeignPtr") on a second [ForeignPtr](Foreign-ForeignPtr.html#t:ForeignPtr "Foreign.ForeignPtr") F2, then the only guarantee is that the finalizer for F2 is never started before the finalizer for F1. They might be started together if for example both F1 and F2 are otherwise unreachable, and in that case the scheduler might end up running the finalizer for F2 first.
In general, it is not recommended to use finalizers on separate objects with ordering constraints between them. To express the ordering robustly requires explicit synchronisation using MVars between the finalizers, but even then the runtime sometimes runs multiple finalizers sequentially in a single thread (for performance reasons), so synchronisation between finalizers could result in artificial deadlock. Another alternative is to use explicit reference counting.
plusForeignPtr :: ForeignPtr a -> Int -> ForeignPtr b Source #
Advances the given address by the given offset in bytes.
The new [ForeignPtr](Foreign-ForeignPtr.html#t:ForeignPtr "Foreign.ForeignPtr") shares the finalizer of the original, equivalent from a finalization standpoint to just creating another reference to the original. That is, the finalizer will not be called before the new [ForeignPtr](Foreign-ForeignPtr.html#t:ForeignPtr "Foreign.ForeignPtr") is unreachable, nor will it be called an additional time due to this call, and the finalizer will be called with the same address that it would have had this call not happened, *not* the new address.
Since: base-4.10.0.0