anchor.diff:         (funcall (command-executor command-processor)
                   command-processor command)))))
   
  +(defmethod process-gestures-or-command :around ((command-processor command-processor))
  +  (handler-case (call-next-method)
  +    (abort-gesture (c)
  +      ;; If the user aborts, we want to forget whatever previous
  +      ;; gestures he entered since the last command execution.
  +      (setf (accumulated-gestures command-processor) nil)
  +      (signal c))))
  +
   (defmethod process-gestures-or-command ((command-processor command-processor))
     ;; Build up a list of gestures and repeatedly pass them to
     ;; `process-gestures'. This "clumsy" approach is chosen because we
  
positive.code:      do (process-gesture drei gesture)
       finally (setf (executingp drei) nil)))
  
  (defclass macrorecord-processed-gestures-mixin ()
    ()
    (:documentation "Subclasses of this class will perform gesture
  recording for macro recording when the gesture is being
  processed. This is important when gesture reading does not go
  through `esa-read-gesture', for example when the command
  processor is being in an event-handling context."))
  
  (defmethod process-gesture :before ((command-processor macrorecord-processed-gestures-mixin) gesture)
    (when (and (recordingp command-processor)
               (directly-processing-p command-processor))
      (push gesture (recorded-keys command-processor))))
  
  (defclass asynchronous-command-processor (command-processor
                                            instant-macro-execution-mixin
                                            macrorecord-processed-gestures-mixin)
  
negative.code:   (loop
       for gesture = (read-gesture :stream stream)
       until (proper-gesture-p gesture)
       finally (return gesture)))
  
  (defun esa-unread-gesture (gesture &key (command-processor *command-processor*)
                             (stream *standard-input*))
    (cond ((recordingp command-processor)
           (cond ((equal (first (recorded-keys command-processor)) gesture)
                  (pop (recorded-keys command-processor)))
                 ((equal (first (accumulated-gestures command-processor)) gesture)
                  (pop (accumulated-gestures command-processor))))
  	 (unread-gesture gesture :stream stream))
  	((executingp command-processor)
  	 (push gesture (remaining-keys command-processor)))
  