anchor.diff:        ((string= tag ":pointer") t)
         (t nil))))
   
  +(defun maybe-add-constant (name value)
  +  (push (cons name value) *foreign-raw-constant-list*)
  +  (unless (included-p name *foreign-constant-excludes*)
  +    (let ((sym (foreign-type-symbol name :cconst *package*)))
  +      (pushnew sym *foreign-constant-list*)
  +      (if (stringp value)
  +          `(defvar ,sym ,value)
  +          `(defconstant ,sym ,value)))))
  +
     ;; Parsing
   
  
positive.code: (defun parse-enum-to-const (fields)
    (loop for field in fields
          as name = (aval :name field)
          as sym = (foreign-type-symbol name :cconst *package*)
          collect `(defconstant ,sym ,(aval :value field))
          do (pushnew sym *foreign-constant-list*)))
  
  (defmethod parse-form (form (tag (eql 'struct)) &key &allow-other-keys)
    (alist-bind (name fields) form
  
negative.code:                      (accessor-package wrapper-package)
                       (constant-package definition-package)
                       (extern-package accessor-package)
                       constant-accessor exclude-constants
                       trace-c2ffi no-accessors no-functions)
    (let ((*foreign-symbol-exceptions* (alist-hash-table symbol-exceptions :test 'equal))
          (*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))
  