anchor.diff:                     :case case
                      :no-error t))
   
  -(defgeneric token-to-object (syntax token &key no-error package quote read &allow-other-keys)
  +(defgeneric token-to-object (syntax token &key no-error package read backquoted &allow-other-keys)
     (:documentation "Return the Lisp object `token' would evaluate
   to if read. An attempt will be made to construct objects from
   incomplete tokens. This function may signal an error if
   `no-error' is nil and `token' cannot be converted to a Lisp
   object. Otherwise, nil will be returned.")
  -  (:method :around (syntax (token t) &rest args &key
  -                           package quote no-error &allow-other-keys)
  +  (:method :around (syntax (token t) &key package no-error &allow-other-keys)
              ;; Ensure that every symbol that is READ will be looked up
              ;; in the correct package. Also handle quoting.
              (flet ((act ()
                       (let ((*package* (or package
                                            (package-at-mark
  -                                     syntax (start-offset token)))))
  -                      (cond (quote
  -                             (setf (getf args :quote) nil)
  -                             `',(call-next-method))
  -                            (t
  -                             (call-next-method))))))
  +                                          syntax (start-offset token)))))
  +
  +                      (call-next-method))))
                (if no-error 
                    (ignore-errors (act))
                    (act))))
  
positive.code: ;;;;;;;;;;;;;;;; Comma
  
  ;;; parse trees
  (defclass comma-form (form) ())
  (defclass comma-at-form (form) ())
  (defclass comma-dot-form (form) ())
  
  (define-parser-state |, | (form-may-follow) ())
  (define-parser-state |, form | (lexer-toplevel-state parser-state) ())
  
negative.code: (defmethod token-to-object (syntax (token complete-string-form) &key no-error &allow-other-keys)
    (declare (ignore no-error))
    (read-from-string (token-string syntax token)))
  
  (defmethod token-to-object (syntax (token function-form) &rest args)
    (list 'cl:function (apply #'token-to-object syntax (second (children token)) args)))
  