anchor.diff:         (let ((part (make-instance 'variable-expansion-word
                                     :variable name
                                     :value (concatenate 'string "$" name))))
  -         (lexer-context-add-part context part)))
  +         (shell-lexer-context-add-part context part)))
   
         (t
  -       (lexer-context-add-chars context initiation-sequence))))
  +       (shell-lexer-context-add-chars context initiation-sequence))))
     t)
   
   (defun handle-dollar-paren (stream initiation-sequence context)
     (declare (ignore stream initiation-sequence))
  -  (lexer-context-add-part context (read-dollar-paren context))
  +  (shell-lexer-context-add-part context (read-dollar-paren context))
     t)
   
   (defun handle-dollar-paren-paren (stream initiation-sequence context)
     (declare (ignore initiation-sequence))
  -  (lexer-context-add-part context (read-dollar-paren-paren stream))
  +  (shell-lexer-context-add-part context (read-dollar-paren-paren stream))
     t)
   
   (defun handle-backtick (stream initiation-sequence context)
     (declare (ignore initiation-sequence))
  -  (lexer-context-add-part context (read-backquote stream))
  +  (shell-lexer-context-add-part context (read-backquote stream))
     t)
   
   (defun handle-double-quote-backslash (stream initiation-sequence context)
     (declare (ignore stream initiation-sequence))
  -  (lexer-context-add-chars context (string (lexer-context-consume-character context)))
  +  (shell-lexer-context-add-chars context (string (lexer-context-consume-character context)))
     t)
   
   (defun handle-double-quote-backslash-newline (stream initiation-sequence context)
  
positive.code:     (setf stream (make-string-input-stream ""))
      (setf end-marked t)))
  
  (defun lexer-context-delimit (context &key (if-empty :error))
    (unless (or (eq if-empty :error) (eq if-empty nil))
      (error "if-empty arg must be :error or nil"))
  
    (lexer-context-word-boundary context)
    (with-slots (parts all-chars-stream) context
      (let* ((part-count (length parts))
             (simple-word (lexer-context-simple-word context)))
        (cond ((and simple-word
                    (operator-p simple-word))
               (make-operator simple-word (get-output-stream-string all-chars-stream)))
  
negative.code:   (with-slots (stream) context
      (read-char stream nil :eof)))
  
  (defun shell-lexer-context-add-chars (context chars)
    (shell-lexer-context-add-pending-word context)
    (with-slots (pending-word) context
      (loop :for char :across chars :do
         (vector-push-extend char pending-word))))
  
  (defun shell-lexer-context-extend-word (context)
    (shell-lexer-context-add-chars context (string (lexer-context-next-char context)))
    (lexer-context-consume-character context))
  
  (defun shell-lexer-context-word-boundary (context)
    (with-slots (parts pending-word) context
      (when pending-word
        (vector-push-extend (make-instance 'simple-word :text pending-word) parts)
        (setf pending-word nil))))
  
  (defun shell-lexer-context-add-part (context part)
    (shell-lexer-context-word-boundary context)
    (with-slots (parts) context
      (vector-push-extend part parts)))
  
  (defun shell-lexer-context-simple-word (context)
    (with-slots (parts pending-word) context
      (cond
        ((equal 0 (length parts))
  