anchor.diff:  name for the type will be `(:struct NAME)` or `(:union NAME)`, as
   appropriate."
     (assert (member type '(:struct :union)))
  -  (let ((record (make-instance 'foreign-record
  -                               :name name
  -                               :type type
  -                               :bit-size bit-size
  -                               :bit-alignment bit-alignment)))
  -    (define-foreign-type `(,type (,name)) record)
  -    (setf (foreign-record-fields record)
  -          (parse-record-fields field-list))
  -    record))
  +  (with-wrap-attempt ("define foreign ~A ~S" type name) name
  +    (let ((record (make-instance 'foreign-record
  +                                 :name name
  +                                 :type type
  +                                 :bit-size bit-size
  +                                 :bit-alignment bit-alignment)))
  +      (define-foreign-type `(,type (,name)) record)
  +      (setf (foreign-record-fields record)
  +            (parse-record-fields type name field-list))
  +      record)))
   
   (defun define-foreign-enum (name id value-list)
     "Define a foreign enum given `NAME`, a symbol, and a list of
  
positive.code:   ((variadic-p :initarg :variadic-p
                 :initform nil :accessor foreign-function-variadic-p)))
  
  (defun undefined-enum-value (value)
    (autowrap-continuable-error "Undefined enum value: ~S" value))
  
  
negative.code: (defmethod foreign-type-size ((type symbol))
    (if (keywordp type)
        (call-next-method)
        (foreign-type-size (require-type type "determine the size of foreign type ~S" type))))
  
   ;; Defining things
  