anchor.diff:  ;;;# Type Translators
   ;;;
   ;;; Type translation is done with generic functions at runtime for
  -;;; subclasses of ENHANCED-FOREIGN-TYPE/
  +;;; subclasses of TRANSLATABLE-FOREIGN-TYPE.
   ;;;
   ;;; The main interface for defining type translations is through the
   ;;; generic functions TRANSLATE-{TO,FROM}-FOREIGN and
   ;;; FREE-TRANSLATED-OBJECT.
   
  -(defclass enhanced-foreign-type (foreign-type-alias)
  +(defclass translatable-foreign-type (foreign-type) ())
  +
  +;;; ENHANCED-FOREIGN-TYPE is used to define translations on top of
  +;;; previously defined foreign types.
  +(defclass enhanced-foreign-type (translatable-foreign-type
  +                                 foreign-type-alias)
     ((unparsed-type :accessor unparsed-type)))
   
   ;;; If actual-type isn't parsed already, let's parse it.  This way we
  
positive.code: (defgeneric translate-aggregate-to-foreign (ptr value type))
  
  ;;; Translate the foreign object VALUE from the type repsented by
  ;;; TYPE, which will be a subclass of ENHANCED-FOREIGN-TYPE.  Returns
  ;;; the converted Lisp value.
  (defgeneric translate-from-foreign (value type)
    (:method (value type)
      (declare (ignore type))
  
negative.code:     (declare (ignore type))
      value))
  
  (defmethod expand-from-foreign :around (value (type translatable-foreign-type))
    (let ((*runtime-translator-form* `(translate-from-foreign ,value ,type)))
      (call-next-method)))
  
  (defmethod expand-from-foreign (value (type translatable-foreign-type))
    (declare (ignore value))
    *runtime-translator-form*)
  
  