Inline related fixes uncovered by egcs.

8 files changed, 447 insertions, 449 deletions

diff --git a/TAO/tao/IFR_Client/IFR_BaseC.cpp b/TAO/tao/IFR_Client/IFR_BaseC.cpp
index 3f4ba9fb788..397a4945430 100644
--- a/TAO/tao/IFR_Client/IFR_BaseC.cpp
+++ b/TAO/tao/IFR_Client/IFR_BaseC.cpp
@@ -398,13 +398,13 @@ _TAO_IRObject_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::IRObject::IRObject (int collocated)
+CORBA::IRObject::CORBA_IRObject (int collocated)
 {
   this->CORBA_IRObject_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::IRObject::~IRObject (void)
+CORBA::IRObject::~CORBA_IRObject (void)
 {}
 
 void
@@ -2305,13 +2305,13 @@ _TAO_Contained_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::Contained::Contained (int collocated)
+CORBA::Contained::CORBA_Contained (int collocated)
 {
   this->CORBA_Contained_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::Contained::~Contained (void)
+CORBA::Contained::~CORBA_Contained (void)
 {}
 
 void
@@ -3453,17 +3453,17 @@ CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_move::result (CORBA::Env
 
   // The Base_Sequence functions, please see tao/Sequence.h
   void
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_allocate_buffer (CORBA::ULong length)
+  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_allocate_buffer (CORBA::ULong length)
   {
-    Contained **tmp = 0;
+    CORBA_Contained **tmp = 0;
     tmp = _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (length);
     
     if (this->buffer_ != 0)
     {
-      Contained **old = ACE_reinterpret_cast (Contained**, this->buffer_);
+      CORBA_Contained **old = ACE_reinterpret_cast (CORBA_Contained**, this->buffer_);
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         if (!this->release_)
-          tmp[i] = Contained::_duplicate (old[i]);
+          tmp[i] = CORBA_Contained::_duplicate (old[i]);
         else
           tmp[i] = old[i];
         
@@ -3475,52 +3475,52 @@ CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_move::result (CORBA::Env
   }
   
   void
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_deallocate_buffer (void)
+  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
-    Contained **tmp = ACE_reinterpret_cast (Contained**, this->buffer_);
+    CORBA_Contained **tmp = ACE_reinterpret_cast (CORBA_Contained**, this->buffer_);
     for (CORBA::ULong i = 0; i < this->length_; ++i)
     {
       CORBA::release (tmp[i]);
-      tmp[i] = Contained::_nil ();
+      tmp[i] = CORBA_Contained::_nil ();
     }
     _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::freebuf (tmp);
     this->buffer_ = 0;
   }
   
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::~_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (void)
+  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::~_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (void)
   {
     this->_deallocate_buffer ();
   }
   
   void
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
   {
-    Contained **tmp = ACE_reinterpret_cast (Contained**, this->buffer_);
+    CORBA_Contained **tmp = ACE_reinterpret_cast (CORBA_Contained**, this->buffer_);
     
     for (CORBA::ULong i = nl; i < ol; ++i)
     {
       CORBA::release (tmp[i]);
-      tmp[i] = Contained::_nil ();
+      tmp[i] = CORBA_Contained::_nil ();
     }
   }
   void 
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_downcast (
+  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_downcast (
       void* target,
       CORBA_Object *src,
       CORBA_Environment &ACE_TRY_ENV
     )
   {
-    Contained **tmp = ACE_static_cast (Contained**, target);
-    *tmp = Contained::_narrow (src, ACE_TRY_ENV);
+    CORBA_Contained **tmp = ACE_static_cast (CORBA_Contained**, target);
+    *tmp = CORBA_Contained::_narrow (src, ACE_TRY_ENV);
     ACE_CHECK;
   }
 
   CORBA_Object*
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_upcast (void *src) const
+  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_upcast (void *src) const
   {
-    Contained **tmp = ACE_static_cast (Contained**, src);
+    CORBA_Contained **tmp = ACE_static_cast (CORBA_Contained**, src);
     return *tmp;
   }
   
@@ -3588,14 +3588,14 @@ void CORBA::StructMember::_tao_any_destructor (void *x)
 #define __TAO_UNBOUNDED_SEQUENCE_CORBA_STRUCTMEMBERSEQ_CS_
 
   void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_allocate_buffer (CORBA::ULong length)
+  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_allocate_buffer (CORBA::ULong length)
   {
-    StructMember* tmp = 0;
+    CORBA_StructMember* tmp = 0;
     tmp = _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (length);
     
     if (this->buffer_ != 0)
     {
-      StructMember *old = ACE_reinterpret_cast (StructMember *,this->buffer_);
+      CORBA_StructMember *old = ACE_reinterpret_cast (CORBA_StructMember *,this->buffer_);
       
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         tmp[i] = old[i];
@@ -3608,18 +3608,18 @@ void CORBA::StructMember::_tao_any_destructor (void *x)
   }
   
   void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_deallocate_buffer (void)
+  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
     
-    StructMember *tmp = ACE_reinterpret_cast (StructMember *,this->buffer_);
+    CORBA_StructMember *tmp = ACE_reinterpret_cast (CORBA_StructMember *,this->buffer_);
     
     _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (tmp);
     this->buffer_ = 0;
   } 
   
-  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::~_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (void) // Dtor.
+  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::~_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (void) // Dtor.
   {
     this->_deallocate_buffer ();
   }
@@ -3690,14 +3690,14 @@ void CORBA::Initializer::_tao_any_destructor (void *x)
 #define __TAO_UNBOUNDED_SEQUENCE_CORBA_INITIALIZERSEQ_CS_
 
   void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::_allocate_buffer (CORBA::ULong length)
+  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::_allocate_buffer (CORBA::ULong length)
   {
-    Initializer* tmp = 0;
+    CORBA_Initializer* tmp = 0;
     tmp = _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (length);
     
     if (this->buffer_ != 0)
     {
-      Initializer *old = ACE_reinterpret_cast (Initializer *,this->buffer_);
+      CORBA_Initializer *old = ACE_reinterpret_cast (CORBA_Initializer *,this->buffer_);
       
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         tmp[i] = old[i];
@@ -3710,18 +3710,18 @@ void CORBA::Initializer::_tao_any_destructor (void *x)
   }
   
   void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::_deallocate_buffer (void)
+  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
     
-    Initializer *tmp = ACE_reinterpret_cast (Initializer *,this->buffer_);
+    CORBA_Initializer *tmp = ACE_reinterpret_cast (CORBA_Initializer *,this->buffer_);
     
     _TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (tmp);
     this->buffer_ = 0;
   } 
   
-  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::~_TAO_Unbounded_Sequence_CORBA_InitializerSeq (void) // Dtor.
+  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::~_TAO_Unbounded_Sequence_CORBA_InitializerSeq (void) // Dtor.
   {
     this->_deallocate_buffer ();
   }
@@ -3792,14 +3792,14 @@ void CORBA::UnionMember::_tao_any_destructor (void *x)
 #define __TAO_UNBOUNDED_SEQUENCE_CORBA_UNIONMEMBERSEQ_CS_
 
   void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_allocate_buffer (CORBA::ULong length)
+  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_allocate_buffer (CORBA::ULong length)
   {
-    UnionMember* tmp = 0;
+    CORBA_UnionMember* tmp = 0;
     tmp = _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (length);
     
     if (this->buffer_ != 0)
     {
-      UnionMember *old = ACE_reinterpret_cast (UnionMember *,this->buffer_);
+      CORBA_UnionMember *old = ACE_reinterpret_cast (CORBA_UnionMember *,this->buffer_);
       
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         tmp[i] = old[i];
@@ -3812,18 +3812,18 @@ void CORBA::UnionMember::_tao_any_destructor (void *x)
   }
   
   void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_deallocate_buffer (void)
+  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
     
-    UnionMember *tmp = ACE_reinterpret_cast (UnionMember *,this->buffer_);
+    CORBA_UnionMember *tmp = ACE_reinterpret_cast (CORBA_UnionMember *,this->buffer_);
     
     _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (tmp);
     this->buffer_ = 0;
   } 
   
-  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::~_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (void) // Dtor.
+  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::~_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (void) // Dtor.
   {
     this->_deallocate_buffer ();
   }
@@ -4703,13 +4703,13 @@ _TAO_Container_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::Container::Container (int collocated)
+CORBA::Container::CORBA_Container (int collocated)
 {
   this->CORBA_Container_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::Container::~Container (void)
+CORBA::Container::~CORBA_Container (void)
 {}
 
 void
@@ -5127,12 +5127,12 @@ void CORBA::Container::Description::_tao_any_destructor (void *x)
   void
   CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::_allocate_buffer (CORBA::ULong length)
   {
-    Description* tmp = 0;
+    CORBA::Container::Description* tmp = 0;
     tmp = _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (length);
     
     if (this->buffer_ != 0)
     {
-      Description *old = ACE_reinterpret_cast (Description *,this->buffer_);
+      CORBA::Container::Description *old = ACE_reinterpret_cast (CORBA::Container::Description *,this->buffer_);
       
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         tmp[i] = old[i];
@@ -5150,7 +5150,7 @@ void CORBA::Container::Description::_tao_any_destructor (void *x)
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
     
-    Description *tmp = ACE_reinterpret_cast (Description *,this->buffer_);
+    CORBA::Container::Description *tmp = ACE_reinterpret_cast (CORBA::Container::Description *,this->buffer_);
     
     _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::freebuf (tmp);
     this->buffer_ = 0;
@@ -7127,13 +7127,13 @@ _TAO_IDLType_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::IDLType::IDLType (int collocated)
+CORBA_IDLType::CORBA_IDLType (int collocated)
 {
   this->CORBA_IDLType_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::IDLType::~IDLType (void)
+CORBA_IDLType::~CORBA_IDLType (void)
 {}
 
 void
@@ -7416,13 +7416,13 @@ _TAO_TypedefDef_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::TypedefDef::TypedefDef (int collocated)
+CORBA_TypedefDef::CORBA_TypedefDef (int collocated)
 {
   this->CORBA_TypedefDef_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::TypedefDef::~TypedefDef (void)
+CORBA_TypedefDef::~CORBA_TypedefDef (void)
 {}
 
 void
diff --git a/TAO/tao/IFR_Client/IFR_BaseC.i b/TAO/tao/IFR_Client/IFR_BaseC.i
index 66e731e5d46..f2bf85a268b 100644
--- a/TAO/tao/IFR_Client/IFR_BaseC.i
+++ b/TAO/tao/IFR_Client/IFR_BaseC.i
@@ -781,21 +781,21 @@ CORBA::Contained::Description_out::operator-> (void)
 #if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_CONTAINEDSEQ_CI_)
 #define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_CONTAINEDSEQ_CI_
 
-  ACE_INLINE Contained **
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (CORBA::ULong nelems)
+  ACE_INLINE CORBA_Contained **
+  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (CORBA::ULong nelems)
   {
-    Contained **buf = 0;
+    CORBA_Contained **buf = 0;
     
-    ACE_NEW_RETURN (buf, Contained*[nelems], 0);
+    ACE_NEW_RETURN (buf, CORBA_Contained*[nelems], 0);
     
     for (CORBA::ULong i = 0; i < nelems; i++)
-      buf[i] = Contained::_nil ();
+      buf[i] = CORBA_Contained::_nil ();
     
     return buf;
   }
   
   ACE_INLINE void 
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::freebuf (Contained **buffer)
+  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::freebuf (CORBA_Contained **buffer)
   {
     if (buffer == 0)
       return;
@@ -803,36 +803,36 @@ CORBA::Contained::Description_out::operator-> (void)
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (void)
+  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (void)
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (CORBA::ULong maximum)
+  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (CORBA::ULong maximum)
     : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (CORBA::ULong maximum,
+  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (CORBA::ULong maximum,
     CORBA::ULong length,
-    Contained* *value,
+    CORBA_Contained* *value,
     CORBA::Boolean release)
   : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &rhs)
+  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &rhs)
     : TAO_Unbounded_Base_Sequence (rhs)
   {
     if (rhs.buffer_ != 0)
     {
-      Contained **tmp1 = _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (this->maximum_);
-      Contained ** const tmp2 = ACE_reinterpret_cast (Contained ** ACE_CAST_CONST, rhs.buffer_);
+      CORBA_Contained **tmp1 = _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (this->maximum_);
+      CORBA_Contained ** const tmp2 = ACE_reinterpret_cast (CORBA_Contained ** ACE_CAST_CONST, rhs.buffer_);
       
       for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-        tmp1[i] = Contained::_duplicate (tmp2[i]);
+        tmp1[i] = CORBA_Contained::_duplicate (tmp2[i]);
       
       this->buffer_ = tmp1;
     }
@@ -842,20 +842,20 @@ CORBA::Contained::Description_out::operator-> (void)
     }
   }
   
-  ACE_INLINE CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &rhs)
+  ACE_INLINE _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &
+  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &rhs)
   {
     if (this == &rhs)
       return *this;
     
     if (this->release_)
     {
-      Contained **tmp = ACE_reinterpret_cast (Contained **, this->buffer_);
+      CORBA_Contained **tmp = ACE_reinterpret_cast (CORBA_Contained **, this->buffer_);
       
       for (CORBA::ULong i = 0; i < this->length_; ++i)
       {
         CORBA::release (tmp[i]);
-        tmp[i] = Contained::_nil ();
+        tmp[i] = CORBA_Contained::_nil ();
       }
       if (this->maximum_ < rhs.maximum_)
       {
@@ -868,28 +868,28 @@ CORBA::Contained::Description_out::operator-> (void)
     
     TAO_Unbounded_Base_Sequence::operator= (rhs);
     
-    Contained **tmp1 = ACE_reinterpret_cast (Contained **, this->buffer_);
-    Contained ** const tmp2 = ACE_reinterpret_cast (Contained ** ACE_CAST_CONST, rhs.buffer_);
+    CORBA_Contained **tmp1 = ACE_reinterpret_cast (CORBA_Contained **, this->buffer_);
+    CORBA_Contained ** const tmp2 = ACE_reinterpret_cast (CORBA_Contained ** ACE_CAST_CONST, rhs.buffer_);
     
     for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-      tmp1[i] = Contained::_duplicate (tmp2[i]);
+      tmp1[i] = CORBA_Contained::_duplicate (tmp2[i]);
     
     return *this;
   }
   
   ACE_INLINE TAO_Object_Manager<CORBA::Contained,CORBA::Contained_var>
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::operator[] (CORBA::ULong index) const
+  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::operator[] (CORBA::ULong index) const
   // read-write accessor
   {
     ACE_ASSERT (index < this->maximum_);
-    Contained ** const tmp = ACE_reinterpret_cast (Contained ** ACE_CAST_CONST, this->buffer_);
+    CORBA_Contained ** const tmp = ACE_reinterpret_cast (CORBA_Contained ** ACE_CAST_CONST, this->buffer_);
     return TAO_Object_Manager<CORBA::Contained,CORBA::Contained_var> (tmp + index, this->release_);
   }
   
-  ACE_INLINE Contained* *
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::get_buffer (CORBA::Boolean orphan)
+  ACE_INLINE CORBA_Contained* *
+  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::get_buffer (CORBA::Boolean orphan)
   {
-    Contained **result = 0;
+    CORBA_Contained **result = 0;
     if (orphan == 0)
     {
       // We retain ownership.
@@ -901,7 +901,7 @@ CORBA::Contained::Description_out::operator-> (void)
       }
       else
       {
-        result = ACE_reinterpret_cast (Contained**, this->buffer_);
+        result = ACE_reinterpret_cast (CORBA_Contained**, this->buffer_);
       }
     }
     else // if (orphan == 1)
@@ -910,7 +910,7 @@ CORBA::Contained::Description_out::operator-> (void)
       {
         // We set the state back to default and relinquish
         // ownership.
-        result = ACE_reinterpret_cast(Contained**,this->buffer_);
+        result = ACE_reinterpret_cast(CORBA_Contained**,this->buffer_);
         this->maximum_ = 0;
         this->length_ = 0;
         this->buffer_ = 0;
@@ -920,10 +920,10 @@ CORBA::Contained::Description_out::operator-> (void)
     return result;
   }
   
-  ACE_INLINE const Contained* *
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::get_buffer (void) const
+  ACE_INLINE const CORBA_Contained* *
+  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::get_buffer (void) const
   {
-    return ACE_reinterpret_cast(const Contained ** ACE_CAST_CONST, this->buffer_);
+    return ACE_reinterpret_cast(const CORBA_Contained ** ACE_CAST_CONST, this->buffer_);
   }
   
   
@@ -1532,50 +1532,50 @@ CORBA_StructMember_out::operator-> (void)
 #define __TAO_UNBOUNDED_SEQUENCE_CORBA_STRUCTMEMBERSEQ_CI_
 
   // = Static operations.
-  ACE_INLINE StructMember *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (CORBA::ULong size)
+  ACE_INLINE CORBA_StructMember *
+  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
-    StructMember *retval = 0;
-    ACE_NEW_RETURN (retval, StructMember[size], 0);
+    CORBA_StructMember *retval = 0;
+    ACE_NEW_RETURN (retval, CORBA_StructMember[size], 0);
     return retval;
   }
   
-  ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (StructMember *buffer)
+  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (CORBA_StructMember *buffer)
   // Free the sequence.
   {
     delete [] buffer;
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (void) // Default constructor.
+  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (void) // Default constructor.
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
     : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (CORBA::ULong maximum,
+  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (CORBA::ULong maximum,
     CORBA::ULong length,
-    StructMember *data,
+    CORBA_StructMember *data,
     CORBA::Boolean release)
   : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (const _TAO_Unbounded_Sequence_CORBA_StructMemberSeq &rhs)
+  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (const _TAO_Unbounded_Sequence_CORBA_StructMemberSeq &rhs)
   // Copy constructor.
     : TAO_Unbounded_Base_Sequence (rhs)
   {
     if (rhs.buffer_ != 0)
     {
-      StructMember *tmp1 = _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (this->maximum_);
-      StructMember * const tmp2 = ACE_reinterpret_cast (StructMember * ACE_CAST_CONST, rhs.buffer_);
+      CORBA_StructMember *tmp1 = _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (this->maximum_);
+      CORBA_StructMember * const tmp2 = ACE_reinterpret_cast (CORBA_StructMember * ACE_CAST_CONST, rhs.buffer_);
       
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         tmp1[i] = tmp2[i];
@@ -1588,8 +1588,8 @@ CORBA_StructMember_out::operator-> (void)
     }
   }
   
-  ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_StructMemberSeq &rhs)
+  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_StructMemberSeq &
+  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_StructMemberSeq &rhs)
   // Assignment operator.
   {
     if (this == &rhs)
@@ -1600,7 +1600,7 @@ CORBA_StructMember_out::operator-> (void)
       if (this->maximum_ < rhs.maximum_)
       {
         // free the old buffer
-        StructMember *tmp = ACE_reinterpret_cast (StructMember *, this->buffer_);
+        CORBA_StructMember *tmp = ACE_reinterpret_cast (CORBA_StructMember *, this->buffer_);
         _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (tmp);
         this->buffer_ = _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (rhs.maximum_);
       }
@@ -1610,8 +1610,8 @@ CORBA_StructMember_out::operator-> (void)
     
     TAO_Unbounded_Base_Sequence::operator= (rhs);
     
-    StructMember *tmp1 = ACE_reinterpret_cast (StructMember *, this->buffer_);
-    StructMember * const tmp2 = ACE_reinterpret_cast (StructMember * ACE_CAST_CONST, rhs.buffer_);
+    CORBA_StructMember *tmp1 = ACE_reinterpret_cast (CORBA_StructMember *, this->buffer_);
+    CORBA_StructMember * const tmp2 = ACE_reinterpret_cast (CORBA_StructMember * ACE_CAST_CONST, rhs.buffer_);
     
     for (CORBA::ULong i = 0; i < this->length_; ++i)
       tmp1[i] = tmp2[i];
@@ -1620,30 +1620,30 @@ CORBA_StructMember_out::operator-> (void)
   }
   
   // = Accessors.
-  ACE_INLINE StructMember &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::operator[] (CORBA::ULong i)
+  ACE_INLINE CORBA_StructMember &
+  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::operator[] (CORBA::ULong i)
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    StructMember* tmp = ACE_reinterpret_cast(StructMember*,this->buffer_);
+    CORBA_StructMember* tmp = ACE_reinterpret_cast(CORBA_StructMember*,this->buffer_);
     return tmp[i];
   }
   
-  ACE_INLINE const StructMember &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::operator[] (CORBA::ULong i) const
+  ACE_INLINE const CORBA_StructMember &
+  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::operator[] (CORBA::ULong i) const
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    StructMember * const tmp = ACE_reinterpret_cast (StructMember* ACE_CAST_CONST, this->buffer_);
+    CORBA_StructMember * const tmp = ACE_reinterpret_cast (CORBA_StructMember* ACE_CAST_CONST, this->buffer_);
     return tmp[i];
   }
   
   // Implement the TAO_Base_Sequence methods (see Sequence.h)
   
-  ACE_INLINE StructMember *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::get_buffer (CORBA::Boolean orphan)
+  ACE_INLINE CORBA_StructMember *
+  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::get_buffer (CORBA::Boolean orphan)
   {
-    StructMember *result = 0;
+    CORBA_StructMember *result = 0;
     if (orphan == 0)
     {
       // We retain ownership.
@@ -1655,7 +1655,7 @@ CORBA_StructMember_out::operator-> (void)
       }
       else
       {
-        result = ACE_reinterpret_cast (StructMember*, this->buffer_);
+        result = ACE_reinterpret_cast (CORBA_StructMember*, this->buffer_);
       }
     }
     else // if (orphan == 1)
@@ -1664,7 +1664,7 @@ CORBA_StructMember_out::operator-> (void)
       {
         // We set the state back to default and relinquish
         // ownership.
-        result = ACE_reinterpret_cast(StructMember*,this->buffer_);
+        result = ACE_reinterpret_cast(CORBA_StructMember*,this->buffer_);
         this->maximum_ = 0;
         this->length_ = 0;
         this->buffer_ = 0;
@@ -1674,23 +1674,23 @@ CORBA_StructMember_out::operator-> (void)
     return result;
   }
   
-  ACE_INLINE const StructMember *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::get_buffer (void) const
+  ACE_INLINE const CORBA_StructMember *
+  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::get_buffer (void) const
   {
-    return ACE_reinterpret_cast(const StructMember * ACE_CAST_CONST, this->buffer_);
+    return ACE_reinterpret_cast(const CORBA_StructMember * ACE_CAST_CONST, this->buffer_);
   }
   
   ACE_INLINE void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::replace (CORBA::ULong max,
+  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::replace (CORBA::ULong max,
   CORBA::ULong length,
-  StructMember *data,
+  CORBA_StructMember *data,
   CORBA::Boolean release)
   {
     this->maximum_ = max;
     this->length_ = length;
     if (this->buffer_ && this->release_ == 1)
     {
-      StructMember *tmp = ACE_reinterpret_cast(StructMember*,this->buffer_);
+      CORBA_StructMember *tmp = ACE_reinterpret_cast(CORBA_StructMember*,this->buffer_);
       _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (tmp);
     }
     this->buffer_ = data;
@@ -2119,50 +2119,50 @@ CORBA_Initializer_out::operator-> (void)
 #define __TAO_UNBOUNDED_SEQUENCE_CORBA_INITIALIZERSEQ_CI_
 
   // = Static operations.
-  ACE_INLINE Initializer *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (CORBA::ULong size)
+  ACE_INLINE CORBA_Initializer *
+  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
-    Initializer *retval = 0;
-    ACE_NEW_RETURN (retval, Initializer[size], 0);
+    CORBA_Initializer *retval = 0;
+    ACE_NEW_RETURN (retval, CORBA_Initializer[size], 0);
     return retval;
   }
   
-  ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (Initializer *buffer)
+  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (CORBA_Initializer *buffer)
   // Free the sequence.
   {
     delete [] buffer;
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (void) // Default constructor.
+  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (void) // Default constructor.
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
     : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (CORBA::ULong maximum,
+  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (CORBA::ULong maximum,
     CORBA::ULong length,
-    Initializer *data,
+    CORBA_Initializer *data,
     CORBA::Boolean release)
   : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (const _TAO_Unbounded_Sequence_CORBA_InitializerSeq &rhs)
+  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (const _TAO_Unbounded_Sequence_CORBA_InitializerSeq &rhs)
   // Copy constructor.
     : TAO_Unbounded_Base_Sequence (rhs)
   {
     if (rhs.buffer_ != 0)
     {
-      Initializer *tmp1 = _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (this->maximum_);
-      Initializer * const tmp2 = ACE_reinterpret_cast (Initializer * ACE_CAST_CONST, rhs.buffer_);
+      CORBA_Initializer *tmp1 = _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (this->maximum_);
+      CORBA_Initializer * const tmp2 = ACE_reinterpret_cast (CORBA_Initializer * ACE_CAST_CONST, rhs.buffer_);
       
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         tmp1[i] = tmp2[i];
@@ -2175,8 +2175,8 @@ CORBA_Initializer_out::operator-> (void)
     }
   }
   
-  ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_InitializerSeq &rhs)
+  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_InitializerSeq &
+  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_InitializerSeq &rhs)
   // Assignment operator.
   {
     if (this == &rhs)
@@ -2187,7 +2187,7 @@ CORBA_Initializer_out::operator-> (void)
       if (this->maximum_ < rhs.maximum_)
       {
         // free the old buffer
-        Initializer *tmp = ACE_reinterpret_cast (Initializer *, this->buffer_);
+        CORBA_Initializer *tmp = ACE_reinterpret_cast (CORBA_Initializer *, this->buffer_);
         _TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (tmp);
         this->buffer_ = _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (rhs.maximum_);
       }
@@ -2197,8 +2197,8 @@ CORBA_Initializer_out::operator-> (void)
     
     TAO_Unbounded_Base_Sequence::operator= (rhs);
     
-    Initializer *tmp1 = ACE_reinterpret_cast (Initializer *, this->buffer_);
-    Initializer * const tmp2 = ACE_reinterpret_cast (Initializer * ACE_CAST_CONST, rhs.buffer_);
+    CORBA_Initializer *tmp1 = ACE_reinterpret_cast (CORBA_Initializer *, this->buffer_);
+    CORBA_Initializer * const tmp2 = ACE_reinterpret_cast (CORBA_Initializer * ACE_CAST_CONST, rhs.buffer_);
     
     for (CORBA::ULong i = 0; i < this->length_; ++i)
       tmp1[i] = tmp2[i];
@@ -2207,30 +2207,30 @@ CORBA_Initializer_out::operator-> (void)
   }
   
   // = Accessors.
-  ACE_INLINE Initializer &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::operator[] (CORBA::ULong i)
+  ACE_INLINE CORBA_Initializer &
+  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::operator[] (CORBA::ULong i)
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    Initializer* tmp = ACE_reinterpret_cast(Initializer*,this->buffer_);
+    CORBA_Initializer* tmp = ACE_reinterpret_cast(CORBA_Initializer*,this->buffer_);
     return tmp[i];
   }
   
-  ACE_INLINE const Initializer &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::operator[] (CORBA::ULong i) const
+  ACE_INLINE const CORBA_Initializer &
+  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::operator[] (CORBA::ULong i) const
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    Initializer * const tmp = ACE_reinterpret_cast (Initializer* ACE_CAST_CONST, this->buffer_);
+    CORBA_Initializer * const tmp = ACE_reinterpret_cast (CORBA_Initializer* ACE_CAST_CONST, this->buffer_);
     return tmp[i];
   }
   
   // Implement the TAO_Base_Sequence methods (see Sequence.h)
   
-  ACE_INLINE Initializer *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::get_buffer (CORBA::Boolean orphan)
+  ACE_INLINE CORBA_Initializer *
+  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::get_buffer (CORBA::Boolean orphan)
   {
-    Initializer *result = 0;
+    CORBA_Initializer *result = 0;
     if (orphan == 0)
     {
       // We retain ownership.
@@ -2242,7 +2242,7 @@ CORBA_Initializer_out::operator-> (void)
       }
       else
       {
-        result = ACE_reinterpret_cast (Initializer*, this->buffer_);
+        result = ACE_reinterpret_cast (CORBA_Initializer*, this->buffer_);
       }
     }
     else // if (orphan == 1)
@@ -2251,7 +2251,7 @@ CORBA_Initializer_out::operator-> (void)
       {
         // We set the state back to default and relinquish
         // ownership.
-        result = ACE_reinterpret_cast(Initializer*,this->buffer_);
+        result = ACE_reinterpret_cast(CORBA_Initializer*,this->buffer_);
         this->maximum_ = 0;
         this->length_ = 0;
         this->buffer_ = 0;
@@ -2261,23 +2261,23 @@ CORBA_Initializer_out::operator-> (void)
     return result;
   }
   
-  ACE_INLINE const Initializer *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::get_buffer (void) const
+  ACE_INLINE const CORBA_Initializer *
+  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::get_buffer (void) const
   {
-    return ACE_reinterpret_cast(const Initializer * ACE_CAST_CONST, this->buffer_);
+    return ACE_reinterpret_cast(const CORBA_Initializer * ACE_CAST_CONST, this->buffer_);
   }
   
   ACE_INLINE void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::replace (CORBA::ULong max,
+  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::replace (CORBA::ULong max,
   CORBA::ULong length,
-  Initializer *data,
+  CORBA_Initializer *data,
   CORBA::Boolean release)
   {
     this->maximum_ = max;
     this->length_ = length;
     if (this->buffer_ && this->release_ == 1)
     {
-      Initializer *tmp = ACE_reinterpret_cast(Initializer*,this->buffer_);
+      CORBA_Initializer *tmp = ACE_reinterpret_cast(CORBA_Initializer*,this->buffer_);
       _TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (tmp);
     }
     this->buffer_ = data;
@@ -2706,50 +2706,50 @@ CORBA_UnionMember_out::operator-> (void)
 #define __TAO_UNBOUNDED_SEQUENCE_CORBA_UNIONMEMBERSEQ_CI_
 
   // = Static operations.
-  ACE_INLINE UnionMember *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (CORBA::ULong size)
+  ACE_INLINE CORBA_UnionMember *
+  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
-    UnionMember *retval = 0;
-    ACE_NEW_RETURN (retval, UnionMember[size], 0);
+    CORBA_UnionMember *retval = 0;
+    ACE_NEW_RETURN (retval, CORBA_UnionMember[size], 0);
     return retval;
   }
   
-  ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (UnionMember *buffer)
+  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (CORBA_UnionMember *buffer)
   // Free the sequence.
   {
     delete [] buffer;
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (void) // Default constructor.
+  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (void) // Default constructor.
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
     : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (CORBA::ULong maximum,
+  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (CORBA::ULong maximum,
     CORBA::ULong length,
-    UnionMember *data,
+    CORBA_UnionMember *data,
     CORBA::Boolean release)
   : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (const _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &rhs)
+  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (const _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &rhs)
   // Copy constructor.
     : TAO_Unbounded_Base_Sequence (rhs)
   {
     if (rhs.buffer_ != 0)
     {
-      UnionMember *tmp1 = _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (this->maximum_);
-      UnionMember * const tmp2 = ACE_reinterpret_cast (UnionMember * ACE_CAST_CONST, rhs.buffer_);
+      CORBA_UnionMember *tmp1 = _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (this->maximum_);
+      CORBA_UnionMember * const tmp2 = ACE_reinterpret_cast (CORBA_UnionMember * ACE_CAST_CONST, rhs.buffer_);
       
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         tmp1[i] = tmp2[i];
@@ -2762,8 +2762,8 @@ CORBA_UnionMember_out::operator-> (void)
     }
   }
   
-  ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &rhs)
+  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &
+  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &rhs)
   // Assignment operator.
   {
     if (this == &rhs)
@@ -2774,7 +2774,7 @@ CORBA_UnionMember_out::operator-> (void)
       if (this->maximum_ < rhs.maximum_)
       {
         // free the old buffer
-        UnionMember *tmp = ACE_reinterpret_cast (UnionMember *, this->buffer_);
+        CORBA_UnionMember *tmp = ACE_reinterpret_cast (CORBA_UnionMember *, this->buffer_);
         _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (tmp);
         this->buffer_ = _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (rhs.maximum_);
       }
@@ -2784,8 +2784,8 @@ CORBA_UnionMember_out::operator-> (void)
     
     TAO_Unbounded_Base_Sequence::operator= (rhs);
     
-    UnionMember *tmp1 = ACE_reinterpret_cast (UnionMember *, this->buffer_);
-    UnionMember * const tmp2 = ACE_reinterpret_cast (UnionMember * ACE_CAST_CONST, rhs.buffer_);
+    CORBA_UnionMember *tmp1 = ACE_reinterpret_cast (CORBA_UnionMember *, this->buffer_);
+    CORBA_UnionMember * const tmp2 = ACE_reinterpret_cast (CORBA_UnionMember * ACE_CAST_CONST, rhs.buffer_);
     
     for (CORBA::ULong i = 0; i < this->length_; ++i)
       tmp1[i] = tmp2[i];
@@ -2794,30 +2794,30 @@ CORBA_UnionMember_out::operator-> (void)
   }
   
   // = Accessors.
-  ACE_INLINE UnionMember &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::operator[] (CORBA::ULong i)
+  ACE_INLINE CORBA_UnionMember &
+  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::operator[] (CORBA::ULong i)
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    UnionMember* tmp = ACE_reinterpret_cast(UnionMember*,this->buffer_);
+    CORBA_UnionMember* tmp = ACE_reinterpret_cast(CORBA_UnionMember*,this->buffer_);
     return tmp[i];
   }
   
-  ACE_INLINE const UnionMember &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::operator[] (CORBA::ULong i) const
+  ACE_INLINE const CORBA_UnionMember &
+  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::operator[] (CORBA::ULong i) const
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    UnionMember * const tmp = ACE_reinterpret_cast (UnionMember* ACE_CAST_CONST, this->buffer_);
+    CORBA_UnionMember * const tmp = ACE_reinterpret_cast (CORBA_UnionMember* ACE_CAST_CONST, this->buffer_);
     return tmp[i];
   }
   
   // Implement the TAO_Base_Sequence methods (see Sequence.h)
   
-  ACE_INLINE UnionMember *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::get_buffer (CORBA::Boolean orphan)
+  ACE_INLINE CORBA_UnionMember *
+  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::get_buffer (CORBA::Boolean orphan)
   {
-    UnionMember *result = 0;
+    CORBA_UnionMember *result = 0;
     if (orphan == 0)
     {
       // We retain ownership.
@@ -2829,7 +2829,7 @@ CORBA_UnionMember_out::operator-> (void)
       }
       else
       {
-        result = ACE_reinterpret_cast (UnionMember*, this->buffer_);
+        result = ACE_reinterpret_cast (CORBA_UnionMember*, this->buffer_);
       }
     }
     else // if (orphan == 1)
@@ -2838,7 +2838,7 @@ CORBA_UnionMember_out::operator-> (void)
       {
         // We set the state back to default and relinquish
         // ownership.
-        result = ACE_reinterpret_cast(UnionMember*,this->buffer_);
+        result = ACE_reinterpret_cast(CORBA_UnionMember*,this->buffer_);
         this->maximum_ = 0;
         this->length_ = 0;
         this->buffer_ = 0;
@@ -2848,23 +2848,23 @@ CORBA_UnionMember_out::operator-> (void)
     return result;
   }
   
-  ACE_INLINE const UnionMember *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::get_buffer (void) const
+  ACE_INLINE const CORBA_UnionMember *
+  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::get_buffer (void) const
   {
-    return ACE_reinterpret_cast(const UnionMember * ACE_CAST_CONST, this->buffer_);
+    return ACE_reinterpret_cast(const CORBA_UnionMember * ACE_CAST_CONST, this->buffer_);
   }
   
   ACE_INLINE void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::replace (CORBA::ULong max,
+  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::replace (CORBA::ULong max,
   CORBA::ULong length,
-  UnionMember *data,
+  CORBA_UnionMember *data,
   CORBA::Boolean release)
   {
     this->maximum_ = max;
     this->length_ = length;
     if (this->buffer_ && this->release_ == 1)
     {
-      UnionMember *tmp = ACE_reinterpret_cast(UnionMember*,this->buffer_);
+      CORBA_UnionMember *tmp = ACE_reinterpret_cast(CORBA_UnionMember*,this->buffer_);
       _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (tmp);
     }
     this->buffer_ = data;
@@ -3505,7 +3505,7 @@ CORBA::Container::Description_out::operator-> (void)
 #define __TAO_UNBOUNDED_SEQUENCE_CORBA_CONTAINER_DESCRIPTIONSEQ_CI_
 
   // = Static operations.
-  ACE_INLINE Description *
+  ACE_INLINE CORBA::Container::Description *
   CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
@@ -3593,30 +3593,30 @@ CORBA::Container::Description_out::operator-> (void)
   }
   
   // = Accessors.
-  ACE_INLINE Description &
+  ACE_INLINE CORBA::Container::Description &
   CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::operator[] (CORBA::ULong i)
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    Description* tmp = ACE_reinterpret_cast(Description*,this->buffer_);
+    CORBA::Container::Description* tmp = ACE_reinterpret_cast(CORBA::Container::Description*,this->buffer_);
     return tmp[i];
   }
   
-  ACE_INLINE const Description &
+  ACE_INLINE const CORBA::Container::Description &
   CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::operator[] (CORBA::ULong i) const
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    Description * const tmp = ACE_reinterpret_cast (Description* ACE_CAST_CONST, this->buffer_);
+    CORBA::Container::Description * const tmp = ACE_reinterpret_cast (CORBA::Container::Description* ACE_CAST_CONST, this->buffer_);
     return tmp[i];
   }
   
   // Implement the TAO_Base_Sequence methods (see Sequence.h)
   
-  ACE_INLINE Description *
+  ACE_INLINE CORBA::Container::Description *
   CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::get_buffer (CORBA::Boolean orphan)
   {
-    Description *result = 0;
+    CORBA::Container::Description *result = 0;
     if (orphan == 0)
     {
       // We retain ownership.
@@ -3628,7 +3628,7 @@ CORBA::Container::Description_out::operator-> (void)
       }
       else
       {
-        result = ACE_reinterpret_cast (Description*, this->buffer_);
+        result = ACE_reinterpret_cast (CORBA::Container::Description*, this->buffer_);
       }
     }
     else // if (orphan == 1)
@@ -3637,7 +3637,7 @@ CORBA::Container::Description_out::operator-> (void)
       {
         // We set the state back to default and relinquish
         // ownership.
-        result = ACE_reinterpret_cast(Description*,this->buffer_);
+        result = ACE_reinterpret_cast(CORBA::Container::Description*,this->buffer_);
         this->maximum_ = 0;
         this->length_ = 0;
         this->buffer_ = 0;
@@ -3647,23 +3647,23 @@ CORBA::Container::Description_out::operator-> (void)
     return result;
   }
   
-  ACE_INLINE const Description *
+  ACE_INLINE const CORBA::Container::Description *
   CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::get_buffer (void) const
   {
-    return ACE_reinterpret_cast(const Description * ACE_CAST_CONST, this->buffer_);
+    return ACE_reinterpret_cast(const CORBA::Container::Description * ACE_CAST_CONST, this->buffer_);
   }
   
   ACE_INLINE void
   CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::replace (CORBA::ULong max,
   CORBA::ULong length,
-  Description *data,
+  CORBA::Container::Description *data,
   CORBA::Boolean release)
   {
     this->maximum_ = max;
     this->length_ = length;
     if (this->buffer_ && this->release_ == 1)
     {
-      Description *tmp = ACE_reinterpret_cast(Description*,this->buffer_);
+      CORBA::Container::Description *tmp = ACE_reinterpret_cast(CORBA::Container::Description*,this->buffer_);
       _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::freebuf (tmp);
     }
     this->buffer_ = data;
diff --git a/TAO/tao/IFR_Client/IFR_BasicC.cpp b/TAO/tao/IFR_Client/IFR_BasicC.cpp
index 4a7ffeec116..6382ea57d6b 100644
--- a/TAO/tao/IFR_Client/IFR_BasicC.cpp
+++ b/TAO/tao/IFR_Client/IFR_BasicC.cpp
@@ -2491,7 +2491,7 @@ CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_local_interface::
 
   // The Base_Sequence functions, please see tao/Sequence.h
   void
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_allocate_buffer (CORBA::ULong length)
+  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_allocate_buffer (CORBA::ULong length)
   {
     CORBA::InterfaceDef **tmp = 0;
     tmp = _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (length);
@@ -2513,7 +2513,7 @@ CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_local_interface::
   }
   
   void
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_deallocate_buffer (void)
+  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
@@ -2527,13 +2527,13 @@ CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_local_interface::
     this->buffer_ = 0;
   }
   
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (void)
+  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (void)
   {
     this->_deallocate_buffer ();
   }
   
   void
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+ _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
   {
     CORBA::InterfaceDef **tmp = ACE_reinterpret_cast (CORBA::InterfaceDef**, this->buffer_);
     
@@ -2544,7 +2544,7 @@ CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_local_interface::
     }
   }
   void 
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_downcast (
+  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_downcast (
       void* target,
       CORBA_Object *src,
       CORBA_Environment &ACE_TRY_ENV
@@ -2556,7 +2556,7 @@ CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_local_interface::
   }
 
   CORBA_Object*
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_upcast (void *src) const
+  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_upcast (void *src) const
   {
     CORBA::InterfaceDef **tmp = ACE_static_cast (CORBA::InterfaceDef**, src);
     return *tmp;
@@ -2621,7 +2621,7 @@ void CORBA_InterfaceDefSeq::_tao_any_destructor (void *x)
 
   // The Base_Sequence functions, please see tao/Sequence.h
   void
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_allocate_buffer (CORBA::ULong length)
+  _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_allocate_buffer (CORBA::ULong length)
   {
     CORBA::AbstractInterfaceDef **tmp = 0;
     tmp = _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::allocbuf (length);
@@ -2643,7 +2643,7 @@ void CORBA_InterfaceDefSeq::_tao_any_destructor (void *x)
   }
   
   void
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_deallocate_buffer (void)
+  _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
@@ -2657,13 +2657,13 @@ void CORBA_InterfaceDefSeq::_tao_any_destructor (void *x)
     this->buffer_ = 0;
   }
   
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (void)
+  _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (void)
   {
     this->_deallocate_buffer ();
   }
   
   void
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
   {
     CORBA::AbstractInterfaceDef **tmp = ACE_reinterpret_cast (CORBA::AbstractInterfaceDef**, this->buffer_);
     
@@ -2674,7 +2674,7 @@ void CORBA_InterfaceDefSeq::_tao_any_destructor (void *x)
     }
   }
   void 
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_downcast (
+  _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_downcast (
       void* target,
       CORBA_Object *src,
       CORBA_Environment &ACE_TRY_ENV
@@ -2686,7 +2686,7 @@ void CORBA_InterfaceDefSeq::_tao_any_destructor (void *x)
   }
 
   CORBA_Object*
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_upcast (void *src) const
+  _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_upcast (void *src) const
   {
     CORBA::AbstractInterfaceDef **tmp = ACE_static_cast (CORBA::AbstractInterfaceDef**, src);
     return *tmp;
@@ -2751,7 +2751,7 @@ void CORBA_AbstractInterfaceDefSeq::_tao_any_destructor (void *x)
 
   // The Base_Sequence functions, please see tao/Sequence.h
   void
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_allocate_buffer (CORBA::ULong length)
+  _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_allocate_buffer (CORBA::ULong length)
   {
     CORBA::LocalInterfaceDef **tmp = 0;
     tmp = _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::allocbuf (length);
@@ -2773,7 +2773,7 @@ void CORBA_AbstractInterfaceDefSeq::_tao_any_destructor (void *x)
   }
   
   void
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_deallocate_buffer (void)
+  _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
@@ -2787,13 +2787,13 @@ void CORBA_AbstractInterfaceDefSeq::_tao_any_destructor (void *x)
     this->buffer_ = 0;
   }
   
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (void)
+  _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (void)
   {
     this->_deallocate_buffer ();
   }
   
   void
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
   {
     CORBA::LocalInterfaceDef **tmp = ACE_reinterpret_cast (CORBA::LocalInterfaceDef**, this->buffer_);
     
@@ -2804,7 +2804,7 @@ void CORBA_AbstractInterfaceDefSeq::_tao_any_destructor (void *x)
     }
   }
   void 
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_downcast (
+  _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_downcast (
       void* target,
       CORBA_Object *src,
       CORBA_Environment &ACE_TRY_ENV
@@ -2816,7 +2816,7 @@ void CORBA_AbstractInterfaceDefSeq::_tao_any_destructor (void *x)
   }
 
   CORBA_Object*
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_upcast (void *src) const
+  _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_upcast (void *src) const
   {
     CORBA::LocalInterfaceDef **tmp = ACE_static_cast (CORBA::LocalInterfaceDef**, src);
     return *tmp;
@@ -4152,13 +4152,13 @@ _TAO_Repository_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::Repository::Repository (int collocated)
+CORBA_Repository::CORBA_Repository (int collocated)
 {
   this->CORBA_Repository_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::Repository::~Repository (void)
+CORBA_Repository::~CORBA_Repository (void)
 {}
 
 void
@@ -5067,13 +5067,13 @@ _TAO_ModuleDef_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::ModuleDef::ModuleDef (int collocated)
+CORBA_ModuleDef::CORBA_ModuleDef (int collocated)
 {
   this->CORBA_ModuleDef_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::ModuleDef::~ModuleDef (void)
+CORBA_ModuleDef::~CORBA_ModuleDef (void)
 {}
 
 void
@@ -6103,13 +6103,13 @@ _TAO_ConstantDef_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::ConstantDef::ConstantDef (int collocated)
+CORBA_ConstantDef::CORBA_ConstantDef (int collocated)
 {
   this->CORBA_ConstantDef_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::ConstantDef::~ConstantDef (void)
+CORBA_ConstantDef::~CORBA_ConstantDef (void)
 {}
 
 void
@@ -7020,13 +7020,13 @@ _TAO_StructDef_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::StructDef::StructDef (int collocated)
+CORBA_StructDef::CORBA_StructDef (int collocated)
 {
   this->CORBA_StructDef_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::StructDef::~StructDef (void)
+CORBA_StructDef::~CORBA_StructDef (void)
 {}
 
 void
@@ -8223,13 +8223,13 @@ _TAO_UnionDef_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::UnionDef::UnionDef (int collocated)
+CORBA_UnionDef::CORBA_UnionDef (int collocated)
 {
   this->CORBA_UnionDef_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::UnionDef::~UnionDef (void)
+CORBA_UnionDef::~CORBA_UnionDef (void)
 {}
 
 void
@@ -9175,13 +9175,13 @@ _TAO_EnumDef_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::EnumDef::EnumDef (int collocated)
+CORBA_EnumDef::CORBA_EnumDef (int collocated)
 {
   this->CORBA_EnumDef_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::EnumDef::~EnumDef (void)
+CORBA_EnumDef::~CORBA_EnumDef (void)
 {}
 
 void
@@ -9890,13 +9890,13 @@ _TAO_AliasDef_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::AliasDef::AliasDef (int collocated)
+CORBA_AliasDef::CORBA_AliasDef (int collocated)
 {
   this->CORBA_AliasDef_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::AliasDef::~AliasDef (void)
+CORBA_AliasDef::~CORBA_AliasDef (void)
 {}
 
 void
@@ -10293,13 +10293,13 @@ _TAO_NativeDef_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::NativeDef::NativeDef (int collocated)
+CORBA_NativeDef::CORBA_NativeDef (int collocated)
 {
   this->CORBA_NativeDef_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::NativeDef::~NativeDef (void)
+CORBA_NativeDef::~CORBA_NativeDef (void)
 {}
 
 void
@@ -10706,13 +10706,13 @@ _TAO_PrimitiveDef_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::PrimitiveDef::PrimitiveDef (int collocated)
+CORBA_PrimitiveDef::CORBA_PrimitiveDef (int collocated)
 {
   this->CORBA_PrimitiveDef_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::PrimitiveDef::~PrimitiveDef (void)
+CORBA_PrimitiveDef::~CORBA_PrimitiveDef (void)
 {}
 
 void
@@ -11318,13 +11318,13 @@ _TAO_StringDef_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::StringDef::StringDef (int collocated)
+CORBA_StringDef::CORBA_StringDef (int collocated)
 {
   this->CORBA_StringDef_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::StringDef::~StringDef (void)
+CORBA_StringDef::~CORBA_StringDef (void)
 {}
 
 void
@@ -12004,13 +12004,13 @@ _TAO_WstringDef_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::WstringDef::WstringDef (int collocated)
+CORBA_WstringDef::CORBA_WstringDef (int collocated)
 {
   this->CORBA_WstringDef_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::WstringDef::~WstringDef (void)
+CORBA_WstringDef::~CORBA_WstringDef (void)
 {}
 
 void
@@ -13162,13 +13162,13 @@ _TAO_SequenceDef_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::SequenceDef::SequenceDef (int collocated)
+CORBA_SequenceDef::CORBA_SequenceDef (int collocated)
 {
   this->CORBA_SequenceDef_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::SequenceDef::~SequenceDef (void)
+CORBA_SequenceDef::~CORBA_SequenceDef (void)
 {}
 
 void
@@ -14541,13 +14541,13 @@ _TAO_ArrayDef_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::ArrayDef::ArrayDef (int collocated)
+CORBA_ArrayDef::CORBA_ArrayDef (int collocated)
 {
   this->CORBA_ArrayDef_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::ArrayDef::~ArrayDef (void)
+CORBA_ArrayDef::~CORBA_ArrayDef (void)
 {}
 
 void
@@ -15611,13 +15611,13 @@ _TAO_ExceptionDef_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::ExceptionDef::ExceptionDef (int collocated)
+CORBA_ExceptionDef::CORBA_ExceptionDef (int collocated)
 {
   this->CORBA_ExceptionDef_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::ExceptionDef::~ExceptionDef (void)
+CORBA_ExceptionDef::~CORBA_ExceptionDef (void)
 {}
 
 void
@@ -16024,7 +16024,7 @@ void CORBA::ExceptionDescription::_tao_any_destructor (void *x)
 
   // The Base_Sequence functions, please see tao/Sequence.h
   void
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_allocate_buffer (CORBA::ULong length)
+  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_allocate_buffer (CORBA::ULong length)
   {
     CORBA::ExceptionDef **tmp = 0;
     tmp = _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (length);
@@ -16046,7 +16046,7 @@ void CORBA::ExceptionDescription::_tao_any_destructor (void *x)
   }
   
   void
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_deallocate_buffer (void)
+  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
@@ -16060,13 +16060,13 @@ void CORBA::ExceptionDescription::_tao_any_destructor (void *x)
     this->buffer_ = 0;
   }
   
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (void)
+  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (void)
   {
     this->_deallocate_buffer ();
   }
   
   void
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+ _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
   {
     CORBA::ExceptionDef **tmp = ACE_reinterpret_cast (CORBA::ExceptionDef**, this->buffer_);
     
@@ -16077,7 +16077,7 @@ void CORBA::ExceptionDescription::_tao_any_destructor (void *x)
     }
   }
   void 
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_downcast (
+ _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_downcast (
       void* target,
       CORBA_Object *src,
       CORBA_Environment &ACE_TRY_ENV
@@ -16089,7 +16089,7 @@ void CORBA::ExceptionDescription::_tao_any_destructor (void *x)
   }
 
   CORBA_Object*
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_upcast (void *src) const
+  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_upcast (void *src) const
   {
     CORBA::ExceptionDef **tmp = ACE_static_cast (CORBA::ExceptionDef**, src);
     return *tmp;
@@ -16153,7 +16153,7 @@ void CORBA_ExceptionDefSeq::_tao_any_destructor (void *x)
 #define __TAO_UNBOUNDED_SEQUENCE_CORBA_EXCDESCRIPTIONSEQ_CS_
 
   void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_allocate_buffer (CORBA::ULong length)
+  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_allocate_buffer (CORBA::ULong length)
   {
     CORBA::ExceptionDescription* tmp = 0;
     tmp = _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (length);
@@ -16173,7 +16173,7 @@ void CORBA_ExceptionDefSeq::_tao_any_destructor (void *x)
   }
   
   void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_deallocate_buffer (void)
+  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
@@ -16184,7 +16184,7 @@ void CORBA_ExceptionDefSeq::_tao_any_destructor (void *x)
     this->buffer_ = 0;
   } 
   
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (void) // Dtor.
+  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (void) // Dtor.
   {
     this->_deallocate_buffer ();
   }
@@ -17090,13 +17090,13 @@ _TAO_AttributeDef_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::AttributeDef::AttributeDef (int collocated)
+CORBA_AttributeDef::CORBA_AttributeDef (int collocated)
 {
   this->CORBA_AttributeDef_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::AttributeDef::~AttributeDef (void)
+CORBA_AttributeDef::~CORBA_AttributeDef (void)
 {}
 
 void
@@ -17641,7 +17641,7 @@ void CORBA::ParameterDescription::_tao_any_destructor (void *x)
 #define __TAO_UNBOUNDED_SEQUENCE_CORBA_PARDESCRIPTIONSEQ_CS_
 
   void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_allocate_buffer (CORBA::ULong length)
+  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_allocate_buffer (CORBA::ULong length)
   {
     CORBA::ParameterDescription* tmp = 0;
     tmp = _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (length);
@@ -17661,7 +17661,7 @@ void CORBA::ParameterDescription::_tao_any_destructor (void *x)
   }
   
   void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_deallocate_buffer (void)
+ _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
@@ -17672,7 +17672,7 @@ void CORBA::ParameterDescription::_tao_any_destructor (void *x)
     this->buffer_ = 0;
   } 
   
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (void) // Dtor.
+  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (void) // Dtor.
   {
     this->_deallocate_buffer ();
   }
@@ -19564,13 +19564,13 @@ _TAO_OperationDef_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::OperationDef::OperationDef (int collocated)
+CORBA_OperationDef::CORBA_OperationDef (int collocated)
 {
   this->CORBA_OperationDef_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::OperationDef::~OperationDef (void)
+CORBA_OperationDef::~CORBA_OperationDef (void)
 {}
 
 void
@@ -20600,7 +20600,7 @@ void CORBA_RepositoryIdSeq::_tao_any_destructor (void *x)
 #define __TAO_UNBOUNDED_SEQUENCE_CORBA_OPDESCRIPTIONSEQ_CS_
 
   void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_allocate_buffer (CORBA::ULong length)
+  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_allocate_buffer (CORBA::ULong length)
   {
     CORBA::OperationDescription* tmp = 0;
     tmp = _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (length);
@@ -20620,7 +20620,7 @@ void CORBA_RepositoryIdSeq::_tao_any_destructor (void *x)
   }
   
   void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_deallocate_buffer (void)
+  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
@@ -20631,7 +20631,7 @@ void CORBA_RepositoryIdSeq::_tao_any_destructor (void *x)
     this->buffer_ = 0;
   } 
   
-  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (void) // Dtor.
+  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (void) // Dtor.
   {
     this->_deallocate_buffer ();
   }
@@ -20695,7 +20695,7 @@ void CORBA_OpDescriptionSeq::_tao_any_destructor (void *x)
 #define __TAO_UNBOUNDED_SEQUENCE_CORBA_ATTRDESCRIPTIONSEQ_CS_
 
   void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_allocate_buffer (CORBA::ULong length)
+  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_allocate_buffer (CORBA::ULong length)
   {
     CORBA::AttributeDescription* tmp = 0;
     tmp = _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (length);
@@ -20715,7 +20715,7 @@ void CORBA_OpDescriptionSeq::_tao_any_destructor (void *x)
   }
   
   void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_deallocate_buffer (void)
+  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
@@ -20726,7 +20726,7 @@ void CORBA_OpDescriptionSeq::_tao_any_destructor (void *x)
     this->buffer_ = 0;
   } 
   
-  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (void) // Dtor.
+  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (void) // Dtor.
   {
     this->_deallocate_buffer ();
   }
@@ -21870,13 +21870,13 @@ _TAO_InterfaceDef_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::InterfaceDef::InterfaceDef (int collocated)
+CORBA_InterfaceDef::CORBA_InterfaceDef (int collocated)
 {
   this->CORBA_InterfaceDef_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::InterfaceDef::~InterfaceDef (void)
+CORBA_InterfaceDef::~CORBA_InterfaceDef (void)
 {}
 
 void
@@ -23641,13 +23641,13 @@ _TAO_AbstractInterfaceDef_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::AbstractInterfaceDef::AbstractInterfaceDef (int collocated)
+CORBA_AbstractInterfaceDef::CORBA_AbstractInterfaceDef (int collocated)
 {
   this->CORBA_AbstractInterfaceDef_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::AbstractInterfaceDef::~AbstractInterfaceDef (void)
+CORBA_AbstractInterfaceDef::~CORBA_AbstractInterfaceDef (void)
 {}
 
 void
@@ -23909,13 +23909,13 @@ _TAO_LocalInterfaceDef_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::LocalInterfaceDef::LocalInterfaceDef (int collocated)
+CORBA_LocalInterfaceDef::CORBA_LocalInterfaceDef (int collocated)
 {
   this->CORBA_LocalInterfaceDef_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::LocalInterfaceDef::~LocalInterfaceDef (void)
+CORBA_LocalInterfaceDef::~CORBA_LocalInterfaceDef (void)
 {}
 
 void
diff --git a/TAO/tao/IFR_Client/IFR_BasicC.h b/TAO/tao/IFR_Client/IFR_BasicC.h
index c9f23caae16..7f48cb9bc77 100644
--- a/TAO/tao/IFR_Client/IFR_BasicC.h
+++ b/TAO/tao/IFR_Client/IFR_BasicC.h
@@ -23,13 +23,12 @@
 #define TAO_IDL_IFR_BASICC_H
 
 #include "ace/pre.h"
+#include "IFR_BaseC.h"
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
-#include "IFR_BaseC.h"
-
 #if defined (TAO_EXPORT_MACRO)
 #undef TAO_EXPORT_MACRO
 #endif
@@ -11835,45 +11834,6 @@ TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Abs
 TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::LocalInterfaceDef_ptr);
 TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::LocalInterfaceDef *&);
 
-#ifndef __ACE_INLINE__
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::PrimitiveKind &); // 
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::PrimitiveKind &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::Repository_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::Repository_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ModuleDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ModuleDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ModuleDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ModuleDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ConstantDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ConstantDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ConstantDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ConstantDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::StructDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::StructDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::UnionDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::UnionDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::EnumDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::EnumDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::AliasDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::AliasDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::NativeDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::NativeDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::PrimitiveDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::PrimitiveDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::StringDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::StringDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::WstringDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::WstringDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::SequenceDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::SequenceDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ArrayDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ArrayDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ExceptionDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ExceptionDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ExceptionDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ExceptionDescription &);
-
 // **************************************************************
 // CDR operators for classes moved from IFR_BaseC.h
 
@@ -11923,6 +11883,45 @@ TAO_IFR_Client_Export CORBA::Boolean operator>> (
 
 // **********************************************************
 
+#ifndef __ACE_INLINE__
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::PrimitiveKind &); // 
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::PrimitiveKind &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::Repository_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::Repository_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ModuleDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ModuleDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ModuleDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ModuleDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ConstantDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ConstantDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ConstantDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ConstantDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::StructDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::StructDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::UnionDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::UnionDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::EnumDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::EnumDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::AliasDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::AliasDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::NativeDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::NativeDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::PrimitiveDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::PrimitiveDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::StringDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::StringDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::WstringDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::WstringDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::SequenceDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::SequenceDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ArrayDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ArrayDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ExceptionDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ExceptionDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ExceptionDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ExceptionDescription &);
+
 #if !defined _TAO_CDR_OP_CORBA_ExceptionDefSeq_H_
 #define _TAO_CDR_OP_CORBA_ExceptionDefSeq_H_
 
diff --git a/TAO/tao/IFR_Client/IFR_BasicC.i b/TAO/tao/IFR_Client/IFR_BasicC.i
index e37507f627e..d51384effc6 100644
--- a/TAO/tao/IFR_Client/IFR_BasicC.i
+++ b/TAO/tao/IFR_Client/IFR_BasicC.i
@@ -29,7 +29,7 @@
 #define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_INTERFACEDEFSEQ_CI_
 
   ACE_INLINE CORBA::InterfaceDef **
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (CORBA::ULong nelems)
+  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (CORBA::ULong nelems)
   {
     CORBA::InterfaceDef **buf = 0;
     
@@ -42,7 +42,7 @@
   }
   
   ACE_INLINE void 
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::freebuf (CORBA::InterfaceDef **buffer)
+  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::freebuf (CORBA::InterfaceDef **buffer)
   {
     if (buffer == 0)
       return;
@@ -50,18 +50,18 @@
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (void)
+  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (void)
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (CORBA::ULong maximum)
+  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (CORBA::ULong maximum)
     : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (CORBA::ULong maximum,
+  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (CORBA::ULong maximum,
     CORBA::ULong length,
     CORBA::InterfaceDef* *value,
     CORBA::Boolean release)
@@ -70,7 +70,7 @@
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &rhs)
+  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &rhs)
     : TAO_Unbounded_Base_Sequence (rhs)
   {
     if (rhs.buffer_ != 0)
@@ -89,8 +89,8 @@
     }
   }
   
-  ACE_INLINE CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &rhs)
+  ACE_INLINE _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &
+  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &rhs)
   {
     if (this == &rhs)
       return *this;
@@ -125,7 +125,7 @@
   }
   
   ACE_INLINE TAO_Object_Manager<CORBA::InterfaceDef,CORBA::InterfaceDef_var>
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::operator[] (CORBA::ULong index) const
+  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::operator[] (CORBA::ULong index) const
   // read-write accessor
   {
     ACE_ASSERT (index < this->maximum_);
@@ -134,7 +134,7 @@
   }
   
   ACE_INLINE CORBA::InterfaceDef* *
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::get_buffer (CORBA::Boolean orphan)
+  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::get_buffer (CORBA::Boolean orphan)
   {
     CORBA::InterfaceDef **result = 0;
     if (orphan == 0)
@@ -168,7 +168,7 @@
   }
   
   ACE_INLINE const CORBA::InterfaceDef* *
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::get_buffer (void) const
+  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::get_buffer (void) const
   {
     return ACE_reinterpret_cast(const CORBA::InterfaceDef ** ACE_CAST_CONST, this->buffer_);
   }
@@ -396,7 +396,7 @@ CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index)
 #define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_ABSTRACTINTERFACEDEFSEQ_CI_
 
   ACE_INLINE CORBA::AbstractInterfaceDef **
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::allocbuf (CORBA::ULong nelems)
+  _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::allocbuf (CORBA::ULong nelems)
   {
     CORBA::AbstractInterfaceDef **buf = 0;
     
@@ -409,7 +409,7 @@ CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index)
   }
   
   ACE_INLINE void 
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::freebuf (CORBA::AbstractInterfaceDef **buffer)
+ _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::freebuf (CORBA::AbstractInterfaceDef **buffer)
   {
     if (buffer == 0)
       return;
@@ -417,18 +417,18 @@ CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index)
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (void)
+ _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (void)
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (CORBA::ULong maximum)
+ _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (CORBA::ULong maximum)
     : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (CORBA::ULong maximum,
+ _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (CORBA::ULong maximum,
     CORBA::ULong length,
     CORBA::AbstractInterfaceDef* *value,
     CORBA::Boolean release)
@@ -437,7 +437,7 @@ CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index)
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq &rhs)
+ _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq &rhs)
     : TAO_Unbounded_Base_Sequence (rhs)
   {
     if (rhs.buffer_ != 0)
@@ -456,8 +456,8 @@ CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index)
     }
   }
   
-  ACE_INLINE CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq &
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq &rhs)
+  ACE_INLINE _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq &
+ _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq &rhs)
   {
     if (this == &rhs)
       return *this;
@@ -492,7 +492,7 @@ CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index)
   }
   
   ACE_INLINE TAO_Object_Manager<CORBA::AbstractInterfaceDef,CORBA::AbstractInterfaceDef_var>
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::operator[] (CORBA::ULong index) const
+ _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::operator[] (CORBA::ULong index) const
   // read-write accessor
   {
     ACE_ASSERT (index < this->maximum_);
@@ -501,7 +501,7 @@ CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index)
   }
   
   ACE_INLINE CORBA::AbstractInterfaceDef* *
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::get_buffer (CORBA::Boolean orphan)
+ _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::get_buffer (CORBA::Boolean orphan)
   {
     CORBA::AbstractInterfaceDef **result = 0;
     if (orphan == 0)
@@ -535,7 +535,7 @@ CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index)
   }
   
   ACE_INLINE const CORBA::AbstractInterfaceDef* *
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::get_buffer (void) const
+  _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::get_buffer (void) const
   {
     return ACE_reinterpret_cast(const CORBA::AbstractInterfaceDef ** ACE_CAST_CONST, this->buffer_);
   }
