anchor.diff:                       (accessor-package wrapper-package)
                        (constant-package definition-package)
                        (extern-package accessor-package)
  -                     constant-accessor
  -                     trace-c2ffi)
  +                     constant-accessor exclude-constants
  +                     trace-c2ffi no-accessors no-functions)
     (let ((*foreign-symbol-exceptions* (alist-hash-table symbol-exceptions :test 'equal))
  -        (*foreign-symbol-regex* (mapcar (lambda (x)
  -                                          (cons (apply #'ppcre:create-scanner (car x) (cadr x))
  -                                                (eval (caddr x))))
  -                                        symbol-regex))
  +        (*foreign-symbol-regex* (make-scanners symbol-regex))
  +        (*foreign-constant-excludes* (mapcar #'ppcre:create-scanner exclude-constants))
  +        (*foreign-raw-constant-list*)
           (exclude-definitions (mapcar #'ppcre:create-scanner exclude-definitions))
           (exclude-sources (mapcar #'ppcre:create-scanner exclude-sources))
           (*package* (find-package definition-package))
  
positive.code:       ((string= tag ":pointer") t)
        (t nil))))
  
   ;; Parsing
  
  
negative.code: (defun read-json (file)
    (let ((*read-default-float-format* 'double-float))
      (json:decode-json file)))
  
   ;; c-include utility
  
  (defun make-scanners (list)
    (mapcar (lambda (x)
              (cons (apply #'ppcre:create-scanner (car x) (cadr x))
                    (eval (caddr x))))
            list))
  
  (defun read-parse-forms (in-spec exclude-definitions exclude-sources include-sources)
    (loop for form in (read-json in-spec)
          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))))
            collect (parse-form form (aval :tag form))))
  
  (defun make-define-list (def-symbol list package)
   (loop for x in (reverse list)
         collect `(,def-symbol ,x ,package)))
  
  (defun make-export-list (list package)
    `(export '(,@(mapcar
                  (lambda (x)
                    (etypecase x
                      (symbol x)
                      (cons (caadr x))))
                  list))
             ,package))
  
  (defun make-constant-accessor (name value-map-name)
    (with-gensyms (internal-name)
      `((defvar ,value-map-name)
        (defun ,internal-name (name)
          (declare (string name))
          (multiple-value-bind (value presentp) (gethash name ,value-map-name)
            (if presentp
                value
                (error "~@<Unknown constant: ~S~%~:@>" name))))
        (defun ,name (name)
          (,internal-name name))
        ;; I wonder if we really must break this loop..
        (define-compiler-macro ,name (&whole whole name)
          (if (stringp name)
              (,internal-name name)
              whole))
        (export '(,name)))))
  
   ;; Exported API
  