anchor.diff:      (loop
         (let* ((conn (request-start-request req))
                (req-id (next-request-id conn)))
  -        (setf (request-req-id req) req-id)
  +        (setf (request-id req) req-id)
           (connection-start-locate-request conn req-id
                                            (request-effective-profile req)))
         (send-request req)
  
positive.code:   (marshal-giop-set-message-length buffer)
    (connection-send-buffer conn buffer)
    (when req
      (push req (connection-client-requests conn))
      (push req *corba-waiting-requests*)))
  
  
  (defun find-waiting-request (conn request-id)
    (let ((req-list (connection-client-requests conn)))
      (let ((req (find request-id req-list :key #'request-req-id)))
        (if req
          (setf (connection-client-requests conn) (delete req req-list))
          (mess 4 "Unexpected response with request id ~d" request-id))
        req)))
  
  
  ;;;; IIOP - Profiles
  
  
  (defstruct IIOP-PROFILE
    (version '(1 . 0))
    (host    nil)
    (port    0    :type fixnum)
    (key     nil))
  
  
  (defmethod profile-short-desc ((profile IIOP-PROFILE) stream)
    (format stream "~A:~A" 
            (iiop-profile-host profile)
            (iiop-profile-port profile)))
  
  (defmethod profile-equal ((profile1 iiop-profile) (profile2 iiop-profile))
    (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))))
  
  (defmethod profile-hash ((profile iiop-profile))
    (sxhash (list* (iiop-profile-host profile)
                   (iiop-profile-port profile)
                   (coerce (iiop-profile-key profile) 'list))))
  
  (defmethod decode-ior-profile ((tag (eql 0)) encaps)
    (unmarshal-encapsulation encaps #'unmarshal-iiop-profile-body))
  
  (defun unmarshal-iiop-profile-body (buffer)
    (make-iiop-profile
     :version (cons (unmarshal-octet buffer) 
                    (unmarshal-octet buffer))
     :host (unmarshal-string buffer)
     :port (unmarshal-ushort buffer)
     :key (unmarshal-osequence buffer)))
  
  (defmethod raw-profiles ((objref CORBA:Proxy))
    (or (object-raw-profiles objref)
        (setf (object-raw-profiles objref)
              (map 'list
                   (lambda (p)
                     (cons iop:tag_internet_iop
                           (marshal-make-encapsulation
                            (lambda (buffer)
                              (let ((version (iiop-profile-version p)))
                                (marshal-octet (car version) buffer)
                                (marshal-octet (cdr version) buffer))
                              (marshal-string (iiop-profile-host p) buffer)
                              (marshal-ushort (iiop-profile-port p) buffer)
                              (marshal-osequence (iiop-profile-key p) buffer)))))
                   (object-profiles objref)))))
  
  
  
  ;;;; IIOP - Sending request
  
  #+unused-functions
  (defun request-prepare (req object)
    (let* ((conn (get-object-connection object)))
      (unless conn
        (raise-system-exception 'corba:comm_failure))
      (setf (request-connection req) conn)    
      (setf (request-status req) nil)
      (setf (request-req-id req) (next-request-id conn))
      (values
       (or (object-forward object) object)
       (setf (request-buffer req) (get-work-buffer (the-orb req)))
       conn)))
  
  
  
  (defun request-marshal-head (req)
    (let ((connection (request-start-request req)))
      (setf (request-req-id req) (next-request-id connection))
      (will-send-request (the-orb req) req)
      (setf (request-buffer req) 
            (connection-start-request
             connection
             (request-req-id req)
             (service-context-list req)
             (response-expected req)
             (request-effective-profile req)
             (request-operation req)))))
  
  
  (defun send-request (req)
    (let ((buffer (request-buffer req)))
      (setf (request-buffer req) nil)
      (setf (request-status req) nil)
      (connection-send-request (request-connection req) buffer
                               (if (response-expected req) req))))
  
  
  
negative.code:               (setf (object-forward (request-target req))
                      (unmarshal-object buffer))
                (values status))
               (:error                    ; comm error
                (has-received-exception (the-orb req) req)
                (error (request-exception req)))
               (:system_exception
                (let ((condition (unmarshal-systemexception buffer)))
                  (setf (request-exception req) condition)
  