Dear Foreign Function Interface,
why does a program like the following fail with a "<<loop>>" exception (using GHC 6.2 on MacOS X)?
-----snip----- import Foreign
main =
do
f <- mkFinPtr finalizer
fp <- newForeignPtr f nullPtr
putStrLn "Hello World"finalizer ptr = putStrLn ("Finalize "++show ptr++".")foreign import ccall "wrapper"
mkFinPtr :: (Ptr () -> IO ()) -> IO (FinalizerPtr ())
-----snap-----Also, does the use of a "wrapper" import constitute a callback from C in the sense of the following statement?
"Whether a finalizer may call back into the Haskell system is system dependent. Portable code may not rely on such callbacks."
I.e. is the above code non-portable?
Why is the ForeignPtr interface constrained to finalizers that are FunPtrs at all? I want to touch a ForeignPtr from another's finalizer to satisfy a liveness dependency (as suggested in the spec). What is the best way to do this?
Suppose I have:
-----snip----- type Thing = Ptr () type Subthing = Ptr ()
foreign import ccall "new_thing"
newThing :: IO Thing
foreign import ccall "new_subthing"
newSubthing :: Thing -> IO Subthing
-----snap-----I can't do, as I would like:
-----snip-----
foreign import ccall "del_thing"
delThing :: Thing -> IO ()
foreign import ccall "del_subthing"
delSubthing :: Subthing -> IO ()main =
do
p1 <- newThing
p2 <- newSubthing p1
fp1 <- newForeignPtr delThing p1
fp2 <- newForeignPtr (\p -> delSubthing p >> touchForeignPtr fp1) p2
{- ...do more funny things... -}
-----snap-----So because touchForeignPtr is a Haskell function, I must go through a wrapper. It seems strange to me that the Haskell storage manager would not be able to call Haskell routines as finalizers directly...
Assuming that's really the only way to do it, I suppose my code would look like this, correct?
-----snip-----
foreign import ccall "&del_thing"
delThing_p :: FunPtr (Thing -> IO ())
foreign import ccall "del_subthing"
delSubthing :: Subthing -> IO ()
foreign import ccall "wrapper"
mkFinPtr :: (Ptr () -> IO ()) -> FunPtr (Ptr () -> IO ())main =
p1 <- new_thing
p2 <- new_subthing p1
fp1 <- newForeignPtr delThing_p p1
f <- mkFinPtr (\p -> delSubthing p >> touchForeignPtr fp1)
fp2 <- newForeignPtr f p2
{- ...do the funky chicken... -}
-----snap-----
Thanks in advance, Sven Moritz
PS: You're still great! PPS: Do you mind being called fifi? ;-)
_______________________________________________ FFI mailing list [EMAIL PROTECTED] http://www.haskell.org/mailman/listinfo/ffi
