anchor.diff:    (port    0    :type fixnum)
     (key     nil))
   
  +(defun object-key (object)
  +  (let ((p (selected-profile object)))
  +    (and p (iiop-profile-key p))))
  +
  +
   ;;;| boolean	is_equivalent (in Object other_object);
   ;;; _is_equivalent in lisp mapping
   
   (define-method _is_equivalent ((obj corba:proxy) other)
  -  (if (object-host obj)
  -      (and
  -       (equal (object-host obj) (object-host other))
  -       (equal (object-port obj) (object-port other))
  -       (equalp (object-key obj) (object-key other)))
  -      (if (object-profiles obj)
  -          (let ((profile1 (car (object-profiles obj)))
  -                (profile2 (car (object-profiles other))))
  -            (and
  -             (equal (iiop-profile-host profile1) (iiop-profile-host profile2))
  -             (equal (iiop-profile-port profile1) (iiop-profile-port profile2))
  -             (equalp (iiop-profile-key profile1) (iiop-profile-key profile2)))))))
  +  (let ((profile1 (car (object-profiles obj)))
  +        (profile2 (car (object-profiles other))))
  +    (and profile1 profile2
  +         (equal (iiop-profile-host profile1) (iiop-profile-host profile2))
  +         (equal (iiop-profile-port profile1) (iiop-profile-port profile2))
  +         (equalp (iiop-profile-key profile1) (iiop-profile-key profile2)))))
   
   
   ;;;| unsigned 	long hash(in unsigned long maximum);
   ;;; _hash in lisp mapping
   
   (define-method _hash ((obj corba:proxy) maximum)
  -  (rem (sxhash (list* (object-host obj)
  -                      (object-port obj)
  -                      (coerce (object-key obj) 'list)))
  +  (rem (if (object-profiles obj)
  +         (iiop-profile-hash (first (object-profiles obj)))
  +         0)
          maximum))
  +
  +(defun iiop-profile-hash (profile)
  +  (sxhash (list* (iiop-profile-host profile)
  +                 (iiop-profile-port profile)
  +                 (coerce (iiop-profile-key profile) 'list))))
  +
   
   
   ;;;| Status create_request (			
  
positive.code: 
  ;;;; CORBA:Object / CORBA:Proxy
  
  (defclass CORBA:Object ()
    ())
  
  (defmethod object-id ((obj CORBA:Object))
    (or (some #'(lambda (x)
  
negative.code: 
  
  (defclass CORBA:Proxy (CORBA:Object)
    ((id :initform nil :initarg :id :accessor proxy-id)
     (connection :initform nil :accessor object-connection)
     (raw-profiles :initform nil :initarg :raw-profiles
                   :accessor object-raw-profiles)
     (profiles :initform nil :initarg :profiles :accessor object-profiles)
     (selected-profile :initform nil :accessor selected-profile)
     (forward :initform nil :initarg :forward :accessor object-forward)))
  
  (defmethod print-object ((o corba:proxy) stream)
    (print-unreadable-object (o stream :type t)
      (when (eql (class-of o) (find-class 'corba:proxy))
        (format stream "~S @" (object-id o)))
      (let ((profile (loop with x = o
                           while (object-forward x)
                           do (setf x (object-forward x))
                           finally (return (or (selected-profile x)
                                               (first (object-profiles x)))))))
        (if profile
          (format stream "~A:~A" 
                  (iiop-profile-host profile)
                  (iiop-profile-port profile))
          (format stream "--" )))))
  
  
  
  (defun object-key (proxy)
    "Return a key for the proxy."
  