From 2a81161dc0a00a1db2f00a0601541b81542b3ea8 Mon Sep 17 00:00:00 2001 From: simonmar Date: Thu, 12 Jun 2003 10:53:16 +0000 Subject: [PATCH] [project @ 2003-06-12 10:53:15 by simonmar] Update to latest revision of the FFI spec: - foreignPtrToPtr is now unsafeForeignPtrToPtr - newForeignPtr_ added. --- Foreign/ForeignPtr.hs | 19 ++++++++++--------- GHC/ForeignPtr.hs | 39 +++++++++++++++++++++------------------ 2 files changed, 31 insertions(+), 27 deletions(-) diff --git a/Foreign/ForeignPtr.hs b/Foreign/ForeignPtr.hs index a92ec45..01c5c09 100644 --- a/Foreign/ForeignPtr.hs +++ b/Foreign/ForeignPtr.hs @@ -21,9 +21,10 @@ module Foreign.ForeignPtr ForeignPtr , FinalizerPtr , newForeignPtr + , newForeignPtr_ , addForeignPtrFinalizer , withForeignPtr - , foreignPtrToPtr -- will soon become unsafeForeignPtrToPtr + , unsafeForeignPtrToPtr , touchForeignPtr , castForeignPtr @@ -75,13 +76,13 @@ import Data.Dynamic INSTANCE_TYPEABLE1(ForeignPtr,foreignPtrTc,"ForeignPtr") instance Eq (ForeignPtr a) where - p == q = foreignPtrToPtr p == foreignPtrToPtr q + p == q = unsafeForeignPtrToPtr p == unsafeForeignPtrToPtr q instance Ord (ForeignPtr a) where - compare p q = compare (foreignPtrToPtr p) (foreignPtrToPtr q) + compare p q = compare (unsafeForeignPtrToPtr p) (unsafeForeignPtrToPtr q) instance Show (ForeignPtr a) where - showsPrec p f = showsPrec p (foreignPtrToPtr f) + showsPrec p f = showsPrec p (unsafeForeignPtrToPtr f) #endif @@ -97,7 +98,7 @@ withForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO b -- of the pointer should be inside the -- 'withForeignPtr' bracket. The reason for -- this unsafety is the same as for --- 'foreignPtrToPtr' below: the finalizer +-- '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. @@ -107,14 +108,14 @@ withForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO b -- 'ForeignPtr', using the operations from the -- 'Storable' class. withForeignPtr fo io - = do r <- io (foreignPtrToPtr fo) + = do r <- io (unsafeForeignPtrToPtr fo) touchForeignPtr fo return r #endif /* ! __NHC__ */ -#ifdef __NHC__ --- temporary aliasing until ghc and hugs catch up -foreignPtrToPtr = unsafeForeignPtrToPtr +#ifdef __HUGS__ +-- temporary aliasing until hugs catches up +unsafeForeignPtrToPtr = foreignPtrToPtr #endif #ifdef __HUGS__ diff --git a/GHC/ForeignPtr.hs b/GHC/ForeignPtr.hs index 6b19970..07c201a 100644 --- a/GHC/ForeignPtr.hs +++ b/GHC/ForeignPtr.hs @@ -18,11 +18,12 @@ module GHC.ForeignPtr ForeignPtr(..), FinalizerPtr, newForeignPtr, + newForeignPtr_, mallocForeignPtr, mallocForeignPtrBytes, addForeignPtrFinalizer, touchForeignPtr, - foreignPtrToPtr, + unsafeForeignPtrToPtr, castForeignPtr, newConcForeignPtr, addForeignPtrConcFinalizer, @@ -61,13 +62,13 @@ data ForeignPtr a | MallocPtr (MutableByteArray# RealWorld) !(IORef [IO ()]) instance Eq (ForeignPtr a) where - p == q = foreignPtrToPtr p == foreignPtrToPtr q + p == q = unsafeForeignPtrToPtr p == unsafeForeignPtrToPtr q instance Ord (ForeignPtr a) where - compare p q = compare (foreignPtrToPtr p) (foreignPtrToPtr q) + compare p q = compare (unsafeForeignPtrToPtr p) (unsafeForeignPtrToPtr q) instance Show (ForeignPtr a) where - showsPrec p f = showsPrec p (foreignPtrToPtr f) + showsPrec p f = showsPrec p (unsafeForeignPtrToPtr f) #include "Dynamic.h" INSTANCE_TYPEABLE1(ForeignPtr,foreignPtrTc,"ForeignPtr") @@ -79,15 +80,15 @@ INSTANCE_TYPEABLE1(ForeignPtr,foreignPtrTc,"ForeignPtr") type FinalizerPtr a = FunPtr (Ptr a -> IO ()) newForeignPtr :: Ptr a -> FinalizerPtr a -> IO (ForeignPtr a) --- ^Turns a plain memory reference into a foreign object by --- associating a finaliser with the reference. The finaliser will be executed +-- ^Turns a plain memory reference into a foreign pointer, and +-- associates a finaliser with the reference. The finaliser will be executed -- after the last reference to the foreign object is dropped. Note that there -- is no guarantee on how soon the finaliser is executed after the last -- reference was dropped; this depends on the details of the Haskell storage -- manager. The only guarantee is that the finaliser runs before the program -- terminates. newForeignPtr p finalizer - = do fObj <- mkForeignPtr p + = do fObj <- newForeignPtr_ p addForeignPtrFinalizer fObj finalizer return fObj @@ -105,7 +106,7 @@ newConcForeignPtr :: Ptr a -> IO () -> IO (ForeignPtr a) -- The finalizer, when invoked, will run in a separate thread. -- newConcForeignPtr p finalizer - = do fObj <- mkForeignPtr p + = do fObj <- newForeignPtr_ p addForeignPtrConcFinalizer fObj finalizer return fObj @@ -146,7 +147,7 @@ addForeignPtrFinalizer :: ForeignPtr a -> FinalizerPtr a -> IO () -- object which have already been registered. addForeignPtrFinalizer fptr finalizer = addForeignPtrConcFinalizer fptr - (mkFinalizer finalizer (foreignPtrToPtr fptr)) + (mkFinalizer finalizer (unsafeForeignPtrToPtr fptr)) addForeignPtrConcFinalizer :: ForeignPtr a -> IO () -> IO () -- ^This function adds a finaliser to the given @ForeignPtr@. The @@ -162,7 +163,7 @@ addForeignPtrConcFinalizer f@(ForeignPtr fo r) finalizer = do writeIORef r (finalizer : fs) if (null fs) then IO $ \s -> - let p = foreignPtrToPtr f in + let p = unsafeForeignPtrToPtr f in case mkWeak# fo () (foreignPtrFinalizer r p) s of (# s1, w #) -> (# s1, () #) else return () @@ -171,7 +172,7 @@ addForeignPtrConcFinalizer f@(MallocPtr fo r) finalizer = do writeIORef r (finalizer : fs) if (null fs) then IO $ \s -> - let p = foreignPtrToPtr f in + let p = unsafeForeignPtrToPtr f in case mkWeak# fo () (foreignPtrFinalizer r p) s of (# s1, w #) -> (# s1, () #) else return () @@ -184,8 +185,10 @@ foreignPtrFinalizer r p = do fs <- readIORef r sequence_ fs -mkForeignPtr :: Ptr a -> IO (ForeignPtr a) {- not exported -} -mkForeignPtr (Ptr obj) = do +newForeignPtr_ :: Ptr a -> IO (ForeignPtr a) +-- ^Turns a plain memory reference into a foreign pointer that may be +-- associated with finalizers by using 'addForeignPtrFinalizer'. +newForeignPtr_ (Ptr obj) = do r <- newIORef [] IO $ \ s# -> case mkForeignObj# obj s# of @@ -215,10 +218,10 @@ touchForeignPtr (ForeignPtr fo r) touchForeignPtr (MallocPtr fo r) = IO $ \s -> case touch# fo s of s -> (# s, () #) -foreignPtrToPtr :: ForeignPtr a -> Ptr a +unsafeForeignPtrToPtr :: ForeignPtr a -> Ptr a -- ^This function extracts the pointer component of a foreign -- pointer. This is a potentially dangerous operations, as if the --- argument to 'foreignPtrToPtr' is the last usage +-- argument to 'unsafeForeignPtrToPtr' is the last usage -- occurence of the given foreign pointer, then its finaliser(s) will -- be run, which potentially invalidates the plain pointer just -- obtained. Hence, 'touchForeignPtr' must be used @@ -227,11 +230,11 @@ foreignPtrToPtr :: ForeignPtr a -> Ptr a -- -- To avoid subtle coding errors, hand written marshalling code -- should preferably use 'withForeignPtr' rather --- than combinations of 'foreignPtrToPtr' and +-- than combinations of 'unsafeForeignPtrToPtr' and -- 'touchForeignPtr'. However, the later routines -- are occasionally preferred in tool generated marshalling code. -foreignPtrToPtr (ForeignPtr fo r) = Ptr (foreignObjToAddr# fo) -foreignPtrToPtr (MallocPtr fo r) = Ptr (byteArrayContents# (unsafeCoerce# fo)) +unsafeForeignPtrToPtr (ForeignPtr fo r) = Ptr (foreignObjToAddr# fo) +unsafeForeignPtrToPtr (MallocPtr fo r) = Ptr (byteArrayContents# (unsafeCoerce# fo)) castForeignPtr :: ForeignPtr a -> ForeignPtr b -- ^This function casts a 'ForeignPtr' -- 1.7.10.4