package base

Raised when finalization after an exception failed, too. The first exception argument is the one raised by the initial function, the second exception the one raised by the finalizer.

create_s sexp returns an exception t such that phys_equal (sexp_of_t t) sexp. This is useful when one wants to create an exception that serves as a message and the particular exn constructor doesn't matter.

Same as raise, except that the backtrace is not recorded.

Types with format4 are hard to read, so here's an example.

let foobar str =
  try
    ...
  with exn ->
    Exn.reraisef exn "Foobar is buggy on: %s" str ()

human-readable, multi-lines

machine format, single-line

Executes f and afterwards executes finally, whether f throws an exception or not.

handle_uncaught ~exit f catches an exception escaping f and prints an error message to stderr. Exits with return code 1 if exit is true. Otherwise returns unit.

Note that since OCaml 4.02.0, it is not needed to use this at the entry point of your program as the OCaml runtime will do better than this function.

handle_uncaught_and_exit f returns f (), unless that raises, in which case it prints the exception and exits nonzero.

Traces exceptions passing through. Useful because in practice backtraces still don't seem to work.

Example:

let rogue_function () = if Random.bool () then failwith "foo" else 3
let traced_function () = Exn.reraise_uncaught "rogue_function" rogue_function
                           traced_function ();;

: Program died with Reraised("rogue_function", Failure "foo")

does_raise f returns true iff f () raises, which is often useful in unit tests.

User code never calls this. It is called in std_kernel.ml, as a top-level side effect, to change the display of exceptions and install an uncaught-exception printer.