@@ -763,7 +763,7 @@ CORBA_AbstractInterfaceDefSeq_out::operator[] (CORBA::ULong index)
 #define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_LOCALINTERFACEDEFSEQ_CI_
 
   ACE_INLINE CORBA::LocalInterfaceDef **
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::allocbuf (CORBA::ULong nelems)
+ _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::allocbuf (CORBA::ULong nelems)
   {
     CORBA::LocalInterfaceDef **buf = 0;
     
@@ -776,7 +776,7 @@ CORBA_AbstractInterfaceDefSeq_out::operator[] (CORBA::ULong index)
   }
   
   ACE_INLINE void 
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::freebuf (CORBA::LocalInterfaceDef **buffer)
+ _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::freebuf (CORBA::LocalInterfaceDef **buffer)
   {
     if (buffer == 0)
       return;
@@ -784,18 +784,18 @@ CORBA_AbstractInterfaceDefSeq_out::operator[] (CORBA::ULong index)
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (void)
+ _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (void)
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (CORBA::ULong maximum)
+  _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (CORBA::ULong maximum)
     : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (CORBA::ULong maximum,
+  _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (CORBA::ULong maximum,
     CORBA::ULong length,
     CORBA::LocalInterfaceDef* *value,
     CORBA::Boolean release)
@@ -804,7 +804,7 @@ CORBA_AbstractInterfaceDefSeq_out::operator[] (CORBA::ULong index)
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq &rhs)
+ _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq &rhs)
     : TAO_Unbounded_Base_Sequence (rhs)
   {
     if (rhs.buffer_ != 0)
@@ -823,8 +823,8 @@ CORBA_AbstractInterfaceDefSeq_out::operator[] (CORBA::ULong index)
     }
   }
   
