anchor.diff:  (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-double-quote (context)
  +  (let* ((stream (lexer-context-stream context))
  +         (readtable (subtable (lexer-context-readtable context) #(double-quote)))
  +         (inner-context
  +          (make-instance 'lexer-context :stream stream :readtable (lexer-context-readtable context))))
  +    (loop
  +       :while (not (lexer-context-end-marked-p inner-context)) :do
  +       (if (eq :eof (lexer-context-next-char inner-context))
  +           (error "EOF while reading double-quote")
  +           (lexer-context-shell-extensible-read inner-context :readtable readtable)))
  +    (let ((token (lexer-context-delimit inner-context)))
  +      (make-instance 'double-quote :parts (vector token)))))
   
   (defun read-backquote (stream)
     (declare (ignore stream))
  
positive.code:   t)
  
  (defun handle-double-quote (stream initiation-sequence context)
    (declare (ignore initiation-sequence))
    (lexer-context-add-part context (read-double-quote stream))
    t)
  
  (defun handle-dollar (stream initiation-sequence context)
  
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)
  