anchor.diff:  appropriate."
     (assert (member type '(:struct :union)))
     (with-wrap-attempt ("define foreign ~A ~S" type name) name
  -    (let* ((record (gethash name *foreign-incomplete*))
  -           (incomplete-p record))
  +    (let* ((record (gethash `(,type (,name)) *foreign-types*)))
         (unless record
           (setf record (make-instance 'foreign-record
                                       :name name
  
positive.code:         (setf (foreign-record-bit-size record) bit-size))
        (unless (= 0 bit-alignment)
          (setf (foreign-record-bit-alignment record) bit-alignment))
        (if (car field-list)
            (progn
              (setf (foreign-record-fields record)
                    (parse-record-fields type name field-list))
              (when incomplete-p
                (remhash name *foreign-incomplete*)))
            (setf (gethash name *foreign-incomplete*) record))
        record)))
  
  (defun define-foreign-enum (name id value-list)
  
negative.code:                                                            name c-symbol (car param) (cadr param)))))
          (setf (gethash name *foreign-functions*) fun)))))
  
  (defun parse-record-fields (record-type record-type-name field-list)
    (loop for field in field-list
          collect
          (destructuring-bind (name type &key bitfield-p bit-size bit-offset
                               bit-alignment bit-width)
              field
            (handler-case
                (make-instance 'foreign-record-field
                               :name name
                               :type (ensure-type type "define ~(~S~) ~S field ~S of type ~S"
                                                  record-type record-type-name name type)
                               :bitfield-p bitfield-p
                               :bit-size bit-size
                               :bit-offset bit-offset
                               :bit-alignment bit-alignment
                               :bit-width bit-width)
              (undefined-foreign-type (e) (declare (ignore e)) nil)))
            into fields
          finally (return (delete-if #'null fields))))
  
  (defun struct-or-union-p (name)
    (or (find-type `(:struct (,name)))
  