-  ACE_INLINE CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq &
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq &rhs)
+  ACE_INLINE _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq &
+  _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq &rhs)
   {
     if (this == &rhs)
       return *this;
@@ -859,7 +859,7 @@ CORBA_AbstractInterfaceDefSeq_out::operator[] (CORBA::ULong index)
   }
   
   ACE_INLINE TAO_Object_Manager<CORBA::LocalInterfaceDef,CORBA::LocalInterfaceDef_var>
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::operator[] (CORBA::ULong index) const
+ _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::operator[] (CORBA::ULong index) const
   // read-write accessor
   {
     ACE_ASSERT (index < this->maximum_);
@@ -868,7 +868,7 @@ CORBA_AbstractInterfaceDefSeq_out::operator[] (CORBA::ULong index)
   }
   
   ACE_INLINE CORBA::LocalInterfaceDef* *
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::get_buffer (CORBA::Boolean orphan)
+  _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::get_buffer (CORBA::Boolean orphan)
   {
     CORBA::LocalInterfaceDef **result = 0;
     if (orphan == 0)
@@ -902,7 +902,7 @@ CORBA_AbstractInterfaceDefSeq_out::operator[] (CORBA::ULong index)
   }
   
   ACE_INLINE const CORBA::LocalInterfaceDef* *
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::get_buffer (void) const
+ _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::get_buffer (void) const
   {
     return ACE_reinterpret_cast(const CORBA::LocalInterfaceDef ** ACE_CAST_CONST, this->buffer_);
   }
