anchor.diff:  (defmethod character-gesture-name ((name symbol))
     (let ((entry (car (gethash name *gesture-names*))))
       (if entry
  -	(destructuring-bind (type device-name modifier-state)
  -	    entry
  -	  (if (and (eq type :keyboard)
  -		   (eql modifier-state 0))
  -	      device-name
  -	      nil))
  -	nil)))
  +        (destructuring-bind (type device-name modifier-state)
  +            entry
  +          (if (and (eq type :keyboard)
  +                   (eql modifier-state 0))
  +              device-name
  +              nil))
  +        nil)))
   
   (defgeneric %event-matches-gesture (event type device-name modifier-state))
   
  
positive.code: (defun invoke-condition-restart (c)
    (let ((restarts (compute-restarts c)))
      (loop for i from 0
  	  for restart in restarts
  	  do (format t "~&~D: ~A~%" i restart))
      (loop with n = nil
  	  and k = (length restarts)
  	  until (and (integerp n) (>= n 0) (< n k))
  	  do (progn
  	       (format t "~&Option: ")
  	       (setq n (read))
  	       (fresh-line))
  	  finally
  	  #-cmu (invoke-restart (nth n restarts))
  	  #+cmu (funcall (conditions::restart-function (nth n restarts))))))
  
  (defmacro catch-abort-gestures (format-args &body body)
    `(restart-case
         (handler-bind ((abort-gesture #'invoke-condition-restart))
  	 ,@body)
       (nil ()
         :report (lambda (s) (format s ,@format-args))
         :test (lambda (c) (typep c 'abort-gesture))
  
negative.code: 
  (eval-when (:compile-toplevel :load-toplevel :execute)
    (defvar *string-input-stream-class* (with-input-from-string (s "foo")
                                          (class-name (class-of s)))))
  
  (defmethod stream-read-gesture ((stream #.*string-input-stream-class*)
                                  &key peek-p
                                  &allow-other-keys)
    (let ((char (if peek-p
                    (peek-char nil stream nil nil)
                    (read-char stream nil nil))))
      (if char
          char
          (values nil :eof))))
  
  (defmethod stream-unread-gesture ((stream #.*string-input-stream-class*)
                                    gesture)
    (unread-char gesture stream))
  
  ;;; Gestures
  