anchor.diff:  
   ;;; parse trees
   (defclass function-form (form) ())
  +(defclass complete-function-form (form complete-form-mixin) ())
  +(defclass incomplete-function-form (form incomplete-form-mixin) ())
   
   (define-parser-state |#' | (form-may-follow) ())
   (define-parser-state |#' form | (lexer-toplevel-state parser-state) ())
   
   (define-new-lisp-state (form-may-follow function-lexeme) |#' |)
  -(define-new-lisp-state (|#' | form) |#' form |)
  +(define-new-lisp-state (|#' | complete-form-mixin) |#' form |)
   (define-new-lisp-state (|#' | comment) |#' |)
   
   ;;; reduce according to the rule form -> #' form
   (define-lisp-action (|#' form | t)
  -  (reduce-until-type function-form function-lexeme))
  +  (reduce-until-type complete-function-form function-lexeme))
  +(define-lisp-action (|#' | unmatched-right-parenthesis-lexeme)
  +  (reduce-until-type incomplete-function-form function-lexeme))
  +(define-lisp-action (|#' | (eql nil))
  +  (reduce-until-type incomplete-function-form function-lexeme))
   
   ;;;;;;;;;;;;;;;; Reader conditionals
   
  
positive.code: 
  ;;; parse trees
  (defclass pathname-form (form) ())
  
  (define-parser-state |#P | (form-may-follow) ())
  (define-parser-state |#P form | (lexer-toplevel-state parser-state) ())
  
  (define-new-lisp-state (form-may-follow pathname-start-lexeme) |#P |)
  (define-new-lisp-state (|#P | form) |#P form |)
  (define-new-lisp-state (|#P | comment) |#P |)
  
  ;;; reduce according to the rule form -> #P form
  (define-lisp-action (|#P form | t)
    (reduce-until-type pathname-form pathname-start-lexeme))
  
  ;;;;;;;;;;;;;;;; undefined reader macro
  
  
negative.code: (defmethod token-to-object ((syntax lisp-syntax) (token literal-object-lexeme) &key &allow-other-keys)
    (object-after (start-mark token)))
  
  (defmethod token-to-object ((syntax lisp-syntax) (token pathname-form) &key &allow-other-keys)
    (read-from-string (token-string syntax token)))
  
  (defmethod token-to-object ((syntax lisp-syntax) (token incomplete-pathname-form) &rest args &key read &allow-other-keys)
    (if read
        ;; Will cause a reader error (which is what we want).
        (call-next-method)
        ;; Try to create a pathname as much as possible.
        (let ((pathspec-token (second (children token))))
          (pathname (if pathspec-token
                        (apply #'token-to-object syntax pathspec-token
                               ;; Since `pathspec-token' will be
                               ;; incomplete, `read'ing from it is
                               ;; probably bad.
                               :read nil args)
                        "")))))
  
  (defmethod token-to-object ((syntax lisp-syntax) (token complete-function-form) &rest args &key &allow-other-keys)
    (fdefinition (apply #'token-to-object syntax (second (children token)) args)))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  ;;; Arglist fetching.
  