anchor.diff:  (defun handle-backtick (stream initiation-sequence context)
     (declare (ignore initiation-sequence))
     (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)))
  +  t)
  +
  +(defun handle-double-quote-backslash-newline (stream initiation-sequence context)
  +  (declare (ignore stream initiation-sequence context))
  +  ;; This never happened.
  +  t)
  +
  +(defun handle-double-quote-termination (stream initiation-sequence context)
  +  (declare (ignore stream initiation-sequence))
  +  (lexer-context-mark-end-of-token context)
  +  t)
  +
  +(defun handle-double-quote-default (stream initiation-sequence context)
  +  (declare (ignore stream initiation-sequence))
  +  (lexer-context-add-chars context (string (lexer-context-consume-character context)))
     t)
   
   (define-once-global +quote-table+
  
positive.code: (defmethod print-object ((double-quote double-quote) stream)
    (format stream "#<~A ~S>" (class-name (class-of double-quote)) (double-quote-parts double-quote)))
  
  (defun read-double-quote (stream)
    (let ((token-value (make-extensible-vector :element-type 'character))
          (parts (make-extensible-vector :element-type 'token))
          (literal-string (make-extensible-vector :element-type 'character))
          (next-char (peek-char nil stream nil :eof)))
      (labels ((keep ()
                 (vector-push-extend next-char literal-string)
                 (skip))
               (skip ()
                 (vector-push-extend next-char token-value)
                 (read-char stream nil :eof)
                 (reset-next-char))
               (reset-next-char ()
                 (setf next-char (peek-char nil stream nil :eof)))
               (take-literal ()
                 (unless (equal 0 (length literal-string))
                   (vector-push-extend literal-string parts)
                   (setf literal-string (make-extensible-vector :element-type 'character)))))
        (loop
           (reset-next-char)
           (cond ((equal :eof next-char)
                  (eof-error :comment "Double quote expected"))
  
                 ((equal #\" next-char)
                  (skip)
                  (take-literal)
                  (return-from read-double-quote (make-instance 'double-quote :parts parts :value token-value)))
  
                 ((equal #\\ next-char)
                  (skip)
                  (if (find next-char '(#\$ #\` #\" #\\ #\Linefeed))
                      (keep)))
  
                 ((equal #\` next-char)
                  (take-literal)
                  (skip)
                  (let* ((backquote (read-backquote stream))
                         (backquote-string (token-value backquote)))
                    (vector-push-extend backquote parts)
                    (loop :for char :across backquote-string
                       :do (vector-push-extend char token-value))))
  
                 ((equal #\$ next-char)
                  (take-literal)
                  (skip)
                  (let* ((dollar (read-dollar stream))
                         (dollar-string (token-value dollar)))
                    (vector-push-extend dollar parts)
                    (loop :for char :across dollar-string
                       :do (vector-push-extend char token-value))))
  
                 (t
                  (keep)))))
      (assert nil nil "This function shouldn't return via this path")))
  
  (defun read-backquote (stream)
    (declare (ignore stream))
  
negative.code: 
     ;; Extensible reading
     #:lexer-context-mark-end-of-token
     #:lexer-context-shell-extensible-read-from-stream #:lexer-context-readtable
     #:lexer-context-stream #:+standard-shell-readtable+))
  (in-package :shcl/core/lexer)
  
  (optimization-settings)
  