anchor.diff:        (error "No applicable constructor ~A found for arguments ~A"
                (qclass-name class) args))
       (assert (eq class (qtype-class (qmethod-return-type method))))
  -    (with-tracing (method nil args)
  -      (apply #'values
  -             (call-with-marshalling
  -              (lambda (stack)
  -                (setf (qobject-pointer instance)
  -                      (%call-ctor method
  -                                  stack
  -				  (binding-for-ctor method instance)))
  -                (cache! instance)
  -                (list instance))
  -              (list-qmethod-argument-types method)
  -              args)))))
  +    (apply #'values
  +	   (call-with-marshalling
  +	    (lambda (stack)
  +	      (setf (qobject-pointer instance)
  +		    (%call-ctor method
  +				stack
  +				(binding-for-ctor method instance)))
  +	      (cache! instance)
  +	      (list instance))
  +	    (list-qmethod-argument-types method)
  +	    args))))
   
   (defun call (instance method &rest args)
     (%call t instance method args))
  
positive.code: (defmethod new ((qclass string) &rest args)
    (apply #'new (find-qclass qclass) args))
  
  (defmacro with-tracing ((method instance args) &body body)
    `(invoke-with-tracing (lambda () ,@body) ,method ,instance ,args))
  
  (defun invoke-with-tracing (fun method instance args)
    (cond
      #+nil ;tracing currently broken 
      ((plusp (qmethod-trace-counter method))
       (if instance
           (format *trace-output* ";; ~A.~A(~{~A~^, ~})~%"
                   instance
                   (qmethod-name method)
                   args)
           (format *trace-output* ";; new ~A(~{~A~^, ~})~%"
                   (qmethod-name method)
                   args))
       (let ((ok nil))
         (unwind-protect
              (let ((results (multiple-value-list (funcall fun))))
                (if instance
                    (format *trace-output* ";; ~A.~A returned ~{~A~^, ~}~%"
                            instance
                            (qmethod-name method)
                            results)
                    (format *trace-output* ";; new ~A returned ~{~A~^, ~}~%"
                            (qmethod-name method)
                            results))
                (setf ok t)
                (apply #'values results))
           (unless ok
             (if instance
                 (format *trace-output* ";; nlx unwind in ~A.~A~%"
                         instance
                         (qmethod-name method))
                 (format *trace-output* ";; nlx unwind in ~A~%"
                         (qmethod-name method)))))))
      (t
       (funcall fun))))
  
  (defvar *pending-finalizations* nil)
  
  (defun finalize-if-matching-thread (thread ptr class description qp dynamicp)
  
negative.code:         (error "not a static method"))
        (setf instance (null-qobject instance)))
      (let ((rtype (qmethod-return-type method)))
        (apply #'values
  	     (call-with-marshalling
  	      (lambda (stack &aux fun)
  		(cond
  		 ((and allow-override-p
  		       (setf fun
  			     (find-method-override instance method)))
  		  (multiple-value-list (override fun instance method args)))
  		 (t
  		  (cffi:foreign-funcall-pointer
  		   (qclass-trampoline-fun (qmethod-class method))
  		   ()
  		   :short (qmethod-arg-for-classfn method)
  		   :pointer (qobject-pointer instance)
  		   :pointer stack
  		   :void)
  		  (list (and (not (qtype-void-p rtype))
  			     (unmarshal rtype stack))))))
  	      (list-qmethod-argument-types method)
  	      args)))))
  
  (defclass deleted-object (abstract-qobject)
    ())
  