anchor.diff:                                                             name c-symbol (car param) (cadr param)))))
           (setf (gethash name *foreign-functions*) fun)))))
   
  -(defun parse-record-fields (compound-type compound-type-name field-list)
  +(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
  -          (make-instance 'foreign-record-field
  -                         :name name
  -                         :type (ensure-type type "define ~(~S~) ~S wrt. field ~S of type ~S" compound-type compound-type-name name type)
  -                         :bitfield-p bitfield-p
  -                         :bit-size bit-size
  -                         :bit-offset bit-offset
  -                         :bit-alignment bit-alignment
  -                         :bit-width bit-width))
  +          (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 fields)))
  +        finally (return (delete-if #'null fields))))
   
   (defun struct-or-union-p (name)
     (or (find-type `(:struct (,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: (defvar *foreign-types* (make-hash-table :test 'equal))
  (defvar *foreign-functions* (make-hash-table))
  (defvar *foreign-externs* (make-hash-table))
  
   ;; Temporary record indexing
  