(defparameter *test* :hello)

(declaim (optimize (debug 3)))

(defun custom-print-backtrace (stream)
  (let ((sb-debug:*debug-print-variable-alist*
          (if nil
              (list* '(*print-level* . nil)
		             '(*print-length* . nil)
		             sb-debug:*debug-print-variable-alist*)
              nil)))
    (sb-debug:print-backtrace :count most-positive-fixnum :stream stream)))

(defun g4 ()
  (custom-print-backtrace t))

(defun g3 ()
  (g4))

(defun g2 ()
  (let ((*test* :hi))
    (g3)))

(defun g1 ()
  (g2))

(defun e4 ()
  (error "Hello"))

(defun e3 ()
  (e4))

(defun e2 ()
  (e3))

(defun e1 ()
  (e2))

;;; Handles the error but captures the wrong backtrace because the transfer of
;;; control happens *before* the call to G1.

(defun f1 ()
  (handler-case (e1)
    (error () (g1))))

;;; Captures the correct backtrace but doesn't handle the error.

(defun f2 ()
  (handler-bind ((error (lambda (c)
                          (declare (ignore c))
                          (g1))))
    (e1)))

;;; Does everything right. :-)

(defun f3 ()
  (block get-me-out
    (handler-bind ((error (lambda (c)
                            (declare (ignore c))
                            (g1)
                            (return-from get-me-out))))
      (e1))))