anchor.diff:    (setf (reply-service-context req) service-context))
   
   
  +(defun request-poll (req)
  +  ;; Check if result of request is ready
  +  ;; might retransmit request, if redirected
  +  (case (request-status req)
  +    (:location_forward
  +     (setf (object-forward (request-target req))
  +           (unmarshal-object (request-buffer req)))
  +     (has-received-other (the-orb req) req)
  +     (request-send req)
  +     nil)
  +    
  +    ;;FIXME: check for transient and retry if policies allow
  +
  +    (otherwise 
  +     req)))
  +
  +
   (defun request-wait-response (req)
  -  (orb-wait #'request-status req))
  +  (loop do (orb-wait #'request-status req)
  +        until (request-poll req)))
   
   
   (defun request-handle-error (req)
  
positive.code:           (setq op (setter-name name))
            (setq output-func
                  (let ((mfun (marshal-function type)))
                    (lambda (req buffer arg)
                      (declare (ignore req))
                      (funcall mfun arg buffer))))))
        (do-static-call obj op t 
                        (lambda (req buffer)
                          (funcall output-func req buffer value))
                        (lambda (req buffer) (declare (ignore req buffer)))
                        nil))))
  
  
  
negative.code: 
  
  (defun request-send (req)
    (multiple-value-bind (connection request-id)
                         (request-start-request req)
      (setf (service-context-list req) nil)
      (will-send-request (the-orb req) req)
      (let ((buffer
             (connection-start-request connection request-id (service-context-list req)
                                       (response-expected req) (request-effective-profile req)
                                       (request-operation req))))
        (funcall (output-func req) req buffer) 
        (connection-send-request connection buffer
                                 (if (response-expected req) req)))))
  
  
  ;;; void send_oneway ()
  