anchor.diff:  (defun map-applicable-translators (func
   				   presentation input-context frame window x y
   				   &key event (modifier-state 0) for-menu)
  -  (loop for context in input-context
  -	for (context-ptype) = context
  -	do (map-over-presentations-containing-position
  -	    #'(lambda (p)
  -		(let ((maybe-translators
  -		       (find-presentation-translators (presentation-type p)
  -						      context-ptype
  -						      (frame-command-table
  -						       frame))))
  -		  (loop for translator in maybe-translators
  -			if (test-presentation-translator translator
  -							 p
  -							 context-ptype
  -							 frame
  -							 window
  -							 x y
  -							 :event event
  -							 :modifier-state
  -							 modifier-state
  -							 :for-menu for-menu)
  -			do (funcall func translator p context))))
  -	    presentation
  -	    x y)))
  +  (let ((found nil))
  +    (flet ((process-presentation (context context-ptype presentation)
  +             (let ((maybe-translators
  +                    (find-presentation-translators (presentation-type presentation)
  +                                                   context-ptype
  +                                                   (frame-command-table
  +                                                    frame))))
  +               (loop for translator in maybe-translators
  +                     when (test-presentation-translator translator
  +                                                        presentation
  +                                                        context-ptype
  +                                                        frame
  +                                                        window
  +                                                        x y
  +                                                        :event event
  +                                                        :modifier-state
  +                                                        modifier-state
  +                                                        :for-menu for-menu)
  +                     do (funcall func translator presentation context)
  +                        (setq found t)))))
  +      (loop for context in input-context
  +            for (context-ptype) = context
  +            do (map-over-presentations-containing-position
  +                #'(lambda (p)
  +                    (process-presentation context context-ptype p))
  +                presentation
  +                x y)
  +            finally (unless found
  +                      (loop for context in input-context
  +                            for (context-ptype) = context
  +                            do (process-presentation context
  +                                                     context-ptype
  +                                                     *null-presentation*)))))))
   
   (defun find-applicable-translators
       (presentation input-context frame window x y
  
positive.code:   (:documentation "The specializer to use for this type in a presentation
  method lambda list"))
  
  ;;; Metaclass for presentation types.  For presentation types not associated 
  ;;; with CLOS classes, objects with this metaclass are used as a proxy for the
  ;;; type during presentation method dispatch.  
  
  (eval-when (:compile-toplevel :load-toplevel :execute)
    (defclass presentation-type ()
  
negative.code: 	(result-size nil))
      (map-applicable-translators
       #'(lambda (translator presentation context)
           (if (and result-context (not (eq result-context context)))
  	     ;; Return inner presentation
  	     (return-from find-innermost-presentation-match
  	       (values result result-translator result-context))
  