anchor.diff:    "maps recursively over all presentations in record, including record."
     (map-over-output-records-containing-position
      #'(lambda (child)
  -       (when (output-record-p child)	; ? What else could it be? --moore
  -	 (map-over-presentations-containing-position func child x y))
  +       (when (output-record-p child)    ; ? What else could it be? --moore
  +         (map-over-presentations-containing-position func child x y))
          #+nil
          (when (presentationp child)
  -	 (funcall func child)))
  +         (funcall func child)))
      record
      x y)
     (when (and (presentationp record)
  -	     (presentation-contains-position record x y))
  +             (presentation-contains-position record x y))
       (funcall func record)))
   
   (defvar *null-presentation*)
   
   (defun map-applicable-translators (func
  -				   presentation input-context frame window x y
  -				   &key event (modifier-state 0)
  -					for-menu
  -					button)
  +                                   presentation input-context frame window x y
  +                                   &key event (modifier-state 0)
  +                                        for-menu
  +                                        button)
     (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 (and (or (not for-menu) (eql for-menu (menu translator)))
  -			   (test-presentation-translator translator
  -							 presentation
  -							 context-ptype
  -							 frame
  -							 window
  -							 x y
  -							 :event event
  -							 :modifier-state
  -							 modifier-state
  -							 :for-menu for-menu
  -							 :button button))
  -		 do (funcall func translator presentation context)))))
  +           (let ((maybe-translators
  +                  (find-presentation-translators (presentation-type
  +                                                  presentation)
  +                                                 context-ptype
  +                                                 (frame-command-table
  +                                                  frame))))
  +             (loop for translator in maybe-translators
  +                 when (and (or (not for-menu) (eql for-menu (menu translator)))
  +                           (test-presentation-translator translator
  +                                                         presentation
  +                                                         context-ptype
  +                                                         frame
  +                                                         window
  +                                                         x y
  +                                                         :event event
  +                                                         :modifier-state
  +                                                         modifier-state
  +                                                         :for-menu for-menu
  +                                                         :button button))
  +                 do (funcall func translator presentation context)))))
       (if (and (presentationp presentation)
  -	     (presentation-subtypep (presentation-type presentation) 
  -				    'blank-area))
  -	(loop for context in input-context
  -	      for (context-ptype) = context
  -	      do (process-presentation context context-ptype presentation))
  -	(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)))))
  +             (presentation-subtypep (presentation-type presentation)
  +                                    'blank-area))
  +        (loop for context in input-context
  +              for (context-ptype) = context
  +              do (process-presentation context context-ptype presentation))
  +        (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)))))
   
   (defun window-modifier-state (window)
     "Provides default modifier state for presentation translator functions."
  
positive.code:   (let ((state 'required))
      (loop for arg in ll
         append (cond ((member arg lambda-list-keywords :test #'eq)
  		     (setq state arg)
  		     nil)
  		    ((eq state 'required)
  		     (get-all-params arg))
  		    ((or (eq state '&optional) (eq state '&aux))
  		     (if (atom arg)
  			 (list arg)
  			 (get-all-params (car arg))))
  		    ((eq state '&key)
  		     (cond ((atom arg)
  			    (list arg))
  			   ((atom (car arg))
  			    (list (car arg)))
  			   (t (get-all-params (cadar arg)))))
  		    ((member state '(required &rest &body &whole))
  		     (when (eq state '&whole)
  		       (setq state 'required))
  		     (get-all-params arg))
  		    (t nil)))))
  
  ;;; ...And another.  Given a lambda list, return a form that replicates the
  ;;; structure of the argument with variables filled in.
  
  (defun map-over-lambda-list (function ll
  			     &key (pass-lambda-list-keywords nil))
    (declare (ignore function pass-lambda-list-keywords))
    (unless ll
      (return-from map-over-lambda-list nil))
  
negative.code: 
  ;;; Load-time actions for define-presentation-type
  (defmacro %define-presentation-type (name parameters params-ll
                                       options options-ll
                                       inherit-from inherit-from-lambda
                                       description history parameters-are-types)
    (declare (ignore inherit-from))
    (let* ((inherit-from-func (coerce inherit-from-lambda 'function))
           (inherit-typespec (funcall inherit-from-func
                                      (cons name (fake-params-args params-ll))))
           (superclasses (if inherit-typespec
                             (with-presentation-type-decoded
                                 (super-name super-params)
                               inherit-typespec
                               (if (eq super-name 'and)
                                   (mapcar #'presentation-type-name super-params)
                                   (list super-name)))
                             nil))
           (expansion-lambda (make-expansion-lambda params-ll options-ll)))
      `(progn
         (record-presentation-type ',name ',parameters ',params-ll ',options
                                     ',options-ll #',inherit-from-lambda
                                     ',description ',history
                                     ',parameters-are-types
                                     nil ',superclasses
                                     #',expansion-lambda)
         ,@(cond ((eq (presentation-type-name inherit-typespec) 'and)
                  (loop for super in superclasses
                      for i from 0
                      append (unless (or (not (atom super))
                                         (eq super 'satisfies)
                                         (eq super 'not))
                               `((defmethod massage-type-for-super
                                     ((type-name (eql ',name))
                                      (super-name (eql ',super))
                                      type)
                                   (values (nth ,i
                                                (cdr (,inherit-from-lambda
                                                      type)))
                                           t))))))
                 (superclasses
                  `((defmethod massage-type-for-super
                        ((type-name (eql ',name))
                         (super-name (eql ',(car superclasses)))
                         type)
                      (values (,inherit-from-lambda type) t))))
                 (t nil)))))
  
  (defmacro define-presentation-type (name parameters
                                      &key options inherit-from
                                      (description
                                       (make-default-description name))
                                      (history t)
                                      parameters-are-types)
    (let* ((params-ll (transform-parameters-lambda-list parameters))
           (options-ll (transform-options-lambda-list options))
           (inherit-from-func (make-inherit-from-lambda params-ll
                                                        options-ll
                                                        inherit-from)))
      `(progn
         (eval-when (:compile-toplevel)
           (record-presentation-type ',name ',parameters ',params-ll ',options
                                     ',options-ll #',inherit-from-func
                                     ',description ',history
                                     ',parameters-are-types
                                     t nil nil))
         (eval-when (:load-toplevel :execute)
           (%define-presentation-type ,name ,parameters ,params-ll
                                      ,options ,options-ll
                                      ,inherit-from ,inherit-from-func
                                      ,description ,history
                                      ,parameters-are-types)))))
  
  ;;; These are used by the presentation method MOP code, but are
  ;;; actually defined in presentation-defs.lisp after the forms for these
  