@@ -4334,7 +4334,7 @@ CORBA_ExceptionDescription_out::operator-> (void)
 #define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_EXCEPTIONDEFSEQ_CI_
 
   ACE_INLINE CORBA::ExceptionDef **
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (CORBA::ULong nelems)
+ _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (CORBA::ULong nelems)
   {
     CORBA::ExceptionDef **buf = 0;
     
@@ -4347,7 +4347,7 @@ CORBA_ExceptionDescription_out::operator-> (void)
   }
   
   ACE_INLINE void 
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::freebuf (CORBA::ExceptionDef **buffer)
+  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::freebuf (CORBA::ExceptionDef **buffer)
   {
     if (buffer == 0)
       return;
@@ -4355,18 +4355,18 @@ CORBA_ExceptionDescription_out::operator-> (void)
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (void)
+  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (void)
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (CORBA::ULong maximum)
+  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (CORBA::ULong maximum)
     : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (CORBA::ULong maximum,
+  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (CORBA::ULong maximum,
     CORBA::ULong length,
     CORBA::ExceptionDef* *value,
     CORBA::Boolean release)
@@ -4375,7 +4375,7 @@ CORBA_ExceptionDescription_out::operator-> (void)
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &rhs)
+  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &rhs)
     : TAO_Unbounded_Base_Sequence (rhs)
   {
     if (rhs.buffer_ != 0)
@@ -4394,8 +4394,8 @@ CORBA_ExceptionDescription_out::operator-> (void)
     }
   }
   
