anchor.diff:                                               :cenumfield *package*)
                           (aval :value field)))))
   
  +(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)))
     (alist-bind (name fields) form
       (let ((sym (foreign-type-symbol name :cstruct *package*)))
  
positive.code:                   `(export '(,@(mapcar (lambda (x) (etypecase x (symbol x) (cons (caadr x))))
                                  *foreign-record-list*))))
                 ,(when *foreign-function-list*
                    `(export ',*foreign-function-list* ,function-package))
                 ,(when *foreign-extern-list*
                    `(export ',*foreign-extern-list* ,extern-package))
                 ,(when *foreign-constant-list*
                    `(export ',*foreign-constant-list* ,constant-package))
                 ,(when *foreign-other-exports-list*
                    `(export ',*foreign-other-exports-list* ,definition-package)))))))))
  
negative.code:   (alist-bind (name fields) form
      (let ((sym (foreign-type-symbol name :cenum *package*)))
        (pushnew sym *foreign-other-exports-list*)
        `(progn
           ,@(parse-enum-to-const fields)
           (define-foreign-enum ',sym ',(parse-enum-fields fields))))))
  
  (defmethod parse-form (form (tag (eql 'function)))
    (alist-bind (name parameters return-type variadic) form
  