anchor.diff:                   #+sbcl
                    (progn
                      (setf *foreign-record-index* (make-hash-table))
  -                   ,@(loop for form in (json:decode-json in-h)
  +                   ,@(loop for form in (read-json in-h)
                              unless (or (included-p (aval :name form) exclude-definitions)
                                         (and (included-p (aval :location form) exclude-sources)
                                              (not (included-p (aval :location form) include-sources))))
  
positive.code:                (eval-when (:compile-toplevel :load-toplevel :execute)
                   (setf *failed-wraps* nil)
                   ,@(when constant-accessor
                           `((defvar ,constant-name-value-map)
                             (defun ,constant-accessor-internal (name)
                               (declare (string name))
                               (multiple-value-bind (value presentp) (gethash name ,constant-name-value-map)
                                 (if presentp
                                     value
                                     (error "~@<Unknown constant: ~S~%~:@>" name))))
                             (defun ,constant-accessor (name)
                               (,constant-accessor-internal name))
                             ;; I wonder if we really must break this loop..
                             (define-compiler-macro ,constant-accessor (&whole whole name)
                               (if (stringp name)
                                   (,constant-accessor-internal name)
                                   whole))
                             (export '(,constant-accessor))))
                   #-sbcl
                   (with-anonymous-indexing
                     ,@(loop for form in (json:decode-json in-h)
                             unless (or (included-p (aval :name form) exclude-definitions)
                                        (included-p (aval :location form) exclude-sources))
                               collect (parse-form form (aval :tag form)))
  
negative.code:                  (compile-time-report-wrap-failures)
                   ,(when *foreign-record-list*
                      `(export '(,@(mapcar (lambda (x) (etypecase x (symbol x) (cons (caadr x))))
                                    *foreign-record-list*))))
                   ,(when *foreign-function-list*
                      `(export ',(mapcar (lambda (x) (intern (symbol-name x) function-package))
                                         *foreign-function-list*)
  