-  ACE_INLINE CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &rhs)
+  ACE_INLINE _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &
+  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &rhs)
   {
     if (this == &rhs)
       return *this;
@@ -4430,7 +4430,7 @@ CORBA_ExceptionDescription_out::operator-> (void)
   }
   
   ACE_INLINE TAO_Object_Manager<CORBA::ExceptionDef,CORBA::ExceptionDef_var>
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::operator[] (CORBA::ULong index) const
+  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::operator[] (CORBA::ULong index) const
   // read-write accessor
   {
     ACE_ASSERT (index < this->maximum_);
@@ -4439,7 +4439,7 @@ CORBA_ExceptionDescription_out::operator-> (void)
   }
   
   ACE_INLINE CORBA::ExceptionDef* *
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::get_buffer (CORBA::Boolean orphan)
+  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::get_buffer (CORBA::Boolean orphan)
   {
     CORBA::ExceptionDef **result = 0;
     if (orphan == 0)
@@ -4473,7 +4473,7 @@ CORBA_ExceptionDescription_out::operator-> (void)
   }
   
   ACE_INLINE const CORBA::ExceptionDef* *
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::get_buffer (void) const
+  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::get_buffer (void) const
   {
     return ACE_reinterpret_cast(const CORBA::ExceptionDef ** ACE_CAST_CONST, this->buffer_);
   }
