anchor.diff:               (error "Cannot convert incomplete form to Lisp object: ~A"
                       token))))
   
  +;;; The complicated primary structure forms.
  +
  +;; The problem is that we can't portably create in-memory backquote
  +;; forms, so we have to rewrite them to calls to `nconc'. I think this
  +;; is valid, because the CLHS doesn't specify the in-memory
  +;; representation of backquoted forms, and thus the user can't assume
  +;; that it isn't just a whole bunch of calls to `nconc' anyway.
  +(defmethod token-to-object (syntax (token list-form) &rest args &key backquoted)
  +  (if backquoted
  +      `(nconc ,@(loop for child in (children token)
  +                   if (typep child 'comma-at-form)
  +                   collect (apply #'token-to-object syntax child :backquoted nil args)
  +                   else if (typep child 'comma-form)
  +                   collect `(list ,(apply #'token-to-object syntax child :backquoted nil args))
  +                   else if (form-token-p child)
  +                   collect `(list ,`',(apply #'token-to-object syntax child args))
  +                   else if (formp child)
  +                   collect `(list ,(apply #'token-to-object syntax child args))))
  +      (mapcar #'(lambda (child)
  +                  (apply #'token-to-object syntax child args))
  +              (remove-if-not #'formp (children token)))))
  +
  +(defmethod token-to-object (syntax (token complete-quote-form) &rest args &key backquoted)
  +  (if backquoted
  +      (let ((quoted-form (first-form (children token))))
  +        (if (form-token-p quoted-form)
  +            `(list 'quote (quote ,(apply #'token-to-object syntax (second (children token)) args)))
  +            `(list 'quote ,(apply #'token-to-object syntax (second (children token)) args))))
  +      `',(apply #'token-to-object syntax (second (children token)) args)))
  +
  +(defmethod token-to-object (syntax (token incomplete-quote-form) &rest args)
  +  (declare (ignore args))
  +  ;; Utterly arbitrary, but reasonable in my opinion.
  +  '(quote))
  +
  +;; I'm not sure backquotes are handled correctly, but they should be,
  +;; at least when :read t is specified.
  +(defmethod token-to-object (syntax (token backquote-form) &rest args)
  +  (let ((backquoted-form (first-form (children token))))
  +    (if (form-token-p backquoted-form)
  +        `',(apply #'token-to-object syntax backquoted-form args)
  +        (apply #'token-to-object syntax  backquoted-form :backquoted t args))))
  +
  +(defmethod token-to-object (syntax (token comma-form) &rest args)
  +  (apply #'token-to-object syntax (first-form (children token)) :backquoted nil args))
  +
  +(defmethod token-to-object (syntax (token comma-at-form) &rest args)
  +  (apply #'token-to-object syntax (first-form (children token)) :backquoted nil args))
  +
  +;;; The atom(-ish) forms.
  +
   (defmethod token-to-object (syntax (token complete-token-lexeme)
                               &key no-error read (case (readtable-case *readtable*))
                               &allow-other-keys)
  
positive.code:                    :case case
                     :no-error t))
  
  (defgeneric token-to-object (syntax token &key no-error package quote read &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)
             ;; 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))))))
               (if no-error 
                   (ignore-errors (act))
                   (act))))
  
negative.code: ;;;;;;;;;;;;;;;; Comma
  
  ;;; parse trees
  (defclass comma-form (form complete-form-mixin) ())
  (defclass comma-at-form (form complete-form-mixin) ())
  (defclass comma-dot-form (form complete-form-mixin) ())
  
  (define-parser-state |, | (form-may-follow) ())
  (define-parser-state |, form | (lexer-toplevel-state parser-state) ())
  