anchor.diff:                   t  ; callback
                    :c ; convention
                    ;; return type '(:c-type lisp-type)
  -                 ',(allegro-type-pair (convert-foreign-type rettype :funcall))
  +                 ',(allegro-type-pair rettype)
                    ;; arg types '({(:c-type lisp-type)}*)
  -                 '(,@(loop for type in types
  -                           collect (allegro-type-pair
  -                                    (convert-foreign-type type :funcall))))
  +                 '(,@(mapcar #'allegro-type-pair types))
                    nil ; arg-checking
                    ff::ep-flag-never-release))))
   
  
positive.code:   "Returns a list of types, list of args and return type."
    (let ((return-type :void))
      (loop for (type arg) on args by #'cddr
            if arg collect (convert-foreign-type type :funcall) into types
            and collect arg into fargs
            else do (setf return-type (convert-foreign-type type :funcall))
            finally (return (values types fargs return-type)))))
  
  (defun convert-to-lisp-type (type)
    (if (equal '(* :void) type)
        'integer
        (ecase type
          (:char 'signed-byte)
          (:unsigned-char 'integer) ;'unsigned-byte)
          ((:short
            :unsigned-short
            :int
            :unsigned-int
            :long
            :unsigned-long) 'integer)
          (:float 'single-float)
          (:double 'double-float)
          (:foreign-address :foreign-address)
          (:void 'null))))
  
  (defun foreign-allegro-type (type)
    (if (eq type :foreign-address)
        nil
        type))
  
  (defun allegro-type-pair (type)
    (list (foreign-allegro-type type)
          (convert-to-lisp-type type)))
  
  #+ignore
  (defun note-named-foreign-function (symbol name types rettype)
  
negative.code: 
  ;;;# Dereferencing
  
  (defun convert-foreign-type (type-keyword)
    "Convert a CFFI type keyword to an Allegro type."
    (ecase type-keyword
      (:char             :char)
  