@@ -4703,7 +4703,7 @@ CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index)
 
   // = Static operations.
   ACE_INLINE CORBA::ExceptionDescription *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (CORBA::ULong size)
+  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
     CORBA::ExceptionDescription *retval = 0;
@@ -4711,25 +4711,25 @@ CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index)
     return retval;
   }
   
-  ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::freebuf (CORBA::ExceptionDescription *buffer)
+  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::freebuf (CORBA::ExceptionDescription *buffer)
   // Free the sequence.
   {
     delete [] buffer;
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (void) // Default constructor.
+  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (void) // Default constructor.
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
     : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (CORBA::ULong maximum,
+  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (CORBA::ULong maximum,
     CORBA::ULong length,
     CORBA::ExceptionDescription *data,
     CORBA::Boolean release)
@@ -4738,7 +4738,7 @@ CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index)
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &rhs)
+  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &rhs)
   // Copy constructor.
     : TAO_Unbounded_Base_Sequence (rhs)
   {
@@ -4758,8 +4758,8 @@ CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index)
     }
   }
   
-  ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &rhs)
+  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &
+  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &rhs)
   // Assignment operator.
   {
     if (this == &rhs)
@@ -4791,7 +4791,7 @@ CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index)
   
   // = Accessors.
   ACE_INLINE CORBA::ExceptionDescription &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::operator[] (CORBA::ULong i)
