anchor.diff:                 ;; character shall be used as the beginning of the next
                  ;; (operator) token.
                  ((operator-p (string (next-char)))
  -                (unless (lexer-context-no-content-p context)
  +                (unless (shell-lexer-context-no-content-p context)
                     (delimit))
  -                (lexer-context-extend-word context)
  +                (shell-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)
  +                (when (shell-lexer-context-no-content-p context)
                     (lexer-context-consume-character context)
  -                  (lexer-context-add-part context +newline+))
  +                  (shell-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)
  +                (unless (shell-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)
  +               ((not (shell-lexer-context-no-content-p context))
  +                (shell-lexer-context-extend-word context)
                   (again))
   
                  ;; If the current character is a '#', it and all
  
positive.code:       result)))
  
  (defun lexer-context-shell-extensible-read-from-stream (stream readtable)
    (let ((c (make-instance 'lexer-context :stream stream :readtable readtable)))
      (lexer-context-shell-extensible-read c)))
  
  (defun handle-extensible-syntax (context)
  
negative.code:                ;; the current characters to form an operator, the
                 ;; operator containing the previous character shall be
                 ;; delimited.
                 ((let ((simple-word (shell-lexer-context-simple-word context)))
                    (and simple-word
                         (operator-p simple-word)
                         (not (operator-p (concatenate 'string simple-word (string (next-char)))))))
  