anchor.diff:  				    &key)
     (let* ((object nil)
   	 (ptype nil))
  -    (if (and #-openmcl nil subform-read)
  -	(multiple-value-bind (val valid)
  -	    (funcall *sys-%read-list-expression* stream *dot-ok* *termch*)
  -	  (if valid
  -	      (setq object val)
  -	      (return-from accept (values nil 'list-terminator))))
  -	;; We don't want activation gestures like :return causing an eof
  -	;; while reading a form. Also, we don't want spaces within forms or
  -	;; strings causing a premature return either!
  -	;; XXX This loses when rescanning (possibly in other contexts too) an
  -	;; activated input buffer (e.g., reading an expression from the accept
  -	;; method for OR where the previous readers have already given
  -	;; up). We should call *sys-read-preserving-whitespace* and handle the
  -	;; munching of whitespace ourselves according to the
  -	;; PRESERVE-WHITESPACE parameter. Fix after .9.2.2.
  -	(with-delimiter-gestures (nil :override t)
  -	  (with-activation-gestures (nil :override t)
  -	    (setq object (funcall (if preserve-whitespace
  -				      *sys-read-preserving-whitespace*
  -				      *sys-read*)
  -				  stream
  -				  *eof-error-p* *eof-value* *recursivep*)))))
  +    #.(funcall (if #+openmcl t #-openmcl nil #'identity #'fourth)
  +               `(if subform-read
  +                    (multiple-value-bind (val valid)
  +                        (funcall *sys-%read-list-expression* stream *dot-ok* *termch*)
  +                      (if valid
  +                          (setq object val)
  +                          (return-from accept (values nil 'list-terminator))))
  +                    ;; We don't want activation gestures like :return causing an eof
  +                    ;; while reading a form. Also, we don't want spaces within forms or
  +                    ;; strings causing a premature return either!
  +                    ;; XXX This loses when rescanning (possibly in other contexts too) an
  +                    ;; activated input buffer (e.g., reading an expression from the accept
  +                    ;; method for OR where the previous readers have already given
  +                    ;; up). We should call *sys-read-preserving-whitespace* and handle the
  +                    ;; munching of whitespace ourselves according to the
  +                    ;; PRESERVE-WHITESPACE parameter. Fix after .9.2.2.
  +                    (with-delimiter-gestures (nil :override t)
  +                      (with-activation-gestures (nil :override t)
  +                        (setq object (funcall (if preserve-whitespace
  +                                                  *sys-read-preserving-whitespace*
  +                                                  *sys-read*)
  +                                              stream
  +                                              *eof-error-p* *eof-value* *recursivep*))))))
       (setq ptype (presentation-type-of object))
       (unless (presentation-subtypep ptype 'expression)
         (setq ptype 'expression))
  
positive.code: 	   for c = (read-char stream)
  	   until (or (activation-gesture-p c) (delimiter-gesture-p c))
  	   finally
  	     (when (delimiter-gesture-p c)
  	       (unread-char c stream))
  	     (return (values object ptype))))))
  
  
  (with-system-redefinition-allowed
  
negative.code:                                     (stream input-editing-stream)
                                      (view textual-view)
  				    &key)
    ;; This method is specialized to
    ;; input-editing-streams and has thus been
    ;; made slightly more tolerant of input
    ;; errors. It is slightly hacky, but seems
    ;; to work fine.
    (let* ((object nil)
  	 (ptype nil))
      #.(funcall (if #+openmcl t #-openmcl nil #'identity #'fourth)
                 `(if (and #-openmcl nil subform-read)
                      (multiple-value-bind (val valid)
                          (funcall *sys-%read-list-expression* stream *dot-ok* *termch*)
                        (if valid
                            (setq object val)
                            (return-from accept (values nil 'list-terminator))))
                      ;; We don't want activation gestures like :return causing an
                      ;; eof while reading a form. Also, we don't want spaces within
                      ;; forms or strings causing a premature return either!
                      (with-delimiter-gestures (nil :override t)
                        (with-activation-gestures (nil :override t)
                          (setq object
                                ;; We loop in our accept of user input, if a reader
                                ;; error is signalled, we merely ignore it and ask
                                ;; for more input. This is so a single malplaced #\(
                                ;; or #\, won't throw up a debugger with a
                                ;; READER-ERROR and remove whatever the user wrote
                                ;; to the stream.
                                (loop for potential-object =
                                     (handler-case (funcall
                                                    (if preserve-whitespace
                                                        *sys-read-preserving-whitespace*
                                                        *sys-read*)
                                                    stream
                                                    *eof-error-p*
                                                    *eof-value*
                                                    *recursivep*)
                                       ((and reader-error) (e)
                                         (declare (ignore e))
                                         nil))
                                     unless (null potential-object)
                                     return potential-object))))))
      (setq ptype (presentation-type-of object))
      (unless (presentation-subtypep ptype 'expression)
        (setq ptype 'expression))
  