anchor.diff:  ;; transaction context that differs from that of the request.
   
   (define-method op::get_response ((req client-request))
  +  (unless (remove-pending-request (the-orb req) req)
  +    ;; FIXME: ??
  +    (raise-system-exception 'CORBA:BAD_INV_ORDER))
     (request-get-response req)
     (values))
   
   
  +;;; boolean poll_response ();
  +;;
  +;; poll_response determines whether the request has completed. A TRUE return indicates
  +;; that it has; FALSE indicates it has not.
  +;;
  +;; Return is immediate, whether the response has completed or not. Values in the request are
  +;; not changed.
  +
  +;; Exception BAD_INV_ORDER with minor
  +;;  * 11 - request not sendt
  +;;  * 12 - request already returned
  +;;  * 13 - request invoked
  +
   (define-method poll_response ((req client-request))
  -  ;; FIXME: possibly (orb-wait ...) if without timeout
  -  (not (null (request-status req))))
  -
  +  ;; FIXME: 13
  +  (case (request-status req)
  +    ((:initial) (raise-system-exception 'CORBA:BAD_INV_ORDER 11 :completed_no))
  +    ((:returned) (raise-system-exception 'CORBA:BAD_INV_ORDER 12 :completed_yes))
  +    ((nil) nil)
  +    (otherwise t)))
   
   
   ;;; void invoke ()
   
   (define-method op::invoke ((req client-request))
  -  (op:send_deferred req)
  -  (op:get_response req))
  +  (request-send req)
  +  (request-get-response req)
  +  (values))
   
   
   (defun request-funcall (req)
  
positive.code:                       (lambda (req buffer) (funcall output-func req buffer args))
                        input-func exceptions))))
  
  
  ;;; clorb-request.lisp ends here
  
negative.code: 
  ;;;; Stub support
  
  
  (defun symbol-op-info (sym)
    "Returns: name result params mode exc-syms"
    (values (get sym 'ifr-name)
            (get sym 'ifr-result)
            (get sym 'ifr-params)
            (get sym 'ifr-mode)
            (get sym 'ifr-exceptions)))
  
  
  (defun symbol-attr-info (sym)
    "Returns: name type mode"
    (values (get sym 'ifr-name)
            (get sym 'ifr-type)
            (get sym 'ifr-mode)))
  
  
  (defun compute-static-call (sym)
    (let (input-func output-func exceptions op response-expected)
      (lambda (obj &rest args)
        (unless input-func
          (multiple-value-bind (name result params mode exc-syms)
                               (symbol-op-info sym)
            (setq input-func
                  (let ((ufuns (loop for (nil pmode tc) in params
                                     unless (eql pmode :param_in) collect (unmarshal-function tc))))
  