+  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::operator[] (CORBA::ULong i)
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
@@ -4800,7 +4800,7 @@ CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index)
   }
   
   ACE_INLINE const CORBA::ExceptionDescription &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::operator[] (CORBA::ULong i) const
+  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::operator[] (CORBA::ULong i) const
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
@@ -4811,7 +4811,7 @@ CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index)
   // Implement the TAO_Base_Sequence methods (see Sequence.h)
   
   ACE_INLINE CORBA::ExceptionDescription *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::get_buffer (CORBA::Boolean orphan)
+  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::get_buffer (CORBA::Boolean orphan)
   {
     CORBA::ExceptionDescription *result = 0;
     if (orphan == 0)
@@ -4845,13 +4845,13 @@ CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index)
   }
   
   ACE_INLINE const CORBA::ExceptionDescription *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::get_buffer (void) const
+  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::get_buffer (void) const
   {
     return ACE_reinterpret_cast(const CORBA::ExceptionDescription * ACE_CAST_CONST, this->buffer_);
   }
   
   ACE_INLINE void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::replace (CORBA::ULong max,
+  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::replace (CORBA::ULong max,
   CORBA::ULong length,
   CORBA::ExceptionDescription *data,
   CORBA::Boolean release)
@@ -5670,7 +5670,7 @@ CORBA_ParameterDescription_out::operator-> (void)
 
   // = Static operations.
   ACE_INLINE CORBA::ParameterDescription *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (CORBA::ULong size)
+  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
     CORBA::ParameterDescription *retval = 0;
@@ -5678,25 +5678,25 @@ CORBA_ParameterDescription_out::operator-> (void)
     return retval;
   }
   
-  ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::freebuf (CORBA::ParameterDescription *buffer)
+  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::freebuf (CORBA::ParameterDescription *buffer)
   // Free the sequence.
   {
     delete [] buffer;
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (void) // Default constructor.
+  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (void) // Default constructor.
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
     : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (CORBA::ULong maximum,
+  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (CORBA::ULong maximum,
     CORBA::ULong length,
     CORBA::ParameterDescription *data,
     CORBA::Boolean release)
@@ -5705,7 +5705,7 @@ CORBA_ParameterDescription_out::operator-> (void)
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &rhs)
+  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &rhs)
   // Copy constructor.
     : TAO_Unbounded_Base_Sequence (rhs)
   {
@@ -5725,8 +5725,8 @@ CORBA_ParameterDescription_out::operator-> (void)
     }
   }
   
-  ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &rhs)
+  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &
+  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &rhs)
   // Assignment operator.
   {
     if (this == &rhs)
@@ -5758,7 +5758,7 @@ CORBA_ParameterDescription_out::operator-> (void)
   
   // = Accessors.
   ACE_INLINE CORBA::ParameterDescription &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::operator[] (CORBA::ULong i)
+  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::operator[] (CORBA::ULong i)
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
@@ -5767,7 +5767,7 @@ CORBA_ParameterDescription_out::operator-> (void)
   }
   
   ACE_INLINE const CORBA::ParameterDescription &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::operator[] (CORBA::ULong i) const
+  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::operator[] (CORBA::ULong i) const
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
@@ -5778,7 +5778,7 @@ CORBA_ParameterDescription_out::operator-> (void)
   // Implement the TAO_Base_Sequence methods (see Sequence.h)
   
   ACE_INLINE CORBA::ParameterDescription *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::get_buffer (CORBA::Boolean orphan)
+  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::get_buffer (CORBA::Boolean orphan)
   {
     CORBA::ParameterDescription *result = 0;
     if (orphan == 0)
@@ -5812,13 +5812,13 @@ CORBA_ParameterDescription_out::operator-> (void)
   }
   
   ACE_INLINE const CORBA::ParameterDescription *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::get_buffer (void) const
+  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::get_buffer (void) const
   {
     return ACE_reinterpret_cast(const CORBA::ParameterDescription * ACE_CAST_CONST, this->buffer_);
   }
   
   ACE_INLINE void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::replace (CORBA::ULong max,
+  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::replace (CORBA::ULong max,
   CORBA::ULong length,
   CORBA::ParameterDescription *data,
   CORBA::Boolean release)
@@ -6868,7 +6868,7 @@ CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index)
 
   // = Static operations.
   ACE_INLINE CORBA::OperationDescription *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (CORBA::ULong size)
+  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
     CORBA::OperationDescription *retval = 0;
@@ -6876,25 +6876,25 @@ CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index)
     return retval;
   }
   
-  ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::freebuf (CORBA::OperationDescription *buffer)
+  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::freebuf (CORBA::OperationDescription *buffer)
   // Free the sequence.
   {
     delete [] buffer;
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (void) // Default constructor.
+  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (void) // Default constructor.
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
     : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (CORBA::ULong maximum,
+  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (CORBA::ULong maximum,
     CORBA::ULong length,
     CORBA::OperationDescription *data,
     CORBA::Boolean release)
@@ -6903,7 +6903,7 @@ CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index)
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &rhs)
+  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &rhs)
   // Copy constructor.
     : TAO_Unbounded_Base_Sequence (rhs)
   {
@@ -6923,8 +6923,8 @@ CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index)
     }
   }
   
-  ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &rhs)
+  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &
+  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &rhs)
   // Assignment operator.
   {
     if (this == &rhs)
@@ -6956,7 +6956,7 @@ CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index)
   
   // = Accessors.
   ACE_INLINE CORBA::OperationDescription &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::operator[] (CORBA::ULong i)
+  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::operator[] (CORBA::ULong i)
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
@@ -6965,7 +6965,7 @@ CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index)
   }
   
   ACE_INLINE const CORBA::OperationDescription &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::operator[] (CORBA::ULong i) const
+  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::operator[] (CORBA::ULong i) const
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
@@ -6976,7 +6976,7 @@ CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index)
   // Implement the TAO_Base_Sequence methods (see Sequence.h)
   
   ACE_INLINE CORBA::OperationDescription *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::get_buffer (CORBA::Boolean orphan)
+  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::get_buffer (CORBA::Boolean orphan)
   {
     CORBA::OperationDescription *result = 0;
     if (orphan == 0)
@@ -7010,13 +7010,13 @@ CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index)
   }
   
   ACE_INLINE const CORBA::OperationDescription *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::get_buffer (void) const
+  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::get_buffer (void) const
   {
     return ACE_reinterpret_cast(const CORBA::OperationDescription * ACE_CAST_CONST, this->buffer_);
   }
   
   ACE_INLINE void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::replace (CORBA::ULong max,
+  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::replace (CORBA::ULong max,
   CORBA::ULong length,
   CORBA::OperationDescription *data,
   CORBA::Boolean release)
@@ -7262,7 +7262,7 @@ CORBA_OpDescriptionSeq_out::operator[] (CORBA::ULong index)
 
   // = Static operations.
   ACE_INLINE CORBA::AttributeDescription *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (CORBA::ULong size)
+  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
     CORBA::AttributeDescription *retval = 0;
@@ -7270,25 +7270,25 @@ CORBA_OpDescriptionSeq_out::operator[] (CORBA::ULong index)
     return retval;
   }
   
-  ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::freebuf (CORBA::AttributeDescription *buffer)
+  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::freebuf (CORBA::AttributeDescription *buffer)
   // Free the sequence.
   {
     delete [] buffer;
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (void) // Default constructor.
+  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (void) // Default constructor.
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
     : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (CORBA::ULong maximum,
+  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (CORBA::ULong maximum,
     CORBA::ULong length,
     CORBA::AttributeDescription *data,
     CORBA::Boolean release)
@@ -7297,7 +7297,7 @@ CORBA_OpDescriptionSeq_out::operator[] (CORBA::ULong index)
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &rhs)
+  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &rhs)
   // Copy constructor.
     : TAO_Unbounded_Base_Sequence (rhs)
   {
@@ -7317,8 +7317,8 @@ CORBA_OpDescriptionSeq_out::operator[] (CORBA::ULong index)
     }
   }
   
-  ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &rhs)
+  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &
+  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &rhs)
   // Assignment operator.
   {
     if (this == &rhs)
@@ -7350,7 +7350,7 @@ CORBA_OpDescriptionSeq_out::operator[] (CORBA::ULong index)
   
   // = Accessors.
   ACE_INLINE CORBA::AttributeDescription &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::operator[] (CORBA::ULong i)
+  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::operator[] (CORBA::ULong i)
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
@@ -7359,7 +7359,7 @@ CORBA_OpDescriptionSeq_out::operator[] (CORBA::ULong index)
   }
   
   ACE_INLINE const CORBA::AttributeDescription &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::operator[] (CORBA::ULong i) const
+  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::operator[] (CORBA::ULong i) const
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
@@ -7370,7 +7370,7 @@ CORBA_OpDescriptionSeq_out::operator[] (CORBA::ULong index)
   // Implement the TAO_Base_Sequence methods (see Sequence.h)
   
   ACE_INLINE CORBA::AttributeDescription *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::get_buffer (CORBA::Boolean orphan)
