, readIORef
, writeIORef
+ , mkWeakIORef
+
, IOArray -- instance of: Eq
, newIOArray
, boundsIOArray
, writeIOArray
, freezeIOArray
, thawIOArray
+#ifndef __HUGS__
+ , unsafeFreezeIOArray
+ , unsafeThawIOArray
+#endif
#ifdef __HUGS__
#else
#endif
, unsafePtrEq
- , unsafeIOToST
+
+ , freeHaskellFunctionPtr
) where
)
import PrelST
import PrelArr
+import PrelWeak
import PrelGHC
import PrelHandle
import PrelErr
import IO ( hPutStr, hPutChar )
+import PrelAddr ( Addr )
#endif
import Ix
readIORef (IORef var) = stToIO (readVar var)
writeIORef (IORef var) v = stToIO (writeVar var v)
#endif
+
+mkWeakIORef :: IORef a -> IO () -> IO (Weak (IORef a))
+mkWeakIORef r@(IORef (MutableVar r#)) f = IO $ \s ->
+ case mkWeak# r# r f s of (# s1, w #) -> (# s1, Weak w #)
\end{code}
\begin{code}
writeIOArray :: Ix ix => IOArray ix elt -> ix -> elt -> IO ()
freezeIOArray :: Ix ix => IOArray ix elt -> IO (Array ix elt)
thawIOArray :: Ix ix => Array ix elt -> IO (IOArray ix elt)
+#ifndef __HUGS__
+unsafeFreezeIOArray :: Ix ix => IOArray ix elt -> IO (Array ix elt)
+unsafeThawIOArray :: Ix ix => Array ix elt -> IO (IOArray ix elt)
+#endif
#ifdef __HUGS__
type IOArray ix elt = STArray RealWorld ix elt
thawIOArray arr = do
marr <- stToIO (thawArray arr)
return (IOArray marr)
+
+unsafeFreezeIOArray (IOArray arr) = stToIO (unsafeFreezeArray arr)
+unsafeThawIOArray arr = do
+ marr <- stToIO (unsafeThawArray arr)
+ return (IOArray marr)
#endif
\end{code}
#endif
\end{code}
-\begin{code}
-unsafeIOToST :: IO a -> ST s a
-#ifdef __HUGS__
-unsafeIOToST = primUnsafeCoerce
-#else
-unsafeIOToST (IO io) = ST $ \ s ->
- case ((unsafeCoerce# io) s) of
- (# new_s, a #) -> unsafeCoerce# (STret new_s a)
--- IOfail new_s e -> error ("I/O Error (unsafeIOToST): " ++ showsPrec 0 e "\n")
-#endif
-\end{code}
-
Not something you want to call normally, but useful
in the cases where you do want to flush stuff out of
the heap or make sure you've got room enough
#endif
\end{code}
+When using 'foreign export dynamic' to dress up a Haskell
+IO action to look like a C function pointer, a little bit
+of memory is allocated (along with a stable pointer to
+the Haskell IO action). When done with the C function
+pointer, you'll need to call @freeHaskellFunctionPtr()@ to
+let go of these resources - here's the Haskell wrapper for
+that RTS entry point, should you want to free it from
+within Haskell.
+
+\begin{code}
+foreign import ccall "freeHaskellFunctionPtr"
+ freeHaskellFunctionPtr :: Addr -> IO ()
+
+\end{code}
+