*** empty log message ***

9 files changed, 742 insertions, 1311 deletions

diff --git a/TAO/tests/Cubit/Orbix/base_server/Makefile b/TAO/tests/Cubit/Orbix/base_server/Makefile
index 3bf0684dfd5..a6aa32a05ce 100644
--- a/TAO/tests/Cubit/Orbix/base_server/Makefile
+++ b/TAO/tests/Cubit/Orbix/base_server/Makefile
@@ -12,13 +12,14 @@ SRC = cubitS.cpp cubit_impl.cpp server.cpp
 
 SVR_OBJS = cubitS.o cubit_impl.o server.o
 
-LDLIBS	 = 
+LDLIBS	 = -lorbixmt
 
 VLDLIBS	 = $(LDLIBS:%=%$(VAR))
 
 #----------------------------------------------------------------------------
 #	Include macros and targets
 #----------------------------------------------------------------------------
+exceptions = 1
 
 include		$(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU
 include		$(ACE_ROOT)/include/makeinclude/macros.GNU
@@ -34,8 +35,8 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
 
 
 ORBIX_BINDIR    = $(ORBIX_ROOT)/bin
-ORBIX_LIBDIR    = $(ORBIX_ROOT)/corba2/lib
-ORBIX_INCDIR    = $(ORBIX_ROOT)/corba2/include
+ORBIX_LIBDIR    = $(ORBIX_ROOT)/lib
+ORBIX_INCDIR    = $(ORBIX_ROOT)/inc
 
 # Remove -DCubit_USE_BOA from below to use the TIE approach
 
@@ -53,37 +54,20 @@ all: server
 server: $(addprefix $(VDIR),$(SVR_OBJS))
 	$(LINK.cc) -o server $(addprefix $(VDIR),$(SVR_OBJS)) $(LDFLAGS) $(ITIIOP) $(ITSRV) $(VLDLIBS) $(POSTLINK)
 
+realclean: clean
+	-/bin/rm -rf server cubitC.* cubitS.* cubit.hh
 #----------------------------------------------------------------------------
 #	Dependencies
 #----------------------------------------------------------------------------
 # DO NOT DELETE THIS LINE -- g++dep uses it.
 # DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY.
 
-.obj/cubit_impl.o .shobj/cubit_impl.so: cubit_impl.cpp cubit_impl.h cubit.h \
- $(ACE_ROOT)/ace/OS.h \
- $(ACE_ROOT)/ace/config.h \
- $(ACE_ROOT)/ace/config-sunos5.5-sunc++-4.x.h \
+.obj/cubitS.o .obj/cubitS.so .shobj/cubitS.o .shobj/cubitS.so: cubitS.cpp cubit.hh cubitC.cpp
+.obj/cubit_impl.o .obj/cubit_impl.so .shobj/cubit_impl.o .shobj/cubit_impl.so: cubit_impl.cpp cubit_impl.h cubit.hh
+.obj/server.o .obj/server.so .shobj/server.o .shobj/server.so: server.cpp \
  $(ACE_ROOT)/ace/streams.h \
- $(ACE_ROOT)/ace/OS.i \
- $(ACE_ROOT)/ace/Trace.h \
- $(ACE_ROOT)/ace/Log_Msg.h \
- $(ACE_ROOT)/ace/Log_Record.h \
- $(ACE_ROOT)/ace/ACE.h \
- $(ACE_ROOT)/ace/ACE.i \
- $(ACE_ROOT)/ace/Log_Priority.h \
- $(ACE_ROOT)/ace/Log_Record.i
-.obj/server.o .shobj/server.so: server.cpp cubit_impl.h cubit.h \
- $(ACE_ROOT)/ace/OS.h \
- $(ACE_ROOT)/ace/config.h \
- $(ACE_ROOT)/ace/config-sunos5.5-sunc++-4.x.h \
- $(ACE_ROOT)/ace/streams.h \
- $(ACE_ROOT)/ace/OS.i \
- $(ACE_ROOT)/ace/Trace.h \
- $(ACE_ROOT)/ace/Log_Msg.h \
- $(ACE_ROOT)/ace/Log_Record.h \
- $(ACE_ROOT)/ace/ACE.h \
- $(ACE_ROOT)/ace/ACE.i \
- $(ACE_ROOT)/ace/Log_Priority.h \
- $(ACE_ROOT)/ace/Log_Record.i
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h cubit_impl.h \
+ cubit.hh
 
 # IF YOU PUT ANYTHING HERE IT WILL GO AWAY
diff --git a/TAO/tests/Cubit/Orbix/base_server/cubit.h b/TAO/tests/Cubit/Orbix/base_server/cubit.h
deleted file mode 100644
index 1c868a6597d..00000000000
--- a/TAO/tests/Cubit/Orbix/base_server/cubit.h
+++ /dev/null
@@ -1,727 +0,0 @@
-
-#ifndef cubit_hh
-#define cubit_hh
-
-#include "ace/OS.h"
-#include <CORBA.h>
-
-
-#ifndef _Cubit_defined
-#define _Cubit_defined
-class Cubit_dispatch : public virtual CORBA::PPTR {
-public:
-
-      Cubit_dispatch (void *IT_p, CORBA::Object* IT_o, const char *IT_m, 
-        CORBA::LoaderClass *IT_l, char *IT_i, void* IT_im)
-       : PPTR (IT_p,IT_o,IT_m,IT_l,IT_i,IT_im) {}
-
-
-   Cubit_dispatch (char *IT_OR, void *IT_p, CORBA::Object *IT_o)
-       : PPTR (IT_OR,IT_p,IT_o) {}
-
-
-   Cubit_dispatch () {}
-
-   Cubit_dispatch (ObjectReference *IT_OR, void *IT_p, CORBA::Object *IT_o)
-       : PPTR (IT_OR,IT_p,IT_o) {}
-
-
-   Cubit_dispatch (void *IT_p, CORBA::Object *IT_o, const char *IT_m, 
-        char *IT_i, CORBA::Object* IT_ob, void* IT_im)
-       : PPTR (IT_p,IT_o,IT_m,IT_i,IT_ob,IT_im) {}
-
-
-   virtual unsigned char dispatch (CORBA::Request &IT_r, 
-        unsigned char IT_isTarget, void* IT_pp=NULL);
-
-
-};
-
-class Cubit;
-
-#ifndef CubitPtr
-#define CubitPtr
-
-typedef Cubit* Cubit_ptr;
-
-typedef Cubit* CubitRef;
-
-#endif
-
-
-#ifndef CubitForwH
-#define CubitForwH
-CORBA::ObjectRef Cubit_getBase (void *);
-void Cubit_release (Cubit *, CORBA::Environment &IT_env);
-void Cubit_release (Cubit_ptr);
-Cubit* Cubit_duplicate (Cubit_ptr, CORBA::Environment &IT_env);
-Cubit* Cubit_duplicate (Cubit_ptr );
-Cubit_ptr Cubit_nil (CORBA::Environment &IT_env);
-Cubit_ptr Cubit_nil ();
-#endif
-#define Cubit_IMPL "Cubit"
-
-
-class Cubit;
-
-typedef Cubit CubitProxy;
-#define Cubit_IR "Cubit$v1.1"
-#define Cubit_IMPL "Cubit"
-
-#ifndef CubitPtr
-#define CubitPtr
-
-typedef Cubit* Cubit_ptr;
-
-typedef Cubit* CubitRef;
-
-#endif
-
-class Cubit: public virtual CORBA::Object  {
-public:
-        Cubit (char *IT_OR);
-    Cubit (ObjectReference *IT_OR);
-    Cubit () : CORBA::Object  (1) {}
-protected:
-    Cubit_ptr __duplicate(
-            CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) {
-       CORBA::Object::__duplicate (IT_env);
-       return this;
-    }
-public:
-    static Cubit_ptr _duplicate(
-            Cubit_ptr, 
-            CORBA::Environment &IT_pEnv=CORBA::IT_chooseDefaultEnv ());
-public:
-   static Cubit* _bind (const char* IT_markerServer, const char* host,
-		const CORBA::Context &IT_c, 
-		CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
-   static Cubit* _bind (CORBA::Environment &IT_env);
-   static Cubit* _bind (const char* IT_markerServer=NULL, const char* host=NULL,
-                 CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
-    static Cubit* _narrow (CORBA::Object* , CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
-    static Cubit_ptr _nil (CORBA::Environment &IT_pEnv=CORBA::IT_chooseDefaultEnv ()) {
-        CORBA::EnvExcRaiser IT_raise;
-        CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv);
-        return (Cubit_ptr) CORBA::OBJECT_NIL;}
-
-#ifndef Cubit_Many_defined
-#define Cubit_Many_defined
-
-struct Many {
-    CORBA::Octet o;
-    CORBA::Long l;
-    CORBA::Short s;
-
-    void encodeOp (CORBA::Request &IT_r) const;
-    void decodeOp (CORBA::Request &IT_r);
-    void decodeInOutOp (CORBA::Request &IT_r);
-    Many(const Many &);
-    Many();
-    ~Many();
-    Many& operator= (const Many&);
-};
-
-#ifndef Cubit_ManyVarH
-#define Cubit_ManyVarH
-
-#ifndef Cubit_ManyvPtr
-#define Cubit_ManyvPtr
-typedef Many* Many_vPtr;
-typedef const Many* Many_cvPtr;
-#endif
-
-class Many_var : public CORBA::_var
-{
-    private:
-
-    unsigned char copyHelper (const Many_var &IT_s) {
-        if (!IT_s._ptr) {
-            _ptr = IT_s._ptr;
-        } else
-        {
-            _ptr = new Many;
-            *(_ptr) =  *(IT_s._ptr);
-        }
-        return 1;
-    }
-
-    public:
-
-    Many_var (const Many_var &IT_s) {
-        (void) copyHelper (IT_s);
-    }
-
-    Many_var () {
-        _ptr =  new Many;
-;
-    }
-
-    Many_var (Many *IT_p) {
-        _ptr = IT_p;
-    }
-
-    Many_var &operator= (Many *IT_p) {
-        if (_ptr != IT_p) {
-            delete _ptr;
-        }
-        _ptr = IT_p;
-        return (*this);
-    }
-
-    Many_var &operator= (const Many_var &IT_s) {
-        if (_ptr != IT_s._ptr) {
-            delete _ptr;
-        }
-        _ptr = new Many;
-        *(_ptr) =  *(IT_s._ptr);
-        return (*this);
-    }
-
-    ~Many_var () {
-        delete _ptr;
-    }
-
-    Many* operator-> () {
-        return _ptr;
-    }
-
-    operator Many_cvPtr () const { return _ptr;}
-    operator Many_vPtr& () { return _ptr;}
-    operator Many& () const { return * _ptr;}
-
-    protected:
-    Many *_ptr;
-    private:
-    Many_var &operator= (const CORBA::_var &IT_s);
-    Many_var (const CORBA::_var &IT_s);
-};
-
-#endif
-
-
-#endif
-
-enum discrim {e_0th,e_1st,e_2nd,e_3rd,e_4th,e_5th, IT__ENUM_Cubit_discrim=CORBA_ULONG_MAX};
-
-#ifndef Cubit_oneof_defined
-#define Cubit_oneof_defined
-
-struct oneof {
-    private:
-
-    discrim __d;
-    union {
-        CORBA::Octet _o_;
-        CORBA::Short _s_;
-        CORBA::Long _l_;
-        Many * _cm_;
-    };
-
-    public:
-
-    void encodeOp (CORBA::Request &IT_r) const;
-    void decodeOp (CORBA::Request &IT_r);
-    void decodeInOutOp (CORBA::Request &IT_r);
-
-    private:
-
-    unsigned char isSet;
-
-    public:
-
-    discrim _d () const { return __d; }
-
-    CORBA::Octet o () const {
-      return _o_;
-    }
-
-    void o (CORBA::Octet IT_member) {
-        if (isSet && (__d != Cubit::e_0th))
-        {
-            this-> oneof::~oneof();
-            memset(this, 0, sizeof(*this));
-        }
-
-        __d = Cubit::e_0th;
-        isSet = 1;
-        _o_ = IT_member;
-    }
-
-    CORBA::Short s () const {
-        return _s_;
-    }
-
-    void s (CORBA::Short IT_member) {
-        if (isSet && (__d != Cubit::e_1st))
-        {
-            this-> oneof::~oneof();
-            memset(this, 0, sizeof(*this));
-        }
-
-        __d = Cubit::e_1st;
-        isSet = 1;
-        _s_ = IT_member;
-    }
-
-    CORBA::Long l () const {
-        return _l_;
-    }
-
-    void l (CORBA::Long IT_member) {
-        if (isSet && (__d != Cubit::e_2nd))
-        {
-            this-> oneof::~oneof();
-            memset(this, 0, sizeof(*this));
-        }
-
-        __d = Cubit::e_2nd;
-        isSet = 1;
-        _l_ = IT_member;
-    }
-
-    Many& cm () {
-        return (*_cm_);
-    }
-
-    const Many& cm () const {
-        return (*_cm_);
-    }
-
-    void cm (const Many& IT_member) {
-        if (isSet && (__d != Cubit::e_3rd))
-        {
-            this-> oneof::~oneof();
-            memset(this, 0, sizeof(*this));
-        }
-
-        __d = Cubit::e_3rd;
-
-        if (!isSet) {
-            _cm_ = new Many;
-            isSet = 1;
-        }
-        *(_cm_) = IT_member;
-    }
-
-
-    oneof();
-    oneof(const oneof &);
-    ~oneof();
-    oneof& operator= (const oneof&);
-};
-
-#ifndef Cubit_oneofVarH
-#define Cubit_oneofVarH
-
-#ifndef Cubit_oneofvPtr
-#define Cubit_oneofvPtr
-typedef oneof* oneof_vPtr;
-typedef const oneof* oneof_cvPtr;
-#endif
-
-class oneof_var : public CORBA::_var
-{
-    private:
-
-    unsigned char copyHelper (const oneof_var &IT_s) {
-        if (!IT_s._ptr) {
-            _ptr = IT_s._ptr;
-        } else
-        {
-            _ptr = new oneof;
-            *(_ptr) =  *(IT_s._ptr);
-        }
-        return 1;
-    }
-
-    public:
-
-    oneof_var (const oneof_var &IT_s) {
-        (void) copyHelper (IT_s);
-    }
-
-    oneof_var () {
-        _ptr = NULL;
-    }
-
-    oneof_var (oneof *IT_p) {
-        _ptr = IT_p;
-    }
-
-    oneof_var &operator= (oneof *IT_p) {
-        if (_ptr != IT_p) {
-            delete _ptr;
-        }
-        _ptr = IT_p;
-        return (*this);
-    }
-
-    oneof_var &operator= (const oneof_var &IT_s) {
-        if (_ptr != IT_s._ptr) {
-            delete _ptr;
-        }
-        _ptr = new oneof;
-        *(_ptr) =  *(IT_s._ptr);
-        return (*this);
-    }
-
-    ~oneof_var () {
-        delete _ptr;
-    }
-
-    oneof* operator-> () {
-        return _ptr;
-    }
-
-    operator oneof_cvPtr () const { return _ptr;}
-    operator oneof_vPtr& () { return _ptr;}
-    operator oneof& () const { return * _ptr;}
-
-    protected:
-    oneof *_ptr;
-    private:
-    oneof_var &operator= (const CORBA::_var &IT_s);
-    oneof_var (const CORBA::_var &IT_s);
-};
-
-#endif
-
-
-#endif
-        virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException);
-        virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException);
-        virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException);
-        virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException);
-        virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException);
-        virtual void please_exit (CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException);
-};
-
-#ifndef CubitVarH
-#define CubitVarH
-
-#ifndef CubitvPtr
-#define CubitvPtr
-typedef Cubit* Cubit_vPtr;
-typedef const Cubit* Cubit_cvPtr;
-#endif
-
-class Cubit_var : public CORBA::_var
-{
-    private:
-
-    unsigned char copyHelper (const Cubit_var &IT_s) {
-        {
-            _ptr = Cubit_duplicate (IT_s._ptr);
-        }
-        return 1;
-    }
-
-    public:
-
-    Cubit_var (const Cubit_var &IT_s) {
-        (void) copyHelper (IT_s);
-    }
-
-    Cubit_var () {
-        _ptr = Cubit_nil ();
-    }
-
-    Cubit_var (Cubit *IT_p) {
-        _ptr = IT_p;
-    }
-
-    Cubit_var &operator= (Cubit *IT_p) {
-        Cubit_release (_ptr);
-        _ptr = IT_p;
-        return (*this);
-    }
-
-    Cubit_var &operator= (const Cubit_var &IT_s) {
-        Cubit_release (_ptr);
-        _ptr = Cubit_duplicate (IT_s._ptr);
-        return (*this);
-    }
-
-    ~Cubit_var () {
-        Cubit_release (_ptr);
-    }
-
-    Cubit* operator-> () {
-        return _ptr;
-    }
-
-    operator Cubit_cvPtr () const { return _ptr;}
-    operator Cubit_vPtr& () { return _ptr;}
-
-    protected:
-    Cubit *_ptr;
-    private:
-    Cubit_var &operator= (const CORBA::_var &IT_s);
-    Cubit_var (const CORBA::_var &IT_s);
-    Cubit_var &operator= (const CORBA::_mgr &IT_s);
-    Cubit_var &operator= (const CORBA::_SeqElem &IT_s);
-    Cubit_var (const CORBA::_mgr &IT_s);
-    Cubit_var (const CORBA::_SeqElem &IT_s);
-};
-
-#endif
-
-
-#ifndef CubitMgrH
-#define CubitMgrH
-
-class Cubit_mgr : public CORBA::_mgr
-{
-    public:
-
-    Cubit_mgr () {
-        _ptr = Cubit_nil ();
-        _release = 1;
-    }
-
-    Cubit_mgr (const Cubit_mgr &IT_s) {
-        _ptr = Cubit_duplicate (IT_s._ptr);
-        _release = 1;
-    }
-
-    Cubit_mgr &operator= (Cubit *IT_p) {
-        if (_ptr && _release)
-            Cubit_release (_ptr);
-        _ptr = IT_p;
-        _release = 1;
-        return (*this);
-    }
-
-    Cubit_mgr &operator= (const Cubit_mgr &IT_s) {
-        if (_ptr && _release)
-            Cubit_release (_ptr);
-        _ptr = Cubit_duplicate(IT_s._ptr);
-        _release = 1;
-        return (*this);
-    }
-
-    Cubit_mgr &operator= (Cubit_var &IT_s) {
-        if (_ptr && _release)
-            Cubit_release (_ptr);
-        _ptr = Cubit_duplicate(IT_s);
-        _release = 1;
-        return (*this);
-    }
-
-    ~Cubit_mgr () {
-        if (_release)
-            Cubit_release (_ptr);
-    }
-
-    unsigned char release () {
-        return _release;
-    }
-
-    void release (unsigned char rel) {
-        _release = rel;
-    }
-
-    operator int () const {
-        return (((CORBA::Object_ptr) _ptr) ? 1 : 0);
-    }
-
-    operator void* () const {
-        return _ptr;
-    }
-
-    operator CORBA::Object * () const {
-        return (CORBA::Object *) _ptr;
-    }
-
-    operator Cubit* () const {
-        return (Cubit*) _ptr;
-    }
-
-    Cubit_ptr operator-> () const {
-        return _ptr;
-    }
-
-    Cubit *_ptr;
-
-    protected:
-
-    unsigned char _release;
-};
-
-typedef Cubit_mgr Cubit_mgr_IT_const;
-#endif
-
-#ifndef CubitSeqElemH
-#define CubitSeqElemH
-
-class Cubit_SeqElem : public CORBA::_SeqElem
-{
-    public:
-
-    Cubit_SeqElem (Cubit_ptr* IT_p, unsigned char rel) {
-        _ptr = IT_p;
-        _release = rel;
-    }
-
-    Cubit_SeqElem &operator= (Cubit_ptr IT_p) {
-        if (_ptr) {
-            if (*(_ptr) && _release)
-                Cubit_release (*(_ptr));
-            *(_ptr) = IT_p;
-        }
-        return (*this);
-    }
-
-    Cubit_SeqElem &operator= (const Cubit_SeqElem &IT_s) {
-        if (_ptr && IT_s._ptr) {
-            if (*(_ptr) && _release)
-                Cubit_release (*(_ptr));
-            *(_ptr) = Cubit_duplicate(*(IT_s._ptr));
-        }
-        return (*this);
-    }
-
-    operator Cubit_ptr () const {
-        return _ptr ? (Cubit_ptr) (*_ptr) : Cubit_nil(); 
-    }
-
-    Cubit_ptr operator->() const { return *_ptr;}
-
-    protected:
-    Cubit_ptr *_ptr;
-    unsigned char _release;
-};
-
-#endif
-
-
-#define TIE_Cubit(X) Cubit##X
-
-#define DEF_TIE_Cubit(X) \
-	class Cubit##X : public virtual Cubit {		\
-	  X* m_obj;						\
-	public:							\
-								\
-								\
-	   Cubit##X  (X *objp, const char* m="", CORBA::LoaderClass *l=0)\
-		: Cubit(), m_obj(objp) {	\
-		m_pptr = new Cubit_dispatch		\
-			(( Cubit*)this,(CORBA::Object*)this,m,l,Cubit_IR,m_obj);	\
-	   }								\
-	   Cubit##X  (CORBA::Object *IT_p, const char* IT_m="", void *IT_q=0)\
-		: Cubit() {	\
-		m_pptr = new Cubit_dispatch		\
-			(( Cubit*)this,(CORBA::Object*)this,IT_m,Cubit_IR,IT_p,IT_q);	\
-		m_obj = (X*)(m_pptr->getImplObj ());			\
-	   }								\
-								\
-	   virtual ~Cubit##X  () {				\
-		if (_okToDeleteImpl ()) delete m_obj; }					\
-	   virtual void* _deref () {					\
-		return m_obj; }					\
-								\
-virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
-return m_obj->cube_octet (  o,IT_env);\
-}\
-	\
-virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
-return m_obj->cube_short (  s,IT_env);\
-}\
-	\
-virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
-return m_obj->cube_long (  l,IT_env);\
-}\
-	\
-virtual Cubit::Many cube_struct (const Cubit::Many& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
-return m_obj->cube_struct (  values,IT_env);\
-}\
-	\
-virtual Cubit::oneof cube_union (const Cubit::oneof& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
-return m_obj->cube_union (  values,IT_env);\
-}\
-	\
-virtual void please_exit (CORBA::Environment &IT_env) throw (CORBA::SystemException){\
-m_obj->please_exit (IT_env);\
-}\
-								\
-	};						\
-
-
-#define QUALS_Cubit	\
-virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
-return m_obj->cube_octet (  o,IT_env);\
-}\
-	\
-virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
-return m_obj->cube_short (  s,IT_env);\
-}\
-	\
-virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
-return m_obj->cube_long (  l,IT_env);\
-}\
-	\
-virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
-return m_obj->cube_struct (  values,IT_env);\
-}\
-	\
-virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
-return m_obj->cube_union (  values,IT_env);\
-}\
-	\
-virtual void please_exit (CORBA::Environment &IT_env) throw (CORBA::SystemException){\
-m_obj->please_exit (IT_env);\
-}\
-
-
-
-
-class CubitProxyFactoryClass : public virtual CORBA::ObjectFactoryClass {
-public:
-   CubitProxyFactoryClass (unsigned char IT_p=0)
-		: CORBA::ProxyFactory (Cubit_IR, IT_p) {}
-
-    virtual void* New (char *IT_OR, CORBA::Environment&);
-
-    virtual void* New (ObjectReference *IT_OR, CORBA::Environment&);
-
-    virtual void* New2 (); 
-
-    virtual CORBA::Object* NewObject (char *IT_OR, CORBA::Environment&);
-
-    virtual CORBA::Object* NewObject (ObjectReference *IT_OR, CORBA::Environment&);
-
-    virtual CORBA::Object* New2Object (); 
-
-    virtual void* IT_castUp (void *IT_p, char* IT_s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
-
-    virtual CORBA::PPTR* pptr (void *IT_p);
-
-    virtual void baseInterfaces (_IDL_SEQUENCE_string&);
-
-
-};
-
-extern CubitProxyFactoryClass CubitProxyFactory;
-
-class CubitBOAImpl : public virtual Cubit  {
-public:
-    CubitBOAImpl (const char *m="", CORBA::LoaderClass *l=NULL) {
-  if (CORBA::PPTR::isOK (m_pptr, Cubit_IR))
-    m_pptr = new Cubit_dispatch ( (Cubit*)this,
-   	 (CORBA::Object*)this, m, l, Cubit_IR, this);
-}
-
-        virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0;
-        virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0;
-        virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0;
-        virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0;
-        virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0;
-        virtual void please_exit (CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0;
-};
-
-
-#endif
-
-
-#endif
diff --git a/TAO/tests/Cubit/Orbix/base_server/cubitC.cpp b/TAO/tests/Cubit/Orbix/base_server/cubitC.cpp
index c47e38f26ee..3f7f893e543 100644
--- a/TAO/tests/Cubit/Orbix/base_server/cubitC.cpp
+++ b/TAO/tests/Cubit/Orbix/base_server/cubitC.cpp
@@ -1,36 +1,185 @@
-#include "cubit.h"
+
+#include "cubit.hh"
+
+Cubit_mgr::Cubit_mgr () 
+{
+    _ptr = Cubit:: _nil ();
+}
+
+Cubit_mgr::Cubit_mgr (const Cubit_mgr &IT_s) 
+{
+    _ptr = Cubit:: _duplicate (IT_s._ptr);
+}
+
+Cubit_mgr::Cubit_mgr (Cubit_var IT_s) 
+{
+    _ptr = Cubit:: _duplicate (IT_s);
+}
+
+Cubit_mgr::Cubit_mgr (const Cubit_SeqElem &IT_s) 
+{
+    _ptr = Cubit:: _duplicate (IT_s);
+}
+
+Cubit_mgr &Cubit_mgr::operator= (Cubit_ptr IT_p) {
+    CORBA::release (_ptr);
+    _ptr = IT_p;
+    return (*this);
+}
+
+Cubit_mgr &Cubit_mgr::operator= (const Cubit_mgr &IT_s) {
+    CORBA::release (_ptr);
+    _ptr = Cubit:: _duplicate(IT_s._ptr);
+    return (*this);
+}
+
+Cubit_mgr &Cubit_mgr::operator= (Cubit_var IT_s) {
+    CORBA::release (_ptr);
+    _ptr = Cubit:: _duplicate(IT_s);
+    return (*this);
+}
+
+Cubit_mgr &Cubit_mgr::operator= (const Cubit_SeqElem &IT_s) {
+    CORBA::release (_ptr);
+    _ptr = Cubit:: _duplicate(IT_s);
+    return (*this);
+}
+
+Cubit_mgr::~Cubit_mgr () {
+    CORBA::release (_ptr);
+}
+
+Cubit_ptr Cubit_mgr:: operator-> () const {
+    return _ptr;
+}
+
+Cubit_mgr::operator ! () const {
+    return ((CORBA::is_nil (_ptr)));
+}
+
+Cubit_mgr::operator Cubit_ptr& () { return (Cubit_ptr &) (_ptr);}
+Cubit_mgr::operator const Cubit_ptr& () const { return (Cubit_ptr &) (_ptr);}
+
+Cubit_mgr::operator CORBA::Object_ptr () const {
+    return _ptr;
+}
+
+Cubit_ptr Cubit_mgr:: in () const {
+    return _ptr;
+}
+
+Cubit_ptr& Cubit_mgr:: inOut () {
+    return _ptr;
+}
+
+Cubit_ptr& Cubit_mgr:: out () {
+    return _ptr;
+}
+
+Cubit_ptr Cubit_mgr:: ret () const {
+    return _ptr;
+}
+
+Cubit_SeqElem::Cubit_SeqElem (Cubit_ptr* IT_p, unsigned char rel) {
+    _ptr = IT_p;
+    _release = rel;
+}
+
+Cubit_SeqElem &Cubit_SeqElem::operator= (Cubit_ptr IT_p) {
+    if (_ptr) {
+        if (_release)
+            CORBA::release (*(_ptr));
+        *(_ptr) = IT_p;
+    }
+    return (*this);
+}
+
+Cubit_SeqElem &Cubit_SeqElem::operator= (const Cubit_SeqElem &IT_s) {
+    if (_ptr && IT_s._ptr) {
+        if (_release)
+            CORBA::release (*(_ptr));
+        *(_ptr) = Cubit:: _duplicate(*(IT_s._ptr));
+    }
+    return (*this);
+}
+
+Cubit_SeqElem &Cubit_SeqElem::operator= (const Cubit_mgr &IT_s) {
+    if (_ptr ) {
+        if (_release)
+            CORBA::release (*(_ptr));
+        *(_ptr) = Cubit:: _duplicate(IT_s._ptr);
+    }
+    return (*this);
+}
+
+Cubit_SeqElem &Cubit_SeqElem::operator= (Cubit_var IT_s) {
+    if (_ptr ) {
+        if (_release)
+            CORBA::release (*(_ptr));
+        *(_ptr) = Cubit:: _duplicate (IT_s);
+    }
+    return (*this);
+}
+
+Cubit_SeqElem::operator ! () const {
+    return ((CORBA::is_nil (*_ptr)));
+}
+
+Cubit_SeqElem::operator const Cubit_ptr& () const { return (Cubit_ptr &) (*_ptr);}
+
+Cubit_SeqElem::operator CORBA::Object_ptr () const {
+    return *_ptr;
+}
+
+Cubit_ptr Cubit_SeqElem:: in () const {
+    return *_ptr;
+}
+
+Cubit_ptr& Cubit_SeqElem:: inOut () {
+    return *_ptr;
+}
+
+Cubit_ptr& Cubit_SeqElem:: out () {
+    return *_ptr;
+}
+
+Cubit_ptr Cubit_SeqElem:: ret () const {
+    return *_ptr;
+}
+
+Cubit_ptr Cubit_SeqElem::operator->() const { return *_ptr;}
 
 Cubit::Cubit (char *IT_OR) {
       m_pptr = new Cubit_dispatch (IT_OR, this,(CORBA::Object*)this);
 } 
-Cubit::Cubit (ObjectReference *IT_OR) {
+Cubit::Cubit (ObjectReferenceImpl *IT_OR) {
       m_pptr = new Cubit_dispatch (IT_OR, this,(CORBA::Object*)this);
 } 
 
 #ifndef CubitForwC
 #define CubitForwC
-CORBA::ObjectRef Cubit_getBase(void *IT_p){
+CORBA::ObjectRef CALL_SPEC Cubit_getBase(void *IT_p){
     return (Cubit*) IT_p;}
 
-void Cubit_release (Cubit_ptr IT_p, CORBA::Environment &IT_env) {
+void CALL_SPEC Cubit_release (Cubit_ptr IT_p, CORBA::Environment &IT_env) {
     CORBA::release(IT_p, IT_env);}
 
-void Cubit_release (Cubit_ptr IT_p) {
+void CALL_SPEC Cubit_release (Cubit_ptr IT_p) {
     Cubit_release (IT_p, CORBA::IT_chooseDefaultEnv ()); }
 
-Cubit_ptr Cubit_nil (CORBA::Environment &) {
+Cubit_ptr CALL_SPEC Cubit_nil (CORBA::Environment &) {
     return Cubit:: _nil ();}
 
-Cubit_ptr Cubit_nil () {
+Cubit_ptr CALL_SPEC Cubit_nil () {
     return Cubit_nil (CORBA::IT_chooseDefaultEnv ());}
 
-Cubit_ptr Cubit_duplicate (Cubit_ptr IT_p, CORBA::Environment &IT_env) {
+Cubit_ptr CALL_SPEC Cubit_duplicate (Cubit_ptr IT_p, CORBA::Environment &IT_env) {
     return (Cubit::_duplicate(IT_p, IT_env)); }
-Cubit_ptr Cubit_duplicate (Cubit_ptr IT_p) {
+Cubit_ptr CALL_SPEC Cubit_duplicate (Cubit_ptr IT_p) {
     return Cubit_duplicate (IT_p, CORBA::IT_chooseDefaultEnv ()); }
 #endif
 
-Cubit_ptr Cubit::_duplicate(Cubit_ptr obj, CORBA::Environment& IT_pEnv) {
+Cubit_ptr CALL_SPEC Cubit::_duplicate(Cubit_ptr obj, CORBA::Environment& IT_pEnv) {
         CORBA::EnvExcRaiser IT_raise;
         CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv);
        if (!obj) {
@@ -42,7 +191,7 @@ Cubit_ptr Cubit::_duplicate(Cubit_ptr obj, CORBA::Environment& IT_pEnv) {
 
 
 
-Cubit* Cubit:: _bind (const char* IT_markerServer, const char* host,
+Cubit* CALL_SPEC Cubit:: _bind (const char* IT_markerServer, const char* host,
 		const CORBA::Context &IT_c, 
 		CORBA::Environment &IT_env) {
        return (Cubit*)CORBA::Factory.New (IT_markerServer, IT_env, IT_c, host, 
@@ -51,14 +200,14 @@ Cubit* Cubit:: _bind (const char* IT_markerServer, const char* host,
 
 
 
-Cubit* Cubit:: _bind (CORBA::Environment &IT_env) {
+Cubit* CALL_SPEC Cubit:: _bind (CORBA::Environment &IT_env) {
        return _bind (NULL,NULL,CORBA::Context(), IT_env); }
 
 
-Cubit* Cubit:: _bind (const char* IT_markerServer, const char* host,
+Cubit* CALL_SPEC Cubit:: _bind (const char* IT_markerServer, const char* host,
                 CORBA::Environment &IT_env) {
        return _bind (IT_markerServer, host, CORBA::Context (), IT_env); }
-Cubit* Cubit::_narrow (CORBA::Object* IT_obj, CORBA::Environment &IT_pEnv) {
+Cubit* CALL_SPEC Cubit::_narrow (CORBA::Object* IT_obj, CORBA::Environment &IT_pEnv) {
         CORBA::EnvExcRaiser IT_raise;
         CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv);
         if (CORBA::is_nil (IT_obj)) {
@@ -73,6 +222,8 @@ Cubit* Cubit::_narrow (CORBA::Object* IT_obj, CORBA::Environment &IT_pEnv) {
         return IT_p;
    }
 
+const void* Cubit:: IT_impl = CORBA::IT_implTable.record (Cubit_IMPL, "IDL:Eng.SUN.COM/Cubit:1.0");
+
 
 #ifndef Cubit_Many_Ops
 #define Cubit_Many_Ops
@@ -125,6 +276,107 @@ Cubit::Many &Cubit::Many:: operator= (const Cubit::Many& IT_s) {
     return *this;
 }
 
+unsigned char Cubit::Many_var ::copyHelper (const Many_var &IT_s) {
+    if (!IT_s._ptr) {
+        _ptr = IT_s._ptr;
+    } else
+    {
+        _ptr = new Many;
+        *(_ptr) =  *(IT_s._ptr);
+    }
+    return 1;
+}
+
+Cubit::Many_ptr* Cubit::Many_var ::_newPtr () {
+    return new Cubit::Many_ptr;
+}
+
+Cubit::Many_var ::Many_var (const Many_var &IT_s) 
+    :
+    _indPtr(_newPtr()),
+    _ptr(*_indPtr)
+{
+    (void) copyHelper (IT_s);
+}
+
+Cubit::Many_var ::Many_var () 
+    :
+    _indPtr(_newPtr()),
+    _ptr(*_indPtr)
+{
+    _ptr = NULL;
+}
+
+Cubit::Many_var ::Many_var (Many_ptr IT_p) 
+    :
+    _indPtr(_newPtr()),
+    _ptr(*_indPtr)
+{
+    _ptr = IT_p;
+}
+
+Cubit::Many_var &Cubit::Many_var :: operator= (Many_ptr IT_p) {
+    if (_ptr != IT_p) {
+        if (_ptr) {
+                delete _ptr;
+                _ptr = 0;
+        }
+    }
+    _ptr = IT_p;
+    return (*this);
+}
+
+Cubit::Many_var &Cubit::Many_var :: operator= (const Many_var &IT_s) {
+    if (_ptr != IT_s._ptr) {
+        if (_ptr) {
+                delete _ptr;
+                _ptr = 0;
+        }
+    }
+    _ptr = new Many;
+    *(_ptr) =  *(IT_s._ptr);
+    return (*this);
+}
+
+Cubit::Many_var ::~Many_var () {
+    if (_ptr) {
+        delete _ptr;
+        _ptr = 0;
+    }
+    if ( _indPtr ) {
+        delete _indPtr;
+        _indPtr = 0;
+    }
+}
+
+Cubit::Many_ptr Cubit::Many_var :: operator-> () const {
+    return _ptr;
+}
+
+Cubit::Many_var::operator ! () const {
+    return (_ptr ? 0 : 1);
+}
+
+Cubit::Many_var::operator Cubit::Many_ptr& () { return (Cubit::Many_ptr &) (_ptr);}
+Cubit::Many_var::operator const Cubit::Many_cptr& () const { return (Cubit::Many_cptr &) (_ptr);}
+Cubit::Many_var:: operator Cubit::Many& () const { return (Cubit::Many&) (* _ptr);}
+
+const Cubit::Many Cubit::Many_var :: in () const {
+    return *_ptr;
+}
+
+Cubit::Many& Cubit::Many_var :: inOut () {
+    return *_ptr;
+}
+
+Cubit::Many& Cubit::Many_var :: out () {
+    return *_ptr;
+}
+
+Cubit::Many Cubit::Many_var :: ret () const {
+    return *_ptr;
+}
+
 
 #endif
 
@@ -266,6 +518,20 @@ void Cubit::oneof:: decodeInOutOp (CORBA::Request &IT_r) {
 
 }
 
+Cubit::oneof:: oneof(const Cubit::discrim d) {
+    memset(this, 0, sizeof(*this));
+    __d = d;
+    isSet = 1;
+    switch (__d) {
+        case Cubit::e_0th:         break;
+        case Cubit::e_1st:         break;
+        case Cubit::e_2nd:         break;
+        case Cubit::e_3rd: 
+        default:         _cm_ = new Cubit::Many;
+        break;
+    }
+}
+
 Cubit::oneof:: oneof() { 
     memset(this, 0, sizeof(*this));
     isSet = 0;
@@ -343,26 +609,251 @@ Cubit::oneof& Cubit::oneof:: operator= (const Cubit::oneof & IT_s) {
     return *this;
 }
 
+unsigned char Cubit::oneof_var ::copyHelper (const oneof_var &IT_s) {
+    if (!IT_s._ptr) {
+        _ptr = IT_s._ptr;
+    } else
+    {
+        _ptr = new oneof;
+        *(_ptr) =  *(IT_s._ptr);
+    }
+    return 1;
+}
+
+Cubit::oneof_ptr* Cubit::oneof_var ::_newPtr () {
+    return new Cubit::oneof_ptr;
+}
+
+Cubit::oneof_var ::oneof_var (const oneof_var &IT_s) 
+    :
+    _indPtr(_newPtr()),
+    _ptr(*_indPtr)
+{
+    (void) copyHelper (IT_s);
+}
+
+Cubit::oneof_var ::oneof_var () 
+    :
+    _indPtr(_newPtr()),
+    _ptr(*_indPtr)
+{
+    _ptr = NULL;
+}
+
+Cubit::oneof_var ::oneof_var (oneof_ptr IT_p) 
+    :
+    _indPtr(_newPtr()),
+    _ptr(*_indPtr)
+{
+    _ptr = IT_p;
+}
+
+Cubit::oneof_var &Cubit::oneof_var :: operator= (oneof_ptr IT_p) {
+    if (_ptr != IT_p) {
+        if (_ptr) {
+                delete _ptr;
+                _ptr = 0;
+        }
+    }
+    _ptr = IT_p;
+    return (*this);
+}
+
+Cubit::oneof_var &Cubit::oneof_var :: operator= (const oneof_var &IT_s) {
+    if (_ptr != IT_s._ptr) {
+        if (_ptr) {
+                delete _ptr;
+                _ptr = 0;
+        }
+    }
+    _ptr = new oneof;
+    *(_ptr) =  *(IT_s._ptr);
+    return (*this);
+}
+
+Cubit::oneof_var ::~oneof_var () {
+    if (_ptr) {
+        delete _ptr;
+        _ptr = 0;
+    }
+    if ( _indPtr ) {
+        delete _indPtr;
+        _indPtr = 0;
+    }
+}
+
+Cubit::oneof_ptr Cubit::oneof_var :: operator-> () const {
+    return _ptr;
+}
+
+Cubit::oneof_var::operator ! () const {
+    return (_ptr ? 0 : 1);
+}
+
+Cubit::oneof_var::operator Cubit::oneof_ptr& () { return (Cubit::oneof_ptr &) (_ptr);}
+Cubit::oneof_var::operator const Cubit::oneof_cptr& () const { return (Cubit::oneof_cptr &) (_ptr);}
+Cubit::oneof_var:: operator Cubit::oneof& () const { return (Cubit::oneof&) (* _ptr);}
+
+const Cubit::oneof Cubit::oneof_var :: in () const {
+    return *_ptr;
+}
+
+Cubit::oneof& Cubit::oneof_var :: inOut () {
+    return *_ptr;
+}
+
+Cubit::oneof& Cubit::oneof_var :: out () {
+    return *_ptr;
+}
+
+Cubit::oneof Cubit::oneof_var :: ret () const {
+    return *_ptr;
+}
+
 
 #endif
 
+unsigned char Cubit_var ::copyHelper (const Cubit_var &IT_s) {
+    {
+        _ptr = Cubit:: _duplicate (IT_s._ptr);
+    }
+    return 1;
+}
+
+unsigned char Cubit_var ::copyHelper (const Cubit_mgr &IT_s) {
+    _ptr = Cubit:: _duplicate (IT_s._ptr);
+return 1;
+}
+
+unsigned char Cubit_var ::copyHelper (const Cubit_SeqElem &IT_s) {
+    _ptr = Cubit:: _duplicate (IT_s);
+return 1;
+}
+
+Cubit_ptr* Cubit_var ::_newPtr () {
+    return new Cubit_ptr;
+}
+
+Cubit_var ::Cubit_var (const Cubit_var &IT_s) 
+    :
+    _indPtr(_newPtr()),
+    _ptr(*_indPtr)
+{
+    (void) copyHelper (IT_s);
+}
+
+Cubit_var ::Cubit_var (const Cubit_mgr &IT_s) 
+    :
+    _indPtr(_newPtr()),
+    _ptr(*_indPtr)
+{
+    (void) copyHelper (IT_s);
+}
+
+Cubit_var ::Cubit_var (const Cubit_SeqElem &IT_s) 
+    :
+    _indPtr(_newPtr()),
+    _ptr(*_indPtr)
+{
+    (void) copyHelper (IT_s);
+}
+
+Cubit_var ::Cubit_var () 
+    :
+    _indPtr(_newPtr()),
+    _ptr(*_indPtr)
+{
+    _ptr = Cubit:: _nil ();
+}
+
+Cubit_var ::Cubit_var (Cubit_ptr IT_p) 
+    :
+    _indPtr(_newPtr()),
+    _ptr(*_indPtr)
+{
+    _ptr = IT_p;
+}
+
+Cubit_var &Cubit_var :: operator= (Cubit_ptr IT_p) {
+    CORBA::release (_ptr);
+    _ptr = IT_p;
+    return (*this);
+}
+
+Cubit_var &Cubit_var :: operator= (const Cubit_var &IT_s) {
+    CORBA::release (_ptr);
+    _ptr = Cubit:: _duplicate (IT_s._ptr);
+    return (*this);
+}
+
+Cubit_var &Cubit_var :: operator= (const Cubit_mgr &IT_s) {
+    CORBA::release (_ptr);
+    _ptr = Cubit:: _duplicate (IT_s._ptr);
+    return (*this);
+}
+
+Cubit_var &Cubit_var :: operator= (const Cubit_SeqElem &IT_s) {
+    CORBA::release (_ptr);
+    _ptr = Cubit:: _duplicate (IT_s);
+    return (*this);
+}
+
+Cubit_var ::~Cubit_var () {
+    CORBA::release (_ptr);
+    if ( _indPtr ) {
+        delete _indPtr;
+        _indPtr = 0;
+    }
+}
+
+Cubit_ptr Cubit_var :: operator-> () const {
+    return _ptr;
+}
+
+Cubit_var::operator ! () const {
+    return ((CORBA::is_nil (_ptr)));
+}
+
+Cubit_var::operator Cubit_ptr& () { return (Cubit_ptr &) (_ptr);}
+Cubit_var::operator const Cubit_cptr& () const { return (Cubit_cptr &) (_ptr);}
+
+Cubit_var ::operator CORBA::Object_ptr () const {
+    return _ptr;
+}
+
+Cubit_ptr Cubit_var :: in () const {
+    return _ptr;
+}
+
+Cubit_ptr& Cubit_var :: inOut () {
+    return _ptr;
+}
+
+Cubit_ptr& Cubit_var :: out () {
+    return _ptr;
+}
+
+Cubit_ptr Cubit_var :: ret () const {
+    return _ptr;
+}
+
 void* CubitProxyFactoryClass::New (char *IT_OR, CORBA::Environment&) {
         return  new class Cubit(IT_OR);}
 
-void* CubitProxyFactoryClass::New (ObjectReference *IT_OR, CORBA::Environment&) {
+void* CubitProxyFactoryClass::New (ObjectReferenceImpl *IT_OR, CORBA::Environment&) {
         return  new class Cubit(IT_OR);}
 
 void* CubitProxyFactoryClass::New2 () {
         return  new class Cubit((char*)0);}
 
-CORBA::Object* CubitProxyFactoryClass::NewObject (char *IT_OR, CORBA::Environment&) {
-        return  new class Cubit(IT_OR);}
+CORBA::Object* CubitProxyFactoryClass::NewObject (char *IT_OR, CORBA::Environment& IT_env) {
+        return (CORBA::Object*)((Cubit*)New (IT_OR, IT_env));}
 
-CORBA::Object* CubitProxyFactoryClass::NewObject (ObjectReference *IT_OR, CORBA::Environment&) {
-        return  new class Cubit(IT_OR);}
+CORBA::Object* CubitProxyFactoryClass::NewObject (ObjectReferenceImpl *IT_OR, CORBA::Environment& IT_env) {
+        return (CORBA::Object*)((Cubit*)New (IT_OR, IT_env));}
 
 CORBA::Object* CubitProxyFactoryClass::New2Object () {
-        return  new class Cubit((char*)0);}
+        return (CORBA::Object*)((Cubit*)New2 ());}
 
 void* CubitProxyFactoryClass::IT_castUp (void *IT_p, char* IT_s, CORBA::Environment &IT_env) {
       void *IT_l;
@@ -392,17 +883,37 @@ CORBA::Octet Cubit:: cube_octet (CORBA::Octet o, CORBA::Environment &IT_pEnv) th
         return 0;
     }
     CORBA::Request IT_r (this, "cube_octet",IT_env,1,0);
-    if (!IT_r.isException (IT_env)) {
+    for (int IT_i1=0; IT_i1 < 2; IT_i1++) {
+        if (!IT_r.isException (IT_env)) {
 
-        IT_r.insertOctet (o);
-    }
+            IT_r.insertOctet (o);
+        }
 
-    IT_r.invoke (CORBA::Flags(0),IT_env);
+        IT_r.invoke (CORBA::Flags(0),IT_env);
+        CORBA::SystemException *IT_sy = CORBA::SystemException::_narrow(IT_env.exception()) ;
+        if (IT_sy && IT_sy->minor() == 10601)
+                IT_r.reset(IT_r.target(),  IT_r.operation(), IT_env);
+        else
+                break;
+    }
     if (!IT_r.isException (IT_env)) {
-        CORBA::Octet IT_result;
-        IT_r.extractOctet (IT_result);
-        IT_r.checkEnv (IT_env);
-        return IT_result;
+        switch (IT_r.targetProtocol()) {
+            case CORBA::IT_INTEROPERABLE_OR_KIND:
+            {
+                CORBA::Octet IT_result;
+                IT_r.extractOctet (IT_result);
+                IT_r.checkEnv (IT_env);
+                return IT_result;
+            }
+            case CORBA::IT_ORBIX_OR_KIND:
+            default:
+            {
+                CORBA::Octet IT_result;
+                IT_r.extractOctet (IT_result);
+                IT_r.checkEnv (IT_env);
+                return IT_result;
+            }
+        }
     }
     if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) {
         IT_r.checkEnv (IT_env);
@@ -418,17 +929,37 @@ CORBA::Short Cubit:: cube_short (CORBA::Short s, CORBA::Environment &IT_pEnv) th
         return 0;
     }
     CORBA::Request IT_r (this, "cube_short",IT_env,1,0);
-    if (!IT_r.isException (IT_env)) {
+    for (int IT_i1=0; IT_i1 < 2; IT_i1++) {
+        if (!IT_r.isException (IT_env)) {
 
-        IT_r << s;
-    }
+            IT_r << s;
+        }
 
-    IT_r.invoke (CORBA::Flags(0),IT_env);
+        IT_r.invoke (CORBA::Flags(0),IT_env);
+        CORBA::SystemException *IT_sy = CORBA::SystemException::_narrow(IT_env.exception()) ;
+        if (IT_sy && IT_sy->minor() == 10601)
+                IT_r.reset(IT_r.target(),  IT_r.operation(), IT_env);
+        else
+                break;
+    }
     if (!IT_r.isException (IT_env)) {
-        CORBA::Short IT_result;
-        IT_r >> IT_result;
-        IT_r.checkEnv (IT_env);
-        return IT_result;
+        switch (IT_r.targetProtocol()) {
+            case CORBA::IT_INTEROPERABLE_OR_KIND:
+            {
+                CORBA::Short IT_result;
+                IT_r >> IT_result;
+                IT_r.checkEnv (IT_env);
+                return IT_result;
+            }
+            case CORBA::IT_ORBIX_OR_KIND:
+            default:
+            {
+                CORBA::Short IT_result;
+                IT_r >> IT_result;
+                IT_r.checkEnv (IT_env);
+                return IT_result;
+            }
+        }
     }
     if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) {
         IT_r.checkEnv (IT_env);
@@ -444,17 +975,37 @@ CORBA::Long Cubit:: cube_long (CORBA::Long l, CORBA::Environment &IT_pEnv) throw
         return 0;
     }
     CORBA::Request IT_r (this, "cube_long",IT_env,1,0);
-    if (!IT_r.isException (IT_env)) {
+    for (int IT_i1=0; IT_i1 < 2; IT_i1++) {
+        if (!IT_r.isException (IT_env)) {
 
-        IT_r << l;
-    }
+            IT_r << l;
+        }
 
-    IT_r.invoke (CORBA::Flags(0),IT_env);
+        IT_r.invoke (CORBA::Flags(0),IT_env);
+        CORBA::SystemException *IT_sy = CORBA::SystemException::_narrow(IT_env.exception()) ;
+        if (IT_sy && IT_sy->minor() == 10601)
+                IT_r.reset(IT_r.target(),  IT_r.operation(), IT_env);
+        else
+                break;
+    }
     if (!IT_r.isException (IT_env)) {
-        CORBA::Long IT_result;
-        IT_r >> IT_result;
-        IT_r.checkEnv (IT_env);
-        return IT_result;
+        switch (IT_r.targetProtocol()) {
+            case CORBA::IT_INTEROPERABLE_OR_KIND:
+            {
+                CORBA::Long IT_result;
+                IT_r >> IT_result;
+                IT_r.checkEnv (IT_env);
+                return IT_result;
+            }
+            case CORBA::IT_ORBIX_OR_KIND:
+            default:
+            {
+                CORBA::Long IT_result;
+                IT_r >> IT_result;
+                IT_r.checkEnv (IT_env);
+                return IT_result;
+            }
+        }
     }
     if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) {
         IT_r.checkEnv (IT_env);
@@ -473,17 +1024,37 @@ Cubit::Many Cubit:: cube_struct (const Cubit::Many& values, CORBA::Environment &
         }
     }
     CORBA::Request IT_r (this, "cube_struct",IT_env,1,0);
-    if (!IT_r.isException (IT_env)) {
+    for (int IT_i1=0; IT_i1 < 2; IT_i1++) {
+        if (!IT_r.isException (IT_env)) {
 
-        values.encodeOp (IT_r);
-    }
+            values.encodeOp (IT_r);
+        }
 
-    IT_r.invoke (CORBA::Flags(0),IT_env);
+        IT_r.invoke (CORBA::Flags(0),IT_env);
+        CORBA::SystemException *IT_sy = CORBA::SystemException::_narrow(IT_env.exception()) ;
+        if (IT_sy && IT_sy->minor() == 10601)
+                IT_r.reset(IT_r.target(),  IT_r.operation(), IT_env);
+        else
+                break;
+    }
     if (!IT_r.isException (IT_env)) {
-        Cubit::Many IT_result;
-        IT_result.decodeOp (IT_r);
-        IT_r.checkEnv (IT_env);
-        return IT_result;
+        switch (IT_r.targetProtocol()) {
+            case CORBA::IT_INTEROPERABLE_OR_KIND:
+            {
+                Cubit::Many IT_result;
+                IT_result.decodeOp (IT_r);
+                IT_r.checkEnv (IT_env);
+                return IT_result;
+            }
+            case CORBA::IT_ORBIX_OR_KIND:
+            default:
+            {
+                Cubit::Many IT_result;
+                IT_result.decodeOp (IT_r);
+                IT_r.checkEnv (IT_env);
+                return IT_result;
+            }
+        }
     }
     if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) {
         IT_r.checkEnv (IT_env);
@@ -505,17 +1076,37 @@ Cubit::oneof Cubit:: cube_union (const Cubit::oneof& values, CORBA::Environment
         }
     }
     CORBA::Request IT_r (this, "cube_union",IT_env,1,0);
-    if (!IT_r.isException (IT_env)) {
+    for (int IT_i1=0; IT_i1 < 2; IT_i1++) {
+        if (!IT_r.isException (IT_env)) {
 
-        values.encodeOp (IT_r);
-    }
+            values.encodeOp (IT_r);
+        }
 
-    IT_r.invoke (CORBA::Flags(0),IT_env);
+        IT_r.invoke (CORBA::Flags(0),IT_env);
+        CORBA::SystemException *IT_sy = CORBA::SystemException::_narrow(IT_env.exception()) ;
+        if (IT_sy && IT_sy->minor() == 10601)
+                IT_r.reset(IT_r.target(),  IT_r.operation(), IT_env);
+        else
+                break;
+    }
     if (!IT_r.isException (IT_env)) {
-        Cubit::oneof IT_result;
-        IT_result.decodeOp (IT_r);
-        IT_r.checkEnv (IT_env);
-        return IT_result;
+        switch (IT_r.targetProtocol()) {
+            case CORBA::IT_INTEROPERABLE_OR_KIND:
+            {
+                Cubit::oneof IT_result;
+                IT_result.decodeOp (IT_r);
+                IT_r.checkEnv (IT_env);
+                return IT_result;
+            }
+            case CORBA::IT_ORBIX_OR_KIND:
+            default:
+            {
+                Cubit::oneof IT_result;
+                IT_result.decodeOp (IT_r);
+                IT_r.checkEnv (IT_env);
+                return IT_result;
+            }
+        }
     }
     if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) {
         IT_r.checkEnv (IT_env);
@@ -534,8 +1125,15 @@ void Cubit:: please_exit (CORBA::Environment &IT_pEnv) throw (CORBA::SystemExcep
         return ;
     }
     CORBA::Request IT_r (this, "please_exit",IT_env,1,1);
-
-    IT_r.invoke (CORBA::Flags(CORBA::INV_NO_RESPONSE), IT_env);
+    for (int IT_i1=0; IT_i1 < 2; IT_i1++) {
+
+        IT_r.invoke (CORBA::Flags(CORBA::INV_NO_RESPONSE), IT_env);
+        CORBA::SystemException *IT_sy = CORBA::SystemException::_narrow(IT_env.exception()) ;
+        if (IT_sy && IT_sy->minor() == 10601)
+                IT_r.reset(IT_r.target(),  IT_r.operation(), IT_env);
+        else
+                break;
+    }
     if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) {
         IT_r.checkEnv (IT_env);
     }
diff --git a/TAO/tests/Cubit/Orbix/base_server/cubitC.h b/TAO/tests/Cubit/Orbix/base_server/cubitC.h
deleted file mode 100644
index 15247168d3c..00000000000
--- a/TAO/tests/Cubit/Orbix/base_server/cubitC.h
+++ /dev/null
@@ -1,343 +0,0 @@
-#ifndef _cubitC_h
-#define _cubitC_h
-
-/************************************************************************/
-/*                                                                      */
-/* This file is automatically generated by ORBeline IDL compiler        */
-/* Do not modify this file.                                             */
-/*                                                                      */
-/* ORBeline (c) is copyrighted by PostModern Computing, Inc.            */
-/*                                                                      */
-/* The generated code conforms to OMG's IDL C++ mapping as              */
-/* specified in OMG Document Number: 94-9-14.                           */
-/*                                                                      */
-/************************************************************************/
-
-#include "corba.h"
-
-
-
-class Cubit;
-typedef Cubit *Cubit_ptr;
-typedef Cubit_ptr CubitRef;
-
-#ifndef _Cubit_var_
-#define _Cubit_var_
-class Cubit_var
-{
-    public:
-	Cubit_var();
-	Cubit_var(Cubit_ptr);
-	Cubit_var(const Cubit_var&);
-	~Cubit_var();
-	Cubit_var& operator=(Cubit_ptr);
-	operator Cubit_ptr() const { return _ptr; }
-#if defined(_HPCC_BUG)
-	operator Cubit *&() { return _ptr; }
-#else
-	operator Cubit_ptr&() { return _ptr; }
-#endif
-	Cubit_ptr operator->() const { return _ptr;}
-	friend NCistream& operator>>(NCistream&, Cubit_var&);
-	friend NCostream& operator<<(NCostream&, const Cubit_var&);
-	friend istream& operator>>(istream&, Cubit_var&);
-	friend ostream& operator<<(ostream&, const Cubit_var&);
-    private:
-	Cubit_ptr	_ptr;
-	void operator=(const Cubit_var&) {}
-};
-#endif
-class Cubit: public virtual CORBA_Object
-{
-    private:
-	static const CORBA::TypeInfo _class_info;
-	Cubit(const Cubit&) {}
-	void operator=(const Cubit&){}
-    public:
-	static const CORBA::TypeInfo *_desc();
-	virtual const CORBA::TypeInfo *_type_info() const;
-	virtual void *_safe_narrow(const CORBA::TypeInfo& ) const;
-	static CORBA::Object *_factory();
-    protected:
-	Cubit(const char *obj_name = NULL) :CORBA_Object(obj_name, 1) {}
-	Cubit(NCistream& strm) :CORBA_Object(strm) {}
-	virtual ~Cubit() {}
-    public:
-	static Cubit_ptr _duplicate(Cubit_ptr obj) {
-		if (obj ) obj->_ref();
-		return obj;
-	}
-	static Cubit_ptr _nil() { return (Cubit_ptr)NULL;}
-	static Cubit_ptr _narrow(CORBA::Object *obj);
-	static Cubit_ptr _clone(Cubit_ptr obj) {
-		CORBA::Object_var obj_var(__clone(obj));
-
-#if defined(_HPCC_BUG)
-		return _narrow(obj_var.operator CORBA::Object_ptr());
-#else
-		return _narrow(obj_var);
-#endif
-	}
-	static Cubit_ptr _bind(const char *object_name = NULL,
-		const char *host_name = NULL,
-		const CORBA::BindOptions* opt = NULL); 
-
-	virtual CORBA::Octet cube_octet(CORBA::Octet o);
-	
-	virtual CORBA::Short cube_short(CORBA::Short s);
-	
-	virtual CORBA::Long cube_long(CORBA::Long l);
-	
-	struct Many {
-		CORBA::Octet	o;
-		CORBA::Long	l;
-		CORBA::Short	s;
-	};
-	friend NCostream& operator<<(NCostream&, const Many& );
-	friend NCistream& operator>>(NCistream&, Many& );
-	
-	friend ostream& operator<<(ostream&, const Many& );
-	inline friend istream& operator>>(istream& _strm, Many& _obj) {
-		NCistream _istrm(_strm);
-		_istrm >> _obj;
-		return _strm;
-	}
-	
-	
-	typedef Many *Many_ptr;
-	class Many_var
-	{
-	    public:
-		Many_var() { _ptr = (Many*)NULL;}
-		Many_var(Many *ptr) {
-			_ptr = ptr;
-		}
-		Many_var(const Many_var& var) {
-			if (var._ptr)
-				_ptr = new Many(*var._ptr);
-			else
-				_ptr = (Many *)NULL;
-		}
-		~Many_var() {
-			if (_ptr != (Many *)NULL) delete _ptr;
-		}
-		Many_var& operator=(Many *ptr) {
-			if (_ptr != (Many *)NULL) delete _ptr;
-			_ptr = ptr;
-			return *this;
-		}
-		Many_var& operator=(const Many_var& var) {
-			if (_ptr != (Many *)NULL) delete _ptr;
-			if (var._ptr)
-				_ptr = new Many(*var._ptr);
-			else
-				_ptr = (Many *)NULL;
-			return *this;
-		}
-		Many *operator->() { return _ptr; }
-		operator Many () const { return *_ptr; }
-		operator Many& () { return *_ptr; }
-		inline friend NCostream& operator<<(NCostream& strm,
-				const Many_var& var) {
-			if (var._ptr == (Many *)NULL) {
-				throw CORBA::BAD_PARAM();
-			}
-			else
-				strm << *var._ptr;
-			return strm;
-		}
-		inline friend NCistream& operator>>(NCistream& strm,
-				Many_var& var) {
-			if ( ! var._ptr)
-				var._ptr = new Many;
-			strm >> *var._ptr;
-			return strm;
-		}
-	    private:
-		Many *_ptr;
-	};
-	
-	
-	virtual Cubit::Many cube_struct(const Cubit::Many& values);
-	
-	enum discrim {
-		e_0th,
-		e_1st,
-		e_2nd,
-		e_3rd,
-		e_4th,
-		e_5th
-	};
-	inline friend NCostream& operator<<(NCostream& _strm, discrim _enum_type) {
-		_strm << (CORBA::ULong)_enum_type;
-		return _strm;
-	}
-	inline friend NCistream& operator>>(NCistream& _strm, discrim& _enum_type) {
-		CORBA::ULong _temp;
-		_strm >> _temp;
-		if (_temp >= 6)
-			throw CORBA::BAD_PARAM();
-		_enum_type = discrim(_temp);
-		return _strm;
-	}
-	inline friend ostream& operator<<(ostream& _strm, discrim _enum_type) {
-		if( &_strm == &cout || &_strm == &cerr || &_strm == &clog) {
-			_strm << "discrim:";
-			switch(_enum_type) {
-				case e_0th:
-					_strm << "e_0th" << endl;
-					break;
-				case e_1st:
-					_strm << "e_1st" << endl;
-					break;
-				case e_2nd:
-					_strm << "e_2nd" << endl;
-					break;
-				case e_3rd:
-					_strm << "e_3rd" << endl;
-					break;
-				case e_4th:
-					_strm << "e_4th" << endl;
-					break;
-				case e_5th:
-					_strm << "e_5th" << endl;
-					break;
-			}
-		}
-		else 
-			_strm << (CORBA::ULong)_enum_type;
-		return _strm;
-	}
-	inline friend istream& operator>>(istream& _strm, discrim& _enum_type) {
-		CORBA::ULong _temp;
-		_strm >> _temp;
-		_enum_type = discrim(_temp);
-		return _strm;
-	}
-	
-	
-	class oneof
-	{
-	    public:
-	    private:
-		discrim	_disc;
-		CORBA::Octet	__o;
-		CORBA::Short	__s;
-		CORBA::Long	__l;
-		Cubit::Many	__cm;
-	    public:
-		oneof() : _disc(discrim(0)) {}
-		~oneof() {}
-		oneof(const oneof& obj);
-		oneof& operator=(const oneof& obj);
-	
-		void _d(discrim val) { _disc = val; }
-		discrim _d() const { return _disc; }
-	
-		void o(CORBA::Octet val) {
-			__o = val;
-			_disc = Cubit::e_0th;
-		}
-		CORBA::Octet o() const { return __o; }
-	
-		void s(CORBA::Short val) {
-			__s = val;
-			_disc = Cubit::e_1st;
-		}
-		CORBA::Short s() const { return __s; }
-	
-		void l(CORBA::Long val) {
-			__l = val;
-			_disc = Cubit::e_2nd;
-		}
-		CORBA::Long l() const { return __l; }
-	
-		void cm(const Cubit::Many& val) {
-			__cm = val;
-			_disc = Cubit::e_3rd;
-		}
-		const Cubit::Many& cm() const { return __cm; }
-		Cubit::Many& cm() { return __cm; }
-	
-		friend NCostream& operator<<(NCostream&, const oneof& );
-		friend NCistream& operator>>(NCistream&, oneof& );
-		friend ostream& operator<<(ostream&, const oneof&);
-		inline friend istream& operator>>(istream& strm, oneof& obj) {
-			NCistream istrm(strm);
-			strm >> obj;
-			return strm;
-		}
-	};
-	
-	typedef oneof *oneof_ptr;
-	class oneof_var
-	{
-	    public:
-		oneof_var() { _ptr = (oneof*)NULL;}
-		oneof_var(oneof *ptr) {
-			_ptr = ptr;
-		}
-		oneof_var(const oneof_var& var) {
-			_ptr = new oneof(*var._ptr);
-		}
-		~oneof_var() {
-			if (_ptr != (oneof *)NULL) delete _ptr;
-		}
-		oneof_var& operator=(oneof *ptr) {
-			if (_ptr != (oneof *)NULL) delete _ptr;
-			_ptr = ptr;
-			return *this;
-		}
-		oneof_var& operator=(const oneof_var& var) {
-			if (_ptr != (oneof *)NULL) delete _ptr;
-			_ptr = new oneof(*var._ptr);
-			return *this;
-		}
-		oneof *operator->() { return _ptr; }
-		operator oneof () const { return *_ptr; }
-		operator oneof& () { return *_ptr; }
-		inline friend NCostream& operator<<(NCostream& strm,
-				const oneof_var& var) {
-			if (var._ptr == (oneof *)NULL) {
-				throw CORBA::BAD_PARAM();
-			}
-			else
-				strm << *var._ptr;
-			return strm;
-		}
-		inline friend NCistream& operator>>(NCistream& strm,
-				oneof_var& var) {
-			if ( ! var._ptr)
-				var._ptr = new oneof;
-			strm >> *var._ptr;
-			return strm;
-		}
-	    private:
-		oneof *_ptr;
-	};
-	
-	
-	virtual Cubit::oneof cube_union(const Cubit::oneof& values);
-	
-	virtual void please_exit();
-	
-	inline friend NCistream& operator>>(NCistream& strm, Cubit_ptr& obj) {
-		CORBA::Object_var _obj(obj);
-		_obj = CORBA::Object::_read(strm, Cubit::_desc());
-		obj = Cubit::_narrow(_obj);
-		return strm;
-	}
-	inline friend ostream& operator<<(ostream& strm, const Cubit_ptr obj) {
-		strm << (CORBA::Object_ptr)obj;
-		return strm;
-	}
-	inline friend istream& operator>>(istream& strm, Cubit_ptr& obj) {
-		NCistream istrm(strm);
-		istrm >> obj;
-		return strm;
-	}
-};
-
-
-#endif
-
diff --git a/TAO/tests/Cubit/Orbix/base_server/cubitS.cpp b/TAO/tests/Cubit/Orbix/base_server/cubitS.cpp
index 449a8c23548..fcccf83c236 100644
--- a/TAO/tests/Cubit/Orbix/base_server/cubitS.cpp
+++ b/TAO/tests/Cubit/Orbix/base_server/cubitS.cpp
@@ -1,4 +1,6 @@
-#include "cubit.h"
+
+
+#include "cubit.hh"
 
 
 #define Cubit_dispatch_impl
@@ -37,7 +39,19 @@ Ro~cube_octet~+o{o},>{o},N{}\
             if (!IT_r.convertToReply ("\
 o\
 ", IT_env)) return 1;
-            IT_r.insertOctet (IT_result);
+            switch (IT_r.targetProtocol()) {
+                case CORBA::IT_INTEROPERABLE_OR_KIND:
+                {
+                    IT_r.insertOctet (IT_result);
+                    break;
+                }
+                case CORBA::IT_ORBIX_OR_KIND:
+                default:
+                {
+                    IT_r.insertOctet (IT_result);
+                    break;
+                }
+            }
             }
 
         else IT_r.makeSystemException (IT_env);
@@ -73,7 +87,19 @@ Ro~cube_short~+s{s},>{s},N{}\
             if (!IT_r.convertToReply ("\
 s\
 ", IT_env)) return 1;
-            IT_r << IT_result;
+            switch (IT_r.targetProtocol()) {
+                case CORBA::IT_INTEROPERABLE_OR_KIND:
+                {
+                    IT_r << IT_result;
+                    break;
+                }
+                case CORBA::IT_ORBIX_OR_KIND:
+                default:
+                {
+                    IT_r << IT_result;
+                    break;
+                }
+            }
             }
 
         else IT_r.makeSystemException (IT_env);
@@ -109,7 +135,19 @@ Ro~cube_long~+l{l},>{l},N{}\
             if (!IT_r.convertToReply ("\
 l\
 ", IT_env)) return 1;
-            IT_r << IT_result;
+            switch (IT_r.targetProtocol()) {
+                case CORBA::IT_INTEROPERABLE_OR_KIND:
+                {
+                    IT_r << IT_result;
+                    break;
+                }
+                case CORBA::IT_ORBIX_OR_KIND:
+                default:
+                {
+                    IT_r << IT_result;
+                    break;
+                }
+            }
             }
 
         else IT_r.makeSystemException (IT_env);
@@ -145,7 +183,19 @@ Ro~cube_struct~+values{R~Cubit::Many~o{o},l{l},s{s}},>{R~Cubit::Many~o{o},l{l},s
             if (!IT_r.convertToReply ("\
 R~Cubit::Many~o{o},l{l},s{s}\
 ", IT_env)) return 1;
-            IT_result.encodeOp (IT_r);
+            switch (IT_r.targetProtocol()) {
+                case CORBA::IT_INTEROPERABLE_OR_KIND:
+                {
+                    IT_result.encodeOp (IT_r);
+                    break;
+                }
+                case CORBA::IT_ORBIX_OR_KIND:
+                default:
+                {
+                    IT_result.encodeOp (IT_r);
+                    break;
+                }
+            }
             }
 
         else IT_r.makeSystemException (IT_env);
@@ -185,7 +235,19 @@ e_4th,e_5th}~Cubit::e_0th o{o};Cubit::e_1st s{s};Cubit::e_2nd l{l};Cubit::e_3rd,
             if (!IT_r.convertToReply ("\
 U~Cubit::oneof~{E~Cubit::discrim~e_0th,e_1st,e_2nd,e_3rd,e_4th,e_5th}~Cubit::e_0th o{o};Cubit::e_1st s{s};Cubit::e_2nd l{l};Cubit::e_3rd,$ cm{R~Cubit::Many~o{o},l{l},s{s}}\
 ", IT_env)) return 1;
-            IT_result.encodeOp (IT_r);
+            switch (IT_r.targetProtocol()) {
+                case CORBA::IT_INTEROPERABLE_OR_KIND:
+                {
+                    IT_result.encodeOp (IT_r);
+                    break;
+                }
+                case CORBA::IT_ORBIX_OR_KIND:
+                default:
+                {
+                    IT_result.encodeOp (IT_r);
+                    break;
+                }
+            }
             }
 
         else IT_r.makeSystemException (IT_env);
diff --git a/TAO/tests/Cubit/Orbix/base_server/cubitS.h b/TAO/tests/Cubit/Orbix/base_server/cubitS.h
deleted file mode 100644
index 757af4664ad..00000000000
--- a/TAO/tests/Cubit/Orbix/base_server/cubitS.h
+++ /dev/null
@@ -1,118 +0,0 @@
-#ifndef _cubitS_h
-#define _cubitS_h
-
-#include "cubitC.h"
-
-/************************************************************************/
-/*                                                                      */
-/* This file is automatically generated by ORBeline IDL compiler        */
-/* Do not modify this file.                                             */
-/*                                                                      */
-/* ORBeline (c) is copyrighted by PostModern Computing, Inc.            */
-/*                                                                      */
-/* The generated code conforms to OMG's IDL C++ mapping as              */
-/* specified in OMG Document Number: 94-9-14.                           */
-/*                                                                      */
-/************************************************************************/
-
-class _sk_Cubit : public Cubit
-{
-    protected:
-	_sk_Cubit(const char *object_name = (const char *)NULL);
-	_sk_Cubit(const char *service_name, const CORBA::ReferenceData& data);
-	virtual ~_sk_Cubit() {}
-    public:
-	static const CORBA::TypeInfo _skel_info;
-
-	// The following operations need to be implemented by the server.
-	virtual CORBA::Octet cube_octet(CORBA::Octet o) = 0;
-	virtual CORBA::Short cube_short(CORBA::Short s) = 0;
-	virtual CORBA::Long cube_long(CORBA::Long l) = 0;
-	virtual Cubit::Many cube_struct(const Cubit::Many& values) = 0;
-	virtual Cubit::oneof cube_union(const Cubit::oneof& values) = 0;
-	virtual void please_exit() = 0;
-	
-	// Skeleton Operations implemented automatically
-	
-	static void _cube_octet(void *obj,
-			CORBA::MarshalStream &strm,
-			CORBA::Principal_ptr principal,
-			const char *oper,
-			void *priv_data);
-	
-	static void _cube_short(void *obj,
-			CORBA::MarshalStream &strm,
-			CORBA::Principal_ptr principal,
-			const char *oper,
-			void *priv_data);
-	
-	static void _cube_long(void *obj,
-			CORBA::MarshalStream &strm,
-			CORBA::Principal_ptr principal,
-			const char *oper,
-			void *priv_data);
-	
-	static void _cube_struct(void *obj,
-			CORBA::MarshalStream &strm,
-			CORBA::Principal_ptr principal,
-			const char *oper,
-			void *priv_data);
-	
-	static void _cube_union(void *obj,
-			CORBA::MarshalStream &strm,
-			CORBA::Principal_ptr principal,
-			const char *oper,
-			void *priv_data);
-	
-	static void _please_exit(void *obj,
-			CORBA::MarshalStream &strm,
-			CORBA::Principal_ptr principal,
-			const char *oper,
-			void *priv_data);
-	
-};
-template <class T>
-class _tie_Cubit : public Cubit
-{
-    public:
-	_tie_Cubit(T& t, const char *obj_name=(char*)NULL) : 
-			Cubit(obj_name), 
-			_ref(t) {
-		_object_name(obj_name);
-	}
-	_tie_Cubit(T& t, const char *service_name,
-			const CORBA::ReferenceData& id)
-			:_ref(t) {
-		_service(service_name, id);
-	}
-	~_tie_Cubit() {}
-	CORBA::Octet cube_octet(CORBA::Octet o) {
-		return _ref.cube_octet(
-		o);
-	}
-	CORBA::Short cube_short(CORBA::Short s) {
-		return _ref.cube_short(
-		s);
-	}
-	CORBA::Long cube_long(CORBA::Long l) {
-		return _ref.cube_long(
-		l);
-	}
-	Cubit::Many cube_struct(const Cubit::Many& values) {
-		return _ref.cube_struct(
-		values);
-	}
-	Cubit::oneof cube_union(const Cubit::oneof& values) {
-		return _ref.cube_union(
-		values);
-	}
-	void please_exit() {
-		_ref.please_exit();
-	}
-
-    private:
-	T& _ref;
-};
-
-#endif
-
diff --git a/TAO/tests/Cubit/Orbix/base_server/cubit_impl.h b/TAO/tests/Cubit/Orbix/base_server/cubit_impl.h
index 1e710bb15d1..ef5b0dffe5f 100644
--- a/TAO/tests/Cubit/Orbix/base_server/cubit_impl.h
+++ b/TAO/tests/Cubit/Orbix/base_server/cubit_impl.h
@@ -2,7 +2,7 @@
 #ifndef cubit_ih
 #define cubit_ih
 
-#include "cubit.h"
+#include "cubit.hh"
 
 
 #ifdef Cubit_USE_BOA
diff --git a/TAO/tests/Cubit/Orbix/base_server/server.cpp b/TAO/tests/Cubit/Orbix/base_server/server.cpp
index 96117fe3e0d..cfeafe72375 100644
--- a/TAO/tests/Cubit/Orbix/base_server/server.cpp
+++ b/TAO/tests/Cubit/Orbix/base_server/server.cpp
@@ -8,6 +8,7 @@
 //****************************************************************************
 #define IT_EX_MACROS
 
+#include "ace/streams.h"
 #include "cubit_impl.h"		// server header file
 
 int 
diff --git a/TAO/tests/Cubit/Orbix/base_server/tpr.cpp b/TAO/tests/Cubit/Orbix/base_server/tpr.cpp
deleted file mode 100644
index 415410aea9f..00000000000
--- a/TAO/tests/Cubit/Orbix/base_server/tpr.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#include "tpr.h"
-
-void *
-worker(void *vp)
-{
-  ACE_Thread_Control tc (ACE_Thread_Manager::instance ());
-  CORBA::Orbix.continueThreadDispatch (*(CORBA::Request *)vp);
-  return NULL;
-}
-
-
-int
-tpr_filter::inRequestPreMarshal(CORBA::Request &r,  CORBA::Environment&)
-{
-//   thread_t	tid;
-//   thr_create(NULL, 0, worker, (void *)&r, THR_DETACHED, &tid);
-
-  ACE_Thread_Manager *thr_mgr = ACE_Thread_Manager::instance ();
-  thr_mgr->spawn (ACE_THR_FUNC (worker),
-                  (void *) &r, 
-                  THR_DETACHED);
-
-  return -1;
-}
-
-tpr_filter tpr_dispatcher;