+  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::get_buffer (CORBA::Boolean orphan)
   {
     CORBA::AttributeDescription *result = 0;
     if (orphan == 0)
@@ -7404,13 +7404,13 @@ CORBA_OpDescriptionSeq_out::operator[] (CORBA::ULong index)
   }
   
   ACE_INLINE const CORBA::AttributeDescription *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::get_buffer (void) const
+  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::get_buffer (void) const
   {
     return ACE_reinterpret_cast(const CORBA::AttributeDescription * ACE_CAST_CONST, this->buffer_);
   }
   
   ACE_INLINE void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::replace (CORBA::ULong max,
+  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::replace (CORBA::ULong max,
   CORBA::ULong length,
   CORBA::AttributeDescription *data,
   CORBA::Boolean release)
diff --git a/TAO/tao/IFR_Client/IFR_ExtendedC.cpp b/TAO/tao/IFR_Client/IFR_ExtendedC.cpp
index 45a9975bc61..f6cb1bfc861 100644
--- a/TAO/tao/IFR_Client/IFR_ExtendedC.cpp
+++ b/TAO/tao/IFR_Client/IFR_ExtendedC.cpp
@@ -43,7 +43,7 @@
 
   // The Base_Sequence functions, please see tao/Sequence.h
   void
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_allocate_buffer (CORBA::ULong length)
+  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_allocate_buffer (CORBA::ULong length)
   {
     CORBA::ValueDef **tmp = 0;
     tmp = _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (length);
@@ -65,7 +65,7 @@
   }
   
   void
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_deallocate_buffer (void)
+  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
@@ -79,13 +79,13 @@
     this->buffer_ = 0;
   }
   
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (void)
+  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (void)
   {
     this->_deallocate_buffer ();
   }
   
   void
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+ _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
   {
     CORBA::ValueDef **tmp = ACE_reinterpret_cast (CORBA::ValueDef**, this->buffer_);
     
@@ -96,7 +96,7 @@
     }
   }
   void 
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_downcast (
+ _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_downcast (
       void* target,
       CORBA_Object *src,
       CORBA_Environment &ACE_TRY_ENV
@@ -108,7 +108,7 @@
   }
 
   CORBA_Object*
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_upcast (void *src) const
+ _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_upcast (void *src) const
   {
     CORBA::ValueDef **tmp = ACE_static_cast (CORBA::ValueDef**, src);
     return *tmp;
@@ -1527,13 +1527,13 @@ _TAO_FixedDef_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::FixedDef::FixedDef (int collocated)
+CORBA_FixedDef::CORBA_FixedDef (int collocated)
 {
   this->CORBA_FixedDef_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::FixedDef::~FixedDef (void)
+CORBA_FixedDef::~CORBA_FixedDef (void)
 {}
 
 void
@@ -1997,7 +1997,7 @@ void CORBA::ValueMember::_tao_any_destructor (void *x)
 #define __TAO_UNBOUNDED_SEQUENCE_CORBA_VALUEMEMBERSEQ_CS_
 
   void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_allocate_buffer (CORBA::ULong length)
+  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_allocate_buffer (CORBA::ULong length)
   {
     CORBA::ValueMember* tmp = 0;
     tmp = _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (length);
@@ -2017,7 +2017,7 @@ void CORBA::ValueMember::_tao_any_destructor (void *x)
   }
   
   void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_deallocate_buffer (void)
+  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
@@ -2028,7 +2028,7 @@ void CORBA::ValueMember::_tao_any_destructor (void *x)
     this->buffer_ = 0;
   } 
   
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::~_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (void) // Dtor.
+  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::~_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (void) // Dtor.
   {
     this->_deallocate_buffer ();
   }
@@ -2934,13 +2934,13 @@ _TAO_ValueMemberDef_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::ValueMemberDef::ValueMemberDef (int collocated)
+CORBA_ValueMemberDef::CORBA_ValueMemberDef (int collocated)
 {
   this->CORBA_ValueMemberDef_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::ValueMemberDef::~ValueMemberDef (void)
+CORBA_ValueMemberDef::~CORBA_ValueMemberDef (void)
 {}
 
 void
@@ -6603,13 +6603,13 @@ _TAO_ValueDef_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::ValueDef::ValueDef (int collocated)
+CORBA_ValueDef::CORBA_ValueDef (int collocated)
 {
   this->CORBA_ValueDef_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::ValueDef::~ValueDef (void)
+CORBA_ValueDef::~CORBA_ValueDef (void)
 {}
 
 void
@@ -10145,13 +10145,13 @@ _TAO_ValueBoxDef_Remote_Proxy_Broker::select_proxy (
 
 
 // default constructor
-CORBA::ValueBoxDef::ValueBoxDef (int collocated)
+CORBA_ValueBoxDef::CORBA_ValueBoxDef (int collocated)
 {
   this->CORBA_ValueBoxDef_setup_collocation (collocated);
 }
 
 // destructor
-CORBA::ValueBoxDef::~ValueBoxDef (void)
+CORBA_ValueBoxDef::~CORBA_ValueBoxDef (void)
 {}
 
 void
diff --git a/TAO/tao/IFR_Client/IFR_ExtendedC.h b/TAO/tao/IFR_Client/IFR_ExtendedC.h
index d529f9319cb..ce32c47633a 100644
--- a/TAO/tao/IFR_Client/IFR_ExtendedC.h
+++ b/TAO/tao/IFR_Client/IFR_ExtendedC.h
@@ -23,13 +23,12 @@
 #define TAO_IDL_IFR_EXTENDEDC_H
 
 #include "ace/pre.h"
+#include "IFR_BasicC.h"
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
-#include "IFR_BasicC.h"
-
 #if defined (TAO_EXPORT_MACRO)
 #undef TAO_EXPORT_MACRO
 #endif
@@ -3766,8 +3765,6 @@ TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORB
 TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ValueBoxDef_ptr);
 TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueBoxDef *&);
 
-#ifndef __ACE_INLINE__
-
 // **************************************************************
 // CDR operators for class moved from IFR_BaseC.h
 
@@ -3787,6 +3784,8 @@ TAO_IFR_Client_Export CORBA::Boolean operator>> (
 
 // **************************************************************
 
+#ifndef __ACE_INLINE__
+
 TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::FixedDef_ptr );
 TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::FixedDef_ptr &);
 TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ValueMember &);
diff --git a/TAO/tao/IFR_Client/IFR_ExtendedC.i b/TAO/tao/IFR_Client/IFR_ExtendedC.i
index ea9fef81789..0a05122927c 100644
--- a/TAO/tao/IFR_Client/IFR_ExtendedC.i
+++ b/TAO/tao/IFR_Client/IFR_ExtendedC.i
@@ -28,7 +28,7 @@
 #define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_VALUEDEFSEQ_CI_
 
   ACE_INLINE CORBA::ValueDef **
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (CORBA::ULong nelems)
+ _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (CORBA::ULong nelems)
   {
     CORBA::ValueDef **buf = 0;
     
@@ -41,7 +41,7 @@
   }
   
   ACE_INLINE void 
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::freebuf (CORBA::ValueDef **buffer)
+  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::freebuf (CORBA::ValueDef **buffer)
   {
     if (buffer == 0)
       return;
@@ -49,18 +49,18 @@
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (void)
+  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (void)
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (CORBA::ULong maximum)
+  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (CORBA::ULong maximum)
     : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (CORBA::ULong maximum,
+  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (CORBA::ULong maximum,
     CORBA::ULong length,
     CORBA::ValueDef* *value,
     CORBA::Boolean release)
@@ -69,7 +69,7 @@
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &rhs)
+  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &rhs)
     : TAO_Unbounded_Base_Sequence (rhs)
   {
     if (rhs.buffer_ != 0)
@@ -88,8 +88,8 @@
     }
   }
   
-  ACE_INLINE CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &rhs)
+  ACE_INLINE _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &
+  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &rhs)
   {
     if (this == &rhs)
       return *this;
@@ -124,7 +124,7 @@
   }
   
   ACE_INLINE TAO_Object_Manager<CORBA::ValueDef,CORBA::ValueDef_var>
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::operator[] (CORBA::ULong index) const
+  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::operator[] (CORBA::ULong index) const
   // read-write accessor
   {
     ACE_ASSERT (index < this->maximum_);
@@ -133,7 +133,7 @@
   }
   
   ACE_INLINE CORBA::ValueDef* *
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::get_buffer (CORBA::Boolean orphan)
+ _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::get_buffer (CORBA::Boolean orphan)
   {
     CORBA::ValueDef **result = 0;
     if (orphan == 0)
@@ -167,7 +167,7 @@
   }
   
   ACE_INLINE const CORBA::ValueDef* *
-  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::get_buffer (void) const
+ _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::get_buffer (void) const
   {
     return ACE_reinterpret_cast(const CORBA::ValueDef ** ACE_CAST_CONST, this->buffer_);
   }
@@ -778,7 +778,7 @@ CORBA_ValueMember_out::operator-> (void)
 
   // = Static operations.
   ACE_INLINE CORBA::ValueMember *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (CORBA::ULong size)
+  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
     CORBA::ValueMember *retval = 0;
@@ -786,25 +786,25 @@ CORBA_ValueMember_out::operator-> (void)
     return retval;
   }
   
-  ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::freebuf (CORBA::ValueMember *buffer)
+  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::freebuf (CORBA::ValueMember *buffer)
   // Free the sequence.
   {
     delete [] buffer;
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (void) // Default constructor.
+  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (void) // Default constructor.
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
     : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (CORBA::ULong maximum,
+  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (CORBA::ULong maximum,
     CORBA::ULong length,
     CORBA::ValueMember *data,
     CORBA::Boolean release)
@@ -813,7 +813,7 @@ CORBA_ValueMember_out::operator-> (void)
   }
   
   ACE_INLINE
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (const _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &rhs)
+  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (const _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &rhs)
   // Copy constructor.
     : TAO_Unbounded_Base_Sequence (rhs)
   {
@@ -833,8 +833,8 @@ CORBA_ValueMember_out::operator-> (void)
     }
   }
   
-  ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &rhs)
+  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &
+  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &rhs)
   // Assignment operator.
   {
     if (this == &rhs)
@@ -866,7 +866,7 @@ CORBA_ValueMember_out::operator-> (void)
   
   // = Accessors.
   ACE_INLINE CORBA::ValueMember &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::operator[] (CORBA::ULong i)
+  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::operator[] (CORBA::ULong i)
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
@@ -875,7 +875,7 @@ CORBA_ValueMember_out::operator-> (void)
   }
   
   ACE_INLINE const CORBA::ValueMember &
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::operator[] (CORBA::ULong i) const
+  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::operator[] (CORBA::ULong i) const
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
@@ -886,7 +886,7 @@ CORBA_ValueMember_out::operator-> (void)
   // Implement the TAO_Base_Sequence methods (see Sequence.h)
   
   ACE_INLINE CORBA::ValueMember *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::get_buffer (CORBA::Boolean orphan)
+  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::get_buffer (CORBA::Boolean orphan)
   {
     CORBA::ValueMember *result = 0;
     if (orphan == 0)
@@ -920,13 +920,13 @@ CORBA_ValueMember_out::operator-> (void)
   }
   
   ACE_INLINE const CORBA::ValueMember *
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::get_buffer (void) const
+  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::get_buffer (void) const
   {
     return ACE_reinterpret_cast(const CORBA::ValueMember * ACE_CAST_CONST, this->buffer_);
   }
   
   ACE_INLINE void
-  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::replace (CORBA::ULong max,
+  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::replace (CORBA::ULong max,
   CORBA::ULong length,
   CORBA::ValueMember *data,
   CORBA::Boolean release)