anchor.diff:    (declare (ignore target))
     (mess 4 "Can't generate code for ~A of kind ~S"
           (op:name x)
  -        (op:def_kind x))
  -  )
  +        (op:def_kind x)))
   
   (defmethod target-code ((x CORBA:AliasDef) target)
     (let ((symbol (scoped-target-symbol target x)))
  
positive.code:         (export (,@(slot-value target 'symbols)))
          ,code))))
  
  (defun gen-stub-file (object filename &key package-def)
    (with-open-file (*standard-output* filename :direction :output :if-exists :supersede)
      (let* ((target (make-instance 'code-target))
             (code (target-code object target)))
        (print '(in-package :clorb))
        (when package-def
          (loop for package in (slot-value target 'packages)
                  unless (member package *stub-code-ignored-packages*)
                  do (terpri)
                     (pprint (make-allways-eval 
                              (make-target-ensure-package package target)))))
        (mapc (lambda (x) (terpri) (pprint x))
              (remove nil (cdr code)))
        (terpri))))
  
  
  #|
  (load "clorb:src;iop-idl")
  (gen-stub-file (lookup-name "IOP") "clorb:x-iop.lisp")
  (gen-stub-file (lookup-name "CORBA") "clorb:orb-stub.lisp")
  (gen-stub-file (lookup-name "CosNaming") "clorb:x-cosnaming.lisp" :package-def t)
  
  
  (defvar *target* (make-instance 'code-target))
  (target-code (lookup-name "CosNaming") *target*)
  
  (pprint
  (loop for sym in (slot-value *target* 'symbols)
        collect (cons (package-name (symbol-package sym)) (symbol-name sym))))
  
  (pprint (make-target-ensure-package (elt (slot-value *target* 'packages) 2) *target*))
  
  
  
  |#
  
negative.code: (defmethod target-typecode ((x CORBA:IDLType) target)
    `(symbol-typecode ',(scoped-target-symbol target x)))
  
  (defmethod target-typecode ((x CORBA:ExceptionDef) target)
    `(symbol-typecode ',(scoped-target-symbol target x)))
  
  
  ;;;; target-code methods
  
  