anchor.diff:      :type stream
       :initarg :stream
       :initform (required))
  -   (pending-word
  -    :type (or null string)
  -    :initform nil)
  -   (parts
  -    :type array
  -    :initform (make-extensible-vector))
  +   (end-marked
  +    :type boolean
  +    :initform nil
  +    :reader lexer-context-end-marked-p)
      (readtable
       :type dispatch-table
       :initarg :readtable
       :initform (required)
  -    :reader lexer-context-readtable)
  -   (end-marked
  -    :type boolean
  -    :initform nil
  -    :reader lexer-context-end-marked-p)))
  +    :reader lexer-context-readtable)))
   (defmethod print-object ((lc lexer-context) stream)
  -  (with-slots (pending-word parts) lc
  -    (format stream "#<~A parts ~A pending-word ~A>" (class-name (class-of lc)) parts pending-word)))
  +  (format stream "#<~A>" (class-name (class-of lc))))
   
   (defmethod shared-initialize :around ((instance lexer-context) slots &rest args &key &allow-other-keys)
     (declare (ignore args))
  
positive.code:                ;; character shall be used as the beginning of the next
                 ;; (operator) token.
                 ((operator-p (string (next-char)))
                  (unless (lexer-context-no-content-p context)
                    (delimit))
                  (lexer-context-extend-word context)
                  (again))
  
                 ;; If the current character is an unquoted <newline>, the
                 ;; current token shall be delimited.
                 ((equal #\linefeed (next-char))
                  (when (lexer-context-no-content-p context)
                    (lexer-context-consume-character context)
                    (lexer-context-add-part context +newline+))
                  (delimit))
  
                 ;; If the current character is an unquoted <blank>, any
                 ;; token containing the previous character is delimited
                 ;; and the current character shall be discarded.
                 ((whitespace-p (next-char))
                  (unless (lexer-context-no-content-p context)
                    (delimit))
                  (lexer-context-consume-character context)
                  (again))
  
                 ;; If the previous character was part of a word, the
                 ;; current character shall be appended to that word.
                 ((not (lexer-context-no-content-p context))
                  (lexer-context-extend-word context)
                  (again))
  
                 ;; If the current character is a '#', it and all
  
negative.code:       (return-from handle-extensible-syntax t))
  
      (typecase value
        (string (shell-lexer-context-add-chars context value))
        (token (shell-lexer-context-add-part context value))))
    t)
  
  (defun next-token (stream &key (readtable +standard-shell-readtable+))
    (let* ((context (make-instance 'shell-lexer-context :stream stream :readtable readtable)))
      (labels ((next-char () (lexer-context-next-char context)))
  
        ;; The lexing rules depend on whether the current character
  