anchor.diff:  	   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))))))
  +           (when (delimiter-gesture-p c)
  +             (unread-char c stream))
  +           (return (values object ptype))))))
   
   
   (with-system-redefinition-allowed
  
positive.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))
      (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))
  
negative.code: 				    &key)
    (let* ((object nil)
  	 (ptype nil))
      #.(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))
  