anchor.diff:    (let ((fun (car msg))
           (chan (cdr msg))
           (condition))
  -    (handler-bind ((sdl-abort-pass
  -                     (lambda (c)
  -                       (declare (ignore c))
  -                       (when chan (sendmsg chan condition))))
  -                   (sdl-abort
  +    (handler-bind ((sdl-abort
                        (lambda (c)
                          (declare (ignore c))
                          (when chan (sendmsg chan nil))
  +                       (return-from handle-message)))
  +                   (sdl-quit
  +                     (lambda (c)
  +                       (declare (ignore c))
  +                       (quit)
                          (return-from handle-message))))
         (handler-bind ((error (lambda (e) (setf condition e))))
           (if chan
  
positive.code:                                 (signal 'sdl-abort))
                                :report-function
                                (lambda (stream)
                                  (format stream "Abort the call, ignoring the error.")))
                         (abort-pass (lambda (&optional v)
                                       (declare (ignore v))
                                       (signal 'sdl-abort-pass))
                                     :report-function
                                     (lambda (stream)
                                       (format stream "Abort the call, passing the error back to the caller"))))
            (recv-and-handle-message))))))
  
  (defun ensure-main-channel ()
  
negative.code:                (format s "SDL Error (~A): ~A" code string)))))
  
  (define-condition sdl-abort (condition) ())
  (define-condition sdl-quit (condition) ())
  
  (defun sdl-collect (wrapped-ptr &optional (free-fun #'foreign-free))
    (let ((ptr (autowrap:ptr wrapped-ptr)))
  