Hoogle Search
Within LTS Haskell 24.40 (ghc-9.10.3)
Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.
newForeignPtrEnv :: FinalizerEnvPtr env a -> Ptr env -> Ptr a -> IO (ForeignPtr a)ghc-internal GHC.Internal.Foreign.ForeignPtr.Imp This variant of newForeignPtr adds a finalizer that expects an environment in addition to the finalized pointer. The environment that will be passed to the finalizer is fixed by the second argument to newForeignPtrEnv.
newForeignPtr_ :: Ptr a -> IO (ForeignPtr a)ghc-internal GHC.Internal.Foreign.ForeignPtr.Imp Turns a plain memory reference into a foreign pointer that may be associated with finalizers by using addForeignPtrFinalizer.
plusForeignPtr :: ForeignPtr a -> Int -> ForeignPtr bghc-internal GHC.Internal.Foreign.ForeignPtr.Imp Advances the given address by the given offset in bytes. The new 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 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.
touchForeignPtr :: ForeignPtr a -> IO ()ghc-internal GHC.Internal.Foreign.ForeignPtr.Imp 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 preceding touchForeignPtr diverges (e.g. by looping infinitely or throwing an exception). For this reason, you are strongly advised to use instead withForeignPtr where possible. Also, note that this function should not be used to express dependencies between finalizers on ForeignPtrs. For example, if the finalizer for a ForeignPtr F1 calls touchForeignPtr on a second 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.
unsafeForeignPtrToPtr :: ForeignPtr a -> Ptr aghc-internal GHC.Internal.Foreign.ForeignPtr.Imp This function extracts the pointer component of a foreign pointer. This is a potentially dangerous operations, as if the argument to unsafeForeignPtrToPtr is the last usage occurrence of the given foreign pointer, then its finalizer(s) will be run, which potentially invalidates the plain pointer just obtained. Hence, touchForeignPtr must be used wherever it has to be guaranteed that the pointer lives on - i.e., has another usage occurrence. To avoid subtle coding errors, hand written marshalling code should preferably use withForeignPtr rather than combinations of unsafeForeignPtrToPtr and touchForeignPtr. However, the latter routines are occasionally preferred in tool generated marshalling code.
withForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO bghc-internal GHC.Internal.Foreign.ForeignPtr.Imp 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 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 bracket. The reason for this unsafeness is the same as for unsafeForeignPtrToPtr below: the finalizer may run earlier than expected, because the compiler can only track usage of the ForeignPtr object, not a Ptr object made from it. This function is normally used for marshalling data to or from the object pointed to by the ForeignPtr, using the operations from the Storable class.
unsafeForeignPtrToPtr :: ForeignPtr a -> Ptr aghc-internal GHC.Internal.Foreign.ForeignPtr.Unsafe This function extracts the pointer component of a foreign pointer. This is a potentially dangerous operations, as if the argument to unsafeForeignPtrToPtr is the last usage occurrence of the given foreign pointer, then its finalizer(s) will be run, which potentially invalidates the plain pointer just obtained. Hence, touchForeignPtr must be used wherever it has to be guaranteed that the pointer lives on - i.e., has another usage occurrence. To avoid subtle coding errors, hand written marshalling code should preferably use withForeignPtr rather than combinations of unsafeForeignPtrToPtr and touchForeignPtr. However, the latter routines are occasionally preferred in tool generated marshalling code.
PlainForeignPtr :: !IORef Finalizers -> ForeignPtrContentsghc-internal GHC.Internal.ForeignPtr The pointer refers to unmanaged memory that was allocated by a foreign function (typically using malloc). The finalizer frequently calls the C function free or some variant of it.
addForeignPtrConcFinalizer :: ForeignPtr a -> IO () -> IO ()ghc-internal GHC.Internal.ForeignPtr This function adds a finalizer to the given ForeignPtr. The finalizer will run before all other finalizers for the same object which have already been registered. This is a variant of addForeignPtrFinalizer, where the finalizer is an arbitrary IO action. When finalization is triggered by GC, the finalizer will run in a new thread. When finalization is triggered by explicitly calling finalizeForeignPtr, the finalizer will run immediately on the current Haskell thread. NB. Be very careful with these finalizers. One common trap is that if a finalizer references another finalized value, it does not prevent that value from being finalized. In particular, Handles are finalized objects, so a finalizer should not refer to a Handle (including stdout, stdin, or stderr).
addForeignPtrFinalizer :: FinalizerPtr a -> ForeignPtr a -> IO ()ghc-internal GHC.Internal.ForeignPtr This function adds a finalizer to the given foreign object. The finalizer will run before all other finalizers for the same object which have already been registered.