GHC/Weak.lhs

   1 % ------------------------------------------------------------------------------
   2 % $Id: Weak.lhs,v 1.2 2001/07/03 14:13:32 simonmar Exp $
   3 %
   4 % (c) The University of Glasgow, 1998-2000
   5 %
   6
   7 \section[GHC.Weak]{Module @GHC.Weak@}
   8
   9 \begin{code}
  10 {-# OPTIONS -fno-implicit-prelude #-}
  11
  12 module GHC.Weak where
  13
  14 import GHC.Prim
  15 import GHC.Base
  16 import Data.Maybe
  17 import GHC.IOBase       ( IO(..), unIO )
  18
  19 data Weak v = Weak (Weak# v)
  20
  21 mkWeak  :: k                            -- key
  22         -> v                            -- value
  23         -> Maybe (IO ())                -- finalizer
  24         -> IO (Weak v)                  -- weak pointer
  25
  26 mkWeak key val (Just finalizer) = IO $ \s ->
  27    case mkWeak# key val finalizer s of { (# s1, w #) -> (# s1, Weak w #) }
  28 mkWeak key val Nothing = IO $ \s ->
  29    case mkWeak# key val (unsafeCoerce# 0#) s of { (# s1, w #) -> (# s1, Weak w #) }
  30
  31 mkWeakPtr :: k -> Maybe (IO ()) -> IO (Weak k)
  32 mkWeakPtr key finalizer = mkWeak key key finalizer
  33
  34 addFinalizer :: key -> IO () -> IO ()
  35 addFinalizer key finalizer = do
  36    mkWeakPtr key (Just finalizer)       -- throw it away
  37    return ()
  38
  39 {-
  40 Instance Eq (Weak v) where
  41   (Weak w1) == (Weak w2) = w1 `sameWeak#` w2
  42 -}
  43
  44
  45 -- run a batch of finalizers from the garbage collector.  We're given
  46 -- an array of finalizers and the length of the array, and we just
  47 -- call each one in turn.
  48 --
  49 -- the IO primitives are inlined by hand here to get the optimal
  50 -- code (sigh) --SDM.
  51
  52 runFinalizerBatch :: Int -> Array# (IO ()) -> IO ()
  53 runFinalizerBatch (I# n) arr =
  54    let  go m  = IO $ \s ->
  55                   case m of
  56                   0# -> (# s, () #)
  57                   _  -> let m' = m -# 1# in
  58                         case indexArray# arr m' of { (# io #) ->
  59                         case unIO io s of          { (# s, _ #) ->
  60                         unIO (go m') s
  61                         }}
  62    in
  63         go n
  64
  65 \end{code}