ghc/lib/std/PrelException.lhs

   1 % -----------------------------------------------------------------------------
   2 % $Id: PrelException.lhs,v 1.2 1998/12/02 13:27:01 simonm Exp $
   3 %
   4 % (c) The GRAP/AQUA Project, Glasgow University, 1998
   5 %
   6
   7 Exceptions and exception-handling functions.
   8
   9 \begin{code}
  10 {-# OPTIONS -fno-implicit-prelude #-}
  11
  12 #ifndef __HUGS__
  13 module PrelException where
  14
  15 import PrelBase
  16 import PrelIOBase
  17 import PrelST           ( STret(..) )
  18 import PrelDynamic
  19 import PrelGHC
  20 #endif
  21 \end{code}
  22
  23 -----------------------------------------------------------------------------
  24 Exception datatype and operations.
  25
  26 \begin{code}
  27 data Exception
  28   = IOException         IOError         -- IO exceptions (from 'fail')
  29   | ArithException      ArithError      -- Arithmetic exceptions
  30   | ErrorCall           String          -- Calls to 'error'
  31   | NoMethodError       String          -- A non-existent method was invoked
  32   | PatternMatchFail    String          -- A pattern match failed
  33   | NonExhaustiveGuards String          -- A guard match failed
  34   | RecSelError         String          -- Selecting a non-existent field
  35   | RecConError         String          -- Field missing in record construction
  36   | RecUpdError         String          -- Record doesn't contain updated field
  37   | AssertionFailed     String          -- Assertions
  38   | DynException        Dynamic         -- Dynamic exceptions
  39   | ExternalException   ExtError        -- External exceptions
  40
  41 data ArithError
  42   = Overflow
  43   | Underflow
  44   | LossOfPrecision
  45   | DivideByZero
  46   | Denormal
  47   deriving (Eq, Ord)
  48
  49 data ExtError
  50   = StackOverflow
  51   | HeapOverflow
  52   | ThreadKilled
  53   deriving (Eq, Ord)
  54
  55 instance Show ArithError where
  56   showsPrec _ Overflow        = showString "arithmetic overflow"
  57   showsPrec _ Underflow       = showString "arithmetic underflow"
  58   showsPrec _ LossOfPrecision = showString "loss of precision"
  59   showsPrec _ DivideByZero    = showString "divide by zero"
  60   showsPrec _ Denormal        = showString "denormal"
  61
  62 instance Show ExtError where
  63   showsPrec _ StackOverflow   = showString "stack overflow"
  64   showsPrec _ HeapOverflow    = showString "heap overflow"
  65   showsPrec _ ThreadKilled    = showString "thread killed"
  66
  67 instance Show Exception where
  68   showsPrec _ (IOException err)          = shows err
  69   showsPrec _ (ArithException err)       = shows err
  70   showsPrec _ (ErrorCall err)            = showString err
  71   showsPrec _ (NoMethodError err)        = showString err
  72   showsPrec _ (PatternMatchFail err)     = showString err
  73   showsPrec _ (NonExhaustiveGuards err)  = showString err
  74   showsPrec _ (RecSelError err)          = showString err
  75   showsPrec _ (RecConError err)          = showString err
  76   showsPrec _ (RecUpdError err)          = showString err
  77   showsPrec _ (AssertionFailed err)      = showString err
  78   showsPrec _ (DynException err)         = showString "unknown exception"
  79
  80 -- Primitives:
  81
  82 throw :: Exception -> a
  83
  84 #ifdef __HUGS__
  85 throw = primRaise
  86 #else
  87 throw exception = raise# exception
  88 #endif
  89 \end{code}
  90
  91 catch handles the passing around of the state in the IO monad; if we
  92 don't actually apply (and hence run) an IO computation, we don't get
  93 any exceptions!  Hence a large mantrap to watch out for is
  94
  95         catch# (m :: IO ()) (handler :: NDSet Exception -> IO ())
  96
  97 since the computation 'm' won't actually be performed in the context
  98 of the 'catch#'.  In fact, don't use catch# at all.
  99
 100 \begin{code}
 101 catchException :: IO a -> (Exception -> IO a) -> IO a
 102 #ifdef __HUGS__
 103 catchException m k =  ST (\s -> unST m s `primCatch'` \ err -> unST (k err) s)
 104 #else
 105 catchException m k =  IO $ \s -> case catch# (liftIO m s) (\exs -> liftIO (k exs) s)
 106                           of STret s r -> (# s, r #)
 107 #endif
 108
 109 catch           :: IO a -> (IOError -> IO a) -> IO a
 110 catch m k       =  catchException m handler
 111   where handler (IOException err) = k err
 112         handler other             = throw other
 113 \end{code}
 114
 115 Why is this stuff here?  To avoid recursive module dependencies of
 116 course.
 117
 118 \begin{code}
 119 fail            :: IOError -> IO a
 120 fail err        =  throw (IOException err)
 121 \end{code}
 122