This commit was manufactured by cvs2svn to create branch 'ft_tao_2'.

10 files changed, 3431 insertions, 0 deletions

diff --git a/TAO/tao/diffs/Dynamic.diff b/TAO/tao/diffs/Dynamic.diff
new file mode 100644
index 00000000000..8d5d4e1e69b
--- /dev/null
+++ b/TAO/tao/diffs/Dynamic.diff
@@ -0,0 +1,31 @@
+--- DynamicC.h.old	Mon Oct 16 22:31:46 2000
++++ DynamicC.h	Mon Oct 16 22:32:48 2000
+@@ -23,13 +23,15 @@
+ #define _TAO_IDL_DYNAMICC_H_
+ 
+ #include "ace/pre.h"
+-#include "tao/corba.h"
++
++#include "tao/corbafwd.h"
+ 
+ #if !defined (ACE_LACKS_PRAGMA_ONCE)
+ # pragma once
+ #endif /* ACE_LACKS_PRAGMA_ONCE */
+ 
+-#include "tao/corbafwd.h"
++#include "tao/Any.h"
++#include "tao/Sequence.h"
+ 
+ #if defined (TAO_EXPORT_MACRO)
+ #undef TAO_EXPORT_MACRO
+--- DynamicC.cpp.old	Mon Oct 16 22:31:46 2000
++++ DynamicC.cpp	Mon Oct 16 22:32:48 2000
+@@ -25,6 +25,8 @@
+ #include "DynamicC.i"
+ #endif /* !defined INLINE */
+ 
++#include "tao/StringSeqC.h"
++
+ static const CORBA::Long _oc_Dynamic_ParameterMode[] =
+ {
+   TAO_ENCAP_BYTE_ORDER, // byte order
diff --git a/TAO/tao/diffs/IOP.diff b/TAO/tao/diffs/IOP.diff
new file mode 100644
index 00000000000..ee716db57cb
--- /dev/null
+++ b/TAO/tao/diffs/IOP.diff
@@ -0,0 +1,71 @@
+--- IOPC.h.old	Sun Sep 24 17:32:44 2000
++++ IOPC.h	Sun Sep 24 19:47:04 2000
+@@ -21,17 +21,18 @@
+ 
+ #ifndef _TAO_IDL_IOPC_H_
+ #define _TAO_IDL_IOPC_H_
+ 
+ #include "ace/pre.h"
+-#include "tao/corba.h"
++#include "tao/TAO_Export.h"
+ 
+ #if !defined (ACE_LACKS_PRAGMA_ONCE)
+ # pragma once
+ #endif /* ACE_LACKS_PRAGMA_ONCE */
+ 
+-#include "tao/TAO_Export.h"
++#include "tao/CDR.h"
++#include "tao/Sequence.h"
+ 
+ #if defined (TAO_EXPORT_MACRO)
+ #undef TAO_EXPORT_MACRO
+ #endif
+ #define TAO_EXPORT_MACRO TAO_Export
+--- IOPS.h.old	Sun Sep 24 17:32:44 2000
++++ IOPS.h	Sun Sep 24 19:47:08 2000
+@@ -28,14 +28,10 @@
+ 
+ #if !defined (ACE_LACKS_PRAGMA_ONCE)
+ # pragma once
+ #endif /* ACE_LACKS_PRAGMA_ONCE */
+ 
+-#include "tao/PortableServer/PortableServer.h"
+-#include "tao/PortableServer/Servant_Base.h"
+-#include "tao/PortableServer/Collocated_Object.h"
+-
+ #if defined(_MSC_VER)
+ #if (_MSC_VER >= 1200)
+ #pragma warning(push)
+ #endif /* _MSC_VER >= 1200 */
+ #pragma warning(disable:4250)
+--- IOPC.cpp.old	Sun Sep 24 17:32:44 2000
++++ IOPC.cpp	Sun Sep 24 19:47:04 2000
+@@ -23,10 +23,13 @@
+ 
+ #if !defined (__ACE_INLINE__)
+ #include "IOPC.i"
+ #endif /* !defined INLINE */
+ 
++#include "tao/Any.h"
++#include "tao/Typecode.h"
++
+ static const CORBA::Long _oc_IOP_ProfileId[] =
+ {
+   TAO_ENCAP_BYTE_ORDER, // byte order
+   30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x494f502f), ACE_NTOHL (0x50726f66), ACE_NTOHL (0x696c6549), ACE_NTOHL (0x643a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IOP/ProfileId:1.0
+   10, ACE_NTOHL (0x50726f66), ACE_NTOHL (0x696c6549), ACE_NTOHL (0x64000000),  // name = ProfileId
+--- IOPS.cpp.old	Sun Sep 24 17:32:44 2000
++++ IOPS.cpp	Sun Sep 24 19:47:08 2000
+@@ -18,12 +18,10 @@
+ //
+ // Information about TAO is available at:
+ //     http://www.cs.wustl.edu/~schmidt/TAO.html
+ 
+ #include "IOPS.h"
+-#include "tao/PortableServer/Object_Adapter.h"
+-#include "tao/PortableServer/Operation_Table.h"
+ 
+ #if !defined (__ACE_INLINE__)
+ #include "IOPS.i"
+ #endif /* !defined INLINE */
+ 
diff --git a/TAO/tao/diffs/OctetSeq.diff b/TAO/tao/diffs/OctetSeq.diff
new file mode 100644
index 00000000000..82a2ec88e9d
--- /dev/null
+++ b/TAO/tao/diffs/OctetSeq.diff
@@ -0,0 +1,687 @@
+--- OctetSeqC.h.old	Sun Oct 22 22:28:28 2000
++++ OctetSeqC.h	Sun Oct 22 22:29:06 2000
+@@ -23,13 +23,14 @@
+ #define _TAO_IDL_OCTETSEQC_H_
+ 
+ #include "ace/pre.h"
+-#include "tao/corba.h"
++
++#include "tao/corbafwd.h"
+ 
+ #if !defined (ACE_LACKS_PRAGMA_ONCE)
+ # pragma once
+ #endif /* ACE_LACKS_PRAGMA_ONCE */
+ 
+-#include "tao/corbafwd.h"
++#include "tao/Sequence.h"
+ 
+ #if defined (TAO_EXPORT_MACRO)
+ #undef TAO_EXPORT_MACRO
+@@ -54,14 +55,14 @@
+ #if !defined (_OCTETSEQ_CH_)
+ #define _OCTETSEQ_CH_
+ 
+-class OctetSeq;
+-class OctetSeq_var;
++class CORBA_OctetSeq;
++class CORBA_OctetSeq_var;
+ 
+ // *************************************************************
+-// OctetSeq
++// CORBA_OctetSeq
+ // *************************************************************
+ 
+-class TAO_Export OctetSeq : public 
++class TAO_Export CORBA_OctetSeq : public 
+ #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+   TAO_Unbounded_Sequence<CORBA::Octet>
+ #else /* TAO_USE_SEQUENCE_TEMPLATES */
+@@ -69,25 +70,25 @@
+ #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ {
+ public:
+-  OctetSeq (void); // default ctor
+-  OctetSeq (CORBA::ULong max); // uses max size
+-  OctetSeq (
++  CORBA_OctetSeq (void); // default ctor
++  CORBA_OctetSeq (CORBA::ULong max); // uses max size
++  CORBA_OctetSeq (
+     CORBA::ULong max, 
+     CORBA::ULong length, 
+     CORBA::Octet *buffer, 
+     CORBA::Boolean release = 0
+   );
+-  OctetSeq (const OctetSeq &); // copy ctor
+-  ~OctetSeq (void);
++  CORBA_OctetSeq (const CORBA_OctetSeq &); // copy ctor
++  ~CORBA_OctetSeq (void);
+   static void _tao_any_destructor (void*);
+ 
+ #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+-  typedef OctetSeq_var _var_type;
++  typedef CORBA_OctetSeq_var _var_type;
+ #endif /* ! __GNUC__ || g++ >= 2.8 */
+ 
+ 
+ #if (TAO_NO_COPY_OCTET_SEQUENCES == 1)
+-  OctetSeq (
++  CORBA_OctetSeq (
+       CORBA::ULong length,
+       const ACE_Message_Block* mb
+     )
+@@ -103,40 +104,40 @@
+ #define _OCTETSEQ___VAR_CH_
+ 
+ // *************************************************************
+-// class OctetSeq_var
++// class CORBA_OctetSeq_var
+ // *************************************************************
+ 
+-class TAO_Export OctetSeq_var
++class TAO_Export CORBA_OctetSeq_var
+ {
+ public:
+-  OctetSeq_var (void); // default constructor
+-  OctetSeq_var (OctetSeq *);
+-  OctetSeq_var (const OctetSeq_var &); // copy constructor
+-  OctetSeq_var (const OctetSeq &); // fixed-size base types only
+-  ~OctetSeq_var (void); // destructor
++  CORBA_OctetSeq_var (void); // default constructor
++  CORBA_OctetSeq_var (CORBA_OctetSeq *);
++  CORBA_OctetSeq_var (const CORBA_OctetSeq_var &); // copy constructor
++  CORBA_OctetSeq_var (const CORBA_OctetSeq &); // fixed-size base types only
++  ~CORBA_OctetSeq_var (void); // destructor
+   
+-  OctetSeq_var &operator= (OctetSeq *);
+-  OctetSeq_var &operator= (const OctetSeq_var &);
+-  OctetSeq_var &operator= (const OctetSeq &); // fixed-size base types only
+-  OctetSeq *operator-> (void);
+-  const OctetSeq *operator-> (void) const;
++  CORBA_OctetSeq_var &operator= (CORBA_OctetSeq *);
++  CORBA_OctetSeq_var &operator= (const CORBA_OctetSeq_var &);
++  CORBA_OctetSeq_var &operator= (const CORBA_OctetSeq &); // fixed-size base types only
++  CORBA_OctetSeq *operator-> (void);
++  const CORBA_OctetSeq *operator-> (void) const;
+   
+-  operator const OctetSeq &() const;
+-  operator OctetSeq &();
+-  operator OctetSeq &() const;
++  operator const CORBA_OctetSeq &() const;
++  operator CORBA_OctetSeq &();
++  operator CORBA_OctetSeq &() const;
+   
+   CORBA::Octet & operator[] (CORBA::ULong index);
+   const CORBA::Octet & operator[] (CORBA::ULong index) const;
+   
+   // in, inout, out, _retn 
+-  const OctetSeq &in (void) const;
+-  OctetSeq &inout (void);
+-  OctetSeq *&out (void);
+-  OctetSeq *_retn (void);
+-  OctetSeq *ptr (void) const;
++  const CORBA_OctetSeq &in (void) const;
++  CORBA_OctetSeq &inout (void);
++  CORBA_OctetSeq *&out (void);
++  CORBA_OctetSeq *_retn (void);
++  CORBA_OctetSeq *ptr (void) const;
+ 
+ private:
+-  OctetSeq *ptr_;
++  CORBA_OctetSeq *ptr_;
+ };
+ 
+ 
+@@ -146,51 +147,51 @@
+ #if !defined (_OCTETSEQ___OUT_CH_)
+ #define _OCTETSEQ___OUT_CH_
+ 
+-class TAO_Export OctetSeq_out
++class TAO_Export CORBA_OctetSeq_out
+ {
+ public:
+-  OctetSeq_out (OctetSeq *&);
+-  OctetSeq_out (OctetSeq_var &);
+-  OctetSeq_out (const OctetSeq_out &);
+-  OctetSeq_out &operator= (const OctetSeq_out &);
+-  OctetSeq_out &operator= (OctetSeq *);
+-  operator OctetSeq *&();
+-  OctetSeq *&ptr (void);
+-  OctetSeq *operator-> (void);
++  CORBA_OctetSeq_out (CORBA_OctetSeq *&);
++  CORBA_OctetSeq_out (CORBA_OctetSeq_var &);
++  CORBA_OctetSeq_out (const CORBA_OctetSeq_out &);
++  CORBA_OctetSeq_out &operator= (const CORBA_OctetSeq_out &);
++  CORBA_OctetSeq_out &operator= (CORBA_OctetSeq *);
++  operator CORBA_OctetSeq *&();
++  CORBA_OctetSeq *&ptr (void);
++  CORBA_OctetSeq *operator-> (void);
+   CORBA::Octet & operator[] (CORBA::ULong index);
+   
+ private:
+-  OctetSeq *&ptr_;
++  CORBA_OctetSeq *&ptr_;
+   // assignment from T_var not allowed
+-  void operator= (const OctetSeq_var &);
++  void operator= (const CORBA_OctetSeq_var &);
+ };
+ 
+ 
+ #endif /* end #if !defined */
+ 
+-extern TAO_Export CORBA::TypeCode_ptr  _tc_OctetSeq;
++extern TAO_Export CORBA::TypeCode_ptr  _tc_CORBA_OctetSeq;
+ 
+-TAO_Export void operator<<= (CORBA::Any &, const OctetSeq &); // copying version
+-TAO_Export void operator<<= (CORBA::Any &, OctetSeq*); // noncopying version
+-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, OctetSeq *&); // deprecated
+-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const OctetSeq *&);
++TAO_Export void operator<<= (CORBA::Any &, const CORBA_OctetSeq &); // copying version
++TAO_Export void operator<<= (CORBA::Any &, CORBA_OctetSeq*); // noncopying version
++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_OctetSeq *&); // deprecated
++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA_OctetSeq *&);
+ 
+ #ifndef __ACE_INLINE__
+ 
+ 
+-#if !defined _TAO_CDR_OP_OctetSeq_H_
+-#define _TAO_CDR_OP_OctetSeq_H_
++#if !defined _TAO_CDR_OP_CORBA_OctetSeq_H_
++#define _TAO_CDR_OP_CORBA_OctetSeq_H_
+ 
+ TAO_Export CORBA::Boolean operator<< (
+     TAO_OutputCDR &,
+-    const OctetSeq &
++    const CORBA_OctetSeq &
+   );
+ TAO_Export CORBA::Boolean operator>> (
+     TAO_InputCDR &,
+-    OctetSeq &
++    CORBA_OctetSeq &
+   );
+ 
+-#endif /* _TAO_CDR_OP_OctetSeq_H_ */
++#endif /* _TAO_CDR_OP_CORBA_OctetSeq_H_ */
+ 
+ 
+ #endif /* __ACE_INLINE__ */
+--- OctetSeqC.i.old	Sun Oct 22 22:28:28 2000
++++ OctetSeqC.i	Sun Oct 22 22:29:06 2000
+@@ -24,162 +24,162 @@
+ #define _OCTETSEQ_CI_
+ 
+ // *************************************************************
+-// Inline operations for class OctetSeq_var
++// Inline operations for class CORBA_OctetSeq_var
+ // *************************************************************
+ 
+ ACE_INLINE
+-OctetSeq_var::OctetSeq_var (void) // default constructor
++CORBA_OctetSeq_var::CORBA_OctetSeq_var (void) // default constructor
+   : ptr_ (0)
+ {}
+ 
+ ACE_INLINE
+-OctetSeq_var::OctetSeq_var (OctetSeq *p)
++CORBA_OctetSeq_var::CORBA_OctetSeq_var (CORBA_OctetSeq *p)
+   : ptr_ (p)
+ {}
+ 
+ ACE_INLINE
+-OctetSeq_var::OctetSeq_var (const ::OctetSeq_var &p) // copy constructor
++CORBA_OctetSeq_var::CORBA_OctetSeq_var (const ::CORBA_OctetSeq_var &p) // copy constructor
+ {
+   if (p.ptr_)
+-    ACE_NEW (this->ptr_, ::OctetSeq (*p.ptr_));
++    ACE_NEW (this->ptr_, ::CORBA_OctetSeq (*p.ptr_));
+   else
+     this->ptr_ = 0;
+ }
+ 
+ // fixed-size base types only
+ ACE_INLINE
+-OctetSeq_var::OctetSeq_var (const ::OctetSeq &p)
++CORBA_OctetSeq_var::CORBA_OctetSeq_var (const ::CORBA_OctetSeq &p)
+ {
+-  ACE_NEW (this->ptr_, ::OctetSeq (p));
++  ACE_NEW (this->ptr_, ::CORBA_OctetSeq (p));
+ }
+ 
+ ACE_INLINE
+-OctetSeq_var::~OctetSeq_var (void) // destructor
++CORBA_OctetSeq_var::~CORBA_OctetSeq_var (void) // destructor
+ {
+   delete this->ptr_;
+ }
+ 
+-ACE_INLINE OctetSeq_var &
+-OctetSeq_var::operator= (OctetSeq *p)
++ACE_INLINE CORBA_OctetSeq_var &
++CORBA_OctetSeq_var::operator= (CORBA_OctetSeq *p)
+ {
+   delete this->ptr_;
+   this->ptr_ = p;
+   return *this;
+ }
+ 
+-ACE_INLINE OctetSeq_var &
+-OctetSeq_var::operator= (const ::OctetSeq_var &p) // deep copy
++ACE_INLINE CORBA_OctetSeq_var &
++CORBA_OctetSeq_var::operator= (const ::CORBA_OctetSeq_var &p) // deep copy
+ {
+   if (this != &p)
+   {
+     delete this->ptr_;
+-    ACE_NEW_RETURN (this->ptr_, ::OctetSeq (*p.ptr_), *this);
++    ACE_NEW_RETURN (this->ptr_, ::CORBA_OctetSeq (*p.ptr_), *this);
+   }
+   return *this;
+ }
+ 
+ // fixed-size types only
+-ACE_INLINE ::OctetSeq_var &
+-OctetSeq_var::operator= (const ::OctetSeq &p)
++ACE_INLINE ::CORBA_OctetSeq_var &
++CORBA_OctetSeq_var::operator= (const ::CORBA_OctetSeq &p)
+ {
+   if (this->ptr_ != &p)
+   {
+     delete this->ptr_;
+-    ACE_NEW_RETURN (this->ptr_, ::OctetSeq (p), *this);
++    ACE_NEW_RETURN (this->ptr_, ::CORBA_OctetSeq (p), *this);
+   }
+   return *this;
+ }
+ 
+-ACE_INLINE const ::OctetSeq *
+-OctetSeq_var::operator-> (void) const
++ACE_INLINE const ::CORBA_OctetSeq *
++CORBA_OctetSeq_var::operator-> (void) const
+ {
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE ::OctetSeq *
+-OctetSeq_var::operator-> (void)
++ACE_INLINE ::CORBA_OctetSeq *
++CORBA_OctetSeq_var::operator-> (void)
+ {
+   return this->ptr_;
+ }
+ 
+ ACE_INLINE 
+-OctetSeq_var::operator const ::OctetSeq &() const // cast
++CORBA_OctetSeq_var::operator const ::CORBA_OctetSeq &() const // cast
+ {
+   return *this->ptr_;
+ }
+ 
+ ACE_INLINE 
+-OctetSeq_var::operator ::OctetSeq &() // cast 
++CORBA_OctetSeq_var::operator ::CORBA_OctetSeq &() // cast 
+ {
+   return *this->ptr_;
+ }
+ 
+ ACE_INLINE 
+-OctetSeq_var::operator ::OctetSeq &() const // cast 
++CORBA_OctetSeq_var::operator ::CORBA_OctetSeq &() const // cast 
+ {
+   return *this->ptr_;
+ }
+ 
+ ACE_INLINE CORBA::Octet &
+-OctetSeq_var::operator[] (CORBA::ULong index)
++CORBA_OctetSeq_var::operator[] (CORBA::ULong index)
+ {
+   return this->ptr_->operator[] (index);
+ }
+ 
+ ACE_INLINE const CORBA::Octet &
+-OctetSeq_var::operator[] (CORBA::ULong index) const
++CORBA_OctetSeq_var::operator[] (CORBA::ULong index) const
+ {
+   return ACE_const_cast (const CORBA::Octet &, this->ptr_->operator[] (index));
+ }
+ 
+-ACE_INLINE const ::OctetSeq &
+-OctetSeq_var::in (void) const
++ACE_INLINE const ::CORBA_OctetSeq &
++CORBA_OctetSeq_var::in (void) const
+ {
+   return *this->ptr_;
+ }
+ 
+-ACE_INLINE ::OctetSeq &
+-OctetSeq_var::inout (void)
++ACE_INLINE ::CORBA_OctetSeq &
++CORBA_OctetSeq_var::inout (void)
+ {
+   return *this->ptr_;
+ }
+ 
+ // mapping for variable size 
+-ACE_INLINE ::OctetSeq *&
+-OctetSeq_var::out (void)
++ACE_INLINE ::CORBA_OctetSeq *&
++CORBA_OctetSeq_var::out (void)
+ {
+   delete this->ptr_;
+   this->ptr_ = 0;
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE ::OctetSeq *
+-OctetSeq_var::_retn (void)
++ACE_INLINE ::CORBA_OctetSeq *
++CORBA_OctetSeq_var::_retn (void)
+ {
+-  ::OctetSeq *tmp = this->ptr_;
++  ::CORBA_OctetSeq *tmp = this->ptr_;
+   this->ptr_ = 0;
+   return tmp;
+ }
+ 
+-ACE_INLINE ::OctetSeq *
+-OctetSeq_var::ptr (void) const
++ACE_INLINE ::CORBA_OctetSeq *
++CORBA_OctetSeq_var::ptr (void) const
+ {
+   return this->ptr_;
+ }
+ 
+ // *************************************************************
+-// Inline operations for class OctetSeq_out
++// Inline operations for class CORBA_OctetSeq_out
+ // *************************************************************
+ 
+ ACE_INLINE
+-OctetSeq_out::OctetSeq_out (OctetSeq *&p)
++CORBA_OctetSeq_out::CORBA_OctetSeq_out (CORBA_OctetSeq *&p)
+   : ptr_ (p)
+ {
+   this->ptr_ = 0;
+ }
+ 
+ ACE_INLINE
+-OctetSeq_out::OctetSeq_out (OctetSeq_var &p) // constructor from _var
++CORBA_OctetSeq_out::CORBA_OctetSeq_out (CORBA_OctetSeq_var &p) // constructor from _var
+   : ptr_ (p.out ())
+ {
+   delete this->ptr_;
+@@ -187,44 +187,44 @@
+ }
+ 
+ ACE_INLINE
+-OctetSeq_out::OctetSeq_out (const ::OctetSeq_out &p) // copy constructor
+-  : ptr_ (ACE_const_cast (OctetSeq_out&, p).ptr_)
++CORBA_OctetSeq_out::CORBA_OctetSeq_out (const ::CORBA_OctetSeq_out &p) // copy constructor
++  : ptr_ (ACE_const_cast (CORBA_OctetSeq_out&, p).ptr_)
+ {}
+ 
+-ACE_INLINE ::OctetSeq_out &
+-OctetSeq_out::operator= (const ::OctetSeq_out &p)
++ACE_INLINE ::CORBA_OctetSeq_out &
++CORBA_OctetSeq_out::operator= (const ::CORBA_OctetSeq_out &p)
+ {
+-  this->ptr_ = ACE_const_cast (OctetSeq_out&, p).ptr_;
++  this->ptr_ = ACE_const_cast (CORBA_OctetSeq_out&, p).ptr_;
+   return *this;
+ }
+ 
+-ACE_INLINE ::OctetSeq_out &
+-OctetSeq_out::operator= (OctetSeq *p)
++ACE_INLINE ::CORBA_OctetSeq_out &
++CORBA_OctetSeq_out::operator= (CORBA_OctetSeq *p)
+ {
+   this->ptr_ = p;
+   return *this;
+ }
+ 
+ ACE_INLINE 
+-OctetSeq_out::operator ::OctetSeq *&() // cast
++CORBA_OctetSeq_out::operator ::CORBA_OctetSeq *&() // cast
+ {
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE ::OctetSeq *&
+-OctetSeq_out::ptr (void) // ptr
++ACE_INLINE ::CORBA_OctetSeq *&
++CORBA_OctetSeq_out::ptr (void) // ptr
+ {
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE ::OctetSeq *
+-OctetSeq_out::operator-> (void)
++ACE_INLINE ::CORBA_OctetSeq *
++CORBA_OctetSeq_out::operator-> (void)
+ {
+   return this->ptr_;
+ }
+ 
+ ACE_INLINE CORBA::Octet &
+-OctetSeq_out::operator[] (CORBA::ULong index)
++CORBA_OctetSeq_out::operator[] (CORBA::ULong index)
+ {
+   return this->ptr_->operator[] (index);
+ }
+@@ -233,17 +233,17 @@
+ #endif /* end #if !defined */
+ 
+ 
+-#if !defined _TAO_CDR_OP_OctetSeq_I_
+-#define _TAO_CDR_OP_OctetSeq_I_
++#if !defined _TAO_CDR_OP_CORBA_OctetSeq_I_
++#define _TAO_CDR_OP_CORBA_OctetSeq_I_
+ 
+ CORBA::Boolean TAO_Export operator<< (
+     TAO_OutputCDR &,
+-    const OctetSeq &
++    const CORBA_OctetSeq &
+   );
+ CORBA::Boolean TAO_Export operator>> (
+     TAO_InputCDR &,
+-    OctetSeq &
++    CORBA_OctetSeq &
+   );
+ 
+-#endif /* _TAO_CDR_OP_OctetSeq_I_ */
++#endif /* _TAO_CDR_OP_CORBA_OctetSeq_I_ */
+ 
+--- OctetSeqC.cpp.old	Sun Oct 22 22:28:28 2000
++++ OctetSeqC.cpp	Sun Oct 22 22:29:06 2000
+@@ -25,17 +25,18 @@
+ #include "OctetSeqC.i"
+ #endif /* !defined INLINE */
+ 
++#include "tao/Any.h"
+ 
+ #if !defined (_OCTETSEQ_CS_)
+ #define _OCTETSEQ_CS_
+ 
+ // *************************************************************
+-// OctetSeq
++// CORBA_OctetSeq
+ // *************************************************************
+ 
+-OctetSeq::OctetSeq (void)
++CORBA_OctetSeq::CORBA_OctetSeq (void)
+ {}
+-OctetSeq::OctetSeq (CORBA::ULong max) // uses max size
++CORBA_OctetSeq::CORBA_OctetSeq (CORBA::ULong max) // uses max size
+   : 
+ #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+   TAO_Unbounded_Sequence<CORBA::Octet>
+@@ -44,7 +45,7 @@
+ #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  (max)
+ {}
+-OctetSeq::OctetSeq (CORBA::ULong max, CORBA::ULong length, CORBA::Octet *buffer, CORBA::Boolean release)
++CORBA_OctetSeq::CORBA_OctetSeq (CORBA::ULong max, CORBA::ULong length, CORBA::Octet *buffer, CORBA::Boolean release)
+   : 
+ #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+   TAO_Unbounded_Sequence<CORBA::Octet>
+@@ -53,7 +54,7 @@
+ #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  (max, length, buffer, release)
+ {}
+-OctetSeq::OctetSeq (const OctetSeq &seq) // copy ctor
++CORBA_OctetSeq::CORBA_OctetSeq (const CORBA_OctetSeq &seq) // copy ctor
+   : 
+ #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+   TAO_Unbounded_Sequence<CORBA::Octet>
+@@ -62,22 +63,22 @@
+ #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  (seq)
+ {}
+-OctetSeq::~OctetSeq (void) // dtor
++CORBA_OctetSeq::~CORBA_OctetSeq (void) // dtor
+ {}
+-void OctetSeq::_tao_any_destructor (void *x)
++void CORBA_OctetSeq::_tao_any_destructor (void *x)
+ {
+-  OctetSeq *tmp = ACE_static_cast (OctetSeq*,x);
++  CORBA_OctetSeq *tmp = ACE_static_cast (CORBA_OctetSeq*,x);
+   delete tmp;
+ }
+ 
+ 
+ #endif /* end #if !defined */
+ 
+-static const CORBA::Long _oc_OctetSeq[] =
++static const CORBA::Long _oc_CORBA_OctetSeq[] =
+ {
+   TAO_ENCAP_BYTE_ORDER, // byte order
+-  17, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x4f637465), ACE_NTOHL (0x74536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:OctetSeq:1.0
+-  9, ACE_NTOHL (0x4f637465), ACE_NTOHL (0x74536571), ACE_NTOHL (0x0),  // name = OctetSeq
++  17, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x4f637465), ACE_NTOHL (0x74536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:CORBA_OctetSeq:1.0
++  9, ACE_NTOHL (0x4f637465), ACE_NTOHL (0x74536571), ACE_NTOHL (0x0),  // name = CORBA_OctetSeq
+   CORBA::tk_sequence, // typecode kind
+   12, // encapsulation length
+     TAO_ENCAP_BYTE_ORDER, // byte order
+@@ -86,54 +87,54 @@
+     0U,
+ 
+ };
+-static CORBA::TypeCode _tc_TAO_tc_OctetSeq (CORBA::tk_alias, sizeof (_oc_OctetSeq), (char *) &_oc_OctetSeq, 0, sizeof (OctetSeq));
+-CORBA::TypeCode_ptr _tc_OctetSeq = &_tc_TAO_tc_OctetSeq;
++static CORBA::TypeCode _tc_TAO_tc_CORBA_OctetSeq (CORBA::tk_alias, sizeof (_oc_CORBA_OctetSeq), (char *) &_oc_CORBA_OctetSeq, 0, sizeof (CORBA_OctetSeq));
++CORBA::TypeCode_ptr _tc_CORBA_OctetSeq = &_tc_TAO_tc_CORBA_OctetSeq;
+ 
+ void operator<<= (
+     CORBA::Any &_tao_any,
+-    const OctetSeq &_tao_elem
++    const CORBA_OctetSeq &_tao_elem
+   ) // copying
+ {
+   TAO_OutputCDR stream;
+   if (stream << _tao_elem)
+   {
+     _tao_any._tao_replace (
+-        _tc_OctetSeq,
++        _tc_CORBA_OctetSeq,
+         TAO_ENCAP_BYTE_ORDER,
+         stream.begin ()
+       );
+   }
+ }
+ 
+-void operator<<= (CORBA::Any &_tao_any, OctetSeq *_tao_elem) // non copying
++void operator<<= (CORBA::Any &_tao_any, CORBA_OctetSeq *_tao_elem) // non copying
+ {
+   TAO_OutputCDR stream;
+   stream << *_tao_elem;
+   _tao_any._tao_replace (
+-      _tc_OctetSeq,
++      _tc_CORBA_OctetSeq,
+       TAO_ENCAP_BYTE_ORDER,
+       stream.begin (),
+       1,
+       _tao_elem,
+-      OctetSeq::_tao_any_destructor
++      CORBA_OctetSeq::_tao_any_destructor
+     );
+ }
+ 
+-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, OctetSeq *&_tao_elem)
++CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_OctetSeq *&_tao_elem)
+ {
+   return _tao_any >>= ACE_const_cast(
+-      const OctetSeq*&,
++      const CORBA_OctetSeq*&,
+       _tao_elem
+     );
+ }
+ 
+-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const OctetSeq *&_tao_elem)
++CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_OctetSeq *&_tao_elem)
+ {
+   _tao_elem = 0;
+   ACE_TRY_NEW_ENV
+   {
+     CORBA::TypeCode_var type = _tao_any.type ();
+-    if (!type->equivalent (_tc_OctetSeq, ACE_TRY_ENV)) // not equal
++    if (!type->equivalent (_tc_CORBA_OctetSeq, ACE_TRY_ENV)) // not equal
+       {
+         return 0;
+       }
+@@ -141,15 +142,15 @@
+     if (_tao_any.any_owns_data ())
+     {
+       _tao_elem = ACE_static_cast(
+-          const OctetSeq*,
++          const CORBA_OctetSeq*,
+           _tao_any.value ()
+         );
+       return 1;
+     }
+     else
+     {
+-      OctetSeq *tmp;
+-      ACE_NEW_RETURN (tmp, OctetSeq, 0);
++      CORBA_OctetSeq *tmp;
++      ACE_NEW_RETURN (tmp, CORBA_OctetSeq, 0);
+       TAO_InputCDR stream (
+           _tao_any._tao_get_cdr (),
+           _tao_any._tao_byte_order ()
+@@ -157,10 +158,10 @@
+       if (stream >> *tmp)
+       {
+         ((CORBA::Any *)&_tao_any)->_tao_replace (
+-            _tc_OctetSeq,
++            _tc_CORBA_OctetSeq,
+             1,
+             ACE_static_cast (void *, tmp),
+-            OctetSeq::_tao_any_destructor
++            CORBA_OctetSeq::_tao_any_destructor
+           );
+         _tao_elem = tmp;
+         return 1;
+@@ -180,7 +181,7 @@
+ 
+ CORBA::Boolean operator<< (
+     TAO_OutputCDR &strm,
+-    const OctetSeq &_tao_sequence
++    const CORBA_OctetSeq &_tao_sequence
+   )
+ {
+   if (strm << _tao_sequence.length ())
+@@ -190,7 +191,7 @@
+ #if (TAO_NO_COPY_OCTET_SEQUENCES == 1)
+     {
+       TAO_Unbounded_Sequence<CORBA::Octet> *oseq = 
+-        ACE_static_cast (TAO_Unbounded_Sequence<CORBA::Octet>*, (OctetSeq *)&_tao_sequence);
++        ACE_static_cast (TAO_Unbounded_Sequence<CORBA::Octet>*, (CORBA_OctetSeq *)&_tao_sequence);
+       if (oseq->mb ())
+         return strm.write_octet_array_mb (oseq->mb ());
+       else
+@@ -207,7 +208,7 @@
+ 
+ CORBA::Boolean operator>> (
+     TAO_InputCDR &strm,
+-    OctetSeq &_tao_sequence
++    CORBA_OctetSeq &_tao_sequence
+   )
+ {
+   CORBA::ULong _tao_seq_len;
diff --git a/TAO/tao/diffs/PolicyS.cpp.diff b/TAO/tao/diffs/PolicyS.cpp.diff
new file mode 100644
index 00000000000..5c0a0b21986
--- /dev/null
+++ b/TAO/tao/diffs/PolicyS.cpp.diff
@@ -0,0 +1,315 @@
+--- PolicyS.cpp	Fri Jul 14 06:18:45 2000
++++ PolicyS.cpp.mod	Fri Jul 14 06:18:30 2000
+@@ -7,12 +7,16 @@
+ // Information about TAO is available at:
+ //                 http://www.cs.wustl.edu/~schmidt/TAO.html
+ 
+-#include "PolicyS.h"
++#include "tao/PolicyC.h"
++#include "tao/Operation_Table.h"
++#include "tao/Server_Request.h"
++#include "tao/NVList.h"
++#include "tao/Stub.h"
++#include "tao/POA_CORBA.h"
++#include "tao/Typecode.h"
++#include "tao/Object_Adapter.h"
++#include "tao/ORB_Core.h"
+ 
+-#if !defined (__ACE_INLINE__)
+-#include "PolicyS.i"
+-#endif /* !defined INLINE */
+-
+ class TAO_CORBA_Policy_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
+ {
+ private:
+@@ -91,14 +95,14 @@
+   static const class TAO_operation_db_entry  wordlist[] =
+     {
+       {"",0},{"",0},{"",0},{"",0},
+-      {"copy", 	&POA_CORBA_Policy::copy_skel},
+-      {"_is_a",  &POA_CORBA_Policy::_is_a_skel},
++      {"copy",  &POA_CORBA::Policy::copy_skel},
++      {"_is_a",  &POA_CORBA::Policy::_is_a_skel},
+       {"",0},
+-      {"destroy", 	&POA_CORBA_Policy::destroy_skel},
++      {"destroy",       &POA_CORBA::Policy::destroy_skel},
+       {"",0},{"",0},{"",0},{"",0},{"",0},
+-      {"_non_existent",  &POA_CORBA_Policy::_non_existent_skel},
++      {"_non_existent",  &POA_CORBA::Policy::_non_existent_skel},
+       {"",0},{"",0},
+-      {"_get_policy_type", 	&POA_CORBA_Policy::_get_policy_type_skel},
++      {"_get_policy_type",      &POA_CORBA::Policy::_get_policy_type_skel},
+     };
+ 
+   if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
+@@ -131,7 +135,7 @@
+       CORBA_Policy_ptr retval = 0;
+       ACE_NEW_RETURN (
+           retval,
+-          _tao_thru_poa_collocated_CORBA_Policy (stub),
++          POA_CORBA::_tao_thru_poa_collocated_CORBA_Policy (stub),
+           0
+         );
+       return retval;
+@@ -158,29 +162,29 @@
+   _TAO_collocation_POA_CORBA_Policy_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_Policy_Stub_Factory_Initializer));
+ 
+ // skeleton constructor
+-POA_CORBA_Policy::POA_CORBA_Policy (void)
++POA_CORBA::Policy::Policy (void)
+ {
+   this->optable_ = &tao_CORBA_Policy_optable;
+ }
+ 
+ // copy ctor
+-POA_CORBA_Policy::POA_CORBA_Policy (const POA_CORBA_Policy& rhs)
++POA_CORBA::Policy::Policy (const POA_CORBA::Policy& rhs)
+   :   TAO_ServantBase (rhs)
+ {}
+ 
+ // skeleton destructor
+-POA_CORBA_Policy::~POA_CORBA_Policy (void)
++POA_CORBA::Policy::~Policy (void)
+ {
+ }
+ 
+-void POA_CORBA_Policy::_get_policy_type_skel (
++void POA_CORBA::Policy::_get_policy_type_skel (
+     TAO_ServerRequest &_tao_server_request,
+     void *_tao_object_reference, 
+     void * /* context */, 
+     CORBA::Environment &ACE_TRY_ENV
+ )
+ {
+-  POA_CORBA_Policy *_tao_impl = (POA_CORBA_Policy *)_tao_object_reference;
++  POA_CORBA::Policy *_tao_impl = (POA_CORBA::Policy *)_tao_object_reference;
+ 
+   CORBA::PolicyType _tao_retval = 0;
+ #if (TAO_HAS_INTERCEPTORS == 1)
+@@ -259,14 +263,14 @@
+ 
+ }
+ 
+-void POA_CORBA_Policy::copy_skel (
++void POA_CORBA::Policy::copy_skel (
+     TAO_ServerRequest &_tao_server_request,
+     void *_tao_object_reference, 
+     void * /* context */, 
+     CORBA::Environment &ACE_TRY_ENV
+ )
+ {
+-  POA_CORBA_Policy *_tao_impl = (POA_CORBA_Policy *)_tao_object_reference;
++  POA_CORBA::Policy *_tao_impl = (POA_CORBA::Policy *)_tao_object_reference;
+ 
+   CORBA_Policy_var _tao_retval;
+ #if (TAO_HAS_INTERCEPTORS == 1)
+@@ -345,14 +349,14 @@
+ 
+ }
+ 
+-void POA_CORBA_Policy::destroy_skel (
++void POA_CORBA::Policy::destroy_skel (
+     TAO_ServerRequest &_tao_server_request,
+     void *_tao_object_reference, 
+     void * /* context */, 
+     CORBA::Environment &ACE_TRY_ENV
+ )
+ {
+-  POA_CORBA_Policy *_tao_impl = (POA_CORBA_Policy *)_tao_object_reference;
++  POA_CORBA::Policy *_tao_impl = (POA_CORBA::Policy *)_tao_object_reference;
+ 
+ #if (TAO_HAS_INTERCEPTORS == 1)
+   TAO_ServerRequestInterceptor_Adapter
+@@ -424,7 +428,7 @@
+   ACE_CHECK;
+   }
+ 
+-void POA_CORBA_Policy::_is_a_skel (
++void POA_CORBA::Policy::_is_a_skel (
+     TAO_ServerRequest &_tao_server_request, 
+     void * _tao_object_reference,
+     void * /* context */,
+@@ -432,7 +436,7 @@
+   )
+ {
+   TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
+-  POA_CORBA_Policy *_tao_impl = (POA_CORBA_Policy *) _tao_object_reference;
++  POA_CORBA::Policy *_tao_impl = (POA_CORBA::Policy *) _tao_object_reference;
+   CORBA::Boolean _tao_retval = 0;
+   CORBA::String_var value;
+   if (!(_tao_in >> value.out ()))
+@@ -448,14 +452,14 @@
+     ACE_THROW (CORBA::MARSHAL ());
+ }
+ 
+-void POA_CORBA_Policy::_non_existent_skel (
++void POA_CORBA::Policy::_non_existent_skel (
+     TAO_ServerRequest &_tao_server_request, 
+     void * _tao_object_reference,
+     void * /* context */,
+     CORBA::Environment &ACE_TRY_ENV
+   )
+ {
+-  POA_CORBA_Policy *_tao_impl = (POA_CORBA_Policy *) _tao_object_reference;
++  POA_CORBA::Policy *_tao_impl = (POA_CORBA::Policy *) _tao_object_reference;
+   CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
+   ACE_CHECK;
+   
+@@ -466,7 +470,7 @@
+     ACE_THROW (CORBA::MARSHAL ());
+ }
+ 
+-CORBA::Boolean POA_CORBA_Policy::_is_a (
++CORBA::Boolean POA_CORBA::Policy::_is_a (
+     const char* value,
+     CORBA::Environment &ACE_TRY_ENV
+   )
+@@ -479,29 +483,29 @@
+       return 0;
+ }
+ 
+-void* POA_CORBA_Policy::_downcast (
++void* POA_CORBA::Policy::_downcast (
+     const char* logical_type_id
+   )
+ {
+ if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA_Policy:1.0") == 0)
+-    return ACE_static_cast (POA_CORBA_Policy_ptr, this);
++    return ACE_static_cast (POA_CORBA::Policy_ptr, this);
+     if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
+     return ACE_static_cast(PortableServer::Servant, this);
+   return 0;
+ }
+ 
+-void POA_CORBA_Policy::_dispatch (TAO_ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
++void POA_CORBA::Policy::_dispatch (TAO_ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
+ {
+   this->synchronous_upcall_dispatch(req, context, this, ACE_TRY_ENV);
+ }
+ 
+-const char* POA_CORBA_Policy::_interface_repository_id (void) const
++const char* POA_CORBA::Policy::_interface_repository_id (void) const
+ {
+   return "IDL:omg.org/CORBA_Policy:1.0";
+ }
+ 
+ CORBA_Policy*
+-POA_CORBA_Policy::_this (CORBA_Environment &ACE_TRY_ENV)
++POA_CORBA::Policy::_this (CORBA_Environment &ACE_TRY_ENV)
+ {
+   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
+   ACE_CHECK_RETURN (0);
+@@ -513,7 +517,7 @@
+           ::CORBA_Policy_ptr retval = 0;
+           ACE_NEW_RETURN (
+               retval,
+-              _tao_thru_poa_collocated_CORBA_Policy (stub),
++              POA_CORBA::_tao_thru_poa_collocated_CORBA_Policy (stub),
+               0
+             );
+           return retval;
+@@ -533,14 +537,14 @@
+     }
+ }
+ 
+-_tao_thru_poa_collocated_CORBA_Policy::_tao_thru_poa_collocated_CORBA_Policy (
++POA_CORBA::_tao_thru_poa_collocated_CORBA_Policy::_tao_thru_poa_collocated_CORBA_Policy (
+   TAO_Stub *stub
+ )
+   :  CORBA_Object (stub, 0, 1)
+ {
+ }
+ 
+-CORBA::Boolean _tao_thru_poa_collocated_CORBA_Policy::_is_a(
++CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_CORBA_Policy::_is_a(
+     const CORBA::Char *logical_type_id,
+     CORBA_Environment &ACE_TRY_ENV
+   )
+@@ -556,7 +560,7 @@
+     );
+   ACE_CHECK_RETURN (0);
+   return ACE_reinterpret_cast (
+-      POA_CORBA_Policy_ptr,
++      POA_CORBA::Policy_ptr,
+       servant_upcall.servant ()->_downcast (
+           "IDL:omg.org/CORBA_Policy:1.0"
+         )
+@@ -564,7 +568,7 @@
+ }
+ 
+ 
+-CORBA::Boolean _tao_thru_poa_collocated_CORBA_Policy::_non_existent(
++CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_CORBA_Policy::_non_existent(
+     CORBA_Environment &ACE_TRY_ENV
+   )
+ 
+@@ -579,7 +583,7 @@
+     );
+   ACE_CHECK_RETURN (0);
+   return ACE_reinterpret_cast (
+-      POA_CORBA_Policy_ptr,
++      POA_CORBA::Policy_ptr,
+       servant_upcall.servant ()->_downcast (
+           "IDL:omg.org/CORBA_Policy:1.0"
+         )
+@@ -587,7 +591,7 @@
+ }
+ 
+ 
+-CORBA::PolicyType _tao_thru_poa_collocated_CORBA_Policy::policy_type  (
++CORBA::PolicyType POA_CORBA::_tao_thru_poa_collocated_CORBA_Policy::policy_type  (
+     CORBA::Environment &ACE_TRY_ENV
+   )
+   ACE_THROW_SPEC ((
+@@ -606,7 +610,7 @@
+     );
+   ACE_CHECK_RETURN  (_tao_retval);
+   return ACE_reinterpret_cast (
+-      POA_CORBA_Policy_ptr,
++      POA_CORBA::Policy_ptr,
+       servant_upcall.servant ()->_downcast (
+           "IDL:omg.org/CORBA_Policy:1.0"
+         )
+@@ -616,7 +620,7 @@
+ 
+ }
+ 
+-CORBA_Policy_ptr _tao_thru_poa_collocated_CORBA_Policy::copy  (
++CORBA_Policy_ptr POA_CORBA::_tao_thru_poa_collocated_CORBA_Policy::copy  (
+     CORBA::Environment &ACE_TRY_ENV
+   )
+   ACE_THROW_SPEC ((
+@@ -635,7 +639,7 @@
+     );
+   ACE_CHECK_RETURN (0);
+   return ACE_reinterpret_cast (
+-      POA_CORBA_Policy_ptr,
++      POA_CORBA::Policy_ptr,
+       servant_upcall.servant ()->_downcast (
+           "IDL:omg.org/CORBA_Policy:1.0"
+         )
+@@ -645,7 +649,7 @@
+ 
+ }
+ 
+-void _tao_thru_poa_collocated_CORBA_Policy::destroy  (
++void POA_CORBA::_tao_thru_poa_collocated_CORBA_Policy::destroy  (
+     CORBA::Environment &ACE_TRY_ENV
+   )
+   ACE_THROW_SPEC ((
+@@ -662,7 +666,7 @@
+     );
+   ACE_CHECK;
+   ACE_reinterpret_cast (
+-      POA_CORBA_Policy_ptr,
++      POA_CORBA::Policy_ptr,
+       servant_upcall.servant ()->_downcast (
+           "IDL:omg.org/CORBA_Policy:1.0"
+         )
+@@ -671,6 +675,3 @@
+     );
+   return;
+ }
+-
+-
+-
diff --git a/TAO/tao/diffs/PortableInterceptor.diff b/TAO/tao/diffs/PortableInterceptor.diff
new file mode 100644
index 00000000000..b1820a80a13
--- /dev/null
+++ b/TAO/tao/diffs/PortableInterceptor.diff
@@ -0,0 +1,382 @@
+--- PortableInterceptorC.h.old	Mon Oct 23 22:19:37 2000
++++ PortableInterceptorC.h	Mon Oct 23 22:21:26 2000
+@@ -23,15 +23,16 @@
+ #define _TAO_IDL_PORTABLEINTERCEPTORC_H_
+ 
+ #include "ace/pre.h"
+-#include "tao/corba.h"
++#include "tao/corbafwd.h"
+ 
+ #if !defined (ACE_LACKS_PRAGMA_ONCE)
+ # pragma once
+ #endif /* ACE_LACKS_PRAGMA_ONCE */
+ 
+-#include "tao/corbafwd.h"
+ #include "DynamicC.h"
+ #include "MessagingC.h"
++#include "CurrentC.h"
++#include "IOPC.h"
+ 
+ #if defined (TAO_EXPORT_MACRO)
+ #undef TAO_EXPORT_MACRO
+@@ -152,8 +153,7 @@
+       }
+ 
+     virtual char * name (
+-                CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+       )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException
+@@ -586,6 +586,8 @@
+         CORBA::SystemException
+       )) = 0;
+ 
++#if (TAO_HAS_CORBA_MESSAGING == 1)
++
+     virtual Messaging::SyncScope sync_scope (
+                 CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+@@ -594,6 +596,8 @@
+         CORBA::SystemException
+       )) = 0;
+ 
++#endif /* TAO_HAS_CORBA_MESSAGING == 1 */
++
+     virtual PortableInterceptor::ReplyStatus reply_status (
+                 CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+@@ -792,8 +796,7 @@
+ 
+     virtual IOP::TaggedComponent * get_effective_component (
+         IOP::ComponentId id,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ()
+       )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException
+@@ -801,8 +804,7 @@
+ 
+     virtual CORBA::Policy_ptr get_request_policy (
+         CORBA::PolicyType type,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ()
+       )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException
+@@ -811,8 +813,7 @@
+     virtual void add_request_service_context (
+         const IOP::ServiceContext & service_context,
+         CORBA::Boolean replace,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ()
+       )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException
+@@ -931,32 +932,28 @@
+       }
+ 
+     virtual CORBA::Any * sending_exception (
+-                CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ()
+       )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException
+       )) = 0;
+ 
+     virtual CORBA::OctetSeq * object_id (
+-                CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ()
+       )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException
+       )) = 0;
+ 
+     virtual CORBA::OctetSeq * adapter_id (
+-                CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ()
+       )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException
+       )) = 0;
+ 
+     virtual char * target_most_derived_interface (
+-                CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ()
+       )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException
+@@ -964,8 +961,7 @@
+ 
+     virtual CORBA::Policy_ptr get_server_policy (
+         CORBA::PolicyType type,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ()
+       )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException
+@@ -974,9 +970,8 @@
+     virtual void set_slot (
+         PortableInterceptor::SlotId id,
+         const CORBA::Any & data,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
+-      )
++        CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ()
++        )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException,
+         PortableInterceptor::InvalidSlot
+@@ -984,8 +979,7 @@
+ 
+     virtual CORBA::Boolean target_is_a (
+         const char * id,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ()
+       )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException
+@@ -994,9 +988,8 @@
+     virtual void add_reply_service_context (
+         const IOP::ServiceContext & service_context,
+         CORBA::Boolean replace,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
+-      )
++        CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ()
++        )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException
+       )) = 0;
+@@ -1114,47 +1107,42 @@
+       }
+ 
+     virtual void send_request (
+-        PortableInterceptor::ClientRequestInfo_ptr ri,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
+-      )
++        PortableInterceptor::ClientRequestInfo_ptr ri
++        TAO_ENV_ARG_DECL_WITH_DEFAULTS
++        )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException,
+         PortableInterceptor::ForwardRequest
+       )) = 0;
+ 
+     virtual void send_poll (
+-        PortableInterceptor::ClientRequestInfo_ptr ri,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        PortableInterceptor::ClientRequestInfo_ptr ri
++        TAO_ENV_ARG_DECL_WITH_DEFAULTS        
+       )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException
+       )) = 0;
+ 
+     virtual void receive_reply (
+-        PortableInterceptor::ClientRequestInfo_ptr ri,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
+-      )
++        PortableInterceptor::ClientRequestInfo_ptr ri
++        TAO_ENV_ARG_DECL_WITH_DEFAULTS
++        )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException
+       )) = 0;
+ 
+     virtual void receive_exception (
+-        PortableInterceptor::ClientRequestInfo_ptr ri,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
+-      )
++        PortableInterceptor::ClientRequestInfo_ptr ri
++        TAO_ENV_ARG_DECL_WITH_DEFAULTS
++        )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException,
+         PortableInterceptor::ForwardRequest
+       )) = 0;
+ 
+     virtual void receive_other (
+-        PortableInterceptor::ClientRequestInfo_ptr ri,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        PortableInterceptor::ClientRequestInfo_ptr ri
++        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+       )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException,
+@@ -1274,9 +1262,8 @@
+       }
+ 
+     virtual void receive_request_service_contexts (
+-        PortableInterceptor::ServerRequestInfo_ptr ri,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        PortableInterceptor::ServerRequestInfo_ptr ri
++        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+       )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException,
+@@ -1284,38 +1271,34 @@
+       )) = 0;
+ 
+     virtual void receive_request (
+-        PortableInterceptor::ServerRequestInfo_ptr ri,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
+-      )
++        PortableInterceptor::ServerRequestInfo_ptr ri
++        TAO_ENV_ARG_DECL_WITH_DEFAULTS
++        )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException,
+         PortableInterceptor::ForwardRequest
+       )) = 0;
+ 
+     virtual void send_reply (
+-        PortableInterceptor::ServerRequestInfo_ptr ri,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
+-      )
++        PortableInterceptor::ServerRequestInfo_ptr ri
++        TAO_ENV_ARG_DECL_WITH_DEFAULTS
++        )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException
+       )) = 0;
+ 
+     virtual void send_exception (
+-        PortableInterceptor::ServerRequestInfo_ptr ri,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
+-      )
++        PortableInterceptor::ServerRequestInfo_ptr ri
++        TAO_ENV_ARG_DECL_WITH_DEFAULTS
++        )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException,
+         PortableInterceptor::ForwardRequest
+       )) = 0;
+ 
+     virtual void send_other (
+-        PortableInterceptor::ServerRequestInfo_ptr ri,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        PortableInterceptor::ServerRequestInfo_ptr ri
++        TAO_ENV_ARG_DECL_WITH_DEFAULTS        
+       )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException,
+@@ -1436,8 +1419,7 @@
+ 
+     virtual CORBA::Policy_ptr get_effective_policy (
+         CORBA::PolicyType type,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ()
+       )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException
+@@ -1445,8 +1427,7 @@
+ 
+     virtual void add_ior_component (
+         const IOP::TaggedComponent & component,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ()
+       )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException
+@@ -1455,8 +1436,7 @@
+     virtual void add_ior_component_to_profile (
+         const IOP::TaggedComponent & component,
+         IOP::ProfileId profile_id,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ()
+       )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException
+@@ -1575,9 +1555,8 @@
+       }
+ 
+     virtual void establish_components (
+-        PortableInterceptor::IORInfo_ptr info,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        PortableInterceptor::IORInfo_ptr info
++        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+       )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException
+@@ -1697,9 +1676,8 @@
+ 
+     virtual CORBA::Policy_ptr create_policy (
+         CORBA::PolicyType type,
+-        const CORBA::Any & value,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        const CORBA::Any & value
++        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+       )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException,
+@@ -2105,18 +2083,16 @@
+       }
+ 
+     virtual void pre_init (
+-        PortableInterceptor::ORBInitInfo_ptr info,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        PortableInterceptor::ORBInitInfo_ptr info
++        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+       )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException
+       )) = 0;
+ 
+     virtual void post_init (
+-        PortableInterceptor::ORBInitInfo_ptr info,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        PortableInterceptor::ORBInitInfo_ptr info
++        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+       )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException
+@@ -2137,6 +2113,11 @@
+ 
+ #endif /* end #if !defined */
+ 
++ TAO_NAMESPACE_STORAGE_CLASS void register_orb_initializer (
++   ORBInitializer_ptr init,
++   CORBA::Environment & = TAO_default_environment ());
++ ///< Register an ORBInitializer with the global ORBInitializer
++ ///< table.
+ 
+ }
+ TAO_NAMESPACE_CLOSE // module PortableInterceptor
+--- PortableInterceptorC.cpp.old	Mon Oct 23 22:19:37 2000
++++ PortableInterceptorC.cpp	Mon Oct 23 22:20:52 2000
+@@ -25,6 +25,7 @@
+ #include "PortableInterceptorC.i"
+ #endif /* !defined INLINE */
+ 
++#include "tao/CORBA_String.h"
+ 
+ // default constructor
+ PortableInterceptor::Interceptor::Interceptor (void)
diff --git a/TAO/tao/diffs/PortableServerC.cpp.diff b/TAO/tao/diffs/PortableServerC.cpp.diff
new file mode 100644
index 00000000000..e84f8755327
--- /dev/null
+++ b/TAO/tao/diffs/PortableServerC.cpp.diff
@@ -0,0 +1,197 @@
+--- PortableServerC.cpp	Tue Jul 11 01:25:50 2000
++++ PortableServerC.cpp.mod	Tue Jul 11 01:16:29 2000
+@@ -8,6 +8,8 @@
+ //                 http://www.cs.wustl.edu/~schmidt/TAO.html
+ 
+ #include "PortableServerC.h"
++#include "POA.h"
++#include "tao/ORB.h"
+ 
+ #if !defined (__ACE_INLINE__)
+ #include "PortableServerC.i"
+@@ -209,6 +211,9 @@
+ TAO_NAMESPACE_BEGIN (PortableServer)
+ TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ObjectId, &_tc_TAO_tc_PortableServer_ObjectId)
+ TAO_NAMESPACE_END
++
++#if (TAO_HAS_MINIMUM_CORBA == 0)
++
+ // default constructor
+ PortableServer::ForwardRequest::ForwardRequest (void)
+   : CORBA_UserException (::PortableServer::_tc_ForwardRequest)
+@@ -340,6 +340,8 @@
+   return ::PortableServer::_tc_ForwardRequest;
+ }
+ 
++#endif /* TAO_HAS_MINIMUM_CORBA == 0 */
++
+ TAO_NAMESPACE_TYPE (const CORBA::ULong)
+ TAO_NAMESPACE_BEGIN (PortableServer)
+ TAO_NAMESPACE_DEFINE (const CORBA::ULong, THREAD_POLICY_ID, 16U)
+@@ -342,6 +350,9 @@
+ TAO_NAMESPACE_BEGIN (PortableServer)
+ TAO_NAMESPACE_DEFINE (const CORBA::ULong, REQUEST_PROCESSING_POLICY_ID, 22U)
+ TAO_NAMESPACE_END
++
++#if (TAO_HAS_MINIMUM_POA == 0)
++
+ static const CORBA::Long _oc_PortableServer_ThreadPolicyValue[] =
+ {
+   TAO_ENCAP_BYTE_ORDER, // byte order
+@@ -436,6 +447,8 @@
+   return "IDL:PortableServer/ThreadPolicy:1.0";
+ }
+ 
++#endif /* TAO_HAS_MINIMUM_POA == 0 */
++
+ static const CORBA::Long _oc_PortableServer_LifespanPolicyValue[] =
+ {
+   TAO_ENCAP_BYTE_ORDER, // byte order
+@@ -718,6 +731,8 @@
+   return "IDL:PortableServer/IdAssignmentPolicy:1.0";
+ }
+ 
++#if (TAO_HAS_MINIMUM_POA == 0)
++
+ static const CORBA::Long _oc_PortableServer_ImplicitActivationPolicyValue[] =
+ {
+   TAO_ENCAP_BYTE_ORDER, // byte order
+@@ -1001,6 +1016,7 @@
+   return "IDL:PortableServer/RequestProcessingPolicy:1.0";
+ }
+ 
++#endif /* TAO_HAS_MINIMUM_POA == 0 */
+ 
+ // default constructor
+ PortableServer::POAManager::POAManager (void)
+@@ -1048,6 +1064,8 @@
+   return obj;
+ }
+ 
++#if (TAO_HAS_MINIMUM_POA == 0)
++
+ // default constructor
+ PortableServer::POAManager::AdapterInactive::AdapterInactive (void)
+ {
+@@ -1430,6 +1448,7 @@
+   return "IDL:PortableServer/ServantLocator:1.0";
+ }
+ 
++#endif /* TAO_HAS_MINIMUM_POA == 0 */
+ 
+ // default constructor
+ PortableServer::POA::POA (void)
+@@ -1681,6 +1700,8 @@
+     this->index = _tao_index;
+ }
+ 
++#if (TAO_HAS_MINIMUM_POA == 0)
++
+ // default constructor
+ PortableServer::POA::NoServant::NoServant (void)
+ {
+@@ -1746,6 +1767,8 @@
+   return retval;
+ }
+ 
++#endif /* TAO_HAS_MINIMUM_POA == 0 */
++
+ // default constructor
+ PortableServer::POA::ObjectAlreadyActive::ObjectAlreadyActive (void)
+ {
+@@ -2302,6 +2325,30 @@
+   return "IDL:PortableServer/Current:1.0";
+ }
+ 
++char *
++PortableServer::ObjectId_to_string (const PortableServer::ObjectId &id)
++{
++  return TAO_POA::ObjectId_to_string (id);
++}
++
++CORBA::WChar *
++PortableServer::ObjectId_to_wstring (const PortableServer::ObjectId &id)
++{
++  return TAO_POA::ObjectId_to_wstring (id);
++}
++
++PortableServer::ObjectId *
++PortableServer::string_to_ObjectId (const char *id)
++{
++  return TAO_POA::string_to_ObjectId (id);
++}
++
++PortableServer::ObjectId *
++PortableServer::wstring_to_ObjectId (const CORBA::WChar *id)
++{
++  return TAO_POA::wstring_to_ObjectId (id);
++}
++
+ void operator<<= (
+     CORBA::Any &_tao_any,
+     const PortableServer::ObjectId &_tao_elem
+@@ -2391,6 +2438,8 @@
+   return 0;
+ }
+ 
++#if (TAO_HAS_MINIMUM_CORBA == 0)
++
+ void operator<<= (CORBA::Any &_tao_any, const PortableServer::ForwardRequest &_tao_elem) // copying
+ {
+   TAO_OutputCDR stream;
+@@ -2479,6 +2528,10 @@
+   return 0;
+ }
+ 
++#endif /* TAO_HAS_MINIMUM_CORBA == 0 */
++
++#if (TAO_HAS_MINIMUM_POA == 0)
++
+ void operator<<= (CORBA::Any &_tao_any, PortableServer::ThreadPolicyValue _tao_elem)
+ {
+   TAO_OutputCDR stream;
+@@ -2524,6 +2577,8 @@
+   #  pragma instantiate TAO_Object_Manager<PortableServer::ThreadPolicy,PortableServer::ThreadPolicy_var>
+ #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+ 
++#endif /* TAO_HAS_MINIMUM_POA == 0 */
++
+ void operator<<= (CORBA::Any &_tao_any, PortableServer::LifespanPolicyValue _tao_elem)
+ {
+   TAO_OutputCDR stream;
+@@ -2659,6 +2714,8 @@
+   #  pragma instantiate TAO_Object_Manager<PortableServer::IdAssignmentPolicy,PortableServer::IdAssignmentPolicy_var>
+ #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+ 
++#if (TAO_HAS_MINIMUM_POA == 0)
++
+ void operator<<= (CORBA::Any &_tao_any, PortableServer::ImplicitActivationPolicyValue _tao_elem)
+ {
+   TAO_OutputCDR stream;
+@@ -2794,6 +2851,8 @@
+   #  pragma instantiate TAO_Object_Manager<PortableServer::RequestProcessingPolicy,PortableServer::RequestProcessingPolicy_var>
+ #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+ 
++#endif /* TAO_HAS_MINIMUM_POA == 0 */
++
+ #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+     defined (ACE_HAS_GNU_REPO)
+     template class TAO_Object_Manager<PortableServer::POAManager,PortableServer::POAManager_var>;
+@@ -2801,6 +2860,8 @@
+   #  pragma instantiate TAO_Object_Manager<PortableServer::POAManager,PortableServer::POAManager_var>
+ #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+ 
++#if (TAO_HAS_MINIMUM_POA == 0)
++
+ #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+     defined (ACE_HAS_GNU_REPO)
+     template class TAO_Object_Manager<PortableServer::AdapterActivator,PortableServer::AdapterActivator_var>;
+@@ -2829,6 +2890,8 @@
+   #  pragma instantiate TAO_Object_Manager<PortableServer::ServantLocator,PortableServer::ServantLocator_var>
+ #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+ 
++#endif /* TAO_HAS_MINIMUM_POA == 0 */
++
+ #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+     defined (ACE_HAS_GNU_REPO)
+     template class TAO_Object_Manager<PortableServer::POA,PortableServer::POA_var>;
diff --git a/TAO/tao/diffs/PortableServerC.h.diff b/TAO/tao/diffs/PortableServerC.h.diff
new file mode 100644
index 00000000000..c30ae80a66e
--- /dev/null
+++ b/TAO/tao/diffs/PortableServerC.h.diff
@@ -0,0 +1,435 @@
+--- PortableServerC.h	Fri Jul 14 06:41:41 2000
++++ PortableServerC.h.mod	Fri Jul 14 06:39:07 2000
+@@ -1,4 +1,4 @@
+-/* -*- C++ -*- $Id$ */
++/* -*- C++ -*- $Id$ */
+ 
+ // ******  Code generated by the The ACE ORB (TAO) IDL Compiler *******
+ // TAO and the TAO IDL Compiler have been developed by the Center for
+@@ -11,7 +11,7 @@
+ #define _TAO_IDL_PORTABLESERVERC_H_
+ 
+ #include "ace/pre.h"
+-#include "tao/corba.h"
++#include "tao/corbafwd.h"
+ 
+ #if defined (ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION)
+ #include "ace/streams.h"
+@@ -21,7 +21,10 @@
+ # pragma once
+ #endif /* ACE_LACKS_PRAGMA_ONCE */
+ 
+-#include "tao/corbafwd.h"
++#include "tao/CurrentC.h"
++#include "tao/PolicyC.h"
++#include "tao/Typecode.h"
++#include "tao/Any.h"
+ 
+ #if defined (TAO_EXPORT_MACRO)
+ #undef TAO_EXPORT_MACRO
+@@ -42,8 +45,22 @@
+ #pragma warning(disable:4250)
+ #endif /* _MSC_VER */
+ 
++class TAO_ServantBase;
++class TAO_ServantBase_var;
++class TAO_RefCountServantBase;
++class TAO_Local_ServantBase;
++class TAO_DynamicImplementation;
++
+ TAO_NAMESPACE  PortableServer
+ {
++  typedef TAO_ServantBase ServantBase;
++  typedef TAO_ServantBase_var ServantBase_var;
++  typedef TAO_RefCountServantBase RefCountServantBase;
++  typedef ServantBase *Servant;
++
++  typedef TAO_Local_ServantBase LocalServantBase;
++  typedef TAO_DynamicImplementation DynamicImplementation;
++
+   class POA;
+   
+ #if !defined (_PORTABLESERVER_POA___PTR_CH_)
+@@ -297,13 +314,13 @@
+ #endif /* ! __GNUC__ || g++ >= 2.8 */
+ 
+ 
+-#if (TAO_NO_COPY_OCTET_SEQUENCES == 1)
++#if defined(TAO_NO_COPY_OCTET_SEQUENCES)
+     ObjectId (
+         CORBA::ULong length,
+         const ACE_Message_Block* mb
+       )
+       : TAO_Unbounded_Sequence<CORBA::Octet> (length, mb) {}
+-#endif /* TAO_NO_COPY_OCTET_SEQUENCE == 1 */
++#endif /* TAO_NO_COPY_OCTET_SEQUENCE */
+ 
+   };
+   
+@@ -380,6 +397,8 @@
+   TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ObjectId;
+ 
+ 
++#if (TAO_HAS_MINIMUM_CORBA == 0)
++
+ #if !defined (_PORTABLESERVER_FORWARDREQUEST_CH_)
+ #define _PORTABLESERVER_FORWARDREQUEST_CH_
+ 
+@@ -421,6 +440,8 @@
+ 
+   #endif /* end #if !defined */
+ 
++#endif /* TAO_HAS_MINIMUM_CORBA == 0 */
++
+   TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong THREAD_POLICY_ID;
+ 
+   TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong LIFESPAN_POLICY_ID;
+@@ -441,6 +462,9 @@
+       ORB_CTRL_MODEL,
+       SINGLE_THREAD_MODEL
+   };
++
++#if (TAO_HAS_MINIMUM_POA == 0)
++
+   typedef ThreadPolicyValue &ThreadPolicyValue_out;
+   TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ThreadPolicyValue;
+ 
+@@ -564,6 +588,8 @@
+ 
+ #endif /* end #if !defined */
+ 
++#endif /* TAO_HAS_MINIMUM_POA == 0 */
++
+   enum LifespanPolicyValue
+   {
+       TRANSIENT,
+@@ -957,6 +983,9 @@
+       IMPLICIT_ACTIVATION,
+       NO_IMPLICIT_ACTIVATION,
+   };
++
++#if (TAO_HAS_MINIMUM_POA == 0)
++
+   typedef ImplicitActivationPolicyValue &ImplicitActivationPolicyValue_out;
+   TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ImplicitActivationPolicyValue;
+ 
+@@ -1080,11 +1109,16 @@
+ 
+ #endif /* end #if !defined */
+ 
++#endif /* TAO_HAS_MINIMUM_POA == 0 */
++
+   enum ServantRetentionPolicyValue
+   {
+         RETAIN,
+         NON_RETAIN    
+   };
++
++#if (TAO_HAS_MINIMUM_POA == 0)
++
+   typedef ServantRetentionPolicyValue &ServantRetentionPolicyValue_out;
+   TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ServantRetentionPolicyValue;
+ 
+@@ -1209,6 +1243,8 @@
+ 
+ #endif /* end #if !defined */
+ 
++#endif /* TAO_HAS_MINIMUM_POA == 0 */
++
+   enum RequestProcessingPolicyValue
+   {
+       USE_ACTIVE_OBJECT_MAP_ONLY,
+@@ -1216,6 +1252,9 @@
+       USE_DEFAULT_SERVANT,
+       USE_SERVANT_MANAGER
+   };
++
++#if (TAO_HAS_MINIMUM_POA == 0)
++
+   typedef RequestProcessingPolicyValue &RequestProcessingPolicyValue_out;
+   TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_RequestProcessingPolicyValue;
+ 
+@@ -1339,6 +1378,7 @@
+ 
+ #endif /* end #if !defined */
+ 
++#endif /* TAO_HAS_MINIMUM_POA == 0 */
+ 
+ #if !defined (_PORTABLESERVER_POAMANAGER___PTR_CH_)
+ #define _PORTABLESERVER_POAMANAGER___PTR_CH_
+@@ -1489,6 +1529,8 @@
+         PortableServer::POAManager::AdapterInactive
+       )) = 0;
+ 
++#if (TAO_HAS_MINIMUM_POA == 0)
++
+     virtual void hold_requests (
+         CORBA::Boolean wait_for_completion,
+         CORBA::Environment &ACE_TRY_ENV = 
+@@ -1520,6 +1562,8 @@
+         PortableServer::POAManager::AdapterInactive
+       )) = 0;
+ 
++#endif /* TAO_HAS_MINIMUM_POA == 0 */
++
+     virtual PortableServer::POAManager::State get_state (
+                 CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+@@ -1544,6 +1588,8 @@
+ #endif /* end #if !defined */
+ 
+ 
++#if (TAO_HAS_MINIMUM_POA == 0)
++
+ #if !defined (_PORTABLESERVER_ADAPTERACTIVATOR___PTR_CH_)
+ #define _PORTABLESERVER_ADAPTERACTIVATOR___PTR_CH_
+ 
+@@ -1876,23 +1922,27 @@
+ 
+     virtual PortableServer::Servant incarnate (
+         const PortableServer::ObjectId & oid,
+-        PortableServer::POA_ptr adapter,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        PortableServer::POA_ptr adapter
++        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+       )
++#if (TAO_HAS_MINIMUM_CORBA == 0)
+       ACE_THROW_SPEC ((
+         CORBA::SystemException,
+         PortableServer::ForwardRequest
+       )) = 0;
++#else
++      ACE_THROW_SPEC ((
++        CORBA::SystemException
++      )) = 0;
++#endif /* TAO_HAS_MINIMUM_CORBA == 0 */
+ 
+     virtual void etherealize (
+         const PortableServer::ObjectId & oid,
+         PortableServer::POA_ptr adapter,
+         PortableServer::Servant serv,
+         CORBA::Boolean cleanup_in_progress,
+-        CORBA::Boolean remaining_activations,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        CORBA::Boolean remaining_activations
++        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+       )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException
+@@ -1988,6 +2038,9 @@
+ class TAO_Export ServantLocator: public virtual ServantManager
+   {
+   public:
++
++    typedef void *Cookie;
++
+   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+     typedef ServantLocator_ptr _ptr_type;
+     typedef ServantLocator_var _var_type;
+@@ -2014,23 +2067,27 @@
+         const PortableServer::ObjectId & oid,
+         PortableServer::POA_ptr adapter,
+         const char * operation,
+-        PortableServer::ServantLocator::Cookie & the_cookie,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        PortableServer::ServantLocator::Cookie & the_cookie
++        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+       )
++#if (TAO_HAS_MINIMUM_CORBA == 0)
+       ACE_THROW_SPEC ((
+         CORBA::SystemException,
+         PortableServer::ForwardRequest
+       )) = 0;
++#else
++      ACE_THROW_SPEC ((
++        CORBA::SystemException
++      )) = 0;
++#endif /* TAO_HAS_MINIMUM_CORBA == 0 */
+ 
+     virtual void postinvoke (
+         const PortableServer::ObjectId & oid,
+         PortableServer::POA_ptr adapter,
+         const char * operation,
+         PortableServer::ServantLocator::Cookie the_cookie,
+-        PortableServer::Servant the_servant,
+-        CORBA::Environment &ACE_TRY_ENV = 
+-          TAO_default_environment ()
++        PortableServer::Servant the_servant
++        TAO_ENV_ARG_DECL_WITH_DEFAULTS
+       )
+       ACE_THROW_SPEC ((
+         CORBA::SystemException
+@@ -2052,6 +2109,8 @@
+ #endif /* end #if !defined */
+ 
+ 
++#endif /* TAO_HAS_MINIMUM_POA == 0 */
++
+ #if !defined (_PORTABLESERVER_POA___PTR_CH_)
+ #define _PORTABLESERVER_POA___PTR_CH_
+ 
+@@ -2258,6 +2317,8 @@
+ #endif /* end #if !defined */
+ 
+ 
++#if (TAO_HAS_MINIMUM_POA == 0)
++
+ #if !defined (_PORTABLESERVER_POA_NOSERVANT_CH_)
+ #define _PORTABLESERVER_POA_NOSERVANT_CH_
+ 
+@@ -2292,6 +2353,7 @@
+ 
+ #endif /* end #if !defined */
+ 
++#endif /* TAO_HAS_MINIMUM_POA == 0 */
+ 
+ #if !defined (_PORTABLESERVER_POA_OBJECTALREADYACTIVE_CH_)
+ #define _PORTABLESERVER_POA_OBJECTALREADYACTIVE_CH_
+@@ -2536,6 +2598,8 @@
+         CORBA::SystemException
+       )) = 0;
+ 
++#if (TAO_HAS_MINIMUM_POA == 0)
++
+     virtual PortableServer::ThreadPolicy_ptr create_thread_policy (
+         PortableServer::ThreadPolicyValue value,
+         CORBA::Environment &ACE_TRY_ENV = 
+@@ -2545,6 +2609,8 @@
+         CORBA::SystemException
+       )) = 0;
+ 
++#endif /* TAO_HAS_MINIMUM_POA == 0 */
++
+     virtual PortableServer::LifespanPolicy_ptr create_lifespan_policy (
+         PortableServer::LifespanPolicyValue value,
+         CORBA::Environment &ACE_TRY_ENV = 
+@@ -2572,6 +2638,8 @@
+         CORBA::SystemException
+       )) = 0;
+ 
++#if (TAO_HAS_MINIMUM_POA == 0)
++
+     virtual PortableServer::ImplicitActivationPolicy_ptr create_implicit_activation_policy (
+         PortableServer::ImplicitActivationPolicyValue value,
+         CORBA::Environment &ACE_TRY_ENV = 
+@@ -2599,6 +2667,8 @@
+         CORBA::SystemException
+       )) = 0;
+ 
++#endif /* TAO_HAS_MINIMUM_POA == 0 */
++
+     virtual char * the_name (
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+@@ -2631,6 +2701,8 @@
+         CORBA::SystemException
+       )) = 0;
+ 
++#if (TAO_HAS_MINIMUM_POA == 0)
++
+     virtual PortableServer::AdapterActivator_ptr the_activator (
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+@@ -2687,6 +2759,8 @@
+         PortableServer::POA::WrongPolicy
+       )) = 0;
+ 
++#endif /* TAO_HAS_MINIMUM_POA == 0 */
++
+     virtual PortableServer::ObjectId * activate_object (
+         PortableServer::Servant p_servant,
+         CORBA::Environment &ACE_TRY_ENV = 
+@@ -2989,6 +3063,10 @@
+ 
+ #endif /* end #if !defined */
+ 
++  TAO_NAMESPACE_STORAGE_CLASS char *ObjectId_to_string (const PortableServer::ObjectId &id);
++  TAO_NAMESPACE_STORAGE_CLASS CORBA::WChar *ObjectId_to_wstring (const PortableServer::ObjectId &id);
++  TAO_NAMESPACE_STORAGE_CLASS PortableServer::ObjectId *string_to_ObjectId (const char *id);
++  TAO_NAMESPACE_STORAGE_CLASS PortableServer::ObjectId *wstring_to_ObjectId (const CORBA::WChar *id);
+ 
+ }
+ TAO_NAMESPACE_CLOSE // module PortableServer
+@@ -2997,18 +3075,32 @@
+ TAO_Export void operator<<= (CORBA::Any &, PortableServer::ObjectId*); // noncopying version
+ TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::ObjectId *&); // deprecated
+ TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::ObjectId *&);
++
++#if (TAO_HAS_MINIMUM_CORBA == 0)
++
+ TAO_Export void operator<<= (CORBA::Any &, const PortableServer::ForwardRequest &); // copying version
+ TAO_Export void operator<<= (CORBA::Any &, PortableServer::ForwardRequest*); // noncopying version
+ TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::ForwardRequest *&); // deprecated
+ TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const PortableServer::ForwardRequest *&);
++
++#endif /* TAO_HAS_MINIMUM_CORBA == 0 */
++
++#if (TAO_HAS_MINIMUM_POA == 0)
++
+ TAO_Export void operator<<= (CORBA::Any &, PortableServer::ThreadPolicyValue);
+ TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::ThreadPolicyValue &);
++
++#endif /* TAO_HAS_MINIMUM_POA == 0 */
++
+ TAO_Export void operator<<= (CORBA::Any &, PortableServer::LifespanPolicyValue);
+ TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::LifespanPolicyValue &);
+ TAO_Export void operator<<= (CORBA::Any &, PortableServer::IdUniquenessPolicyValue);
+ TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::IdUniquenessPolicyValue &);
+ TAO_Export void operator<<= (CORBA::Any &, PortableServer::IdAssignmentPolicyValue);
+ TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::IdAssignmentPolicyValue &);
++
++#if (TAO_HAS_MINIMUM_POA == 0)
++
+ TAO_Export void operator<<= (CORBA::Any &, PortableServer::ImplicitActivationPolicyValue);
+ TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::ImplicitActivationPolicyValue &);
+ TAO_Export void operator<<= (CORBA::Any &, PortableServer::ServantRetentionPolicyValue);
+@@ -3016,6 +3108,8 @@
+ TAO_Export void operator<<= (CORBA::Any &, PortableServer::RequestProcessingPolicyValue);
+ TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::RequestProcessingPolicyValue &);
+ 
++#endif /* TAO_HAS_MINIMUM_POA == 0 */
++
+ #ifndef __ACE_INLINE__
+ 
+ 
+@@ -3033,23 +3127,37 @@
+ 
+ #endif /* _TAO_CDR_OP_PortableServer_ObjectId_H_ */
+ 
++#if (TAO_HAS_MINIMUM_CORBA == 0)
++
+ TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ForwardRequest &);
+ TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ForwardRequest &);
+ 
++#endif /* TAO_HAS_MINIMUM_CORBA == 0 */
++
++#if (TAO_HAS_MINIMUM_POA == 0)
++
+ TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ThreadPolicyValue &); // 
+ TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ThreadPolicyValue &);
++
++#endif /* TAO_HAS_MINIMUM_POA == 0 */
++
+ TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::LifespanPolicyValue &); // 
+ TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::LifespanPolicyValue &);
+ TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::IdUniquenessPolicyValue &); // 
+ TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::IdUniquenessPolicyValue &);
+ TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::IdAssignmentPolicyValue &); // 
+ TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::IdAssignmentPolicyValue &);
++
++#if (TAO_HAS_MINIMUM_POA == 0)
++
+ TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ImplicitActivationPolicyValue &); // 
+ TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ImplicitActivationPolicyValue &);
+ TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ServantRetentionPolicyValue &); // 
+ TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ServantRetentionPolicyValue &);
+ TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::RequestProcessingPolicyValue &); // 
+ TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::RequestProcessingPolicyValue &);
++
++#endif /* TAO_HAS_MINIMUM_POA == 0 */
+ 
+ #endif /* __ACE_INLINE__ */
+ 
diff --git a/TAO/tao/diffs/RTPortableServerC.cpp.diff b/TAO/tao/diffs/RTPortableServerC.cpp.diff
new file mode 100644
index 00000000000..4d78209a4a8
--- /dev/null
+++ b/TAO/tao/diffs/RTPortableServerC.cpp.diff
@@ -0,0 +1,16 @@
+--- RTPortableServerC.cpp	Fri Sep 29 01:51:22 2000
++++ ..\RTPortableServerC.cpp	Fri Sep 29 02:04:44 2000
+@@ -21,6 +21,8 @@
+ 
+ #include "RTPortableServerC.h"
+ 
++#if (TAO_HAS_RT_CORBA == 1)
++
+ #if !defined (__ACE_INLINE__)
+ #include "RTPortableServerC.i"
+ #endif /* !defined INLINE */
+@@ -112,3 +114,4 @@
+   #  pragma instantiate TAO_Object_Manager<RTPortableServer::POA,RTPortableServer::POA_var>
+ #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+ 
++#endif /* TAO_HAS_RT_CORBA == 1 */
diff --git a/TAO/tao/diffs/RTPortableServerC.h.diff b/TAO/tao/diffs/RTPortableServerC.h.diff
new file mode 100644
index 00000000000..648465dd84b
--- /dev/null
+++ b/TAO/tao/diffs/RTPortableServerC.h.diff
@@ -0,0 +1,39 @@
+--- RTPortableServerC.h	Fri Sep 29 01:51:22 2000
++++ ..\RTPortableServerC.h	Fri Sep 29 02:04:44 2000
+@@ -23,14 +23,15 @@
+ #define _TAO_IDL_RTPORTABLESERVERC_H_
+ 
+ #include "ace/pre.h"
+-#include "tao/corba.h"
++#include "PortableServerC.h"
++
++#if (TAO_HAS_RT_CORBA == 1)
+ 
+ #if !defined (ACE_LACKS_PRAGMA_ONCE)
+ # pragma once
+ #endif /* ACE_LACKS_PRAGMA_ONCE */
+ 
+-#include "PortableServerC.h"
+-#include "RTCORBAC.h"
++#include "tao/RTCORBAC.h"
+ 
+ #if defined (TAO_EXPORT_MACRO)
+ #undef TAO_EXPORT_MACRO
+@@ -125,7 +126,7 @@
+ #if !defined (_RTPORTABLESERVER_POA_CH_)
+ #define _RTPORTABLESERVER_POA_CH_
+ 
+-class TAO_PortableServer_Export POA: public virtual PortableServer::POA
++class TAO_PortableServer_Export POA: public PortableServer::POA
+   {
+   public:
+   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+@@ -232,6 +233,8 @@
+ #if defined(_MSC_VER) && (_MSC_VER >= 1200)
+ #pragma warning(pop)
+ #endif /* _MSC_VER */
++
++#endif /* TAO_HAS_RT_CORBA */
+ 
+ #include "ace/post.h"
+ #endif /* ifndef */
diff --git a/TAO/tao/diffs/StringSeq.diff b/TAO/tao/diffs/StringSeq.diff
new file mode 100644
index 00000000000..97701853ad8
--- /dev/null
+++ b/TAO/tao/diffs/StringSeq.diff
@@ -0,0 +1,1258 @@
+--- StringSeqC.h.old	Sun Oct 22 22:31:13 2000
++++ StringSeqC.h	Sun Oct 22 22:31:52 2000
+@@ -23,13 +23,14 @@
+ #define _TAO_IDL_STRINGSEQC_H_
+ 
+ #include "ace/pre.h"
+-#include "tao/corba.h"
++
++#include "tao/corbafwd.h"
+ 
+ #if !defined (ACE_LACKS_PRAGMA_ONCE)
+ # pragma once
+ #endif /* ACE_LACKS_PRAGMA_ONCE */
+ 
+-#include "tao/corbafwd.h"
++#include "tao/Sequence.h"
+ 
+ #if defined (TAO_EXPORT_MACRO)
+ #undef TAO_EXPORT_MACRO
+@@ -54,14 +55,14 @@
+ #if !defined (_STRINGSEQ_CH_)
+ #define _STRINGSEQ_CH_
+ 
+-class StringSeq;
+-class StringSeq_var;
++class CORBA_StringSeq;
++class CORBA_StringSeq_var;
+ 
+ // *************************************************************
+-// StringSeq
++// CORBA_StringSeq
+ // *************************************************************
+ 
+-class TAO_Export StringSeq : public 
++class TAO_Export CORBA_StringSeq : public 
+ #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+   TAO_Unbounded_String_Sequence
+ #else /* TAO_USE_SEQUENCE_TEMPLATES */
+@@ -69,20 +70,20 @@
+ #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ {
+ public:
+-  StringSeq (void); // default ctor
+-  StringSeq (CORBA::ULong max); // uses max size
+-  StringSeq (
++  CORBA_StringSeq (void); // default ctor
++  CORBA_StringSeq (CORBA::ULong max); // uses max size
++  CORBA_StringSeq (
+     CORBA::ULong max, 
+     CORBA::ULong length, 
+     char * *buffer, 
+     CORBA::Boolean release = 0
+   );
+-  StringSeq (const StringSeq &); // copy ctor
+-  ~StringSeq (void);
++  CORBA_StringSeq (const CORBA_StringSeq &); // copy ctor
++  ~CORBA_StringSeq (void);
+   static void _tao_any_destructor (void*);
+ 
+ #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+-  typedef StringSeq_var _var_type;
++  typedef CORBA_StringSeq_var _var_type;
+ #endif /* ! __GNUC__ || g++ >= 2.8 */
+ 
+ };
+@@ -94,38 +95,38 @@
+ #define _STRINGSEQ___VAR_CH_
+ 
+ // *************************************************************
+-// class StringSeq_var
++// class CORBA_StringSeq_var
+ // *************************************************************
+ 
+-class TAO_Export StringSeq_var
++class TAO_Export CORBA_StringSeq_var
+ {
+ public:
+-  StringSeq_var (void); // default constructor
+-  StringSeq_var (StringSeq *);
+-  StringSeq_var (const StringSeq_var &); // copy constructor
+-  ~StringSeq_var (void); // destructor
++  CORBA_StringSeq_var (void); // default constructor
++  CORBA_StringSeq_var (CORBA_StringSeq *);
++  CORBA_StringSeq_var (const CORBA_StringSeq_var &); // copy constructor
++  ~CORBA_StringSeq_var (void); // destructor
+   
+-  StringSeq_var &operator= (StringSeq *);
+-  StringSeq_var &operator= (const StringSeq_var &);
+-  StringSeq *operator-> (void);
+-  const StringSeq *operator-> (void) const;
++  CORBA_StringSeq_var &operator= (CORBA_StringSeq *);
++  CORBA_StringSeq_var &operator= (const CORBA_StringSeq_var &);
++  CORBA_StringSeq *operator-> (void);
++  const CORBA_StringSeq *operator-> (void) const;
+   
+-  operator const StringSeq &() const;
+-  operator StringSeq &();
+-  operator StringSeq &() const;
+-  operator StringSeq *&(); // variable-size base types only
++  operator const CORBA_StringSeq &() const;
++  operator CORBA_StringSeq &();
++  operator CORBA_StringSeq &() const;
++  operator CORBA_StringSeq *&(); // variable-size base types only
+   
+   TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
+   
+   // in, inout, out, _retn 
+-  const StringSeq &in (void) const;
+-  StringSeq &inout (void);
+-  StringSeq *&out (void);
+-  StringSeq *_retn (void);
+-  StringSeq *ptr (void) const;
++  const CORBA_StringSeq &in (void) const;
++  CORBA_StringSeq &inout (void);
++  CORBA_StringSeq *&out (void);
++  CORBA_StringSeq *_retn (void);
++  CORBA_StringSeq *ptr (void) const;
+ 
+ private:
+-  StringSeq *ptr_;
++  CORBA_StringSeq *ptr_;
+ };
+ 
+ 
+@@ -135,42 +136,42 @@
+ #if !defined (_STRINGSEQ___OUT_CH_)
+ #define _STRINGSEQ___OUT_CH_
+ 
+-class TAO_Export StringSeq_out
++class TAO_Export CORBA_StringSeq_out
+ {
+ public:
+-  StringSeq_out (StringSeq *&);
+-  StringSeq_out (StringSeq_var &);
+-  StringSeq_out (const StringSeq_out &);
+-  StringSeq_out &operator= (const StringSeq_out &);
+-  StringSeq_out &operator= (StringSeq *);
+-  operator StringSeq *&();
+-  StringSeq *&ptr (void);
+-  StringSeq *operator-> (void);
++  CORBA_StringSeq_out (CORBA_StringSeq *&);
++  CORBA_StringSeq_out (CORBA_StringSeq_var &);
++  CORBA_StringSeq_out (const CORBA_StringSeq_out &);
++  CORBA_StringSeq_out &operator= (const CORBA_StringSeq_out &);
++  CORBA_StringSeq_out &operator= (CORBA_StringSeq *);
++  operator CORBA_StringSeq *&();
++  CORBA_StringSeq *&ptr (void);
++  CORBA_StringSeq *operator-> (void);
+   TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
+   
+ private:
+-  StringSeq *&ptr_;
++  CORBA_StringSeq *&ptr_;
+   // assignment from T_var not allowed
+-  void operator= (const StringSeq_var &);
++  void operator= (const CORBA_StringSeq_var &);
+ };
+ 
+ 
+ #endif /* end #if !defined */
+ 
+-extern TAO_Export CORBA::TypeCode_ptr  _tc_StringSeq;
++extern TAO_Export CORBA::TypeCode_ptr  _tc_CORBA_StringSeq;
+ 
+ 
+ #if !defined (_WSTRINGSEQ_CH_)
+ #define _WSTRINGSEQ_CH_
+ 
+-class WStringSeq;
+-class WStringSeq_var;
++class CORBA_WStringSeq;
++class CORBA_WStringSeq_var;
+ 
+ // *************************************************************
+-// WStringSeq
++// CORBA_WStringSeq
+ // *************************************************************
+ 
+-class TAO_Export WStringSeq : public 
++class TAO_Export CORBA_WStringSeq : public 
+ #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+   TAO_Unbounded_WString_Sequence
+ #else /* TAO_USE_SEQUENCE_TEMPLATES */
+@@ -178,20 +179,20 @@
+ #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ {
+ public:
+-  WStringSeq (void); // default ctor
+-  WStringSeq (CORBA::ULong max); // uses max size
+-  WStringSeq (
++  CORBA_WStringSeq (void); // default ctor
++  CORBA_WStringSeq (CORBA::ULong max); // uses max size
++  CORBA_WStringSeq (
+     CORBA::ULong max, 
+     CORBA::ULong length, 
+     CORBA::WChar * *buffer, 
+     CORBA::Boolean release = 0
+   );
+-  WStringSeq (const WStringSeq &); // copy ctor
+-  ~WStringSeq (void);
++  CORBA_WStringSeq (const CORBA_WStringSeq &); // copy ctor
++  ~CORBA_WStringSeq (void);
+   static void _tao_any_destructor (void*);
+ 
+ #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+-  typedef WStringSeq_var _var_type;
++  typedef CORBA_WStringSeq_var _var_type;
+ #endif /* ! __GNUC__ || g++ >= 2.8 */
+ 
+ };
+@@ -203,38 +204,38 @@
+ #define _WSTRINGSEQ___VAR_CH_
+ 
+ // *************************************************************
+-// class WStringSeq_var
++// class CORBA_WStringSeq_var
+ // *************************************************************
+ 
+-class TAO_Export WStringSeq_var
++class TAO_Export CORBA_WStringSeq_var
+ {
+ public:
+-  WStringSeq_var (void); // default constructor
+-  WStringSeq_var (WStringSeq *);
+-  WStringSeq_var (const WStringSeq_var &); // copy constructor
+-  ~WStringSeq_var (void); // destructor
++  CORBA_WStringSeq_var (void); // default constructor
++  CORBA_WStringSeq_var (CORBA_WStringSeq *);
++  CORBA_WStringSeq_var (const CORBA_WStringSeq_var &); // copy constructor
++  ~CORBA_WStringSeq_var (void); // destructor
+   
+-  WStringSeq_var &operator= (WStringSeq *);
+-  WStringSeq_var &operator= (const WStringSeq_var &);
+-  WStringSeq *operator-> (void);
+-  const WStringSeq *operator-> (void) const;
++  CORBA_WStringSeq_var &operator= (CORBA_WStringSeq *);
++  CORBA_WStringSeq_var &operator= (const CORBA_WStringSeq_var &);
++  CORBA_WStringSeq *operator-> (void);
++  const CORBA_WStringSeq *operator-> (void) const;
+   
+-  operator const WStringSeq &() const;
+-  operator WStringSeq &();
+-  operator WStringSeq &() const;
+-  operator WStringSeq *&(); // variable-size base types only
++  operator const CORBA_WStringSeq &() const;
++  operator CORBA_WStringSeq &();
++  operator CORBA_WStringSeq &() const;
++  operator CORBA_WStringSeq *&(); // variable-size base types only
+   
+   TAO_SeqElem_WString_Manager operator[] (CORBA::ULong index);
+   
+   // in, inout, out, _retn 
+-  const WStringSeq &in (void) const;
+-  WStringSeq &inout (void);
+-  WStringSeq *&out (void);
+-  WStringSeq *_retn (void);
+-  WStringSeq *ptr (void) const;
++  const CORBA_WStringSeq &in (void) const;
++  CORBA_WStringSeq &inout (void);
++  CORBA_WStringSeq *&out (void);
++  CORBA_WStringSeq *_retn (void);
++  CORBA_WStringSeq *ptr (void) const;
+ 
+ private:
+-  WStringSeq *ptr_;
++  CORBA_WStringSeq *ptr_;
+ };
+ 
+ 
+@@ -244,70 +245,70 @@
+ #if !defined (_WSTRINGSEQ___OUT_CH_)
+ #define _WSTRINGSEQ___OUT_CH_
+ 
+-class TAO_Export WStringSeq_out
++class TAO_Export CORBA_WStringSeq_out
+ {
+ public:
+-  WStringSeq_out (WStringSeq *&);
+-  WStringSeq_out (WStringSeq_var &);
+-  WStringSeq_out (const WStringSeq_out &);
+-  WStringSeq_out &operator= (const WStringSeq_out &);
+-  WStringSeq_out &operator= (WStringSeq *);
+-  operator WStringSeq *&();
+-  WStringSeq *&ptr (void);
+-  WStringSeq *operator-> (void);
++  CORBA_WStringSeq_out (CORBA_WStringSeq *&);
++  CORBA_WStringSeq_out (CORBA_WStringSeq_var &);
++  CORBA_WStringSeq_out (const CORBA_WStringSeq_out &);
++  CORBA_WStringSeq_out &operator= (const CORBA_WStringSeq_out &);
++  CORBA_WStringSeq_out &operator= (CORBA_WStringSeq *);
++  operator CORBA_WStringSeq *&();
++  CORBA_WStringSeq *&ptr (void);
++  CORBA_WStringSeq *operator-> (void);
+   TAO_SeqElem_WString_Manager operator[] (CORBA::ULong index);
+   
+ private:
+-  WStringSeq *&ptr_;
++  CORBA_WStringSeq *&ptr_;
+   // assignment from T_var not allowed
+-  void operator= (const WStringSeq_var &);
++  void operator= (const CORBA_WStringSeq_var &);
+ };
+ 
+ 
+ #endif /* end #if !defined */
+ 
+-extern TAO_Export CORBA::TypeCode_ptr  _tc_WStringSeq;
++extern TAO_Export CORBA::TypeCode_ptr  _tc_CORBA_WStringSeq;
+ 
+-TAO_Export void operator<<= (CORBA::Any &, const StringSeq &); // copying version
+-TAO_Export void operator<<= (CORBA::Any &, StringSeq*); // noncopying version
+-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, StringSeq *&); // deprecated
+-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const StringSeq *&);
+-TAO_Export void operator<<= (CORBA::Any &, const WStringSeq &); // copying version
+-TAO_Export void operator<<= (CORBA::Any &, WStringSeq*); // noncopying version
+-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, WStringSeq *&); // deprecated
+-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const WStringSeq *&);
++TAO_Export void operator<<= (CORBA::Any &, const CORBA_StringSeq &); // copying version
++TAO_Export void operator<<= (CORBA::Any &, CORBA_StringSeq*); // noncopying version
++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_StringSeq *&); // deprecated
++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA_StringSeq *&);
++TAO_Export void operator<<= (CORBA::Any &, const CORBA_WStringSeq &); // copying version
++TAO_Export void operator<<= (CORBA::Any &, CORBA_WStringSeq*); // noncopying version
++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_WStringSeq *&); // deprecated
++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA_WStringSeq *&);
+ 
+ #ifndef __ACE_INLINE__
+ 
+ 
+-#if !defined _TAO_CDR_OP_StringSeq_H_
+-#define _TAO_CDR_OP_StringSeq_H_
++#if !defined _TAO_CDR_OP_CORBA_StringSeq_H_
++#define _TAO_CDR_OP_CORBA_StringSeq_H_
+ 
+ TAO_Export CORBA::Boolean operator<< (
+     TAO_OutputCDR &,
+-    const StringSeq &
++    const CORBA_StringSeq &
+   );
+ TAO_Export CORBA::Boolean operator>> (
+     TAO_InputCDR &,
+-    StringSeq &
++    CORBA_StringSeq &
+   );
+ 
+-#endif /* _TAO_CDR_OP_StringSeq_H_ */
++#endif /* _TAO_CDR_OP_CORBA_StringSeq_H_ */
+ 
+ 
+-#if !defined _TAO_CDR_OP_WStringSeq_H_
+-#define _TAO_CDR_OP_WStringSeq_H_
++#if !defined _TAO_CDR_OP_CORBA_WStringSeq_H_
++#define _TAO_CDR_OP_CORBA_WStringSeq_H_
+ 
+ TAO_Export CORBA::Boolean operator<< (
+     TAO_OutputCDR &,
+-    const WStringSeq &
++    const CORBA_WStringSeq &
+   );
+ TAO_Export CORBA::Boolean operator>> (
+     TAO_InputCDR &,
+-    WStringSeq &
++    CORBA_WStringSeq &
+   );
+ 
+-#endif /* _TAO_CDR_OP_WStringSeq_H_ */
++#endif /* _TAO_CDR_OP_CORBA_WStringSeq_H_ */
+ 
+ 
+ #endif /* __ACE_INLINE__ */
+--- StringSeqC.i.old	Sun Oct 22 22:31:13 2000
++++ StringSeqC.i	Sun Oct 22 22:31:52 2000
+@@ -24,144 +24,144 @@
+ #define _STRINGSEQ_CI_
+ 
+ // *************************************************************
+-// Inline operations for class StringSeq_var
++// Inline operations for class CORBA_StringSeq_var
+ // *************************************************************
+ 
+ ACE_INLINE
+-StringSeq_var::StringSeq_var (void) // default constructor
++CORBA_StringSeq_var::CORBA_StringSeq_var (void) // default constructor
+   : ptr_ (0)
+ {}
+ 
+ ACE_INLINE
+-StringSeq_var::StringSeq_var (StringSeq *p)
++CORBA_StringSeq_var::CORBA_StringSeq_var (CORBA_StringSeq *p)
+   : ptr_ (p)
+ {}
+ 
+ ACE_INLINE
+-StringSeq_var::StringSeq_var (const ::StringSeq_var &p) // copy constructor
++CORBA_StringSeq_var::CORBA_StringSeq_var (const ::CORBA_StringSeq_var &p) // copy constructor
+ {
+   if (p.ptr_)
+-    ACE_NEW (this->ptr_, ::StringSeq (*p.ptr_));
++    ACE_NEW (this->ptr_, ::CORBA_StringSeq (*p.ptr_));
+   else
+     this->ptr_ = 0;
+ }
+ 
+ ACE_INLINE
+-StringSeq_var::~StringSeq_var (void) // destructor
++CORBA_StringSeq_var::~CORBA_StringSeq_var (void) // destructor
+ {
+   delete this->ptr_;
+ }
+ 
+-ACE_INLINE StringSeq_var &
+-StringSeq_var::operator= (StringSeq *p)
++ACE_INLINE CORBA_StringSeq_var &
++CORBA_StringSeq_var::operator= (CORBA_StringSeq *p)
+ {
+   delete this->ptr_;
+   this->ptr_ = p;
+   return *this;
+ }
+ 
+-ACE_INLINE StringSeq_var &
+-StringSeq_var::operator= (const ::StringSeq_var &p) // deep copy
++ACE_INLINE CORBA_StringSeq_var &
++CORBA_StringSeq_var::operator= (const ::CORBA_StringSeq_var &p) // deep copy
+ {
+   if (this != &p)
+   {
+     delete this->ptr_;
+-    ACE_NEW_RETURN (this->ptr_, ::StringSeq (*p.ptr_), *this);
++    ACE_NEW_RETURN (this->ptr_, ::CORBA_StringSeq (*p.ptr_), *this);
+   }
+   return *this;
+ }
+ 
+-ACE_INLINE const ::StringSeq *
+-StringSeq_var::operator-> (void) const
++ACE_INLINE const ::CORBA_StringSeq *
++CORBA_StringSeq_var::operator-> (void) const
+ {
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE ::StringSeq *
+-StringSeq_var::operator-> (void)
++ACE_INLINE ::CORBA_StringSeq *
++CORBA_StringSeq_var::operator-> (void)
+ {
+   return this->ptr_;
+ }
+ 
+ ACE_INLINE 
+-StringSeq_var::operator const ::StringSeq &() const // cast
++CORBA_StringSeq_var::operator const ::CORBA_StringSeq &() const // cast
+ {
+   return *this->ptr_;
+ }
+ 
+ ACE_INLINE 
+-StringSeq_var::operator ::StringSeq &() // cast 
++CORBA_StringSeq_var::operator ::CORBA_StringSeq &() // cast 
+ {
+   return *this->ptr_;
+ }
+ 
+ ACE_INLINE 
+-StringSeq_var::operator ::StringSeq &() const // cast 
++CORBA_StringSeq_var::operator ::CORBA_StringSeq &() const // cast 
+ {
+   return *this->ptr_;
+ }
+ 
+ // variable-size types only
+ ACE_INLINE
+-StringSeq_var::operator ::StringSeq *&() // cast 
++CORBA_StringSeq_var::operator ::CORBA_StringSeq *&() // cast 
+ {
+   return this->ptr_;
+ }
+ 
+ ACE_INLINE TAO_SeqElem_String_Manager
+-StringSeq_var::operator[] (CORBA::ULong index)
++CORBA_StringSeq_var::operator[] (CORBA::ULong index)
+ {
+   return this->ptr_->operator[] (index);
+ }
+ 
+-ACE_INLINE const ::StringSeq &
+-StringSeq_var::in (void) const
++ACE_INLINE const ::CORBA_StringSeq &
++CORBA_StringSeq_var::in (void) const
+ {
+   return *this->ptr_;
+ }
+ 
+-ACE_INLINE ::StringSeq &
+-StringSeq_var::inout (void)
++ACE_INLINE ::CORBA_StringSeq &
++CORBA_StringSeq_var::inout (void)
+ {
+   return *this->ptr_;
+ }
+ 
+ // mapping for variable size 
+-ACE_INLINE ::StringSeq *&
+-StringSeq_var::out (void)
++ACE_INLINE ::CORBA_StringSeq *&
++CORBA_StringSeq_var::out (void)
+ {
+   delete this->ptr_;
+   this->ptr_ = 0;
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE ::StringSeq *
+-StringSeq_var::_retn (void)
++ACE_INLINE ::CORBA_StringSeq *
++CORBA_StringSeq_var::_retn (void)
+ {
+-  ::StringSeq *tmp = this->ptr_;
++  ::CORBA_StringSeq *tmp = this->ptr_;
+   this->ptr_ = 0;
+   return tmp;
+ }
+ 
+-ACE_INLINE ::StringSeq *
+-StringSeq_var::ptr (void) const
++ACE_INLINE ::CORBA_StringSeq *
++CORBA_StringSeq_var::ptr (void) const
+ {
+   return this->ptr_;
+ }
+ 
+ // *************************************************************
+-// Inline operations for class StringSeq_out
++// Inline operations for class CORBA_StringSeq_out
+ // *************************************************************
+ 
+ ACE_INLINE
+-StringSeq_out::StringSeq_out (StringSeq *&p)
++CORBA_StringSeq_out::CORBA_StringSeq_out (CORBA_StringSeq *&p)
+   : ptr_ (p)
+ {
+   this->ptr_ = 0;
+ }
+ 
+ ACE_INLINE
+-StringSeq_out::StringSeq_out (StringSeq_var &p) // constructor from _var
++CORBA_StringSeq_out::CORBA_StringSeq_out (CORBA_StringSeq_var &p) // constructor from _var
+   : ptr_ (p.out ())
+ {
+   delete this->ptr_;
+@@ -169,44 +169,44 @@
+ }
+ 
+ ACE_INLINE
+-StringSeq_out::StringSeq_out (const ::StringSeq_out &p) // copy constructor
+-  : ptr_ (ACE_const_cast (StringSeq_out&, p).ptr_)
++CORBA_StringSeq_out::CORBA_StringSeq_out (const ::CORBA_StringSeq_out &p) // copy constructor
++  : ptr_ (ACE_const_cast (CORBA_StringSeq_out&, p).ptr_)
+ {}
+ 
+-ACE_INLINE ::StringSeq_out &
+-StringSeq_out::operator= (const ::StringSeq_out &p)
++ACE_INLINE ::CORBA_StringSeq_out &
++CORBA_StringSeq_out::operator= (const ::CORBA_StringSeq_out &p)
+ {
+-  this->ptr_ = ACE_const_cast (StringSeq_out&, p).ptr_;
++  this->ptr_ = ACE_const_cast (CORBA_StringSeq_out&, p).ptr_;
+   return *this;
+ }
+ 
+-ACE_INLINE ::StringSeq_out &
+-StringSeq_out::operator= (StringSeq *p)
++ACE_INLINE ::CORBA_StringSeq_out &
++CORBA_StringSeq_out::operator= (CORBA_StringSeq *p)
+ {
+   this->ptr_ = p;
+   return *this;
+ }
+ 
+ ACE_INLINE 
+-StringSeq_out::operator ::StringSeq *&() // cast
++CORBA_StringSeq_out::operator ::CORBA_StringSeq *&() // cast
+ {
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE ::StringSeq *&
+-StringSeq_out::ptr (void) // ptr
++ACE_INLINE ::CORBA_StringSeq *&
++CORBA_StringSeq_out::ptr (void) // ptr
+ {
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE ::StringSeq *
+-StringSeq_out::operator-> (void)
++ACE_INLINE ::CORBA_StringSeq *
++CORBA_StringSeq_out::operator-> (void)
+ {
+   return this->ptr_;
+ }
+ 
+ ACE_INLINE TAO_SeqElem_String_Manager
+-StringSeq_out::operator[] (CORBA::ULong index)
++CORBA_StringSeq_out::operator[] (CORBA::ULong index)
+ {
+   return this->ptr_->operator[] (index);
+ }
+@@ -219,144 +219,144 @@
+ #define _WSTRINGSEQ_CI_
+ 
+ // *************************************************************
+-// Inline operations for class WStringSeq_var
++// Inline operations for class CORBA_WStringSeq_var
+ // *************************************************************
+ 
+ ACE_INLINE
+-WStringSeq_var::WStringSeq_var (void) // default constructor
++CORBA_WStringSeq_var::CORBA_WStringSeq_var (void) // default constructor
+   : ptr_ (0)
+ {}
+ 
+ ACE_INLINE
+-WStringSeq_var::WStringSeq_var (WStringSeq *p)
++CORBA_WStringSeq_var::CORBA_WStringSeq_var (CORBA_WStringSeq *p)
+   : ptr_ (p)
+ {}
+ 
+ ACE_INLINE
+-WStringSeq_var::WStringSeq_var (const ::WStringSeq_var &p) // copy constructor
++CORBA_WStringSeq_var::CORBA_WStringSeq_var (const ::CORBA_WStringSeq_var &p) // copy constructor
+ {
+   if (p.ptr_)
+-    ACE_NEW (this->ptr_, ::WStringSeq (*p.ptr_));
++    ACE_NEW (this->ptr_, ::CORBA_WStringSeq (*p.ptr_));
+   else
+     this->ptr_ = 0;
+ }
+ 
+ ACE_INLINE
+-WStringSeq_var::~WStringSeq_var (void) // destructor
++CORBA_WStringSeq_var::~CORBA_WStringSeq_var (void) // destructor
+ {
+   delete this->ptr_;
+ }
+ 
+-ACE_INLINE WStringSeq_var &
+-WStringSeq_var::operator= (WStringSeq *p)
++ACE_INLINE CORBA_WStringSeq_var &
++CORBA_WStringSeq_var::operator= (CORBA_WStringSeq *p)
+ {
+   delete this->ptr_;
+   this->ptr_ = p;
+   return *this;
+ }
+ 
+-ACE_INLINE WStringSeq_var &
+-WStringSeq_var::operator= (const ::WStringSeq_var &p) // deep copy
++ACE_INLINE CORBA_WStringSeq_var &
++CORBA_WStringSeq_var::operator= (const ::CORBA_WStringSeq_var &p) // deep copy
+ {
+   if (this != &p)
+   {
+     delete this->ptr_;
+-    ACE_NEW_RETURN (this->ptr_, ::WStringSeq (*p.ptr_), *this);
++    ACE_NEW_RETURN (this->ptr_, ::CORBA_WStringSeq (*p.ptr_), *this);
+   }
+   return *this;
+ }
+ 
+-ACE_INLINE const ::WStringSeq *
+-WStringSeq_var::operator-> (void) const
++ACE_INLINE const ::CORBA_WStringSeq *
++CORBA_WStringSeq_var::operator-> (void) const
+ {
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE ::WStringSeq *
+-WStringSeq_var::operator-> (void)
++ACE_INLINE ::CORBA_WStringSeq *
++CORBA_WStringSeq_var::operator-> (void)
+ {
+   return this->ptr_;
+ }
+ 
+ ACE_INLINE 
+-WStringSeq_var::operator const ::WStringSeq &() const // cast
++CORBA_WStringSeq_var::operator const ::CORBA_WStringSeq &() const // cast
+ {
+   return *this->ptr_;
+ }
+ 
+ ACE_INLINE 
+-WStringSeq_var::operator ::WStringSeq &() // cast 
++CORBA_WStringSeq_var::operator ::CORBA_WStringSeq &() // cast 
+ {
+   return *this->ptr_;
+ }
+ 
+ ACE_INLINE 
+-WStringSeq_var::operator ::WStringSeq &() const // cast 
++CORBA_WStringSeq_var::operator ::CORBA_WStringSeq &() const // cast 
+ {
+   return *this->ptr_;
+ }
+ 
+ // variable-size types only
+ ACE_INLINE
+-WStringSeq_var::operator ::WStringSeq *&() // cast 
++CORBA_WStringSeq_var::operator ::CORBA_WStringSeq *&() // cast 
+ {
+   return this->ptr_;
+ }
+ 
+ ACE_INLINE TAO_SeqElem_WString_Manager
+-WStringSeq_var::operator[] (CORBA::ULong index)
++CORBA_WStringSeq_var::operator[] (CORBA::ULong index)
+ {
+   return this->ptr_->operator[] (index);
+ }
+ 
+-ACE_INLINE const ::WStringSeq &
+-WStringSeq_var::in (void) const
++ACE_INLINE const ::CORBA_WStringSeq &
++CORBA_WStringSeq_var::in (void) const
+ {
+   return *this->ptr_;
+ }
+ 
+-ACE_INLINE ::WStringSeq &
+-WStringSeq_var::inout (void)
++ACE_INLINE ::CORBA_WStringSeq &
++CORBA_WStringSeq_var::inout (void)
+ {
+   return *this->ptr_;
+ }
+ 
+ // mapping for variable size 
+-ACE_INLINE ::WStringSeq *&
+-WStringSeq_var::out (void)
++ACE_INLINE ::CORBA_WStringSeq *&
++CORBA_WStringSeq_var::out (void)
+ {
+   delete this->ptr_;
+   this->ptr_ = 0;
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE ::WStringSeq *
+-WStringSeq_var::_retn (void)
++ACE_INLINE ::CORBA_WStringSeq *
++CORBA_WStringSeq_var::_retn (void)
+ {
+-  ::WStringSeq *tmp = this->ptr_;
++  ::CORBA_WStringSeq *tmp = this->ptr_;
+   this->ptr_ = 0;
+   return tmp;
+ }
+ 
+-ACE_INLINE ::WStringSeq *
+-WStringSeq_var::ptr (void) const
++ACE_INLINE ::CORBA_WStringSeq *
++CORBA_WStringSeq_var::ptr (void) const
+ {
+   return this->ptr_;
+ }
+ 
+ // *************************************************************
+-// Inline operations for class WStringSeq_out
++// Inline operations for class CORBA_WStringSeq_out
+ // *************************************************************
+ 
+ ACE_INLINE
+-WStringSeq_out::WStringSeq_out (WStringSeq *&p)
++CORBA_WStringSeq_out::CORBA_WStringSeq_out (CORBA_WStringSeq *&p)
+   : ptr_ (p)
+ {
+   this->ptr_ = 0;
+ }
+ 
+ ACE_INLINE
+-WStringSeq_out::WStringSeq_out (WStringSeq_var &p) // constructor from _var
++CORBA_WStringSeq_out::CORBA_WStringSeq_out (CORBA_WStringSeq_var &p) // constructor from _var
+   : ptr_ (p.out ())
+ {
+   delete this->ptr_;
+@@ -364,44 +364,44 @@
+ }
+ 
+ ACE_INLINE
+-WStringSeq_out::WStringSeq_out (const ::WStringSeq_out &p) // copy constructor
+-  : ptr_ (ACE_const_cast (WStringSeq_out&, p).ptr_)
++CORBA_WStringSeq_out::CORBA_WStringSeq_out (const ::CORBA_WStringSeq_out &p) // copy constructor
++  : ptr_ (ACE_const_cast (CORBA_WStringSeq_out&, p).ptr_)
+ {}
+ 
+-ACE_INLINE ::WStringSeq_out &
+-WStringSeq_out::operator= (const ::WStringSeq_out &p)
++ACE_INLINE ::CORBA_WStringSeq_out &
++CORBA_WStringSeq_out::operator= (const ::CORBA_WStringSeq_out &p)
+ {
+-  this->ptr_ = ACE_const_cast (WStringSeq_out&, p).ptr_;
++  this->ptr_ = ACE_const_cast (CORBA_WStringSeq_out&, p).ptr_;
+   return *this;
+ }
+ 
+-ACE_INLINE ::WStringSeq_out &
+-WStringSeq_out::operator= (WStringSeq *p)
++ACE_INLINE ::CORBA_WStringSeq_out &
++CORBA_WStringSeq_out::operator= (CORBA_WStringSeq *p)
+ {
+   this->ptr_ = p;
+   return *this;
+ }
+ 
+ ACE_INLINE 
+-WStringSeq_out::operator ::WStringSeq *&() // cast
++CORBA_WStringSeq_out::operator ::CORBA_WStringSeq *&() // cast
+ {
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE ::WStringSeq *&
+-WStringSeq_out::ptr (void) // ptr
++ACE_INLINE ::CORBA_WStringSeq *&
++CORBA_WStringSeq_out::ptr (void) // ptr
+ {
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE ::WStringSeq *
+-WStringSeq_out::operator-> (void)
++ACE_INLINE ::CORBA_WStringSeq *
++CORBA_WStringSeq_out::operator-> (void)
+ {
+   return this->ptr_;
+ }
+ 
+ ACE_INLINE TAO_SeqElem_WString_Manager
+-WStringSeq_out::operator[] (CORBA::ULong index)
++CORBA_WStringSeq_out::operator[] (CORBA::ULong index)
+ {
+   return this->ptr_->operator[] (index);
+ }
+@@ -410,32 +410,32 @@
+ #endif /* end #if !defined */
+ 
+ 
+-#if !defined _TAO_CDR_OP_StringSeq_I_
+-#define _TAO_CDR_OP_StringSeq_I_
++#if !defined _TAO_CDR_OP_CORBA_StringSeq_I_
++#define _TAO_CDR_OP_CORBA_StringSeq_I_
+ 
+ CORBA::Boolean TAO_Export operator<< (
+     TAO_OutputCDR &,
+-    const StringSeq &
++    const CORBA_StringSeq &
+   );
+ CORBA::Boolean TAO_Export operator>> (
+     TAO_InputCDR &,
+-    StringSeq &
++    CORBA_StringSeq &
+   );
+ 
+-#endif /* _TAO_CDR_OP_StringSeq_I_ */
++#endif /* _TAO_CDR_OP_CORBA_StringSeq_I_ */
+ 
+ 
+-#if !defined _TAO_CDR_OP_WStringSeq_I_
+-#define _TAO_CDR_OP_WStringSeq_I_
++#if !defined _TAO_CDR_OP_CORBA_WStringSeq_I_
++#define _TAO_CDR_OP_CORBA_WStringSeq_I_
+ 
+ CORBA::Boolean TAO_Export operator<< (
+     TAO_OutputCDR &,
+-    const WStringSeq &
++    const CORBA_WStringSeq &
+   );
+ CORBA::Boolean TAO_Export operator>> (
+     TAO_InputCDR &,
+-    WStringSeq &
++    CORBA_WStringSeq &
+   );
+ 
+-#endif /* _TAO_CDR_OP_WStringSeq_I_ */
++#endif /* _TAO_CDR_OP_CORBA_WStringSeq_I_ */
+ 
+--- StringSeqC.cpp.old	Sun Oct 22 22:31:13 2000
++++ StringSeqC.cpp	Sun Oct 22 22:31:52 2000
+@@ -25,17 +25,18 @@
+ #include "StringSeqC.i"
+ #endif /* !defined INLINE */
+ 
++#include "tao/Any.h"
+ 
+ #if !defined (_STRINGSEQ_CS_)
+ #define _STRINGSEQ_CS_
+ 
+ // *************************************************************
+-// StringSeq
++// CORBA_StringSeq
+ // *************************************************************
+ 
+-StringSeq::StringSeq (void)
++CORBA_StringSeq::CORBA_StringSeq (void)
+ {}
+-StringSeq::StringSeq (CORBA::ULong max) // uses max size
++CORBA_StringSeq::CORBA_StringSeq (CORBA::ULong max) // uses max size
+   : 
+ #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+   TAO_Unbounded_String_Sequence
+@@ -44,7 +45,7 @@
+ #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  (max)
+ {}
+-StringSeq::StringSeq (CORBA::ULong max, CORBA::ULong length, char * *buffer, CORBA::Boolean release)
++CORBA_StringSeq::CORBA_StringSeq (CORBA::ULong max, CORBA::ULong length, char * *buffer, CORBA::Boolean release)
+   : 
+ #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+   TAO_Unbounded_String_Sequence
+@@ -53,7 +54,7 @@
+ #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  (max, length, buffer, release)
+ {}
+-StringSeq::StringSeq (const StringSeq &seq) // copy ctor
++CORBA_StringSeq::CORBA_StringSeq (const CORBA_StringSeq &seq) // copy ctor
+   : 
+ #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+   TAO_Unbounded_String_Sequence
+@@ -62,22 +63,22 @@
+ #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  (seq)
+ {}
+-StringSeq::~StringSeq (void) // dtor
++CORBA_StringSeq::~CORBA_StringSeq (void) // dtor
+ {}
+-void StringSeq::_tao_any_destructor (void *x)
++void CORBA_StringSeq::_tao_any_destructor (void *x)
+ {
+-  StringSeq *tmp = ACE_static_cast (StringSeq*,x);
++  CORBA_StringSeq *tmp = ACE_static_cast (CORBA_StringSeq*,x);
+   delete tmp;
+ }
+ 
+ 
+ #endif /* end #if !defined */
+ 
+-static const CORBA::Long _oc_StringSeq[] =
++static const CORBA::Long _oc_CORBA_StringSeq[] =
+ {
+   TAO_ENCAP_BYTE_ORDER, // byte order
+-  18, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x53747269), ACE_NTOHL (0x6e675365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:StringSeq:1.0
+-  10, ACE_NTOHL (0x53747269), ACE_NTOHL (0x6e675365), ACE_NTOHL (0x71000000),  // name = StringSeq
++  18, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x53747269), ACE_NTOHL (0x6e675365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:CORBA_StringSeq:1.0
++  10, ACE_NTOHL (0x53747269), ACE_NTOHL (0x6e675365), ACE_NTOHL (0x71000000),  // name = CORBA_StringSeq
+   CORBA::tk_sequence, // typecode kind
+   16, // encapsulation length
+     TAO_ENCAP_BYTE_ORDER, // byte order
+@@ -86,20 +87,20 @@
+     0U,
+ 
+ };
+-static CORBA::TypeCode _tc_TAO_tc_StringSeq (CORBA::tk_alias, sizeof (_oc_StringSeq), (char *) &_oc_StringSeq, 0, sizeof (StringSeq));
+-CORBA::TypeCode_ptr _tc_StringSeq = &_tc_TAO_tc_StringSeq;
++static CORBA::TypeCode _tc_TAO_tc_CORBA_StringSeq (CORBA::tk_alias, sizeof (_oc_CORBA_StringSeq), (char *) &_oc_CORBA_StringSeq, 0, sizeof (CORBA_StringSeq));
++CORBA::TypeCode_ptr _tc_CORBA_StringSeq = &_tc_TAO_tc_CORBA_StringSeq;
+ 
+ 
+ #if !defined (_WSTRINGSEQ_CS_)
+ #define _WSTRINGSEQ_CS_
+ 
+ // *************************************************************
+-// WStringSeq
++// CORBA_WStringSeq
+ // *************************************************************
+ 
+-WStringSeq::WStringSeq (void)
++CORBA_WStringSeq::CORBA_WStringSeq (void)
+ {}
+-WStringSeq::WStringSeq (CORBA::ULong max) // uses max size
++CORBA_WStringSeq::CORBA_WStringSeq (CORBA::ULong max) // uses max size
+   : 
+ #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+   TAO_Unbounded_WString_Sequence
+@@ -108,7 +109,7 @@
+ #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  (max)
+ {}
+-WStringSeq::WStringSeq (CORBA::ULong max, CORBA::ULong length, CORBA::WChar * *buffer, CORBA::Boolean release)
++CORBA_WStringSeq::CORBA_WStringSeq (CORBA::ULong max, CORBA::ULong length, CORBA::WChar * *buffer, CORBA::Boolean release)
+   : 
+ #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+   TAO_Unbounded_WString_Sequence
+@@ -117,7 +118,7 @@
+ #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  (max, length, buffer, release)
+ {}
+-WStringSeq::WStringSeq (const WStringSeq &seq) // copy ctor
++CORBA_WStringSeq::CORBA_WStringSeq (const CORBA_WStringSeq &seq) // copy ctor
+   : 
+ #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+   TAO_Unbounded_WString_Sequence
+@@ -126,22 +127,22 @@
+ #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  (seq)
+ {}
+-WStringSeq::~WStringSeq (void) // dtor
++CORBA_WStringSeq::~CORBA_WStringSeq (void) // dtor
+ {}
+-void WStringSeq::_tao_any_destructor (void *x)
++void CORBA_WStringSeq::_tao_any_destructor (void *x)
+ {
+-  WStringSeq *tmp = ACE_static_cast (WStringSeq*,x);
++  CORBA_WStringSeq *tmp = ACE_static_cast (CORBA_WStringSeq*,x);
+   delete tmp;
+ }
+ 
+ 
+ #endif /* end #if !defined */
+ 
+-static const CORBA::Long _oc_WStringSeq[] =
++static const CORBA::Long _oc_CORBA_WStringSeq[] =
+ {
+   TAO_ENCAP_BYTE_ORDER, // byte order
+-  19, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x57537472), ACE_NTOHL (0x696e6753), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:WStringSeq:1.0
+-  11, ACE_NTOHL (0x57537472), ACE_NTOHL (0x696e6753), ACE_NTOHL (0x65710000),  // name = WStringSeq
++  19, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x57537472), ACE_NTOHL (0x696e6753), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:CORBA_WStringSeq:1.0
++  11, ACE_NTOHL (0x57537472), ACE_NTOHL (0x696e6753), ACE_NTOHL (0x65710000),  // name = CORBA_WStringSeq
+   CORBA::tk_sequence, // typecode kind
+   16, // encapsulation length
+     TAO_ENCAP_BYTE_ORDER, // byte order
+@@ -150,54 +151,54 @@
+     0U,
+ 
+ };
+-static CORBA::TypeCode _tc_TAO_tc_WStringSeq (CORBA::tk_alias, sizeof (_oc_WStringSeq), (char *) &_oc_WStringSeq, 0, sizeof (WStringSeq));
+-CORBA::TypeCode_ptr _tc_WStringSeq = &_tc_TAO_tc_WStringSeq;
++static CORBA::TypeCode _tc_TAO_tc_CORBA_WStringSeq (CORBA::tk_alias, sizeof (_oc_CORBA_WStringSeq), (char *) &_oc_CORBA_WStringSeq, 0, sizeof (CORBA_WStringSeq));
++CORBA::TypeCode_ptr _tc_CORBA_WStringSeq = &_tc_TAO_tc_CORBA_WStringSeq;
+ 
+ void operator<<= (
+     CORBA::Any &_tao_any,
+-    const StringSeq &_tao_elem
++    const CORBA_StringSeq &_tao_elem
+   ) // copying
+ {
+   TAO_OutputCDR stream;
+   if (stream << _tao_elem)
+   {
+     _tao_any._tao_replace (
+-        _tc_StringSeq,
++        _tc_CORBA_StringSeq,
+         TAO_ENCAP_BYTE_ORDER,
+         stream.begin ()
+       );
+   }
+ }
+ 
+-void operator<<= (CORBA::Any &_tao_any, StringSeq *_tao_elem) // non copying
++void operator<<= (CORBA::Any &_tao_any, CORBA_StringSeq *_tao_elem) // non copying
+ {
+   TAO_OutputCDR stream;
+   stream << *_tao_elem;
+   _tao_any._tao_replace (
+-      _tc_StringSeq,
++      _tc_CORBA_StringSeq,
+       TAO_ENCAP_BYTE_ORDER,
+       stream.begin (),
+       1,
+       _tao_elem,
+-      StringSeq::_tao_any_destructor
++      CORBA_StringSeq::_tao_any_destructor
+     );
+ }
+ 
+-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, StringSeq *&_tao_elem)
++CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_StringSeq *&_tao_elem)
+ {
+   return _tao_any >>= ACE_const_cast(
+-      const StringSeq*&,
++      const CORBA_StringSeq*&,
+       _tao_elem
+     );
+ }
+ 
+-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const StringSeq *&_tao_elem)
++CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_StringSeq *&_tao_elem)
+ {
+   _tao_elem = 0;
+   ACE_TRY_NEW_ENV
+   {
+     CORBA::TypeCode_var type = _tao_any.type ();
+-    if (!type->equivalent (_tc_StringSeq, ACE_TRY_ENV)) // not equal
++    if (!type->equivalent (_tc_CORBA_StringSeq, ACE_TRY_ENV)) // not equal
+       {
+         return 0;
+       }
+@@ -205,15 +206,15 @@
+     if (_tao_any.any_owns_data ())
+     {
+       _tao_elem = ACE_static_cast(
+-          const StringSeq*,
++          const CORBA_StringSeq*,
+           _tao_any.value ()
+         );
+       return 1;
+     }
+     else
+     {
+-      StringSeq *tmp;
+-      ACE_NEW_RETURN (tmp, StringSeq, 0);
++      CORBA_StringSeq *tmp;
++      ACE_NEW_RETURN (tmp, CORBA_StringSeq, 0);
+       TAO_InputCDR stream (
+           _tao_any._tao_get_cdr (),
+           _tao_any._tao_byte_order ()
+@@ -221,10 +222,10 @@
+       if (stream >> *tmp)
+       {
+         ((CORBA::Any *)&_tao_any)->_tao_replace (
+-            _tc_StringSeq,
++            _tc_CORBA_StringSeq,
+             1,
+             ACE_static_cast (void *, tmp),
+-            StringSeq::_tao_any_destructor
++            CORBA_StringSeq::_tao_any_destructor
+           );
+         _tao_elem = tmp;
+         return 1;
+@@ -244,49 +245,49 @@
+ 
+ void operator<<= (
+     CORBA::Any &_tao_any,
+-    const WStringSeq &_tao_elem
++    const CORBA_WStringSeq &_tao_elem
+   ) // copying
+ {
+   TAO_OutputCDR stream;
+   if (stream << _tao_elem)
+   {
+     _tao_any._tao_replace (
+-        _tc_WStringSeq,
++        _tc_CORBA_WStringSeq,
+         TAO_ENCAP_BYTE_ORDER,
+         stream.begin ()
+       );
+   }
+ }
+ 
+-void operator<<= (CORBA::Any &_tao_any, WStringSeq *_tao_elem) // non copying
++void operator<<= (CORBA::Any &_tao_any, CORBA_WStringSeq *_tao_elem) // non copying
+ {
+   TAO_OutputCDR stream;
+   stream << *_tao_elem;
+   _tao_any._tao_replace (
+-      _tc_WStringSeq,
++      _tc_CORBA_WStringSeq,
+       TAO_ENCAP_BYTE_ORDER,
+       stream.begin (),
+       1,
+       _tao_elem,
+-      WStringSeq::_tao_any_destructor
++      CORBA_WStringSeq::_tao_any_destructor
+     );
+ }
+ 
+-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, WStringSeq *&_tao_elem)
++CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_WStringSeq *&_tao_elem)
+ {
+   return _tao_any >>= ACE_const_cast(
+-      const WStringSeq*&,
++      const CORBA_WStringSeq*&,
+       _tao_elem
+     );
+ }
+ 
+-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const WStringSeq *&_tao_elem)
++CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_WStringSeq *&_tao_elem)
+ {
+   _tao_elem = 0;
+   ACE_TRY_NEW_ENV
+   {
+     CORBA::TypeCode_var type = _tao_any.type ();
+-    if (!type->equivalent (_tc_WStringSeq, ACE_TRY_ENV)) // not equal
++    if (!type->equivalent (_tc_CORBA_WStringSeq, ACE_TRY_ENV)) // not equal
+       {
+         return 0;
+       }
+@@ -294,15 +295,15 @@
+     if (_tao_any.any_owns_data ())
+     {
+       _tao_elem = ACE_static_cast(
+-          const WStringSeq*,
++          const CORBA_WStringSeq*,
+           _tao_any.value ()
+         );
+       return 1;
+     }
+     else
+     {
+-      WStringSeq *tmp;
+-      ACE_NEW_RETURN (tmp, WStringSeq, 0);
++      CORBA_WStringSeq *tmp;
++      ACE_NEW_RETURN (tmp, CORBA_WStringSeq, 0);
+       TAO_InputCDR stream (
+           _tao_any._tao_get_cdr (),
+           _tao_any._tao_byte_order ()
+@@ -310,10 +311,10 @@
+       if (stream >> *tmp)
+       {
+         ((CORBA::Any *)&_tao_any)->_tao_replace (
+-            _tc_WStringSeq,
++            _tc_CORBA_WStringSeq,
+             1,
+             ACE_static_cast (void *, tmp),
+-            WStringSeq::_tao_any_destructor
++            CORBA_WStringSeq::_tao_any_destructor
+           );
+         _tao_elem = tmp;
+         return 1;
+@@ -333,7 +334,7 @@
+ 
+ CORBA::Boolean operator<< (
+     TAO_OutputCDR &strm,
+-    const StringSeq &_tao_sequence
++    const CORBA_StringSeq &_tao_sequence
+   )
+ {
+   if (strm << _tao_sequence.length ())
+@@ -351,7 +352,7 @@
+ 
+ CORBA::Boolean operator>> (
+     TAO_InputCDR &strm,
+-    StringSeq &_tao_sequence
++    CORBA_StringSeq &_tao_sequence
+   )
+ {
+   CORBA::ULong _tao_seq_len;
+@@ -375,7 +376,7 @@
+ 
+ CORBA::Boolean operator<< (
+     TAO_OutputCDR &strm,
+-    const WStringSeq &_tao_sequence
++    const CORBA_WStringSeq &_tao_sequence
+   )
+ {
+   if (strm << _tao_sequence.length ())
+@@ -393,7 +394,7 @@
+ 
+ CORBA::Boolean operator>> (
+     TAO_InputCDR &strm,
+-    WStringSeq &_tao_sequence
++    CORBA_WStringSeq &_tao_sequence
+   )
+ {
+   CORBA::ULong _tao_seq_len;