anchor.diff:  (defvar *null-listener*
     (make-null-listener
      :predicate (lambda (_ _1 _2)
  -		(declare (ignore _ _1 _2))
  -		(error "skitter bug: null listener fired"))))
  +                (declare (ignore _ _1 _2))
  +                (error "skitter bug: null listener fired"))))
   
   ;;----------------------------------------------------------------------
   
  
positive.code:              (propagate ,this timestamp tpref))
             nil))
         (defmethod stop-listening ((listener ,name))
  	 ,@(loop :for s :in source-slots :collect
  	      `(remove-listener listener (,s listener)))
  	 (setf (predicate-source-predicate listener) #'source-is-unregistered
  	       (event-source-listeners listener) nil
  	       ,@(loop :for s :in source-slots :append
  		    `((,s listener) nil)))))))
  
  (defun source-is-unregistered (_ _1 _2)
    (declare (ignore _ _1 _2))
    (error "Skitter: This predicate-source is not registered to anything"))
  
  (defmethod listen-to ((listener predicate-source) (input predicate-source)
  		      &optional slot-name)
    (assert (null slot-name))
    (vector-push-extend listener (event-source-listeners input))
    (values listener input))
  
  (defmethod remove-listener ((listener predicate-source)
  			    (input predicate-source))
    (shifting-remove (event-source-listeners input) listener *null-listener*)
    nil)
  
  
negative.code: (defmacro defcombo (name (event-var &rest sources) slots &body body)
    (assert (string= (first sources) :&source))
    (let* ((slots (append `((%step 0 fixnum)
                            (%last-event-time 0 fixnum)
                            (%last-step-time 0 fixnum))
                          slots))
           (raw-sources sources)
           (sources (mapcar (lambda (x)
                              `(,(first x) ,(second x)
                                 ,@(when (third x)
                                         (list (intern (symbol-name (third x))
                                                       :keyword)))))
                            (cdr sources)))
           (top (gensym "top"))
           (reset-harder (gensym "reset-harder")))
      `(def-predicate-source ,name (,event-var ,@raw-sources) ,slots
         (macrolet ((resetting-when (predicate-form &body body)
                      `(if ,predicate-form
                           (progn ,@body)
                           (reset)))
                    ,@(loop :for (name kind slot) :in sources :append
                         (let* ((acc (intern (format nil "~a-~a" kind slot)
                                             (symbol-package kind)))
                                (pred
                                 `(eq (event-source-container-slot ,event-var)
                                      ',acc)))
                           `((,name (&optional index)
                                    (if index
                                        `(,',acc ,',kind index)
                                        `(,',acc ,',kind)))
                             (,(intern (format nil "~s-P" name)
                                       (symbol-package name))
                               (&optional index)
                               (if index
                                   (list 'and ',pred
                                         (list '= '(event-source-container-index
                                                    ,event-var)
                                               index))
                                   ',pred))))))
           (let ((%time (get-internal-real-time))
                 (,reset-harder nil))
             (block ,top
               (labels ((reset ()
                          (if ,reset-harder
                              (reset-hard)
                              (progn
                                (setf %step 0)
                                (setf ,reset-harder t)
                                (return-from ,top (body ,event-var)))))
                        (reset-hard ()
                          (setf %step 0)
                          (return-from ,top))
                        (before (offset)
                          (< (- %time %last-step-time) offset))
                        (after (offset)
                          (> (- %time %last-step-time) offset))
                        (between (start-offset end-offset)
                          (and (after start-offset) (before end-offset)))
                        (body (,event-var)
                          (case= %step
                            ,@(loop for b in body for i from 0 collect
                                   `(,i ,b)))))
                 (declare (ignorable #'reset #'reset-hard #'before
                                     #'after #'between))
                 (let ((result (body ,event-var)))
                   (setf %last-event-time %time)
                   (when result
                     (setf %last-step-time %time)
                     (if (= %step ,(length body))
                         (progn (setf %step 0) t)
                         (progn (incf %step 1) nil)))))))))))
  
  ;;----------------------------------------------------------------------
  
  (deftclass (event-listener (:include predicate-source)
                             (:constructor %make-event-listener))
    (subject nil)
    (callback (error "skitter: event-listener must be created with a callback")
              :type function))
  
  (defun make-event-listener (callback)
    (%make-event-listener :predicate #'%event-listener-body
                          :callback callback))
  
  (defun %event-listener-body (this evt timestamp tpref)
    (funcall (event-listener-callback this) evt timestamp tpref))
  