AbstractBase.*

48 files changed, 4819 insertions, 4702 deletions

diff --git a/TAO/tao/CORBA_String.cpp b/TAO/tao/CORBA_String.cpp
index ad39e775b6b..f141b3f20ca 100644
--- a/TAO/tao/CORBA_String.cpp
+++ b/TAO/tao/CORBA_String.cpp
@@ -13,7 +13,7 @@ ACE_RCSID (tao,
 // String utility support; this needs to be integrated with the ORB's
 // own memory allocation subsystem.
 
-CORBA_String_var::CORBA_String_var (char *p)
+CORBA::String_var::String_var (char *p)
   : ptr_ (p)
 {
   // NOTE: According to the CORBA spec this string must *not* be
@@ -21,19 +21,19 @@ CORBA_String_var::CORBA_String_var (char *p)
   // calling code.  argument is consumed. p should never be NULL
 }
 
-CORBA_String_var::CORBA_String_var (const CORBA_String_var& r)
+CORBA::String_var::String_var (const CORBA::String_var& r)
 {
   this->ptr_ = CORBA::string_dup (r.ptr_);
 }
 
-CORBA_String_var::~CORBA_String_var (void)
+CORBA::String_var::~String_var (void)
 {
   CORBA::string_free (this->ptr_);
   this->ptr_ = 0;
 }
 
-CORBA_String_var &
-CORBA_String_var::operator= (char *p)
+CORBA::String_var &
+CORBA::String_var::operator= (char *p)
 {
   if (this->ptr_ != p)
     {
@@ -43,8 +43,8 @@ CORBA_String_var::operator= (char *p)
   return *this;
 }
 
-CORBA_String_var &
-CORBA_String_var::operator= (const char *p)
+CORBA::String_var &
+CORBA::String_var::operator= (const char *p)
 {
   CORBA::string_free (this->ptr_);
 
@@ -52,8 +52,8 @@ CORBA_String_var::operator= (const char *p)
   return *this;
 }
 
-CORBA_String_var &
-CORBA_String_var::operator= (const CORBA_String_var& r)
+CORBA::String_var &
+CORBA::String_var::operator= (const CORBA::String_var& r)
 {
   if (this != &r)
     {
@@ -65,7 +65,7 @@ CORBA_String_var::operator= (const CORBA_String_var& r)
 
 // ****************************************************************
 
-CORBA_WString_var::CORBA_WString_var (CORBA::WChar *p)
+CORBA::WString_var::WString_var (CORBA::WChar *p)
   : ptr_ (p)
 {
   // NOTE: According to the CORBA spec this string must *not* be
@@ -73,19 +73,19 @@ CORBA_WString_var::CORBA_WString_var (CORBA::WChar *p)
   // calling code.  argument is consumed. p should never be NULL
 }
 
-CORBA_WString_var::CORBA_WString_var (const CORBA_WString_var& r)
+CORBA::WString_var::WString_var (const CORBA::WString_var& r)
 {
   this->ptr_ = CORBA::wstring_dup (r.ptr_);
 }
 
-CORBA_WString_var::~CORBA_WString_var (void)
+CORBA::WString_var::~WString_var (void)
 {
   CORBA::wstring_free (this->ptr_);
   this->ptr_ = 0;
 }
 
-CORBA_WString_var &
-CORBA_WString_var::operator= (CORBA::WChar *p)
+CORBA::WString_var &
+CORBA::WString_var::operator= (CORBA::WChar *p)
 {
   if (this->ptr_ != p)
     {
@@ -95,8 +95,8 @@ CORBA_WString_var::operator= (CORBA::WChar *p)
   return *this;
 }
 
-CORBA_WString_var &
-CORBA_WString_var::operator= (const CORBA::WChar *p)
+CORBA::WString_var &
+CORBA::WString_var::operator= (const CORBA::WChar *p)
 {
   CORBA::wstring_free (this->ptr_);
 
@@ -104,8 +104,8 @@ CORBA_WString_var::operator= (const CORBA::WChar *p)
   return *this;
 }
 
-CORBA_WString_var &
-CORBA_WString_var::operator= (const CORBA_WString_var& r)
+CORBA::WString_var &
+CORBA::WString_var::operator= (const CORBA::WString_var& r)
 {
   if (this != &r)
     {
@@ -162,7 +162,7 @@ operator>> (istream &is, CORBA::String_out &so)
 ostream &
 operator<< (ostream &os, const CORBA::WString_var &wsv)
 {
-  CORBA::ULong len = ACE_OS::wslen (wsv.in ());
+  const CORBA::ULong len = ACE_OS::wslen (wsv.in ());
 
   for (CORBA::ULong i = 0; i < len; ++i)
     {
@@ -177,7 +177,7 @@ operator>> (istream &is, CORBA::WString_var &wsv)
 {
   is.seekg (0, ios::end);
   // @@ is.tellg()/sizeof(CORBA::WChar) instead?
-  CORBA::ULong len = is.tellg ();
+  const CORBA::ULong len = is.tellg ();
   wsv = CORBA::wstring_alloc (len);
   is.seekg (0, ios::beg);
 
@@ -201,7 +201,7 @@ ostream &
 operator<< (ostream &os, CORBA::WString_out &wso)
 {
   CORBA::WChar *tmp = wso.ptr ();
-  CORBA::ULong len = ACE_OS::wslen (tmp);
+  const CORBA::ULong len = ACE_OS::wslen (tmp);
 
   for (CORBA::ULong i = 0; i < len; ++i)
     {
@@ -216,7 +216,7 @@ operator>> (istream &is, CORBA::WString_out &wso)
 {
   is.seekg (0, ios::end);
   // @@ is.tellg()/sizeof(CORBA::WChar) instead?
-  CORBA::ULong len = is.tellg ();
+  const CORBA::ULong len = is.tellg ();
   wso = CORBA::wstring_alloc (len);
   is.seekg (0, ios::beg);
 
diff --git a/TAO/tao/CORBA_String.h b/TAO/tao/CORBA_String.h
index ce660e6f8fd..827c68aaf88 100644
--- a/TAO/tao/CORBA_String.h
+++ b/TAO/tao/CORBA_String.h
@@ -1,20 +1,17 @@
 // -*- C++ -*-
 
-
 //=============================================================================
 /**
  *  @file    CORBA_String.h
  *
  *  $Id$
  *
- *   Header file for the CORBA string types.
- *
+ *  Header file for the CORBA string types.
  *
+ *  @author DOC Group at Wash U, UCI, and Vanderbilt U.
  */
 //=============================================================================
 
-
-
 #ifndef TAO_CORBA_STRING_H
 #define TAO_CORBA_STRING_H
 
@@ -33,228 +30,233 @@
 #include "ace/streams.h"
 #endif /* ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION */
 
-/**
- * @class CORBA_String_var
- *
- * @brief CORBA_String var class. Provides automatic deallocation of storage
- * for the string once it goes out of scope.
- */
-class TAO_Export CORBA_String_var
+namespace CORBA
 {
-public:
-  /// default constructor.
-  CORBA_String_var (void);
+  /**
+   * @class String_var
+   *
+   * @brief CORBA::String var class.
+   *
+   * Provides automatic deallocation of storage for the string once it
+   * goes out of scope.
+   */
+  class TAO_Export String_var
+  {
+  public:
+  /// Default constructor.
+    String_var (void);
 
-  /// constructor, owns p.
-  CORBA_String_var (char *p);
+    /// Constructor, owns p.
+    String_var (char *p);
 
-  /// constructor. Makes a copy of p.
-  CORBA_String_var (const char *p);
+    /// constructor. Makes a copy of p.
+    String_var (const char *p);
 
-  /// copy constructor.
-  CORBA_String_var (const CORBA_String_var &s);
+    /// copy constructor.
+    String_var (const String_var &s);
 
-  /// destructor.
-  ~CORBA_String_var (void);
+    /// destructor.
+    ~String_var (void);
 
-  /// assignment operator.
-  CORBA_String_var &operator= (char *p);
+    /// assignment operator.
+    String_var &operator= (char *p);
 
-  /// assignment to a const char*.  Makes a copy.
-  CORBA_String_var &operator= (const char *p);
+    /// assignment to a const char*.  Makes a copy.
+    String_var &operator= (const char *p);
 
-  /// assignment operator.
-  CORBA_String_var &operator= (const CORBA_String_var &s);
+    /// assignment operator.
+    String_var &operator= (const String_var &s);
 
-  /// Read/write version.
-  operator char *&();
+    /// Spec-defined read/write version.
+    operator char *&();
 
-  /// Only read privileges.
-  operator const char *() const;
+    /// only read privileges.
+    operator const char *() const;
 
-  /// allows access and modification using an slot.
-  char &operator[] (CORBA::ULong slot);
+    /// allows access and modification using an slot.
+    char &operator[] (CORBA::ULong slot);
 
-  /// allows only accessing thru an slot.
-  char operator[] (CORBA::ULong slot) const;
+    /// allows only accessing thru an slot.
+    char operator[] (CORBA::ULong slot) const;
 
     // = in, out, out, and _retn operations.
     // ORBOS/97-05-15, Appendix C.2
 
-  /// for in parameter.
-  const char *in (void) const;
+    /// for in parameter.
+    const char *in (void) const;
 
-  /// for inout parameter.
-  char *&inout (void);
+    /// for inout parameter.
+    char *&inout (void);
 
-  /// for out parameter.
-  char *&out (void);
+    /// for out parameter.
+    char *&out (void);
 
-  /// for string of return type.
-  char *_retn (void);
+    /// for string of return type.
+    char *_retn (void);
 
-private:
-  /// instance.
-  char *ptr_;
-};
+  private:
+    /// instance.
+    char *ptr_;
+  };
 
-/**
- * @class CORBA_String_out
- *
- * @brief CORBA_String_out
- *
- * To support the memory management for "out" parameter passing
- * mode.  ORBOS/97-05-15, Appendix C.2 defines a CORBA_String_out class
- */
-class TAO_Export CORBA_String_out
-{
-public:
-  // = operations.
+  /**
+   * @class String_out
+   *
+   * @brief String_out
+   *
+   * To support the memory management for "out" parameter passing
+   * mode.  ORBOS/97-05-15, Appendix C.2 defines a CORBA::String_out
+   * class
+   */
+  class TAO_Export String_out
+  {
+  public:
 
-  /// Construction from a reference to a string.
-  CORBA_String_out (char *&p);
+    /// Construction from a reference to a string.
+    String_out (char *&p);
 
-  /// Construction from a var.
-  CORBA_String_out (CORBA_String_var &p);
+    /// Construction from a var.
+    String_out (CORBA::String_var &p);
 
-  /// Construction from a var.
-  CORBA_String_out (TAO_String_Manager &p);
+    /// Construction from a var.
+    String_out (TAO_String_Manager &p);
 
-  /// Copy constructor.
-  CORBA_String_out (const CORBA_String_out &s);
+    /// Copy constructor.
+    String_out (const String_out &s);
 
-  /// Assignment from a string_out.
-  CORBA_String_out &operator= (const CORBA_String_out &s);
+    /// Assignment from a string_out.
+    String_out &operator= (const String_out &s);
 
-  /// Assignment from a string.
-  CORBA_String_out &operator= (char *p);
+    /// Assignment from a string.
+    String_out &operator= (char *p);
 
-  /// Assignment from a constant char*.
-  CORBA_String_out& operator= (const char* p);
+    /// Assignment from a constant char*.
+    String_out& operator= (const char* p);
 
-  /// Cast.
-  operator char *&();
+    /// Cast.
+    operator char *&();
 
-  /// Return underlying instance.
-  char *&ptr (void);
+    /// Return underlying instance.
+    char *&ptr (void);
 
-private:
-  /// Instance.
-  char *&ptr_;
+  private:
+    /// Instance.
+    char *&ptr_;
 
-  // assignment from _var disallowed
-  void operator= (const CORBA_String_var &);
-};
+    // assignment from _var disallowed
+    void operator= (const CORBA::String_var &);
+  };
 
-// ****************************************************************
+  // ****************************************************************
 
-/**
- * @class CORBA_WString_var
- *
- * @brief CORBA_WString var class. Provides automatic deallocation of
- * storage for wide strings
- */
-class TAO_Export CORBA_WString_var
-{
-public:
-  /// default constructor.
-  CORBA_WString_var (void);
+  /**
+   * @class WString_var
+   *
+   * @brief CORBA::WString var class.
+   *
+   * Provides automatic deallocation of storage for wide strings.
+   */
+  class TAO_Export WString_var
+  {
+  public:
+    /// default constructor.
+    WString_var (void);
 
-  /// constructor, owns p.
-  CORBA_WString_var (CORBA::WChar *p);
+    /// constructor, owns p.
+    WString_var (CORBA::WChar *p);
 
-  /// constructor. Makes a copy of p.
-  CORBA_WString_var (const CORBA::WChar *p);
+    /// constructor. Makes a copy of p.
+    WString_var (const CORBA::WChar *p);
 
-  /// copy constructor.
-  CORBA_WString_var (const CORBA_WString_var &s);
+    /// copy constructor.
+    WString_var (const WString_var &s);
 
-  /// destructor.
-  ~CORBA_WString_var (void);
+    /// destructor.
+    ~WString_var (void);
 
-  /// assignment operator.
-  CORBA_WString_var &operator= (CORBA::WChar *p);
+    /// assignment operator.
+    WString_var &operator= (CORBA::WChar *p);
 
-  /// assignment to a const char*.  Makes a copy.
-  CORBA_WString_var &operator= (const CORBA::WChar *p);
+    /// assignment to a const char*.  Makes a copy.
+    WString_var &operator= (const CORBA::WChar *p);
 
-  /// assignment operator.
-  CORBA_WString_var &operator= (const CORBA_WString_var &s);
+    /// assignment operator.
+    WString_var &operator= (const WString_var &s);
 
-  /// access and modify.
-  operator CORBA::WChar *();
+    /// access and modify.
+    operator CORBA::WChar *();
 
-  /// only read privileges.
-  operator const CORBA::WChar *() const;
+    /// only read privileges.
+    operator const CORBA::WChar *() const;
 
-  /// allows access and modification using an slot.
-  CORBA::WChar &operator[] (CORBA::ULong slot);
+    /// allows access and modification using an slot.
+    CORBA::WChar &operator[] (CORBA::ULong slot);
 
-  /// allows only accessing thru an slot.
-  CORBA::WChar operator[] (CORBA::ULong slot) const;
+    /// allows only accessing thru an slot.
+    CORBA::WChar operator[] (CORBA::ULong slot) const;
 
     // = in, out, out, and _retn operations.
     // ORBOS/97-05-15, Appendix C.2
 
-  /// for in parameter.
-  const CORBA::WChar *in (void) const;
+    /// for in parameter.
+    const CORBA::WChar *in (void) const;
 
-  /// for inout parameter.
-  CORBA::WChar *&inout (void);
+    /// for inout parameter.
+    CORBA::WChar *&inout (void);
 
-  /// for out parameter.
-  CORBA::WChar *&out (void);
+    /// for out parameter.
+    CORBA::WChar *&out (void);
 
-  /// for string of return type.
-  CORBA::WChar *_retn (void);
+    /// for string of return type.
+    CORBA::WChar *_retn (void);
 
-private:
-  /// instance.
-  CORBA::WChar *ptr_;
-};
+  private:
+    /// instance.
+    CORBA::WChar *ptr_;
+  };
 
-/**
- * @class CORBA_WString_out
- *
- * @brief CORBA_WString_out
- *
- * To support the memory management for "out" parameter passing
- * mode.  ORBOS/97-05-15, Appendix C.2 defines a CORBA_WString_out
- * class
- */
-class TAO_Export CORBA_WString_out
-{
-public:
-  // = operations.
+  /**
+   * @class WString_out
+   *
+   * @brief WString_out
+   *
+   * To support the memory management for "out" parameter passing
+   * mode.  ORBOS/97-05-15, Appendix C.2 defines a CORBA::WString_out
+   * class.
+   */
+  class TAO_Export WString_out
+  {
+  public:
 
-  /// Construction from a reference to a string.
-  CORBA_WString_out (CORBA::WChar *&p);
+    /// Construction from a reference to a string.
+    WString_out (CORBA::WChar *&p);
 
-  /// Construction from a var.
-  CORBA_WString_out (CORBA_WString_var &p);
+    /// Construction from a var.
+    WString_out (CORBA::WString_var &p);
 
-  /// Copy constructor.
-  CORBA_WString_out (const CORBA_WString_out &s);
+    /// Copy constructor.
+    WString_out (const WString_out &s);
 
-  /// Assignment from a string_out.
-  CORBA_WString_out &operator= (const CORBA_WString_out &s);
+    /// Assignment from a string_out.
+    WString_out &operator= (const WString_out &s);
 
-  /// Assignment from a string.
-  CORBA_WString_out &operator= (CORBA::WChar *p);
+    /// Assignment from a string.
+    WString_out &operator= (CORBA::WChar *p);
 
-  /// Cast.
-  operator CORBA::WChar *&();
+    /// Cast.
+    operator CORBA::WChar *&();
 
-  /// Return underlying instance.
-  CORBA::WChar *&ptr (void);
+    /// Return underlying instance.
+    CORBA::WChar *&ptr (void);
 
-private:
-  /// Instance.
-  CORBA::WChar *&ptr_;
+  private:
+    /// Instance.
+    CORBA::WChar *&ptr_;
 
-  // assignment from _var disallowed
-  void operator= (const CORBA_WString_var &);
-};
+    // assignment from _var disallowed
+    void operator= (const CORBA::WString_var &);
+  };
+}  // End CORBA namespace.
 
 # if !defined (ACE_LACKS_IOSTREAM_TOTALLY)
 
diff --git a/TAO/tao/CORBA_String.inl b/TAO/tao/CORBA_String.inl
index e087707c6de..79c40246dcd 100644
--- a/TAO/tao/CORBA_String.inl
+++ b/TAO/tao/CORBA_String.inl
@@ -1,5 +1,5 @@
 // -*- C++ -*-
-
+//
 // $Id$
 
 // ----------------------------------------------------------------------
@@ -7,57 +7,57 @@
 // ----------------------------------------------------------------------
 
 ACE_INLINE
-CORBA_String_var::CORBA_String_var (void)
+CORBA::String_var::String_var (void)
   : ptr_ (0)
 {
 }
 
 ACE_INLINE
-CORBA_String_var::CORBA_String_var (const char *p)
+CORBA::String_var::String_var (const char *p)
   : ptr_ (CORBA::string_dup (p))
 {
 }
 
 ACE_INLINE CORBA::Char &
-CORBA_String_var::operator[] (CORBA::ULong slot)
+CORBA::String_var::operator[] (CORBA::ULong slot)
 {
   // We need to verify bounds else raise some exception.
   return this->ptr_[slot];
 }
 
 ACE_INLINE CORBA::Char
-CORBA_String_var::operator[] (CORBA::ULong slot) const
+CORBA::String_var::operator[] (CORBA::ULong slot) const
 {
   // We need to verify bounds else raise some exception.
   return this->ptr_[slot];
 }
 
 ACE_INLINE
-CORBA_String_var::operator char *&()
+CORBA::String_var::operator char *&()
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_String_var::operator const char *() const
+CORBA::String_var::operator const char *() const
 {
   return this->ptr_;
 }
 
 ACE_INLINE const char *
-CORBA_String_var::in (void) const
+CORBA::String_var::in (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE char *&
-CORBA_String_var::inout (void)
+CORBA::String_var::inout (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE char *&
-CORBA_String_var::out (void)
+CORBA::String_var::out (void)
 {
   CORBA::string_free (this->ptr_);
   this->ptr_ = 0;
@@ -65,7 +65,7 @@ CORBA_String_var::out (void)
 }
 
 ACE_INLINE char *
-CORBA_String_var::_retn (void)
+CORBA::String_var::_retn (void)
 {
   char *temp = this->ptr_;
   this->ptr_ = 0;
@@ -77,59 +77,59 @@ CORBA_String_var::_retn (void)
 // ----------------------------------------------------
 
 ACE_INLINE
-CORBA_String_out::CORBA_String_out (char *&s)
+CORBA::String_out::String_out (char *&s)
   : ptr_ (s)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_String_out::CORBA_String_out (CORBA_String_var &s)
+CORBA::String_out::String_out (CORBA::String_var &s)
   : ptr_ (s.out ())
 {
 }
 
 ACE_INLINE
-CORBA_String_out::CORBA_String_out (TAO_String_Manager &s)
+CORBA::String_out::String_out (TAO_String_Manager &s)
   : ptr_ (s.out ())
 {
 }
 
 ACE_INLINE
-CORBA_String_out::CORBA_String_out (const CORBA_String_out &s)
+CORBA::String_out::String_out (const CORBA::String_out &s)
   : ptr_ (s.ptr_)
 {
 }
 
-ACE_INLINE CORBA_String_out &
-CORBA_String_out::operator= (const CORBA_String_out &s)
+ACE_INLINE CORBA::String_out &
+CORBA::String_out::operator= (const CORBA::String_out &s)
 {
   this->ptr_ = s.ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_String_out &
-CORBA_String_out::operator= (char *s)
+ACE_INLINE CORBA::String_out &
+CORBA::String_out::operator= (char *s)
 {
   this->ptr_ = s;
   return *this;
 }
 
-ACE_INLINE CORBA_String_out &
-CORBA_String_out::operator= (const char *s)
+ACE_INLINE CORBA::String_out &
+CORBA::String_out::operator= (const char *s)
 {
   this->ptr_ = CORBA::string_dup (s);
   return *this;
 }
 
 ACE_INLINE
-CORBA_String_out::operator char *&()
+CORBA::String_out::operator char *&()
 {
   return this->ptr_;
 }
 
 ACE_INLINE char *&
-CORBA_String_out::ptr (void)
+CORBA::String_out::ptr (void)
 {
   return this->ptr_;
 }
@@ -141,57 +141,57 @@ CORBA_String_out::ptr (void)
 // ----------------------------------------------------------------------
 
 ACE_INLINE
-CORBA_WString_var::CORBA_WString_var (void)
+CORBA::WString_var::WString_var (void)
   : ptr_ (0)
 {
 }
 
 ACE_INLINE
-CORBA_WString_var::CORBA_WString_var (const CORBA::WChar *p)
+CORBA::WString_var::WString_var (const CORBA::WChar *p)
   : ptr_ (CORBA::wstring_dup (p))
 {
 }
 
 ACE_INLINE CORBA::WChar &
-CORBA_WString_var::operator[] (CORBA::ULong slot)
+CORBA::WString_var::operator[] (CORBA::ULong slot)
 {
   // @@ We need to verify bounds else raise some exception.
   return this->ptr_[slot];
 }
 
 ACE_INLINE CORBA::WChar
-CORBA_WString_var::operator[] (CORBA::ULong slot) const
+CORBA::WString_var::operator[] (CORBA::ULong slot) const
 {
   // @@ We need to verify bounds else raise some exception.
   return this->ptr_[slot];
 }
 
 ACE_INLINE
-CORBA_WString_var::operator CORBA::WChar *()
+CORBA::WString_var::operator CORBA::WChar *()
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_WString_var::operator const CORBA::WChar *() const
+CORBA::WString_var::operator const CORBA::WChar *() const
 {
   return this->ptr_;
 }
 
 ACE_INLINE const CORBA::WChar *
-CORBA_WString_var::in (void) const
+CORBA::WString_var::in (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::WChar *&
-CORBA_WString_var::inout (void)
+CORBA::WString_var::inout (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::WChar *&
-CORBA_WString_var::out (void)
+CORBA::WString_var::out (void)
 {
   CORBA::wstring_free (this->ptr_);
   this->ptr_ = 0;
@@ -199,7 +199,7 @@ CORBA_WString_var::out (void)
 }
 
 ACE_INLINE CORBA::WChar *
-CORBA_WString_var::_retn (void)
+CORBA::WString_var::_retn (void)
 {
   CORBA::WChar *temp = this->ptr_;
   this->ptr_ = 0;
@@ -211,46 +211,46 @@ CORBA_WString_var::_retn (void)
 // ----------------------------------------------------
 
 ACE_INLINE
-CORBA_WString_out::CORBA_WString_out (CORBA::WChar *&s)
+CORBA::WString_out::WString_out (CORBA::WChar *&s)
   : ptr_ (s)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_WString_out::CORBA_WString_out (CORBA_WString_var &s)
+CORBA::WString_out::WString_out (CORBA::WString_var &s)
   : ptr_ (s.out ())
 {
 }
 
 ACE_INLINE
-CORBA_WString_out::CORBA_WString_out (const CORBA_WString_out &s)
+CORBA::WString_out::WString_out (const CORBA::WString_out &s)
   : ptr_ (s.ptr_)
 {
 }
 
-ACE_INLINE CORBA_WString_out &
-CORBA_WString_out::operator= (const CORBA_WString_out &s)
+ACE_INLINE CORBA::WString_out &
+CORBA::WString_out::operator= (const CORBA::WString_out &s)
 {
   this->ptr_ = s.ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_WString_out &
-CORBA_WString_out::operator= (CORBA::WChar *s)
+ACE_INLINE CORBA::WString_out &
+CORBA::WString_out::operator= (CORBA::WChar *s)
 {
   this->ptr_ = s;
   return *this;
 }
 
 ACE_INLINE
-CORBA_WString_out::operator CORBA::WChar *&()
+CORBA::WString_out::operator CORBA::WChar *&()
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::WChar *&
-CORBA_WString_out::ptr (void)
+CORBA::WString_out::ptr (void)
 {
   return this->ptr_;
 }
diff --git a/TAO/tao/CurrentC.cpp b/TAO/tao/CurrentC.cpp
index 80e915709ed..4edd00a402b 100644
--- a/TAO/tao/CurrentC.cpp
+++ b/TAO/tao/CurrentC.cpp
@@ -30,7 +30,7 @@
 #include "tao/CurrentC.i"
 #endif /* !defined INLINE */
 
-int CORBA_Current::_tao_class_id = 0;
+int CORBA::Current::_tao_class_id = 0;
 
 CORBA::Current_ptr
 tao_CORBA_Current_duplicate (
@@ -48,21 +48,21 @@ tao_CORBA_Current_release (
   CORBA::release (p);
 }
 
-CORBA_Current_ptr
+CORBA::Current_ptr
 tao_CORBA_Current_nil (
     void
   )
 {
-  return CORBA_Current::_nil ();
+  return CORBA::Current::_nil ();
 }
 
-CORBA_Current_ptr
+CORBA::Current_ptr
 tao_CORBA_Current_narrow (
     CORBA::Object *p
     ACE_ENV_ARG_DECL
   )
 {
-  return CORBA_Current::_narrow (p ACE_ENV_ARG_PARAMETER);
+  return CORBA::Current::_narrow (p ACE_ENV_ARG_PARAMETER);
 }
 
 CORBA::Object *
@@ -70,246 +70,246 @@ tao_CORBA_Current_upcast (
     void *src
   )
 {
-  CORBA_Current **tmp =
-    ACE_static_cast (CORBA_Current **, src);
+  CORBA::Current **tmp =
+    ACE_static_cast (CORBA::Current **, src);
   return *tmp;
 }
 
 // *************************************************************
-// Operations for class CORBA_Current_var
+// Operations for class CORBA::Current_var
 // *************************************************************
 
-CORBA_Current_var::CORBA_Current_var (void) // default constructor
-  : ptr_ (CORBA_Current::_nil ())
+CORBA::Current_var::Current_var (void) // default constructor
+  : ptr_ (CORBA::Current::_nil ())
 {}
 
-::CORBA_Current_ptr
-CORBA_Current_var::ptr (void) const
+::CORBA::Current_ptr
+CORBA::Current_var::ptr (void) const
 {
   return this->ptr_;
 }
 
-CORBA_Current_var::CORBA_Current_var (const ::CORBA_Current_var &p) // copy constructor
+CORBA::Current_var::Current_var (const ::CORBA::Current_var &p) // copy constructor
   : TAO_Base_var (),
-    ptr_ (CORBA_Current::_duplicate (p.ptr ()))
+    ptr_ (CORBA::Current::_duplicate (p.ptr ()))
 {}
 
-CORBA_Current_var::~CORBA_Current_var (void) // destructor
+CORBA::Current_var::~Current_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-CORBA_Current_var &
-CORBA_Current_var::operator= (CORBA_Current_ptr p)
+CORBA::Current_var &
+CORBA::Current_var::operator= (CORBA::Current_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-CORBA_Current_var &
-CORBA_Current_var::operator= (const ::CORBA_Current_var &p)
+CORBA::Current_var &
+CORBA::Current_var::operator= (const ::CORBA::Current_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = ::CORBA_Current::_duplicate (p.ptr ());
+    this->ptr_ = ::CORBA::Current::_duplicate (p.ptr ());
   }
   return *this;
 }
 
-CORBA_Current_var::operator const ::CORBA_Current_ptr &() const // cast
+CORBA::Current_var::operator const ::CORBA::Current_ptr &() const // cast
 {
   return this->ptr_;
 }
 
-CORBA_Current_var::operator ::CORBA_Current_ptr &() // cast
+CORBA::Current_var::operator ::CORBA::Current_ptr &() // cast
 {
   return this->ptr_;
 }
 
-::CORBA_Current_ptr
-CORBA_Current_var::operator-> (void) const
+::CORBA::Current_ptr
+CORBA::Current_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-::CORBA_Current_ptr
-CORBA_Current_var::in (void) const
+::CORBA::Current_ptr
+CORBA::Current_var::in (void) const
 {
   return this->ptr_;
 }
 
-::CORBA_Current_ptr &
-CORBA_Current_var::inout (void)
+::CORBA::Current_ptr &
+CORBA::Current_var::inout (void)
 {
   return this->ptr_;
 }
 
-::CORBA_Current_ptr &
-CORBA_Current_var::out (void)
+::CORBA::Current_ptr &
+CORBA::Current_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = ::CORBA_Current::_nil ();
+  this->ptr_ = ::CORBA::Current::_nil ();
   return this->ptr_;
 }
 
-::CORBA_Current_ptr
-CORBA_Current_var::_retn (void)
+::CORBA::Current_ptr
+CORBA::Current_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  ::CORBA_Current_ptr val = this->ptr_;
-  this->ptr_ = ::CORBA_Current::_nil ();
+  ::CORBA::Current_ptr val = this->ptr_;
+  this->ptr_ = ::CORBA::Current::_nil ();
   return val;
 }
 
-::CORBA_Current_ptr
-CORBA_Current_var::tao_duplicate (CORBA_Current_ptr p)
+::CORBA::Current_ptr
+CORBA::Current_var::tao_duplicate (CORBA::Current_ptr p)
 {
-  return ::CORBA_Current::_duplicate (p);
+  return ::CORBA::Current::_duplicate (p);
 }
 
 void
-CORBA_Current_var::tao_release (CORBA_Current_ptr p)
+CORBA::Current_var::tao_release (CORBA::Current_ptr p)
 {
   CORBA::release (p);
 }
 
-::CORBA_Current_ptr
-CORBA_Current_var::tao_nil (void)
+::CORBA::Current_ptr
+CORBA::Current_var::tao_nil (void)
 {
-  return ::CORBA_Current::_nil ();
+  return ::CORBA::Current::_nil ();
 }
 
-::CORBA_Current_ptr
-CORBA_Current_var::tao_narrow (
+::CORBA::Current_ptr
+CORBA::Current_var::tao_narrow (
     CORBA::Object *p
     ACE_ENV_ARG_DECL
   )
 {
-  return ::CORBA_Current::_narrow (p ACE_ENV_ARG_PARAMETER);
+  return ::CORBA::Current::_narrow (p ACE_ENV_ARG_PARAMETER);
 }
 
 CORBA::Object *
-CORBA_Current_var::tao_upcast (void *src)
+CORBA::Current_var::tao_upcast (void *src)
 {
-  CORBA_Current **tmp =
-    ACE_static_cast (CORBA_Current **, src);
+  CORBA::Current **tmp =
+    ACE_static_cast (CORBA::Current **, src);
   return *tmp;
 }
 
 // *************************************************************
-// Operations for class CORBA_Current_out
+// Operations for class CORBA::Current_out
 // *************************************************************
 
-CORBA_Current_out::CORBA_Current_out (CORBA_Current_ptr &p)
+CORBA::Current_out::Current_out (CORBA::Current_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = ::CORBA_Current::_nil ();
+  this->ptr_ = ::CORBA::Current::_nil ();
 }
 
-CORBA_Current_out::CORBA_Current_out (CORBA_Current_var &p) // constructor from _var
+CORBA::Current_out::Current_out (CORBA::Current_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = ::CORBA_Current::_nil ();
+  this->ptr_ = ::CORBA::Current::_nil ();
 }
 
-CORBA_Current_out::CORBA_Current_out (const ::CORBA_Current_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_Current_out &, p).ptr_)
+CORBA::Current_out::Current_out (const ::CORBA::Current_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA::Current_out &, p).ptr_)
 {}
 
-::CORBA_Current_out &
-CORBA_Current_out::operator= (const ::CORBA_Current_out &p)
+::CORBA::Current_out &
+CORBA::Current_out::operator= (const ::CORBA::Current_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_Current_out&, p).ptr_;
+  this->ptr_ = ACE_const_cast (CORBA::Current_out&, p).ptr_;
   return *this;
 }
 
-CORBA_Current_out &
-CORBA_Current_out::operator= (const ::CORBA_Current_var &p)
+CORBA::Current_out &
+CORBA::Current_out::operator= (const ::CORBA::Current_var &p)
 {
-  this->ptr_ = ::CORBA_Current::_duplicate (p.ptr ());
+  this->ptr_ = ::CORBA::Current::_duplicate (p.ptr ());
   return *this;
 }
 
-CORBA_Current_out &
-CORBA_Current_out::operator= (CORBA_Current_ptr p)
+CORBA::Current_out &
+CORBA::Current_out::operator= (CORBA::Current_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
-CORBA_Current_out::operator ::CORBA_Current_ptr &() // cast
+CORBA::Current_out::operator ::CORBA::Current_ptr &() // cast
 {
   return this->ptr_;
 }
 
-::CORBA_Current_ptr &
-CORBA_Current_out::ptr (void) // ptr
+::CORBA::Current_ptr &
+CORBA::Current_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-::CORBA_Current_ptr
-CORBA_Current_out::operator-> (void)
+::CORBA::Current_ptr
+CORBA::Current_out::operator-> (void)
 {
   return this->ptr_;
 }
 
 
 // default constructor
-CORBA_Current::CORBA_Current (void)
+CORBA::Current::Current (void)
 {}
 
   // destructor
-  CORBA_Current::~CORBA_Current (void)
+  CORBA::Current::~Current (void)
   {}
 
-  CORBA_Current_ptr CORBA_Current::_narrow (
+  CORBA::Current_ptr CORBA::Current::_narrow (
       CORBA::Object_ptr obj
       ACE_ENV_ARG_DECL
     )
   {
-    return CORBA_Current::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
+    return CORBA::Current::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
   }
 
-  CORBA_Current_ptr CORBA_Current::_unchecked_narrow (
+  CORBA::Current_ptr CORBA::Current::_unchecked_narrow (
       CORBA::Object_ptr obj
       ACE_ENV_ARG_DECL_NOT_USED
     )
   {
     if (CORBA::is_nil (obj))
-      return CORBA_Current::_nil ();
+      return CORBA::Current::_nil ();
     return
         ACE_reinterpret_cast
           (
-            CORBA_Current_ptr,
+            CORBA::Current_ptr,
               obj->_tao_QueryInterface
                 (
                   ACE_reinterpret_cast
                     (
                       ptr_arith_t,
-                      &CORBA_Current::_tao_class_id
+                      &CORBA::Current::_tao_class_id
                     )
                 )
           );
 }
 
-CORBA_Current_ptr
-CORBA_Current::_duplicate (CORBA_Current_ptr obj)
+CORBA::Current_ptr
+CORBA::Current::_duplicate (CORBA::Current_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_add_ref ();
   return obj;
 }
 
-void *CORBA_Current::_tao_QueryInterface (ptr_arith_t type)
+void *CORBA::Current::_tao_QueryInterface (ptr_arith_t type)
 {
   void *retv = 0;
   if (type == ACE_reinterpret_cast
     (ptr_arith_t,
-      &CORBA_Current::_tao_class_id))
+      &CORBA::Current::_tao_class_id))
     retv = ACE_reinterpret_cast (void*, this);
   else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
     retv = ACE_reinterpret_cast (void *,
@@ -320,14 +320,14 @@ void *CORBA_Current::_tao_QueryInterface (ptr_arith_t type)
   return retv;
 }
 
-const char* CORBA_Current::_interface_repository_id (void) const
+const char* CORBA::Current::_interface_repository_id (void) const
 {
   return "IDL:omg.org/CORBA/Current:1.0";
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<CORBA_Current,CORBA_Current_var>;
+    template class TAO_Object_Manager<CORBA::Current,CORBA::Current_var>;
   #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<CORBA_Current,CORBA_Current_var>
+  #  pragma instantiate TAO_Object_Manager<CORBA::Current,CORBA::Current_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/TAO/tao/CurrentC.h b/TAO/tao/CurrentC.h
index be2ac03a544..b259236cc94 100644
--- a/TAO/tao/CurrentC.h
+++ b/TAO/tao/CurrentC.h
@@ -30,6 +30,7 @@
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
 #include "tao/corbafwd.h"
+#include "tao/varbase.h"
 
 #if defined (TAO_EXPORT_MACRO)
 #undef TAO_EXPORT_MACRO
@@ -54,12 +55,13 @@
 #pragma option push -w-rvl -w-rch -w-ccc -w-inl
 #endif /* __BORLANDC__ */
 
-
+namespace CORBA
+{
 #if !defined (_CORBA_CURRENT___PTR_CH_)
 #define _CORBA_CURRENT___PTR_CH_
 
-class CORBA_Current;
-typedef CORBA_Current *CORBA_Current_ptr;
+  class Current;
+  typedef Current *Current_ptr;
 
 #endif /* end #if !defined */
 
@@ -67,44 +69,44 @@ typedef CORBA_Current *CORBA_Current_ptr;
 #if !defined (_CORBA_CURRENT___VAR_CH_)
 #define _CORBA_CURRENT___VAR_CH_
 
-class TAO_Export CORBA_Current_var : public TAO_Base_var
-{
-public:
-  CORBA_Current_var (void); // default constructor
-  CORBA_Current_var (CORBA_Current_ptr p) : ptr_ (p) {}
-  CORBA_Current_var (const CORBA_Current_var &); // copy constructor
-  ~CORBA_Current_var (void); // destructor
-
-  CORBA_Current_var &operator= (CORBA_Current_ptr);
-  CORBA_Current_var &operator= (const CORBA_Current_var &);
-  CORBA_Current_ptr operator-> (void) const;
-
-  operator const CORBA_Current_ptr &() const;
-  operator CORBA_Current_ptr &();
-  // in, inout, out, _retn
-  CORBA_Current_ptr in (void) const;
-  CORBA_Current_ptr &inout (void);
-  CORBA_Current_ptr &out (void);
-  CORBA_Current_ptr _retn (void);
-  CORBA_Current_ptr ptr (void) const;
-
-  // Hooks used by template sequence and object manager classes
+  class TAO_Export Current_var : public TAO_Base_var
+  {
+  public:
+    Current_var (void); // default constructor
+    Current_var (Current_ptr p) : ptr_ (p) {}
+    Current_var (const Current_var &); // copy constructor
+    ~Current_var (void); // destructor
+
+    Current_var &operator= (Current_ptr);
+    Current_var &operator= (const Current_var &);
+    Current_ptr operator-> (void) const;
+
+    operator const Current_ptr &() const;
+    operator Current_ptr &();
+    // in, inout, out, _retn
+    Current_ptr in (void) const;
+    Current_ptr &inout (void);
+    Current_ptr &out (void);
+    Current_ptr _retn (void);
+    Current_ptr ptr (void) const;
+
+    // Hooks used by template sequence and object manager classes
   // for non-defined forward declared interfaces.
-  static CORBA_Current_ptr tao_duplicate (CORBA_Current_ptr);
-  static void tao_release (CORBA_Current_ptr);
-  static CORBA_Current_ptr tao_nil (void);
-  static CORBA_Current_ptr tao_narrow (
-      CORBA::Object *
-      ACE_ENV_ARG_DECL_NOT_USED
-    );
-  static CORBA::Object * tao_upcast (void *);
-
-private:
-  CORBA_Current_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  CORBA_Current_var (const TAO_Base_var &rhs);
-  CORBA_Current_var &operator= (const TAO_Base_var &rhs);
-};
+    static Current_ptr tao_duplicate (Current_ptr);
+    static void tao_release (Current_ptr);
+    static Current_ptr tao_nil (void);
+    static Current_ptr tao_narrow (
+                                         CORBA::Object *
+                                         ACE_ENV_ARG_DECL_NOT_USED
+                                         );
+    static CORBA::Object * tao_upcast (void *);
+
+  private:
+    Current_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    Current_var (const TAO_Base_var &rhs);
+    Current_var &operator= (const TAO_Base_var &rhs);
+  };
 
 
 #endif /* end #if !defined */
@@ -113,22 +115,22 @@ private:
 #if !defined (_CORBA_CURRENT___OUT_CH_)
 #define _CORBA_CURRENT___OUT_CH_
 
-class TAO_Export CORBA_Current_out
-{
-public:
-  CORBA_Current_out (CORBA_Current_ptr &);
-  CORBA_Current_out (CORBA_Current_var &);
-  CORBA_Current_out (const CORBA_Current_out &);
-  CORBA_Current_out &operator= (const CORBA_Current_out &);
-  CORBA_Current_out &operator= (const CORBA_Current_var &);
-  CORBA_Current_out &operator= (CORBA_Current_ptr);
-  operator CORBA_Current_ptr &();
-  CORBA_Current_ptr &ptr (void);
-  CORBA_Current_ptr operator-> (void);
-
-private:
-  CORBA_Current_ptr &ptr_;
-};
+  class TAO_Export Current_out
+  {
+  public:
+    Current_out (Current_ptr &);
+    Current_out (Current_var &);
+    Current_out (const Current_out &);
+    Current_out &operator= (const Current_out &);
+    Current_out &operator= (const Current_var &);
+    Current_out &operator= (Current_ptr);
+    operator Current_ptr &();
+    Current_ptr &ptr (void);
+    Current_ptr operator-> (void);
+
+  private:
+    Current_ptr &ptr_;
+  };
 
 
 #endif /* end #if !defined */
@@ -137,52 +139,51 @@ private:
 #if !defined (_CORBA_CURRENT_CH_)
 #define _CORBA_CURRENT_CH_
 
-class TAO_Export CORBA_Current
-  : public virtual CORBA_Object
-{
-public:
+  class TAO_Export Current
+    : public virtual CORBA::Object
+  {
+  public:
 #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef CORBA_Current_ptr _ptr_type;
-  typedef CORBA_Current_var _var_type;
+    typedef Current_ptr _ptr_type;
+    typedef Current_var _var_type;
 #endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  static int _tao_class_id;
+    static int _tao_class_id;
 
-  // The static operations.
-  static CORBA_Current_ptr _duplicate (CORBA_Current_ptr obj);
+    // The static operations.
+    static Current_ptr _duplicate (Current_ptr obj);
 
-  static CORBA_Current_ptr _narrow (
-      CORBA::Object_ptr obj
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    static Current_ptr _narrow (
+                                      CORBA::Object_ptr obj
+                                      ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-
-  static CORBA_Current_ptr _unchecked_narrow (
+    static Current_ptr _unchecked_narrow (
       CORBA::Object_ptr obj
       ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
 
-  static CORBA_Current_ptr _nil (void)
+    static Current_ptr _nil (void)
     {
-      return (CORBA_Current_ptr)0;
+      return (Current_ptr)0;
     }
 
-  virtual void *_tao_QueryInterface (ptr_arith_t type);
+    virtual void *_tao_QueryInterface (ptr_arith_t type);
 
-  virtual const char* _interface_repository_id (void) const;
+    virtual const char* _interface_repository_id (void) const;
 
-protected:
-  CORBA_Current (void);
+  protected:
+    Current (void);
 
-  virtual ~CORBA_Current (void);
+    virtual ~Current (void);
 
-private:
-  CORBA_Current (const CORBA_Current &);
-  void operator= (const CORBA_Current &);
-};
+  private:
+    Current (const Current &);
+    void operator= (const Current &);
+  };
 
 
 #endif /* end #if !defined */
-
+}  // End namespace CORBA 
 
 #ifndef __ACE_INLINE__
 
diff --git a/TAO/tao/DomainC.cpp b/TAO/tao/DomainC.cpp
index 1b37e4710b5..de85cbcd4a1 100644
--- a/TAO/tao/DomainC.cpp
+++ b/TAO/tao/DomainC.cpp
@@ -387,7 +387,7 @@ CORBA::_TAO_DomainManager_Remote_Proxy_Impl::_TAO_DomainManager_Remote_Proxy_Imp
 // Remote Implementation of the IDL interface methods
 
 ::CORBA::Policy_ptr CORBA::_TAO_DomainManager_Remote_Proxy_Impl::get_domain_policy (
-    CORBA_Object *_collocated_tao_target_,
+    CORBA::Object *_collocated_tao_target_,
     CORBA::PolicyType policy_type
     ACE_ENV_ARG_DECL
   )
@@ -741,7 +741,7 @@ CORBA::Boolean CORBA::DomainManager::_is_a (const CORBA::Char *value ACE_ENV_ARG
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
   else
-    return this->CORBA_Object::_is_a (value ACE_ENV_ARG_PARAMETER);
+    return this->Object::_is_a (value ACE_ENV_ARG_PARAMETER);
 }
 
 void *CORBA::DomainManager::_tao_QueryInterface (ptr_arith_t type)
@@ -1168,7 +1168,7 @@ CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Impl::_TAO_ConstructionPolicy_Remote
 // Remote Implementation of the IDL interface methods
 
 void CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Impl::make_domain_manager (
-    CORBA_Object *_collocated_tao_target_,
+    CORBA::Object *_collocated_tao_target_,
     CORBA::InterfaceDef_ptr object_type,
     CORBA::Boolean constr_policy
     ACE_ENV_ARG_DECL
@@ -1516,7 +1516,7 @@ CORBA::Boolean CORBA::ConstructionPolicy::_is_a (const CORBA::Char *value ACE_EN
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
   else
-    return this->CORBA_Object::_is_a (value ACE_ENV_ARG_PARAMETER);
+    return this->Object::_is_a (value ACE_ENV_ARG_PARAMETER);
 }
 
 void *CORBA::ConstructionPolicy::_tao_QueryInterface (ptr_arith_t type)
@@ -1681,7 +1681,7 @@ CORBA::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_shrink_buffer (C
 void 
 CORBA::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_downcast (
     void* target,
-    CORBA_Object *src
+    CORBA::Object *src
     ACE_ENV_ARG_DECL
   )
 {
@@ -1690,7 +1690,7 @@ CORBA::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_downcast (
   ACE_CHECK;
 }
 
-CORBA_Object*
+CORBA::Object*
 CORBA::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_upcast (void *src) const
 {
   CORBA::DomainManager **tmp = ACE_static_cast (CORBA::DomainManager**, src);
diff --git a/TAO/tao/DomainC.h b/TAO/tao/DomainC.h
index 4050cb9241b..9bb231c11fd 100644
--- a/TAO/tao/DomainC.h
+++ b/TAO/tao/DomainC.h
@@ -154,7 +154,7 @@ TAO_NAMESPACE  CORBA
   class _TAO_DomainManager_Remote_Proxy_Broker;
   
   class TAO_Export DomainManager
-    : public virtual CORBA_Object
+    : public virtual CORBA::Object
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -243,7 +243,7 @@ TAO_NAMESPACE  CORBA
   public:
     virtual ~_TAO_DomainManager_Proxy_Impl (void) { }
     virtual ::CORBA::Policy_ptr get_domain_policy (
-        CORBA_Object *_collocated_tao_target_,
+        CORBA::Object *_collocated_tao_target_,
         CORBA::PolicyType policy_type
         ACE_ENV_ARG_DECL
       )
@@ -274,7 +274,7 @@ TAO_NAMESPACE  CORBA
     
     virtual ~_TAO_DomainManager_Remote_Proxy_Impl (void) { }
     virtual ::CORBA::Policy_ptr get_domain_policy (
-        CORBA_Object *_collocated_tao_target_,
+        CORBA::Object *_collocated_tao_target_,
         CORBA::PolicyType policy_type
         ACE_ENV_ARG_DECL
       )
@@ -542,7 +542,7 @@ TAO_NAMESPACE  CORBA
   public:
     virtual ~_TAO_ConstructionPolicy_Proxy_Impl (void) { }
     virtual void make_domain_manager (
-        CORBA_Object *_collocated_tao_target_,
+        CORBA::Object *_collocated_tao_target_,
         CORBA::InterfaceDef_ptr object_type,
         CORBA::Boolean constr_policy
         ACE_ENV_ARG_DECL
@@ -575,7 +575,7 @@ TAO_NAMESPACE  CORBA
     
     virtual ~_TAO_ConstructionPolicy_Remote_Proxy_Impl (void) { }
     virtual void make_domain_manager (
-        CORBA_Object *_collocated_tao_target_,
+        CORBA::Object *_collocated_tao_target_,
         CORBA::InterfaceDef_ptr object_type,
         CORBA::Boolean constr_policy
         ACE_ENV_ARG_DECL
@@ -702,10 +702,10 @@ TAO_NAMESPACE  CORBA
     
     virtual void _downcast (
         void* target,
-        CORBA_Object *src
+        CORBA::Object *src
         ACE_ENV_ARG_DECL_WITH_DEFAULTS
       );
-    virtual CORBA_Object* _upcast (void *src) const;
+    virtual CORBA::Object* _upcast (void *src) const;
   };
   
 #endif /* end #if !defined */
diff --git a/TAO/tao/DomainC.i b/TAO/tao/DomainC.i
index 1bd874d2b4d..12b934c2f68 100644
--- a/TAO/tao/DomainC.i
+++ b/TAO/tao/DomainC.i
@@ -29,7 +29,7 @@ CORBA::DomainManager::DomainManager (
     CORBA::Boolean _tao_collocated,
     TAO_Abstract_ServantBase *servant
   )
-  : CORBA_Object (objref, _tao_collocated, servant)
+  : Object (objref, _tao_collocated, servant)
 {
   this->CORBA_DomainManager_setup_collocation (_tao_collocated);
 }
@@ -47,7 +47,7 @@ CORBA::ConstructionPolicy::ConstructionPolicy (
     CORBA::Boolean _tao_collocated,
     TAO_Abstract_ServantBase *servant
   )
-  : CORBA_Object (objref, _tao_collocated, servant)
+  : Object (objref, _tao_collocated, servant)
 {
   this->CORBA_ConstructionPolicy_setup_collocation (_tao_collocated);
 }
diff --git a/TAO/tao/Environment.cpp b/TAO/tao/Environment.cpp
index 069dcba6a33..86a43612b17 100644
--- a/TAO/tao/Environment.cpp
+++ b/TAO/tao/Environment.cpp
@@ -1,5 +1,3 @@
-// $Id$
-
 #include "tao/Environment.h"
 #include "tao/ORB_Core.h"
 #include "tao/Exception.h"
@@ -9,17 +7,19 @@
 #endif /* __ACE_INLINE__ */
 
 
-ACE_RCSID(tao, Environment, "$Id$")
+ACE_RCSID (tao,
+           Environment,
+           "$Id$")
 
 
-CORBA_Environment::CORBA_Environment (void)
+CORBA::Environment::Environment (void)
   : exception_ (0)
   , previous_ (0)
 {
   //  TAO_ORB_Core_instance ()->default_environment (this);
 }
 
-CORBA_Environment::CORBA_Environment (const CORBA_Environment& rhs)
+CORBA::Environment::Environment (const CORBA::Environment& rhs)
   : exception_ (0)
   , previous_ (0)
 {
@@ -27,31 +27,31 @@ CORBA_Environment::CORBA_Environment (const CORBA_Environment& rhs)
     this->exception_ = rhs.exception_->_tao_duplicate ();
 }
 
-CORBA_Environment::CORBA_Environment (TAO_ORB_Core* orb_core)
+CORBA::Environment::Environment (TAO_ORB_Core* orb_core)
   : exception_ (0)
   , previous_ (orb_core->default_environment ())
 {
   orb_core->default_environment (this);
 }
 
-CORBA_Environment&
-CORBA_Environment::operator= (const CORBA_Environment& rhs)
+CORBA::Environment&
+CORBA::Environment::operator= (const CORBA::Environment& rhs)
 {
-  CORBA_Environment tmp (rhs);
+  CORBA::Environment tmp (rhs);
   {
-    CORBA_Exception *tmp_ex = this->exception_;
+    CORBA::Exception *tmp_ex = this->exception_;
     this->exception_ = tmp.exception_;
     tmp.exception_ = tmp_ex;
   }
   {
-    CORBA_Environment *tmp_env = this->previous_;
+    CORBA::Environment *tmp_env = this->previous_;
     this->previous_ = rhs.previous_;
     tmp.previous_ = tmp_env;
   }
   return *this;
 }
 
-CORBA_Environment::~CORBA_Environment (void)
+CORBA::Environment::~Environment (void)
 {
   this->clear ();
 
@@ -63,7 +63,7 @@ CORBA_Environment::~CORBA_Environment (void)
 }
 
 void
-CORBA_Environment::exception (CORBA_Exception *ex)
+CORBA::Environment::exception (CORBA::Exception *ex)
 {
   // @@ This does not look right, setting the exception to the
   //    contained exception is a bug,  the application is only
@@ -93,19 +93,19 @@ CORBA_Environment::exception (CORBA_Exception *ex)
 }
 
 void
-CORBA_Environment::clear (void)
+CORBA::Environment::clear (void)
 {
   delete this->exception_;
   this->exception_ = 0;
 }
 
-CORBA_Environment&
-CORBA_Environment::default_environment ()
+CORBA::Environment&
+CORBA::Environment::default_environment ()
 {
 #if defined (TAO_HAS_EXCEPTIONS)
   //
   // If we are using native C++ exceptions the user is *not* supposed
-  // to clear the environment every time she calls into TAO, in fact
+  // to clear the environment every time she calls into TAO.  In fact
   // the user is not supposed to use the environment at all!
   //
   // But TAO is using the default environment internally, thus
@@ -162,7 +162,7 @@ CORBA::Environment::exception_type (void) const
 }
 
 const char*
-CORBA_Environment::exception_id (void) const
+CORBA::Environment::exception_id (void) const
 {
   if (this->exception_ == 0)
     return 0;
@@ -186,7 +186,7 @@ CORBA::Environment::print_exception (const char *info,
                   info));
 
       CORBA::SystemException *x2 =
-        CORBA_SystemException::_downcast (this->exception_);
+        CORBA::SystemException::_downcast (this->exception_);
 
       if (x2 != 0)
         x2->_tao_print_system_exception ();
@@ -203,23 +203,23 @@ CORBA::Environment::print_exception (const char *info,
                 ACE_TEXT ("TAO: (%P|%t) no exception, %s\n"), info));
 }
 
-CORBA_Environment_var &
-CORBA_Environment_var::operator= (CORBA_Environment_ptr p)
+CORBA::Environment_var &
+CORBA::Environment_var::operator= (CORBA::Environment_ptr p)
 {
-  CORBA_Environment_var tmp (p);
+  CORBA::Environment_var tmp (p);
   // @@ We need as ACE_Swap<> template!!
-  CORBA_Environment *tmp_ptr = this->ptr_;
+  CORBA::Environment *tmp_ptr = this->ptr_;
   this->ptr_ = tmp.ptr_;
   tmp.ptr_ = tmp_ptr;
   return *this;
 }
 
-CORBA_Environment_var &
-CORBA_Environment_var::operator= (const CORBA_Environment_var &r)
+CORBA::Environment_var &
+CORBA::Environment_var::operator= (const CORBA::Environment_var &r)
 {
-  CORBA_Environment_var tmp (r);
+  CORBA::Environment_var tmp (r);
   // @@ We need as ACE_Swap<> template!!
-  CORBA_Environment *tmp_ptr = this->ptr_;
+  CORBA::Environment *tmp_ptr = this->ptr_;
   this->ptr_ = tmp.ptr_;
   tmp.ptr_ = tmp_ptr;
   return *this;
diff --git a/TAO/tao/Environment.h b/TAO/tao/Environment.h
index 1779f5b6687..eb420bc1657 100644
--- a/TAO/tao/Environment.h
+++ b/TAO/tao/Environment.h
@@ -1,4 +1,4 @@
-// This may look like C, but it's really -*- C++ -*-
+// -*- C++ -*-
 
 //=============================================================================
 /**
@@ -6,14 +6,13 @@
  *
  *  $Id$
  *
- * Declare the CORBA_Environment class.  Note that this header file
+ * Declare the CORBA::Environment class.  Note that this header file
  * only requires a few forward declarations of CORBA classes, this
  * is *very* important because even the ORB needs to know about it;
  * make your changes with care.  It is also a good idea trying to
  * minimize cross dependencies between header files.
  *
- *
- *  @author Carlos O'Ryan <coryan@cs.wustl.edu>
+ * @author Carlos O'Ryan <coryan@cs.wustl.edu>
  */
 //=============================================================================
 
@@ -30,177 +29,180 @@
 
 class TAO_ORB_Core;
 
-/**
- * @class CORBA_Environment
- *
- * @brief CORBA_Environment
- *
- * A CORBA_Environment is a way to automagically ensure that
- * exception data is freed -- the "var" class for Exceptions.  It
- * adds just a bit of convenience function support, helping
- * classify exceptions as well as reducing memory leakage.
- * The thread has a default environment to simplify porting
- * between platforms that support native C++ exceptions and those
- * that don't. This is a TSS resource (always), but with a twist:
- * if the user creates a new environment the old one is "pushed"
- * (actually the new one remembers it), eventually the new
- * environment destructor pops itself from the stack and we
- * recover the old environment.  This means that if the user
- * create a new environment and somebody calls a function using
- * the default one the exception will still be received in the
- * environment created by the user.  The only drawback is that
- * environments life time must nest properly, this shouldn't be a
- * problem because environments are usually created on the stack,
- * but, the spec allows their creation on the heap and/or as class
- * members; we need to investigate the tradeoffs and take a
- * decision.
- */
-class TAO_Export CORBA_Environment
+namespace CORBA
 {
-public:
-  // = Initialization and termination methods.
-  /// The default constructor, the environment will hold no exceptions.
-  CORBA_Environment (void);
-
-  /// Copy constructor.
-  CORBA_Environment (const CORBA_Environment &ACE_TRY_ENV);
-
-  /// Assingment.
-  CORBA_Environment &operator=(const CORBA_Environment &ACE_TRY_ENV);
-
-  /// Destructor, release the exception.
-  ~CORBA_Environment (void);
-
-  /// Some static methods that need to be defined in every pseudo object
-  static CORBA_Environment * _duplicate (CORBA_Environment *);
-  static CORBA_Environment * _nil (void);
-
-  /// Return the contained CORBA::Exception.
   /**
-   * CORBA::Environment retains ownership of the exception, this is
-   * contrary to the normal memory management rules in the C++
-   * mapping, but actually mandated by the specification:
+   * @class Environment
    *
-   * "C++ Language Mapping" (formal/00-01-02). Section 1.27
-   * Environment (page 1-113)
+   * @brief Environment
    *
+   * A CORBA::Environment is a way to automagically ensure that
+   * exception data is freed -- the "var" class for Exceptions.  It
+   * adds just a bit of convenience function support, helping
+   * classify exceptions as well as reducing memory leakage.
+   * The thread has a default environment to simplify porting
+   * between platforms that support native C++ exceptions and those
+   * that don't. This is a TSS resource (always), but with a twist:
+   * if the user creates a new environment the old one is "pushed"
+   * (actually the new one remembers it), eventually the new
+   * environment destructor pops itself from the stack and we
+   * recover the old environment.  This means that if the user
+   * create a new environment and somebody calls a function using
+   * the default one the exception will still be received in the
+   * environment created by the user.  The only drawback is that
+   * environments life time must nest properly, this shouldn't be a
+   * problem because environments are usually created on the stack,
+   * but, the spec allows their creation on the heap and/or as class
+   * members; we need to investigate the tradeoffs and take a
+   * decision.
    */
-  CORBA_Exception* exception (void) const;
-
-  /// Set the contained CORBA::Exception to <ex>
-  /**
-   * CORBA::Environment assumes ownership of the exception, this is
-   * contrary to the normal memory management rules in the C++
-   * mapping, but actually mandated by the specification:
-   *
-   * "C++ Language Mapping" (formal/00-01-02). Section 1.27
-   * Environment (page 1-113)
-   *
-   */
-  void exception (CORBA_Exception *ex);
-
-  /// Return if the exception is a user exception or a system
-  /// exception.
-  int exception_type (void) const;
-
-  /// return the repository ID for the exception.
-  const char *exception_id (void) const;
-
-  /// Clear the exception.
-  void clear (void);
-
-  /// Print the exception to output determined by f.  This function is
-  /// not CORBA compliant.
-  void print_exception (const char *info,
-                        FILE *f=stdout) const;
-
-  // = Obtain a default environment to use with TAO.
-  static CORBA_Environment &default_environment (void);
+  class TAO_Export Environment
+  {
+  public:
+    /// The default constructor.  The environment will hold no
+    /// exceptions.
+    Environment (void);
+
+    /// Copy constructor.
+    Environment (const Environment &ACE_TRY_ENV);
+
+    /// Assingment.
+    Environment &operator=(const Environment &ACE_TRY_ENV);
+
+    /// Destructor, release the exception.
+    ~Environment (void);
+
+    /// Some static methods that need to be defined in every pseudo object
+    static Environment * _duplicate (Environment *);
+    static Environment * _nil (void);
+
+    /// Return the contained CORBA::Exception.
+    /**
+     * CORBA::Environment retains ownership of the exception, this is
+     * contrary to the normal memory management rules in the C++
+     * mapping, but actually mandated by the specification:
+     *
+     * "C++ Language Mapping" (formal/00-01-02). Section 1.27
+     * Environment (page 1-113)
+     */
+    CORBA::Exception* exception (void) const;
+
+    /// Set the contained CORBA::Exception to <ex>
+    /**
+     * CORBA::Environment assumes ownership of the exception, this is
+     * contrary to the normal memory management rules in the C++
+     * mapping, but actually mandated by the specification:
+     *
+     * "C++ Language Mapping" (formal/00-01-02). Section 1.27
+     * Environment (page 1-113)
+     *
+     */
+    void exception (CORBA::Exception *ex);
+
+    /// Return if the exception is a user exception or a system
+    /// exception.
+    int exception_type (void) const;
+
+    /// return the repository ID for the exception.
+    const char *exception_id (void) const;
+
+    /// Clear the exception.
+    void clear (void);
+
+    /// Print the exception to output determined by f.  This function
+    /// is not CORBA compliant.
+    void print_exception (const char *info,
+                          FILE *f=stdout) const;
+
+    // = Obtain a default environment to use with TAO.
+    static CORBA::Environment &default_environment (void);
 
 #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-  typedef CORBA_Environment_ptr _ptr_type;
-  typedef CORBA_Environment_var _var_type;
+    // Useful for template programming.
+    typedef CORBA::Environment_ptr _ptr_type;
+    typedef CORBA::Environment_var _var_type;
 #endif /* __GNUC__ */
-  // Useful for template programming.
 
-private:
+  private:
 
-  /// Initialize using a well known ORB Core; this is intended for the
-  /// bootstraping of the ORB_Core, not for general consumption.
-  friend class TAO_ORB_Core;
-  CORBA_Environment (TAO_ORB_Core *orb_core);
+    /// Initialize using a well known ORB Core; this is intended for
+    /// the bootstraping of the ORB_Core, not for general
+    /// consumption.
+    friend class TAO_ORB_Core;
+    Environment (TAO_ORB_Core *orb_core);
 
-  /// Pointer to the exception object contained in the environment.
-  CORBA_Exception *exception_;
+    /// Pointer to the exception object contained in the environment.
+    CORBA::Exception *exception_;
 
-  /// The previous environment on the "default environment stack".
-  CORBA_Environment *previous_;
-};
+    /// The previous environment on the "default environment stack".
+    Environment *previous_;
+  };
 
-/**
- * @class CORBA_Environment_var
- *
- * @brief CORBA_Environment_var
- *
- * Provide for automatic storage deallocation on going out of
- * scope.
- */
-class TAO_Export CORBA_Environment_var
-{
-public:
   /**
-   * default constructor
-   * copy constructor
-   * destructor
+   * @class Environment_var
+   *
+   * @brief Environment_var
+   *
+   * Provide for automatic storage deallocation on going out of
+   * scope.
    */
-  CORBA_Environment_var (void);
-  CORBA_Environment_var (CORBA_Environment_ptr);
-  CORBA_Environment_var (const CORBA_Environment_var &);
-  ~CORBA_Environment_var (void);
-
-  CORBA_Environment_var &operator= (CORBA_Environment_ptr);
-  CORBA_Environment_var &operator= (const CORBA_Environment_var &);
-  CORBA_Environment_ptr operator-> (void) const;
-
-  /// in, inout, out, _retn
-  operator const CORBA_Environment_ptr &() const;
-  operator CORBA_Environment_ptr &();
-  CORBA_Environment_ptr in (void) const;
-  CORBA_Environment_ptr &inout (void);
-  CORBA_Environment_ptr &out (void);
-  CORBA_Environment_ptr _retn (void);
-  CORBA_Environment_ptr ptr (void) const;
-
-private:
-  CORBA_Environment_ptr ptr_;
-};
+  class TAO_Export Environment_var
+  {
+  public:
+    /**
+     * default constructor
+     * copy constructor
+     * destructor
+     */
+    Environment_var (void);
+    Environment_var (CORBA::Environment_ptr);
+    Environment_var (const Environment_var &);
+    ~Environment_var (void);
+
+    Environment_var &operator= (CORBA::Environment_ptr);
+    Environment_var &operator= (const Environment_var &);
+    CORBA::Environment_ptr operator-> (void) const;
+
+    /// in, inout, out, _retn
+    operator const CORBA::Environment_ptr &() const;
+    operator CORBA::Environment_ptr &();
+    CORBA::Environment_ptr in (void) const;
+    CORBA::Environment_ptr &inout (void);
+    CORBA::Environment_ptr &out (void);
+    CORBA::Environment_ptr _retn (void);
+    CORBA::Environment_ptr ptr (void) const;
+
+  private:
+    CORBA::Environment_ptr ptr_;
+  };
 
-/**
- * @class CORBA_Environment_out
- *
- * @brief CORBA_Environment_out
- *
- * The _out class for CORBA_Environment. This is used to help in
- * managing the out parameters.
- */
-class TAO_Export CORBA_Environment_out
-{
-public:
-  CORBA_Environment_out (CORBA_Environment_ptr &);
-  CORBA_Environment_out (CORBA_Environment_var &);
-  CORBA_Environment_out (const CORBA_Environment_out &);
-  CORBA_Environment_out &operator= (const CORBA_Environment_out &);
-  CORBA_Environment_out &operator= (CORBA_Environment_ptr);
-  operator CORBA_Environment_ptr &();
-  CORBA_Environment_ptr &ptr (void);
-  CORBA_Environment_ptr operator-> (void);
-
-private:
-  CORBA_Environment_ptr &ptr_;
-
-  /// Assignment from _var not allowed.
-  CORBA_Environment_out &operator= (const CORBA_Environment_var &);
-};
+  /**
+   * @class Environment_out
+   *
+   * @brief Environment_out
+   *
+   * The _out class for CORBA::Environment.  This is used to help in
+   * managing the out parameters.
+   */
+  class TAO_Export Environment_out
+  {
+  public:
+    Environment_out (Environment_ptr &);
+    Environment_out (Environment_var &);
+    Environment_out (const Environment_out &);
+    Environment_out &operator= (const Environment_out &);
+    Environment_out &operator= (CORBA::Environment_ptr);
+    operator CORBA::Environment_ptr &();
+    CORBA::Environment_ptr &ptr (void);
+    CORBA::Environment_ptr operator-> (void);
+
+  private:
+    Environment_ptr &ptr_;
+
+    /// Assignment from _var not allowed.
+    Environment_out &operator= (const CORBA::Environment_var &);
+  };
+} // End CORBA namespace
 
 #if defined (__ACE_INLINE__)
 # include "tao/Environment.i"
diff --git a/TAO/tao/Environment.i b/TAO/tao/Environment.i
index 1b03dda71ef..b2aadaf0791 100644
--- a/TAO/tao/Environment.i
+++ b/TAO/tao/Environment.i
@@ -1,4 +1,5 @@
-// This may look like C, but it's really -*- C++ -*-
+// -*- C++ -*-
+//
 // $Id$
 
 ACE_INLINE CORBA::Boolean
@@ -15,113 +16,113 @@ CORBA::release (CORBA::Environment_ptr env)
   delete env;
 }
 
-ACE_INLINE CORBA_Exception*
-CORBA_Environment::exception (void) const
+ACE_INLINE CORBA::Exception*
+CORBA::Environment::exception (void) const
 {
   return this->exception_;
 }
 
-ACE_INLINE CORBA_Environment *
-CORBA_Environment::_duplicate (CORBA_Environment *x)
+ACE_INLINE CORBA::Environment *
+CORBA::Environment::_duplicate (CORBA::Environment *x)
 {
   if (x == 0)
     return 0;
-  return new CORBA_Environment (*x);
+  return new CORBA::Environment (*x);
 }
 
-ACE_INLINE CORBA_Environment_ptr
-CORBA_Environment::_nil (void)
+ACE_INLINE CORBA::Environment_ptr
+CORBA::Environment::_nil (void)
 {
-  return (CORBA_Environment_ptr)0;
+  return (CORBA::Environment_ptr)0;
 }
 
-// Inline operations for class CORBA_Environment_var
+// Inline operations for class CORBA::Environment_var
 
 ACE_INLINE
-CORBA_Environment_var::CORBA_Environment_var (void)
+CORBA::Environment_var::Environment_var (void)
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_Environment_var::CORBA_Environment_var (CORBA_Environment_ptr p)
+CORBA::Environment_var::Environment_var (CORBA::Environment_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_Environment_ptr
-CORBA_Environment_var::ptr (void) const
+ACE_INLINE CORBA::Environment_ptr
+CORBA::Environment_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_Environment_var::CORBA_Environment_var (const CORBA_Environment_var &p)
-  : ptr_ (new CORBA_Environment (*p.ptr ()))
+CORBA::Environment_var::Environment_var (const CORBA::Environment_var &p)
+  : ptr_ (new CORBA::Environment (*p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_Environment_var::~CORBA_Environment_var (void)
+CORBA::Environment_var::~Environment_var (void)
 {
   delete this->ptr_;
 }
 
 ACE_INLINE
-CORBA_Environment_var::operator const CORBA_Environment_ptr &() const
+CORBA::Environment_var::operator const CORBA::Environment_ptr &() const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_Environment_var::operator CORBA_Environment_ptr &()
+CORBA::Environment_var::operator CORBA::Environment_ptr &()
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Environment_ptr
-CORBA_Environment_var::operator-> (void) const
+ACE_INLINE CORBA::Environment_ptr
+CORBA::Environment_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Environment_ptr
-CORBA_Environment_var::in (void) const
+ACE_INLINE CORBA::Environment_ptr
+CORBA::Environment_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Environment_ptr &
-CORBA_Environment_var::inout (void)
+ACE_INLINE CORBA::Environment_ptr &
+CORBA::Environment_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Environment_ptr &
-CORBA_Environment_var::out (void)
+ACE_INLINE CORBA::Environment_ptr &
+CORBA::Environment_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Environment_ptr
-CORBA_Environment_var::_retn (void)
+ACE_INLINE CORBA::Environment_ptr
+CORBA::Environment_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_Environment_ptr val = this->ptr_;
+  CORBA::Environment_ptr val = this->ptr_;
   this->ptr_ = 0;
   return val;
 }
 
-// Inline operations for class CORBA_Environment_out
+// Inline operations for class CORBA::Environment_out
 
 ACE_INLINE
-CORBA_Environment_out::CORBA_Environment_out (CORBA_Environment_ptr &p)
+CORBA::Environment_out::Environment_out (CORBA::Environment_ptr &p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_Environment_out::CORBA_Environment_out (CORBA_Environment_var &p)
+CORBA::Environment_out::Environment_out (CORBA::Environment_var &p)
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -129,38 +130,38 @@ CORBA_Environment_out::CORBA_Environment_out (CORBA_Environment_var &p)
 }
 
 ACE_INLINE
-CORBA_Environment_out::CORBA_Environment_out (const CORBA_Environment_out &p)
+CORBA::Environment_out::Environment_out (const CORBA::Environment_out &p)
   : ptr_ (p.ptr_)
 {}
 
-ACE_INLINE CORBA_Environment_out &
-CORBA_Environment_out::operator= (const CORBA_Environment_out &p)
+ACE_INLINE CORBA::Environment_out &
+CORBA::Environment_out::operator= (const CORBA::Environment_out &p)
 {
   this->ptr_ = p.ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_Environment_out &
-CORBA_Environment_out::operator= (CORBA_Environment_ptr p)
+ACE_INLINE CORBA::Environment_out &
+CORBA::Environment_out::operator= (CORBA::Environment_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE
-CORBA_Environment_out::operator CORBA_Environment_ptr &()
+CORBA::Environment_out::operator CORBA::Environment_ptr &()
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Environment_ptr &
-CORBA_Environment_out::ptr (void)
+ACE_INLINE CORBA::Environment_ptr &
+CORBA::Environment_out::ptr (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Environment_ptr
-CORBA_Environment_out::operator-> (void)
+ACE_INLINE CORBA::Environment_ptr
+CORBA::Environment_out::operator-> (void)
 {
   return this->ptr_;
 }
diff --git a/TAO/tao/Exception.cpp b/TAO/tao/Exception.cpp
index f56c11b9f36..ea903bb24bf 100644
--- a/TAO/tao/Exception.cpp
+++ b/TAO/tao/Exception.cpp
@@ -40,15 +40,15 @@ extern CORBA::TypeCode_ptr TC_completion_status;
 
 // ****************************************************************
 
-CORBA_Exception::CORBA_Exception (const char *repository_id,
-                                  const char *local_name)
+CORBA::Exception::Exception (const char *repository_id,
+                             const char *local_name)
   : id_ (CORBA::string_dup (repository_id)),
-    name_ ( CORBA::string_dup (local_name))
+    name_ (CORBA::string_dup (local_name))
 {
   ACE_ASSERT (this->id_ != 0 && this->name_ != 0);
 }
 
-CORBA_Exception::CORBA_Exception (const CORBA_Exception &src)
+CORBA::Exception::Exception (const CORBA::Exception &src)
   : id_ (CORBA::string_dup (src.id_)),
     name_ (CORBA::string_dup (src.name_))
 {
@@ -59,20 +59,20 @@ CORBA_Exception::CORBA_Exception (const CORBA_Exception &src)
 // responsible for releasing any storage owned by the exception.  It
 // can do this because it's got the local name and the id.
 
-CORBA_Exception::CORBA_Exception (void)
+CORBA::Exception::Exception (void)
   : id_ (0),
     name_ (0)
 {
 }
 
-CORBA_Exception::~CORBA_Exception (void)
+CORBA::Exception::~Exception (void)
 {
   CORBA::string_free (this->id_);
   CORBA::string_free (this->name_);
 }
 
-CORBA_Exception &
-CORBA_Exception::operator= (const CORBA_Exception &src)
+CORBA::Exception &
+CORBA::Exception::operator= (const CORBA::Exception &src)
 {
   if (this->id_)
     {
@@ -94,33 +94,33 @@ CORBA_Exception::operator= (const CORBA_Exception &src)
 }
 
 const char *
-CORBA_Exception::_rep_id (void) const
+CORBA::Exception::_rep_id (void) const
 {
   return this->id_;
 }
 
 const char *
-CORBA_Exception::_name (void) const
+CORBA::Exception::_name (void) const
 {
   return this->name_;
 }
 
 CORBA::TypeCode_ptr
-CORBA_Exception::_type (void) const
+CORBA::Exception::_type (void) const
 {
   return CORBA::TypeCode::_nil ();
 }
 
 int
-CORBA_Exception::_is_a (const char* repository_id) const
+CORBA::Exception::_is_a (const char* repository_id) const
 {
   return ACE_OS_String::strcmp (repository_id,
                                 "IDL:omg.org/CORBA/Exception:1.0") == 0;
 }
 
 void
-CORBA_Exception::_tao_print_exception (const char *user_provided_info,
-                                       FILE *) const
+CORBA::Exception::_tao_print_exception (const char *user_provided_info,
+                                        FILE *) const
 {
   ACE_DEBUG ((LM_ERROR,
               ACE_LIB_TEXT("(%P|%t) EXCEPTION, %s\n")
@@ -131,20 +131,20 @@ CORBA_Exception::_tao_print_exception (const char *user_provided_info,
 
 #if defined (ACE_USES_WCHAR)
 void
-CORBA_Exception::_tao_print_exception (const ACE_WCHAR_T *info,
-                                       FILE *f) const
+CORBA::Exception::_tao_print_exception (const ACE_WCHAR_T *info,
+                                        FILE *f) const
 {
-    // Even though this call causes additional type conversions,
-    // this is better for the maintenance.  Plus, this will occur
-    // only on exception anyway.
-    this->_tao_print_exception(ACE_TEXT_ALWAYS_CHAR(info), f);
+  // Even though this call causes additional type conversions, this is
+  // better for the maintenance.  Plus, this will occur only on
+  // exception anyway.
+  this->_tao_print_exception (ACE_TEXT_ALWAYS_CHAR (info), f);
 }
 #endif  // ACE_USES_WCHAR
 
 void
-CORBA_Exception::_tao_any_destructor (void *x)
+CORBA::Exception::_tao_any_destructor (void *x)
 {
-  CORBA_Exception *tmp = ACE_static_cast (CORBA_Exception *, x);
+  CORBA::Exception *tmp = ACE_static_cast (CORBA::Exception *, x);
   delete tmp;
 }
 
@@ -152,7 +152,7 @@ CORBA_Exception::_tao_any_destructor (void *x)
 
 // Convenient ostrean operator.
 ostream& operator<< (ostream &os,
-                     const CORBA_Exception &e)
+                     const CORBA::Exception &e)
 {
   os << e._name () << " (" << e._rep_id () << ')';
 
@@ -163,42 +163,42 @@ ostream& operator<< (ostream &os,
 
 // Avoid zillions of not-quite-inlined copies of utilities.
 
-CORBA_UserException::CORBA_UserException (void)
+CORBA::UserException::UserException (void)
 {
 }
 
-CORBA_UserException::CORBA_UserException (const char *repository_id,
-                                          const char *local_name)
-  : CORBA_Exception (repository_id,
-                     local_name)
+CORBA::UserException::UserException (const char *repository_id,
+                                     const char *local_name)
+  : CORBA::Exception (repository_id,
+                      local_name)
 {
 }
 
-CORBA_UserException::~CORBA_UserException (void)
+CORBA::UserException::~UserException (void)
 {
 }
 
-CORBA_UserException &
-CORBA_UserException::operator= (const CORBA_UserException &src)
+CORBA::UserException &
+CORBA::UserException::operator= (const CORBA::UserException &src)
 {
-  this->CORBA_Exception::operator= (src);
+  this->Exception::operator= (src);
   return *this;
 }
 
 int
-CORBA_UserException::_is_a (const char* interface_id) const
+CORBA::UserException::_is_a (const char* interface_id) const
 {
   return ACE_OS_String::strcmp (interface_id,
                                 "IDL:omg.org/CORBA/UserException:1.0") == 0
-    || CORBA_Exception::_is_a (interface_id);
+    || this->Exception::_is_a (interface_id);
 }
 
-CORBA_UserException*
-CORBA_UserException::_downcast (CORBA_Exception* exception)
+CORBA::UserException*
+CORBA::UserException::_downcast (CORBA::Exception* exception)
 {
   if (exception->_is_a ("IDL:omg.org/CORBA/UserException:1.0"))
     {
-      return ACE_dynamic_cast (CORBA_UserException *,
+      return ACE_dynamic_cast (CORBA::UserException *,
                                exception);
     }
 
@@ -206,7 +206,7 @@ CORBA_UserException::_downcast (CORBA_Exception* exception)
 }
 
 ACE_CString
-CORBA_UserException::_info (void) const
+CORBA::UserException::_info (void) const
 {
   // @@ we can use the exception's typecode to dump all the data held
   // within it ...
@@ -226,36 +226,36 @@ TAO_NAMESPACE_END
 
 // ****************************************************************
 
-CORBA_SystemException::CORBA_SystemException (void)
+CORBA::SystemException::SystemException (void)
 {
 }
 
-CORBA_SystemException::CORBA_SystemException (const char *repository_id,
-                                              const char *local_name,
-                                              CORBA::ULong code,
-                                              CORBA::CompletionStatus completed)
-  : CORBA_Exception (repository_id,
-                     local_name),
+CORBA::SystemException::SystemException (const char *repository_id,
+                                         const char *local_name,
+                                         CORBA::ULong code,
+                                         CORBA::CompletionStatus completed)
+  : CORBA::Exception (repository_id,
+                      local_name),
     minor_ (code),
     completed_ (completed)
 {
 }
 
-CORBA_SystemException::CORBA_SystemException (const CORBA_SystemException &src)
-  : CORBA_Exception (src),
+CORBA::SystemException::SystemException (const CORBA::SystemException &src)
+  : CORBA::Exception (src),
     minor_ (src.minor_),
     completed_ (src.completed_)
 {
 }
 
-CORBA_SystemException::~CORBA_SystemException (void)
+CORBA::SystemException::~SystemException (void)
 {
 }
 
-CORBA_SystemException &
-CORBA_SystemException::operator= (const CORBA_SystemException &src)
+CORBA::SystemException &
+CORBA::SystemException::operator= (const CORBA::SystemException &src)
 {
-  this->CORBA_Exception::operator= (src);
+  this->Exception::operator= (src);
 
   this->minor_ = src.minor_;
   this->completed_ = src.completed_;
@@ -264,19 +264,19 @@ CORBA_SystemException::operator= (const CORBA_SystemException &src)
 }
 
 int
-CORBA_SystemException::_is_a (const char* interface_id) const
+CORBA::SystemException::_is_a (const char* interface_id) const
 {
   return ACE_OS_String::strcmp (interface_id,
                                 "IDL:omg.org/CORBA/SystemException:1.0") == 0
-    || CORBA_Exception::_is_a (interface_id);
+    || this->Exception::_is_a (interface_id);
 }
 
-CORBA_SystemException*
-CORBA_SystemException::_downcast (CORBA_Exception* exception)
+CORBA::SystemException*
+CORBA::SystemException::_downcast (CORBA::Exception* exception)
 {
   if (exception->_is_a ("IDL:omg.org/CORBA/SystemException:1.0"))
     {
-      return ACE_dynamic_cast (CORBA_SystemException *,
+      return ACE_dynamic_cast (CORBA::SystemException *,
                                exception);
     }
 
@@ -284,8 +284,8 @@ CORBA_SystemException::_downcast (CORBA_Exception* exception)
 }
 
 void
-CORBA_SystemException::_tao_encode (TAO_OutputCDR &cdr
-                                    ACE_ENV_ARG_DECL) const
+CORBA::SystemException::_tao_encode (TAO_OutputCDR &cdr
+                                     ACE_ENV_ARG_DECL) const
 {
   if (cdr.write_string (this->_rep_id ())
       && cdr.write_ulong (this->minor ())
@@ -298,8 +298,8 @@ CORBA_SystemException::_tao_encode (TAO_OutputCDR &cdr
 }
 
 void
-CORBA_SystemException::_tao_decode (TAO_InputCDR &cdr
-                                    ACE_ENV_ARG_DECL)
+CORBA::SystemException::_tao_decode (TAO_InputCDR &cdr
+                                     ACE_ENV_ARG_DECL)
 {
   // The string is read by the caller, to determine the exact type of
   // the exception.  We just decode the fields...
@@ -317,7 +317,7 @@ CORBA_SystemException::_tao_decode (TAO_InputCDR &cdr
 }
 
 CORBA::ULong
-CORBA_SystemException::_tao_errno (int errno_value)
+CORBA::SystemException::_tao_errno (int errno_value)
 {
   switch (errno_value)
     {
@@ -378,8 +378,8 @@ CORBA_SystemException::_tao_errno (int errno_value)
 }
 
 CORBA::ULong
-CORBA_SystemException::_tao_minor_code (u_int location,
-                                        int errno_value)
+CORBA::SystemException::_tao_minor_code (u_int location,
+                                         int errno_value)
 {
   return
     TAO_DEFAULT_MINOR_CODE
@@ -388,7 +388,7 @@ CORBA_SystemException::_tao_minor_code (u_int location,
 }
 
 void
-CORBA_SystemException::_tao_print_system_exception (FILE *) const
+CORBA::SystemException::_tao_print_system_exception (FILE *) const
 {
   ACE_DEBUG ((LM_ERROR,
               ACE_LIB_TEXT("(%P|%t) system exception, ID '%s'\n"),
@@ -396,7 +396,7 @@ CORBA_SystemException::_tao_print_system_exception (FILE *) const
 }
 
 ACE_CString
-CORBA_SystemException::_info (void) const
+CORBA::SystemException::_info (void) const
 {
   // @@ there are a other few "user exceptions" in the CORBA scope,
   // they're not all standard/system exceptions ... really need to
@@ -620,7 +620,7 @@ CORBA_SystemException::_info (void) const
 }
 
 const char *
-CORBA_SystemException::_tao_get_omg_exception_description (
+CORBA::SystemException::_tao_get_omg_exception_description (
   const CORBA::SystemException &exc,
   CORBA::ULong minor_code)
 {
@@ -869,7 +869,7 @@ void
 TAO_Exceptions::make_unknown_user_typecode (CORBA::TypeCode_ptr &tcp
                                             ACE_ENV_ARG_DECL)
 {
-  // Create the TypeCode for the CORBA_UnknownUserException.
+  // Create the TypeCode for the CORBA::UnknownUserException.
 
 #if defined(ACE_MVS)
   // @@ We need to use a translator to make sure that all TypeCodes
@@ -904,18 +904,18 @@ TAO_Exceptions::make_unknown_user_typecode (CORBA::TypeCode_ptr &tcp
     || stream.write_ulong (1L) == 0
     || stream.write_string (field_name) == 0;
   if (result)
-    ACE_THROW (CORBA_INITIALIZE ());
+    ACE_THROW (CORBA::INITIALIZE ());
 
   if (!(stream << CORBA::_tc_any))
-    ACE_THROW (CORBA_INITIALIZE ());
+    ACE_THROW (CORBA::INITIALIZE ());
 
   ACE_NEW_THROW_EX (tcp,
                     CORBA::TypeCode (CORBA::tk_except,
                                      stream.length (),
                                      stream.buffer (),
                                      1,
-                                     sizeof (CORBA_UserException)),
-                    CORBA_INITIALIZE ());
+                                     sizeof (CORBA::UserException)),
+                    CORBA::INITIALIZE ());
 }
 
 void
@@ -1003,8 +1003,8 @@ TAO_Exceptions::make_standard_typecode (CORBA::TypeCode_ptr &tcp,
                                      stream.length (),
                                      stream.buffer (),
                                      1,
-                                     sizeof (CORBA_SystemException)),
-                    CORBA_INITIALIZE ());
+                                     sizeof (CORBA::SystemException)),
+                    CORBA::INITIALIZE ());
   ACE_CHECK;
 
   ACE_ASSERT (tcp->length_ <= buflen);
@@ -1066,11 +1066,9 @@ TAO_Exceptions::make_standard_typecode (CORBA::TypeCode_ptr &tcp,
 #define TAO_TC_BUF_LEN 256
 
 #define TAO_SYSTEM_EXCEPTION(name) \
-    static CORBA::Long tc_buf_##name[TAO_TC_BUF_LEN/sizeof(CORBA::Long)]; \
-    TAO_NAMESPACE_TYPE(CORBA::TypeCode_ptr) \
-    TAO_NAMESPACE_BEGIN (CORBA) \
-    TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_##name, 0) \
-    TAO_NAMESPACE_END
+    static CORBA::Long tc_buf_##name[TAO_TC_BUF_LEN / sizeof (CORBA::Long)]; \
+    CORBA::TypeCode_ptr CORBA::_tc_##name = 0;
+
   STANDARD_EXCEPTION_LIST
 #undef  TAO_SYSTEM_EXCEPTION
 #undef TAO_TC_BUF_LEN
@@ -1085,8 +1083,6 @@ TAO_Exceptions::init (ACE_ENV_SINGLE_ARG_DECL)
   if (TAO_Exceptions::initialized_ != 0)
     return;
 
-  TAO_Exceptions::initialized_ = 1;
-
   // Initialize the start up allocator.
   ACE_NEW (TAO_Exceptions::global_allocator_,
            ACE_New_Allocator);
@@ -1094,18 +1090,20 @@ TAO_Exceptions::init (ACE_ENV_SINGLE_ARG_DECL)
 #define TAO_SYSTEM_EXCEPTION(name) \
   TAO_Exceptions::make_standard_typecode (CORBA::_tc_ ## name, \
                                           #name, \
-                                          (char*)tc_buf_##name, \
-                                          sizeof(tc_buf_##name) \
-                                           ACE_ENV_ARG_PARAMETER); \
+                                          (char*) tc_buf_##name, \
+                                          sizeof (tc_buf_##name) \
+                                          ACE_ENV_ARG_PARAMETER); \
   ACE_CHECK;
   STANDARD_EXCEPTION_LIST
 #undef  TAO_SYSTEM_EXCEPTION
 
   TAO_Exceptions::make_unknown_user_typecode (CORBA::_tc_UnknownUserException
                                               ACE_ENV_ARG_PARAMETER);
+
+  TAO_Exceptions::initialized_ = 1;
 }
 
-CORBA_SystemException *
+CORBA::SystemException *
 TAO_Exceptions::create_system_exception (const char *id
                                          ACE_ENV_ARG_DECL_NOT_USED)
 {
@@ -1139,22 +1137,22 @@ TAO_Exceptions::fini (void)
 
 #define TAO_SYSTEM_EXCEPTION(name) \
 int \
-CORBA_##name ::_is_a (const char* interface_id) const \
+CORBA::##name ::_is_a (const char* interface_id) const \
 { \
   return ((ACE_OS_String::strcmp ( \
                interface_id, \
                "IDL:omg.org/CORBA/" #name ":1.0") == 0) \
-          || CORBA_SystemException::_is_a (interface_id)); \
+          || this->SystemException::_is_a (interface_id)); \
 }
 STANDARD_EXCEPTION_LIST
 #undef TAO_SYSTEM_EXCEPTION
 
 #define TAO_SYSTEM_EXCEPTION(name) \
-CORBA_##name * \
-CORBA_##name ::_downcast (CORBA_Exception* exception) \
+CORBA::##name * \
+CORBA::##name ::_downcast (CORBA::Exception* exception) \
 { \
   if (exception->_is_a ("IDL:omg.org/CORBA/" #name ":1.0")) \
-    return ACE_dynamic_cast (CORBA_##name *, exception); \
+    return ACE_dynamic_cast (CORBA::##name *, exception); \
   return 0; \
 }
 STANDARD_EXCEPTION_LIST
@@ -1162,19 +1160,20 @@ STANDARD_EXCEPTION_LIST
 
 #define TAO_SYSTEM_EXCEPTION(name) \
 void \
-CORBA_##name ::_raise (void) \
+CORBA::##name ::_raise (void) \
 { \
   TAO_RAISE (*this); \
 }
 STANDARD_EXCEPTION_LIST
 #undef TAO_SYSTEM_EXCEPTION
 
+// SystemException constructors
 #define TAO_SYSTEM_EXCEPTION(name) \
-CORBA_##name :: CORBA_##name (void) \
-  :  CORBA_SystemException ("IDL:omg.org/CORBA/" #name ":1.0", \
-                            #name, \
-                            TAO_DEFAULT_MINOR_CODE, \
-                            CORBA::COMPLETED_NO) \
+CORBA::##name ::##name (void) \
+  :  CORBA::SystemException ("IDL:omg.org/CORBA/" #name ":1.0", \
+                             #name, \
+                             TAO_DEFAULT_MINOR_CODE, \
+                             CORBA::COMPLETED_NO) \
 { \
 }
 STANDARD_EXCEPTION_LIST
@@ -1182,7 +1181,7 @@ STANDARD_EXCEPTION_LIST
 
 #define TAO_SYSTEM_EXCEPTION(name) \
 CORBA::TypeCode_ptr \
-CORBA_##name ::_type (void) const \
+CORBA::##name ::_type (void) const \
 { \
   return CORBA::_tc_ ## name; \
 }
@@ -1191,20 +1190,20 @@ STANDARD_EXCEPTION_LIST
 
 #define TAO_SYSTEM_EXCEPTION(name) \
 void \
-CORBA_##name ::_tao_any_destructor (void *x) \
+CORBA::##name ::_tao_any_destructor (void *x) \
 { \
-  CORBA_##name *tmp = ACE_static_cast (CORBA_##name *, x); \
+  CORBA::##name *tmp = ACE_static_cast (CORBA::##name *, x); \
   delete tmp; \
 }
 STANDARD_EXCEPTION_LIST
 #undef TAO_SYSTEM_EXCEPTION
 
 #define TAO_SYSTEM_EXCEPTION(name) \
-CORBA_Exception * \
-CORBA_##name ::_tao_duplicate (void) const \
+CORBA::Exception * \
+CORBA::##name ::_tao_duplicate (void) const \
 { \
-  CORBA_Exception *result; \
-  ACE_NEW_RETURN (result, CORBA_##name (*this), 0); \
+  CORBA::Exception *result; \
+  ACE_NEW_RETURN (result, CORBA::##name (*this), 0); \
   return result; \
 }
 STANDARD_EXCEPTION_LIST
@@ -1236,10 +1235,10 @@ tao_insert_for_insertion_system_exception (CORBA::Any &any,
 }
 
 #define TAO_SYSTEM_EXCEPTION(name) \
-void operator<<= (CORBA::Any &any, const CORBA_##name &ex) \
+void operator<<= (CORBA::Any &any, const CORBA::##name &ex) \
 { \
   tao_insert_for_insertion_system_exception (any, ex, \
-            "\tCORBA::Any insertion (non-copy) of CORBA_" #name "\n" \
+            "\tCORBA::Any insertion (non-copy) of CORBA::" #name "\n" \
                                ); \
 }
 STANDARD_EXCEPTION_LIST
@@ -1276,11 +1275,11 @@ tao_insert_system_exception (CORBA::Any &any,
 }
 
 #define TAO_SYSTEM_EXCEPTION(name) \
-void operator<<= (CORBA::Any &any, CORBA_##name *ex) \
+void operator<<= (CORBA::Any &any, CORBA::##name *ex) \
 { \
   tao_insert_system_exception (any, ex, \
-          CORBA_##name ::_tao_any_destructor, \
-          "\tCORBA::Any insertion (non-copy) of CORBA_" #name "\n" \
+          CORBA::##name ::_tao_any_destructor, \
+          "\tCORBA::Any insertion (non-copy) of CORBA::" #name "\n" \
                                ); \
 }
 
@@ -1288,22 +1287,22 @@ STANDARD_EXCEPTION_LIST
 #undef TAO_SYSTEM_EXCEPTION
 
 #define TAO_SYSTEM_EXCEPTION(name) \
-static CORBA_SystemException* _tao_allocator_##name (void) \
+static CORBA::SystemException* _tao_allocator_##name (void) \
 { \
-  return new CORBA_##name; \
+  return new CORBA::##name; \
 }
 STANDARD_EXCEPTION_LIST
 #undef TAO_SYSTEM_EXCEPTION
 
 static CORBA::Boolean
 tao_insert_in_extractor_system_exception (
-        const CORBA::Any &any,
-        CORBA::SystemException *&tmp,
-        CORBA::SystemException * (*allocator)(void),
-        CORBA::TypeCode_ptr tc_name,
-        CORBA::Any::_tao_destructor destructor,
-        const char *compare_IR_Id,
-        const char *msg)
+  const CORBA::Any &any,
+  CORBA::SystemException *&tmp,
+  CORBA::SystemException * (*allocator)(void),
+  CORBA::TypeCode_ptr tc_name,
+  CORBA::Any::_tao_destructor destructor,
+  const char *compare_IR_Id,
+  const char *msg)
 {
   ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
@@ -1316,7 +1315,7 @@ tao_insert_in_extractor_system_exception (
         return 0;
       if (any.any_owns_data ())
         {
-          tmp = (CORBA_SystemException *)any.value ();
+          tmp = (CORBA::SystemException *)any.value ();
           return 1;
         }
       else
@@ -1356,22 +1355,22 @@ tao_insert_in_extractor_system_exception (
 
 #define TAO_SYSTEM_EXCEPTION(name) \
 CORBA::Boolean operator>>= (const CORBA::Any &any, \
-                            const CORBA_##name *&ex) \
+                            const CORBA::##name *&ex) \
 { \
   ex = 0; \
-  CORBA_SystemException *tmp; \
+  CORBA::SystemException *tmp; \
   if (tao_insert_in_extractor_system_exception (any, \
        tmp, \
        _tao_allocator_##name, \
        CORBA::_tc_##name, \
-       CORBA_##name ::_tao_any_destructor, \
+       CORBA::##name ::_tao_any_destructor, \
        "IDL:omg.org/CORBA/" #name ":1.0", \
-       "\tCORBA::Any extraction of CORBA_" #name "\n") == 0) \
+       "\tCORBA::Any extraction of CORBA::" #name "\n") == 0) \
          { \
              ex = 0; \
          return 0; \
          } \
- ex = (CORBA_##name*)tmp; \
+ ex = (CORBA::##name*)tmp; \
  return 1; \
 }
 
diff --git a/TAO/tao/Exception.h b/TAO/tao/Exception.h
index 645b6e1ee84..f87ecda46bb 100644
--- a/TAO/tao/Exception.h
+++ b/TAO/tao/Exception.h
@@ -9,7 +9,8 @@
  *   This file defines way in which CORBA exceptions are reported.
  *
  *
- *  @author  Copyright 1994-1995 by Sun Microsystems Inc.
+ *  @author Copyright 1994-1995 by Sun Microsystems Inc.
+ *  @author DOC Group at Wash U, UCI and Vanderbilt U.
  */
 //=============================================================================
 
@@ -23,8 +24,6 @@
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
-#include "ace/SString.h"
-
 // This is used in the implementation of the _raise methods
 #if defined (TAO_HAS_EXCEPTIONS)
 #define TAO_RAISE(EXCEPTION) throw EXCEPTION
@@ -32,281 +31,272 @@
 #define TAO_RAISE(EXCEPTION)
 #endif /* TAO_HAS_EXCEPTIONS */
 
+#include "ace/CORBA_macros.h"
 #include "ace/SString.h"
 
-class CORBA_Any;
+
 class TAO_OutputCDR;
 class TAO_InputCDR;
 
-/**
- * @class CORBA_Exception
- *
- * @brief CORBA_Exception
- *
- * CORBA2-specified exception hierarchy.  All exceptions have a
- * type (represented by a TypeCode) and a widely scoped type ID
- * (in the TypeCode) that generated by any OMG-IDL compiler and
- * available through the Interface Repositories.  Think of it as a
- * "globally scoped" name distinguishing each exception.
- */
-class TAO_Export CORBA_Exception
+namespace CORBA
 {
-public:
-  // = Initialization and termination methods.
+  /**
+   * @class Exception
+   *
+   * @brief Exception
+   *
+   * CORBA2-specified exception hierarchy.  All exceptions have a
+   * type (represented by a TypeCode) and a widely scoped type ID
+   * (in the TypeCode) that generated by any OMG-IDL compiler and
+   * available through the Interface Repositories.  Think of it as a
+   * "globally scoped" name distinguishing each exception.
+   */
+  class TAO_Export Exception
+  {
+  public:
 
-  /// Copy constructor.
-  CORBA_Exception (const CORBA_Exception &src);
+    /// Copy constructor.
+    Exception (const Exception &src);
 
-  /// Assignment operator.
-  CORBA_Exception &operator = (const CORBA_Exception &src);
+    /// Assignment operator.
+    Exception &operator = (const Exception &src);
 
-  /// Destructor.
-  virtual ~CORBA_Exception (void);
+    /// Destructor.
+    virtual ~Exception (void);
 
-  // = To throw the exception (when using the standard mapping).
-  virtual void _raise (void) = 0;
+    // = To throw the exception (when using the standard mapping).
+    virtual void _raise (void) = 0;
 
-  // = The static narrow operation.
-  static CORBA_Exception *_downcast (CORBA_Exception *x);
+    // = The static narrow operation.
+    static Exception *_downcast (Exception *x);
 
-  // = These are TAO-specific extensions.
+    // = These are TAO-specific extensions.
 
-  /// Return the repository ID of the Exception.
-  const char *_rep_id (void) const;
+    /// Return the repository ID of the Exception.
+    const char *_rep_id (void) const;
 
-  /// Return the name of the Exception.
-  const char *_name (void) const;
+    /// Return the name of the Exception.
+    const char *_name (void) const;
 
-  /// Will be overridden in the concrete derived classes.
-  virtual CORBA::TypeCode_ptr _type (void) const;
+    /// Will be overridden in the concrete derived classes.
+    virtual CORBA::TypeCode_ptr _type (void) const;
 
-  // = To implement the narrow method.
-  virtual int _is_a (const char* repository_id) const;
+    // = To implement the narrow method.
+    virtual int _is_a (const char* repository_id) const;
 
-  /// Constructor from a respository id.
-  CORBA_Exception (const char *repository_id,
-                   const char *local_name);
+    /// Constructor from a respository id.
+    Exception (const char *repository_id,
+               const char *local_name);
 
-  /// Print the exception <ex> to output determined by <f>.  This
-  /// function is not CORBA compliant.
-  void _tao_print_exception (const char *info,
-                             FILE *f = stdout) const;
+    /// Print the exception <ex> to output determined by <f>.  This
+    /// function is not CORBA compliant.
+    void _tao_print_exception (const char *info,
+                               FILE *f = stdout) const;
 
 #if defined (ACE_USES_WCHAR)
-  /// ACE_WCHAR_T version of _tao_print_exception.
-  void _tao_print_exception (const ACE_WCHAR_T *info,
-                             FILE *f = stdout) const;
+    /// ACE_WCHAR_T version of _tao_print_exception.
+    void _tao_print_exception (const ACE_WCHAR_T *info,
+                               FILE *f = stdout) const;
 #endif  // ACE_USES_WCHAR
 
-  /// Returns a string containing information about the exception. This
-  /// function is not CORBA compliant.
-  virtual ACE_CString _info (void) const = 0;
-
-  virtual void _tao_encode (TAO_OutputCDR &cdr
-                            ACE_ENV_ARG_DECL_NOT_USED) const = 0;
-  virtual void _tao_decode (TAO_InputCDR &cdr
-                            ACE_ENV_ARG_DECL_NOT_USED) = 0;
-
-  /// Used in the non-copying Any insertion operator.
-  static void _tao_any_destructor (void *);
+    /// Returns a string containing information about the exception. This
+    /// function is not CORBA compliant.
+    virtual ACE_CString _info (void) const = 0;
+
+    virtual void _tao_encode (TAO_OutputCDR &cdr
+                              ACE_ENV_ARG_DECL_NOT_USED) const = 0;
+    virtual void _tao_decode (TAO_InputCDR &cdr
+                              ACE_ENV_ARG_DECL_NOT_USED) = 0;
+
+    /// Used in the non-copying Any insertion operator.
+    static void _tao_any_destructor (void *);
+
+    /// Deep copy
+    /**
+     * The following operation is used in the implementation of
+     * it performs a deep copy of the
+     * exception, normally it is implemented as:
+     *
+     * <PRE>
+     * class SomeException : public // Derives from CORBA::Exception
+     * {
+     * public:
+     *   virtual CORBA::Exception *_tao_duplicate (void) const
+     *   {
+     *     return new SomeException (*this);
+     *   }
+     * };
+     * </PRE>
+     */
+    virtual CORBA::Exception *_tao_duplicate (void) const = 0;
+
+  protected:
+    /// Default constructor is protected.
+    Exception (void);
+
+  private:
+    /// Storage of our repository id and local name.
+    char *id_;
+    char *name_;
+  };
 
-  /// Deep copy
   /**
-   * The following operation is used in the implementation of
-   * it performs a deep copy of the
-   * exception, normally it is implemented as:
+   * @class UserException
    *
-   * <PRE>
-   * class SomeException : public // Derives from CORBA_Exception
-   * {
-   * public:
-   *   virtual CORBA_Exception *_tao_duplicate (void) const
-   *   {
-   *     return new SomeException (*this);
-   *   }
-   * };
-   * </PRE>
+   * @brief User exceptions are those defined by application developers
+   * using OMG-IDL.
    */
-  virtual CORBA_Exception *_tao_duplicate (void) const = 0;
-
-protected:
-  CORBA_Exception (void);
-  // Default constructor is protected.
-
-private:
-  /// Storage of our repository id and local name.
-  char *id_;
-  char *name_;
-};
-
-#if !defined (ACE_LACKS_IOSTREAM_TOTALLY)
-
-// Convenient ostream operator.
-TAO_Export ostream& operator<< (ostream &os,
-                                const CORBA_Exception &e);
-
-#endif /* (ACE_LACKS_IOSTREAM_TOTALLY) */
-
-/**
- * @class CORBA_UserException
- *
- * @brief User exceptions are those defined by application developers
- * using OMG-IDL.
- */
-class TAO_Export CORBA_UserException : public CORBA_Exception
-{
-public:
-  // = Initialization and termination methods.
+  class TAO_Export UserException : public CORBA::Exception
+  {
+  public:
 
-  /// Copy constructor.
-  CORBA_UserException (const CORBA_UserException &src);
+    /// Copy constructor.
+    UserException (const UserException &src);
 
-  /// Destructor.
-  ~CORBA_UserException (void);
+    /// Destructor.
+    ~UserException (void);
 
-  /// Assignment operator.
-  CORBA_UserException &operator= (const CORBA_UserException &src);
+    /// Assignment operator.
+    UserException &operator= (const UserException &src);
 
-  /// The narrow operation.
-  static CORBA_UserException *_downcast (CORBA_Exception *exception);
+    /// The narrow operation.
+    static UserException *_downcast (CORBA::Exception *exception);
 
-  // = TAO specific extension.
+    // = TAO specific extension.
 
-  /// Constructor from a repository id.
-  CORBA_UserException (const char *repository_id,
-                       const char *local_name);
+    /// Constructor from a repository id.
+    UserException (const char *repository_id,
+                         const char *local_name);
 
-  virtual int _is_a (const char *interface_id) const;
+    virtual int _is_a (const char *interface_id) const;
 
-  // Used for narrowing
+    // Used for narrowing
 
-  /// Returns a string containing information about the exception. This
-  /// function is not CORBA compliant.
-  virtual ACE_CString _info (void) const;
+    /// Returns a string containing information about the exception. This
+    /// function is not CORBA compliant.
+    virtual ACE_CString _info (void) const;
 
-  //protected:
-  /// Default constructor.
-  CORBA_UserException (void);
-};
+    //protected:
+    /// Default constructor.
+    UserException (void);
+  };
 
-/**
- * @class CORBA_SystemException
- *
- * @brief CORBA_SystemException
- *
- * System exceptions are those defined in the CORBA spec; OMG-IDL
- * defines these.
- */
-class TAO_Export CORBA_SystemException : public CORBA_Exception
-{
-public:
-  // = Initialization and termination methods.
+  /**
+   * @class SystemException
+   *
+   * @brief SystemException
+   *
+   * System exceptions are those defined in the CORBA spec; OMG-IDL
+   * defines these.
+   */
+  class TAO_Export SystemException : public CORBA::Exception
+  {
+  public:
 
-  /// Default constructtor
-  CORBA_SystemException (void);
+    /// Default constructtor
+    SystemException (void);
 
-  /// Copy constructor.
-  CORBA_SystemException (const CORBA_SystemException &src);
+    /// Copy constructor.
+    SystemException (const SystemException &src);
 
-  /// Destructor.
-  ~CORBA_SystemException (void);
+    /// Destructor.
+    ~SystemException (void);
 
-  /// Assignment operator.
-  CORBA_SystemException &operator= (const CORBA_SystemException &src);
+    /// Assignment operator.
+    SystemException &operator= (const SystemException &src);
 
-  /// Get the minor status.
-  CORBA::ULong minor (void) const;
+    /// Get the minor status.
+    CORBA::ULong minor (void) const;
 
-  /// Set the minor status.
-  void minor (CORBA::ULong m);
+    /// Set the minor status.
+    void minor (CORBA::ULong m);
 
-  /// Get the completion status.
-  CORBA::CompletionStatus completed (void) const;
+    /// Get the completion status.
+    CORBA::CompletionStatus completed (void) const;
 
-  /// Set the operation completion status.
-  void completed (CORBA::CompletionStatus c);
+    /// Set the operation completion status.
+    void completed (CORBA::CompletionStatus c);
 
-  /// Narrow to a SystemException.
-  static CORBA_SystemException *_downcast (CORBA_Exception *exception);
+    /// Narrow to a SystemException.
+    static SystemException *_downcast (CORBA::Exception *exception);
 
-  // = TAO-specific extension.
+    // = TAO-specific extension.
 
-  /// Helper for the _downcast operation.
-  virtual int _is_a (const char *type_id) const;
+    /// Helper for the _downcast operation.
+    virtual int _is_a (const char *type_id) const;
 
-  /// Print the system exception <ex> to output determined by f.  This
-  /// function is not CORBA compliant.
-  void _tao_print_system_exception (FILE *f = stdout) const;
+    /// Print the system exception @c ex to output determined by @c f.
+    /// This function is not CORBA compliant.
+    void _tao_print_system_exception (FILE *f = stdout) const;
 
-  /// Returns a string containing information about the exception. This
-  /// function is not CORBA compliant.
-  virtual ACE_CString _info (void) const;
+    /// Returns a string containing information about the exception. This
+    /// function is not CORBA compliant.
+    virtual ACE_CString _info (void) const;
 
-  virtual void _tao_encode (TAO_OutputCDR &cdr
-                            ACE_ENV_ARG_DECL_NOT_USED) const;
-  virtual void _tao_decode (TAO_InputCDR &cdr
-                            ACE_ENV_ARG_DECL_NOT_USED);
+    virtual void _tao_encode (TAO_OutputCDR &cdr
+                              ACE_ENV_ARG_DECL_NOT_USED) const;
+    virtual void _tao_decode (TAO_InputCDR &cdr
+                              ACE_ENV_ARG_DECL_NOT_USED);
 
-  /// Helper to create a minor status value.
-  static CORBA::ULong _tao_minor_code (u_int location,
-                                       int errno_value);
+    /// Helper to create a minor status value.
+    static CORBA::ULong _tao_minor_code (u_int location,
+                                         int errno_value);
 
-  /// Helper to translate a platform-specific errno to a TAO errno
-  /// value.
-  static CORBA::ULong _tao_errno (int errno_value);
+    /// Helper to translate a platform-specific errno to a TAO errno
+    /// value.
+    static CORBA::ULong _tao_errno (int errno_value);
 
-protected:
+  protected:
 
-  /// Constructor using a repository id.
-  CORBA_SystemException (const char *repository_id,
-                         const char *local_name,
-                         CORBA::ULong code,
-                         CORBA::CompletionStatus completed);
+    /// Constructor using a repository id.
+    SystemException (const char *repository_id,
+                     const char *local_name,
+                     CORBA::ULong code,
+                     CORBA::CompletionStatus completed);
 
-  /// Return the exception description associated with the given OMG
-  /// minor code.
-  static const char *_tao_get_omg_exception_description (
+    /// Return the exception description associated with the given OMG
+    /// minor code.
+    static const char *_tao_get_omg_exception_description (
       const CORBA::SystemException &exc,
-      CORBA::ULong minor_code
-    );
+      CORBA::ULong minor_code);
 
-private:
-  /// Minor code.
-  CORBA::ULong minor_;
+  private:
+    /// Minor code.
+    CORBA::ULong minor_;
 
-  /// Completion status.
-  CORBA::CompletionStatus completed_;
+    /// Completion status.
+    CORBA::CompletionStatus completed_;
 
-};
+  };
 
-// Declarations for all of the CORBA standard exceptions.
-//
-// @@ - shouldn't have a default minor code, at least for code that's
-// inside the ORB.  All minor codes should be symbolically catalogued.
+  // Declarations for all of the CORBA standard exceptions.
+  //
+  // @@ - shouldn't have a default minor code, at least for code that's
+  // inside the ORB.  All minor codes should be symbolically catalogued.
 
 #define TAO_SYSTEM_EXCEPTION(name) \
-class TAO_Export CORBA_ ## name : public CORBA_SystemException { \
-public: \
-  CORBA_ ## name (void); \
-  CORBA_ ## name (CORBA::ULong code, \
-                  CORBA::CompletionStatus completed) \
-    : CORBA_SystemException ("IDL:omg.org/CORBA/" #name ":1.0", \
-                             #name, \
-                             code, \
-                             completed) \
-    { } \
-  static CORBA_##name * _downcast (CORBA_Exception* exception); \
-  virtual int _is_a (const char* type_id) const; \
-  virtual void _raise (void); \
-  virtual CORBA::TypeCode_ptr _type (void) const; \
-  static void _tao_any_destructor (void*); \
-  virtual CORBA_Exception *_tao_duplicate (void) const; \
-}; \
-TAO_Export void operator<<= (CORBA::Any &, const CORBA_##name &); \
-TAO_Export void operator<<= (CORBA::Any &, CORBA_##name *); \
+  class TAO_Export name : public CORBA::SystemException \
+  { \
+  public: \
+    name (void); \
+    name (CORBA::ULong code, \
+          CORBA::CompletionStatus completed) \
+      : CORBA::SystemException ("IDL:omg.org/CORBA/" #name ":1.0", \
+                                #name, \
+                                code, \
+                                completed) \
+      { } \
+    static name * _downcast (CORBA::Exception* exception); \
+    virtual int _is_a (const char* type_id) const; \
+    virtual void _raise (void); \
+    virtual CORBA::TypeCode_ptr _type (void) const; \
+    static void _tao_any_destructor (void*); \
+    virtual CORBA::Exception *_tao_duplicate (void) const; \
+  }; \
+TAO_Export void operator<<= (CORBA::Any &, const CORBA::##name &); \
+TAO_Export void operator<<= (CORBA::Any &, CORBA::##name *); \
 TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, \
-                                       const CORBA_##name *&)
-
+                                       const CORBA::##name *&)
 
 TAO_SYSTEM_EXCEPTION(UNKNOWN);          // the unknown exception
 TAO_SYSTEM_EXCEPTION(BAD_PARAM);        // an invalid parameter was passed
@@ -350,6 +340,16 @@ TAO_SYSTEM_EXCEPTION(ACTIVITY_REQUIRED);
 
 #undef TAO_SYSTEM_EXCEPTION
 
+} // End CORBA namespace
+
+#if !defined (ACE_LACKS_IOSTREAM_TOTALLY)
+
+// Convenient ostream operator.
+TAO_Export ostream& operator<< (ostream &os,
+                                const CORBA::Exception &e);
+
+#endif /* (ACE_LACKS_IOSTREAM_TOTALLY) */
+
 /**
  * @class TAO_Exceptions
  *
@@ -368,24 +368,24 @@ public:
                                       const char *name,
                                       char *buf,
                                       size_t buflen
-                                      ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+                                      ACE_ENV_ARG_DECL);
 
   /// Make the TypeCode for the CORBA::UnknownUserException standard
   /// exception.
   static void make_unknown_user_typecode (CORBA::TypeCode_ptr &tcp
-                                          ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+                                          ACE_ENV_ARG_DECL);
 
   /// Runtime initialization of all standard exception typecodes.
   /// Called from <CORBA::ORB_init>.
-  static void init (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
+  static void init (ACE_ENV_SINGLE_ARG_DECL);
 
   /// Runtime finalization of all standard exception typecodes.
   static void fini (void);
 
   /// Create a CORBA::SystemException given the interface repository ID.
-  static CORBA_SystemException *create_system_exception (
+  static CORBA::SystemException *create_system_exception (
       const char *id
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS
+      ACE_ENV_ARG_DECL
     );
 
 
diff --git a/TAO/tao/Exception.i b/TAO/tao/Exception.i
index 73084d4fb08..56bf7a1e6a9 100644
--- a/TAO/tao/Exception.i
+++ b/TAO/tao/Exception.i
@@ -1,38 +1,39 @@
-// This may look like C, but it's really -*- C++ -*-
+// -*- C++ -*-
+//
 // $Id$
 
-ACE_INLINE CORBA_Exception*
-CORBA_Exception::_downcast (CORBA_Exception* x)
+ACE_INLINE CORBA::Exception*
+CORBA::Exception::_downcast (CORBA::Exception* x)
 {
   return x;
 }
 
 ACE_INLINE
-CORBA_UserException::CORBA_UserException (const CORBA_UserException &src)
-  : CORBA_Exception (src)
+CORBA::UserException::UserException (const CORBA::UserException &src)
+  : CORBA::Exception (src)
 {
 }
 
 ACE_INLINE CORBA::ULong
-CORBA_SystemException::minor (void) const
+CORBA::SystemException::minor (void) const
 {
   return this->minor_;
 }
 
 ACE_INLINE void
-CORBA_SystemException::minor (CORBA::ULong m)
+CORBA::SystemException::minor (CORBA::ULong m)
 {
   this->minor_ = m;
 }
 
 ACE_INLINE CORBA::CompletionStatus
-CORBA_SystemException::completed (void) const
+CORBA::SystemException::completed (void) const
 {
   return this->completed_;
 }
 
 ACE_INLINE void
-CORBA_SystemException::completed (CORBA::CompletionStatus c)
+CORBA::SystemException::completed (CORBA::CompletionStatus c)
 {
   this->completed_ = c;
 }
diff --git a/TAO/tao/LocalObject.cpp b/TAO/tao/LocalObject.cpp
index ff44d98f9c8..d4319e014bb 100644
--- a/TAO/tao/LocalObject.cpp
+++ b/TAO/tao/LocalObject.cpp
@@ -1,8 +1,3 @@
-// -*- C++ -*-
-//
-// $Id$
-
-
 #include "LocalObject.h"
 
 #if !defined (__ACE_INLINE__)
@@ -10,24 +5,26 @@
 #endif /* ! __ACE_INLINE__ */
 
 #include "PolicyC.h"
+#include "debug.h"
+
 
 ACE_RCSID (tao,
            LocalObject,
            "$Id$")
 
 
-CORBA_LocalObject::~CORBA_LocalObject (void)
+CORBA::LocalObject::~LocalObject (void)
 {
 }
 
 void
-CORBA_LocalObject::_add_ref (void)
+CORBA::LocalObject::_add_ref (void)
 {
   // Do nothing as per CCM spec.
 }
 
 void
-CORBA_LocalObject::_remove_ref (void)
+CORBA::LocalObject::_remove_ref (void)
 {
   // Do nothing as per CCM spec.
 }
@@ -36,8 +33,8 @@ CORBA_LocalObject::_remove_ref (void)
 // create hash tables.
 
 CORBA::ULong
-CORBA_LocalObject::_hash (CORBA::ULong maximum
-                          ACE_ENV_ARG_DECL_NOT_USED)
+CORBA::LocalObject::_hash (CORBA::ULong maximum
+                           ACE_ENV_ARG_DECL_NOT_USED)
 {
   // Note that we reinterpret_cast to an "unsigned long" instead of
   // CORBA::ULong since we need to first cast to an integer large
@@ -56,8 +53,8 @@ CORBA_LocalObject::_hash (CORBA::ULong maximum
 // such as strcmp(), to allow more comparison algorithms.
 
 CORBA::Boolean
-CORBA_LocalObject::_is_equivalent (CORBA_Object_ptr other_obj
-                                   ACE_ENV_ARG_DECL_NOT_USED)
+CORBA::LocalObject::_is_equivalent (CORBA::Object_ptr other_obj
+                                    ACE_ENV_ARG_DECL_NOT_USED)
   ACE_THROW_SPEC (())
 {
   return (other_obj == this) ? 1 : 0;
@@ -67,27 +64,28 @@ CORBA_LocalObject::_is_equivalent (CORBA_Object_ptr other_obj
 
 
 TAO_ObjectKey *
-CORBA_LocalObject::_key (ACE_ENV_SINGLE_ARG_DECL)
+CORBA::LocalObject::_key (ACE_ENV_SINGLE_ARG_DECL)
 {
-  ACE_ERROR((LM_ERROR,
-             ACE_TEXT ("(%P|%t) Cannot get _key froma LocalObject!!!\n")));
+  if (TAO_debug_level > 0)
+    ACE_ERROR ((LM_ERROR,
+                ACE_TEXT ("(%P|%t) Cannot get _key from a LocalObject!\n")));
 
   ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (), 0);
 }
 
 #if 0
 void *
-CORBA_LocalObject::_tao_QueryInterface (ptr_arith_t type)
+CORBA::LocalObject::_tao_QueryInterface (ptr_arith_t type)
 {
   void *retv = 0;
 
   if (type == ACE_reinterpret_cast (ptr_arith_t,
-                                    &CORBA_LocalObject::_narrow))
+                                    &CORBA::LocalObject::_narrow))
     retv = ACE_reinterpret_cast (void *, this);
   else if (type == ACE_reinterpret_cast (ptr_arith_t,
-                                         &CORBA_Object::_narrow))
+                                         &CORBA::Object::_narrow))
     retv = ACE_reinterpret_cast (void *,
-                                 ACE_static_cast (CORBA_Object_ptr,
+                                 ACE_static_cast (CORBA::Object_ptr,
                                                   this));
   if (retv)
     this->_add_ref ();
@@ -103,20 +101,20 @@ CORBA_LocalObject::_tao_QueryInterface (ptr_arith_t type)
 // the latter case, return FALSE.
 
 CORBA::Boolean
-CORBA_LocalObject::_non_existent (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
+CORBA::LocalObject::_non_existent (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
 {
   // Always return false.
   return 0;
 }
 
 void
-CORBA_LocalObject::_create_request (CORBA::Context_ptr,
-                                    const CORBA::Char *,
-                                    CORBA::NVList_ptr,
-                                    CORBA::NamedValue_ptr,
-                                    CORBA::Request_ptr &,
-                                    CORBA::Flags
-                                    ACE_ENV_ARG_DECL)
+CORBA::LocalObject::_create_request (CORBA::Context_ptr,
+                                     const char *,
+                                     CORBA::NVList_ptr,
+                                     CORBA::NamedValue_ptr,
+                                     CORBA::Request_ptr &,
+                                     CORBA::Flags
+                                     ACE_ENV_ARG_DECL)
 {
   // @@ Correct minor code?  CCM spec says one thing CORBA spec says
   //    another!
@@ -125,15 +123,15 @@ CORBA_LocalObject::_create_request (CORBA::Context_ptr,
 }
 
 void
-CORBA_LocalObject::_create_request (CORBA::Context_ptr,
-                                    const CORBA::Char *,
-                                    CORBA::NVList_ptr,
-                                    CORBA::NamedValue_ptr,
-                                    CORBA::ExceptionList_ptr,
-                                    CORBA::ContextList_ptr,
-                                    CORBA::Request_ptr &,
-                                    CORBA::Flags
-                                    ACE_ENV_ARG_DECL)
+CORBA::LocalObject::_create_request (CORBA::Context_ptr,
+                                     const char *,
+                                     CORBA::NVList_ptr,
+                                     CORBA::NamedValue_ptr,
+                                     CORBA::ExceptionList_ptr,
+                                     CORBA::ContextList_ptr,
+                                     CORBA::Request_ptr &,
+                                     CORBA::Flags
+                                     ACE_ENV_ARG_DECL)
 {
   // @@ Correct minor code?  CCM spec says one thing CORBA spec says
   //    another!
@@ -142,8 +140,8 @@ CORBA_LocalObject::_create_request (CORBA::Context_ptr,
 }
 
 CORBA::Request_ptr
-CORBA_LocalObject::_request (const CORBA::Char *
-                             ACE_ENV_ARG_DECL)
+CORBA::LocalObject::_request (const char *
+                              ACE_ENV_ARG_DECL)
 {
   // @@ Correct minor code?  CCM spec says one thing CORBA spec says
   //    another!
@@ -153,85 +151,85 @@ CORBA_LocalObject::_request (const CORBA::Char *
 }
 
 CORBA::Object_ptr
-CORBA_LocalObject::_get_component (ACE_ENV_SINGLE_ARG_DECL)
+CORBA::LocalObject::_get_component (ACE_ENV_SINGLE_ARG_DECL)
 {
   ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (), 0);
 }
 
-CORBA_InterfaceDef_ptr
-CORBA_LocalObject::_get_interface (ACE_ENV_SINGLE_ARG_DECL)
+CORBA::InterfaceDef_ptr
+CORBA::LocalObject::_get_interface (ACE_ENV_SINGLE_ARG_DECL)
 {
   ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (), 0);
 }
 
 CORBA::ImplementationDef_ptr
-CORBA_LocalObject::_get_implementation (ACE_ENV_SINGLE_ARG_DECL)
+CORBA::LocalObject::_get_implementation (ACE_ENV_SINGLE_ARG_DECL)
 {
   ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (), 0);
 }
 
 #endif /* TAO_HAS_MINIMUM_CORBA */
 
-// ****************************************************************
-
-void
-TAO_Local_RefCounted_Object::_add_ref (void)
-{
-  ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->refcount_lock_);
-  this->refcount_++;
-}
-
-void
-TAO_Local_RefCounted_Object::_remove_ref (void)
-{
-  {
-    ACE_GUARD (TAO_SYNCH_MUTEX, mon, this->refcount_lock_);
-    this->refcount_--;
-
-    if (this->refcount_ != 0)
-      return;
-  }
-
-  delete this;
-}
-
 #if (TAO_HAS_CORBA_MESSAGING == 1)
 
 CORBA::Policy_ptr
-CORBA_LocalObject::_get_policy (CORBA::PolicyType
-                                ACE_ENV_ARG_DECL)
+CORBA::LocalObject::_get_policy (CORBA::PolicyType
+                                 ACE_ENV_ARG_DECL)
 {
   ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (),
                     CORBA::Policy::_nil ());
 }
 
 CORBA::Policy_ptr
-CORBA_LocalObject::_get_client_policy (CORBA::PolicyType
-                                       ACE_ENV_ARG_DECL)
+CORBA::LocalObject::_get_client_policy (CORBA::PolicyType
+                                        ACE_ENV_ARG_DECL)
 {
   ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (), CORBA::Policy::_nil ());
 }
 
 CORBA::Object_ptr
-CORBA_LocalObject::_set_policy_overrides (const CORBA::PolicyList &,
-                                          CORBA::SetOverrideType
-                                          ACE_ENV_ARG_DECL)
+CORBA::LocalObject::_set_policy_overrides (const CORBA::PolicyList &,
+                                           CORBA::SetOverrideType
+                                           ACE_ENV_ARG_DECL)
 {
   ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (), CORBA::Policy::_nil ());
 }
 
 CORBA::PolicyList *
-CORBA_LocalObject::_get_policy_overrides (const CORBA::PolicyTypeSeq &
-                                          ACE_ENV_ARG_DECL)
+CORBA::LocalObject::_get_policy_overrides (const CORBA::PolicyTypeSeq &
+                                           ACE_ENV_ARG_DECL)
 {
   ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (), 0);
 }
 
 CORBA::Boolean
-CORBA_LocalObject::_validate_connection (CORBA::PolicyList_out
-                                         ACE_ENV_ARG_DECL)
+CORBA::LocalObject::_validate_connection (CORBA::PolicyList_out
+                                          ACE_ENV_ARG_DECL)
 {
   ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (), 0);
 }
 
 #endif /* TAO_HAS_CORBA_MESSAGING == 1 */
+
+// ****************************************************************
+
+void
+TAO_Local_RefCounted_Object::_add_ref (void)
+{
+  ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->refcount_lock_);
+  this->refcount_++;
+}
+
+void
+TAO_Local_RefCounted_Object::_remove_ref (void)
+{
+  {
+    ACE_GUARD (TAO_SYNCH_MUTEX, mon, this->refcount_lock_);
+    this->refcount_--;
+
+    if (this->refcount_ != 0)
+      return;
+  }
+
+  delete this;
+}
diff --git a/TAO/tao/LocalObject.h b/TAO/tao/LocalObject.h
index e4af9361a1a..d8b1f52d2fd 100644
--- a/TAO/tao/LocalObject.h
+++ b/TAO/tao/LocalObject.h
@@ -28,220 +28,222 @@
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
-/**
- * @class CORBA_LocalObject
- *
- * @note NW: It is not clear whether minimum CORBA should support
- * LocalObject or not.  I think it should.
- */
-class TAO_Export CORBA_LocalObject : public virtual CORBA_Object
+namespace CORBA
 {
-public:
+  /**
+   * @class LocalObject
+   *
+   * @note NW: It is not clear whether minimum CORBA should support
+   * LocalObject or not.  I think it should.
+   */
+  class TAO_Export LocalObject : public virtual CORBA::Object
+  {
+  public:
 
-  /// Destructor
-  virtual ~CORBA_LocalObject (void);
+    /// Destructor
+    virtual ~LocalObject (void);
 
-  /// Increment the ref count
-  static CORBA_LocalObject_ptr _duplicate (CORBA_LocalObject_ptr obj);
+    /// Increment the ref count
+    static LocalObject_ptr _duplicate (LocalObject_ptr obj);
 
-  /// Return a NIL object
-  static CORBA_LocalObject_ptr _nil (void);
+    /// Return a NIL object
+    static LocalObject_ptr _nil (void);
 
-  /**
-   * @@ Narrowing a CORBA_LocalObject to a CORBA_Object is broken
-   * right now.  The solution seems to be making CORBA_Object an
-   * abstract base class and create a CORBA_RemoteObject for regular
-   * object.  Or, even easier, add a <is_local> member into
-   * CORBA_Object.  I'll take the easier route for now.
-   */
-  static CORBA_LocalObject_ptr _narrow (CORBA::Object_ptr obj
-                                        ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    /**
+     * @todo Narrowing a LocalObject to a CORBA::Object is broken
+     * right now.  The solution seems to be making CORBA::Object an
+     * abstract base class and create a CORBA::RemoteObject for
+     * regular object.  Or, even easier, add a @c is_local member into
+     * CORBA::Object.  I'll take the easier route for now.
+     */
+    static LocalObject_ptr _narrow (CORBA::Object_ptr obj
+                                    ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-  /// No-op it is just here to simplify some templates.
-  static CORBA_LocalObject_ptr _unchecked_narrow (
-             CORBA::Object_ptr obj
-             ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    /// No-op it is just here to simplify some templates.
+    static LocalObject_ptr _unchecked_narrow (CORBA::Object_ptr obj
+                                              ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
 #if (TAO_HAS_MINIMUM_CORBA == 0)
 
-  /// Always returns false.
-  virtual CORBA::Boolean _non_existent (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
-
-  /// Throws CORBA::NO_IMPLEMENT.
-  virtual CORBA::ImplementationDef_ptr
-      _get_implementation (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
-
-  /// Gets info about object from the Interface Repository.
-  virtual CORBA_InterfaceDef_ptr _get_interface (
-      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
-    );
+    /// Always returns false.
+    virtual CORBA::Boolean _non_existent (
+      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
 
-  /// Throws NO_IMPLEMENT.
-  virtual CORBA::Object_ptr _get_component (
+    /// Throws CORBA::NO_IMPLEMENT.
+    virtual CORBA::ImplementationDef_ptr _get_implementation (
       ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
 
-  virtual void _create_request (CORBA::Context_ptr ctx,
-                                const CORBA::Char *operation,
-                                CORBA::NVList_ptr arg_list,
-                                CORBA::NamedValue_ptr result,
-                                CORBA::Request_ptr &request,
-                                CORBA::Flags req_flags
-                                ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    /// Gets info about object from the Interface Repository.
+    virtual CORBA::InterfaceDef_ptr _get_interface (
+      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
 
-  virtual void _create_request (CORBA::Context_ptr ctx,
-                                const CORBA::Char *operation,
-                                CORBA::NVList_ptr arg_list,
-                                CORBA::NamedValue_ptr result,
-                                CORBA::ExceptionList_ptr exclist,
-                                CORBA::ContextList_ptr ctxtlist,
-                                CORBA::Request_ptr &request,
-                                CORBA::Flags req_flags
-                                ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    /// Throws NO_IMPLEMENT.
+    virtual CORBA::Object_ptr _get_component (
+      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
 
-  /// Throws NO_IMPLEMENT.
-  virtual CORBA::Request_ptr _request (const CORBA::Char *operation
-                                       ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    virtual void _create_request (CORBA::Context_ptr ctx,
+                                  const char *operation,
+                                  CORBA::NVList_ptr arg_list,
+                                  CORBA::NamedValue_ptr result,
+                                  CORBA::Request_ptr &request,
+                                  CORBA::Flags req_flags
+                                  ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+
+    virtual void _create_request (CORBA::Context_ptr ctx,
+                                  const char *operation,
+                                  CORBA::NVList_ptr arg_list,
+                                  CORBA::NamedValue_ptr result,
+                                  CORBA::ExceptionList_ptr exclist,
+                                  CORBA::ContextList_ptr ctxtlist,
+                                  CORBA::Request_ptr &request,
+                                  CORBA::Flags req_flags
+                                  ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+
+    /// Throws NO_IMPLEMENT.
+    virtual CORBA::Request_ptr _request (const char *operation
+                                         ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
 #endif /* TAO_HAS_MINIMUM_CORBA */
 
 #if (TAO_HAS_CORBA_MESSAGING == 1)
 
-  /// Throws CORBA::NO_IMPLEMENT.
-  CORBA::Policy_ptr _get_policy (
-      CORBA::PolicyType type
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS);
-
-
-  /// Throws CORBA::NO_IMPLEMENT.
-  CORBA::Policy_ptr _get_client_policy (
-      CORBA::PolicyType type
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    /// Throws CORBA::NO_IMPLEMENT.
+    CORBA::Policy_ptr _get_policy (CORBA::PolicyType type
+                                   ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
+    /// Throws CORBA::NO_IMPLEMENT.
+    CORBA::Policy_ptr _get_client_policy (CORBA::PolicyType type
+                                          ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-  /// Throws CORBA::NO_IMPLEMENT.
-  CORBA::Object_ptr _set_policy_overrides (
+    /// Throws CORBA::NO_IMPLEMENT.
+    CORBA::Object_ptr _set_policy_overrides (
       const CORBA::PolicyList & policies,
       CORBA::SetOverrideType set_add
       ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-
-  /// Throws CORBA::NO_IMPLEMENT.
-  CORBA::PolicyList * _get_policy_overrides (
+    /// Throws CORBA::NO_IMPLEMENT.
+    CORBA::PolicyList * _get_policy_overrides (
       const CORBA::PolicyTypeSeq & types
       ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-
-  /// Throws CORBA::NO_IMPLEMENT.
-  CORBA::Boolean _validate_connection (
+    /// Throws CORBA::NO_IMPLEMENT.
+    CORBA::Boolean _validate_connection (
       CORBA::PolicyList_out inconsistent_policies
       ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-
 #endif /* TAO_HAS_CORBA_MESSAGING == 1 */
 
-  /**
-   * Return a hash value for this object.  The hash is based on the
-   * address of the object.  On non-32 bit platforms, the hash may be
-   * non-unique.
-   */
-  virtual CORBA::ULong _hash (CORBA::ULong maximum
-                              ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    /**
+     * Return a hash value for this object.  The hash is based on the
+     * address of the object.  On non-32 bit platforms, the hash may
+     * be non-unique.
+     */
+    virtual CORBA::ULong _hash (CORBA::ULong maximum
+                                ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-  /**
-   * Try to determine if this object is the same as <other_obj>.  This
-   * method relies on the representation of the object reference's
-   * private state.  Since that changes easily (when different ORB
-   * protocols are in use) there is no default implementation.
-   */
-  virtual CORBA::Boolean _is_equivalent (CORBA_Object_ptr other_obj
-                                         ACE_ENV_ARG_DECL_WITH_DEFAULTS)
-    ACE_THROW_SPEC (());
+    /**
+     * Try to determine if this object is the same as @c other_obj.
+     * This method relies on the representation of the object
+     * reference's private state.  Since that changes easily (when
+     * different ORB protocols are in use) there is no default
+     * implementation.
+     */
+    virtual CORBA::Boolean _is_equivalent (CORBA::Object_ptr other_obj
+                                           ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+      ACE_THROW_SPEC (());
 
-  // = Reference count managment.
-  /// Increment the reference count.
-  virtual void _add_ref (void);
+    // = Reference count managment.
+    /// Increment the reference count.
+    virtual void _add_ref (void);
 
-  /// Decrement the reference count.
-  virtual void _remove_ref (void);
+    /// Decrement the reference count.
+    virtual void _remove_ref (void);
 
-  // = TAO extensions
+    // = TAO extensions
 
-  /// Throws CORBA::NO_IMPLEMENT.
-  virtual TAO_ObjectKey *_key (ACE_ENV_SINGLE_ARG_DECL);
+    /// Throws CORBA::NO_IMPLEMENT.
+    virtual TAO_ObjectKey *_key (ACE_ENV_SINGLE_ARG_DECL);
 
 #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-  /// Useful for template programming.
-  typedef CORBA_LocalObject_ptr _ptr_type;
-  typedef CORBA_LocalObject_var _var_type;
+    /// Useful for template programming.
+    typedef LocalObject_ptr _ptr_type;
+    typedef LocalObject_var _var_type;
 #endif /* __GNUC__ */
 
-protected:
-
-  /// Default constructor.
-  /**
-   * Make it protected to prevent instantiation of this class.
-   */
-  CORBA_LocalObject (void);
-
-private:
-
-  /**
-   * @name Unimplemented methods
-   */
-  //@{
-  CORBA_LocalObject (const CORBA_LocalObject &);
-  CORBA_LocalObject &operator = (const CORBA_LocalObject &);
-  //@}
-
-};
-
-class TAO_Export CORBA_LocalObject_var
-{
-public:
-  CORBA_LocalObject_var (void); // default constructor
-  CORBA_LocalObject_var (CORBA_LocalObject_ptr);
-  CORBA_LocalObject_var (const CORBA_LocalObject_var &); // copy constructor
-  ~CORBA_LocalObject_var (void); // destructor
-
-  CORBA_LocalObject_var &operator= (CORBA_LocalObject_ptr);
-  CORBA_LocalObject_var &operator= (const CORBA_LocalObject_var &);
-  CORBA_LocalObject_ptr operator-> (void) const;
-
-  /// in, inout, out, _retn
-  operator const CORBA_LocalObject_ptr &() const;
-  operator CORBA_LocalObject_ptr &();
-  CORBA_LocalObject_ptr in (void) const;
-  CORBA_LocalObject_ptr &inout (void);
-  CORBA_LocalObject_ptr &out (void);
-  CORBA_LocalObject_ptr _retn (void);
-  CORBA_LocalObject_ptr ptr (void) const;
-
-private:
-  CORBA_LocalObject_ptr ptr_;
-};
-
-class TAO_Export CORBA_LocalObject_out
-{
-public:
-  CORBA_LocalObject_out (CORBA_LocalObject_ptr &);
-  CORBA_LocalObject_out (CORBA_LocalObject_var &);
-  CORBA_LocalObject_out (const CORBA_LocalObject_out &);
-  CORBA_LocalObject_out &operator= (const CORBA_LocalObject_out &);
-  CORBA_LocalObject_out &operator= (const CORBA_LocalObject_var &);
-  CORBA_LocalObject_out &operator= (CORBA_LocalObject_ptr);
-  operator CORBA_LocalObject_ptr &();
-  CORBA_LocalObject_ptr &ptr (void);
-  CORBA_LocalObject_ptr operator-> (void);
-
-private:
-  CORBA_LocalObject_ptr &ptr_;
-};
+  protected:
+
+    /// Default constructor.
+    /**
+     * Make it protected to prevent instantiation of this class.
+     */
+    LocalObject (void);
+
+  private:
+
+    /**
+     * @name Unimplemented methods
+     */
+    //@{
+    LocalObject (const LocalObject &);
+    LocalObject &operator = (const LocalObject &);
+    //@}
+
+  };
+
+  class TAO_Export LocalObject_var
+  {
+  public:
+    LocalObject_var (void); // default constructor
+    LocalObject_var (LocalObject_ptr);
+    LocalObject_var (const LocalObject_var &); // copy constructor
+    ~LocalObject_var (void); // destructor
+
+    LocalObject_var &operator= (LocalObject_ptr);
+    LocalObject_var &operator= (const LocalObject_var &);
+    LocalObject_ptr operator-> (void) const;
+
+    /// in, inout, out, _retn
+    operator const LocalObject_ptr &() const;
+    operator LocalObject_ptr &();
+    LocalObject_ptr in (void) const;
+    LocalObject_ptr &inout (void);
+    LocalObject_ptr &out (void);
+    LocalObject_ptr _retn (void);
+    LocalObject_ptr ptr (void) const;
+
+  private:
+    LocalObject_ptr ptr_;
+  };
+
+  class TAO_Export LocalObject_out
+  {
+  public:
+    LocalObject_out (LocalObject_ptr &);
+    LocalObject_out (LocalObject_var &);
+    LocalObject_out (const LocalObject_out &);
+    LocalObject_out &operator= (const LocalObject_out &);
+    LocalObject_out &operator= (const LocalObject_var &);
+    LocalObject_out &operator= (LocalObject_ptr);
+    operator LocalObject_ptr &();
+    LocalObject_ptr &ptr (void);
+    LocalObject_ptr operator-> (void);
+
+  private:
+    LocalObject_ptr &ptr_;
+  };
+}   // End CORBA namespace
 
 /**
  * @class TAO_Local_RefCounted_Object
- This class adds default reference counting to local objects.
+ *
+ * @brief This class adds default reference counting to local
+ *        objects.
+ *
+ * This is proprietary convenience class that implements reference
+ * counting in locality constrained objects.
  */
-class TAO_Export TAO_Local_RefCounted_Object : public virtual CORBA_LocalObject
+class TAO_Export TAO_Local_RefCounted_Object
+  : public virtual CORBA::LocalObject
 {
 public:
 
@@ -279,6 +281,7 @@ protected:
 
 };
 
+
 #if defined (__ACE_INLINE__)
 # include "LocalObject.i"
 #endif /* __ACE_INLINE__ */
diff --git a/TAO/tao/LocalObject.i b/TAO/tao/LocalObject.i
index 7f27ffaaa20..dc1e3061de5 100644
--- a/TAO/tao/LocalObject.i
+++ b/TAO/tao/LocalObject.i
@@ -4,8 +4,8 @@
 
 // ****************************************************************
 
-ACE_INLINE CORBA_LocalObject_ptr
-CORBA_LocalObject::_duplicate (CORBA_LocalObject_ptr obj)
+ACE_INLINE CORBA::LocalObject_ptr
+CORBA::LocalObject::_duplicate (CORBA::LocalObject_ptr obj)
 {
   if (obj)
     obj->_add_ref ();
@@ -14,215 +14,218 @@ CORBA_LocalObject::_duplicate (CORBA_LocalObject_ptr obj)
 
 // Null pointers represent nil objects.
 
-ACE_INLINE CORBA_LocalObject_ptr
-CORBA_LocalObject::_nil (void)
+ACE_INLINE CORBA::LocalObject_ptr
+CORBA::LocalObject::_nil (void)
 {
   return 0;
 }
 
-ACE_INLINE CORBA_LocalObject_ptr
-CORBA_LocalObject::_narrow (CORBA_Object_ptr obj
-                            ACE_ENV_ARG_DECL_NOT_USED)
+ACE_INLINE CORBA::LocalObject_ptr
+CORBA::LocalObject::_narrow (CORBA::Object_ptr obj
+                             ACE_ENV_ARG_DECL_NOT_USED)
 {
   if (obj->_is_local () != 0)
     return
       ACE_reinterpret_cast (
-        CORBA_LocalObject_ptr,
+        CORBA::LocalObject_ptr,
         obj->_tao_QueryInterface (
           ACE_reinterpret_cast (ptr_arith_t,
-                                &CORBA_LocalObject::_narrow)));
+                                &CORBA::LocalObject::_narrow)));
 
   return 0;
 }
 
-ACE_INLINE CORBA_LocalObject_ptr
-CORBA_LocalObject::_unchecked_narrow (CORBA_Object_ptr obj
-                                      ACE_ENV_ARG_DECL_NOT_USED)
+ACE_INLINE CORBA::LocalObject_ptr
+CORBA::LocalObject::_unchecked_narrow (CORBA::Object_ptr obj
+                                       ACE_ENV_ARG_DECL_NOT_USED)
 {
   if (obj->_is_local () != 0)
     return
       ACE_reinterpret_cast (
-        CORBA_LocalObject_ptr,
+        CORBA::LocalObject_ptr,
         obj->_tao_QueryInterface (
           ACE_reinterpret_cast (ptr_arith_t,
-                                &CORBA_LocalObject::_narrow)));
+                                &CORBA::LocalObject::_narrow)));
 
   return 0;
 }
 
 ACE_INLINE
-CORBA_LocalObject::CORBA_LocalObject (void)
-  : CORBA_Object (0)
-{
-}
-
-ACE_INLINE
-TAO_Local_RefCounted_Object::TAO_Local_RefCounted_Object (void)
-  : refcount_lock_ (),
-    refcount_ (1)
+CORBA::LocalObject::LocalObject (void)
+  : Object (0)
 {
 }
 
 // *************************************************************
-// Inline operations for class CORBA_LocalObject_var
+// Inline operations for class CORBA::LocalObject_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_LocalObject_var::CORBA_LocalObject_var (void)
-  : ptr_ (CORBA_LocalObject::_nil ())
+CORBA::LocalObject_var::LocalObject_var (void)
+  : ptr_ (CORBA::LocalObject::_nil ())
 {
 }
 
 ACE_INLINE
-CORBA_LocalObject_var::CORBA_LocalObject_var (CORBA_LocalObject_ptr p)
+CORBA::LocalObject_var::LocalObject_var (CORBA::LocalObject_ptr p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_LocalObject_var::~CORBA_LocalObject_var (void)
+CORBA::LocalObject_var::~LocalObject_var (void)
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_LocalObject_ptr
-CORBA_LocalObject_var::ptr (void) const
+ACE_INLINE CORBA::LocalObject_ptr
+CORBA::LocalObject_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_LocalObject_var::CORBA_LocalObject_var (const CORBA_LocalObject_var &p)
-  : ptr_ (CORBA_LocalObject::_duplicate (p.ptr ()))
+CORBA::LocalObject_var::LocalObject_var (const CORBA::LocalObject_var &p)
+  : ptr_ (CORBA::LocalObject::_duplicate (p.ptr ()))
 {
 }
 
-ACE_INLINE CORBA_LocalObject_var &
-CORBA_LocalObject_var::operator= (CORBA_LocalObject_ptr p)
+ACE_INLINE CORBA::LocalObject_var &
+CORBA::LocalObject_var::operator= (CORBA::LocalObject_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_LocalObject_var &
-CORBA_LocalObject_var::operator= (const CORBA_LocalObject_var &p)
+ACE_INLINE CORBA::LocalObject_var &
+CORBA::LocalObject_var::operator= (const CORBA::LocalObject_var &p)
 {
   if (this != &p)
     {
       CORBA::release (this->ptr_);
-      this->ptr_ = CORBA_LocalObject::_duplicate (p.ptr ());
+      this->ptr_ = CORBA::LocalObject::_duplicate (p.ptr ());
     }
 
   return *this;
 }
 
 ACE_INLINE
-CORBA_LocalObject_var::operator const CORBA_LocalObject_ptr &() const // cast
+CORBA::LocalObject_var::operator const CORBA::LocalObject_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_LocalObject_var::operator CORBA_LocalObject_ptr &() // cast
+CORBA::LocalObject_var::operator CORBA::LocalObject_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_LocalObject_ptr
-CORBA_LocalObject_var::operator-> (void) const
+ACE_INLINE CORBA::LocalObject_ptr
+CORBA::LocalObject_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_LocalObject_ptr
-CORBA_LocalObject_var::in (void) const
+ACE_INLINE CORBA::LocalObject_ptr
+CORBA::LocalObject_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_LocalObject_ptr &
-CORBA_LocalObject_var::inout (void)
+ACE_INLINE CORBA::LocalObject_ptr &
+CORBA::LocalObject_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_LocalObject_ptr &
-CORBA_LocalObject_var::out (void)
+ACE_INLINE CORBA::LocalObject_ptr &
+CORBA::LocalObject_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_LocalObject::_nil ();
+  this->ptr_ = CORBA::LocalObject::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_LocalObject_ptr
-CORBA_LocalObject_var::_retn (void)
+ACE_INLINE CORBA::LocalObject_ptr
+CORBA::LocalObject_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_LocalObject_ptr val = this->ptr_;
-  this->ptr_ = CORBA_LocalObject::_nil ();
+  CORBA::LocalObject_ptr val = this->ptr_;
+  this->ptr_ = CORBA::LocalObject::_nil ();
   return val;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_LocalObject_out
+// Inline operations for class CORBA::LocalObject_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_LocalObject_out::CORBA_LocalObject_out (CORBA_LocalObject_ptr &p)
+CORBA::LocalObject_out::LocalObject_out (CORBA::LocalObject_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_LocalObject::_nil ();
+  this->ptr_ = CORBA::LocalObject::_nil ();
 }
 
 ACE_INLINE
-CORBA_LocalObject_out::CORBA_LocalObject_out (CORBA_LocalObject_var &p)
+CORBA::LocalObject_out::LocalObject_out (CORBA::LocalObject_var &p)
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_LocalObject::_nil ();
+  this->ptr_ = CORBA::LocalObject::_nil ();
 }
 
 ACE_INLINE
-CORBA_LocalObject_out::CORBA_LocalObject_out (const CORBA_LocalObject_out &p)
+CORBA::LocalObject_out::LocalObject_out (const CORBA::LocalObject_out &p)
   : ptr_ (p.ptr_)
 {
 }
 
-ACE_INLINE CORBA_LocalObject_out &
-CORBA_LocalObject_out::operator= (const CORBA_LocalObject_out &p)
+ACE_INLINE CORBA::LocalObject_out &
+CORBA::LocalObject_out::operator= (const CORBA::LocalObject_out &p)
 {
   this->ptr_ = p.ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_LocalObject_out &
-CORBA_LocalObject_out::operator= (const CORBA_LocalObject_var &p)
+ACE_INLINE CORBA::LocalObject_out &
+CORBA::LocalObject_out::operator= (const CORBA::LocalObject_var &p)
 {
-  this->ptr_ = CORBA_LocalObject::_duplicate (p.ptr ());
+  this->ptr_ = CORBA::LocalObject::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_LocalObject_out &
-CORBA_LocalObject_out::operator= (CORBA_LocalObject_ptr p)
+ACE_INLINE CORBA::LocalObject_out &
+CORBA::LocalObject_out::operator= (CORBA::LocalObject_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE
-CORBA_LocalObject_out::operator CORBA_LocalObject_ptr &() // cast
+CORBA::LocalObject_out::operator CORBA::LocalObject_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_LocalObject_ptr &
-CORBA_LocalObject_out::ptr (void) // ptr
+ACE_INLINE CORBA::LocalObject_ptr &
+CORBA::LocalObject_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_LocalObject_ptr
-CORBA_LocalObject_out::operator-> (void)
+ACE_INLINE CORBA::LocalObject_ptr
+CORBA::LocalObject_out::operator-> (void)
 {
   return this->ptr_;
 }
+
+// ------------------------------------------------------------------
+
+ACE_INLINE
+TAO_Local_RefCounted_Object::TAO_Local_RefCounted_Object (void)
+  : refcount_lock_ (),
+    refcount_ (1)
+{
+}
+
diff --git a/TAO/tao/NVList.cpp b/TAO/tao/NVList.cpp
index c13000fcc4c..303e51ea3b7 100644
--- a/TAO/tao/NVList.cpp
+++ b/TAO/tao/NVList.cpp
@@ -17,19 +17,21 @@
 # include "tao/NVList.i"
 #endif /* ! __ACE_INLINE__ */
 
-ACE_RCSID(tao, NVList, "$Id$")
+ACE_RCSID (tao,
+           NVList,
+           "$Id$")
 
 // Reference counting for DII Request object
 
 CORBA::ULong
-CORBA_NamedValue::_incr_refcnt (void)
+CORBA::NamedValue::_incr_refcnt (void)
 {
   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->refcount_lock_, 0);
   return this->refcount_++;
 }
 
 CORBA::ULong
-CORBA_NamedValue::_decr_refcnt (void)
+CORBA::NamedValue::_decr_refcnt (void)
 {
   {
     ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->refcount_lock_, 0);
@@ -42,7 +44,7 @@ CORBA_NamedValue::_decr_refcnt (void)
   return 0;
 }
 
-CORBA_NamedValue::~CORBA_NamedValue (void)
+CORBA::NamedValue::~NamedValue (void)
 {
   if (this->name_)
     {
@@ -55,14 +57,14 @@ CORBA_NamedValue::~CORBA_NamedValue (void)
 // ****************************************************************
 
 CORBA::ULong
-CORBA_NVList::_incr_refcnt (void)
+CORBA::NVList::_incr_refcnt (void)
 {
   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->refcount_lock_, 0);
   return this->refcount_++;
 }
 
 CORBA::ULong
-CORBA_NVList::_decr_refcnt (void)
+CORBA::NVList::_decr_refcnt (void)
 {
   {
     ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->refcount_lock_, 0);
@@ -75,7 +77,7 @@ CORBA_NVList::_decr_refcnt (void)
   return 0;
 }
 
-CORBA_NVList::~CORBA_NVList (void)
+CORBA::NVList::~NVList (void)
 {
   // initialize an iterator and delete each NamedValue
   ACE_Unbounded_Queue_Iterator<CORBA::NamedValue_ptr> iter (this->values_);
@@ -95,21 +97,23 @@ CORBA_NVList::~CORBA_NVList (void)
 
 // add an element and just initialize its flags
 CORBA::NamedValue_ptr
-CORBA_NVList::add (CORBA::Flags flags
-                   ACE_ENV_ARG_DECL)
+CORBA::NVList::add (CORBA::Flags flags
+                    ACE_ENV_ARG_DECL)
 {
   // call the helper to allocate a NamedValue element (if necessary)
-  return this->add_element (flags ACE_ENV_ARG_PARAMETER);
+  return this->add_element (flags
+                            ACE_ENV_ARG_PARAMETER);
 }
 
 // add an element and just initialize its flags and name
 CORBA::NamedValue_ptr
-CORBA_NVList::add_item (const char *name,
-                        CORBA::Flags flags
-                        ACE_ENV_ARG_DECL)
+CORBA::NVList::add_item (const char *name,
+                         CORBA::Flags flags
+                         ACE_ENV_ARG_DECL)
 {
   // call the helper to allocate a NamedValue element
-  CORBA::NamedValue_ptr nv = this->add_element (flags ACE_ENV_ARG_PARAMETER);
+  CORBA::NamedValue_ptr nv = this->add_element (flags
+                                                ACE_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
   if (nv)
@@ -124,13 +128,14 @@ CORBA_NVList::add_item (const char *name,
 
 // add a value. If necessary, increment the list
 CORBA::NamedValue_ptr
-CORBA_NVList::add_value (const char *name,
-                         const CORBA::Any &value,
-                         CORBA::Flags flags
-                         ACE_ENV_ARG_DECL)
+CORBA::NVList::add_value (const char *name,
+                          const CORBA::Any &value,
+                          CORBA::Flags flags
+                          ACE_ENV_ARG_DECL)
 {
   // call the helper to allocate a NamedValue element
-  CORBA::NamedValue_ptr nv = this->add_element (flags ACE_ENV_ARG_PARAMETER);
+  CORBA::NamedValue_ptr nv = this->add_element (flags
+                                                ACE_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
   if (nv)
     {
@@ -161,13 +166,14 @@ CORBA_NVList::add_value (const char *name,
 
 // add an element and just initialize its flags and name
 CORBA::NamedValue_ptr
-CORBA_NVList::add_item_consume (char *name,
-                                CORBA::Flags flags
-                                ACE_ENV_ARG_DECL)
+CORBA::NVList::add_item_consume (char *name,
+                                 CORBA::Flags flags
+                                 ACE_ENV_ARG_DECL)
 {
 
   // call the helper to allocate a NamedValue element
-  CORBA::NamedValue_ptr nv = this->add_element (flags ACE_ENV_ARG_PARAMETER);
+  CORBA::NamedValue_ptr nv = this->add_element (flags
+                                                ACE_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
   if (nv)
@@ -184,13 +190,14 @@ CORBA_NVList::add_item_consume (char *name,
 
 // add a value. If necessary, increment the list
 CORBA::NamedValue_ptr
-CORBA_NVList::add_value_consume (char * name,
-                                 CORBA::Any * value,
-                                 CORBA::Flags flags
-                                 ACE_ENV_ARG_DECL)
+CORBA::NVList::add_value_consume (char * name,
+                                  CORBA::Any * value,
+                                  CORBA::Flags flags
+                                  ACE_ENV_ARG_DECL)
 {
   // call the helper to allocate a NamedValue element
-  CORBA::NamedValue_ptr nv = this->add_element (flags ACE_ENV_ARG_PARAMETER);
+  CORBA::NamedValue_ptr nv = this->add_element (flags
+                                                ACE_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
   if (nv)
@@ -211,7 +218,8 @@ CORBA_NVList::add_value_consume (char * name,
 
 //CORBA::Status
 void
-CORBA_NVList::remove (CORBA::ULong /*n*/ ACE_ENV_ARG_DECL_NOT_USED/*env*/)
+CORBA::NVList::remove (CORBA::ULong /* n */
+                       ACE_ENV_ARG_DECL_NOT_USED)
 {
   // not implemented
   // @@ (ASG) - TODO
@@ -219,20 +227,23 @@ CORBA_NVList::remove (CORBA::ULong /*n*/ ACE_ENV_ARG_DECL_NOT_USED/*env*/)
 
 // Helper method
 CORBA::NamedValue_ptr
-CORBA_NVList::add_element (CORBA::Flags flags
-                           ACE_ENV_ARG_DECL)
+CORBA::NVList::add_element (CORBA::Flags flags
+                            ACE_ENV_ARG_DECL)
 {
   this->evaluate (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (CORBA::NamedValue::_nil ());
 
   if (ACE_BIT_DISABLED (flags,
                         CORBA::ARG_IN | CORBA::ARG_OUT | CORBA::ARG_INOUT))
-    ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
+    ACE_THROW_RETURN (CORBA::BAD_PARAM (), CORBA::NamedValue::_nil ());
 
   CORBA::NamedValue_ptr nv;
 
   // allocate a new NamedValue
-  ACE_NEW_RETURN (nv, CORBA::NamedValue, 0);
+  ACE_NEW_THROW_EX (nv,
+                    CORBA::NamedValue,
+                    CORBA::NO_MEMORY ());
+  ACE_CHECK_RETURN (CORBA::NamedValue::_nil ());
 
   // set the flags and enqueue in the queue
   nv->flags_ = flags;
@@ -248,13 +259,15 @@ CORBA_NVList::add_element (CORBA::Flags flags
 
 // return the item at location n
 CORBA::NamedValue_ptr
-CORBA_NVList::item (CORBA::ULong n ACE_ENV_ARG_DECL)
+CORBA::NVList::item (CORBA::ULong n
+                     ACE_ENV_ARG_DECL)
 {
   this->evaluate (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (CORBA::NamedValue::_nil ());
 
   if (n >= this->max_) // 0 based indexing
-    ACE_THROW_RETURN (CORBA::Bounds (), 0);
+    ACE_THROW_RETURN (CORBA::Bounds (),
+                      CORBA::NamedValue::_nil ());
 
   CORBA::NamedValue_ptr *nv;
 
@@ -263,10 +276,10 @@ CORBA_NVList::item (CORBA::ULong n ACE_ENV_ARG_DECL)
 }
 
 void
-CORBA_NVList::_tao_incoming_cdr (TAO_InputCDR &cdr,
-                                 int flag,
-                                 int &lazy_evaluation
-                                 ACE_ENV_ARG_DECL)
+CORBA::NVList::_tao_incoming_cdr (TAO_InputCDR &cdr,
+                                  int flag,
+                                  int &lazy_evaluation
+                                  ACE_ENV_ARG_DECL)
 {
   // If the list is empty then using lazy evaluation is the only
   // choice.
@@ -295,10 +308,10 @@ CORBA_NVList::_tao_incoming_cdr (TAO_InputCDR &cdr,
 }
 
 void
-CORBA_NVList::_tao_encode (TAO_OutputCDR &cdr,
-                           TAO_ORB_Core *orb_core,
-                           int flag
-                           ACE_ENV_ARG_DECL)
+CORBA::NVList::_tao_encode (TAO_OutputCDR &cdr,
+                            TAO_ORB_Core *orb_core,
+                            int flag
+                            ACE_ENV_ARG_DECL)
 {
   ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->refcount_lock_);
   if (this->incoming_ != 0)
@@ -341,7 +354,7 @@ CORBA_NVList::_tao_encode (TAO_OutputCDR &cdr,
           (void) TAO_Marshal_Object::perform_append (tc.in (),
                                                      this->incoming_,
                                                      &cdr
-                                                      ACE_ENV_ARG_PARAMETER);
+                                                     ACE_ENV_ARG_PARAMETER);
           ACE_CHECK;
         }
 
@@ -368,15 +381,15 @@ CORBA_NVList::_tao_encode (TAO_OutputCDR &cdr,
 
       nv->value ()->_tao_encode (cdr,
                                  orb_core
-                                  ACE_ENV_ARG_PARAMETER);
+                                 ACE_ENV_ARG_PARAMETER);
       ACE_CHECK;
     }
 }
 
 void
-CORBA_NVList::_tao_decode (TAO_InputCDR &incoming,
-                           int flag
-                           ACE_ENV_ARG_DECL)
+CORBA::NVList::_tao_decode (TAO_InputCDR &incoming,
+                            int flag
+                            ACE_ENV_ARG_DECL)
 {
   if (TAO_debug_level > 3)
     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) : NVList::_tao_decode\n")));
@@ -405,13 +418,13 @@ CORBA_NVList::_tao_decode (TAO_InputCDR &incoming,
 
       CORBA::Any_ptr any = nv->value ();
       any->_tao_decode (incoming
-                         ACE_ENV_ARG_PARAMETER);
+                        ACE_ENV_ARG_PARAMETER);
       ACE_CHECK;
     }
 }
 
 ptr_arith_t
-CORBA_NVList::_tao_target_alignment (void)
+CORBA::NVList::_tao_target_alignment (void)
 {
   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->refcount_lock_,
                     ACE_CDR::MAX_ALIGNMENT);
@@ -423,7 +436,7 @@ CORBA_NVList::_tao_target_alignment (void)
 }
 
 void
-CORBA_NVList::evaluate (ACE_ENV_SINGLE_ARG_DECL)
+CORBA::NVList::evaluate (ACE_ENV_SINGLE_ARG_DECL)
 {
   ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->refcount_lock_);
   if (this->incoming_ == 0)
@@ -434,11 +447,11 @@ CORBA_NVList::evaluate (ACE_ENV_SINGLE_ARG_DECL)
 
   this->_tao_decode (*(incoming.get ()),
                      this->incoming_flag_
-                      ACE_ENV_ARG_PARAMETER);
+                     ACE_ENV_ARG_PARAMETER);
 }
 
 CORBA::Boolean
-CORBA_NVList::_lazy_has_arguments (void) const
+CORBA::NVList::_lazy_has_arguments (void) const
 {
   if (this->incoming_ != 0)
     {
diff --git a/TAO/tao/NVList.h b/TAO/tao/NVList.h
index ee96cea184c..9ae776a5ded 100644
--- a/TAO/tao/NVList.h
+++ b/TAO/tao/NVList.h
@@ -14,6 +14,7 @@
 
 #ifndef TAO_NVLIST_H
 #define TAO_NVLIST_H
+
 #include "ace/pre.h"
 
 #include "tao/orbconf.h"
@@ -27,359 +28,367 @@
 
 class TAO_InputCDR;
 
-/**
- * @class CORBA_NamedValue
- *
- * @brief NamedValue ... these occur only in "NVList" (named value list) data
- * structures.  The binary form of the data structure is frozen and
- * visible to programs using it (e.g. from C).  The C++ class supports
- * some programming discipline, e.g. to avoid memory leaks.
- * They just represent parameters to calls.  The name is optional, and
- * the value is packaged as an Any.  The flags indicate parameter
- * mode, and some ownership rules for "top level" memory.
- */
-class TAO_Export CORBA_NamedValue
+namespace CORBA
 {
-public:
-  /// optional name
-  const char *name (void) const;
+  /**
+   * @class NamedValue
+   *
+   * @brief CORBA Name/value pair implementation.
+   *
+   * These occur only in "NVList" (named value list) data structures.
+   * The binary form of the data structure is frozen and visible to
+   * programs using it (e.g. from C).  The C++ class supports some
+   * programming discipline, e.g. to avoid memory leaks.  They just
+   * represent parameters to calls.  The name is optional, and the
+   * value is packaged as an Any.  The flags indicate parameter mode,
+   * and some ownership rules for "top level" memory.
+   */
+  class TAO_Export NamedValue
+  {
+    friend class CORBA::ORB;
+    friend class CORBA::NVList;
+    friend class CORBA::Request;
 
-  /// return the value
-  CORBA::Any_ptr value (void) const;
+  public:
+    /// optional name
+    const char *name (void) const;
 
-  /// return the parameter mode flag
-  CORBA::Flags flags (void) const;
+    /// return the value
+    CORBA::Any_ptr value (void) const;
 
-  /// destructor - manages the name and value
-  ~CORBA_NamedValue (void);
+    /// return the parameter mode flag
+    CORBA::Flags flags (void) const;
 
-  // The pseudo object static methods..
-  static CORBA_NamedValue* _duplicate (CORBA_NamedValue*);
-  static CORBA_NamedValue* _nil (void);
+    // The pseudo object static methods..
+    static NamedValue* _duplicate (NamedValue*);
+    static NamedValue* _nil (void);
 
-  // = Reference counting.
-  CORBA::ULong _incr_refcnt (void);
-  CORBA::ULong _decr_refcnt (void);
+    // = Reference counting.
+    CORBA::ULong _incr_refcnt (void);
+    CORBA::ULong _decr_refcnt (void);
 
-  // Useful for template programming.
+    // Useful for template programming.
 #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-  typedef CORBA_NamedValue_ptr _ptr_type;
-  typedef CORBA_NamedValue_var _var_type;
+    typedef NamedValue_ptr _ptr_type;
+    typedef NamedValue_var _var_type;
 #endif /* __GNUC__ */
 
-private:
-  /// maintains how many references exist to this object
-  CORBA::ULong refcount_;
+  protected:
 
-  /// Protects the reference count.
-  TAO_SYNCH_MUTEX refcount_lock_;
+    /// Destructor
+    /**
+     * Protected destructor to enforce proper memory management
+     * through the reference counting mechanism.
+     */
+    ~NamedValue (void);
 
-  /// holds the value
-  CORBA::Any any_;
+  private:
 
-  /// parameter mode flags
-  CORBA::Flags flags_;
+    /// private constructor. Cannot be directly instantiated other than
+    /// by its friends.
+    NamedValue (void);
 
-  /// optional IDL name of the parameter
-  char *name_;
+  private:
 
-  /// private constructor. Cannot be directly instantiated other than
-  /// by its friends.
-  CORBA_NamedValue (void);
+    /// maintains how many references exist to this object
+    CORBA::ULong refcount_;
 
-  friend class CORBA_ORB;
-  friend class CORBA_NVList;
-  friend class CORBA_Request;
-};
+    /// Protects the reference count.
+    TAO_SYNCH_MUTEX refcount_lock_;
 
-/**
- * @class CORBA_NamedValue_var
- *
- * @brief The T_var class for NamedValue
- *
- * As any other pseudo object NamedValue must have a T_var class,
- * the interface an semantics are specified in the CORBA spec.
- * = NOTE
- * We use CORBA_NamedValue_ptr as the _ptr type instead of
- * CORBA::NamedValue_ptr, this is an attempt to reduced the cyclic
- * dependencies in TAO.
- */
-class TAO_Export CORBA_NamedValue_var
-{
-public:
-  CORBA_NamedValue_var (void); // default constructor
-  CORBA_NamedValue_var (CORBA_NamedValue_ptr);
-  CORBA_NamedValue_var (const CORBA_NamedValue_var &); // copy constructor
-  ~CORBA_NamedValue_var (void); // destructor
-
-  CORBA_NamedValue_var &operator= (CORBA_NamedValue_ptr);
-  CORBA_NamedValue_var &operator= (const CORBA_NamedValue_var &);
-  CORBA_NamedValue_ptr operator-> (void) const;
-
-  /// in, inout, out, _retn
-  operator const CORBA_NamedValue_ptr &() const;
-  operator CORBA_NamedValue_ptr &();
-  CORBA_NamedValue_ptr in (void) const;
-  CORBA_NamedValue_ptr &inout (void);
-  CORBA_NamedValue_ptr &out (void);
-  CORBA_NamedValue_ptr _retn (void);
-  CORBA_NamedValue_ptr ptr (void) const;
-
-private:
-  CORBA_NamedValue_ptr ptr_;
-};
+    /// holds the value
+    CORBA::Any any_;
 
-/**
- * @class CORBA_NamedValue_out
- *
- * @brief The T_out class for NamedValue
- *
- * As any other pseudo object NamedValue must have a T_out class,
- * the interface an semantics are specified in the CORBA spec.
- * = NOTE
- * We use CORBA_NamedValue_ptr as the _ptr type instead of
- * CORBA::NamedValue_ptr, this is an attempt to reduced the cyclic
- * dependencies in TAO.
- */
-class TAO_Export CORBA_NamedValue_out
-{
-public:
-  CORBA_NamedValue_out (CORBA_NamedValue_ptr &);
-  CORBA_NamedValue_out (CORBA_NamedValue_var &);
-  CORBA_NamedValue_out (CORBA_NamedValue_out &);
-  CORBA_NamedValue_out &operator= (CORBA_NamedValue_out &);
-  CORBA_NamedValue_out &operator= (const CORBA_NamedValue_var &);
-  CORBA_NamedValue_out &operator= (CORBA_NamedValue_ptr);
-  operator CORBA_NamedValue_ptr &();
-  CORBA_NamedValue_ptr &ptr (void);
-  CORBA_NamedValue_ptr operator-> (void);
-
-private:
-  CORBA_NamedValue_ptr &ptr_;
-};
-
-// ****************************************************************
+    /// parameter mode flags
+    CORBA::Flags flags_;
 
-/**
- * @class CORBA_NVList
- *
- * @brief NVList ... this is used in the (client side) DII (Dynamic
- * Invocation Interface) to hold parameters, except for the return
- * parameter. It's used in the same role in the (server side) DSI
- * (Dynamic Skeleton Interface).
- *
- * Each user (client, server) provides the typecode and memory for
- * each parameter using an NVList, then talks to the ORB using a
- * Request or ServerRequest pseudo-object.  The ORB copies data
- * to/from the IPC messages (e.g. IIOP::Request, IIOP::Response)
- * as appropriate.
- */
-class TAO_Export CORBA_NVList
-{
-public:
-  /// destructor
-  ~CORBA_NVList (void);
-
-  /// return the current number of elements in the list
-  CORBA::ULong count (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
-
-  /// add an element and just initialize the flags
-  CORBA_NamedValue_ptr add (CORBA::Flags
-                            ACE_ENV_ARG_DECL_WITH_DEFAULTS);
-
-  /// add an element and initialize its name and flags
-  CORBA_NamedValue_ptr add_item (const char *,
-                                 CORBA::Flags
-                                 ACE_ENV_ARG_DECL_WITH_DEFAULTS);
-
-  /// initializes a value, name, and flags
-  CORBA_NamedValue_ptr add_value (const char *,
-                                  const CORBA::Any &,
-                                  CORBA::Flags
-                                  ACE_ENV_ARG_DECL_WITH_DEFAULTS);
-
-  /// just like add_item. In addition, memory management of char * name
-  /// is taken over by the NVList
-  CORBA_NamedValue_ptr add_item_consume (char *,
-                                         CORBA::Flags
-                                         ACE_ENV_ARG_DECL_WITH_DEFAULTS);
-
-  /// just like add_value. In addition, the NVList controls the memory
-  /// management of the char *name and Any *value parameter
-  CORBA_NamedValue_ptr add_value_consume (char *,
-                                          CORBA::Any_ptr,
-                                          CORBA::Flags
-                                          ACE_ENV_ARG_DECL_WITH_DEFAULTS);
-
-  /// retrieve the item at the nth location. Raises Bounds
-  CORBA_NamedValue_ptr item (CORBA::ULong n
-                             ACE_ENV_ARG_DECL_WITH_DEFAULTS);
-
-  //  CORBA::Status
-  /// remove element at index n. Raises Bounds
-  void remove (CORBA::ULong n
-               ACE_ENV_ARG_DECL_WITH_DEFAULTS);
-
-  // The pseudo object static methods..
-  static CORBA_NVList* _duplicate (CORBA_NVList*);
-  static CORBA_NVList* _nil (void);
-
-  // = Reference counting.
-  CORBA::ULong _incr_refcnt (void);
-  CORBA::ULong _decr_refcnt (void);
-
-  // = TAO Extensions:
+    /// optional IDL name of the parameter
+    char *name_;
+  };
 
   /**
-   * Set the incoming CDR stream, this is used by TAO to perform lazy
-   * evaluation of the NVList in an incoming ServerRequest.
-   * The <flag> is used to check which parameters (IN, OUT and/or
-   * INOUT) are to be extracted
+   * @class NamedValue_var
+   *
+   * @brief The T_var class for NamedValue
+   *
+   * As any other pseudo object NamedValue must have a T_var class,
+   * the interface an semantics are specified in the CORBA spec.
    */
-  void _tao_incoming_cdr (TAO_InputCDR &cdr,
-                          int flag,
-                          int &lazy_evaluation
-                          ACE_ENV_ARG_DECL);
-
-  /// Encode the NVList into the CDR stream. <flag> masks the type of
-  /// arguments (IN, OUT or INOUT) that are to be marshaled.
-  void _tao_encode (TAO_OutputCDR &cdr,
-                    TAO_ORB_Core *orb_core,
-                    int flag
-                    ACE_ENV_ARG_DECL_WITH_DEFAULTS);
-
-  /// Decode the NVList arguments from the <cdr> stream.
-  void _tao_decode (TAO_InputCDR &cdr,
-                    int flag
-                    ACE_ENV_ARG_DECL);
+  class TAO_Export NamedValue_var
+  {
+  public:
+
+    NamedValue_var (void); // default constructor
+    NamedValue_var (NamedValue_ptr);
+    NamedValue_var (const NamedValue_var &); // copy constructor
+    ~NamedValue_var (void); // destructor
+
+    NamedValue_var &operator= (NamedValue_ptr);
+    NamedValue_var &operator= (const NamedValue_var &);
+    NamedValue_ptr operator-> (void) const;
+
+    /// in, inout, out, _retn
+    operator const NamedValue_ptr &() const;
+    operator NamedValue_ptr &();
+    NamedValue_ptr in (void) const;
+    NamedValue_ptr &inout (void);
+    NamedValue_ptr &out (void);
+    NamedValue_ptr _retn (void);
+    NamedValue_ptr ptr (void) const;
+
+  private:
+    NamedValue_ptr ptr_;
+  };
 
   /**
-   * Return the required alignment to marshal the NVList without any
-   * re-alignment.
-   * It returns ACE_CDR::MAX_ALIGNMENT to indicate errors.
+   * @class NamedValue_out
+   *
+   * @brief The T_out class for NamedValue
+   *
+   * As any other pseudo object NamedValue must have a T_out class,
+   * the interface an semantics are specified in the CORBA spec.
    */
-  ptr_arith_t _tao_target_alignment (void);
+  class TAO_Export NamedValue_out
+  {
+  public:
+    NamedValue_out (NamedValue_ptr &);
+    NamedValue_out (NamedValue_var &);
+    NamedValue_out (NamedValue_out &);
+    NamedValue_out &operator= (NamedValue_out &);
+    NamedValue_out &operator= (const NamedValue_var &);
+    NamedValue_out &operator= (NamedValue_ptr);
+    operator NamedValue_ptr &();
+    NamedValue_ptr &ptr (void);
+    NamedValue_ptr operator-> (void);
+
+  private:
+    NamedValue_ptr &ptr_;
+  };
+
+  // ****************************************************************
 
   /**
-   * If this list is used by a DII request, this will tell us if
-   * our CDR stream contains any marshaled arguments (needed for
-   * GIOP 1.2).
+   * @class NVList
+   *
+   * @brief CORBA::NVList implementation.
+   
+   * This is used in the (client side) DII (Dynamic Invocation
+   * Interface) to hold parameters, except for the return
+   * parameter. It's used in the same role in the (server side) DSI
+   * (Dynamic Skeleton Interface).
+   *
+   * Each user (client, server) provides the typecode and memory for
+   * each parameter using an NVList, then talks to the ORB using a
+   * Request or ServerRequest pseudo-object.  The ORB copies data
+   * to/from the IPC messages (e.g. IIOP::Request, IIOP::Response)
+   * as appropriate.
    */
-  CORBA::Boolean _lazy_has_arguments (void) const;
+  class TAO_Export NVList
+  {
+    friend class CORBA::ORB;
+    friend class CORBA::Request;
 
-  // Useful for template programming.
+  public:
+
+    /// return the current number of elements in the list
+    CORBA::ULong count (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
+
+    /// add an element and just initialize the flags
+    CORBA::NamedValue_ptr add (CORBA::Flags
+                               ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+
+    /// add an element and initialize its name and flags
+    CORBA::NamedValue_ptr add_item (const char *,
+                                    CORBA::Flags
+                                    ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+
+    /// initializes a value, name, and flags
+    CORBA::NamedValue_ptr add_value (const char *,
+                                     const CORBA::Any &,
+                                     CORBA::Flags
+                                     ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+
+    /// just like add_item. In addition, memory management of char *
+    /// name is taken over by the NVList
+    CORBA::NamedValue_ptr add_item_consume (char *,
+                                            CORBA::Flags
+                                            ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+
+    /// just like add_value. In addition, the NVList controls the
+    /// memory management of the char *name and Any *value parameter
+    CORBA::NamedValue_ptr add_value_consume (char *,
+                                             CORBA::Any_ptr,
+                                             CORBA::Flags
+                                             ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+
+    /// retrieve the item at the nth location. Raises Bounds
+    CORBA::NamedValue_ptr item (CORBA::ULong n
+                                ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+
+    //  CORBA::Status
+    /// remove element at index n. Raises Bounds
+    void remove (CORBA::ULong n
+                 ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+
+    // The pseudo object static methods..
+    static NVList* _duplicate (NVList*);
+    static NVList* _nil (void);
+
+    // = Reference counting.
+    CORBA::ULong _incr_refcnt (void);
+    CORBA::ULong _decr_refcnt (void);
+
+    // = TAO Extensions:
+
+    /**
+     * Set the incoming CDR stream, this is used by TAO to perform lazy
+     * evaluation of the NVList in an incoming ServerRequest.
+     * The <flag> is used to check which parameters (IN, OUT and/or
+     * INOUT) are to be extracted
+     */
+    void _tao_incoming_cdr (TAO_InputCDR &cdr,
+                            int flag,
+                            int &lazy_evaluation
+                            ACE_ENV_ARG_DECL);
+
+    /// Encode the NVList into the CDR stream. <flag> masks the type of
+    /// arguments (IN, OUT or INOUT) that are to be marshaled.
+    void _tao_encode (TAO_OutputCDR &cdr,
+                      TAO_ORB_Core *orb_core,
+                      int flag
+                      ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+
+    /// Decode the NVList arguments from the <cdr> stream.
+    void _tao_decode (TAO_InputCDR &cdr,
+                      int flag
+                      ACE_ENV_ARG_DECL);
+
+    /**
+     * Return the required alignment to marshal the NVList without any
+     * re-alignment.
+     * It returns ACE_CDR::MAX_ALIGNMENT to indicate errors.
+     */
+    ptr_arith_t _tao_target_alignment (void);
+
+    /**
+     * If this list is used by a DII request, this will tell us if
+     * our CDR stream contains any marshaled arguments (needed for
+     * GIOP 1.2).
+     */
+    CORBA::Boolean _lazy_has_arguments (void) const;
+
+    // Useful for template programming.
 #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-  typedef CORBA_NVList_ptr _ptr_type;
-  typedef CORBA_NVList_var _var_type;
+    typedef NVList_ptr _ptr_type;
+    typedef NVList_var _var_type;
 #endif /* __GNUC__ */
 
-private:
-  /// constructor - cannot be instantiated directly other than through the
-  /// ORB::create_list method
-  CORBA_NVList (void);
+  protected:
 
-  /// helper to increase the list size. This is used by all the add_
-  /// methods of the NVList class
-  CORBA_NamedValue_ptr add_element (CORBA::Flags
-                                    ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    /// Destructor
+    /**
+     * Protected destructor to enforce proper memory management
+     * through the reference counting mechanism.
+     */
+    ~NVList (void);
 
-  /// Lazy evaluation routine to fill up the Anys in the NVList from
-  /// the CDR stream.
-  void evaluate (ACE_ENV_SINGLE_ARG_DECL);
+  private:
+    /// constructor - cannot be instantiated directly other than
+    /// through the CORBA::ORB::create_list method
+    NVList (void);
 
-private:
-  /// internal list of parameters stored as NamedValues
-  ACE_Unbounded_Queue<CORBA_NamedValue_ptr> values_;
+    /// helper to increase the list size. This is used by all the add_
+    /// methods of the NVList class
+    CORBA::NamedValue_ptr add_element (CORBA::Flags
+                                       ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-  /// maximum length of list
-  CORBA::ULong max_;
+    /// Lazy evaluation routine to fill up the Anys in the NVList from
+    /// the CDR stream.
+    void evaluate (ACE_ENV_SINGLE_ARG_DECL);
 
-  /// maintains how many references exist to this object
-  CORBA::ULong refcount_;
+  private:
+    /// internal list of parameters stored as NamedValues
+    ACE_Unbounded_Queue<CORBA::NamedValue_ptr> values_;
 
-  /// Protects the reference count.
-  TAO_SYNCH_MUTEX refcount_lock_;
+    /// maximum length of list
+    CORBA::ULong max_;
 
-  /**
-   * When the NVList is used as part of a Server Request we can simply
-   * store the CDR buffer and perform lazy evaluation to compute the
-   * Anys.
-   */
-  TAO_InputCDR *incoming_;
+    /// maintains how many references exist to this object
+    CORBA::ULong refcount_;
 
-  /// The flags used to check which parameters are actually extracted
-  /// from the <incoming_> buffer
-  int incoming_flag_;
+    /// Protects the reference count.
+    TAO_SYNCH_MUTEX refcount_lock_;
 
-  friend class CORBA_ORB;
-  friend class CORBA_Request;
-};
+    /**
+     * When the NVList is used as part of a Server Request we can simply
+     * store the CDR buffer and perform lazy evaluation to compute the
+     * Anys.
+     */
+    TAO_InputCDR *incoming_;
 
-/**
- * @class CORBA_NVList_var
- *
- * @brief The T_var class for NVList
- *
- * As any other pseudo object NVList must have a T_var class,
- * the interface an semantics are specified in the CORBA spec.
- * = NOTE
- * We use CORBA_NVList_ptr as the _ptr type instead of
- * CORBA::NVList_ptr, this is an attempt to reduced the cyclic
- * dependencies in TAO.
- */
-class TAO_Export CORBA_NVList_var
-{
-public:
-  CORBA_NVList_var (void);
-  CORBA_NVList_var (CORBA_NVList_ptr);
-  CORBA_NVList_var (const CORBA_NVList_var &);
-  ~CORBA_NVList_var (void);
-
-  CORBA_NVList_var &operator= (CORBA_NVList_ptr);
-  CORBA_NVList_var &operator= (const CORBA_NVList_var &);
-  CORBA_NVList_ptr operator-> (void) const;
-
-  /// in, inout, out, _retn
-  operator const CORBA_NVList_ptr &() const;
-  operator CORBA_NVList_ptr &();
-  CORBA_NVList_ptr in (void) const;
-  CORBA_NVList_ptr &inout (void);
-  CORBA_NVList_ptr &out (void);
-  CORBA_NVList_ptr _retn (void);
-  CORBA_NVList_ptr ptr (void) const;
-
-private:
-  CORBA_NVList_ptr ptr_;
-};
+    /// The flags used to check which parameters are actually extracted
+    /// from the <incoming_> buffer
+    int incoming_flag_;
+  };
 
-/**
- * @class CORBA_NVList_out
- *
- * @brief The T_out class for NVList
- *
- * As any other pseudo object NVList must have a T_out class,
- * the interface an semantics are specified in the CORBA spec.
- * = NOTE
- * We use CORBA_NVList_ptr as the _ptr type instead of
- * CORBA::NVList_ptr, this is an attempt to reduced the cyclic
- * dependencies in TAO.
- */
-class TAO_Export CORBA_NVList_out
-{
-public:
-  CORBA_NVList_out (CORBA_NVList_ptr &);
-  CORBA_NVList_out (CORBA_NVList_var &);
-  CORBA_NVList_out (CORBA_NVList_out &);
-  CORBA_NVList_out &operator= (CORBA_NVList_out &);
-  CORBA_NVList_out &operator= (const CORBA_NVList_var &);
-  CORBA_NVList_out &operator= (CORBA_NVList_ptr);
-  operator CORBA_NVList_ptr &();
-  CORBA_NVList_ptr &ptr (void);
-  CORBA_NVList_ptr operator-> (void);
-
-private:
-  CORBA_NVList_ptr &ptr_;
-};
+  /**
+   * @class NVList_var
+   *
+   * @brief The T_var class for NVList
+   *
+   * As any other pseudo object NVList must have a T_var class,
+   * the interface an semantics are specified in the CORBA spec.
+   */
+  class TAO_Export NVList_var
+  {
+  public:
+    NVList_var (void);
+    NVList_var (NVList_ptr);
+    NVList_var (const NVList_var &);
+    ~NVList_var (void);
+
+    NVList_var &operator= (NVList_ptr);
+    NVList_var &operator= (const NVList_var &);
+    NVList_ptr operator-> (void) const;
+
+    /// in, inout, out, _retn
+    operator const NVList_ptr &() const;
+    operator NVList_ptr &();
+    NVList_ptr in (void) const;
+    NVList_ptr &inout (void);
+    NVList_ptr &out (void);
+    NVList_ptr _retn (void);
+    NVList_ptr ptr (void) const;
+
+  private:
+    NVList_ptr ptr_;
+   };
+
+  /**
+   * @class NVList_out
+   *
+   * @brief The T_out class for NVList
+   *
+   * As any other pseudo object NVList must have a T_out class,
+   * the interface an semantics are specified in the CORBA spec.
+   */
+  class TAO_Export NVList_out
+  {
+  public:
+    NVList_out (NVList_ptr &);
+    NVList_out (NVList_var &);
+    NVList_out (NVList_out &);
+    NVList_out &operator= (NVList_out &);
+    NVList_out &operator= (const NVList_var &);
+    NVList_out &operator= (NVList_ptr);
+    operator NVList_ptr &();
+    NVList_ptr &ptr (void);
+    NVList_ptr operator-> (void);
+
+  private:
+    NVList_ptr &ptr_;
+   };
+}
 
 // ****************************************************************
 
diff --git a/TAO/tao/NVList.i b/TAO/tao/NVList.i
index 81c69a9f738..94715f70889 100644
--- a/TAO/tao/NVList.i
+++ b/TAO/tao/NVList.i
@@ -1,5 +1,6 @@
+// -*- C++ -*-
+//
 // $Id$
-// This may look like C, but it's really -*- C++ -*-
 
 ACE_INLINE CORBA::Boolean
 CORBA::is_nil (CORBA::NamedValue_ptr nv)
@@ -16,7 +17,7 @@ CORBA::release (CORBA::NamedValue_ptr nv)
 
 // constructor
 ACE_INLINE
-CORBA_NamedValue::CORBA_NamedValue (void)
+CORBA::NamedValue::NamedValue (void)
   : refcount_ (1),
     flags_ (0),
     name_ (0)
@@ -25,41 +26,41 @@ CORBA_NamedValue::CORBA_NamedValue (void)
 
 // return the name
 ACE_INLINE const char*
-CORBA_NamedValue::name (void) const
+CORBA::NamedValue::name (void) const
 {
   return this->name_;
 }
 
 // return the value
 ACE_INLINE CORBA::Any_ptr
-CORBA_NamedValue::value (void) const
+CORBA::NamedValue::value (void) const
 {
   return ACE_const_cast (CORBA::Any_ptr, &this->any_);
 }
 
 // return the flags
 ACE_INLINE CORBA::Flags
-CORBA_NamedValue::flags (void) const
+CORBA::NamedValue::flags (void) const
 {
   return this->flags_;
 }
 
-ACE_INLINE CORBA_NamedValue*
-CORBA_NamedValue::_duplicate (CORBA_NamedValue *x)
+ACE_INLINE CORBA::NamedValue*
+CORBA::NamedValue::_duplicate (CORBA::NamedValue *x)
 {
   if (x != 0)
     x->_incr_refcnt ();
   return x;
 }
 
-ACE_INLINE CORBA_NamedValue*
-CORBA_NamedValue::_nil (void)
+ACE_INLINE CORBA::NamedValue*
+CORBA::NamedValue::_nil (void)
 {
   return 0;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_NamedValue_var
+// Inline operations for class CORBA::NamedValue_var
 // *************************************************************
 
 ACE_INLINE CORBA::Boolean
@@ -76,158 +77,158 @@ CORBA::release (CORBA::NVList_ptr nvl)
 }
 
 ACE_INLINE
-CORBA_NamedValue_var::CORBA_NamedValue_var (void)
-  : ptr_ (CORBA_NamedValue::_nil ())
+CORBA::NamedValue_var::NamedValue_var (void)
+  : ptr_ (CORBA::NamedValue::_nil ())
 {
 }
 
 ACE_INLINE
-CORBA_NamedValue_var::CORBA_NamedValue_var (CORBA_NamedValue_ptr p)
+CORBA::NamedValue_var::NamedValue_var (CORBA::NamedValue_ptr p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_NamedValue_var::~CORBA_NamedValue_var (void)
+CORBA::NamedValue_var::~NamedValue_var (void)
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_NamedValue_ptr
-CORBA_NamedValue_var::ptr (void) const
+ACE_INLINE CORBA::NamedValue_ptr
+CORBA::NamedValue_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_NamedValue_var::CORBA_NamedValue_var (const CORBA_NamedValue_var &p)
-  : ptr_ (CORBA_NamedValue::_duplicate (p.ptr ()))
+CORBA::NamedValue_var::NamedValue_var (const CORBA::NamedValue_var &p)
+  : ptr_ (CORBA::NamedValue::_duplicate (p.ptr ()))
 {}
 
-ACE_INLINE CORBA_NamedValue_var &
-CORBA_NamedValue_var::operator= (CORBA_NamedValue_ptr p)
+ACE_INLINE CORBA::NamedValue_var &
+CORBA::NamedValue_var::operator= (CORBA::NamedValue_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_NamedValue_var &
-CORBA_NamedValue_var::operator= (const CORBA_NamedValue_var &p)
+ACE_INLINE CORBA::NamedValue_var &
+CORBA::NamedValue_var::operator= (const CORBA::NamedValue_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_NamedValue::_duplicate (p.ptr ());
+    this->ptr_ = CORBA::NamedValue::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE
-CORBA_NamedValue_var::operator const CORBA_NamedValue_ptr &() const
+CORBA::NamedValue_var::operator const CORBA::NamedValue_ptr &() const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_NamedValue_var::operator CORBA_NamedValue_ptr &()
+CORBA::NamedValue_var::operator CORBA::NamedValue_ptr &()
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_NamedValue_ptr
-CORBA_NamedValue_var::operator-> (void) const
+ACE_INLINE CORBA::NamedValue_ptr
+CORBA::NamedValue_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_NamedValue_ptr
-CORBA_NamedValue_var::in (void) const
+ACE_INLINE CORBA::NamedValue_ptr
+CORBA::NamedValue_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_NamedValue_ptr &
-CORBA_NamedValue_var::inout (void)
+ACE_INLINE CORBA::NamedValue_ptr &
+CORBA::NamedValue_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_NamedValue_ptr &
-CORBA_NamedValue_var::out (void)
+ACE_INLINE CORBA::NamedValue_ptr &
+CORBA::NamedValue_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_NamedValue::_nil ();
+  this->ptr_ = CORBA::NamedValue::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_NamedValue_ptr
-CORBA_NamedValue_var::_retn (void)
+ACE_INLINE CORBA::NamedValue_ptr
+CORBA::NamedValue_var::_retn (void)
 {
   // yield ownership
-  CORBA_NamedValue_ptr val = this->ptr_;
-  this->ptr_ = CORBA_NamedValue::_nil ();
+  CORBA::NamedValue_ptr val = this->ptr_;
+  this->ptr_ = CORBA::NamedValue::_nil ();
   return val;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_NamedValue_out
+// Inline operations for class CORBA::NamedValue_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_NamedValue_out::CORBA_NamedValue_out (CORBA_NamedValue_ptr &p)
+CORBA::NamedValue_out::NamedValue_out (CORBA::NamedValue_ptr &p)
         : ptr_ (p)
 {
-  this->ptr_ = CORBA_NamedValue::_nil ();
+  this->ptr_ = CORBA::NamedValue::_nil ();
 }
 
 ACE_INLINE
-CORBA_NamedValue_out::CORBA_NamedValue_out (CORBA_NamedValue_var &p)
+CORBA::NamedValue_out::NamedValue_out (CORBA::NamedValue_var &p)
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_NamedValue::_nil ();
+  this->ptr_ = CORBA::NamedValue::_nil ();
 }
 
 ACE_INLINE
-CORBA_NamedValue_out::CORBA_NamedValue_out (CORBA_NamedValue_out &p)
+CORBA::NamedValue_out::NamedValue_out (CORBA::NamedValue_out &p)
   : ptr_ (p.ptr_)
 {}
 
-ACE_INLINE CORBA_NamedValue_out &
-CORBA_NamedValue_out::operator= (CORBA_NamedValue_out &p)
+ACE_INLINE CORBA::NamedValue_out &
+CORBA::NamedValue_out::operator= (CORBA::NamedValue_out &p)
 {
   this->ptr_ = p.ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_NamedValue_out &
-CORBA_NamedValue_out::operator= (const CORBA_NamedValue_var &p)
+ACE_INLINE CORBA::NamedValue_out &
+CORBA::NamedValue_out::operator= (const CORBA::NamedValue_var &p)
 {
-  this->ptr_ = CORBA_NamedValue::_duplicate (p.ptr ());
+  this->ptr_ = CORBA::NamedValue::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_NamedValue_out &
-CORBA_NamedValue_out::operator= (CORBA_NamedValue_ptr p)
+ACE_INLINE CORBA::NamedValue_out &
+CORBA::NamedValue_out::operator= (CORBA::NamedValue_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE
-CORBA_NamedValue_out::operator CORBA_NamedValue_ptr &()
+CORBA::NamedValue_out::operator CORBA::NamedValue_ptr &()
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_NamedValue_ptr &
-CORBA_NamedValue_out::ptr (void)
+ACE_INLINE CORBA::NamedValue_ptr &
+CORBA::NamedValue_out::ptr (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_NamedValue_ptr
-CORBA_NamedValue_out::operator-> (void)
+ACE_INLINE CORBA::NamedValue_ptr
+CORBA::NamedValue_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -238,7 +239,7 @@ CORBA_NamedValue_out::operator-> (void)
 
 // constructor
 ACE_INLINE
-CORBA_NVList::CORBA_NVList (void)
+CORBA::NVList::NVList (void)
   : max_ (0),
     refcount_ (1),
     incoming_ (0),
@@ -247,185 +248,186 @@ CORBA_NVList::CORBA_NVList (void)
 }
 
 ACE_INLINE CORBA::ULong
-CORBA_NVList::count (ACE_ENV_SINGLE_ARG_DECL) const
+CORBA::NVList::count (ACE_ENV_SINGLE_ARG_DECL) const
 {
-  (ACE_const_cast(CORBA_NVList*,this))->evaluate (ACE_ENV_SINGLE_ARG_PARAMETER);
+  (ACE_const_cast (CORBA::NVList *,
+                   this))->evaluate (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
   return this->max_;
 }
 
-ACE_INLINE CORBA_NVList*
-CORBA_NVList::_duplicate (CORBA_NVList *x)
+ACE_INLINE CORBA::NVList*
+CORBA::NVList::_duplicate (CORBA::NVList *x)
 {
   if (x != 0)
     x->_incr_refcnt ();
   return x;
 }
 
-ACE_INLINE CORBA_NVList*
-CORBA_NVList::_nil (void)
+ACE_INLINE CORBA::NVList*
+CORBA::NVList::_nil (void)
 {
   return 0;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_NVList_var
+// Inline operations for class CORBA::NVList_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_NVList_var::CORBA_NVList_var (void)
-  : ptr_ (CORBA_NVList::_nil ())
+CORBA::NVList_var::NVList_var (void)
+  : ptr_ (CORBA::NVList::_nil ())
 {
 }
 
 ACE_INLINE
-CORBA_NVList_var::CORBA_NVList_var (CORBA_NVList_ptr p)
+CORBA::NVList_var::NVList_var (CORBA::NVList_ptr p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_NVList_var::~CORBA_NVList_var (void)
+CORBA::NVList_var::~NVList_var (void)
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_NVList_ptr
-CORBA_NVList_var::ptr (void) const
+ACE_INLINE CORBA::NVList_ptr
+CORBA::NVList_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_NVList_var::CORBA_NVList_var (const CORBA_NVList_var &p)
-  : ptr_ (CORBA_NVList::_duplicate (p.ptr ()))
+CORBA::NVList_var::NVList_var (const CORBA::NVList_var &p)
+  : ptr_ (CORBA::NVList::_duplicate (p.ptr ()))
 {}
 
-ACE_INLINE CORBA_NVList_var &
-CORBA_NVList_var::operator= (CORBA_NVList_ptr p)
+ACE_INLINE CORBA::NVList_var &
+CORBA::NVList_var::operator= (CORBA::NVList_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_NVList_var &
-CORBA_NVList_var::operator= (const CORBA_NVList_var &p)
+ACE_INLINE CORBA::NVList_var &
+CORBA::NVList_var::operator= (const CORBA::NVList_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_NVList::_duplicate (p.ptr ());
+    this->ptr_ = CORBA::NVList::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE
-CORBA_NVList_var::operator const CORBA_NVList_ptr &() const
+CORBA::NVList_var::operator const CORBA::NVList_ptr &() const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_NVList_var::operator CORBA_NVList_ptr &()
+CORBA::NVList_var::operator CORBA::NVList_ptr &()
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_NVList_ptr
-CORBA_NVList_var::operator-> (void) const
+ACE_INLINE CORBA::NVList_ptr
+CORBA::NVList_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_NVList_ptr
-CORBA_NVList_var::in (void) const
+ACE_INLINE CORBA::NVList_ptr
+CORBA::NVList_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_NVList_ptr &
-CORBA_NVList_var::inout (void)
+ACE_INLINE CORBA::NVList_ptr &
+CORBA::NVList_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_NVList_ptr &
-CORBA_NVList_var::out (void)
+ACE_INLINE CORBA::NVList_ptr &
+CORBA::NVList_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_NVList::_nil ();
+  this->ptr_ = CORBA::NVList::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_NVList_ptr
-CORBA_NVList_var::_retn (void)
+ACE_INLINE CORBA::NVList_ptr
+CORBA::NVList_var::_retn (void)
 {
   // yield ownership
-  CORBA_NVList_ptr val = this->ptr_;
-  this->ptr_ = CORBA_NVList::_nil ();
+  CORBA::NVList_ptr val = this->ptr_;
+  this->ptr_ = CORBA::NVList::_nil ();
   return val;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_NVList_out
+// Inline operations for class CORBA::NVList_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_NVList_out::CORBA_NVList_out (CORBA_NVList_ptr &p)
+CORBA::NVList_out::NVList_out (CORBA::NVList_ptr &p)
         : ptr_ (p)
 {
-  this->ptr_ = CORBA_NVList::_nil ();
+  this->ptr_ = CORBA::NVList::_nil ();
 }
 
 ACE_INLINE
-CORBA_NVList_out::CORBA_NVList_out (CORBA_NVList_var &p)
+CORBA::NVList_out::NVList_out (CORBA::NVList_var &p)
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_NVList::_nil ();
+  this->ptr_ = CORBA::NVList::_nil ();
 }
 
 ACE_INLINE
-CORBA_NVList_out::CORBA_NVList_out (CORBA_NVList_out &p)
+CORBA::NVList_out::NVList_out (CORBA::NVList_out &p)
   : ptr_ (p.ptr_)
 {}
 
-ACE_INLINE CORBA_NVList_out &
-CORBA_NVList_out::operator= (CORBA_NVList_out &p)
+ACE_INLINE CORBA::NVList_out &
+CORBA::NVList_out::operator= (CORBA::NVList_out &p)
 {
   this->ptr_ = p.ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_NVList_out &
-CORBA_NVList_out::operator= (const CORBA_NVList_var &p)
+ACE_INLINE CORBA::NVList_out &
+CORBA::NVList_out::operator= (const CORBA::NVList_var &p)
 {
-  this->ptr_ = CORBA_NVList::_duplicate (p.ptr ());
+  this->ptr_ = CORBA::NVList::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_NVList_out &
-CORBA_NVList_out::operator= (CORBA_NVList_ptr p)
+ACE_INLINE CORBA::NVList_out &
+CORBA::NVList_out::operator= (CORBA::NVList_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE
-CORBA_NVList_out::operator CORBA_NVList_ptr &()
+CORBA::NVList_out::operator CORBA::NVList_ptr &()
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_NVList_ptr &
-CORBA_NVList_out::ptr (void)
+ACE_INLINE CORBA::NVList_ptr &
+CORBA::NVList_out::ptr (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_NVList_ptr
-CORBA_NVList_out::operator-> (void)
+ACE_INLINE CORBA::NVList_ptr
+CORBA::NVList_out::operator-> (void)
 {
   return this->ptr_;
 }
diff --git a/TAO/tao/ORB.cpp b/TAO/tao/ORB.cpp
index bb82ebc0396..791dff8bdf3 100644
--- a/TAO/tao/ORB.cpp
+++ b/TAO/tao/ORB.cpp
@@ -1,5 +1,3 @@
-// -*- C++ -*-
-
 #include "ORB.h"
 
 ACE_RCSID (tao,
@@ -54,18 +52,18 @@ ACE_RCSID (tao,
 # include "ORB.i"
 #endif /* ! __ACE_INLINE__ */
 
-static const char ior_prefix [] = "IOR:";
+static const char ior_prefix[] = "IOR:";
 
 // = Static initialization.
 
 // Count of the number of ORBs.
-int CORBA_ORB::orb_init_count_ = 0;
+int CORBA::ORB::orb_init_count_ = 0;
 
 // ****************************************************************
 
 CORBA::ORB::InvalidName::InvalidName (void)
-  : CORBA_UserException ("IDL:omg.org/CORBA/ORB/InvalidName:1.0",
-                         "InvalidName")
+  : CORBA::UserException ("IDL:omg.org/CORBA/ORB/InvalidName:1.0",
+                          "InvalidName")
 {
 }
 
@@ -75,9 +73,9 @@ CORBA::ORB::InvalidName::~InvalidName (void)
 }
 
 // Copy constructor.
-CORBA::ORB::InvalidName::InvalidName (const ::CORBA::ORB::InvalidName &_tao_excp)
-  : CORBA_UserException (_tao_excp._rep_id (),
-                         _tao_excp._name ())
+CORBA::ORB::InvalidName::InvalidName (const CORBA::ORB::InvalidName &exc)
+  : CORBA::UserException (exc._rep_id (),
+                          exc._name ())
 {
 }
 
@@ -85,14 +83,15 @@ CORBA::ORB::InvalidName::InvalidName (const ::CORBA::ORB::InvalidName &_tao_excp
 CORBA::ORB::InvalidName&
 CORBA::ORB::InvalidName::operator= (const ::CORBA::ORB::InvalidName &_tao_excp)
 {
-  this->CORBA_UserException::operator= (_tao_excp);
+  this->UserException::operator= (_tao_excp);
   return *this;
 }
 
 CORBA::ORB::InvalidName *
 CORBA::ORB::InvalidName::_downcast (CORBA::Exception *exc)
 {
-  if (!ACE_OS::strcmp ("IDL:omg.org/CORBA/ORB/InvalidName:1.0", exc->_rep_id ()))
+  if (!ACE_OS::strcmp ("IDL:omg.org/CORBA/ORB/InvalidName:1.0",
+                       exc->_rep_id ()))
     {
       return ACE_dynamic_cast (InvalidName *, exc);
     }
@@ -144,7 +143,7 @@ void CORBA::ORB::InvalidName::_tao_decode (
 
 // ****************************************************************
 
-CORBA_ORB::CORBA_ORB (TAO_ORB_Core *orb_core)
+CORBA::ORB::ORB (TAO_ORB_Core *orb_core)
   : lock_ (),
     refcount_ (1),
     orb_core_ (orb_core),
@@ -154,14 +153,14 @@ CORBA_ORB::CORBA_ORB (TAO_ORB_Core *orb_core)
 {
 }
 
-CORBA_ORB::~CORBA_ORB (void)
+CORBA::ORB::~ORB (void)
 {
   // This destructor is only invoked when the last ORB reference (not
   // instance) is being destroyed.
 }
 
 void
-CORBA_ORB::shutdown (CORBA::Boolean wait_for_completion
+CORBA::ORB::shutdown (CORBA::Boolean wait_for_completion
                      ACE_ENV_ARG_DECL)
 {
   // We cannot lock the exceptions here. We need to propogate
@@ -175,7 +174,7 @@ CORBA_ORB::shutdown (CORBA::Boolean wait_for_completion
 }
 
 void
-CORBA_ORB::destroy (ACE_ENV_SINGLE_ARG_DECL)
+CORBA::ORB::destroy (ACE_ENV_SINGLE_ARG_DECL)
 {
   if (this->orb_core () == 0)
     {
@@ -206,20 +205,20 @@ CORBA_ORB::destroy (ACE_ENV_SINGLE_ARG_DECL)
 }
 
 void
-CORBA_ORB::run (ACE_ENV_SINGLE_ARG_DECL)
+CORBA::ORB::run (ACE_ENV_SINGLE_ARG_DECL)
 {
   this->run (0 ACE_ENV_ARG_PARAMETER);
 }
 
 void
-CORBA_ORB::run (ACE_Time_Value &tv ACE_ENV_ARG_DECL)
+CORBA::ORB::run (ACE_Time_Value &tv ACE_ENV_ARG_DECL)
 {
   this->run (&tv ACE_ENV_ARG_PARAMETER);
 }
 
 void
-CORBA_ORB::run (ACE_Time_Value *tv
-                ACE_ENV_ARG_DECL)
+CORBA::ORB::run (ACE_Time_Value *tv
+                 ACE_ENV_ARG_DECL)
 {
   this->check_shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK;
@@ -228,19 +227,19 @@ CORBA_ORB::run (ACE_Time_Value *tv
 }
 
 void
-CORBA_ORB::perform_work (ACE_ENV_SINGLE_ARG_DECL)
+CORBA::ORB::perform_work (ACE_ENV_SINGLE_ARG_DECL)
 {
   this->perform_work (0 ACE_ENV_ARG_PARAMETER);
 }
 
 void
-CORBA_ORB::perform_work (ACE_Time_Value &tv ACE_ENV_ARG_DECL)
+CORBA::ORB::perform_work (ACE_Time_Value &tv ACE_ENV_ARG_DECL)
 {
   this->perform_work (&tv ACE_ENV_ARG_PARAMETER);
 }
 
 void
-CORBA_ORB::perform_work (ACE_Time_Value *tv
+CORBA::ORB::perform_work (ACE_Time_Value *tv
                          ACE_ENV_ARG_DECL)
 {
   // This method should not be called if the ORB has been shutdown.
@@ -251,7 +250,7 @@ CORBA_ORB::perform_work (ACE_Time_Value *tv
 }
 
 CORBA::Boolean
-CORBA_ORB::work_pending (ACE_Time_Value &tv ACE_ENV_ARG_DECL)
+CORBA::ORB::work_pending (ACE_Time_Value &tv ACE_ENV_ARG_DECL)
 {
   // This method should not be called if the ORB has been shutdown.
   this->check_shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
@@ -268,7 +267,7 @@ CORBA_ORB::work_pending (ACE_Time_Value &tv ACE_ENV_ARG_DECL)
 }
 
 CORBA::Boolean
-CORBA_ORB::work_pending (ACE_ENV_SINGLE_ARG_DECL)
+CORBA::ORB::work_pending (ACE_ENV_SINGLE_ARG_DECL)
 {
   // This method should not be called if the ORB has been shutdown.
   this->check_shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
@@ -287,7 +286,7 @@ CORBA_ORB::work_pending (ACE_ENV_SINGLE_ARG_DECL)
 #if (TAO_HAS_MINIMUM_CORBA == 0)
 
 void
-CORBA_ORB::create_list (CORBA::Long count,
+CORBA::ORB::create_list (CORBA::Long count,
                         CORBA::NVList_ptr &new_list
                         ACE_ENV_ARG_DECL)
 {
@@ -297,7 +296,7 @@ CORBA_ORB::create_list (CORBA::Long count,
   ACE_NEW_THROW_EX (new_list,
                     CORBA::NVList,
                     CORBA::NO_MEMORY (
-                      CORBA_SystemException::_tao_minor_code (
+                      CORBA::SystemException::_tao_minor_code (
                         TAO_DEFAULT_MINOR_CODE,
                         ENOMEM),
                       CORBA::COMPLETED_NO));
@@ -314,7 +313,7 @@ CORBA_ORB::create_list (CORBA::Long count,
           ACE_NEW_THROW_EX (nv,
                             CORBA::NamedValue,
                             CORBA::NO_MEMORY (
-                              CORBA_SystemException::_tao_minor_code (
+                              CORBA::SystemException::_tao_minor_code (
                                 TAO_DEFAULT_MINOR_CODE,
                                 ENOMEM),
                               CORBA::COMPLETED_NO));
@@ -326,7 +325,7 @@ CORBA_ORB::create_list (CORBA::Long count,
 }
 
 void
-CORBA_ORB::create_exception_list (CORBA::ExceptionList_ptr &list
+CORBA::ORB::create_exception_list (CORBA::ExceptionList_ptr &list
                                   ACE_ENV_ARG_DECL)
 {
   TAO_Dynamic_Adapter *dynamic_adapter =
@@ -339,26 +338,26 @@ CORBA_ORB::create_exception_list (CORBA::ExceptionList_ptr &list
 }
 
 void
-CORBA_ORB::create_environment (CORBA::Environment_ptr &environment
+CORBA::ORB::create_environment (CORBA::Environment_ptr &environment
                                ACE_ENV_ARG_DECL)
 {
   ACE_NEW_THROW_EX (environment,
                     CORBA::Environment (),
                     CORBA::NO_MEMORY (
-                      CORBA_SystemException::_tao_minor_code (
+                      CORBA::SystemException::_tao_minor_code (
                         TAO_DEFAULT_MINOR_CODE,
                         ENOMEM),
                       CORBA::COMPLETED_NO));
 }
 
 void
-CORBA_ORB::create_named_value (CORBA::NamedValue_ptr &nv
+CORBA::ORB::create_named_value (CORBA::NamedValue_ptr &nv
                                ACE_ENV_ARG_DECL)
 {
   ACE_NEW_THROW_EX (nv,
                     CORBA::NamedValue,
                     CORBA::NO_MEMORY (
-                      CORBA_SystemException::_tao_minor_code (
+                      CORBA::SystemException::_tao_minor_code (
                         TAO_DEFAULT_MINOR_CODE,
                         ENOMEM),
                       CORBA::COMPLETED_NO));
@@ -368,13 +367,13 @@ CORBA_ORB::create_named_value (CORBA::NamedValue_ptr &nv
 // CORBA::NO_IMPLEMENT.
 
 CORBA::Boolean
-CORBA_ORB::get_service_information (
+CORBA::ORB::get_service_information (
   CORBA::ServiceType /* service_type */,
   CORBA::ServiceInformation_out /* service_information */
   ACE_ENV_ARG_DECL)
 {
   ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (
-                      CORBA_SystemException::_tao_minor_code (
+                      CORBA::SystemException::_tao_minor_code (
                         TAO_DEFAULT_MINOR_CODE,
                         ENOTSUP),
                       CORBA::COMPLETED_NO),
@@ -382,65 +381,65 @@ CORBA_ORB::get_service_information (
 }
 
 void
-CORBA_ORB::create_context_list (CORBA::ContextList_ptr &
+CORBA::ORB::create_context_list (CORBA::ContextList_ptr &
                                 ACE_ENV_ARG_DECL)
 {
   ACE_THROW (CORBA::NO_IMPLEMENT (
-               CORBA_SystemException::_tao_minor_code (
+               CORBA::SystemException::_tao_minor_code (
                  TAO_DEFAULT_MINOR_CODE,
                  ENOTSUP),
                CORBA::COMPLETED_NO));
 }
 
 void
-CORBA_ORB::get_default_context (CORBA::Context_ptr &
+CORBA::ORB::get_default_context (CORBA::Context_ptr &
                                 ACE_ENV_ARG_DECL)
 {
   ACE_THROW (CORBA::NO_IMPLEMENT (
-               CORBA_SystemException::_tao_minor_code (
+               CORBA::SystemException::_tao_minor_code (
                  TAO_DEFAULT_MINOR_CODE,
                  ENOTSUP),
                CORBA::COMPLETED_NO));
 }
 
 void
-CORBA_ORB::send_multiple_requests_oneway (const CORBA_ORB_RequestSeq &
+CORBA::ORB::send_multiple_requests_oneway (const CORBA::ORB::RequestSeq &
                                           ACE_ENV_ARG_DECL)
 {
   ACE_THROW (CORBA::NO_IMPLEMENT (
-               CORBA_SystemException::_tao_minor_code (
+               CORBA::SystemException::_tao_minor_code (
                  TAO_DEFAULT_MINOR_CODE,
                  ENOTSUP),
                CORBA::COMPLETED_NO));
 }
 
 void
-CORBA_ORB::send_multiple_requests_deferred (const CORBA_ORB_RequestSeq &
+CORBA::ORB::send_multiple_requests_deferred (const CORBA::ORB::RequestSeq &
                                             ACE_ENV_ARG_DECL)
 {
   ACE_THROW (CORBA::NO_IMPLEMENT (
-               CORBA_SystemException::_tao_minor_code (
+               CORBA::SystemException::_tao_minor_code (
                  TAO_DEFAULT_MINOR_CODE,
                  ENOTSUP),
                CORBA::COMPLETED_NO));
 }
 
 void
-CORBA_ORB::get_next_response (CORBA_Request_ptr &
+CORBA::ORB::get_next_response (CORBA::Request_ptr &
                               ACE_ENV_ARG_DECL)
 {
   ACE_THROW (CORBA::NO_IMPLEMENT (
-               CORBA_SystemException::_tao_minor_code (
+               CORBA::SystemException::_tao_minor_code (
                  TAO_DEFAULT_MINOR_CODE,
                  ENOTSUP),
                CORBA::COMPLETED_NO));
 }
 
 CORBA::Boolean
-CORBA_ORB::poll_next_response (ACE_ENV_SINGLE_ARG_DECL)
+CORBA::ORB::poll_next_response (ACE_ENV_SINGLE_ARG_DECL)
 {
   ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (
-                      CORBA_SystemException::_tao_minor_code (
+                      CORBA::SystemException::_tao_minor_code (
                         TAO_DEFAULT_MINOR_CODE,
                         ENOTSUP),
                       CORBA::COMPLETED_NO),
@@ -450,10 +449,10 @@ CORBA_ORB::poll_next_response (ACE_ENV_SINGLE_ARG_DECL)
 // ****************************************************************
 
 CORBA::TypeCode_ptr
-CORBA_ORB::create_struct_tc (
+CORBA::ORB::create_struct_tc (
     const char *id,
     const char *name,
-    const CORBA_StructMemberSeq & members
+    const CORBA::StructMemberSeq & members
     ACE_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((CORBA::SystemException))
@@ -476,11 +475,11 @@ CORBA_ORB::create_struct_tc (
 }
 
 CORBA::TypeCode_ptr
-CORBA_ORB::create_union_tc (
+CORBA::ORB::create_union_tc (
     const char *id,
     const char *name,
     CORBA::TypeCode_ptr discriminator_type,
-    const CORBA_UnionMemberSeq & members
+    const CORBA::UnionMemberSeq & members
     ACE_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((CORBA::SystemException))
@@ -504,10 +503,10 @@ CORBA_ORB::create_union_tc (
 }
 
 CORBA::TypeCode_ptr
-CORBA_ORB::create_enum_tc (
+CORBA::ORB::create_enum_tc (
     const char *id,
     const char *name,
-    const CORBA_EnumMemberSeq & members
+    const CORBA::EnumMemberSeq & members
     ACE_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((CORBA::SystemException))
@@ -530,7 +529,7 @@ CORBA_ORB::create_enum_tc (
 }
 
 CORBA::TypeCode_ptr
-CORBA_ORB::create_alias_tc (
+CORBA::ORB::create_alias_tc (
     const char *id,
     const char *name,
     CORBA::TypeCode_ptr original_type
@@ -556,10 +555,10 @@ CORBA_ORB::create_alias_tc (
 }
 
 CORBA::TypeCode_ptr
-CORBA_ORB::create_exception_tc (
+CORBA::ORB::create_exception_tc (
     const char *id,
     const char *name,
-    const CORBA_StructMemberSeq & members
+    const CORBA::StructMemberSeq & members
     ACE_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((CORBA::SystemException))
@@ -582,7 +581,7 @@ CORBA_ORB::create_exception_tc (
 }
 
 CORBA::TypeCode_ptr
-CORBA_ORB::create_interface_tc (
+CORBA::ORB::create_interface_tc (
     const char *id,
     const char *name
     ACE_ENV_ARG_DECL
@@ -606,7 +605,7 @@ CORBA_ORB::create_interface_tc (
 }
 
 CORBA::TypeCode_ptr
-CORBA_ORB::create_string_tc (
+CORBA::ORB::create_string_tc (
     CORBA::ULong bound
     ACE_ENV_ARG_DECL
   )
@@ -628,7 +627,7 @@ CORBA_ORB::create_string_tc (
 }
 
 CORBA::TypeCode_ptr
-CORBA_ORB::create_wstring_tc (
+CORBA::ORB::create_wstring_tc (
     CORBA::ULong bound
     ACE_ENV_ARG_DECL
   )
@@ -650,7 +649,7 @@ CORBA_ORB::create_wstring_tc (
 }
 
 CORBA::TypeCode_ptr
-CORBA_ORB::create_fixed_tc (
+CORBA::ORB::create_fixed_tc (
     CORBA::UShort digits,
     CORBA::UShort scale
     ACE_ENV_ARG_DECL
@@ -674,7 +673,7 @@ CORBA_ORB::create_fixed_tc (
 }
 
 CORBA::TypeCode_ptr
-CORBA_ORB::create_sequence_tc (
+CORBA::ORB::create_sequence_tc (
     CORBA::ULong bound,
     CORBA::TypeCode_ptr element_type
     ACE_ENV_ARG_DECL
@@ -698,7 +697,7 @@ CORBA_ORB::create_sequence_tc (
 }
 
 CORBA::TypeCode_ptr
-CORBA_ORB::create_array_tc (
+CORBA::ORB::create_array_tc (
     CORBA::ULong length,
     CORBA::TypeCode_ptr element_type
     ACE_ENV_ARG_DECL
@@ -722,12 +721,12 @@ CORBA_ORB::create_array_tc (
 }
 
 CORBA::TypeCode_ptr
-CORBA_ORB::create_value_tc (
+CORBA::ORB::create_value_tc (
     const char *id,
     const char *name,
     CORBA::ValueModifier type_modifier,
     CORBA::TypeCode_ptr concrete_base,
-    const CORBA_ValueMemberSeq & members
+    const CORBA::ValueMemberSeq & members
     ACE_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((CORBA::SystemException))
@@ -752,7 +751,7 @@ CORBA_ORB::create_value_tc (
 }
 
 CORBA::TypeCode_ptr
-CORBA_ORB::create_value_box_tc (
+CORBA::ORB::create_value_box_tc (
     const char *id,
     const char *name,
     CORBA::TypeCode_ptr boxed_type
@@ -778,7 +777,7 @@ CORBA_ORB::create_value_box_tc (
 }
 
 CORBA::TypeCode_ptr
-CORBA_ORB::create_native_tc (
+CORBA::ORB::create_native_tc (
     const char *id,
     const char *name
     ACE_ENV_ARG_DECL
@@ -802,7 +801,7 @@ CORBA_ORB::create_native_tc (
 }
 
 CORBA::TypeCode_ptr
-CORBA_ORB::create_recursive_tc (
+CORBA::ORB::create_recursive_tc (
     const char *id
     ACE_ENV_ARG_DECL
   )
@@ -824,7 +823,7 @@ CORBA_ORB::create_recursive_tc (
 }
 
 CORBA::TypeCode_ptr
-CORBA_ORB::create_abstract_interface_tc (
+CORBA::ORB::create_abstract_interface_tc (
     const char *id,
     const char *name
     ACE_ENV_ARG_DECL
@@ -848,7 +847,7 @@ CORBA_ORB::create_abstract_interface_tc (
 }
 
 CORBA::TypeCode_ptr
-CORBA_ORB::create_local_interface_tc (
+CORBA::ORB::create_local_interface_tc (
     const char *id,
     const char *name
     ACE_ENV_ARG_DECL
@@ -875,58 +874,56 @@ CORBA_ORB::create_local_interface_tc (
 
 #endif /* TAO_HAS_MINIMUM_CORBA */
 
-CORBA_Object_ptr
-CORBA_ORB::resolve_root_poa (ACE_ENV_SINGLE_ARG_DECL)
+CORBA::Object_ptr
+CORBA::ORB::resolve_root_poa (ACE_ENV_SINGLE_ARG_DECL)
 {
   return this->orb_core_->root_poa (ACE_ENV_SINGLE_ARG_PARAMETER);
 }
 
-CORBA_Object_ptr
-CORBA_ORB::resolve_poa_current (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
+CORBA::Object_ptr
+CORBA::ORB::resolve_poa_current (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
 {
   return this->orb_core_->poa_current ();
 }
 
-CORBA_Object_ptr
-CORBA_ORB::resolve_policy_manager (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
+CORBA::Object_ptr
+CORBA::ORB::resolve_policy_manager (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
 {
-
 #if (TAO_HAS_CORBA_MESSAGING == 1)
 
   TAO_Policy_Manager *policy_manager =
     this->orb_core_->policy_manager ();
   if (policy_manager == 0)
-    return CORBA_Object::_nil ();
+    return CORBA::Object::_nil ();
 
-  return CORBA_Object::_duplicate (policy_manager);
+  return CORBA::Object::_duplicate (policy_manager);
 
 #else
 
-  return CORBA_Object::_nil ();
+  return CORBA::Object::_nil ();
 
 #endif /* TAO_HAS_CORBA_MESSAGING == 1 */
-
 }
 
-CORBA_Object_ptr
-CORBA_ORB::resolve_policy_current (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
+CORBA::Object_ptr
+CORBA::ORB::resolve_policy_current (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
 {
 
 #if (TAO_HAS_CORBA_MESSAGING == 1)
 
   TAO_Policy_Current &policy_current = this->orb_core_->policy_current ();
-  return CORBA_Object::_duplicate (&policy_current);
+  return CORBA::Object::_duplicate (&policy_current);
 
 #else
 
-  return CORBA_Object::_nil ();
+  return CORBA::Object::_nil ();
 
 #endif /* TAO_HAS_CORBA_MESSAGING == 1 */
 }
 
 CORBA::Object_ptr
-CORBA_ORB::resolve_service (TAO_MCAST_SERVICEID mcast_service_id
-                            ACE_ENV_ARG_DECL)
+CORBA::ORB::resolve_service (TAO_MCAST_SERVICEID mcast_service_id
+                             ACE_ENV_ARG_DECL)
 {
   const char *env_service_ior [] =
   {
@@ -952,7 +949,7 @@ CORBA_ORB::resolve_service (TAO_MCAST_SERVICEID mcast_service_id
     TAO_DEFAULT_INTERFACEREPO_SERVER_REQUEST_PORT
   };
 
- CORBA_Object_var return_value = CORBA_Object::_nil ();
+ CORBA::Object_var return_value = CORBA::Object::_nil ();
 
  // By now, the table filled in with -ORBInitRef arguments has been
  // checked.  We only get here if the table didn't contain an initial
@@ -965,7 +962,7 @@ CORBA_ORB::resolve_service (TAO_MCAST_SERVICEID mcast_service_id
    {
      return_value =
        this->string_to_object (service_ior.c_str () ACE_ENV_ARG_PARAMETER);
-     ACE_CHECK_RETURN (CORBA_Object::_nil ());
+     ACE_CHECK_RETURN (CORBA::Object::_nil ());
 
      // Return ior.
      return return_value._retn ();
@@ -1028,19 +1025,19 @@ CORBA_ORB::resolve_service (TAO_MCAST_SERVICEID mcast_service_id
    }
 }
 
-CORBA_Object_ptr
-CORBA_ORB::resolve_initial_references (const char *name
-                                       ACE_ENV_ARG_DECL)
+CORBA::Object_ptr
+CORBA::ORB::resolve_initial_references (const char *name
+                                        ACE_ENV_ARG_DECL)
 {
   return this->resolve_initial_references (name,
                                            0
                                            ACE_ENV_ARG_PARAMETER);
 }
 
-CORBA_Object_ptr
-CORBA_ORB::resolve_initial_references (const char *name,
-                                       ACE_Time_Value *timeout
-                                       ACE_ENV_ARG_DECL)
+CORBA::Object_ptr
+CORBA::ORB::resolve_initial_references (const char *name,
+                                        ACE_Time_Value *timeout
+                                        ACE_ENV_ARG_DECL)
 {
   // This method should not be called if the ORB has been shutdown.
   this->check_shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
@@ -1153,19 +1150,21 @@ CORBA_ORB::resolve_initial_references (const char *name,
 }
 
 void
-CORBA_ORB::register_initial_reference (const char * id,
-                                       CORBA::Object_ptr obj
-                                       ACE_ENV_ARG_DECL)
+CORBA::ORB::register_initial_reference (const char * id,
+                                        CORBA::Object_ptr obj
+                                        ACE_ENV_ARG_DECL)
 {
   TAO_Object_Ref_Table &table = this->orb_core_->object_ref_table ();
 
-  table.register_initial_reference (id, obj ACE_ENV_ARG_PARAMETER);
+  table.register_initial_reference (id,
+                                    obj
+                                    ACE_ENV_ARG_PARAMETER);
   ACE_CHECK;
 }
 
 
-CORBA_ORB_ObjectIdList_ptr
-CORBA_ORB::list_initial_services (ACE_ENV_SINGLE_ARG_DECL)
+CORBA::ORB::ObjectIdList_ptr
+CORBA::ORB::list_initial_services (ACE_ENV_SINGLE_ARG_DECL)
 {
   this->check_shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
@@ -1175,7 +1174,7 @@ CORBA_ORB::list_initial_services (ACE_ENV_SINGLE_ARG_DECL)
 }
 
 void
-CORBA_ORB::check_shutdown (ACE_ENV_SINGLE_ARG_DECL)
+CORBA::ORB::check_shutdown (ACE_ENV_SINGLE_ARG_DECL)
 {
   if (this->orb_core () != 0)
     {
@@ -1199,7 +1198,7 @@ CORBA_ORB::check_shutdown (ACE_ENV_SINGLE_ARG_DECL)
 // ****************************************************************
 
 void
-CORBA_ORB::init_orb_globals (ACE_ENV_SINGLE_ARG_DECL)
+CORBA::ORB::init_orb_globals (ACE_ENV_SINGLE_ARG_DECL)
 {
   // This method should be invoked atomically.  It is the caller's
   // responsibility to ensure that this condition is satisfied.
@@ -1225,7 +1224,7 @@ CORBA_ORB::init_orb_globals (ACE_ENV_SINGLE_ARG_DECL)
   // course requires the TypeCode constants and system exceptions to
   // have been initialized.
   TAO_Singleton_Manager::instance ()->_set_unexpected (
-    CORBA_ORB::_tao_unexpected_exception);
+    CORBA::ORB::_tao_unexpected_exception);
 #endif /* ACE_HAS_EXCEPTIONS */
 
   // Verify some of the basic implementation requirements.  This test
@@ -1264,7 +1263,7 @@ CORBA_ORB::init_orb_globals (ACE_ENV_SINGLE_ARG_DECL)
   ACE_NEW_THROW_EX (tmp_cf_initializer,
                     TAO_CodecFactory_ORBInitializer,
                     CORBA::NO_MEMORY (
-                      CORBA_SystemException::_tao_minor_code (
+                      CORBA::SystemException::_tao_minor_code (
                         TAO_DEFAULT_MINOR_CODE,
                         ENOMEM),
                       CORBA::COMPLETED_NO));
@@ -1291,7 +1290,7 @@ CORBA_ORB::init_orb_globals (ACE_ENV_SINGLE_ARG_DECL)
   ACE_NEW_THROW_EX (temp_pi_initializer,
                     TAO_PICurrent_ORBInitializer,
                     CORBA::NO_MEMORY (
-                      CORBA_SystemException::_tao_minor_code (
+                      CORBA::SystemException::_tao_minor_code (
                         TAO_DEFAULT_MINOR_CODE,
                         ENOMEM),
                       CORBA::COMPLETED_NO));
@@ -1305,7 +1304,7 @@ CORBA_ORB::init_orb_globals (ACE_ENV_SINGLE_ARG_DECL)
 #endif  /* TAO_HAS_INTERCEPTORS == 1 */
 }
 
-void CORBA_ORB::_tao_unexpected_exception (void)
+void CORBA::ORB::_tao_unexpected_exception (void)
 {
 #if defined(ACE_HAS_EXCEPTIONS)
   throw CORBA::UNKNOWN ();
@@ -1316,13 +1315,13 @@ void CORBA_ORB::_tao_unexpected_exception (void)
 }
 
 const ACE_CString &
-CORBA_ORB::_tao_ft_client_id (void)
+CORBA::ORB::_tao_ft_client_id (void)
 {
   return this->orb_core ()->fault_tolerance_service ().client_id ();
 }
 
 void
-CORBA_ORB::_tao_ft_client_id (const char *id)
+CORBA::ORB::_tao_ft_client_id (const char *id)
 {
   this->orb_core ()->fault_tolerance_service ().client_id (id);
 }
@@ -1353,7 +1352,7 @@ CORBA::ORB_ptr
 CORBA::ORB_init (int &argc,
                  char *argv[],
                  const char *orbid,
-                 CORBA_Environment &ACE_TRY_ENV)
+                 CORBA::Environment &ACE_TRY_ENV)
 {
   // This ugly macro will go away once we've merged the two ORB_init's.
   ACE_UNUSED_ARG(ACE_TRY_ENV); // FUZZ: ignore check_for_ace_check
@@ -1374,7 +1373,7 @@ CORBA::ORB_init (int &argc,
   if (TAO_Singleton_Manager::instance ()->init () == -1)
     return CORBA::ORB::_nil ();
 
-  CORBA_ORB::init_orb_globals (ACE_ENV_SINGLE_ARG_PARAMETER);
+  CORBA::ORB::init_orb_globals (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (CORBA::ORB::_nil ());
 
   // Make sure the following is done after the global ORB
@@ -1388,7 +1387,7 @@ CORBA::ORB_init (int &argc,
       (command_line.get_argc() != 0 && (command_line.get_TCHAR_argv() == 0 || command_line.get_TCHAR_argv()[0] == 0)))
     {
       ACE_THROW_RETURN (CORBA::BAD_PARAM (
-                          CORBA_SystemException::_tao_minor_code (
+                          CORBA::SystemException::_tao_minor_code (
                             TAO_DEFAULT_MINOR_CODE,
                             EINVAL),
                           CORBA::COMPLETED_NO),
@@ -1461,7 +1460,7 @@ CORBA::ORB_init (int &argc,
   ACE_NEW_THROW_EX (oc,
                     TAO_ORB_Core (orbid_string.c_str ()),
                     CORBA::NO_MEMORY (
-                      CORBA_SystemException::_tao_minor_code (
+                      CORBA::SystemException::_tao_minor_code (
                         TAO_DEFAULT_MINOR_CODE,
                         ENOMEM),
                       CORBA::COMPLETED_NO));
@@ -1486,7 +1485,7 @@ CORBA::ORB_init (int &argc,
                   ACE_TEXT ("Unable to initialize the ")
                   ACE_TEXT ("Service Configurator")));
       ACE_THROW_RETURN (CORBA::INITIALIZE (
-                          CORBA_SystemException::_tao_minor_code (
+                          CORBA::SystemException::_tao_minor_code (
                             TAO_ORB_CORE_INIT_LOCATION_CODE,
                             0),
                           CORBA::COMPLETED_NO),
@@ -1500,7 +1499,7 @@ CORBA::ORB_init (int &argc,
                                      command_line.get_argc(),
                                      command_line.get_ASCII_argv()),
                     CORBA::NO_MEMORY (
-                      CORBA_SystemException::_tao_minor_code (
+                      CORBA::SystemException::_tao_minor_code (
                         TAO_DEFAULT_MINOR_CODE,
                         ENOMEM),
                       CORBA::COMPLETED_NO));
@@ -1563,8 +1562,8 @@ CORBA::ORB_init (int &argc,
 
 // Object reference stringification.
 char *
-CORBA_ORB::object_to_string (CORBA::Object_ptr obj
-                             ACE_ENV_ARG_DECL)
+CORBA::ORB::object_to_string (CORBA::Object_ptr obj
+                              ACE_ENV_ARG_DECL)
 {
   // This method should not be called if the ORB has been shutdown.
   this->check_shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
@@ -1667,7 +1666,7 @@ CORBA_ORB::object_to_string (CORBA::Object_ptr obj
                         ACE_TEXT ("object reference to URL IOR.\n")));
 
           ACE_THROW_RETURN (CORBA::MARSHAL (
-                              CORBA_SystemException::_tao_minor_code (
+                              CORBA::SystemException::_tao_minor_code (
                                 TAO_DEFAULT_MINOR_CODE,
                                 EINVAL),
                               CORBA::COMPLETED_NO),
@@ -1685,7 +1684,7 @@ CORBA_ORB::object_to_string (CORBA::Object_ptr obj
 
 
           ACE_THROW_RETURN (CORBA::MARSHAL (
-                              CORBA_SystemException::_tao_minor_code (
+                              CORBA::SystemException::_tao_minor_code (
                                 TAO_DEFAULT_MINOR_CODE,
                                 EINVAL),
                               CORBA::COMPLETED_NO),
@@ -1703,8 +1702,8 @@ CORBA_ORB::object_to_string (CORBA::Object_ptr obj
 // <resolve_name_service> with an IOR <multicast_to_service>.
 
 CORBA::Object_ptr
-CORBA_ORB::string_to_object (const char *str
-                             ACE_ENV_ARG_DECL)
+CORBA::ORB::string_to_object (const char *str
+                              ACE_ENV_ARG_DECL)
 {
   // This method should not be called if the ORB has been shutdown.
   this->check_shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
@@ -1713,7 +1712,7 @@ CORBA_ORB::string_to_object (const char *str
   // Check for NULL pointer
   if (str == 0)
     ACE_THROW_RETURN (CORBA::INV_OBJREF (
-                        CORBA_SystemException::_tao_minor_code (
+                        CORBA::SystemException::_tao_minor_code (
                           TAO_DEFAULT_MINOR_CODE,
                           EINVAL),
                         CORBA::COMPLETED_NO),
@@ -1736,13 +1735,14 @@ CORBA_ORB::string_to_object (const char *str
     return this->ior_string_to_object (str + sizeof ior_prefix - 1
                                        ACE_ENV_ARG_PARAMETER);
   else
-    return this->url_ior_string_to_object (str ACE_ENV_ARG_PARAMETER);
+    return this->url_ior_string_to_object (str
+                                           ACE_ENV_ARG_PARAMETER);
 }
 
 // ****************************************************************
 
 char *
-CORBA_ORB::id (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
+CORBA::ORB::id (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
 {
   return CORBA::string_dup (this->orb_core_->orbid ());
 }
@@ -1750,9 +1750,9 @@ CORBA_ORB::id (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
 // ****************************************************************
 
 CORBA::Policy_ptr
-CORBA_ORB::create_policy (CORBA::PolicyType type,
-                          const CORBA::Any& val
-                          ACE_ENV_ARG_DECL)
+CORBA::ORB::create_policy (CORBA::PolicyType type,
+                           const CORBA::Any& val
+                           ACE_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException,
                    CORBA::PolicyError))
 {
@@ -1768,8 +1768,8 @@ CORBA_ORB::create_policy (CORBA::PolicyType type,
 }
 
 CORBA::Policy_ptr
-CORBA_ORB::_create_policy (CORBA::PolicyType type
-                           ACE_ENV_ARG_DECL)
+CORBA::ORB::_create_policy (CORBA::PolicyType type
+                            ACE_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException,
                    CORBA::PolicyError))
 {
@@ -1789,8 +1789,8 @@ CORBA_ORB::_create_policy (CORBA::PolicyType type
 // implementations ...
 
 CORBA::Object_ptr
-CORBA_ORB::ior_string_to_object (const char *str
-                                 ACE_ENV_ARG_DECL)
+CORBA::ORB::ior_string_to_object (const char *str
+                                  ACE_ENV_ARG_DECL)
 {
   // Unhex the bytes, and make a CDR deencapsulation stream from the
   // resulting data.
@@ -1848,8 +1848,8 @@ CORBA_ORB::ior_string_to_object (const char *str
 // Convert an URL style IOR in an object
 
 CORBA::Object_ptr
-CORBA_ORB::url_ior_string_to_object (const char* str
-                                     ACE_ENV_ARG_DECL)
+CORBA::ORB::url_ior_string_to_object (const char* str
+                                      ACE_ENV_ARG_DECL)
 {
   TAO_MProfile mprofile;
   // It is safe to declare this on the stack since the contents of
@@ -1871,7 +1871,7 @@ CORBA_ORB::url_ior_string_to_object (const char* str
   if (retv != 0)
     {
       ACE_THROW_RETURN (CORBA::INV_OBJREF (
-                          CORBA_SystemException::_tao_minor_code (
+                          CORBA::SystemException::_tao_minor_code (
                             TAO_DEFAULT_MINOR_CODE,
                             EINVAL),
                           CORBA::COMPLETED_NO),
@@ -1901,14 +1901,14 @@ CORBA_ORB::url_ior_string_to_object (const char* str
 // ****************************************************************
 
 void
-CORBA_ORB::_optimize_collocation_objects (CORBA::Boolean opt)
+CORBA::ORB::_optimize_collocation_objects (CORBA::Boolean opt)
 {
   if (this->orb_core_ != 0)
     this->orb_core_->optimize_collocation_objects (opt);
 }
 
 CORBA::Boolean
-CORBA_ORB::_optimize_collocation_objects (void) const
+CORBA::ORB::_optimize_collocation_objects (void) const
 {
   if (this->orb_core_ != 0)
     return this->orb_core_->optimize_collocation_objects ();
@@ -1977,7 +1977,7 @@ CORBA::Boolean operator<< (TAO_OutputCDR &strm,
 }
 
 CORBA::Boolean operator>> (TAO_InputCDR &strm,
-                                      CORBA::TCKind &_tao_enumval)
+                           CORBA::TCKind &_tao_enumval)
 {
   CORBA::ULong _tao_temp = 0;
   CORBA::Boolean _tao_result = strm >> _tao_temp;
@@ -1991,13 +1991,13 @@ CORBA::Boolean operator>> (TAO_InputCDR &strm,
 }
 
 ACE_Time_Value *
-CORBA_ORB::get_timeout (void)
+CORBA::ORB::get_timeout (void)
 {
   return this->timeout_;
 }
 
 void
-CORBA_ORB::set_timeout (ACE_Time_Value *timeout)
+CORBA::ORB::set_timeout (ACE_Time_Value *timeout)
 {
   this->timeout_ = timeout;
 }
@@ -2007,9 +2007,9 @@ CORBA_ORB::set_timeout (ACE_Time_Value *timeout)
 // *************************************************************
 
 CORBA::ValueFactory
-CORBA_ORB::register_value_factory (const char *repository_id,
-                                   CORBA::ValueFactory factory
-                                   ACE_ENV_ARG_DECL)
+CORBA::ORB::register_value_factory (const char *repository_id,
+                                    CORBA::ValueFactory factory
+                                    ACE_ENV_ARG_DECL)
 {
 // %! guard, and ACE_Null_Mutex in the map
 // do _add_ref here not in map->rebind
@@ -2037,16 +2037,16 @@ CORBA_ORB::register_value_factory (const char *repository_id,
 }
 
 void
-CORBA_ORB::unregister_value_factory (const char * /* repository_id */
-                                     ACE_ENV_ARG_DECL_NOT_USED)
+CORBA::ORB::unregister_value_factory (const char * /* repository_id */
+                                      ACE_ENV_ARG_DECL_NOT_USED)
 {
   ACE_ERROR((LM_ERROR, ACE_TEXT ("(%N:%l) function not implemented\n")));
   // %! TODO
 }
 
 CORBA::ValueFactory
-CORBA_ORB::lookup_value_factory (const char *repository_id
-                                 ACE_ENV_ARG_DECL_NOT_USED)
+CORBA::ORB::lookup_value_factory (const char *repository_id
+                                  ACE_ENV_ARG_DECL_NOT_USED)
 {
 // %! guard
 // do _add_ref here not in map->find
diff --git a/TAO/tao/ORB.h b/TAO/tao/ORB.h
index b747035cf3b..c324c45e4f8 100644
--- a/TAO/tao/ORB.h
+++ b/TAO/tao/ORB.h
@@ -53,566 +53,598 @@ class TAO_Stub;
 class TAO_Acceptor_Filter;
 class TAO_ValueFactory_Map;
 
-// ****************************************************************
-
-/**
- * @class CORBA_ORB
- *
- * @brief ORB pseudo-objref.
- *
- * The "ORB" pseudo-object is used in bootstrapping, such as to
- * create object references from strings.  This class is intended
- * to be inherited by others, which will provide some more of the
- * CORBA support.  Implementations of this "CORBA::ORB" class must
- * know how to create stringify/destringify their objrefs, as well
- * as how to marshal and unmarshal them.
- */
-class TAO_Export CORBA_ORB
-{
-public:
-
-  // ORB_Core has special privileges
-  friend class TAO_ORB_Core;
-  friend TAO_Export TAO_ORB_Core *TAO_ORB_Core_instance (void);
-
-  class TAO_Export InvalidName : public CORBA::UserException
-  {
-  public:
-    InvalidName (void);
-    InvalidName (const InvalidName &);
-    ~InvalidName (void);
-
-    InvalidName &operator= (const InvalidName &);
-
-    static InvalidName *_downcast (CORBA::Exception *);
-    static CORBA::Exception *_alloc (void);
-
-    virtual CORBA::Exception *_tao_duplicate (void) const;
-
-    virtual void _raise (void);
-
-    virtual void _tao_encode (
-        TAO_OutputCDR &
-        ACE_ENV_ARG_DECL_NOT_USED
-      ) const;
-
-    virtual void _tao_decode (
-        TAO_InputCDR &
-        ACE_ENV_ARG_DECL_NOT_USED
-      );
-    };
-
-  typedef char *ObjectId;
-  typedef CORBA::String_var ObjectId_var;
-  typedef CORBA::String_out ObjectId_out;
-  static CORBA::TypeCode_ptr _tc_ObjectId;
-
-  typedef CORBA_ORB_ObjectIdList ObjectIdList;
-  typedef CORBA_ORB_ObjectIdList_var ObjectIdList_var;
-  typedef CORBA_ORB_ObjectIdList_out ObjectIdList_out;
-  typedef CORBA_ORB_ObjectIdList *ObjectIdList_ptr;
-  static CORBA::TypeCode_ptr _tc_ObjectIdList;
+class CORBA_ORB_ObjectIdList;
+class CORBA_ORB_ObjectIdList_var;
+class CORBA_ORB_ObjectIdList_out;
 
-  /// Return a duplicate of <{orb}>.  When work with this duplicate is
-  /// complete, it should be freed up using <CORBA::release()>.
-  static CORBA::ORB_ptr _duplicate (CORBA::ORB_ptr orb);
+class CORBA_ORB_ObjectIdList;
+class CORBA_ORB_ObjectIdList_var;
+class CORBA_ORB_ObjectIdList_out;
 
-  /// Returns a pointer to a nil ORB, i.e., an non-existent ORB.  This
-  /// can be used for initialization or in comparisons.
-  static CORBA::ORB_ptr _nil (void);
+class CORBA_ORB_RequestSeq;
+class CORBA_ORB_RequestSeq_var;
+class CORBA_ORB_RequestSeq_out;
 
-  /// Return this ORB's ORBid.
-  char * id (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
 
-  /**
-   * Turn a string-ified object reference back into an object pointer.
-   * Typically these strings are created using <object_to_string()>,
-   * but not necessarily locally.
-   */
-  CORBA::Object_ptr string_to_object (const char *str
-                                      ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+// ****************************************************************
 
+namespace CORBA
+{
   /**
-   * Turn an object reference into a string.  Each type of ORB,
-   * e.g. an IIOP ORB, must implement this.  This can be used by
-   * servers to publish their whereabouts to clients.  The output of
-   * this is typically eventually given to <string_to_object()> as an
-   * argument.
+   * @class ORB
+   *
+   * @brief ORB pseudo-objref.
+   *
+   * The "ORB" pseudo-object is used in bootstrapping, such as to
+   * create object references from strings.  This class is intended
+   * to be inherited by others, which will provide some more of the
+   * CORBA support.  Implementations of this "CORBA::ORB" class must
+   * know how to create stringify/destringify their objrefs, as well
+   * as how to marshal and unmarshal them.
    */
-  char * object_to_string (CORBA::Object_ptr obj
-                           ACE_ENV_ARG_DECL_WITH_DEFAULTS);
-
-
-  // Value factory operations  (CORBA 2.3 ptc/98-10-05 Ch. 4.2 p.4-7)
-  CORBA::ValueFactory register_value_factory (
-         const char *repository_id,
-         CORBA::ValueFactory factory
-         ACE_ENV_ARG_DECL_WITH_DEFAULTS );
-  void unregister_value_factory (const char * repository_id
-                                 ACE_ENV_ARG_DECL_WITH_DEFAULTS );
-  CORBA::ValueFactory lookup_value_factory (
-         const char *repository_id
-         ACE_ENV_ARG_DECL_WITH_DEFAULTS );
-
-#if (TAO_HAS_MINIMUM_CORBA == 0)
+  class TAO_Export ORB
+  {
+  public:
 
-  // Typedefs for CORBA_ORB_RequestSeq,
-  // which is an argument of send_multiple_requests_*().
-  // See Request.{h,i,cpp} for definitions.
-  typedef CORBA_ORB_RequestSeq RequestSeq;
-  typedef CORBA_ORB_RequestSeq_var RequestSeq_var;
-  typedef CORBA_ORB_RequestSeq_out RequestSeq_out;
+    // ORB_Core has special privileges
+    friend class TAO_ORB_Core;
+    //friend TAO_Export TAO_ORB_Core *TAO_ORB_Core_instance (void);
 
-  void create_list (CORBA::Long count,
-                    CORBA::NVList_ptr &new_list
-                    ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    class TAO_Export InvalidName : public CORBA::UserException
+    {
+    public:
+      InvalidName (void);
+      InvalidName (const InvalidName &);
+      ~InvalidName (void);
 
-  void create_named_value (CORBA::NamedValue_ptr &nmval
-                           ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+      InvalidName &operator= (const InvalidName &);
 
-  void create_exception_list (CORBA::ExceptionList_ptr &exclist
-                              ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+      static InvalidName *_downcast (CORBA::Exception *);
+      static CORBA::Exception *_alloc (void);
 
-  void create_environment (CORBA::Environment_ptr &new_env
-                           ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+      virtual CORBA::Exception *_tao_duplicate (void) const;
 
-  // The following are not implemented and just throw
-  // CORBA::NO_IMPLEMENT.
+      virtual void _raise (void);
 
-  void create_context_list (CORBA::ContextList_ptr &ctxtlist
-                            ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+      virtual void _tao_encode (TAO_OutputCDR &
+                                ACE_ENV_ARG_DECL_NOT_USED) const;
 
-  void get_default_context (CORBA::Context_ptr &ctx
-                            ACE_ENV_ARG_DECL_WITH_DEFAULTS);
-
-  CORBA::Boolean get_service_information (CORBA::ServiceType service_type,
-                                          CORBA::ServiceInformation_out service_information
-                                          ACE_ENV_ARG_DECL_WITH_DEFAULTS);
-
-  void send_multiple_requests_oneway (const CORBA_ORB_RequestSeq &req
-                                      ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+      virtual void _tao_decode (TAO_InputCDR &
+                                ACE_ENV_ARG_DECL_NOT_USED);
+    };
 
-  void send_multiple_requests_deferred (const CORBA_ORB_RequestSeq &req
+    typedef char *ObjectId;
+    typedef CORBA::String_var ObjectId_var;
+    typedef CORBA::String_out ObjectId_out;
+    static CORBA::TypeCode_ptr _tc_ObjectId;
+
+    typedef CORBA_ORB_ObjectIdList ObjectIdList;
+    typedef CORBA_ORB_ObjectIdList_var ObjectIdList_var;
+    typedef CORBA_ORB_ObjectIdList_out ObjectIdList_out;
+    typedef CORBA_ORB_ObjectIdList *ObjectIdList_ptr;
+    static CORBA::TypeCode_ptr _tc_ObjectIdList;
+
+    /// Return a duplicate of @c orb.
+    /**
+     * When work with this duplicate is complete, it should be freed
+     * up using CORBA::release().
+     */
+    static CORBA::ORB_ptr _duplicate (CORBA::ORB_ptr orb);
+
+    /// Returns a pointer to a nil ORB, i.e., an non-existent ORB.  This
+    /// can be used for initialization or in comparisons.
+    static CORBA::ORB_ptr _nil (void);
+
+    /// Return this ORB's ORBid.
+    char * id (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
+
+    /**
+     * Turn a string-ified object reference back into an object
+     * pointer.  Typically these strings are created using
+     * object_to_string(), but not necessarily locally.
+     */
+    CORBA::Object_ptr string_to_object (const char *str
                                         ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-  void get_next_response (CORBA_Request_ptr &req
-                          ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    /**
+     * Turn an object reference into a string.  Each type of ORB,
+     * e.g. an IIOP ORB, must implement this.  This can be used by
+     * servers to publish their whereabouts to clients.  The output of
+     * this is typically eventually given to <string_to_object()> as
+     * an argument.
+     */
+    char * object_to_string (CORBA::Object_ptr obj
+                             ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+
+    // Value factory operations  (CORBA 2.3 ptc/98-10-05 Ch. 4.2 p.4-7)
+    CORBA::ValueFactory register_value_factory (
+        const char *repository_id,
+        CORBA::ValueFactory factory
+        ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    void unregister_value_factory (const char * repository_id
+                                   ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    CORBA::ValueFactory lookup_value_factory (
+        const char *repository_id
+        ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-  CORBA::Boolean poll_next_response (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
+#if (TAO_HAS_MINIMUM_CORBA == 0)
 
-  /// The ORB TypeCode creation functions.
+    // Typedefs for CORBA::ORB::RequestSeq, which is an argument of
+    // send_multiple_requests_*().  See Request.{h,i,cpp} for
+    // definitions.
+    typedef CORBA_ORB_RequestSeq RequestSeq;
+    typedef CORBA_ORB_RequestSeq_var RequestSeq_var;
+    typedef CORBA_ORB_RequestSeq_out RequestSeq_out;
 
-  CORBA::TypeCode_ptr create_struct_tc (
-      const char *id,
-      const char *name,
-      const CORBA::StructMemberSeq &members
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+    void create_list (CORBA::Long count,
+                      CORBA::NVList_ptr &new_list
+                      ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-    ACE_THROW_SPEC ((CORBA::SystemException));
+    void create_named_value (CORBA::NamedValue_ptr &nmval
+                             ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-  CORBA::TypeCode_ptr create_union_tc (
-      const char *id,
-      const char *name,
-      CORBA::TypeCode_ptr discriminator_type,
-      const CORBA::UnionMemberSeq &members
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+    void create_exception_list (CORBA::ExceptionList_ptr &exclist
+                                ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-    ACE_THROW_SPEC ((CORBA::SystemException));
+    void create_environment (CORBA::Environment_ptr &new_env
+                             ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-  CORBA::TypeCode_ptr create_enum_tc (
-      const char *id,
-      const char *name,
-      const CORBA::EnumMemberSeq &members
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+    // The following are not implemented and just throw
+    // CORBA::NO_IMPLEMENT.
 
-    ACE_THROW_SPEC ((CORBA::SystemException));
+    void create_context_list (CORBA::ContextList_ptr &ctxtlist
+                              ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-  CORBA::TypeCode_ptr create_alias_tc (
-      const char *id,
-      const char *name,
-      CORBA::TypeCode_ptr original_type
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+    void get_default_context (CORBA::Context_ptr &ctx
+                              ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-    ACE_THROW_SPEC ((CORBA::SystemException));
+    CORBA::Boolean get_service_information (
+      CORBA::ServiceType service_type,
+      CORBA::ServiceInformation_out service_information
+      ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-  CORBA::TypeCode_ptr create_exception_tc (
-      const char *id,
-      const char *name,
-      const CORBA::StructMemberSeq &members
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+    void send_multiple_requests_oneway (const CORBA_ORB_RequestSeq &req
+                                        ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-    ACE_THROW_SPEC ((CORBA::SystemException));
+    void send_multiple_requests_deferred (const CORBA_ORB_RequestSeq &req
+                                          ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-  CORBA::TypeCode_ptr create_interface_tc (
-      const char *id,
-      const char *name
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+    void get_next_response (CORBA::Request_ptr &req
+                            ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
+    CORBA::Boolean poll_next_response (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
+
+    /// The ORB TypeCode creation functions.
+
+    CORBA::TypeCode_ptr create_struct_tc (
+        const char *id,
+        const char *name,
+        const CORBA::StructMemberSeq &members
+        ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CORBA::TypeCode_ptr create_union_tc (
+        const char *id,
+        const char *name,
+        CORBA::TypeCode_ptr discriminator_type,
+        const CORBA::UnionMemberSeq &members
+        ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CORBA::TypeCode_ptr create_enum_tc (
+        const char *id,
+        const char *name,
+        const CORBA::EnumMemberSeq &members
+        ACE_ENV_ARG_DECL_WITH_DEFAULTS)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  CORBA::TypeCode_ptr create_string_tc (
-      CORBA::ULong bound
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS)
-
+    CORBA::TypeCode_ptr create_alias_tc (
+        const char *id,
+        const char *name,
+        CORBA::TypeCode_ptr original_type
+        ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CORBA::TypeCode_ptr create_exception_tc (
+        const char *id,
+        const char *name,
+        const CORBA::StructMemberSeq &members
+        ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CORBA::TypeCode_ptr create_interface_tc (
+        const char *id,
+        const char *name
+        ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CORBA::TypeCode_ptr create_string_tc (
+        CORBA::ULong bound
+        ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CORBA::TypeCode_ptr create_wstring_tc (
+        CORBA::ULong bound
+        ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CORBA::TypeCode_ptr create_fixed_tc (
+        CORBA::UShort digits,
+        CORBA::UShort scale
+        ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CORBA::TypeCode_ptr create_sequence_tc (
+        CORBA::ULong bound,
+        CORBA::TypeCode_ptr element_type
+        ACE_ENV_ARG_DECL_WITH_DEFAULTS)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  CORBA::TypeCode_ptr create_wstring_tc (
-      CORBA::ULong bound
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+    CORBA::TypeCode_ptr create_array_tc (
+        CORBA::ULong length,
+        CORBA::TypeCode_ptr element_type
+        ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CORBA::TypeCode_ptr create_value_tc (
+        const char *id,
+        const char *name,
+        CORBA::ValueModifier type_modifier,
+        CORBA::TypeCode_ptr concrete_base,
+        const CORBA::ValueMemberSeq &members
+        ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CORBA::TypeCode_ptr create_value_box_tc (
+        const char *id,
+        const char *name,
+        CORBA::TypeCode_ptr boxed_type
+        ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CORBA::TypeCode_ptr create_native_tc (
+        const char *id,
+        const char *name
+        ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CORBA::TypeCode_ptr create_recursive_tc (
+        const char *id
+        ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CORBA::TypeCode_ptr create_abstract_interface_tc (
+        const char *id,
+        const char *name
+        ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CORBA::TypeCode_ptr create_local_interface_tc (
+        const char *id,
+        const char *ame
+        ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+      ACE_THROW_SPEC ((CORBA::SystemException));
 
-    ACE_THROW_SPEC ((CORBA::SystemException));
+#endif /* TAO_HAS_MINIMUM_CORBA */
 
-  CORBA::TypeCode_ptr create_fixed_tc (
-      CORBA::UShort digits,
-      CORBA::UShort scale
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+    // = ORB event loop methods.
+
+    /**
+     * Instructs the ORB to initialize itself and run its event loop in
+     * the current thread, not returning until the ORB has shut down.
+     * If an error occurs during initialization or at run-time, a CORBA
+     * system exception will be thrown.
+     */
+    void run (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
+
+    /**
+     * Instructs the ORB to initialize itself and run its event loop in
+     * the current thread, not returning until the ORB has shut down or
+     * the time value specified through <tv> has expired.  If an error
+     * occurs during initialization or at run-time, a CORBA system
+     * exception will be thrown.  <tv> is reduced by the amount of time
+     * spent in this call.
+     **/
+    void run (ACE_Time_Value &tv
+              ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+
+    /**
+     * Instructs the ORB to initialize itself and run its event loop in
+     * the current thread, not returning until the ORB has shut down or
+     * the time value specified through <tv> has expired.  If an error
+     * occurs during initialization or at run-time, a CORBA system
+     * exception will be thrown.  <tv> is reduced by the amount of time
+     * spent in this call.  If <tv> is 0, it means that the timeout is
+     * infinite.  If <tv> is ACE_Time_Value::zero, it specifies to poll
+     * and does not block.
+     **/
+    void run (ACE_Time_Value *tv
+              ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+
+    /// Returns an indication of whether the ORB needs to perform some
+    /// work.
+    CORBA::Boolean work_pending (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
+
+    /// Returns an indication of whether the ORB needs to perform some
+    /// work but will look for work pending for no more than the
+    /// specified time.
+    /**
+     * @note This is useful for implementing an event loop with an
+     *       idle timeout.
+     */
+    CORBA::Boolean work_pending (ACE_Time_Value &tv
+                                 ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+
+    /**
+     * This operation performs an implementation-defined unit of work.
+     * Note that the default behavior is to block if the unit of work
+     * is not present; this behavior can be modified by passing an
+     * appropriate @c ACE_Time_Value as described in run(). 
+     **/
+    void perform_work (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
+    void perform_work (ACE_Time_Value &
+                       ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    void perform_work (ACE_Time_Value *
+                       ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+
+    /**
+     * This operation instructs the ORB to shut down. Shutting down the
+     * ORB causes all Object Adapters to be shut down. If
+     * @c wait_for_completion parameter is TRUE, this operation blocks
+     * until all ORB processing (including request processing and object
+     * deactivation or other operations associated with object adapters)
+     * has completed.
+     */
+    void shutdown (CORBA::Boolean wait_for_completion = 0
+                   ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+
+    /**
+     * Explicitly destroy the ORB, releasing any resources.  Note that
+     * TAO *cannot* implicitly release the resources even if you have
+     * destroyed all the references to a particular ORB since
+     * CORBA::ORB_init() is required to return the same pointer if
+     * called with the same ORBid, only after ORB::destroy() is called
+     * it may return a new one.
+     *
+     * The results of multi-threaded applications, trying to destroy ()
+     * the ORB in one thread and trying to service a request in another
+     * thread are not well defined. TAO does not support such cases.
+     */
+    void destroy (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
+
+    CORBA::Object_ptr resolve_initial_references (
+      const char *name
+      ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-    ACE_THROW_SPEC ((CORBA::SystemException));
+    /**
+     * This method acts as a mini-bootstrapping Naming Service, which is
+     * provided by the ORB for certain well-known object references.  TAO
+     * supports the "NameService", "TradingService", "RootPOA",
+     * "ImplRepo", and "POACurrent" via this method.  The @c timeout
+     * value bounds the amount of time the ORB blocks waiting to
+     * resolve the service.  This is most useful for bootstrapping
+     * remote services, such as the "NameService" or "TradingService",
+     * that are commonly resolved via multicast.  By default, the
+     * value is 0, which means "use the @c
+     * TAO_DEFAULT_SERVICE_RESOLUTION_TIMEOUT timeout period".
+     *
+     * @note By using a default value for the @c timeout parameter,
+     *       TAO will remains compliant with the CORBA
+     *       resolve_initial_references() specification.
+     */
+    CORBA::Object_ptr resolve_initial_references (
+      const char *name,
+      ACE_Time_Value *timeout
+      ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-  CORBA::TypeCode_ptr create_sequence_tc (
-      CORBA::ULong bound,
-      CORBA::TypeCode_ptr element_type
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+    /// Register an object reference with the ORB.
+    void register_initial_reference (const char * id,
+                                     CORBA::Object_ptr obj
+                                     ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+
+    /// Returns a sequence of ObjectIds that lists which objects have
+    /// references available via the initial references mechanism.
+    CORBA::ORB::ObjectIdList_ptr list_initial_services (
+      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
+
+    CORBA::Policy_ptr create_policy (CORBA::PolicyType type,
+                                     const CORBA::Any& val
+                                     ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+      ACE_THROW_SPEC ((CORBA::SystemException,
+                       CORBA::PolicyError));
+
+    // ----------------------------------------------------------------
+    // = TAO-specific extensions to the CORBA specification.
+    // ----------------------------------------------------------------
+
+    /// Create an empty policy, usually to be filled in later by
+    /// demarshaling.
+    CORBA::Policy_ptr _create_policy (CORBA::PolicyType type
+                                      ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException,
+                       CORBA::PolicyError));
+
+    /// Resolve the POA.
+    CORBA::Object_ptr resolve_root_poa (ACE_ENV_SINGLE_ARG_DECL);
+
+    /// Initialize the ORB globals correctly, i.e., only when they
+    /// haven't been initialized yet.
+    static void init_orb_globals (ACE_ENV_SINGLE_ARG_DECL);
+
+    // The function used by tao to handle the "unexpected" exceptions,
+    // It raises CORBA::UNKNOWN.
+    static void _tao_unexpected_exception (void);
+
+    // Reference counting...
+    CORBA::ULong _incr_refcnt (void);
+    CORBA::ULong _decr_refcnt (void);
+
+    /// Set the IOR flag.
+    /// Get the IOR flag.
+    void _use_omg_ior_format (CORBA::Boolean ior);
+    CORBA::Boolean _use_omg_ior_format (void);
+
+    /// Set collocation optimization status.
+    /// Get collocation optimization status.
+    void _optimize_collocation_objects (CORBA::Boolean opt);
+    CORBA::Boolean _optimize_collocation_objects (void) const;
+
+    /// Get the ORB core.
+    TAO_ORB_Core *orb_core (void) const;
+
+    /**
+     * TAO specific extension to get and set the client ID. The client
+     * id can be set by the application which would be used by the FT
+     * service. As there are no specific interfaces defined in the
+     * spec, we have this proprietary extension.
+     */
+    const ACE_CString &_tao_ft_client_id (void);
+    void _tao_ft_client_id (const char *id);
 
-    ACE_THROW_SPEC ((CORBA::SystemException));
+#if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
+    // Useful for template programming.
+    typedef ORB_ptr _ptr_type;
+    typedef ORB_var _var_type;
+#endif /* __GNUC__ */
 
-  CORBA::TypeCode_ptr create_array_tc (
-      CORBA::ULong length,
-      CORBA::TypeCode_ptr element_type
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+    /// Get the Timeout value
+    ACE_Time_Value *get_timeout (void);
 
-    ACE_THROW_SPEC ((CORBA::SystemException));
+  protected:
+    // We must be created via the @c ORB_init() call.
+    ORB (TAO_ORB_Core *orb_core);
 
-  CORBA::TypeCode_ptr create_value_tc (
-      const char *id,
-      const char *name,
-      CORBA::ValueModifier type_modifier,
-      CORBA::TypeCode_ptr concrete_base,
-      const CORBA::ValueMemberSeq &members
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+    /// Destructor
+    /**
+     * Protected destructor to enforce proper memory management
+     * through the reference counting mechanism.
+     */
+    ~ORB (void);
 
-    ACE_THROW_SPEC ((CORBA::SystemException));
+    /// Resolve the POA current.
+    CORBA::Object_ptr resolve_poa_current (ACE_ENV_SINGLE_ARG_DECL);
 
-  CORBA::TypeCode_ptr create_value_box_tc (
-      const char *id,
-      const char *name,
-      CORBA::TypeCode_ptr boxed_type
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+    /// Resolve the Policy Manager for this ORB.
+    CORBA::Object_ptr resolve_policy_manager (
+      ACE_ENV_SINGLE_ARG_DECL_NOT_USED);
 
-    ACE_THROW_SPEC ((CORBA::SystemException));
+    /// Resolve the Policy Current for this thread.
+    CORBA::Object_ptr resolve_policy_current (
+      ACE_ENV_SINGLE_ARG_DECL_NOT_USED);
 
-  CORBA::TypeCode_ptr create_native_tc (
-      const char *id,
-      const char *name
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+  private:
 
-    ACE_THROW_SPEC ((CORBA::SystemException));
+    /// Resolve the given service based on the service ID.
+    CORBA::Object_ptr resolve_service (TAO_MCAST_SERVICEID service_id
+                                       ACE_ENV_ARG_DECL);
 
-  CORBA::TypeCode_ptr create_recursive_tc (
-      const char *id
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+    /// Convert an OMG IOR into an object reference.
+    CORBA::Object_ptr ior_string_to_object (const char* ior
+                                            ACE_ENV_ARG_DECL);
 
-    ACE_THROW_SPEC ((CORBA::SystemException));
+    /// Convert an URL style IOR into an object reference.
+    CORBA::Object_ptr url_ior_string_to_object (const char* ior
+                                                ACE_ENV_ARG_DECL);
 
-  CORBA::TypeCode_ptr create_abstract_interface_tc (
-      const char *id,
-      const char *name
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+    /// Check if ORB has shutdown.  If it has, throw the appropriate
+    /// exception.
+    void check_shutdown (ACE_ENV_SINGLE_ARG_DECL);
 
-    ACE_THROW_SPEC ((CORBA::SystemException));
+    /// Set the timeout value
+    void set_timeout (ACE_Time_Value *timeout);
 
+  private:
 
-  CORBA::TypeCode_ptr create_local_interface_tc (
-      const char *id,
-      const char *ame
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+    /// lock required for mutual exclusion between multiple threads.
+    TAO_SYNCH_MUTEX lock_;
 
-    ACE_THROW_SPEC ((CORBA::SystemException));
+    /// Maintains a reference count of number of instantiations of the
+    /// ORB.
+    CORBA::ULong refcount_;
 
-#endif /* TAO_HAS_MINIMUM_CORBA */
+    /// Count of the number of times that @c ORB_init() has been
+    /// called.
+    /**
+     * This must be protected by @c ACE_Static_Object_Lock.
+     */
+    static int orb_init_count_;
 
-  // = ORB event loop methods.
+    /// The ORB_Core that created us....
+    TAO_ORB_Core *orb_core_;
 
-  /**
-   * Instructs the ORB to initialize itself and run its event loop in
-   * the current thread, not returning until the ORB has shut down.
-   * If an error occurs during initialization or at run-time, a CORBA
-   * system exception will be thrown.
-   */
-  void run (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
+    /// If non-0 then this is the Factory for OBV unmarshaling
+    TAO_ValueFactory_Map *valuetype_factory_map_;
 
-  /**
-   * Instructs the ORB to initialize itself and run its event loop in
-   * the current thread, not returning until the ORB has shut down or
-   * the time value specified through <tv> has expired.  If an error
-   * occurs during initialization or at run-time, a CORBA system
-   * exception will be thrown.  <tv> is reduced by the amount of time
-   * spent in this call.
-   **/
-  void run (ACE_Time_Value &tv
-            ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    /// Decides whether to use the URL notation or to use IOR notation.
+    CORBA::Boolean use_omg_ior_format_;
 
-  /**
-   * Instructs the ORB to initialize itself and run its event loop in
-   * the current thread, not returning until the ORB has shut down or
-   * the time value specified through <tv> has expired.  If an error
-   * occurs during initialization or at run-time, a CORBA system
-   * exception will be thrown.  <tv> is reduced by the amount of time
-   * spent in this call.  If <tv> is 0, it means that the timeout is
-   * infinite.  If <tv> is ACE_Time_Value::zero, it specifies to poll
-   * and does not block.
-   **/
-  void run (ACE_Time_Value *tv
-            ACE_ENV_ARG_DECL_WITH_DEFAULTS);
-
-  /// Returns an indication of whether the ORB needs to perform some
-  /// work.
-  CORBA::Boolean work_pending (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
-
-  /// Returns an indication of whether the ORB needs to perform some work
-  /// but will look for work pending for no more than the specified time.
-  /// This is useful for implementing an event loop with an idle timeout.
-  CORBA::Boolean work_pending (ACE_Time_Value &tv
-                               ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    // Prevent copying and assignment.
+    ORB (const ORB &);
+    ORB &operator= (const ORB &);
 
-  /**
-   * This operation performs an implementation-defined unit of work.
-   * Note that the default behavior is to block if the unit of work is
-   * not present; this behavior can be modified by passing an
-   * appropriate <ACE_Time_Value> as described in run().
-   **/
-  void perform_work (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
-  void perform_work (ACE_Time_Value &
-                     ACE_ENV_ARG_DECL_WITH_DEFAULTS);
-  void perform_work (ACE_Time_Value *
-                     ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    /// Timeout value
+    ACE_Time_Value *timeout_;
 
-  /**
-   * This operation instructs the ORB to shut down. Shutting down the
-   * ORB causes all Object Adapters to be shut down. If
-   * <wait_for_completion> parameter is TRUE, this operation blocks
-   * until all ORB processing (including request processing and object
-   * deactivation or other operations associated with object adapters)
-   * has completed.
-   */
-  void shutdown (CORBA::Boolean wait_for_completion = 0
-                 ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+  };
 
   /**
-   * Explicitly destroy the ORB, releasing any resources.  Note that
-   * TAO *cannot* implicitly release the resources even if you have
-   * destroyed all the references to a particular ORB since
-   * CORBA::ORB_init() is required to return the same pointer if
-   * called with the same ORBid, only after ORB::destroy() is called
-   * it may return a new one.
+   * @class ORB_var
    *
-   * The results of multi-threaded applications, trying to destroy ()
-   * the ORB in one thread and trying to service a request in another
-   * thread are not well defined. TAO does not support such cases.  */
-  void destroy (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
-
-  CORBA_Object_ptr resolve_initial_references (const char *name
-                                               ACE_ENV_ARG_DECL_WITH_DEFAULTS);
-
-  /**
-   * This method acts as a mini-bootstrapping Naming Service, which is
-   * provided by the ORB for certain well-known object references.  TAO
-   * supports the "NameService", "TradingService", "RootPOA", "ImplRepo",
-   * and "POACurrent" via this method.  The <timeout> value bounds the
-   * amount of time the ORB blocks waiting to resolve the service.
-   * This is most useful for bootstrapping remote services, such as
-   * the "NameService" or "TradingService", that are commonly resolved
-   * via multicast.  By default, the value is 0, which means "use the
-   * <TAO_DEFAULT_SERVICE_RESOLUTION_TIMEOUT> timeout period".  Note
-   * that by using a default value for the <timeout> parameter, TAO
-   * will remains compliant with the CORBA
-   * <resolve_initial_references> specification.
+   * @brief CORBA::ORB_var implementation.
+   *
+   * CORBA::ORB_var implementation.
    */
-  CORBA_Object_ptr resolve_initial_references (const char *name,
-                                               ACE_Time_Value *timeout
-                                               ACE_ENV_ARG_DECL_WITH_DEFAULTS);
-
-  /// Register an object reference with the ORB.
-  void register_initial_reference (
-      const char * id,
-      CORBA::Object_ptr obj
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS);
-
-
-  /// Returns a sequence of ObjectIds that lists which objects have
-  /// references available via the initial references mechanism.
-  CORBA_ORB_ObjectIdList_ptr list_initial_services (
-              ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
-
-  CORBA::Policy_ptr create_policy (CORBA::PolicyType type,
-                                   const CORBA::Any& val
-                                   ACE_ENV_ARG_DECL_WITH_DEFAULTS)
-    ACE_THROW_SPEC ((CORBA::SystemException,
-                     CORBA::PolicyError));
-
-
-  // ----------------------------------------------------------------
-  // = TAO-specific extensions to the CORBA specification.
-  // ----------------------------------------------------------------
-
-  /// Create an empty policy, usually to be filled in later by
-  /// demarshaling.
-  CORBA::Policy_ptr _create_policy (CORBA::PolicyType type
-                                    ACE_ENV_ARG_DECL)
-    ACE_THROW_SPEC ((CORBA::SystemException,
-                     CORBA::PolicyError));
-
-  /// Resolve the POA.
-  CORBA_Object_ptr resolve_root_poa (ACE_ENV_SINGLE_ARG_DECL);
-
-  /// Initialize the ORB globals correctly, i.e., only when they
-  /// haven't been initialized yet.
-  static void init_orb_globals (ACE_ENV_SINGLE_ARG_DECL);
-
-  // The function used by tao to handle the "unexpected" exceptions,
-  // It raises CORBA::UNKNOWN.
-  static void _tao_unexpected_exception (void);
+  class TAO_Export ORB_var
+  {
+  public:
+    ORB_var (void); // default constructor
+    ORB_var (CORBA::ORB_ptr);
+    ORB_var (const ORB_var &); // copy constructor
+    ~ORB_var (void); // destructor
 
-  // Reference counting...
-  CORBA::ULong _incr_refcnt (void);
-  CORBA::ULong _decr_refcnt (void);
+    ORB_var &operator= (CORBA::ORB_ptr);
+    ORB_var &operator= (const ORB_var &);
+    CORBA::ORB_ptr operator-> (void) const;
 
-  /// Set the IOR flag.
-  /// Get the IOR flag.
-  void _use_omg_ior_format (CORBA::Boolean ior);
-  CORBA::Boolean _use_omg_ior_format (void);
+    /// in, inout, out, _retn
+    operator const CORBA::ORB_ptr &() const;
+    operator CORBA::ORB_ptr &();
+    CORBA::ORB_ptr in (void) const;
+    CORBA::ORB_ptr &inout (void);
+    CORBA::ORB_ptr &out (void);
+    CORBA::ORB_ptr _retn (void);
+    CORBA::ORB_ptr ptr (void) const;
 
-  /// Set collocation optimization status.
-  /// Get collocation optimization status.
-  void _optimize_collocation_objects (CORBA::Boolean opt);
-  CORBA::Boolean _optimize_collocation_objects (void) const;
+  private:
+    CORBA::ORB_ptr ptr_;
 
-  /// Get the ORB core.
-  TAO_ORB_Core *orb_core (void) const;
+  };
 
   /**
-   * TAO specific extension to get and set the client ID. The client
-   * id can be set by the application which would be used by the FT
-   * service. As there are no specific interfaces defined in the spec,
-   * we have this prorpietary extensions
+   * @class ORB_out
+   *
+   * @brief CORBA::ORB_out implementation.
+   *
+   * CORBA::ORB_out implementation.
    */
-  const ACE_CString &_tao_ft_client_id (void);
-  void _tao_ft_client_id (const char *id);
-
-#if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-  typedef CORBA_ORB_ptr _ptr_type;
-  typedef CORBA_ORB_var _var_type;
-#endif /* __GNUC__ */
-  // Useful for template programming.
-
-  /// Get the Timeout value
-  ACE_Time_Value *get_timeout (void);
-
-protected:
-  // We must be created via the <ORB_init> call.
-  CORBA_ORB (TAO_ORB_Core *orb_core);
-  ~CORBA_ORB (void);
-
-  /// Resolve the POA current.
-  CORBA_Object_ptr resolve_poa_current (ACE_ENV_SINGLE_ARG_DECL);
-
-  /// Resolve the Policy Manager for this ORB.
-  CORBA_Object_ptr resolve_policy_manager (ACE_ENV_SINGLE_ARG_DECL_NOT_USED);
-
-  /// Resolve the Policy Current for this thread.
-  CORBA_Object_ptr resolve_policy_current (ACE_ENV_SINGLE_ARG_DECL_NOT_USED);
-
-private:
-
-  /// Resolve the given service based on the service ID.
-  CORBA::Object_ptr resolve_service (TAO_MCAST_SERVICEID service_id
-                                    ACE_ENV_ARG_DECL);
-
-  /// Convert an OMG IOR into an object reference.
-  CORBA::Object_ptr ior_string_to_object (const char* ior
-                                          ACE_ENV_ARG_DECL);
-
-  /// Convert an URL style IOR into an object reference.
-  CORBA::Object_ptr url_ior_string_to_object (const char* ior
-                                              ACE_ENV_ARG_DECL);
-
-  /// Check if ORB has shutdown.  If it has, throw an exception.
-  void check_shutdown (ACE_ENV_SINGLE_ARG_DECL);
-
-  /// Set the timeout value
-  void set_timeout (ACE_Time_Value *timeout);
-
-private:
-  /// lock required for mutual exclusion between multiple threads.
-  TAO_SYNCH_MUTEX lock_;
-
-  /// Maintains a reference count of number of instantiations of the
-  /// ORB.
-  u_int refcount_;
-
-  /// Count of the number of times that <ORB_init> has been called.
-  static int orb_init_count_;
-  // This must be protected by <ACE_Static_Object_Lock>.
-
-  /// The ORB_Core that created us....
-  TAO_ORB_Core *orb_core_;
-
-  /// If non-0 then this is the Factory for OBV unmarshaling
-  TAO_ValueFactory_Map *valuetype_factory_map_;
-
-  /// Decides whether to use the URL notation or to use IOR notation.
-  CORBA::Boolean use_omg_ior_format_;
-
-  // = NON-PROVIDED METHODS
-  CORBA_ORB (const CORBA_ORB &);
-  CORBA_ORB &operator= (const CORBA_ORB &);
-
-  /// Timeout value
-  ACE_Time_Value *timeout_;
-
-};
-
-class TAO_Export CORBA_ORB_var
-{
-public:
-  CORBA_ORB_var (void); // default constructor
-  CORBA_ORB_var (CORBA::ORB_ptr);
-  CORBA_ORB_var (const CORBA_ORB_var &); // copy constructor
-  ~CORBA_ORB_var (void); // destructor
-
-  CORBA_ORB_var &operator= (CORBA::ORB_ptr);
-  CORBA_ORB_var &operator= (const CORBA_ORB_var &);
-  CORBA::ORB_ptr operator-> (void) const;
-
-  /// in, inout, out, _retn
-  operator const CORBA::ORB_ptr &() const;
-  operator CORBA::ORB_ptr &();
-  CORBA::ORB_ptr in (void) const;
-  CORBA::ORB_ptr &inout (void);
-  CORBA::ORB_ptr &out (void);
-  CORBA::ORB_ptr _retn (void);
-  CORBA::ORB_ptr ptr (void) const;
-
-private:
-  CORBA::ORB_ptr ptr_;
-};
-
-class TAO_Export CORBA_ORB_out
-{
-public:
-  CORBA_ORB_out (CORBA::ORB_ptr &);
-  CORBA_ORB_out (CORBA_ORB_var &);
-  CORBA_ORB_out (const CORBA_ORB_out &);
-  CORBA_ORB_out &operator= (CORBA_ORB_out &);
-  CORBA_ORB_out &operator= (const CORBA_ORB_var &);
-  CORBA_ORB_out &operator= (CORBA::ORB_ptr);
-  operator CORBA::ORB_ptr &();
-  CORBA::ORB_ptr &ptr (void);
-  CORBA::ORB_ptr operator-> (void);
-
-private:
-  CORBA::ORB_ptr &ptr_;
-};
+  class TAO_Export ORB_out
+  {
+  public:
+    ORB_out (CORBA::ORB_ptr &);
+    ORB_out (CORBA::ORB_var &);
+    ORB_out (const ORB_out &);
+    ORB_out &operator= (ORB_out &);
+    ORB_out &operator= (const CORBA::ORB_var &);
+    ORB_out &operator= (CORBA::ORB_ptr);
+    operator CORBA::ORB_ptr &();
+    CORBA::ORB_ptr &ptr (void);
+    CORBA::ORB_ptr operator-> (void);
+
+  private:
+    CORBA::ORB_ptr &ptr_;
+  };
+
+}  // End namespace CORBA
 
 #if defined (__ACE_INLINE__)
 # include "tao/ORB.i"
diff --git a/TAO/tao/ORB.i b/TAO/tao/ORB.i
index ff74200abe5..2a219388c0a 100644
--- a/TAO/tao/ORB.i
+++ b/TAO/tao/ORB.i
@@ -8,14 +8,14 @@
 // ---------------------------------------------------------------------------
 
 ACE_INLINE CORBA::ULong
-CORBA_ORB::_incr_refcnt (void)
+CORBA::ORB::_incr_refcnt (void)
 {
   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, guard, lock_, 0);
   return ++this->refcount_;
 }
 
 ACE_INLINE CORBA::ULong
-CORBA_ORB::_decr_refcnt (void)
+CORBA::ORB::_decr_refcnt (void)
 {
   {
     ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_, 0);
@@ -29,7 +29,7 @@ CORBA_ORB::_decr_refcnt (void)
 }
 
 ACE_INLINE CORBA::ORB_ptr
-CORBA_ORB::_duplicate (CORBA::ORB_ptr obj)
+CORBA::ORB::_duplicate (CORBA::ORB_ptr obj)
 {
   if (obj)
     obj->_incr_refcnt ();
@@ -39,25 +39,25 @@ CORBA_ORB::_duplicate (CORBA::ORB_ptr obj)
 // Null pointers represent nil objects.
 
 ACE_INLINE CORBA::ORB_ptr
-CORBA_ORB::_nil (void)
+CORBA::ORB::_nil (void)
 {
   return 0;
 }
 
 ACE_INLINE void
-CORBA_ORB::_use_omg_ior_format (CORBA::Boolean ior)
+CORBA::ORB::_use_omg_ior_format (CORBA::Boolean ior)
 {
   this->use_omg_ior_format_ = ior;
 }
 
 ACE_INLINE CORBA::Boolean
-CORBA_ORB::_use_omg_ior_format (void)
+CORBA::ORB::_use_omg_ior_format (void)
 {
   return this->use_omg_ior_format_;
 }
 
 ACE_INLINE TAO_ORB_Core *
-CORBA_ORB::orb_core (void) const
+CORBA::ORB::orb_core (void) const
 {
   return this->orb_core_;
 }
@@ -69,7 +69,7 @@ CORBA_ORB::orb_core (void) const
 ACE_INLINE CORBA::Boolean
 CORBA::is_nil (CORBA::ORB_ptr obj)
 {
-  return obj == CORBA_ORB::_nil ();
+  return obj == CORBA::ORB::_nil ();
 }
 
 ACE_INLINE void
@@ -80,164 +80,164 @@ CORBA::release (CORBA::ORB_ptr obj)
 }
 
 // *************************************************************
-// Inline operations for class CORBA_ORB_var
+// Inline operations for class CORBA::ORB_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ORB_var::CORBA_ORB_var (void) // default constructor
-  : ptr_ (CORBA_ORB::_nil ())
+CORBA::ORB_var::ORB_var (void) // default constructor
+  : ptr_ (CORBA::ORB::_nil ())
 {
 }
 
 ACE_INLINE
-CORBA_ORB_var::CORBA_ORB_var (CORBA::ORB_ptr p)
+CORBA::ORB_var::ORB_var (CORBA::ORB_ptr p)
   : ptr_ (p)
 {
 }
 
 ACE_INLINE CORBA::ORB_ptr
-CORBA_ORB_var::ptr (void) const
+CORBA::ORB_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_ORB_var::CORBA_ORB_var (const CORBA_ORB_var &p) // copy constructor
-  : ptr_ (CORBA_ORB::_duplicate (p.ptr ()))
+CORBA::ORB_var::ORB_var (const CORBA::ORB_var &p) // copy constructor
+  : ptr_ (CORBA::ORB::_duplicate (p.ptr ()))
 {
 }
 
 ACE_INLINE
-CORBA_ORB_var::~CORBA_ORB_var (void) // destructor
+CORBA::ORB_var::~ORB_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_ORB_var &
-CORBA_ORB_var::operator= (CORBA::ORB_ptr p)
+ACE_INLINE CORBA::ORB_var &
+CORBA::ORB_var::operator= (CORBA::ORB_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ORB_var &
-CORBA_ORB_var::operator= (const CORBA_ORB_var &p)
+ACE_INLINE CORBA::ORB_var &
+CORBA::ORB_var::operator= (const CORBA::ORB_var &p)
 {
   if (this != &p)
     {
       CORBA::release (this->ptr_);
-      this->ptr_ = CORBA_ORB::_duplicate (p.ptr ());
+      this->ptr_ = CORBA::ORB::_duplicate (p.ptr ());
     }
   return *this;
 }
 
 ACE_INLINE
-CORBA_ORB_var::operator const CORBA::ORB_ptr &() const // cast
+CORBA::ORB_var::operator const CORBA::ORB_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_ORB_var::operator CORBA::ORB_ptr &() // cast
+CORBA::ORB_var::operator CORBA::ORB_ptr &() // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::ORB_ptr
-CORBA_ORB_var::operator-> (void) const
+CORBA::ORB_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::ORB_ptr
-CORBA_ORB_var::in (void) const
+CORBA::ORB_var::in (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::ORB_ptr &
-CORBA_ORB_var::inout (void)
+CORBA::ORB_var::inout (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::ORB_ptr &
-CORBA_ORB_var::out (void)
+CORBA::ORB_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_ORB::_nil ();
+  this->ptr_ = CORBA::ORB::_nil ();
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::ORB_ptr
-CORBA_ORB_var::_retn (void)
+CORBA::ORB_var::_retn (void)
 {
   // yield ownership of managed obj reference
   CORBA::ORB_ptr val = this->ptr_;
-  this->ptr_ = CORBA_ORB::_nil ();
+  this->ptr_ = CORBA::ORB::_nil ();
   return val;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_ORB_out
+// Inline operations for class CORBA::ORB_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ORB_out::CORBA_ORB_out (CORBA::ORB_ptr &p)
+CORBA::ORB_out::ORB_out (CORBA::ORB_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_ORB::_nil ();
+  this->ptr_ = CORBA::ORB::_nil ();
 }
 
 ACE_INLINE
-CORBA_ORB_out::CORBA_ORB_out (CORBA_ORB_var &p) // constructor from _var
+CORBA::ORB_out::ORB_out (CORBA::ORB_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_ORB::_nil ();
+  this->ptr_ = CORBA::ORB::_nil ();
 }
 
 ACE_INLINE
-CORBA_ORB_out::CORBA_ORB_out (const CORBA_ORB_out &p) // copy constructor
+CORBA::ORB_out::ORB_out (const CORBA::ORB_out &p) // copy constructor
   : ptr_ (p.ptr_)
 {}
 
-ACE_INLINE CORBA_ORB_out &
-CORBA_ORB_out::operator= (CORBA_ORB_out &p)
+ACE_INLINE CORBA::ORB_out &
+CORBA::ORB_out::operator= (CORBA::ORB_out &p)
 {
   this->ptr_ = p.ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ORB_out &
-CORBA_ORB_out::operator= (const CORBA_ORB_var &p)
+ACE_INLINE CORBA::ORB_out &
+CORBA::ORB_out::operator= (const CORBA::ORB_var &p)
 {
-  this->ptr_ = CORBA_ORB::_duplicate (p.ptr ());
+  this->ptr_ = CORBA::ORB::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_ORB_out &
-CORBA_ORB_out::operator= (CORBA::ORB_ptr p)
+ACE_INLINE CORBA::ORB_out &
+CORBA::ORB_out::operator= (CORBA::ORB_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE
-CORBA_ORB_out::operator CORBA::ORB_ptr &() // cast
+CORBA::ORB_out::operator CORBA::ORB_ptr &() // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::ORB_ptr &
-CORBA_ORB_out::ptr (void) // ptr
+CORBA::ORB_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::ORB_ptr
-CORBA_ORB_out::operator-> (void)
+CORBA::ORB_out::operator-> (void)
 {
   return this->ptr_;
 }
diff --git a/TAO/tao/OctetSeqC.cpp b/TAO/tao/OctetSeqC.cpp
index 1e4ff14dd8b..70fb24a8a53 100644
--- a/TAO/tao/OctetSeqC.cpp
+++ b/TAO/tao/OctetSeqC.cpp
@@ -41,9 +41,9 @@
 // CORBA::OctetSeq
 // *************************************************************
 
-CORBA_OctetSeq::CORBA_OctetSeq (void)
+CORBA::OctetSeq::OctetSeq (void)
 {}
-CORBA_OctetSeq::CORBA_OctetSeq (CORBA::ULong max) // uses max size
+CORBA::OctetSeq::OctetSeq (CORBA::ULong max) // uses max size
   :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_Sequence<CORBA::Octet>
@@ -52,7 +52,7 @@ CORBA_OctetSeq::CORBA_OctetSeq (CORBA::ULong max) // uses max size
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max)
 {}
-CORBA_OctetSeq::CORBA_OctetSeq (CORBA::ULong max, CORBA::ULong length, CORBA::Octet *buffer, CORBA::Boolean release)
+CORBA::OctetSeq::OctetSeq (CORBA::ULong max, CORBA::ULong length, CORBA::Octet *buffer, CORBA::Boolean release)
   :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_Sequence<CORBA::Octet>
@@ -61,7 +61,7 @@ CORBA_OctetSeq::CORBA_OctetSeq (CORBA::ULong max, CORBA::ULong length, CORBA::Oc
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max, length, buffer, release)
 {}
-CORBA_OctetSeq::CORBA_OctetSeq (const CORBA_OctetSeq &seq) // copy ctor
+CORBA::OctetSeq::OctetSeq (const CORBA::OctetSeq &seq) // copy ctor
   :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_Sequence<CORBA::Octet>
@@ -70,11 +70,11 @@ CORBA_OctetSeq::CORBA_OctetSeq (const CORBA_OctetSeq &seq) // copy ctor
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (seq)
 {}
-CORBA_OctetSeq::~CORBA_OctetSeq (void) // dtor
+CORBA::OctetSeq::~OctetSeq (void) // dtor
 {}
-void CORBA_OctetSeq::_tao_any_destructor (void *x)
+void CORBA::OctetSeq::_tao_any_destructor (void *x)
 {
-  CORBA_OctetSeq *tmp = ACE_static_cast (CORBA_OctetSeq*,x);
+  CORBA::OctetSeq *tmp = ACE_static_cast (CORBA::OctetSeq*,x);
   delete tmp;
 }
 
@@ -94,7 +94,7 @@ static const CORBA::Long _oc_CORBA_OctetSeq[] =
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_OctetSeq (CORBA::tk_alias, sizeof (_oc_CORBA_OctetSeq), (char *) &_oc_CORBA_OctetSeq, 0, sizeof (CORBA_OctetSeq));
+static CORBA::TypeCode _tc_TAO_tc_CORBA_OctetSeq (CORBA::tk_alias, sizeof (_oc_CORBA_OctetSeq), (char *) &_oc_CORBA_OctetSeq, 0, sizeof (CORBA::OctetSeq));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (CORBA)
 TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_OctetSeq, &_tc_TAO_tc_CORBA_OctetSeq)
@@ -102,7 +102,7 @@ TAO_NAMESPACE_END
 
 void operator<<= (
     CORBA::Any &_tao_any,
-    const CORBA_OctetSeq &_tao_elem
+    const CORBA::OctetSeq &_tao_elem
   ) // copying
 {
   TAO_OutputCDR stream;
@@ -116,7 +116,7 @@ void operator<<= (
   }
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA_OctetSeq *_tao_elem) // non copying
+void operator<<= (CORBA::Any &_tao_any, CORBA::OctetSeq *_tao_elem) // non copying
 {
   TAO_OutputCDR stream;
   stream << *_tao_elem;
@@ -126,19 +126,19 @@ void operator<<= (CORBA::Any &_tao_any, CORBA_OctetSeq *_tao_elem) // non copyin
       stream.begin (),
       1,
       _tao_elem,
-      CORBA_OctetSeq::_tao_any_destructor
+      CORBA::OctetSeq::_tao_any_destructor
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_OctetSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OctetSeq *&_tao_elem)
 {
   return _tao_any >>= ACE_const_cast(
-      const CORBA_OctetSeq*&,
+      const CORBA::OctetSeq*&,
       _tao_elem
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_OctetSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::OctetSeq *&_tao_elem)
 {
   _tao_elem = 0;
   ACE_TRY_NEW_ENV
@@ -156,15 +156,15 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_OctetSeq *&_
     if (_tao_any.any_owns_data ())
     {
       _tao_elem = ACE_static_cast(
-          const CORBA_OctetSeq*,
+          const CORBA::OctetSeq*,
           _tao_any.value ()
         );
       return 1;
     }
     else
     {
-      CORBA_OctetSeq *tmp;
-      ACE_NEW_RETURN (tmp, CORBA_OctetSeq, 0);
+      CORBA::OctetSeq *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::OctetSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
@@ -175,7 +175,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_OctetSeq *&_
             CORBA::_tc_OctetSeq,
             1,
             ACE_static_cast (void *, tmp),
-            CORBA_OctetSeq::_tao_any_destructor
+            CORBA::OctetSeq::_tao_any_destructor
           );
         _tao_elem = tmp;
         return 1;
@@ -195,7 +195,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_OctetSeq *&_
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_OctetSeq &_tao_sequence
+    const CORBA::OctetSeq &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -205,7 +205,7 @@ CORBA::Boolean operator<< (
 #if (TAO_NO_COPY_OCTET_SEQUENCES == 1)
     {
       TAO_Unbounded_Sequence<CORBA::Octet> *oseq =
-        ACE_static_cast (TAO_Unbounded_Sequence<CORBA::Octet>*, (CORBA_OctetSeq *)&_tao_sequence);
+        ACE_static_cast (TAO_Unbounded_Sequence<CORBA::Octet>*, (CORBA::OctetSeq *)&_tao_sequence);
       if (oseq->mb ())
         return strm.write_octet_array_mb (oseq->mb ());
       else
@@ -222,7 +222,7 @@ CORBA::Boolean operator<< (
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    CORBA_OctetSeq &_tao_sequence
+    CORBA::OctetSeq &_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;
diff --git a/TAO/tao/OctetSeqC.h b/TAO/tao/OctetSeqC.h
index 1faaeb8ee23..c53e4441312 100644
--- a/TAO/tao/OctetSeqC.h
+++ b/TAO/tao/OctetSeqC.h
@@ -54,17 +54,19 @@
 #pragma option push -w-rvl -w-rch -w-ccc -w-inl
 #endif /* __BORLANDC__ */
 
+namespace CORBA
+{
 #if !defined (_CORBA_OCTETSEQ_CH_)
 #define _CORBA_OCTETSEQ_CH_
 
-  class CORBA_OctetSeq;
-  class CORBA_OctetSeq_var;
+  class OctetSeq;
+  class OctetSeq_var;
   
   // *************************************************************
   // CORBA::OctetSeq
   // *************************************************************
   
-  class TAO_Export CORBA_OctetSeq : public 
+  class TAO_Export OctetSeq : public 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
     TAO_Unbounded_Sequence<CORBA::Octet>
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
@@ -72,25 +74,25 @@
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
   {
   public:
-    CORBA_OctetSeq (void); // default ctor
-    CORBA_OctetSeq (CORBA::ULong max); // uses max size
-    CORBA_OctetSeq (
+    OctetSeq (void); // default ctor
+    OctetSeq (CORBA::ULong max); // uses max size
+    OctetSeq (
       CORBA::ULong max, 
       CORBA::ULong length, 
       CORBA::Octet *buffer, 
       CORBA::Boolean release = 0
     );
-    CORBA_OctetSeq (const CORBA_OctetSeq &); // copy ctor
-    ~CORBA_OctetSeq (void);
+    OctetSeq (const OctetSeq &); // copy ctor
+    ~OctetSeq (void);
     static void _tao_any_destructor (void*);
 
 #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-    typedef CORBA_OctetSeq_var _var_type;
+    typedef OctetSeq_var _var_type;
 #endif /* ! __GNUC__ || g++ >= 2.8 */
 
 
 #if (TAO_NO_COPY_OCTET_SEQUENCES == 1)
-    CORBA_OctetSeq (
+    OctetSeq (
         CORBA::ULong length,
         const ACE_Message_Block* mb
       )
@@ -109,37 +111,37 @@
   // class CORBA::OctetSeq_var
   // *************************************************************
 
-  class TAO_Export CORBA_OctetSeq_var
+  class TAO_Export OctetSeq_var
   {
   public:
-    CORBA_OctetSeq_var (void); // default constructor
-    CORBA_OctetSeq_var (CORBA_OctetSeq *);
-    CORBA_OctetSeq_var (const CORBA_OctetSeq_var &); // copy constructor
-    CORBA_OctetSeq_var (const CORBA_OctetSeq &); // fixed-size base types only
-    ~CORBA_OctetSeq_var (void); // destructor
+    OctetSeq_var (void); // default constructor
+    OctetSeq_var (OctetSeq *);
+    OctetSeq_var (const OctetSeq_var &); // copy constructor
+    OctetSeq_var (const OctetSeq &); // fixed-size base types only
+    ~OctetSeq_var (void); // destructor
     
-    CORBA_OctetSeq_var &operator= (CORBA_OctetSeq *);
-    CORBA_OctetSeq_var &operator= (const CORBA_OctetSeq_var &);
-    CORBA_OctetSeq_var &operator= (const CORBA_OctetSeq &); // fixed-size base types only
-    CORBA_OctetSeq *operator-> (void);
-    const CORBA_OctetSeq *operator-> (void) const;
+    OctetSeq_var &operator= (OctetSeq *);
+    OctetSeq_var &operator= (const OctetSeq_var &);
+    OctetSeq_var &operator= (const OctetSeq &); // fixed-size base types only
+    OctetSeq *operator-> (void);
+    const OctetSeq *operator-> (void) const;
     
-    operator const CORBA_OctetSeq &() const;
-    operator CORBA_OctetSeq &();
-    operator CORBA_OctetSeq &() const;
+    operator const OctetSeq &() const;
+    operator OctetSeq &();
+    operator OctetSeq &() const;
     
     CORBA::Octet & operator[] (CORBA::ULong index);
     const CORBA::Octet & operator[] (CORBA::ULong index) const;
     
     // in, inout, out, _retn 
-    const CORBA_OctetSeq &in (void) const;
-    CORBA_OctetSeq &inout (void);
-    CORBA_OctetSeq *&out (void);
-    CORBA_OctetSeq *_retn (void);
-    CORBA_OctetSeq *ptr (void) const;
+    const OctetSeq &in (void) const;
+    OctetSeq &inout (void);
+    OctetSeq *&out (void);
+    OctetSeq *_retn (void);
+    OctetSeq *ptr (void) const;
 
   private:
-    CORBA_OctetSeq *ptr_;
+    OctetSeq *ptr_;
   };
 
 
@@ -149,34 +151,36 @@
 #if !defined (_CORBA_OCTETSEQ___OUT_CH_)
 #define _CORBA_OCTETSEQ___OUT_CH_
 
-  class TAO_Export CORBA_OctetSeq_out
+  class TAO_Export OctetSeq_out
   {
   public:
-    CORBA_OctetSeq_out (CORBA_OctetSeq *&);
-    CORBA_OctetSeq_out (CORBA_OctetSeq_var &);
-    CORBA_OctetSeq_out (const CORBA_OctetSeq_out &);
-    CORBA_OctetSeq_out &operator= (const CORBA_OctetSeq_out &);
-    CORBA_OctetSeq_out &operator= (CORBA_OctetSeq *);
-    operator CORBA_OctetSeq *&();
-    CORBA_OctetSeq *&ptr (void);
-    CORBA_OctetSeq *operator-> (void);
+    OctetSeq_out (OctetSeq *&);
+    OctetSeq_out (OctetSeq_var &);
+    OctetSeq_out (const OctetSeq_out &);
+    OctetSeq_out &operator= (const OctetSeq_out &);
+    OctetSeq_out &operator= (OctetSeq *);
+    operator OctetSeq *&();
+    OctetSeq *&ptr (void);
+    OctetSeq *operator-> (void);
     CORBA::Octet & operator[] (CORBA::ULong index);
     
   private:
-    CORBA_OctetSeq *&ptr_;
+    OctetSeq *&ptr_;
     // assignment from T_var not allowed
-    void operator= (const CORBA_OctetSeq_var &);
+    void operator= (const OctetSeq_var &);
   };
 
 
 #endif /* end #if !defined */
 
+}  // End namespace CORBA
+
 // Proxy Broker Factory function pointer declarations.
 
-TAO_Export void operator<<= (CORBA::Any &, const CORBA_OctetSeq &); // copying version
-TAO_Export void operator<<= (CORBA::Any &, CORBA_OctetSeq*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_OctetSeq *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA_OctetSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const CORBA::OctetSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, CORBA::OctetSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::OctetSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::OctetSeq *&);
 
 #ifndef __ACE_INLINE__
 
@@ -186,11 +190,11 @@ TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA_OctetSeq
 
 TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA_OctetSeq &
+    const CORBA::OctetSeq &
   );
 TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA_OctetSeq &
+    CORBA::OctetSeq &
   );
 
 #endif /* _TAO_CDR_OP_CORBA_OctetSeq_H_ */
diff --git a/TAO/tao/OctetSeqC.i b/TAO/tao/OctetSeqC.i
index 01ffb2d3fba..b713fedefb6 100644
--- a/TAO/tao/OctetSeqC.i
+++ b/TAO/tao/OctetSeqC.i
@@ -28,47 +28,47 @@
 // *************************************************************
 
 ACE_INLINE
-CORBA_OctetSeq_var::CORBA_OctetSeq_var (void) // default constructor
+CORBA::OctetSeq_var::OctetSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_OctetSeq_var::CORBA_OctetSeq_var (CORBA_OctetSeq *p)
+CORBA::OctetSeq_var::OctetSeq_var (CORBA::OctetSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_OctetSeq_var::CORBA_OctetSeq_var (const ::CORBA_OctetSeq_var &p) // copy constructor
+CORBA::OctetSeq_var::OctetSeq_var (const CORBA::OctetSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, ::CORBA_OctetSeq (*p.ptr_));
+    ACE_NEW (this->ptr_, CORBA::OctetSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 // fixed-size base types only
 ACE_INLINE
-CORBA_OctetSeq_var::CORBA_OctetSeq_var (const ::CORBA_OctetSeq &p)
+CORBA::OctetSeq_var::OctetSeq_var (const ::CORBA::OctetSeq &p)
 {
-  ACE_NEW (this->ptr_, ::CORBA_OctetSeq (p));
+  ACE_NEW (this->ptr_, ::CORBA::OctetSeq (p));
 }
 
 ACE_INLINE
-CORBA_OctetSeq_var::~CORBA_OctetSeq_var (void) // destructor
+CORBA::OctetSeq_var::~OctetSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_OctetSeq_var &
-CORBA_OctetSeq_var::operator= (CORBA_OctetSeq *p)
+ACE_INLINE CORBA::OctetSeq_var &
+CORBA::OctetSeq_var::operator= (CORBA::OctetSeq *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE ::CORBA_OctetSeq_var &
-CORBA_OctetSeq_var::operator= (const ::CORBA_OctetSeq_var &p)
+ACE_INLINE ::CORBA::OctetSeq_var &
+CORBA::OctetSeq_var::operator= (const ::CORBA::OctetSeq_var &p)
 {
   if (this != &p)
     {
@@ -79,12 +79,12 @@ CORBA_OctetSeq_var::operator= (const ::CORBA_OctetSeq_var &p)
         }
       else
         {
-          CORBA_OctetSeq *deep_copy =
-            new CORBA_OctetSeq (*p.ptr_);
+          CORBA::OctetSeq *deep_copy =
+            new CORBA::OctetSeq (*p.ptr_);
           
           if (deep_copy != 0)
             {
-              CORBA_OctetSeq *tmp = deep_copy;
+              CORBA::OctetSeq *tmp = deep_copy;
               deep_copy = this->ptr_;
               this->ptr_ = tmp;
               delete deep_copy;
@@ -96,90 +96,90 @@ CORBA_OctetSeq_var::operator= (const ::CORBA_OctetSeq_var &p)
 }
 
 // fixed-size types only
-ACE_INLINE ::CORBA_OctetSeq_var &
-CORBA_OctetSeq_var::operator= (const ::CORBA_OctetSeq &p)
+ACE_INLINE ::CORBA::OctetSeq_var &
+CORBA::OctetSeq_var::operator= (const ::CORBA::OctetSeq &p)
 {
   if (this->ptr_ != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, ::CORBA_OctetSeq (p), *this);
+    ACE_NEW_RETURN (this->ptr_, ::CORBA::OctetSeq (p), *this);
   }
   return *this;
 }
 
-ACE_INLINE const ::CORBA_OctetSeq *
-CORBA_OctetSeq_var::operator-> (void) const
+ACE_INLINE const ::CORBA::OctetSeq *
+CORBA::OctetSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE ::CORBA_OctetSeq *
-CORBA_OctetSeq_var::operator-> (void)
+ACE_INLINE ::CORBA::OctetSeq *
+CORBA::OctetSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_OctetSeq_var::operator const ::CORBA_OctetSeq &() const // cast
+CORBA::OctetSeq_var::operator const ::CORBA::OctetSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_OctetSeq_var::operator ::CORBA_OctetSeq &() // cast 
+CORBA::OctetSeq_var::operator ::CORBA::OctetSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_OctetSeq_var::operator ::CORBA_OctetSeq &() const // cast 
+CORBA::OctetSeq_var::operator ::CORBA::OctetSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE CORBA::Octet &
-CORBA_OctetSeq_var::operator[] (CORBA::ULong index)
+CORBA::OctetSeq_var::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
 
 ACE_INLINE const CORBA::Octet &
-CORBA_OctetSeq_var::operator[] (CORBA::ULong index) const
+CORBA::OctetSeq_var::operator[] (CORBA::ULong index) const
 {
   return ACE_const_cast (const CORBA::Octet &, this->ptr_->operator[] (index));
 }
 
-ACE_INLINE const ::CORBA_OctetSeq &
-CORBA_OctetSeq_var::in (void) const
+ACE_INLINE const ::CORBA::OctetSeq &
+CORBA::OctetSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE ::CORBA_OctetSeq &
-CORBA_OctetSeq_var::inout (void)
+ACE_INLINE ::CORBA::OctetSeq &
+CORBA::OctetSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE ::CORBA_OctetSeq *&
-CORBA_OctetSeq_var::out (void)
+ACE_INLINE ::CORBA::OctetSeq *&
+CORBA::OctetSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE ::CORBA_OctetSeq *
-CORBA_OctetSeq_var::_retn (void)
+ACE_INLINE ::CORBA::OctetSeq *
+CORBA::OctetSeq_var::_retn (void)
 {
-  ::CORBA_OctetSeq *tmp = this->ptr_;
+  ::CORBA::OctetSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE ::CORBA_OctetSeq *
-CORBA_OctetSeq_var::ptr (void) const
+ACE_INLINE ::CORBA::OctetSeq *
+CORBA::OctetSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
@@ -189,14 +189,14 @@ CORBA_OctetSeq_var::ptr (void) const
 // *************************************************************
 
 ACE_INLINE
-CORBA_OctetSeq_out::CORBA_OctetSeq_out (CORBA_OctetSeq *&p)
+CORBA::OctetSeq_out::OctetSeq_out (CORBA::OctetSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_OctetSeq_out::CORBA_OctetSeq_out (CORBA_OctetSeq_var &p) // constructor from _var
+CORBA::OctetSeq_out::OctetSeq_out (CORBA::OctetSeq_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -204,44 +204,44 @@ CORBA_OctetSeq_out::CORBA_OctetSeq_out (CORBA_OctetSeq_var &p) // constructor fr
 }
 
 ACE_INLINE
-CORBA_OctetSeq_out::CORBA_OctetSeq_out (const ::CORBA_OctetSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_OctetSeq_out&, p).ptr_)
+CORBA::OctetSeq_out::OctetSeq_out (const ::CORBA::OctetSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA::OctetSeq_out&, p).ptr_)
 {}
 
-ACE_INLINE ::CORBA_OctetSeq_out &
-CORBA_OctetSeq_out::operator= (const ::CORBA_OctetSeq_out &p)
+ACE_INLINE ::CORBA::OctetSeq_out &
+CORBA::OctetSeq_out::operator= (const ::CORBA::OctetSeq_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_OctetSeq_out&, p).ptr_;
+  this->ptr_ = ACE_const_cast (CORBA::OctetSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE ::CORBA_OctetSeq_out &
-CORBA_OctetSeq_out::operator= (CORBA_OctetSeq *p)
+ACE_INLINE ::CORBA::OctetSeq_out &
+CORBA::OctetSeq_out::operator= (CORBA::OctetSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_OctetSeq_out::operator ::CORBA_OctetSeq *&() // cast
+CORBA::OctetSeq_out::operator ::CORBA::OctetSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE ::CORBA_OctetSeq *&
-CORBA_OctetSeq_out::ptr (void) // ptr
+ACE_INLINE ::CORBA::OctetSeq *&
+CORBA::OctetSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE ::CORBA_OctetSeq *
-CORBA_OctetSeq_out::operator-> (void)
+ACE_INLINE ::CORBA::OctetSeq *
+CORBA::OctetSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::Octet &
-CORBA_OctetSeq_out::operator[] (CORBA::ULong index)
+CORBA::OctetSeq_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
@@ -255,11 +255,11 @@ CORBA_OctetSeq_out::operator[] (CORBA::ULong index)
 
 CORBA::Boolean TAO_Export operator<< (
     TAO_OutputCDR &,
-    const CORBA_OctetSeq &
+    const CORBA::OctetSeq &
   );
 CORBA::Boolean TAO_Export operator>> (
     TAO_InputCDR &,
-    CORBA_OctetSeq &
+    CORBA::OctetSeq &
   );
 
 #endif /* _TAO_CDR_OP_CORBA_OctetSeq_I_ */
diff --git a/TAO/tao/PolicyC.cpp b/TAO/tao/PolicyC.cpp
index d66d67d67bb..338fd760bb5 100644
--- a/TAO/tao/PolicyC.cpp
+++ b/TAO/tao/PolicyC.cpp
@@ -97,8 +97,8 @@ TAO_NAMESPACE_DEFINE (const CORBA::Short, UNSUPPORTED_POLICY_VALUE, 4)
 TAO_NAMESPACE_END
 // Default constructor.
 CORBA::PolicyError::PolicyError (void)
-  : CORBA_UserException ("IDL:omg.org/CORBA/PolicyError:1.0",
-                         "PolicyError")
+  : CORBA::UserException ("IDL:omg.org/CORBA/PolicyError:1.0",
+                          "PolicyError")
 {
 }
 
@@ -109,7 +109,7 @@ CORBA::PolicyError::~PolicyError (void)
 
 // Copy constructor.
 CORBA::PolicyError::PolicyError (const ::CORBA::PolicyError &_tao_excp)
-  : CORBA_UserException (
+  : CORBA::UserException (
         _tao_excp._rep_id (),
         _tao_excp._name ()
       )
@@ -121,7 +121,7 @@ CORBA::PolicyError::PolicyError (const ::CORBA::PolicyError &_tao_excp)
 CORBA::PolicyError&
 CORBA::PolicyError::operator= (const ::CORBA::PolicyError &_tao_excp)
 {
-  this->CORBA_UserException::operator= (_tao_excp);
+  this->UserException::operator= (_tao_excp);
   this->reason = _tao_excp.reason;
   return *this;
 }
@@ -198,8 +198,8 @@ void CORBA::PolicyError::_tao_decode (
 CORBA::PolicyError::PolicyError (
     CORBA::PolicyErrorCode _tao_reason
   )
-  : CORBA_UserException ("IDL:omg.org/CORBA/PolicyError:1.0",
-                         "PolicyError")
+  : CORBA::UserException ("IDL:omg.org/CORBA/PolicyError:1.0",
+                          "PolicyError")
 {
   this->reason = _tao_reason;
 }
@@ -367,10 +367,10 @@ void CORBA::InvalidPolicies::_tao_seq_UShort::_tao_any_destructor (void *_tao_vo
 
 // Default constructor.
 CORBA::InvalidPolicies::InvalidPolicies (void)
-  : CORBA_UserException (
-        "IDL:omg.org/CORBA/InvalidPolicies:1.0",
-        "InvalidPolicies"
-      )
+  : CORBA::UserException (
+                          "IDL:omg.org/CORBA/InvalidPolicies:1.0",
+                          "InvalidPolicies"
+                          )
 {
 }
 
@@ -381,7 +381,7 @@ CORBA::InvalidPolicies::~InvalidPolicies (void)
 
 // Copy constructor.
 CORBA::InvalidPolicies::InvalidPolicies (const ::CORBA::InvalidPolicies &_tao_excp)
-  : CORBA_UserException (
+  : CORBA::UserException (
         _tao_excp._rep_id (),
         _tao_excp._name ()
       )
@@ -393,7 +393,7 @@ CORBA::InvalidPolicies::InvalidPolicies (const ::CORBA::InvalidPolicies &_tao_ex
 CORBA::InvalidPolicies&
 CORBA::InvalidPolicies::operator= (const ::CORBA::InvalidPolicies &_tao_excp)
 {
-  this->CORBA_UserException::operator= (_tao_excp);
+  this->UserException::operator= (_tao_excp);
   this->indices = _tao_excp.indices;
   return *this;
 }
@@ -470,7 +470,7 @@ void CORBA::InvalidPolicies::_tao_decode (
 CORBA::InvalidPolicies::InvalidPolicies (
     const CORBA::InvalidPolicies::_tao_seq_UShort & _tao_indices
   )
-  : CORBA_UserException (
+  : CORBA::UserException (
         "IDL:omg.org/CORBA/InvalidPolicies:1.0",
         "InvalidPolicies"
       )
@@ -1013,7 +1013,7 @@ CORBA::_TAO_Policy_Remote_Proxy_Impl::_TAO_Policy_Remote_Proxy_Impl (void)
 // Remote Implementation of the IDL interface methods
 
 CORBA::PolicyType CORBA::_TAO_Policy_Remote_Proxy_Impl::policy_type (
-    CORBA_Object *_collocated_tao_target_
+    CORBA::Object *_collocated_tao_target_
     ACE_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((
@@ -1178,7 +1178,7 @@ return _tao_retval;
 }
 
 ::CORBA::Policy_ptr CORBA::_TAO_Policy_Remote_Proxy_Impl::copy (
-    CORBA_Object *_collocated_tao_target_
+    CORBA::Object *_collocated_tao_target_
     ACE_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((
@@ -1345,7 +1345,7 @@ return _tao_retval._retn ();
 }
 
 void CORBA::_TAO_Policy_Remote_Proxy_Impl::destroy (
-    CORBA_Object *_collocated_tao_target_
+    CORBA::Object *_collocated_tao_target_
     ACE_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((
@@ -1672,7 +1672,7 @@ CORBA::Boolean CORBA::Policy::_is_a (const CORBA::Char *value ACE_ENV_ARG_DECL)
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
   else
-    return this->CORBA_Object::_is_a (value ACE_ENV_ARG_PARAMETER);
+    return this->Object::_is_a (value ACE_ENV_ARG_PARAMETER);
 }
 
 void *CORBA::Policy::_tao_QueryInterface (ptr_arith_t type)
diff --git a/TAO/tao/PolicyC.h b/TAO/tao/PolicyC.h
index 0d8346ce943..43a3ac596e2 100644
--- a/TAO/tao/PolicyC.h
+++ b/TAO/tao/PolicyC.h
@@ -354,7 +354,7 @@ TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_InvalidPolicies;
   class _TAO_Policy_Remote_Proxy_Broker;
   
   class TAO_Export Policy
-    : public virtual CORBA_Object
+    : public virtual CORBA::Object
     // ****************************************************************
     , public virtual TAO_Encodable
     // ****************************************************************
@@ -469,7 +469,7 @@ TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_InvalidPolicies;
   public:
     virtual ~_TAO_Policy_Proxy_Impl (void) { }
     virtual CORBA::PolicyType policy_type (
-        CORBA_Object *_collocated_tao_target_
+        CORBA::Object *_collocated_tao_target_
         ACE_ENV_ARG_DECL
       )
       ACE_THROW_SPEC ((
@@ -477,7 +477,7 @@ TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_InvalidPolicies;
       )) = 0;
     
     virtual ::CORBA::Policy_ptr copy (
-        CORBA_Object *_collocated_tao_target_
+        CORBA::Object *_collocated_tao_target_
         ACE_ENV_ARG_DECL
       )
       ACE_THROW_SPEC ((
@@ -485,7 +485,7 @@ TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_InvalidPolicies;
       )) = 0;
     
     virtual void destroy (
-        CORBA_Object *_collocated_tao_target_
+        CORBA::Object *_collocated_tao_target_
         ACE_ENV_ARG_DECL
       )
       ACE_THROW_SPEC ((
@@ -515,7 +515,7 @@ TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_InvalidPolicies;
     
     virtual ~_TAO_Policy_Remote_Proxy_Impl (void) { }
     virtual CORBA::PolicyType policy_type (
-        CORBA_Object *_collocated_tao_target_
+        CORBA::Object *_collocated_tao_target_
         ACE_ENV_ARG_DECL
       )
       ACE_THROW_SPEC ((
@@ -523,7 +523,7 @@ TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_InvalidPolicies;
       ));
     
     virtual ::CORBA::Policy_ptr copy (
-        CORBA_Object *_collocated_tao_target_
+        CORBA::Object *_collocated_tao_target_
         ACE_ENV_ARG_DECL
       )
       ACE_THROW_SPEC ((
@@ -531,7 +531,7 @@ TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_InvalidPolicies;
       ));
     
     virtual void destroy (
-        CORBA_Object *_collocated_tao_target_
+        CORBA::Object *_collocated_tao_target_
         ACE_ENV_ARG_DECL
       )
       ACE_THROW_SPEC ((
@@ -700,7 +700,7 @@ TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_InvalidPolicies;
 #define _CORBA_POLICYMANAGER_CH_
   
   class TAO_Export PolicyManager
-    : public virtual CORBA_Object
+    : public virtual CORBA::Object
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
diff --git a/TAO/tao/PolicyC.i b/TAO/tao/PolicyC.i
index 5ee64975e3f..84183bc7916 100644
--- a/TAO/tao/PolicyC.i
+++ b/TAO/tao/PolicyC.i
@@ -213,7 +213,7 @@ CORBA::Policy::Policy (
     CORBA::Boolean _tao_collocated,
     TAO_Abstract_ServantBase *servant
   )
-  : CORBA_Object (objref, _tao_collocated, servant)
+  : Object (objref, _tao_collocated, servant)
 {
   this->CORBA_Policy_setup_collocation (_tao_collocated);
 }
diff --git a/TAO/tao/Principal.cpp b/TAO/tao/Principal.cpp
index 63e4ae4cfc8..ce31a26935c 100644
--- a/TAO/tao/Principal.cpp
+++ b/TAO/tao/Principal.cpp
@@ -11,19 +11,23 @@
 #include "tao/Principal.i"
 #endif /* __ACE_INLINE__ */
 
-ACE_RCSID(tao, Principal, "$Id$")
 
-CORBA_Principal::CORBA_Principal (void)
+ACE_RCSID (tao,
+           Principal,
+           "$Id$")
+
+
+CORBA::Principal::Principal (void)
   : refcount_ (1)
 {
 }
 
-CORBA_Principal::~CORBA_Principal (void)
+CORBA::Principal::~Principal (void)
 {
 }
 
 CORBA::Boolean
-operator<< (TAO_OutputCDR& cdr, CORBA_Principal* x)
+operator<< (TAO_OutputCDR& cdr, CORBA::Principal* x)
 {
   if (x != 0)
     {
@@ -39,7 +43,7 @@ operator<< (TAO_OutputCDR& cdr, CORBA_Principal* x)
 }
 
 CORBA::Boolean
-operator>> (TAO_InputCDR& cdr, CORBA_Principal*& x)
+operator>> (TAO_InputCDR& cdr, CORBA::Principal*& x)
 {
   CORBA::ULong length;
   cdr.read_ulong (length);
diff --git a/TAO/tao/Principal.h b/TAO/tao/Principal.h
index 0e318fd15b8..234be48bcef 100644
--- a/TAO/tao/Principal.h
+++ b/TAO/tao/Principal.h
@@ -6,10 +6,10 @@
  *
  *  $Id$
  *
- *  The CORBA_Principal pseudo-object implementation.
- *
+ *  The CORBA::Principal pseudo-object implementation.
  *
  *  @author  Copyright 1994-1995 by Sun Microsystems Inc.
+ *  @author  DOC group at Wash U and UCI.
  */
 //=============================================================================
 
@@ -27,133 +27,135 @@
 #include "OctetSeqC.h"
 #include "ace/Synch_T.h"
 
-/**
- * @class CORBA_Principal
- *
- * @brief A "Principal" identifies an authenticated entity in the
- * network administration framework.  Identities are used to
- * control acccess (authorization) as well as in audit trails
- * (accountability).
- */
-class TAO_Export CORBA_Principal
+namespace CORBA
 {
-public:
-  // To applications, the identifier is an opaque ID.
-
-  //  CORBA::SEQUENCE <CORBA::Octet> id;
-  CORBA::OctetSeq id;
-
-  // @@ add "==", "<", ">" operators
-
-  // The pseudo object operations.
-  static CORBA_Principal* _duplicate (CORBA_Principal*);
-  static CORBA_Principal* _nil (void);
-
-  // = Stuff required for memory management.
-  CORBA::ULong _incr_refcnt (void);
-  CORBA::ULong _decr_refcnt (void);
-
-  CORBA_Principal (void);
+  /**
+   * @class Principal
+   *
+   * @brief A "Principal" identifies an authenticated entity in the
+   * network administration framework.
+   *
+   * Identities are used to control acccess (authorization) as well as
+   * in audit trails (accountability).
+   *
+   * @note This CORBA feature has been deprecated by the OMG.  Use the
+   *       CORBA Security Service instead.
+   */
+  class TAO_Export Principal
+  {
+  public:
+    // To applications, the identifier is an opaque ID.
+
+    //  CORBA::SEQUENCE <CORBA::Octet> id;
+    CORBA::OctetSeq id;
+
+    // @@ add "==", "<", ">" operators
+
+    // The pseudo object operations.
+    static Principal* _duplicate (Principal*);
+    static Principal* _nil (void);
+
+    // = Stuff required for memory management.
+    CORBA::ULong _incr_refcnt (void);
+    CORBA::ULong _decr_refcnt (void);
+
+    Principal (void);
 
 #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-  typedef CORBA_Principal_ptr _ptr_type;
-  typedef CORBA_Principal_var _var_type;
+    typedef Principal_ptr _ptr_type;
+    typedef Principal_var _var_type;
 #endif /* __GNUC__ */
   // Useful for template programming.
 
-private:
-  ~CORBA_Principal (void);
-
-  // = these are not provided
-  CORBA_Principal &operator = (const CORBA::Principal_ptr &);
-  CORBA_Principal (const CORBA::Principal_ptr &);
-
-private:
-  /// Number of outstanding references to this object.
-  CORBA::ULong refcount_;
-
-  /// Protect the reference count, this is OK because we do no
-  /// duplicates or releases on the critical path.
-  TAO_SYNCH_MUTEX refcount_mutex_;
-
-#if defined (__GNUG__)
-  // G++ (even 2.6.3) stupidly thinks instances can't be created.
-  // This de-warns.
-  friend class everyone_needs_a_friend;
-#endif /* __GNUG__ */
-};
-
-/**
- * @class CORBA_Principal_var
- *
- * @brief The T_var class for Principal
- *
- * As any other pseudo object Principal must have a T_var class,
- * the interface an semantics are specified in the CORBA spec.
- * = NOTE
- * We use CORBA_Principal_ptr as the _ptr type instead of
- * CORBA::Principal_ptr, this is an attempt to reduced the cyclic
- * dependencies in TAO.
- */
-class TAO_Export CORBA_Principal_var
-{
-public:
-  CORBA_Principal_var (void);
-  CORBA_Principal_var (CORBA_Principal_ptr);
-  CORBA_Principal_var (const CORBA_Principal_var &);
-  ~CORBA_Principal_var (void);
-
-  CORBA_Principal_var &operator= (CORBA_Principal_ptr);
-  CORBA_Principal_var &operator= (const CORBA_Principal_var &);
-  CORBA_Principal_ptr operator-> (void) const;
-
-  /// in, inout, out, _retn
-  operator const CORBA_Principal_ptr &() const;
-  operator CORBA_Principal_ptr &();
-  CORBA_Principal_ptr in (void) const;
-  CORBA_Principal_ptr &inout (void);
-  CORBA_Principal_ptr &out (void);
-  CORBA_Principal_ptr _retn (void);
-  CORBA_Principal_ptr ptr (void) const;
-
-private:
-  CORBA_Principal_ptr ptr_;
-};
-
-/**
- * @class CORBA_Principal_out
- *
- * @brief The T_out class for Principal
- *
- * As any other pseudo object Principal must have a T_out class,
- * the interface an semantics are specified in the CORBA spec.
- * = NOTE
- * We use CORBA_Principal_ptr as the _ptr type instead of
- * CORBA::Principal_ptr, this is an attempt to reduced the cyclic
- * dependencies in TAO.
- */
-class TAO_Export CORBA_Principal_out
-{
-public:
-  CORBA_Principal_out (CORBA_Principal_ptr &);
-  CORBA_Principal_out (CORBA_Principal_var &);
-  CORBA_Principal_out (CORBA_Principal_out &);
-  CORBA_Principal_out &operator= (CORBA_Principal_out &);
-  CORBA_Principal_out &operator= (const CORBA_Principal_var &);
-  CORBA_Principal_out &operator= (CORBA_Principal_ptr);
-  operator CORBA_Principal_ptr &();
-  CORBA_Principal_ptr &ptr (void);
-  CORBA_Principal_ptr operator-> (void);
-
-private:
-  CORBA_Principal_ptr &ptr_;
-};
+  protected:
+
+    /// Destructor
+    /**
+     * Protected destructor to enforce proper memory management
+     * through the reference counting mechanism.
+     */
+    ~Principal (void);
+
+  private:
+
+    // = Prevent copying
+    Principal &operator = (const CORBA::Principal_ptr &);
+    Principal (const CORBA::Principal_ptr &);
+
+  private:
+    /// Number of outstanding references to this object.
+    CORBA::ULong refcount_;
+
+    /// Protect the reference count, this is OK because we do no
+    /// duplicates or releases on the critical path.
+    TAO_SYNCH_MUTEX refcount_mutex_;
+
+  };
+
+  /**
+   * @class Principal_var
+   *
+   * @brief The T_var class for CORBA::Principal
+   *
+   * As any other pseudo object Principal must have a T_var class,
+   * the interface an semantics are specified in the CORBA spec.
+   */
+  class TAO_Export Principal_var
+  {
+  public:
+    Principal_var (void);
+    Principal_var (Principal_ptr);
+    Principal_var (const Principal_var &);
+    ~Principal_var (void);
+
+    Principal_var &operator= (Principal_ptr);
+    Principal_var &operator= (const Principal_var &);
+    Principal_ptr operator-> (void) const;
+
+    /// in, inout, out, _retn
+    operator const Principal_ptr &() const;
+    operator Principal_ptr &();
+    Principal_ptr in (void) const;
+    Principal_ptr &inout (void);
+    Principal_ptr &out (void);
+    Principal_ptr _retn (void);
+    Principal_ptr ptr (void) const;
+
+  private:
+    Principal_ptr ptr_;
+  };
+
+  /**
+   * @class Principal_out
+   *
+   * @brief The T_out class for CORBA::Principal
+   *
+   * As any other pseudo object Principal must have a T_out class,
+   * the interface an semantics are specified in the CORBA spec.
+   */
+  class TAO_Export Principal_out
+  {
+  public:
+    Principal_out (Principal_ptr &);
+    Principal_out (Principal_var &);
+    Principal_out (Principal_out &);
+    Principal_out &operator= (Principal_out &);
+    Principal_out &operator= (const Principal_var &);
+    Principal_out &operator= (Principal_ptr);
+    operator Principal_ptr &();
+    Principal_ptr &ptr (void);
+    Principal_ptr operator-> (void);
+
+  private:
+    Principal_ptr &ptr_;
+  };
+}  // End CORBA namespace
 
 TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR&, CORBA_Principal*);
+operator<< (TAO_OutputCDR&, CORBA::Principal*);
 
 TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR&, CORBA_Principal*&);
+operator>> (TAO_InputCDR&, CORBA::Principal*&);
 
 #if defined (__ACE_INLINE__)
 # include "tao/Principal.i"
diff --git a/TAO/tao/Principal.i b/TAO/tao/Principal.i
index 03979d2bbb2..4ec85bcedd9 100644
--- a/TAO/tao/Principal.i
+++ b/TAO/tao/Principal.i
@@ -1,3 +1,5 @@
+// -*- C++ -*-
+//
 // $Id$
 
 ACE_INLINE CORBA::Boolean
@@ -7,7 +9,7 @@ CORBA::is_nil (CORBA::Principal_ptr principal)
 }
 
 ACE_INLINE CORBA::ULong
-CORBA_Principal::_decr_refcnt (void)
+CORBA::Principal::_decr_refcnt (void)
 {
   {
     this->refcount_--;
@@ -27,14 +29,14 @@ CORBA::release (CORBA::Principal_ptr principal)
 }
 
 ACE_INLINE CORBA::ULong
-CORBA_Principal::_incr_refcnt (void)
+CORBA::Principal::_incr_refcnt (void)
 {
   return this->refcount_++;
 }
 
 
-ACE_INLINE CORBA_Principal*
-CORBA_Principal::_duplicate (CORBA_Principal* x)
+ACE_INLINE CORBA::Principal*
+CORBA::Principal::_duplicate (CORBA::Principal* x)
 {
   if (x != 0)
     x->_incr_refcnt ();
@@ -42,169 +44,169 @@ CORBA_Principal::_duplicate (CORBA_Principal* x)
 }
 
 
-ACE_INLINE CORBA_Principal*
-CORBA_Principal::_nil (void)
+ACE_INLINE CORBA::Principal*
+CORBA::Principal::_nil (void)
 {
   return 0;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_Principal_var
+// Inline operations for class CORBA::Principal_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_Principal_var::CORBA_Principal_var (void)
-  : ptr_ (CORBA_Principal::_nil ())
+CORBA::Principal_var::Principal_var (void)
+  : ptr_ (CORBA::Principal::_nil ())
 {
 }
 
 ACE_INLINE
-CORBA_Principal_var::CORBA_Principal_var (CORBA_Principal_ptr p)
+CORBA::Principal_var::Principal_var (CORBA::Principal_ptr p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_Principal_var::~CORBA_Principal_var (void)
+CORBA::Principal_var::~Principal_var (void)
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_Principal_ptr
-CORBA_Principal_var::ptr (void) const
+ACE_INLINE CORBA::Principal_ptr
+CORBA::Principal_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_Principal_var::CORBA_Principal_var (const CORBA_Principal_var &p)
-  : ptr_ (CORBA_Principal::_duplicate (p.ptr ()))
+CORBA::Principal_var::Principal_var (const CORBA::Principal_var &p)
+  : ptr_ (CORBA::Principal::_duplicate (p.ptr ()))
 {}
 
-ACE_INLINE CORBA_Principal_var &
-CORBA_Principal_var::operator= (CORBA_Principal_ptr p)
+ACE_INLINE CORBA::Principal_var &
+CORBA::Principal_var::operator= (CORBA::Principal_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_Principal_var &
-CORBA_Principal_var::operator= (const CORBA_Principal_var &p)
+ACE_INLINE CORBA::Principal_var &
+CORBA::Principal_var::operator= (const CORBA::Principal_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_Principal::_duplicate (p.ptr ());
+    this->ptr_ = CORBA::Principal::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE
-CORBA_Principal_var::operator const CORBA_Principal_ptr &() const
+CORBA::Principal_var::operator const CORBA::Principal_ptr &() const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_Principal_var::operator CORBA_Principal_ptr &()
+CORBA::Principal_var::operator CORBA::Principal_ptr &()
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Principal_ptr
-CORBA_Principal_var::operator-> (void) const
+ACE_INLINE CORBA::Principal_ptr
+CORBA::Principal_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Principal_ptr
-CORBA_Principal_var::in (void) const
+ACE_INLINE CORBA::Principal_ptr
+CORBA::Principal_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Principal_ptr &
-CORBA_Principal_var::inout (void)
+ACE_INLINE CORBA::Principal_ptr &
+CORBA::Principal_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Principal_ptr &
-CORBA_Principal_var::out (void)
+ACE_INLINE CORBA::Principal_ptr &
+CORBA::Principal_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_Principal::_nil ();
+  this->ptr_ = CORBA::Principal::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Principal_ptr
-CORBA_Principal_var::_retn (void)
+ACE_INLINE CORBA::Principal_ptr
+CORBA::Principal_var::_retn (void)
 {
   // yield ownership
-  CORBA_Principal_ptr val = this->ptr_;
-  this->ptr_ = CORBA_Principal::_nil ();
+  CORBA::Principal_ptr val = this->ptr_;
+  this->ptr_ = CORBA::Principal::_nil ();
   return val;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_Principal_out
+// Inline operations for class CORBA::Principal_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_Principal_out::CORBA_Principal_out (CORBA_Principal_ptr &p)
+CORBA::Principal_out::Principal_out (CORBA::Principal_ptr &p)
         : ptr_ (p)
 {
-  this->ptr_ = CORBA_Principal::_nil ();
+  this->ptr_ = CORBA::Principal::_nil ();
 }
 
 ACE_INLINE
-CORBA_Principal_out::CORBA_Principal_out (CORBA_Principal_var &p)
+CORBA::Principal_out::Principal_out (CORBA::Principal_var &p)
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_Principal::_nil ();
+  this->ptr_ = CORBA::Principal::_nil ();
 }
 
 ACE_INLINE
-CORBA_Principal_out::CORBA_Principal_out (CORBA_Principal_out &p)
+CORBA::Principal_out::Principal_out (CORBA::Principal_out &p)
   : ptr_ (p.ptr_)
 {}
 
-ACE_INLINE CORBA_Principal_out &
-CORBA_Principal_out::operator= (CORBA_Principal_out &p)
+ACE_INLINE CORBA::Principal_out &
+CORBA::Principal_out::operator= (CORBA::Principal_out &p)
 {
   this->ptr_ = p.ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_Principal_out &
-CORBA_Principal_out::operator= (const CORBA_Principal_var &p)
+ACE_INLINE CORBA::Principal_out &
+CORBA::Principal_out::operator= (const CORBA::Principal_var &p)
 {
-  this->ptr_ = CORBA_Principal::_duplicate (p.ptr ());
+  this->ptr_ = CORBA::Principal::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_Principal_out &
-CORBA_Principal_out::operator= (CORBA_Principal_ptr p)
+ACE_INLINE CORBA::Principal_out &
+CORBA::Principal_out::operator= (CORBA::Principal_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE
-CORBA_Principal_out::operator CORBA_Principal_ptr &()
+CORBA::Principal_out::operator CORBA::Principal_ptr &()
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Principal_ptr &
-CORBA_Principal_out::ptr (void)
+ACE_INLINE CORBA::Principal_ptr &
+CORBA::Principal_out::ptr (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Principal_ptr
-CORBA_Principal_out::operator-> (void)
+ACE_INLINE CORBA::Principal_ptr
+CORBA::Principal_out::operator-> (void)
 {
   return this->ptr_;
 }
diff --git a/TAO/tao/Services.cpp b/TAO/tao/Services.cpp
index 0605075a92d..0274298a804 100644
--- a/TAO/tao/Services.cpp
+++ b/TAO/tao/Services.cpp
@@ -1,5 +1,4 @@
 //$Id$
-/* -*- C++ -*- */
 
 // ******  Code generated by the The ACE ORB (TAO) IDL Compiler *******
 // TAO and the TAO IDL Compiler have been developed by the Center for
@@ -394,7 +393,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ServiceInformatio
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_ServiceDetail::_tao_seq_Octet &_tao_sequence
+    const CORBA::ServiceDetail::_tao_seq_Octet &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -404,7 +403,7 @@ CORBA::Boolean operator<< (
 #if (TAO_NO_COPY_OCTET_SEQUENCES == 1)
     {
       TAO_Unbounded_Sequence<CORBA::Octet> *oseq =
-        ACE_dynamic_cast (TAO_Unbounded_Sequence<CORBA::Octet>*, (CORBA_ServiceDetail::_tao_seq_Octet *)&_tao_sequence);
+        ACE_dynamic_cast (TAO_Unbounded_Sequence<CORBA::Octet>*, (CORBA::ServiceDetail::_tao_seq_Octet *)&_tao_sequence);
       if (oseq->mb ())
         return strm.write_octet_array_mb (oseq->mb ());
       else
@@ -419,7 +418,7 @@ CORBA::Boolean operator<< (
   return 0; // error
 }
 
-CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ServiceDetail::_tao_seq_Octet &_tao_sequence)
+CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::ServiceDetail::_tao_seq_Octet &_tao_sequence)
 {
   CORBA::ULong _tao_seq_len;
   if (strm >> _tao_seq_len)
@@ -458,7 +457,7 @@ CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ServiceDetail::_tao_seq_Oct
 }
 
 CORBA::Boolean
-operator<< (TAO_OutputCDR &strm, const CORBA_ServiceDetail &_tao_aggregate)
+operator<< (TAO_OutputCDR &strm, const CORBA::ServiceDetail &_tao_aggregate)
 {
   if (
     (strm << _tao_aggregate.service_detail_type) &&
@@ -471,7 +470,7 @@ operator<< (TAO_OutputCDR &strm, const CORBA_ServiceDetail &_tao_aggregate)
 }
 
 CORBA::Boolean
-operator>> (TAO_InputCDR &strm, CORBA_ServiceDetail &_tao_aggregate)
+operator>> (TAO_InputCDR &strm, CORBA::ServiceDetail &_tao_aggregate)
 {
   if (
     (strm >> _tao_aggregate.service_detail_type) &&
@@ -486,7 +485,7 @@ operator>> (TAO_InputCDR &strm, CORBA_ServiceDetail &_tao_aggregate)
 CORBA::Boolean
 operator<< (
             TAO_OutputCDR &strm,
-            const CORBA_ServiceInformation::_tao_seq_ServiceOption &_tao_sequence
+            const CORBA::ServiceInformation::_tao_seq_ServiceOption &_tao_sequence
             )
 {
   if (strm << _tao_sequence.length ())
@@ -499,7 +498,7 @@ operator<< (
 
 CORBA::Boolean
 operator>> (TAO_InputCDR &strm,
-            CORBA_ServiceInformation::_tao_seq_ServiceOption &_tao_sequence)
+            CORBA::ServiceInformation::_tao_seq_ServiceOption &_tao_sequence)
 {
   CORBA::ULong _tao_seq_len;
   if (strm >> _tao_seq_len)
@@ -515,7 +514,7 @@ operator>> (TAO_InputCDR &strm,
 CORBA::Boolean
 operator<< (
             TAO_OutputCDR &strm,
-            const CORBA_ServiceInformation::_tao_seq_ServiceDetail &_tao_sequence
+            const CORBA::ServiceInformation::_tao_seq_ServiceDetail &_tao_sequence
             )
 {
   if (strm << _tao_sequence.length ())
@@ -531,7 +530,7 @@ operator<< (
 
 CORBA::Boolean
 operator>> (TAO_InputCDR &strm,
-            CORBA_ServiceInformation::_tao_seq_ServiceDetail &_tao_sequence)
+            CORBA::ServiceInformation::_tao_seq_ServiceDetail &_tao_sequence)
 {
   CORBA::ULong _tao_seq_len;
   if (strm >> _tao_seq_len)
@@ -549,7 +548,7 @@ operator>> (TAO_InputCDR &strm,
 
 CORBA::Boolean
 operator<< (TAO_OutputCDR &strm,
-            const CORBA_ServiceInformation &_tao_aggregate)
+            const CORBA::ServiceInformation &_tao_aggregate)
 {
   if (
     (strm << _tao_aggregate.service_options) &&
@@ -562,7 +561,7 @@ operator<< (TAO_OutputCDR &strm,
 }
 
 CORBA::Boolean operator>> (TAO_InputCDR &strm,
-                           CORBA_ServiceInformation &_tao_aggregate)
+                           CORBA::ServiceInformation &_tao_aggregate)
 {
   if (
     (strm >> _tao_aggregate.service_options) &&
diff --git a/TAO/tao/Services.h b/TAO/tao/Services.h
index 221ad5054f2..3f556d4000f 100644
--- a/TAO/tao/Services.h
+++ b/TAO/tao/Services.h
@@ -1,14 +1,13 @@
+// -*- C++ -*-
+
 //=============================================================================
 /**
  *  @file    Services.h
  *
  *  $Id$
  *
- *
  *  Service_Detail stubs. This code generated by the The ACE ORB (TAO) IDL
  *  Compiler and was then hand crafted
- *
- *
  */
 //=============================================================================
 
@@ -30,21 +29,30 @@
 #pragma warning(disable:4250)
 #endif /* _MSC_VER */
 
-struct TAO_Export CORBA_ServiceDetail
+namespace CORBA
 {
-  static void _tao_any_destructor (void*);
+  /**
+   * @class ServiceDetail
+   *
+   * @brief CORBA::ServiceDetail implementation.
+   *
+   * CORBA::ServiceDetail implementation.
+   */
+  struct TAO_Export ServiceDetail
+  {
+    static void _tao_any_destructor (void*);
 
-  CORBA::ServiceDetailType service_detail_type;
+    CORBA::ServiceDetailType service_detail_type;
 
 #if !defined (_CORBA_SERVICEDETAIL__TAO_SEQ_OCTET_CH_)
 #define _CORBA_SERVICEDETAIL__TAO_SEQ_OCTET_CH_
 
-  // *************************************************************
-  // _tao_seq_Octet
-  // *************************************************************
+    // *************************************************************
+    // _tao_seq_Octet
+    // *************************************************************
 
-  class  _tao_seq_Octet : public TAO_Unbounded_Sequence<CORBA::Octet>
-  {
+    class  _tao_seq_Octet : public TAO_Unbounded_Sequence<CORBA::Octet>
+    {
     public:
       _tao_seq_Octet (void); // default ctor
       _tao_seq_Octet (CORBA::ULong max); // uses max size
@@ -66,17 +74,17 @@ struct TAO_Export CORBA_ServiceDetail
 #endif /* TAO_NO_COPY_OCTET_SEQUENCE == 1 */
     };
 
-  static CORBA::TypeCode_ptr _tc__tao_seq_Octet;
+    static CORBA::TypeCode_ptr _tc__tao_seq_Octet;
 #endif /* end #if !defined */
 
 #if !defined (_CORBA_SERVICEDETAIL__TAO_SEQ_OCTET___VAR_CH_)
 #define _CORBA_SERVICEDETAIL__TAO_SEQ_OCTET___VAR_CH_
 
-  // *************************************************************
-  // class CORBA::ServiceDetail::_tao_seq_Octet_var
-  // *************************************************************
+    // *************************************************************
+    // class CORBA::ServiceDetail::_tao_seq_Octet_var
+    // *************************************************************
 
-  class  _tao_seq_Octet_var
+    class  _tao_seq_Octet_var
     {
     public:
       _tao_seq_Octet_var (void); // default constructor
@@ -133,63 +141,63 @@ struct TAO_Export CORBA_ServiceDetail
 #endif /* end #if !defined */
 
     _tao_seq_Octet service_detail;
-};
+  };
 
-class  CORBA_ServiceDetail_var
-{
- public:
-  CORBA_ServiceDetail_var (void); // default constructor
-  CORBA_ServiceDetail_var (CORBA_ServiceDetail *);
-  CORBA_ServiceDetail_var (const CORBA_ServiceDetail_var &); // copy constructor
-  ~CORBA_ServiceDetail_var (void); // destructor
-
-  CORBA_ServiceDetail_var &operator= (CORBA_ServiceDetail *);
-  CORBA_ServiceDetail_var &operator= (const CORBA_ServiceDetail_var &);
-  CORBA_ServiceDetail *operator-> (void);
-  const CORBA_ServiceDetail *operator-> (void) const;
-
-  /// in, inout, out, _retn
-  operator const CORBA_ServiceDetail &() const;
-  operator CORBA_ServiceDetail &();
-  operator CORBA_ServiceDetail &() const;
-  const CORBA_ServiceDetail &in (void) const;
-  CORBA_ServiceDetail &inout (void);
-  CORBA_ServiceDetail *&out (void);
-  CORBA_ServiceDetail *_retn (void);
-  CORBA_ServiceDetail *ptr (void) const;
-
- private:
-  CORBA_ServiceDetail *ptr_;
-};
-
-class  CORBA_ServiceDetail_out
-{
- public:
-  CORBA_ServiceDetail_out (CORBA_ServiceDetail *&);
-  CORBA_ServiceDetail_out (CORBA_ServiceDetail_var &);
-  CORBA_ServiceDetail_out (const CORBA_ServiceDetail_out &);
-  CORBA_ServiceDetail_out &operator= (const CORBA_ServiceDetail_out &);
-  CORBA_ServiceDetail_out &operator= (CORBA_ServiceDetail *);
-  operator CORBA_ServiceDetail *&();
-  CORBA_ServiceDetail *&ptr (void);
-  CORBA_ServiceDetail *operator-> (void);
-
- private:
-  /// assignment from T_var not allowed
-  CORBA_ServiceDetail *&ptr_;
-  void operator= (const CORBA_ServiceDetail_var &);
-};
-
-struct  CORBA_ServiceInformation
-{
-  static void _tao_any_destructor (void*);
+  class ServiceDetail_var
+  {
+  public:
+    ServiceDetail_var (void); // default constructor
+    ServiceDetail_var (ServiceDetail *);
+    ServiceDetail_var (const ServiceDetail_var &); // copy constructor
+    ~ServiceDetail_var (void); // destructor
+
+    ServiceDetail_var &operator= (ServiceDetail *);
+    ServiceDetail_var &operator= (const ServiceDetail_var &);
+    ServiceDetail *operator-> (void);
+    const ServiceDetail *operator-> (void) const;
+
+    /// in, inout, out, _retn
+    operator const ServiceDetail &() const;
+    operator ServiceDetail &();
+    operator ServiceDetail &() const;
+    const ServiceDetail &in (void) const;
+    ServiceDetail &inout (void);
+    ServiceDetail *&out (void);
+    ServiceDetail *_retn (void);
+    ServiceDetail *ptr (void) const;
+
+  private:
+    ServiceDetail *ptr_;
+  };
+
+  class  ServiceDetail_out
+  {
+  public:
+    ServiceDetail_out (ServiceDetail *&);
+    ServiceDetail_out (ServiceDetail_var &);
+    ServiceDetail_out (const ServiceDetail_out &);
+    ServiceDetail_out &operator= (const ServiceDetail_out &);
+    ServiceDetail_out &operator= (ServiceDetail *);
+    operator ServiceDetail *&();
+    ServiceDetail *&ptr (void);
+    ServiceDetail *operator-> (void);
+
+  private:
+    /// assignment from T_var not allowed
+    ServiceDetail *&ptr_;
+    void operator= (const ServiceDetail_var &);
+  };
+
+  struct  ServiceInformation
+  {
+    static void _tao_any_destructor (void*);
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
 
 #if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEOPTION_CH_)
 #define __TAO_UNBOUNDED_SEQUENCE_CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEOPTION_CH_
 
-  class _TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption : public TAO_Unbounded_Base_Sequence
+    class _TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption : public TAO_Unbounded_Base_Sequence
     {
     public:
       // = Initialization and termination methods.
@@ -234,7 +242,7 @@ struct  CORBA_ServiceInformation
   // _tao_seq_ServiceOption
   // *************************************************************
 
-  class  _tao_seq_ServiceOption : public
+    class  _tao_seq_ServiceOption : public
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
@@ -253,8 +261,8 @@ struct  CORBA_ServiceInformation
       _tao_seq_ServiceOption (const _tao_seq_ServiceOption &); // copy ctor
       ~_tao_seq_ServiceOption (void); // dtor
     };
-  typedef _tao_seq_ServiceOption *_tao_seq_ServiceOption_ptr;
-  static CORBA::TypeCode_ptr _tc__tao_seq_ServiceOption;
+    typedef _tao_seq_ServiceOption *_tao_seq_ServiceOption_ptr;
+    static CORBA::TypeCode_ptr _tc__tao_seq_ServiceOption;
 
 
 #endif /* end #if !defined */
@@ -263,11 +271,11 @@ struct  CORBA_ServiceInformation
 #if !defined (_CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEOPTION___VAR_CH_)
 #define _CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEOPTION___VAR_CH_
 
-  // *************************************************************
-  // class CORBA::ServiceInformation::_tao_seq_ServiceOption_var
-  // *************************************************************
+    // *************************************************************
+    // class CORBA::ServiceInformation::_tao_seq_ServiceOption_var
+    // *************************************************************
 
-  class  _tao_seq_ServiceOption_var
+    class  _tao_seq_ServiceOption_var
     {
     public:
       _tao_seq_ServiceOption_var (void); // default constructor
@@ -301,7 +309,7 @@ struct  CORBA_ServiceInformation
 #if !defined (_CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEOPTION___OUT_CH_)
 #define _CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEOPTION___OUT_CH_
 
-  class  _tao_seq_ServiceOption_out
+    class  _tao_seq_ServiceOption_out
     {
     public:
       _tao_seq_ServiceOption_out (_tao_seq_ServiceOption *&);
@@ -322,14 +330,14 @@ struct  CORBA_ServiceInformation
 
 #endif /* end #if !defined */
 
-  _tao_seq_ServiceOption service_options;
+    _tao_seq_ServiceOption service_options;
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
 
 #if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEDETAIL_CH_)
 #define __TAO_UNBOUNDED_SEQUENCE_CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEDETAIL_CH_
 
-  class _TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail : public TAO_Unbounded_Base_Sequence
+    class _TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail : public TAO_Unbounded_Base_Sequence
     {
     public:
       // = Initialization and termination methods.
@@ -338,26 +346,26 @@ struct  CORBA_ServiceInformation
       _TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail (CORBA::ULong maximum);
       _TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail (CORBA::ULong maximum,
                                                                                CORBA::ULong length,
-                                                                               CORBA_ServiceDetail *data,
+                                                                               CORBA::ServiceDetail *data,
                                                                                CORBA::Boolean release = 0);
       _TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail (const _TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail & rhs);
       _TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail &operator= (const _TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail &rhs);
       virtual ~_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail (void); // Dtor.
       // = Accessors.
-      CORBA_ServiceDetail &operator[] (CORBA::ULong i);
-      const CORBA_ServiceDetail &operator[] (CORBA::ULong i) const;
+      CORBA::ServiceDetail &operator[] (CORBA::ULong i);
+      const CORBA::ServiceDetail &operator[] (CORBA::ULong i) const;
       // = Static operations.
-      static CORBA_ServiceDetail *allocbuf (CORBA::ULong size);
-      static void freebuf (CORBA_ServiceDetail *buffer);
+      static CORBA::ServiceDetail *allocbuf (CORBA::ULong size);
+      static void freebuf (CORBA::ServiceDetail *buffer);
       virtual void _allocate_buffer (CORBA::ULong length);
       virtual void _deallocate_buffer (void);
       // Implement the TAO_Base_Sequence methods (see Sequence.h)
 
-      CORBA_ServiceDetail *get_buffer (CORBA::Boolean orphan = 0);
-      const CORBA_ServiceDetail *get_buffer (void) const;
+      CORBA::ServiceDetail *get_buffer (CORBA::Boolean orphan = 0);
+      const CORBA::ServiceDetail *get_buffer (void) const;
       void replace (CORBA::ULong max,
                     CORBA::ULong length,
-                    CORBA_ServiceDetail *data,
+                    CORBA::ServiceDetail *data,
                     CORBA::Boolean release);
     };
 
@@ -368,15 +376,15 @@ struct  CORBA_ServiceInformation
 #if !defined (_CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEDETAIL_CH_)
 #define _CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEDETAIL_CH_
 
-  // *************************************************************
-  // _tao_seq_ServiceDetail
-  // *************************************************************
+    // *************************************************************
+    // _tao_seq_ServiceDetail
+    // *************************************************************
 
-  class  _tao_seq_ServiceDetail : public
+    class  _tao_seq_ServiceDetail : public
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail
+    _TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_ServiceDetail>
+    TAO_Unbounded_Sequence<CORBA::ServiceDetail>
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */
     {
     public:
@@ -385,7 +393,7 @@ struct  CORBA_ServiceInformation
       _tao_seq_ServiceDetail (
                               CORBA::ULong max,
                               CORBA::ULong length,
-                              CORBA_ServiceDetail *buffer,
+                              CORBA::ServiceDetail *buffer,
                               CORBA::Boolean release=0
                               );
       _tao_seq_ServiceDetail (const _tao_seq_ServiceDetail &); // copy ctor
@@ -400,11 +408,11 @@ struct  CORBA_ServiceInformation
 #if !defined (_CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEDETAIL___VAR_CH_)
 #define _CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEDETAIL___VAR_CH_
 
-  // *************************************************************
-  // class CORBA::ServiceInformation::_tao_seq_ServiceDetail_var
-  // *************************************************************
+    // *************************************************************
+    // class CORBA::ServiceInformation::_tao_seq_ServiceDetail_var
+    // *************************************************************
 
-  class  _tao_seq_ServiceDetail_var
+    class  _tao_seq_ServiceDetail_var
     {
     public:
       _tao_seq_ServiceDetail_var (void); // default constructor
@@ -420,7 +428,7 @@ struct  CORBA_ServiceInformation
       operator const _tao_seq_ServiceDetail &() const;
       operator _tao_seq_ServiceDetail &();
       operator _tao_seq_ServiceDetail &() const;
-      CORBA_ServiceDetail &operator[] (CORBA::ULong slot);
+      CORBA::ServiceDetail &operator[] (CORBA::ULong slot);
       // in, inout, out, _retn
       const _tao_seq_ServiceDetail &in (void) const;
       _tao_seq_ServiceDetail &inout (void);
@@ -439,7 +447,7 @@ struct  CORBA_ServiceInformation
 #if !defined (_CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEDETAIL___OUT_CH_)
 #define _CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEDETAIL___OUT_CH_
 
-  class  _tao_seq_ServiceDetail_out
+    class  _tao_seq_ServiceDetail_out
     {
     public:
       _tao_seq_ServiceDetail_out (_tao_seq_ServiceDetail *&);
@@ -450,7 +458,7 @@ struct  CORBA_ServiceInformation
       operator _tao_seq_ServiceDetail *&();
       _tao_seq_ServiceDetail *&ptr (void);
       _tao_seq_ServiceDetail *operator-> (void);
-      CORBA_ServiceDetail &operator[] (CORBA::ULong slot);
+      CORBA::ServiceDetail &operator[] (CORBA::ULong slot);
 
     private:
       _tao_seq_ServiceDetail *&ptr_;
@@ -462,74 +470,74 @@ struct  CORBA_ServiceInformation
 #endif /* end #if !defined */
 
     _tao_seq_ServiceDetail service_details;
-};
+  };
 
 
-class  CORBA_ServiceInformation_var
-{
- public:
-  CORBA_ServiceInformation_var (void); // default constructor
-  CORBA_ServiceInformation_var (CORBA_ServiceInformation *);
-  CORBA_ServiceInformation_var (const CORBA_ServiceInformation_var &); // copy constructor
-  ~CORBA_ServiceInformation_var (void); // destructor
-
-  CORBA_ServiceInformation_var &operator= (CORBA_ServiceInformation *);
-  CORBA_ServiceInformation_var &operator= (const CORBA_ServiceInformation_var &);
-  CORBA_ServiceInformation *operator-> (void);
-  const CORBA_ServiceInformation *operator-> (void) const;
-
-  /// in, inout, out, _retn
-  operator const CORBA_ServiceInformation &() const;
-  operator CORBA_ServiceInformation &();
-  operator CORBA_ServiceInformation &() const;
-  const CORBA_ServiceInformation &in (void) const;
-  CORBA_ServiceInformation &inout (void);
-  CORBA_ServiceInformation *&out (void);
-  CORBA_ServiceInformation *_retn (void);
-  CORBA_ServiceInformation *ptr (void) const;
-
- private:
-  CORBA_ServiceInformation *ptr_;
-};
-
-class  CORBA_ServiceInformation_out
-{
- public:
-  CORBA_ServiceInformation_out (CORBA_ServiceInformation *&);
-  CORBA_ServiceInformation_out (CORBA_ServiceInformation_var &);
-  CORBA_ServiceInformation_out (const CORBA_ServiceInformation_out &);
-  CORBA_ServiceInformation_out &operator= (const CORBA_ServiceInformation_out &);
-  CORBA_ServiceInformation_out &operator= (CORBA_ServiceInformation *);
-
-  operator CORBA_ServiceInformation *&();
-  CORBA_ServiceInformation *&ptr (void);
-  CORBA_ServiceInformation *operator-> (void);
-
- private:
-  /// assignment from T_var not allowed
-  CORBA_ServiceInformation *&ptr_;
-  void operator= (const CORBA_ServiceInformation_var &);
-};
-
+  class ServiceInformation_var
+  {
+  public:
+    ServiceInformation_var (void); // default constructor
+    ServiceInformation_var (ServiceInformation *);
+    ServiceInformation_var (const ServiceInformation_var &); // copy constructor
+    ~ServiceInformation_var (void); // destructor
+
+    ServiceInformation_var &operator= (ServiceInformation *);
+    ServiceInformation_var &operator= (const ServiceInformation_var &);
+    ServiceInformation *operator-> (void);
+    const ServiceInformation *operator-> (void) const;
+
+    /// in, inout, out, _retn
+    operator const ServiceInformation &() const;
+    operator ServiceInformation &();
+    operator ServiceInformation &() const;
+    const ServiceInformation &in (void) const;
+    ServiceInformation &inout (void);
+    ServiceInformation *&out (void);
+    ServiceInformation *_retn (void);
+    ServiceInformation *ptr (void) const;
+
+  private:
+    ServiceInformation *ptr_;
+  };
+
+  class  ServiceInformation_out
+  {
+  public:
+    ServiceInformation_out (ServiceInformation *&);
+    ServiceInformation_out (ServiceInformation_var &);
+    ServiceInformation_out (const ServiceInformation_out &);
+    ServiceInformation_out &operator= (const ServiceInformation_out &);
+    ServiceInformation_out &operator= (ServiceInformation *);
+
+    operator ServiceInformation *&();
+    ServiceInformation *&ptr (void);
+    ServiceInformation *operator-> (void);
+
+  private:
+    /// assignment from T_var not allowed
+    ServiceInformation *&ptr_;
+    void operator= (const ServiceInformation_var &);
+  };
+}  // End namespace CORBA
 
 void  operator<<= (CORBA::Any &, const CORBA::ServiceDetail &); // copying version
 void  operator<<= (CORBA::Any &, CORBA::ServiceDetail*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ServiceDetail *&);
-void  operator<<= (CORBA::Any &, const CORBA_ServiceInformation &); // copying version
-void  operator<<= (CORBA::Any &, CORBA_ServiceInformation*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA_ServiceInformation *&);
-
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA_ServiceDetail &); //
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA_ServiceDetail &);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA_ServiceDetail::_tao_seq_Octet &); //
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA_ServiceDetail::_tao_seq_Octet &);
-
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA_ServiceInformation &);
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA_ServiceInformation &);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA_ServiceInformation::_tao_seq_ServiceOption &);
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA_ServiceInformation::_tao_seq_ServiceOption &);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA_ServiceInformation::_tao_seq_ServiceDetail &);
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA_ServiceInformation::_tao_seq_ServiceDetail &);
+  CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ServiceDetail *&);
+void  operator<<= (CORBA::Any &, const CORBA::ServiceInformation &); // copying version
+void  operator<<= (CORBA::Any &, CORBA::ServiceInformation*); // noncopying version
+CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ServiceInformation *&);
+
+CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ServiceDetail &); //
+CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ServiceDetail &);
+CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ServiceDetail::_tao_seq_Octet &); //
+CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ServiceDetail::_tao_seq_Octet &);
+
+CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ServiceInformation &);
+CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ServiceInformation &);
+CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ServiceInformation::_tao_seq_ServiceOption &);
+CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ServiceInformation::_tao_seq_ServiceOption &);
+CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ServiceInformation::_tao_seq_ServiceDetail &);
+CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ServiceInformation::_tao_seq_ServiceDetail &);
 
 #if defined (__ACE_INLINE__)
 #include "tao/Services.i"
diff --git a/TAO/tao/Services.i b/TAO/tao/Services.i
index 4ed4a386630..564b983801b 100644
--- a/TAO/tao/Services.i
+++ b/TAO/tao/Services.i
@@ -1,5 +1,6 @@
+// -*- C++ -*-
+//
 //$Id$
-/* -*- C++ -*- */
 
 // ******  Code generated by the The ACE ORB (TAO) IDL Compiler *******
 // TAO and the TAO IDL Compiler have been developed by the Center for
@@ -13,110 +14,110 @@
 // *************************************************************
 
 ACE_INLINE
-CORBA_ServiceDetail_var::CORBA_ServiceDetail_var (void) // default constructor
+CORBA::ServiceDetail_var::ServiceDetail_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_ServiceDetail_var::CORBA_ServiceDetail_var ( CORBA_ServiceDetail *p)
+CORBA::ServiceDetail_var::ServiceDetail_var ( CORBA::ServiceDetail *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
- CORBA_ServiceDetail_var::CORBA_ServiceDetail_var (const  CORBA_ServiceDetail_var &p) // copy constructor
+CORBA::ServiceDetail_var::ServiceDetail_var (const  CORBA::ServiceDetail_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new  CORBA_ServiceDetail(*p.ptr_);
+    this->ptr_ = new  CORBA::ServiceDetail(*p.ptr_);
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
- CORBA_ServiceDetail_var::~CORBA_ServiceDetail_var (void) // destructor
+ CORBA::ServiceDetail_var::~ServiceDetail_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE  CORBA_ServiceDetail_var &
- CORBA_ServiceDetail_var::operator= ( CORBA_ServiceDetail *p)
+ACE_INLINE  CORBA::ServiceDetail_var &
+ CORBA::ServiceDetail_var::operator= ( CORBA::ServiceDetail *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE  CORBA_ServiceDetail_var &
- CORBA_ServiceDetail_var::operator= (const  CORBA_ServiceDetail_var &p)
+ACE_INLINE  CORBA::ServiceDetail_var &
+ CORBA::ServiceDetail_var::operator= (const  CORBA::ServiceDetail_var &p)
 {
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new  CORBA_ServiceDetail (*p.ptr_);
+    this->ptr_ = new  CORBA::ServiceDetail (*p.ptr_);
   }
   return *this;
 }
 
-ACE_INLINE const  CORBA_ServiceDetail *
- CORBA_ServiceDetail_var::operator-> (void) const
+ACE_INLINE const  CORBA::ServiceDetail *
+ CORBA::ServiceDetail_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE  CORBA_ServiceDetail *
- CORBA_ServiceDetail_var::operator-> (void)
+ACE_INLINE  CORBA::ServiceDetail *
+ CORBA::ServiceDetail_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
- CORBA_ServiceDetail_var::operator const  CORBA_ServiceDetail &() const // cast
+ CORBA::ServiceDetail_var::operator const  CORBA::ServiceDetail &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
- CORBA_ServiceDetail_var::operator  CORBA_ServiceDetail &() // cast 
+ CORBA::ServiceDetail_var::operator  CORBA::ServiceDetail &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
- CORBA_ServiceDetail_var::operator  CORBA_ServiceDetail &() const// cast 
+ CORBA::ServiceDetail_var::operator  CORBA::ServiceDetail &() const// cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE const  CORBA_ServiceDetail &
- CORBA_ServiceDetail_var::in (void) const
+ACE_INLINE const  CORBA::ServiceDetail &
+ CORBA::ServiceDetail_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE  CORBA_ServiceDetail &
- CORBA_ServiceDetail_var::inout (void)
+ACE_INLINE  CORBA::ServiceDetail &
+ CORBA::ServiceDetail_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE  CORBA_ServiceDetail *&
- CORBA_ServiceDetail_var::out (void)
+ACE_INLINE  CORBA::ServiceDetail *&
+ CORBA::ServiceDetail_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE  CORBA_ServiceDetail *
- CORBA_ServiceDetail_var::_retn (void)
+ACE_INLINE  CORBA::ServiceDetail *
+ CORBA::ServiceDetail_var::_retn (void)
 {
-   CORBA_ServiceDetail *tmp = this->ptr_;
+   CORBA::ServiceDetail *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE  CORBA_ServiceDetail *
- CORBA_ServiceDetail_var::ptr (void) const
+ACE_INLINE  CORBA::ServiceDetail *
+ CORBA::ServiceDetail_var::ptr (void) const
 {
   return this->ptr_;
 }
@@ -126,14 +127,14 @@ ACE_INLINE  CORBA_ServiceDetail *
 // *************************************************************
 
 ACE_INLINE
- CORBA_ServiceDetail_out::CORBA_ServiceDetail_out ( CORBA_ServiceDetail *&p)
+ CORBA::ServiceDetail_out::ServiceDetail_out ( CORBA::ServiceDetail *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
- CORBA_ServiceDetail_out::CORBA_ServiceDetail_out ( CORBA_ServiceDetail_var &p) // constructor from _var
+ CORBA::ServiceDetail_out::ServiceDetail_out ( CORBA::ServiceDetail_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -141,38 +142,38 @@ ACE_INLINE
 }
 
 ACE_INLINE
- CORBA_ServiceDetail_out::CORBA_ServiceDetail_out (const  CORBA_ServiceDetail_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ServiceDetail_out&,p).ptr_)
+ CORBA::ServiceDetail_out::ServiceDetail_out (const  CORBA::ServiceDetail_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA::ServiceDetail_out&,p).ptr_)
 {}
 
-ACE_INLINE  CORBA_ServiceDetail_out &
- CORBA_ServiceDetail_out::operator= (const  CORBA_ServiceDetail_out &p)
+ACE_INLINE  CORBA::ServiceDetail_out &
+ CORBA::ServiceDetail_out::operator= (const  CORBA::ServiceDetail_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ServiceDetail_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (CORBA::ServiceDetail_out&,p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ServiceDetail_out &
-CORBA_ServiceDetail_out::operator= (CORBA_ServiceDetail *p)
+ACE_INLINE CORBA::ServiceDetail_out &
+CORBA::ServiceDetail_out::operator= (CORBA::ServiceDetail *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ServiceDetail_out::operator CORBA_ServiceDetail *&() // cast
+CORBA::ServiceDetail_out::operator CORBA::ServiceDetail *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceDetail *&
-CORBA_ServiceDetail_out::ptr (void) // ptr
+ACE_INLINE CORBA::ServiceDetail *&
+CORBA::ServiceDetail_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceDetail *
-CORBA_ServiceDetail_out::operator-> (void)
+ACE_INLINE CORBA::ServiceDetail *
+CORBA::ServiceDetail_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -185,116 +186,116 @@ CORBA_ServiceDetail_out::operator-> (void)
 // *************************************************************
 
 ACE_INLINE
-CORBA_ServiceDetail::_tao_seq_Octet_var::_tao_seq_Octet_var (void) // default constructor
+CORBA::ServiceDetail::_tao_seq_Octet_var::_tao_seq_Octet_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_ServiceDetail::_tao_seq_Octet_var::_tao_seq_Octet_var (CORBA_ServiceDetail::_tao_seq_Octet *p)
+CORBA::ServiceDetail::_tao_seq_Octet_var::_tao_seq_Octet_var (CORBA::ServiceDetail::_tao_seq_Octet *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_ServiceDetail::_tao_seq_Octet_var::_tao_seq_Octet_var (const CORBA_ServiceDetail::_tao_seq_Octet_var &p) // copy constructor
+CORBA::ServiceDetail::_tao_seq_Octet_var::_tao_seq_Octet_var (const CORBA::ServiceDetail::_tao_seq_Octet_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_ServiceDetail::_tao_seq_Octet(*p.ptr_);
+    this->ptr_ = new CORBA::ServiceDetail::_tao_seq_Octet(*p.ptr_);
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ServiceDetail::_tao_seq_Octet_var::~_tao_seq_Octet_var (void) // destructor
+CORBA::ServiceDetail::_tao_seq_Octet_var::~_tao_seq_Octet_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceDetail::_tao_seq_Octet_var &
-CORBA_ServiceDetail::_tao_seq_Octet_var::operator= (CORBA_ServiceDetail::_tao_seq_Octet *p)
+ACE_INLINE CORBA::ServiceDetail::_tao_seq_Octet_var &
+CORBA::ServiceDetail::_tao_seq_Octet_var::operator= (CORBA::ServiceDetail::_tao_seq_Octet *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ServiceDetail::_tao_seq_Octet_var &
-CORBA_ServiceDetail::_tao_seq_Octet_var::operator= (const CORBA_ServiceDetail::_tao_seq_Octet_var &p) // deep copy
+ACE_INLINE CORBA::ServiceDetail::_tao_seq_Octet_var &
+CORBA::ServiceDetail::_tao_seq_Octet_var::operator= (const CORBA::ServiceDetail::_tao_seq_Octet_var &p) // deep copy
 {
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_ServiceDetail::_tao_seq_Octet (*p.ptr_);
+    this->ptr_ = new CORBA::ServiceDetail::_tao_seq_Octet (*p.ptr_);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_ServiceDetail::_tao_seq_Octet *
-CORBA_ServiceDetail::_tao_seq_Octet_var::operator-> (void) const
+ACE_INLINE const CORBA::ServiceDetail::_tao_seq_Octet *
+CORBA::ServiceDetail::_tao_seq_Octet_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceDetail::_tao_seq_Octet *
-CORBA_ServiceDetail::_tao_seq_Octet_var::operator-> (void)
+ACE_INLINE CORBA::ServiceDetail::_tao_seq_Octet *
+CORBA::ServiceDetail::_tao_seq_Octet_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ServiceDetail::_tao_seq_Octet_var::operator const CORBA_ServiceDetail::_tao_seq_Octet &() const // cast
+CORBA::ServiceDetail::_tao_seq_Octet_var::operator const CORBA::ServiceDetail::_tao_seq_Octet &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ServiceDetail::_tao_seq_Octet_var::operator CORBA_ServiceDetail::_tao_seq_Octet &() // cast 
+CORBA::ServiceDetail::_tao_seq_Octet_var::operator CORBA::ServiceDetail::_tao_seq_Octet &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ServiceDetail::_tao_seq_Octet_var::operator CORBA_ServiceDetail::_tao_seq_Octet &() const// cast 
+CORBA::ServiceDetail::_tao_seq_Octet_var::operator CORBA::ServiceDetail::_tao_seq_Octet &() const// cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE CORBA::Octet &
-CORBA_ServiceDetail::_tao_seq_Octet_var::operator[] (CORBA::ULong slot)
+CORBA::ServiceDetail::_tao_seq_Octet_var::operator[] (CORBA::ULong slot)
 {
   return this->ptr_->operator[] (slot);
 }
 
-ACE_INLINE const CORBA_ServiceDetail::_tao_seq_Octet &
-CORBA_ServiceDetail::_tao_seq_Octet_var::in (void) const
+ACE_INLINE const CORBA::ServiceDetail::_tao_seq_Octet &
+CORBA::ServiceDetail::_tao_seq_Octet_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceDetail::_tao_seq_Octet &
-CORBA_ServiceDetail::_tao_seq_Octet_var::inout (void)
+ACE_INLINE CORBA::ServiceDetail::_tao_seq_Octet &
+CORBA::ServiceDetail::_tao_seq_Octet_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_ServiceDetail::_tao_seq_Octet *&
-CORBA_ServiceDetail::_tao_seq_Octet_var::out (void)
+ACE_INLINE CORBA::ServiceDetail::_tao_seq_Octet *&
+CORBA::ServiceDetail::_tao_seq_Octet_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceDetail::_tao_seq_Octet *
-CORBA_ServiceDetail::_tao_seq_Octet_var::_retn (void)
+ACE_INLINE CORBA::ServiceDetail::_tao_seq_Octet *
+CORBA::ServiceDetail::_tao_seq_Octet_var::_retn (void)
 {
-  CORBA_ServiceDetail::_tao_seq_Octet *tmp = this->ptr_;
+  CORBA::ServiceDetail::_tao_seq_Octet *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_ServiceDetail::_tao_seq_Octet *
-CORBA_ServiceDetail::_tao_seq_Octet_var::ptr (void) const
+ACE_INLINE CORBA::ServiceDetail::_tao_seq_Octet *
+CORBA::ServiceDetail::_tao_seq_Octet_var::ptr (void) const
 {
   return this->ptr_;
 }
@@ -304,14 +305,14 @@ CORBA_ServiceDetail::_tao_seq_Octet_var::ptr (void) const
 // *************************************************************
 
 ACE_INLINE
-CORBA_ServiceDetail::_tao_seq_Octet_out::_tao_seq_Octet_out (CORBA_ServiceDetail::_tao_seq_Octet *&p)
+CORBA::ServiceDetail::_tao_seq_Octet_out::_tao_seq_Octet_out (CORBA::ServiceDetail::_tao_seq_Octet *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ServiceDetail::_tao_seq_Octet_out::_tao_seq_Octet_out (CORBA_ServiceDetail::_tao_seq_Octet_var &p) // constructor from _var
+CORBA::ServiceDetail::_tao_seq_Octet_out::_tao_seq_Octet_out (CORBA::ServiceDetail::_tao_seq_Octet_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -319,44 +320,44 @@ CORBA_ServiceDetail::_tao_seq_Octet_out::_tao_seq_Octet_out (CORBA_ServiceDetail
 }
 
 ACE_INLINE
-CORBA_ServiceDetail::_tao_seq_Octet_out::_tao_seq_Octet_out (const CORBA_ServiceDetail::_tao_seq_Octet_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ServiceDetail::_tao_seq_Octet_out&,p).ptr_)
+CORBA::ServiceDetail::_tao_seq_Octet_out::_tao_seq_Octet_out (const CORBA::ServiceDetail::_tao_seq_Octet_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA::ServiceDetail::_tao_seq_Octet_out&,p).ptr_)
 {}
 
-ACE_INLINE CORBA_ServiceDetail::_tao_seq_Octet_out &
-CORBA_ServiceDetail::_tao_seq_Octet_out::operator= (const CORBA_ServiceDetail::_tao_seq_Octet_out &p)
+ACE_INLINE CORBA::ServiceDetail::_tao_seq_Octet_out &
+CORBA::ServiceDetail::_tao_seq_Octet_out::operator= (const CORBA::ServiceDetail::_tao_seq_Octet_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ServiceDetail::_tao_seq_Octet_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (CORBA::ServiceDetail::_tao_seq_Octet_out&,p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ServiceDetail::_tao_seq_Octet_out &
-CORBA_ServiceDetail::_tao_seq_Octet_out::operator= (CORBA_ServiceDetail::_tao_seq_Octet *p)
+ACE_INLINE CORBA::ServiceDetail::_tao_seq_Octet_out &
+CORBA::ServiceDetail::_tao_seq_Octet_out::operator= (CORBA::ServiceDetail::_tao_seq_Octet *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ServiceDetail::_tao_seq_Octet_out::operator CORBA_ServiceDetail::_tao_seq_Octet *&() // cast
+CORBA::ServiceDetail::_tao_seq_Octet_out::operator CORBA::ServiceDetail::_tao_seq_Octet *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceDetail::_tao_seq_Octet *&
-CORBA_ServiceDetail::_tao_seq_Octet_out::ptr (void) // ptr
+ACE_INLINE CORBA::ServiceDetail::_tao_seq_Octet *&
+CORBA::ServiceDetail::_tao_seq_Octet_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceDetail::_tao_seq_Octet *
-CORBA_ServiceDetail::_tao_seq_Octet_out::operator-> (void)
+ACE_INLINE CORBA::ServiceDetail::_tao_seq_Octet *
+CORBA::ServiceDetail::_tao_seq_Octet_out::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::Octet &
-CORBA_ServiceDetail::_tao_seq_Octet_out::operator[] (CORBA::ULong slot)
+CORBA::ServiceDetail::_tao_seq_Octet_out::operator[] (CORBA::ULong slot)
 {
   return this->ptr_->operator[] (slot);
 }
@@ -369,110 +370,110 @@ CORBA_ServiceDetail::_tao_seq_Octet_out::operator[] (CORBA::ULong slot)
 // *************************************************************
 
 ACE_INLINE
-CORBA_ServiceInformation_var::CORBA_ServiceInformation_var (void) // default constructor
+CORBA::ServiceInformation_var::ServiceInformation_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_ServiceInformation_var::CORBA_ServiceInformation_var (CORBA_ServiceInformation *p)
+CORBA::ServiceInformation_var::ServiceInformation_var (CORBA::ServiceInformation *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_ServiceInformation_var::CORBA_ServiceInformation_var (const CORBA_ServiceInformation_var &p) // copy constructor
+CORBA::ServiceInformation_var::ServiceInformation_var (const CORBA::ServiceInformation_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_ServiceInformation(*p.ptr_);
+    this->ptr_ = new CORBA::ServiceInformation(*p.ptr_);
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ServiceInformation_var::~CORBA_ServiceInformation_var (void) // destructor
+CORBA::ServiceInformation_var::~ServiceInformation_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceInformation_var &
-CORBA_ServiceInformation_var::operator= (CORBA_ServiceInformation *p)
+ACE_INLINE CORBA::ServiceInformation_var &
+CORBA::ServiceInformation_var::operator= (CORBA::ServiceInformation *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ServiceInformation_var &
-CORBA_ServiceInformation_var::operator= (const CORBA_ServiceInformation_var &p)
+ACE_INLINE CORBA::ServiceInformation_var &
+CORBA::ServiceInformation_var::operator= (const CORBA::ServiceInformation_var &p)
 {
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_ServiceInformation (*p.ptr_);
+    this->ptr_ = new CORBA::ServiceInformation (*p.ptr_);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_ServiceInformation *
-CORBA_ServiceInformation_var::operator-> (void) const
+ACE_INLINE const CORBA::ServiceInformation *
+CORBA::ServiceInformation_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceInformation *
-CORBA_ServiceInformation_var::operator-> (void)
+ACE_INLINE CORBA::ServiceInformation *
+CORBA::ServiceInformation_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ServiceInformation_var::operator const CORBA_ServiceInformation &() const // cast
+CORBA::ServiceInformation_var::operator const CORBA::ServiceInformation &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ServiceInformation_var::operator CORBA_ServiceInformation &() // cast 
+CORBA::ServiceInformation_var::operator CORBA::ServiceInformation &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ServiceInformation_var::operator CORBA_ServiceInformation &() const// cast 
+CORBA::ServiceInformation_var::operator CORBA::ServiceInformation &() const// cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE const CORBA_ServiceInformation &
-CORBA_ServiceInformation_var::in (void) const
+ACE_INLINE const CORBA::ServiceInformation &
+CORBA::ServiceInformation_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceInformation &
-CORBA_ServiceInformation_var::inout (void)
+ACE_INLINE CORBA::ServiceInformation &
+CORBA::ServiceInformation_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_ServiceInformation *&
-CORBA_ServiceInformation_var::out (void)
+ACE_INLINE CORBA::ServiceInformation *&
+CORBA::ServiceInformation_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceInformation *
-CORBA_ServiceInformation_var::_retn (void)
+ACE_INLINE CORBA::ServiceInformation *
+CORBA::ServiceInformation_var::_retn (void)
 {
-  CORBA_ServiceInformation *tmp = this->ptr_;
+  CORBA::ServiceInformation *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_ServiceInformation *
-CORBA_ServiceInformation_var::ptr (void) const
+ACE_INLINE CORBA::ServiceInformation *
+CORBA::ServiceInformation_var::ptr (void) const
 {
   return this->ptr_;
 }
@@ -482,14 +483,14 @@ CORBA_ServiceInformation_var::ptr (void) const
 // *************************************************************
 
 ACE_INLINE
-CORBA_ServiceInformation_out::CORBA_ServiceInformation_out (CORBA_ServiceInformation *&p)
+CORBA::ServiceInformation_out::ServiceInformation_out (CORBA::ServiceInformation *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ServiceInformation_out::CORBA_ServiceInformation_out (CORBA_ServiceInformation_var &p) // constructor from _var
+CORBA::ServiceInformation_out::ServiceInformation_out (CORBA::ServiceInformation_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -497,38 +498,38 @@ CORBA_ServiceInformation_out::CORBA_ServiceInformation_out (CORBA_ServiceInforma
 }
 
 ACE_INLINE
-CORBA_ServiceInformation_out::CORBA_ServiceInformation_out (const CORBA_ServiceInformation_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ServiceInformation_out&,p).ptr_)
+CORBA::ServiceInformation_out::ServiceInformation_out (const CORBA::ServiceInformation_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA::ServiceInformation_out&,p).ptr_)
 {}
 
-ACE_INLINE CORBA_ServiceInformation_out &
-CORBA_ServiceInformation_out::operator= (const CORBA_ServiceInformation_out &p)
+ACE_INLINE CORBA::ServiceInformation_out &
+CORBA::ServiceInformation_out::operator= (const CORBA::ServiceInformation_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ServiceInformation_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (CORBA::ServiceInformation_out&,p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ServiceInformation_out &
-CORBA_ServiceInformation_out::operator= (CORBA_ServiceInformation *p)
+ACE_INLINE CORBA::ServiceInformation_out &
+CORBA::ServiceInformation_out::operator= (CORBA::ServiceInformation *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ServiceInformation_out::operator CORBA_ServiceInformation *&() // cast
+CORBA::ServiceInformation_out::operator CORBA::ServiceInformation *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceInformation *&
-CORBA_ServiceInformation_out::ptr (void) // ptr
+ACE_INLINE CORBA::ServiceInformation *&
+CORBA::ServiceInformation_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceInformation *
-CORBA_ServiceInformation_out::operator-> (void)
+ACE_INLINE CORBA::ServiceInformation *
+CORBA::ServiceInformation_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -541,31 +542,31 @@ CORBA_ServiceInformation_out::operator-> (void)
 
   // = Static operations.
   ACE_INLINE CORBA::ULong *
-  CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::allocbuf (CORBA::ULong size)
+  CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
     return new CORBA::ULong[size];
   }
   
-  ACE_INLINE void CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::freebuf (CORBA::ULong *buffer)
+  ACE_INLINE void CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption::freebuf (CORBA::ULong *buffer)
   // Free the sequence.
   {
     delete [] buffer;
   }
   
   ACE_INLINE
-  CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption (void) // Default constructor.
+  CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption (void) // Default constructor.
   {
   }
   
   ACE_INLINE
-  CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption (CORBA::ULong maximum) // Constructor using a maximum length value.
-    : TAO_Unbounded_Base_Sequence (maximum, CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::allocbuf (maximum))
+  CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption (CORBA::ULong maximum,
+  CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption (CORBA::ULong maximum,
     CORBA::ULong length,
     CORBA::ULong *data,
     CORBA::Boolean release)
@@ -574,11 +575,11 @@ CORBA_ServiceInformation_out::operator-> (void)
   }
   
   ACE_INLINE
-  CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption (const CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption &rhs)
+  CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption (const CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption &rhs)
   // Copy constructor.
     : TAO_Unbounded_Base_Sequence (rhs)
   {
-    CORBA::ULong *tmp1 = CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::allocbuf (this->maximum_);
+    CORBA::ULong *tmp1 = CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption::allocbuf (this->maximum_);
     CORBA::ULong * const tmp2 = ACE_reinterpret_cast (CORBA::ULong * ACE_CAST_CONST, rhs.buffer_);
     
     for (CORBA::ULong i = 0; i < this->length_; ++i)
@@ -587,8 +588,8 @@ CORBA_ServiceInformation_out::operator-> (void)
     this->buffer_ = tmp1;
   }
   
-  ACE_INLINE CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption &
-  CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::operator= (const CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption &rhs)
+  ACE_INLINE CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption &
+  CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption::operator= (const CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption &rhs)
   // Assignment operator.
   {
     if (this == &rhs)
@@ -600,12 +601,12 @@ CORBA_ServiceInformation_out::operator-> (void)
       {
         // free the old buffer
         CORBA::ULong *tmp = ACE_reinterpret_cast (CORBA::ULong *, this->buffer_);
-        CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::freebuf (tmp);
-        this->buffer_ = CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::allocbuf (rhs.maximum_);
+        CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption::freebuf (tmp);
+        this->buffer_ = CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption::allocbuf (rhs.maximum_);
       }
     }
     else
-      this->buffer_ = CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::allocbuf (rhs.maximum_);
+      this->buffer_ = CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption::allocbuf (rhs.maximum_);
     
     TAO_Unbounded_Base_Sequence::operator= (rhs);
     
@@ -620,7 +621,7 @@ CORBA_ServiceInformation_out::operator-> (void)
   
   // = Accessors.
   ACE_INLINE CORBA::ULong &
-  CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::operator[] (CORBA::ULong i)
+  CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption::operator[] (CORBA::ULong i)
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
@@ -629,7 +630,7 @@ CORBA_ServiceInformation_out::operator-> (void)
   }
   
   ACE_INLINE const CORBA::ULong &
-  CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::operator[] (CORBA::ULong i) const
+  CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption::operator[] (CORBA::ULong i) const
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
@@ -640,7 +641,7 @@ CORBA_ServiceInformation_out::operator-> (void)
   // Implement the TAO_Base_Sequence methods (see Sequence.h)
   
   ACE_INLINE CORBA::ULong *
-  CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::get_buffer (CORBA::Boolean orphan)
+  CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption::get_buffer (CORBA::Boolean orphan)
   {
     CORBA::ULong *result = 0;
     if (orphan == 0)
@@ -648,7 +649,7 @@ CORBA_ServiceInformation_out::operator-> (void)
       // We retain ownership.
       if (this->buffer_ == 0)
       {
-        result = CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::allocbuf (this->length_);
+        result = CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption::allocbuf (this->length_);
         this->buffer_ = result;
 	this->release_ = 1;
       }
@@ -674,13 +675,13 @@ CORBA_ServiceInformation_out::operator-> (void)
   }
   
   ACE_INLINE const CORBA::ULong *
-  CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::get_buffer (void) const
+  CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption::get_buffer (void) const
   {
     return ACE_reinterpret_cast(const CORBA::ULong * ACE_CAST_CONST, this->buffer_);
   }
   
   ACE_INLINE void
-  CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::replace (CORBA::ULong max,
+  CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption::replace (CORBA::ULong max,
   CORBA::ULong length,
   CORBA::ULong *data,
   CORBA::Boolean release)
@@ -690,7 +691,7 @@ CORBA_ServiceInformation_out::operator-> (void)
     if (this->buffer_ && this->release_ == 1)
     {
       CORBA::ULong *tmp = ACE_reinterpret_cast(CORBA::ULong*,this->buffer_);
-      CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceOption::freebuf (tmp);
+      CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceOption::freebuf (tmp);
     }
     this->buffer_ = data;
     this->release_ = release;
@@ -709,133 +710,133 @@ CORBA_ServiceInformation_out::operator-> (void)
 // *************************************************************
 
 ACE_INLINE
-CORBA_ServiceInformation::_tao_seq_ServiceOption_var::_tao_seq_ServiceOption_var (void) // default constructor
+CORBA::ServiceInformation::_tao_seq_ServiceOption_var::_tao_seq_ServiceOption_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_ServiceInformation::_tao_seq_ServiceOption_var::_tao_seq_ServiceOption_var (CORBA_ServiceInformation::_tao_seq_ServiceOption *p)
+CORBA::ServiceInformation::_tao_seq_ServiceOption_var::_tao_seq_ServiceOption_var (CORBA::ServiceInformation::_tao_seq_ServiceOption *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_ServiceInformation::_tao_seq_ServiceOption_var::_tao_seq_ServiceOption_var (const CORBA_ServiceInformation::_tao_seq_ServiceOption_var &p) // copy constructor
+CORBA::ServiceInformation::_tao_seq_ServiceOption_var::_tao_seq_ServiceOption_var (const CORBA::ServiceInformation::_tao_seq_ServiceOption_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_ServiceInformation::_tao_seq_ServiceOption(*p.ptr_);
+    this->ptr_ = new CORBA::ServiceInformation::_tao_seq_ServiceOption(*p.ptr_);
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ServiceInformation::_tao_seq_ServiceOption_var::~_tao_seq_ServiceOption_var (void) // destructor
+CORBA::ServiceInformation::_tao_seq_ServiceOption_var::~_tao_seq_ServiceOption_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceInformation::_tao_seq_ServiceOption_var &
-CORBA_ServiceInformation::_tao_seq_ServiceOption_var::operator= (CORBA_ServiceInformation::_tao_seq_ServiceOption *p)
+ACE_INLINE CORBA::ServiceInformation::_tao_seq_ServiceOption_var &
+CORBA::ServiceInformation::_tao_seq_ServiceOption_var::operator= (CORBA::ServiceInformation::_tao_seq_ServiceOption *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ServiceInformation::_tao_seq_ServiceOption_var &
-CORBA_ServiceInformation::_tao_seq_ServiceOption_var::operator= (const CORBA_ServiceInformation::_tao_seq_ServiceOption_var &p) // deep copy
+ACE_INLINE CORBA::ServiceInformation::_tao_seq_ServiceOption_var &
+CORBA::ServiceInformation::_tao_seq_ServiceOption_var::operator= (const CORBA::ServiceInformation::_tao_seq_ServiceOption_var &p) // deep copy
 {
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_ServiceInformation::_tao_seq_ServiceOption (*p.ptr_);
+    this->ptr_ = new CORBA::ServiceInformation::_tao_seq_ServiceOption (*p.ptr_);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_ServiceInformation::_tao_seq_ServiceOption *
-CORBA_ServiceInformation::_tao_seq_ServiceOption_var::operator-> (void) const
+ACE_INLINE const CORBA::ServiceInformation::_tao_seq_ServiceOption *
+CORBA::ServiceInformation::_tao_seq_ServiceOption_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceInformation::_tao_seq_ServiceOption *
-CORBA_ServiceInformation::_tao_seq_ServiceOption_var::operator-> (void)
+ACE_INLINE CORBA::ServiceInformation::_tao_seq_ServiceOption *
+CORBA::ServiceInformation::_tao_seq_ServiceOption_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ServiceInformation::_tao_seq_ServiceOption_var::operator const CORBA_ServiceInformation::_tao_seq_ServiceOption &() const // cast
+CORBA::ServiceInformation::_tao_seq_ServiceOption_var::operator const CORBA::ServiceInformation::_tao_seq_ServiceOption &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ServiceInformation::_tao_seq_ServiceOption_var::operator CORBA_ServiceInformation::_tao_seq_ServiceOption &() // cast 
+CORBA::ServiceInformation::_tao_seq_ServiceOption_var::operator CORBA::ServiceInformation::_tao_seq_ServiceOption &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ServiceInformation::_tao_seq_ServiceOption_var::operator CORBA_ServiceInformation::_tao_seq_ServiceOption &() const// cast 
+CORBA::ServiceInformation::_tao_seq_ServiceOption_var::operator CORBA::ServiceInformation::_tao_seq_ServiceOption &() const// cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE CORBA::ServiceOption &
-CORBA_ServiceInformation::_tao_seq_ServiceOption_var::operator[] (CORBA::ULong slot)
+CORBA::ServiceInformation::_tao_seq_ServiceOption_var::operator[] (CORBA::ULong slot)
 {
   return this->ptr_->operator[] (slot);
 }
 
-ACE_INLINE const CORBA_ServiceInformation::_tao_seq_ServiceOption &
-CORBA_ServiceInformation::_tao_seq_ServiceOption_var::in (void) const
+ACE_INLINE const CORBA::ServiceInformation::_tao_seq_ServiceOption &
+CORBA::ServiceInformation::_tao_seq_ServiceOption_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceInformation::_tao_seq_ServiceOption &
-CORBA_ServiceInformation::_tao_seq_ServiceOption_var::inout (void)
+ACE_INLINE CORBA::ServiceInformation::_tao_seq_ServiceOption &
+CORBA::ServiceInformation::_tao_seq_ServiceOption_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_ServiceInformation::_tao_seq_ServiceOption *&
-CORBA_ServiceInformation::_tao_seq_ServiceOption_var::out (void)
+ACE_INLINE CORBA::ServiceInformation::_tao_seq_ServiceOption *&
+CORBA::ServiceInformation::_tao_seq_ServiceOption_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceInformation::_tao_seq_ServiceOption *
-CORBA_ServiceInformation::_tao_seq_ServiceOption_var::_retn (void)
+ACE_INLINE CORBA::ServiceInformation::_tao_seq_ServiceOption *
+CORBA::ServiceInformation::_tao_seq_ServiceOption_var::_retn (void)
 {
-  CORBA_ServiceInformation::_tao_seq_ServiceOption *tmp = this->ptr_;
+  CORBA::ServiceInformation::_tao_seq_ServiceOption *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_ServiceInformation::_tao_seq_ServiceOption *
-CORBA_ServiceInformation::_tao_seq_ServiceOption_var::ptr (void) const
+ACE_INLINE CORBA::ServiceInformation::_tao_seq_ServiceOption *
+CORBA::ServiceInformation::_tao_seq_ServiceOption_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_ServiceInformation::_tao_seq_ServiceOption_out
+// Inline operations for class CORBA::ServiceInformation::_tao_seq_ServiceOption_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ServiceInformation::_tao_seq_ServiceOption_out::_tao_seq_ServiceOption_out (CORBA_ServiceInformation::_tao_seq_ServiceOption *&p)
+CORBA::ServiceInformation::_tao_seq_ServiceOption_out::_tao_seq_ServiceOption_out (CORBA::ServiceInformation::_tao_seq_ServiceOption *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ServiceInformation::_tao_seq_ServiceOption_out::_tao_seq_ServiceOption_out (CORBA_ServiceInformation::_tao_seq_ServiceOption_var &p) // constructor from _var
+CORBA::ServiceInformation::_tao_seq_ServiceOption_out::_tao_seq_ServiceOption_out (CORBA::ServiceInformation::_tao_seq_ServiceOption_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -843,44 +844,44 @@ CORBA_ServiceInformation::_tao_seq_ServiceOption_out::_tao_seq_ServiceOption_out
 }
 
 ACE_INLINE
-CORBA_ServiceInformation::_tao_seq_ServiceOption_out::_tao_seq_ServiceOption_out (const CORBA_ServiceInformation::_tao_seq_ServiceOption_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ServiceInformation::_tao_seq_ServiceOption_out&,p).ptr_)
+CORBA::ServiceInformation::_tao_seq_ServiceOption_out::_tao_seq_ServiceOption_out (const CORBA::ServiceInformation::_tao_seq_ServiceOption_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA::ServiceInformation::_tao_seq_ServiceOption_out&,p).ptr_)
 {}
 
-ACE_INLINE CORBA_ServiceInformation::_tao_seq_ServiceOption_out &
-CORBA_ServiceInformation::_tao_seq_ServiceOption_out::operator= (const CORBA_ServiceInformation::_tao_seq_ServiceOption_out &p)
+ACE_INLINE CORBA::ServiceInformation::_tao_seq_ServiceOption_out &
+CORBA::ServiceInformation::_tao_seq_ServiceOption_out::operator= (const CORBA::ServiceInformation::_tao_seq_ServiceOption_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ServiceInformation::_tao_seq_ServiceOption_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (CORBA::ServiceInformation::_tao_seq_ServiceOption_out&,p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ServiceInformation::_tao_seq_ServiceOption_out &
-CORBA_ServiceInformation::_tao_seq_ServiceOption_out::operator= (CORBA_ServiceInformation::_tao_seq_ServiceOption *p)
+ACE_INLINE CORBA::ServiceInformation::_tao_seq_ServiceOption_out &
+CORBA::ServiceInformation::_tao_seq_ServiceOption_out::operator= (CORBA::ServiceInformation::_tao_seq_ServiceOption *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ServiceInformation::_tao_seq_ServiceOption_out::operator CORBA_ServiceInformation::_tao_seq_ServiceOption *&() // cast
+CORBA::ServiceInformation::_tao_seq_ServiceOption_out::operator CORBA::ServiceInformation::_tao_seq_ServiceOption *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceInformation::_tao_seq_ServiceOption *&
-CORBA_ServiceInformation::_tao_seq_ServiceOption_out::ptr (void) // ptr
+ACE_INLINE CORBA::ServiceInformation::_tao_seq_ServiceOption *&
+CORBA::ServiceInformation::_tao_seq_ServiceOption_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceInformation::_tao_seq_ServiceOption *
-CORBA_ServiceInformation::_tao_seq_ServiceOption_out::operator-> (void)
+ACE_INLINE CORBA::ServiceInformation::_tao_seq_ServiceOption *
+CORBA::ServiceInformation::_tao_seq_ServiceOption_out::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::ServiceOption &
-CORBA_ServiceInformation::_tao_seq_ServiceOption_out::operator[] (CORBA::ULong slot)
+CORBA::ServiceInformation::_tao_seq_ServiceOption_out::operator[] (CORBA::ULong slot)
 {
   return this->ptr_->operator[] (slot);
 }
@@ -895,46 +896,46 @@ CORBA_ServiceInformation::_tao_seq_ServiceOption_out::operator[] (CORBA::ULong s
 #define __TAO_UNBOUNDED_SEQUENCE_CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEDETAIL_CI_
 
   // = Static operations.
-  ACE_INLINE CORBA_ServiceDetail *
-  CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::allocbuf (CORBA::ULong size)
+  ACE_INLINE CORBA::ServiceDetail *
+  CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
-    return new CORBA_ServiceDetail[size];
+    return new CORBA::ServiceDetail[size];
   }
   
-  ACE_INLINE void CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::freebuf (CORBA::ServiceDetail *buffer)
+  ACE_INLINE void CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail::freebuf (CORBA::ServiceDetail *buffer)
   // Free the sequence.
   {
     delete [] buffer;
   }
   
   ACE_INLINE
-  CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail (void) // Default constructor.
+  CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail (void) // Default constructor.
   {
   }
   
   ACE_INLINE
-  CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail (CORBA::ULong maximum) // Constructor using a maximum length value.
-    : TAO_Unbounded_Base_Sequence (maximum, CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::allocbuf (maximum))
+  CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail (CORBA::ULong maximum,
+  CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail (CORBA::ULong maximum,
     CORBA::ULong length,
-    CORBA_ServiceDetail *data,
+    CORBA::ServiceDetail *data,
     CORBA::Boolean release)
   : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
   {
   }
   
   ACE_INLINE
-  CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail (const CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail &rhs)
+  CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail (const CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail &rhs)
   // Copy constructor.
     : TAO_Unbounded_Base_Sequence (rhs)
   {
-    CORBA_ServiceDetail *tmp1 = CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::allocbuf (this->maximum_);
-    CORBA_ServiceDetail * const tmp2 = ACE_reinterpret_cast (CORBA_ServiceDetail * ACE_CAST_CONST, rhs.buffer_);
+    CORBA::ServiceDetail *tmp1 = CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail::allocbuf (this->maximum_);
+    CORBA::ServiceDetail * const tmp2 = ACE_reinterpret_cast (CORBA::ServiceDetail * ACE_CAST_CONST, rhs.buffer_);
     
     for (CORBA::ULong i = 0; i < this->length_; ++i)
       tmp1[i] = tmp2[i];
@@ -942,8 +943,8 @@ CORBA_ServiceInformation::_tao_seq_ServiceOption_out::operator[] (CORBA::ULong s
     this->buffer_ = tmp1;
   }
   
-  ACE_INLINE CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail &
-  CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::operator= (const CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail &rhs)
+  ACE_INLINE CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail &
+  CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail::operator= (const CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail &rhs)
   // Assignment operator.
   {
     if (this == &rhs)
@@ -954,18 +955,18 @@ CORBA_ServiceInformation::_tao_seq_ServiceOption_out::operator[] (CORBA::ULong s
       if (this->maximum_ < rhs.maximum_)
       {
         // free the old buffer
-        CORBA_ServiceDetail *tmp = ACE_reinterpret_cast (CORBA_ServiceDetail *, this->buffer_);
-        CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::freebuf (tmp);
-        this->buffer_ = CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::allocbuf (rhs.maximum_);
+        CORBA::ServiceDetail *tmp = ACE_reinterpret_cast (CORBA::ServiceDetail *, this->buffer_);
+        CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail::freebuf (tmp);
+        this->buffer_ = CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail::allocbuf (rhs.maximum_);
       }
     }
     else
-      this->buffer_ = CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::allocbuf (rhs.maximum_);
+      this->buffer_ = CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail::allocbuf (rhs.maximum_);
     
     TAO_Unbounded_Base_Sequence::operator= (rhs);
     
-    CORBA_ServiceDetail *tmp1 = ACE_reinterpret_cast (CORBA_ServiceDetail *, this->buffer_);
-    CORBA_ServiceDetail * const tmp2 = ACE_reinterpret_cast (CORBA_ServiceDetail * ACE_CAST_CONST, rhs.buffer_);
+    CORBA::ServiceDetail *tmp1 = ACE_reinterpret_cast (CORBA::ServiceDetail *, this->buffer_);
+    CORBA::ServiceDetail * const tmp2 = ACE_reinterpret_cast (CORBA::ServiceDetail * ACE_CAST_CONST, rhs.buffer_);
     
     for (CORBA::ULong i = 0; i < this->length_; ++i)
       tmp1[i] = tmp2[i];
@@ -974,42 +975,42 @@ CORBA_ServiceInformation::_tao_seq_ServiceOption_out::operator[] (CORBA::ULong s
   }
   
   // = Accessors.
-  ACE_INLINE CORBA_ServiceDetail &
-  CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::operator[] (CORBA::ULong i)
+  ACE_INLINE CORBA::ServiceDetail &
+  CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail::operator[] (CORBA::ULong i)
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    CORBA_ServiceDetail* tmp = ACE_reinterpret_cast(CORBA_ServiceDetail*,this->buffer_);
+    CORBA::ServiceDetail* tmp = ACE_reinterpret_cast(CORBA::ServiceDetail*,this->buffer_);
     return tmp[i];
   }
   
-  ACE_INLINE const CORBA_ServiceDetail &
-  CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::operator[] (CORBA::ULong i) const
+  ACE_INLINE const CORBA::ServiceDetail &
+  CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail::operator[] (CORBA::ULong i) const
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    CORBA_ServiceDetail * const tmp = ACE_reinterpret_cast (CORBA_ServiceDetail* ACE_CAST_CONST, this->buffer_);
+    CORBA::ServiceDetail * const tmp = ACE_reinterpret_cast (CORBA::ServiceDetail* ACE_CAST_CONST, this->buffer_);
     return tmp[i];
   }
   
   // Implement the TAO_Base_Sequence methods (see Sequence.h)
   
-  ACE_INLINE CORBA_ServiceDetail *
-  CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::get_buffer (CORBA::Boolean orphan)
+  ACE_INLINE CORBA::ServiceDetail *
+  CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail::get_buffer (CORBA::Boolean orphan)
   {
-    CORBA_ServiceDetail *result = 0;
+    CORBA::ServiceDetail *result = 0;
     if (orphan == 0)
     {
       // We retain ownership.
       if (this->buffer_ == 0)
       {
-        result = CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::allocbuf (this->length_);
+        result = CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail::allocbuf (this->length_);
         this->buffer_ = result;
 	this->release_ = 1;
       }
       else
       {
-        result = ACE_reinterpret_cast (CORBA_ServiceDetail*, this->buffer_);
+        result = ACE_reinterpret_cast (CORBA::ServiceDetail*, this->buffer_);
       }
     }
     else // if (orphan == 1)
@@ -1018,7 +1019,7 @@ CORBA_ServiceInformation::_tao_seq_ServiceOption_out::operator[] (CORBA::ULong s
       {
         // We set the state back to default and relinquish
         // ownership.
-        result = ACE_reinterpret_cast(CORBA_ServiceDetail*,this->buffer_);
+        result = ACE_reinterpret_cast(CORBA::ServiceDetail*,this->buffer_);
         this->maximum_ = 0;
         this->length_ = 0;
         this->buffer_ = 0;
@@ -1028,24 +1029,24 @@ CORBA_ServiceInformation::_tao_seq_ServiceOption_out::operator[] (CORBA::ULong s
     return result;
   }
   
-  ACE_INLINE const CORBA_ServiceDetail *
-  CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::get_buffer (void) const
+  ACE_INLINE const CORBA::ServiceDetail *
+  CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail::get_buffer (void) const
   {
-    return ACE_reinterpret_cast(const CORBA_ServiceDetail * ACE_CAST_CONST, this->buffer_);
+    return ACE_reinterpret_cast(const CORBA::ServiceDetail * ACE_CAST_CONST, this->buffer_);
   }
   
   ACE_INLINE void
-  CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::replace (CORBA::ULong max,
+  CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail::replace (CORBA::ULong max,
   CORBA::ULong length,
-  CORBA_ServiceDetail *data,
+  CORBA::ServiceDetail *data,
   CORBA::Boolean release)
   {
     this->maximum_ = max;
     this->length_ = length;
     if (this->buffer_ && this->release_ == 1)
     {
-      CORBA_ServiceDetail *tmp = ACE_reinterpret_cast(CORBA_ServiceDetail*,this->buffer_);
-      CORBA_ServiceInformation::_TAO_Unbounded_Sequence_CORBA_ServiceInformation__tao_seq_ServiceDetail::freebuf (tmp);
+      CORBA::ServiceDetail *tmp = ACE_reinterpret_cast(CORBA::ServiceDetail*,this->buffer_);
+      CORBA::ServiceInformation::_TAO_Unbounded_Sequence_CORBA::ServiceInformation__tao_seq_ServiceDetail::freebuf (tmp);
     }
     this->buffer_ = data;
     this->release_ = release;
@@ -1060,120 +1061,120 @@ CORBA_ServiceInformation::_tao_seq_ServiceOption_out::operator[] (CORBA::ULong s
 #define _CORBA_SERVICEINFORMATION__TAO_SEQ_SERVICEDETAIL_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_ServiceInformation::_tao_seq_ServiceDetail_var
+// Inline operations for class CORBA::ServiceInformation::_tao_seq_ServiceDetail_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_var::_tao_seq_ServiceDetail_var (void) // default constructor
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_var::_tao_seq_ServiceDetail_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_var::_tao_seq_ServiceDetail_var (CORBA_ServiceInformation::_tao_seq_ServiceDetail *p)
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_var::_tao_seq_ServiceDetail_var (CORBA::ServiceInformation::_tao_seq_ServiceDetail *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_var::_tao_seq_ServiceDetail_var (const CORBA_ServiceInformation::_tao_seq_ServiceDetail_var &p) // copy constructor
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_var::_tao_seq_ServiceDetail_var (const CORBA::ServiceInformation::_tao_seq_ServiceDetail_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_ServiceInformation::_tao_seq_ServiceDetail(*p.ptr_);
+    this->ptr_ = new CORBA::ServiceInformation::_tao_seq_ServiceDetail(*p.ptr_);
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_var::~_tao_seq_ServiceDetail_var (void) // destructor
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_var::~_tao_seq_ServiceDetail_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceInformation::_tao_seq_ServiceDetail_var &
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_var::operator= (CORBA_ServiceInformation::_tao_seq_ServiceDetail *p)
+ACE_INLINE CORBA::ServiceInformation::_tao_seq_ServiceDetail_var &
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_var::operator= (CORBA::ServiceInformation::_tao_seq_ServiceDetail *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ServiceInformation::_tao_seq_ServiceDetail_var &
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_var::operator= (const CORBA_ServiceInformation::_tao_seq_ServiceDetail_var &p) // deep copy
+ACE_INLINE CORBA::ServiceInformation::_tao_seq_ServiceDetail_var &
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_var::operator= (const CORBA::ServiceInformation::_tao_seq_ServiceDetail_var &p) // deep copy
 {
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_ServiceInformation::_tao_seq_ServiceDetail (*p.ptr_);
+    this->ptr_ = new CORBA::ServiceInformation::_tao_seq_ServiceDetail (*p.ptr_);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_ServiceInformation::_tao_seq_ServiceDetail *
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_var::operator-> (void) const
+ACE_INLINE const CORBA::ServiceInformation::_tao_seq_ServiceDetail *
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceInformation::_tao_seq_ServiceDetail *
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_var::operator-> (void)
+ACE_INLINE CORBA::ServiceInformation::_tao_seq_ServiceDetail *
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_var::operator const CORBA_ServiceInformation::_tao_seq_ServiceDetail &() const // cast
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_var::operator const CORBA::ServiceInformation::_tao_seq_ServiceDetail &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_var::operator CORBA_ServiceInformation::_tao_seq_ServiceDetail &() // cast 
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_var::operator CORBA::ServiceInformation::_tao_seq_ServiceDetail &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_var::operator CORBA_ServiceInformation::_tao_seq_ServiceDetail &() const// cast 
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_var::operator CORBA::ServiceInformation::_tao_seq_ServiceDetail &() const// cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceDetail &
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_var::operator[] (CORBA::ULong slot)
+ACE_INLINE CORBA::ServiceDetail &
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_var::operator[] (CORBA::ULong slot)
 {
   return this->ptr_->operator[] (slot);
 }
 
-ACE_INLINE const CORBA_ServiceInformation::_tao_seq_ServiceDetail &
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_var::in (void) const
+ACE_INLINE const CORBA::ServiceInformation::_tao_seq_ServiceDetail &
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceInformation::_tao_seq_ServiceDetail &
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_var::inout (void)
+ACE_INLINE CORBA::ServiceInformation::_tao_seq_ServiceDetail &
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_ServiceInformation::_tao_seq_ServiceDetail *&
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_var::out (void)
+ACE_INLINE CORBA::ServiceInformation::_tao_seq_ServiceDetail *&
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceInformation::_tao_seq_ServiceDetail *
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_var::_retn (void)
+ACE_INLINE CORBA::ServiceInformation::_tao_seq_ServiceDetail *
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_var::_retn (void)
 {
-  CORBA_ServiceInformation::_tao_seq_ServiceDetail *tmp = this->ptr_;
+  CORBA::ServiceInformation::_tao_seq_ServiceDetail *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_ServiceInformation::_tao_seq_ServiceDetail *
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_var::ptr (void) const
+ACE_INLINE CORBA::ServiceInformation::_tao_seq_ServiceDetail *
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_var::ptr (void) const
 {
   return this->ptr_;
 }
@@ -1183,14 +1184,14 @@ CORBA_ServiceInformation::_tao_seq_ServiceDetail_var::ptr (void) const
 // *************************************************************
 
 ACE_INLINE
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_out::_tao_seq_ServiceDetail_out (CORBA_ServiceInformation::_tao_seq_ServiceDetail *&p)
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_out::_tao_seq_ServiceDetail_out (CORBA::ServiceInformation::_tao_seq_ServiceDetail *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_out::_tao_seq_ServiceDetail_out (CORBA_ServiceInformation::_tao_seq_ServiceDetail_var &p) // constructor from _var
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_out::_tao_seq_ServiceDetail_out (CORBA::ServiceInformation::_tao_seq_ServiceDetail_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -1198,44 +1199,44 @@ CORBA_ServiceInformation::_tao_seq_ServiceDetail_out::_tao_seq_ServiceDetail_out
 }
 
 ACE_INLINE
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_out::_tao_seq_ServiceDetail_out (const CORBA_ServiceInformation::_tao_seq_ServiceDetail_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ServiceInformation::_tao_seq_ServiceDetail_out&,p).ptr_)
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_out::_tao_seq_ServiceDetail_out (const CORBA::ServiceInformation::_tao_seq_ServiceDetail_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA::ServiceInformation::_tao_seq_ServiceDetail_out&,p).ptr_)
 {}
 
-ACE_INLINE CORBA_ServiceInformation::_tao_seq_ServiceDetail_out &
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_out::operator= (const CORBA_ServiceInformation::_tao_seq_ServiceDetail_out &p)
+ACE_INLINE CORBA::ServiceInformation::_tao_seq_ServiceDetail_out &
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_out::operator= (const CORBA::ServiceInformation::_tao_seq_ServiceDetail_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ServiceInformation::_tao_seq_ServiceDetail_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (CORBA::ServiceInformation::_tao_seq_ServiceDetail_out&,p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ServiceInformation::_tao_seq_ServiceDetail_out &
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_out::operator= (CORBA_ServiceInformation::_tao_seq_ServiceDetail *p)
+ACE_INLINE CORBA::ServiceInformation::_tao_seq_ServiceDetail_out &
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_out::operator= (CORBA::ServiceInformation::_tao_seq_ServiceDetail *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_out::operator CORBA_ServiceInformation::_tao_seq_ServiceDetail *&() // cast
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_out::operator CORBA::ServiceInformation::_tao_seq_ServiceDetail *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceInformation::_tao_seq_ServiceDetail *&
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_out::ptr (void) // ptr
+ACE_INLINE CORBA::ServiceInformation::_tao_seq_ServiceDetail *&
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceInformation::_tao_seq_ServiceDetail *
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_out::operator-> (void)
+ACE_INLINE CORBA::ServiceInformation::_tao_seq_ServiceDetail *
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_out::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ServiceDetail &
-CORBA_ServiceInformation::_tao_seq_ServiceDetail_out::operator[] (CORBA::ULong slot)
+ACE_INLINE CORBA::ServiceDetail &
+CORBA::ServiceInformation::_tao_seq_ServiceDetail_out::operator[] (CORBA::ULong slot)
 {
   return this->ptr_->operator[] (slot);
 }
diff --git a/TAO/tao/StringSeqC.cpp b/TAO/tao/StringSeqC.cpp
index 2cbe38ae513..5b6394831e9 100644
--- a/TAO/tao/StringSeqC.cpp
+++ b/TAO/tao/StringSeqC.cpp
@@ -40,9 +40,9 @@
 // CORBA::StringSeq
 // *************************************************************
 
-CORBA_StringSeq::CORBA_StringSeq (void)
+CORBA::StringSeq::StringSeq (void)
 {}
-CORBA_StringSeq::CORBA_StringSeq (CORBA::ULong max) // uses max size
+CORBA::StringSeq::StringSeq (CORBA::ULong max) // uses max size
   :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_String_Sequence
@@ -51,7 +51,7 @@ CORBA_StringSeq::CORBA_StringSeq (CORBA::ULong max) // uses max size
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max)
 {}
-CORBA_StringSeq::CORBA_StringSeq (CORBA::ULong max, CORBA::ULong length, char * *buffer, CORBA::Boolean release)
+CORBA::StringSeq::StringSeq (CORBA::ULong max, CORBA::ULong length, char * *buffer, CORBA::Boolean release)
   :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_String_Sequence
@@ -60,7 +60,7 @@ CORBA_StringSeq::CORBA_StringSeq (CORBA::ULong max, CORBA::ULong length, char *
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max, length, buffer, release)
 {}
-CORBA_StringSeq::CORBA_StringSeq (const CORBA_StringSeq &seq) // copy ctor
+CORBA::StringSeq::StringSeq (const CORBA::StringSeq &seq) // copy ctor
   :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_String_Sequence
@@ -69,11 +69,11 @@ CORBA_StringSeq::CORBA_StringSeq (const CORBA_StringSeq &seq) // copy ctor
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (seq)
 {}
-CORBA_StringSeq::~CORBA_StringSeq (void) // dtor
+CORBA::StringSeq::~StringSeq (void) // dtor
 {}
-void CORBA_StringSeq::_tao_any_destructor (void *x)
+void CORBA::StringSeq::_tao_any_destructor (void *x)
 {
-  CORBA_StringSeq *tmp = ACE_static_cast (CORBA_StringSeq*,x);
+  CORBA::StringSeq *tmp = ACE_static_cast (CORBA::StringSeq*,x);
   delete tmp;
 }
 
@@ -93,7 +93,7 @@ static const CORBA::Long _oc_CORBA_StringSeq[] =
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_StringSeq (CORBA::tk_alias, sizeof (_oc_CORBA_StringSeq), (char *) &_oc_CORBA_StringSeq, 0, sizeof (CORBA_StringSeq));
+static CORBA::TypeCode _tc_TAO_tc_CORBA_StringSeq (CORBA::tk_alias, sizeof (_oc_CORBA_StringSeq), (char *) &_oc_CORBA_StringSeq, 0, sizeof (CORBA::StringSeq));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (CORBA)
 TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_StringSeq, &_tc_TAO_tc_CORBA_StringSeq)
@@ -106,9 +106,9 @@ TAO_NAMESPACE_END
 // CORBA::WStringSeq
 // *************************************************************
 
-CORBA_WStringSeq::CORBA_WStringSeq (void)
+CORBA::WStringSeq::WStringSeq (void)
 {}
-CORBA_WStringSeq::CORBA_WStringSeq (CORBA::ULong max) // uses max size
+CORBA::WStringSeq::WStringSeq (CORBA::ULong max) // uses max size
   :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_WString_Sequence
@@ -117,7 +117,7 @@ CORBA_WStringSeq::CORBA_WStringSeq (CORBA::ULong max) // uses max size
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max)
 {}
-CORBA_WStringSeq::CORBA_WStringSeq (CORBA::ULong max, CORBA::ULong length, CORBA::WChar * *buffer, CORBA::Boolean release)
+CORBA::WStringSeq::WStringSeq (CORBA::ULong max, CORBA::ULong length, CORBA::WChar * *buffer, CORBA::Boolean release)
   :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_WString_Sequence
@@ -126,7 +126,7 @@ CORBA_WStringSeq::CORBA_WStringSeq (CORBA::ULong max, CORBA::ULong length, CORBA
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max, length, buffer, release)
 {}
-CORBA_WStringSeq::CORBA_WStringSeq (const CORBA_WStringSeq &seq) // copy ctor
+CORBA::WStringSeq::WStringSeq (const CORBA::WStringSeq &seq) // copy ctor
   :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_WString_Sequence
@@ -135,11 +135,11 @@ CORBA_WStringSeq::CORBA_WStringSeq (const CORBA_WStringSeq &seq) // copy ctor
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (seq)
 {}
-CORBA_WStringSeq::~CORBA_WStringSeq (void) // dtor
+CORBA::WStringSeq::~WStringSeq (void) // dtor
 {}
-void CORBA_WStringSeq::_tao_any_destructor (void *x)
+void CORBA::WStringSeq::_tao_any_destructor (void *x)
 {
-  CORBA_WStringSeq *tmp = ACE_static_cast (CORBA_WStringSeq*,x);
+  CORBA::WStringSeq *tmp = ACE_static_cast (CORBA::WStringSeq*,x);
   delete tmp;
 }
 
@@ -159,7 +159,7 @@ static const CORBA::Long _oc_CORBA_WStringSeq[] =
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_WStringSeq (CORBA::tk_alias, sizeof (_oc_CORBA_WStringSeq), (char *) &_oc_CORBA_WStringSeq, 0, sizeof (CORBA_WStringSeq));
+static CORBA::TypeCode _tc_TAO_tc_CORBA_WStringSeq (CORBA::tk_alias, sizeof (_oc_CORBA_WStringSeq), (char *) &_oc_CORBA_WStringSeq, 0, sizeof (CORBA::WStringSeq));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (CORBA)
 TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_WStringSeq, &_tc_TAO_tc_CORBA_WStringSeq)
@@ -167,7 +167,7 @@ TAO_NAMESPACE_END
 
 void operator<<= (
     CORBA::Any &_tao_any,
-    const CORBA_StringSeq &_tao_elem
+    const CORBA::StringSeq &_tao_elem
   ) // copying
 {
   TAO_OutputCDR stream;
@@ -181,7 +181,7 @@ void operator<<= (
   }
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA_StringSeq *_tao_elem) // non copying
+void operator<<= (CORBA::Any &_tao_any, CORBA::StringSeq *_tao_elem) // non copying
 {
   TAO_OutputCDR stream;
   stream << *_tao_elem;
@@ -191,19 +191,19 @@ void operator<<= (CORBA::Any &_tao_any, CORBA_StringSeq *_tao_elem) // non copyi
       stream.begin (),
       1,
       _tao_elem,
-      CORBA_StringSeq::_tao_any_destructor
+      CORBA::StringSeq::_tao_any_destructor
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_StringSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StringSeq *&_tao_elem)
 {
   return _tao_any >>= ACE_const_cast(
-      const CORBA_StringSeq*&,
+      const CORBA::StringSeq*&,
       _tao_elem
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_StringSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::StringSeq *&_tao_elem)
 {
   _tao_elem = 0;
   ACE_TRY_NEW_ENV
@@ -221,15 +221,15 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_StringSeq *&
     if (_tao_any.any_owns_data ())
     {
       _tao_elem = ACE_static_cast(
-          const CORBA_StringSeq*,
+          const CORBA::StringSeq*,
           _tao_any.value ()
         );
       return 1;
     }
     else
     {
-      CORBA_StringSeq *tmp;
-      ACE_NEW_RETURN (tmp, CORBA_StringSeq, 0);
+      CORBA::StringSeq *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::StringSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
@@ -240,7 +240,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_StringSeq *&
             CORBA::_tc_StringSeq,
             1,
             ACE_static_cast (void *, tmp),
-            CORBA_StringSeq::_tao_any_destructor
+            CORBA::StringSeq::_tao_any_destructor
           );
         _tao_elem = tmp;
         return 1;
@@ -260,7 +260,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_StringSeq *&
 
 void operator<<= (
     CORBA::Any &_tao_any,
-    const CORBA_WStringSeq &_tao_elem
+    const CORBA::WStringSeq &_tao_elem
   ) // copying
 {
   TAO_OutputCDR stream;
@@ -274,7 +274,7 @@ void operator<<= (
   }
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA_WStringSeq *_tao_elem) // non copying
+void operator<<= (CORBA::Any &_tao_any, CORBA::WStringSeq *_tao_elem) // non copying
 {
   TAO_OutputCDR stream;
   stream << *_tao_elem;
@@ -284,19 +284,19 @@ void operator<<= (CORBA::Any &_tao_any, CORBA_WStringSeq *_tao_elem) // non copy
       stream.begin (),
       1,
       _tao_elem,
-      CORBA_WStringSeq::_tao_any_destructor
+      CORBA::WStringSeq::_tao_any_destructor
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_WStringSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::WStringSeq *&_tao_elem)
 {
   return _tao_any >>= ACE_const_cast(
-      const CORBA_WStringSeq*&,
+      const CORBA::WStringSeq*&,
       _tao_elem
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_WStringSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::WStringSeq *&_tao_elem)
 {
   _tao_elem = 0;
   ACE_TRY_NEW_ENV
@@ -314,15 +314,15 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_WStringSeq *
     if (_tao_any.any_owns_data ())
     {
       _tao_elem = ACE_static_cast(
-          const CORBA_WStringSeq*,
+          const CORBA::WStringSeq*,
           _tao_any.value ()
         );
       return 1;
     }
     else
     {
-      CORBA_WStringSeq *tmp;
-      ACE_NEW_RETURN (tmp, CORBA_WStringSeq, 0);
+      CORBA::WStringSeq *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::WStringSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
@@ -333,7 +333,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_WStringSeq *
             CORBA::_tc_WStringSeq,
             1,
             ACE_static_cast (void *, tmp),
-            CORBA_WStringSeq::_tao_any_destructor
+            CORBA::WStringSeq::_tao_any_destructor
           );
         _tao_elem = tmp;
         return 1;
@@ -353,7 +353,7 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_WStringSeq *
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_StringSeq &_tao_sequence
+    const CORBA::StringSeq &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -371,7 +371,7 @@ CORBA::Boolean operator<< (
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    CORBA_StringSeq &_tao_sequence
+    CORBA::StringSeq &_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;
@@ -395,7 +395,7 @@ CORBA::Boolean operator>> (
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_WStringSeq &_tao_sequence
+    const CORBA::WStringSeq &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -413,7 +413,7 @@ CORBA::Boolean operator<< (
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    CORBA_WStringSeq &_tao_sequence
+    CORBA::WStringSeq &_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;
diff --git a/TAO/tao/StringSeqC.h b/TAO/tao/StringSeqC.h
index 64f43fb52dd..8f5c09c7e3a 100644
--- a/TAO/tao/StringSeqC.h
+++ b/TAO/tao/StringSeqC.h
@@ -55,17 +55,20 @@
 #pragma option push -w-rvl -w-rch -w-ccc -w-inl
 #endif /* __BORLANDC__ */
 
+namespace CORBA
+{
+
 #if !defined (_CORBA_STRINGSEQ_CH_)
 #define _CORBA_STRINGSEQ_CH_
 
-  class CORBA_StringSeq;
-  class CORBA_StringSeq_var;
+  class StringSeq;
+  class StringSeq_var;
   
   // *************************************************************
   // CORBA::StringSeq
   // *************************************************************
   
-  class TAO_Export CORBA_StringSeq : public 
+  class TAO_Export StringSeq : public 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
     TAO_Unbounded_String_Sequence
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
@@ -73,20 +76,20 @@
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
   {
   public:
-    CORBA_StringSeq (void); // default ctor
-    CORBA_StringSeq (CORBA::ULong max); // uses max size
-    CORBA_StringSeq (
+    StringSeq (void); // default ctor
+    StringSeq (CORBA::ULong max); // uses max size
+    StringSeq (
       CORBA::ULong max, 
       CORBA::ULong length, 
       char * *buffer, 
       CORBA::Boolean release = 0
     );
-    CORBA_StringSeq (const CORBA_StringSeq &); // copy ctor
-    ~CORBA_StringSeq (void);
+    StringSeq (const StringSeq &); // copy ctor
+    ~StringSeq (void);
     static void _tao_any_destructor (void*);
 
 #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-    typedef CORBA_StringSeq_var _var_type;
+    typedef StringSeq_var _var_type;
 #endif /* ! __GNUC__ || g++ >= 2.8 */
 
   };
@@ -101,35 +104,35 @@
   // class CORBA::StringSeq_var
   // *************************************************************
 
-  class TAO_Export CORBA_StringSeq_var
+  class TAO_Export StringSeq_var
   {
   public:
-    CORBA_StringSeq_var (void); // default constructor
-    CORBA_StringSeq_var (CORBA_StringSeq *);
-    CORBA_StringSeq_var (const CORBA_StringSeq_var &); // copy constructor
-    ~CORBA_StringSeq_var (void); // destructor
+    StringSeq_var (void); // default constructor
+    StringSeq_var (StringSeq *);
+    StringSeq_var (const StringSeq_var &); // copy constructor
+    ~StringSeq_var (void); // destructor
     
-    CORBA_StringSeq_var &operator= (CORBA_StringSeq *);
-    CORBA_StringSeq_var &operator= (const CORBA_StringSeq_var &);
-    CORBA_StringSeq *operator-> (void);
-    const CORBA_StringSeq *operator-> (void) const;
+    StringSeq_var &operator= (StringSeq *);
+    StringSeq_var &operator= (const StringSeq_var &);
+    StringSeq *operator-> (void);
+    const StringSeq *operator-> (void) const;
     
-    operator const CORBA_StringSeq &() const;
-    operator CORBA_StringSeq &();
-    operator CORBA_StringSeq &() const;
-    operator CORBA_StringSeq *&(); // variable-size base types only
+    operator const StringSeq &() const;
+    operator StringSeq &();
+    operator StringSeq &() const;
+    operator StringSeq *&(); // variable-size base types only
     
     TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
     
     // in, inout, out, _retn 
-    const CORBA_StringSeq &in (void) const;
-    CORBA_StringSeq &inout (void);
-    CORBA_StringSeq *&out (void);
-    CORBA_StringSeq *_retn (void);
-    CORBA_StringSeq *ptr (void) const;
+    const StringSeq &in (void) const;
+    StringSeq &inout (void);
+    StringSeq *&out (void);
+    StringSeq *_retn (void);
+    StringSeq *ptr (void) const;
 
   private:
-    CORBA_StringSeq *ptr_;
+    StringSeq *ptr_;
   };
 
 
@@ -139,23 +142,23 @@
 #if !defined (_CORBA_STRINGSEQ___OUT_CH_)
 #define _CORBA_STRINGSEQ___OUT_CH_
 
-  class TAO_Export CORBA_StringSeq_out
+  class TAO_Export StringSeq_out
   {
   public:
-    CORBA_StringSeq_out (CORBA_StringSeq *&);
-    CORBA_StringSeq_out (CORBA_StringSeq_var &);
-    CORBA_StringSeq_out (const CORBA_StringSeq_out &);
-    CORBA_StringSeq_out &operator= (const CORBA_StringSeq_out &);
-    CORBA_StringSeq_out &operator= (CORBA_StringSeq *);
-    operator CORBA_StringSeq *&();
-    CORBA_StringSeq *&ptr (void);
-    CORBA_StringSeq *operator-> (void);
+    StringSeq_out (StringSeq *&);
+    StringSeq_out (StringSeq_var &);
+    StringSeq_out (const StringSeq_out &);
+    StringSeq_out &operator= (const StringSeq_out &);
+    StringSeq_out &operator= (StringSeq *);
+    operator StringSeq *&();
+    StringSeq *&ptr (void);
+    StringSeq *operator-> (void);
     TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
     
   private:
-    CORBA_StringSeq *&ptr_;
+    StringSeq *&ptr_;
     // assignment from T_var not allowed
-    void operator= (const CORBA_StringSeq_var &);
+    void operator= (const StringSeq_var &);
   };
 
 
@@ -164,14 +167,14 @@
 #if !defined (_CORBA_WSTRINGSEQ_CH_)
 #define _CORBA_WSTRINGSEQ_CH_
 
-  class CORBA_WStringSeq;
-  class CORBA_WStringSeq_var;
+  class WStringSeq;
+  class WStringSeq_var;
   
   // *************************************************************
   // CORBA::WStringSeq
   // *************************************************************
   
-  class TAO_Export CORBA_WStringSeq : public 
+  class TAO_Export WStringSeq : public 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
     TAO_Unbounded_WString_Sequence
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
@@ -179,20 +182,20 @@
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
   {
   public:
-    CORBA_WStringSeq (void); // default ctor
-    CORBA_WStringSeq (CORBA::ULong max); // uses max size
-    CORBA_WStringSeq (
+    WStringSeq (void); // default ctor
+    WStringSeq (CORBA::ULong max); // uses max size
+    WStringSeq (
       CORBA::ULong max, 
       CORBA::ULong length, 
       CORBA::WChar * *buffer, 
       CORBA::Boolean release = 0
     );
-    CORBA_WStringSeq (const CORBA_WStringSeq &); // copy ctor
-    ~CORBA_WStringSeq (void);
+    WStringSeq (const WStringSeq &); // copy ctor
+    ~WStringSeq (void);
     static void _tao_any_destructor (void*);
 
 #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-    typedef CORBA_WStringSeq_var _var_type;
+    typedef WStringSeq_var _var_type;
 #endif /* ! __GNUC__ || g++ >= 2.8 */
 
   };
@@ -204,38 +207,38 @@
 #define _CORBA_WSTRINGSEQ___VAR_CH_
 
   // *************************************************************
-  // class CORBA_WStringSeq_var
+  // class WStringSeq_var
   // *************************************************************
 
-  class TAO_Export CORBA_WStringSeq_var
+  class TAO_Export WStringSeq_var
   {
   public:
-    CORBA_WStringSeq_var (void); // default constructor
-    CORBA_WStringSeq_var (CORBA_WStringSeq *);
-    CORBA_WStringSeq_var (const CORBA_WStringSeq_var &); // copy constructor
-    ~CORBA_WStringSeq_var (void); // destructor
+    WStringSeq_var (void); // default constructor
+    WStringSeq_var (WStringSeq *);
+    WStringSeq_var (const WStringSeq_var &); // copy constructor
+    ~WStringSeq_var (void); // destructor
     
-    CORBA_WStringSeq_var &operator= (CORBA_WStringSeq *);
-    CORBA_WStringSeq_var &operator= (const CORBA_WStringSeq_var &);
-    CORBA_WStringSeq *operator-> (void);
-    const CORBA_WStringSeq *operator-> (void) const;
+    WStringSeq_var &operator= (WStringSeq *);
+    WStringSeq_var &operator= (const WStringSeq_var &);
+    WStringSeq *operator-> (void);
+    const WStringSeq *operator-> (void) const;
     
-    operator const CORBA_WStringSeq &() const;
-    operator CORBA_WStringSeq &();
-    operator CORBA_WStringSeq &() const;
-    operator CORBA_WStringSeq *&(); // variable-size base types only
+    operator const WStringSeq &() const;
+    operator WStringSeq &();
+    operator WStringSeq &() const;
+    operator WStringSeq *&(); // variable-size base types only
     
     TAO_SeqElem_WString_Manager operator[] (CORBA::ULong index);
     
     // in, inout, out, _retn 
-    const CORBA_WStringSeq &in (void) const;
-    CORBA_WStringSeq &inout (void);
-    CORBA_WStringSeq *&out (void);
-    CORBA_WStringSeq *_retn (void);
-    CORBA_WStringSeq *ptr (void) const;
+    const WStringSeq &in (void) const;
+    WStringSeq &inout (void);
+    WStringSeq *&out (void);
+    WStringSeq *_retn (void);
+    WStringSeq *ptr (void) const;
 
   private:
-    CORBA_WStringSeq *ptr_;
+    WStringSeq *ptr_;
   };
 
 
@@ -245,38 +248,40 @@
 #if !defined (_CORBA_WSTRINGSEQ___OUT_CH_)
 #define _CORBA_WSTRINGSEQ___OUT_CH_
 
-  class TAO_Export CORBA_WStringSeq_out
+  class TAO_Export WStringSeq_out
   {
   public:
-    CORBA_WStringSeq_out (CORBA_WStringSeq *&);
-    CORBA_WStringSeq_out (CORBA_WStringSeq_var &);
-    CORBA_WStringSeq_out (const CORBA_WStringSeq_out &);
-    CORBA_WStringSeq_out &operator= (const CORBA_WStringSeq_out &);
-    CORBA_WStringSeq_out &operator= (CORBA_WStringSeq *);
-    operator CORBA_WStringSeq *&();
-    CORBA_WStringSeq *&ptr (void);
-    CORBA_WStringSeq *operator-> (void);
+    WStringSeq_out (WStringSeq *&);
+    WStringSeq_out (WStringSeq_var &);
+    WStringSeq_out (const WStringSeq_out &);
+    WStringSeq_out &operator= (const WStringSeq_out &);
+    WStringSeq_out &operator= (WStringSeq *);
+    operator WStringSeq *&();
+    WStringSeq *&ptr (void);
+    WStringSeq *operator-> (void);
     TAO_SeqElem_WString_Manager operator[] (CORBA::ULong index);
     
   private:
-    CORBA_WStringSeq *&ptr_;
+    WStringSeq *&ptr_;
     // assignment from T_var not allowed
-    void operator= (const CORBA_WStringSeq_var &);
+    void operator= (const WStringSeq_var &);
   };
 
 
 #endif /* end #if !defined */
 
+}  // End namespace CORBA
+
 // Proxy Broker Factory function pointer declarations.
 
-TAO_Export void operator<<= (CORBA::Any &, const CORBA_StringSeq &); // copying version
-TAO_Export void operator<<= (CORBA::Any &, CORBA_StringSeq*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_StringSeq *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA_StringSeq *&);
-TAO_Export void operator<<= (CORBA::Any &, const CORBA_WStringSeq &); // copying version
-TAO_Export void operator<<= (CORBA::Any &, CORBA_WStringSeq*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_WStringSeq *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA_WStringSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const CORBA::StringSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, CORBA::StringSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::StringSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::StringSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const CORBA::WStringSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, CORBA::WStringSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::WStringSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::WStringSeq *&);
 
 #ifndef __ACE_INLINE__
 
@@ -286,11 +291,11 @@ TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA_WStringSe
 
 TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA_StringSeq &
+    const CORBA::StringSeq &
   );
 TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA_StringSeq &
+    CORBA::StringSeq &
   );
 
 #endif /* _TAO_CDR_OP_CORBA_StringSeq_H_ */
@@ -301,11 +306,11 @@ TAO_Export CORBA::Boolean operator>> (
 
 TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA_WStringSeq &
+    const CORBA::WStringSeq &
   );
 TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA_WStringSeq &
+    CORBA::WStringSeq &
   );
 
 #endif /* _TAO_CDR_OP_CORBA_WStringSeq_H_ */
diff --git a/TAO/tao/StringSeqC.i b/TAO/tao/StringSeqC.i
index ea871fc4a05..dfce9610ce9 100644
--- a/TAO/tao/StringSeqC.i
+++ b/TAO/tao/StringSeqC.i
@@ -28,40 +28,40 @@
 // *************************************************************
 
 ACE_INLINE
-CORBA_StringSeq_var::CORBA_StringSeq_var (void) // default constructor
+CORBA::StringSeq_var::StringSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_StringSeq_var::CORBA_StringSeq_var (CORBA_StringSeq *p)
+CORBA::StringSeq_var::StringSeq_var (CORBA::StringSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_StringSeq_var::CORBA_StringSeq_var (const ::CORBA_StringSeq_var &p) // copy constructor
+CORBA::StringSeq_var::StringSeq_var (const ::CORBA::StringSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, ::CORBA_StringSeq (*p.ptr_));
+    ACE_NEW (this->ptr_, ::CORBA::StringSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_StringSeq_var::~CORBA_StringSeq_var (void) // destructor
+CORBA::StringSeq_var::~StringSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_StringSeq_var &
-CORBA_StringSeq_var::operator= (CORBA_StringSeq *p)
+ACE_INLINE CORBA::StringSeq_var &
+CORBA::StringSeq_var::operator= (CORBA::StringSeq *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE ::CORBA_StringSeq_var &
-CORBA_StringSeq_var::operator= (const ::CORBA_StringSeq_var &p)
+ACE_INLINE ::CORBA::StringSeq_var &
+CORBA::StringSeq_var::operator= (const ::CORBA::StringSeq_var &p)
 {
   if (this != &p)
     {
@@ -72,12 +72,12 @@ CORBA_StringSeq_var::operator= (const ::CORBA_StringSeq_var &p)
         }
       else
         {
-          CORBA_StringSeq *deep_copy =
-            new CORBA_StringSeq (*p.ptr_);
+          CORBA::StringSeq *deep_copy =
+            new CORBA::StringSeq (*p.ptr_);
           
           if (deep_copy != 0)
             {
-              CORBA_StringSeq *tmp = deep_copy;
+              CORBA::StringSeq *tmp = deep_copy;
               deep_copy = this->ptr_;
               this->ptr_ = tmp;
               delete deep_copy;
@@ -88,80 +88,80 @@ CORBA_StringSeq_var::operator= (const ::CORBA_StringSeq_var &p)
   return *this;
 }
 
-ACE_INLINE const ::CORBA_StringSeq *
-CORBA_StringSeq_var::operator-> (void) const
+ACE_INLINE const ::CORBA::StringSeq *
+CORBA::StringSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE ::CORBA_StringSeq *
-CORBA_StringSeq_var::operator-> (void)
+ACE_INLINE ::CORBA::StringSeq *
+CORBA::StringSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_StringSeq_var::operator const ::CORBA_StringSeq &() const // cast
+CORBA::StringSeq_var::operator const ::CORBA::StringSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_StringSeq_var::operator ::CORBA_StringSeq &() // cast 
+CORBA::StringSeq_var::operator ::CORBA::StringSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_StringSeq_var::operator ::CORBA_StringSeq &() const // cast 
+CORBA::StringSeq_var::operator ::CORBA::StringSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
 // variable-size types only
 ACE_INLINE
-CORBA_StringSeq_var::operator ::CORBA_StringSeq *&() // cast 
+CORBA::StringSeq_var::operator ::CORBA::StringSeq *&() // cast 
 {
   return this->ptr_;
 }
 
 ACE_INLINE TAO_SeqElem_String_Manager
-CORBA_StringSeq_var::operator[] (CORBA::ULong index)
+CORBA::StringSeq_var::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
 
-ACE_INLINE const ::CORBA_StringSeq &
-CORBA_StringSeq_var::in (void) const
+ACE_INLINE const ::CORBA::StringSeq &
+CORBA::StringSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE ::CORBA_StringSeq &
-CORBA_StringSeq_var::inout (void)
+ACE_INLINE ::CORBA::StringSeq &
+CORBA::StringSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE ::CORBA_StringSeq *&
-CORBA_StringSeq_var::out (void)
+ACE_INLINE ::CORBA::StringSeq *&
+CORBA::StringSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE ::CORBA_StringSeq *
-CORBA_StringSeq_var::_retn (void)
+ACE_INLINE ::CORBA::StringSeq *
+CORBA::StringSeq_var::_retn (void)
 {
-  ::CORBA_StringSeq *tmp = this->ptr_;
+  ::CORBA::StringSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE ::CORBA_StringSeq *
-CORBA_StringSeq_var::ptr (void) const
+ACE_INLINE ::CORBA::StringSeq *
+CORBA::StringSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
@@ -171,14 +171,14 @@ CORBA_StringSeq_var::ptr (void) const
 // *************************************************************
 
 ACE_INLINE
-CORBA_StringSeq_out::CORBA_StringSeq_out (CORBA_StringSeq *&p)
+CORBA::StringSeq_out::StringSeq_out (CORBA::StringSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_StringSeq_out::CORBA_StringSeq_out (CORBA_StringSeq_var &p) // constructor from _var
+CORBA::StringSeq_out::StringSeq_out (CORBA::StringSeq_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -186,44 +186,44 @@ CORBA_StringSeq_out::CORBA_StringSeq_out (CORBA_StringSeq_var &p) // constructor
 }
 
 ACE_INLINE
-CORBA_StringSeq_out::CORBA_StringSeq_out (const ::CORBA_StringSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_StringSeq_out&, p).ptr_)
+CORBA::StringSeq_out::StringSeq_out (const ::CORBA::StringSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA::StringSeq_out&, p).ptr_)
 {}
 
-ACE_INLINE ::CORBA_StringSeq_out &
-CORBA_StringSeq_out::operator= (const ::CORBA_StringSeq_out &p)
+ACE_INLINE ::CORBA::StringSeq_out &
+CORBA::StringSeq_out::operator= (const ::CORBA::StringSeq_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_StringSeq_out&, p).ptr_;
+  this->ptr_ = ACE_const_cast (CORBA::StringSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE ::CORBA_StringSeq_out &
-CORBA_StringSeq_out::operator= (CORBA_StringSeq *p)
+ACE_INLINE ::CORBA::StringSeq_out &
+CORBA::StringSeq_out::operator= (CORBA::StringSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_StringSeq_out::operator ::CORBA_StringSeq *&() // cast
+CORBA::StringSeq_out::operator ::CORBA::StringSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE ::CORBA_StringSeq *&
-CORBA_StringSeq_out::ptr (void) // ptr
+ACE_INLINE ::CORBA::StringSeq *&
+CORBA::StringSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE ::CORBA_StringSeq *
-CORBA_StringSeq_out::operator-> (void)
+ACE_INLINE ::CORBA::StringSeq *
+CORBA::StringSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE TAO_SeqElem_String_Manager
-CORBA_StringSeq_out::operator[] (CORBA::ULong index)
+CORBA::StringSeq_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
@@ -240,40 +240,40 @@ CORBA_StringSeq_out::operator[] (CORBA::ULong index)
 // *************************************************************
 
 ACE_INLINE
-CORBA_WStringSeq_var::CORBA_WStringSeq_var (void) // default constructor
+CORBA::WStringSeq_var::WStringSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_WStringSeq_var::CORBA_WStringSeq_var (CORBA_WStringSeq *p)
+CORBA::WStringSeq_var::WStringSeq_var (CORBA::WStringSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_WStringSeq_var::CORBA_WStringSeq_var (const ::CORBA_WStringSeq_var &p) // copy constructor
+CORBA::WStringSeq_var::WStringSeq_var (const ::CORBA::WStringSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, ::CORBA_WStringSeq (*p.ptr_));
+    ACE_NEW (this->ptr_, ::CORBA::WStringSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_WStringSeq_var::~CORBA_WStringSeq_var (void) // destructor
+CORBA::WStringSeq_var::~WStringSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_WStringSeq_var &
-CORBA_WStringSeq_var::operator= (CORBA_WStringSeq *p)
+ACE_INLINE CORBA::WStringSeq_var &
+CORBA::WStringSeq_var::operator= (CORBA::WStringSeq *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE ::CORBA_WStringSeq_var &
-CORBA_WStringSeq_var::operator= (const ::CORBA_WStringSeq_var &p)
+ACE_INLINE ::CORBA::WStringSeq_var &
+CORBA::WStringSeq_var::operator= (const ::CORBA::WStringSeq_var &p)
 {
   if (this != &p)
     {
@@ -284,12 +284,12 @@ CORBA_WStringSeq_var::operator= (const ::CORBA_WStringSeq_var &p)
         }
       else
         {
-          CORBA_WStringSeq *deep_copy =
-            new CORBA_WStringSeq (*p.ptr_);
+          CORBA::WStringSeq *deep_copy =
+            new CORBA::WStringSeq (*p.ptr_);
           
           if (deep_copy != 0)
             {
-              CORBA_WStringSeq *tmp = deep_copy;
+              CORBA::WStringSeq *tmp = deep_copy;
               deep_copy = this->ptr_;
               this->ptr_ = tmp;
               delete deep_copy;
@@ -300,80 +300,80 @@ CORBA_WStringSeq_var::operator= (const ::CORBA_WStringSeq_var &p)
   return *this;
 }
 
-ACE_INLINE const ::CORBA_WStringSeq *
-CORBA_WStringSeq_var::operator-> (void) const
+ACE_INLINE const ::CORBA::WStringSeq *
+CORBA::WStringSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE ::CORBA_WStringSeq *
-CORBA_WStringSeq_var::operator-> (void)
+ACE_INLINE ::CORBA::WStringSeq *
+CORBA::WStringSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_WStringSeq_var::operator const ::CORBA_WStringSeq &() const // cast
+CORBA::WStringSeq_var::operator const ::CORBA::WStringSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_WStringSeq_var::operator ::CORBA_WStringSeq &() // cast 
+CORBA::WStringSeq_var::operator ::CORBA::WStringSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_WStringSeq_var::operator ::CORBA_WStringSeq &() const // cast 
+CORBA::WStringSeq_var::operator ::CORBA::WStringSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
 // variable-size types only
 ACE_INLINE
-CORBA_WStringSeq_var::operator ::CORBA_WStringSeq *&() // cast 
+CORBA::WStringSeq_var::operator ::CORBA::WStringSeq *&() // cast 
 {
   return this->ptr_;
 }
 
 ACE_INLINE TAO_SeqElem_WString_Manager
-CORBA_WStringSeq_var::operator[] (CORBA::ULong index)
+CORBA::WStringSeq_var::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
 
-ACE_INLINE const ::CORBA_WStringSeq &
-CORBA_WStringSeq_var::in (void) const
+ACE_INLINE const ::CORBA::WStringSeq &
+CORBA::WStringSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE ::CORBA_WStringSeq &
-CORBA_WStringSeq_var::inout (void)
+ACE_INLINE ::CORBA::WStringSeq &
+CORBA::WStringSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE ::CORBA_WStringSeq *&
-CORBA_WStringSeq_var::out (void)
+ACE_INLINE ::CORBA::WStringSeq *&
+CORBA::WStringSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE ::CORBA_WStringSeq *
-CORBA_WStringSeq_var::_retn (void)
+ACE_INLINE ::CORBA::WStringSeq *
+CORBA::WStringSeq_var::_retn (void)
 {
-  ::CORBA_WStringSeq *tmp = this->ptr_;
+  ::CORBA::WStringSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE ::CORBA_WStringSeq *
-CORBA_WStringSeq_var::ptr (void) const
+ACE_INLINE ::CORBA::WStringSeq *
+CORBA::WStringSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
@@ -383,14 +383,14 @@ CORBA_WStringSeq_var::ptr (void) const
 // *************************************************************
 
 ACE_INLINE
-CORBA_WStringSeq_out::CORBA_WStringSeq_out (CORBA_WStringSeq *&p)
+CORBA::WStringSeq_out::WStringSeq_out (CORBA::WStringSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_WStringSeq_out::CORBA_WStringSeq_out (CORBA_WStringSeq_var &p) // constructor from _var
+CORBA::WStringSeq_out::WStringSeq_out (CORBA::WStringSeq_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -398,44 +398,44 @@ CORBA_WStringSeq_out::CORBA_WStringSeq_out (CORBA_WStringSeq_var &p) // construc
 }
 
 ACE_INLINE
-CORBA_WStringSeq_out::CORBA_WStringSeq_out (const ::CORBA_WStringSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_WStringSeq_out&, p).ptr_)
+CORBA::WStringSeq_out::WStringSeq_out (const ::CORBA::WStringSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA::WStringSeq_out&, p).ptr_)
 {}
 
-ACE_INLINE ::CORBA_WStringSeq_out &
-CORBA_WStringSeq_out::operator= (const ::CORBA_WStringSeq_out &p)
+ACE_INLINE ::CORBA::WStringSeq_out &
+CORBA::WStringSeq_out::operator= (const ::CORBA::WStringSeq_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_WStringSeq_out&, p).ptr_;
+  this->ptr_ = ACE_const_cast (CORBA::WStringSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE ::CORBA_WStringSeq_out &
-CORBA_WStringSeq_out::operator= (CORBA_WStringSeq *p)
+ACE_INLINE ::CORBA::WStringSeq_out &
+CORBA::WStringSeq_out::operator= (CORBA::WStringSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_WStringSeq_out::operator ::CORBA_WStringSeq *&() // cast
+CORBA::WStringSeq_out::operator ::CORBA::WStringSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE ::CORBA_WStringSeq *&
-CORBA_WStringSeq_out::ptr (void) // ptr
+ACE_INLINE ::CORBA::WStringSeq *&
+CORBA::WStringSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE ::CORBA_WStringSeq *
-CORBA_WStringSeq_out::operator-> (void)
+ACE_INLINE ::CORBA::WStringSeq *
+CORBA::WStringSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE TAO_SeqElem_WString_Manager
-CORBA_WStringSeq_out::operator[] (CORBA::ULong index)
+CORBA::WStringSeq_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
@@ -464,11 +464,11 @@ CORBA::Boolean TAO_Export operator>> (
 
 CORBA::Boolean TAO_Export operator<< (
     TAO_OutputCDR &,
-    const CORBA_WStringSeq &
+    const CORBA::WStringSeq &
   );
 CORBA::Boolean TAO_Export operator>> (
     TAO_InputCDR &,
-    CORBA_WStringSeq &
+    CORBA::WStringSeq &
   );
 
 #endif /* _TAO_CDR_OP_CORBA_WStringSeq_I_ */
diff --git a/TAO/tao/Typecode.cpp b/TAO/tao/Typecode.cpp
index 48068a7624e..f996a4d7328 100644
--- a/TAO/tao/Typecode.cpp
+++ b/TAO/tao/Typecode.cpp
@@ -1,24 +1,9 @@
-// $Id$
-
-
-// Typecodes essentially consist of just the CDR octets that get
-// marshaled and unmarshaled, and this code knows how to parse those
-// octets and answer questions CORBA's TypeCode APIs require.
-//
-// NOTE: This isn't well tuned performance-wise.  Given how much is
-// variable (byte order, alignment) it's clear tuning has its limits
-// with respect to CDR bytecode interpretation.
-//
-// THREADING NOTE: Typecodes are readonly data structures, and the
-// only mutual exclusion relates to reference counting and
-// construction.
-
 #include "tao/Typecode.h"
 #include "tao/Environment.h"
 #include "tao/Any.h"
 #include "tao/Exception.h"
-#include "tao/Principal.h"
 #include "tao/Marshal.h"
+#include "tao/CORBA_String.h"
 #include "tao/debug.h"
 #include "ace/Malloc_Base.h"
 
@@ -26,53 +11,57 @@
 # include "tao/Typecode.i"
 #endif /* ! __ACE_INLINE__ */
 
+
 ACE_RCSID (tao,
            Typecode,
            "$Id$")
 
 
-CORBA_TypeCode::Bounds::Bounds (void)
-  : CORBA_UserException ("IDL:omg.org/CORBA/TypeCode/Bounds:1.0",
-                         "Bounds")
+// Typecodes essentially consist of just the CDR octets that get
+// marshaled and unmarshaled, and this code knows how to parse those
+// octets and answer questions CORBA's TypeCode APIs require.
+
+CORBA::TypeCode::Bounds::Bounds (void)
+  : CORBA::UserException ("IDL:omg.org/CORBA/TypeCode/Bounds:1.0",
+                          "Bounds")
 {
 }
 
-CORBA_TypeCode::Bounds*
-CORBA_TypeCode::Bounds::_downcast (CORBA_Exception *ex)
+CORBA::TypeCode::Bounds*
+CORBA::TypeCode::Bounds::_downcast (CORBA::Exception *ex)
 {
   if (ex->_is_a ("IDL:omg.org/CORBA/TypeCode/Bounds:1.0"))
-    return ACE_dynamic_cast (CORBA_TypeCode::Bounds*, ex);
+    return ACE_dynamic_cast (CORBA::TypeCode::Bounds*, ex);
   return 0;
 }
 
-CORBA::Exception *CORBA_TypeCode::Bounds::_alloc (void)
+CORBA::Exception *
+CORBA::TypeCode::Bounds::_alloc (void)
 {
   CORBA::Exception *retval = 0;
-  ACE_NEW_RETURN (retval, ::CORBA_TypeCode::Bounds, 0);
+  ACE_NEW_RETURN (retval, ::CORBA::TypeCode::Bounds, 0);
   return retval;
 }
 
 CORBA::Exception *
-CORBA_TypeCode::Bounds::_tao_duplicate (void) const
+CORBA::TypeCode::Bounds::_tao_duplicate (void) const
 {
   CORBA::Exception *result;
-  ACE_NEW_RETURN (
-      result,
-      CORBA_TypeCode::Bounds (*this),
-      0
-    );
+  ACE_NEW_RETURN (result,
+                  CORBA::TypeCode::Bounds (*this),
+                  0);
   return result;
 }
 
-void CORBA_TypeCode::Bounds::_raise (void)
+void
+CORBA::TypeCode::Bounds::_raise (void)
 {
   TAO_RAISE(*this);
 }
 
-void CORBA_TypeCode::Bounds::_tao_encode (
-    TAO_OutputCDR &cdr
-    ACE_ENV_ARG_DECL
-  ) const
+void
+CORBA::TypeCode::Bounds::_tao_encode (TAO_OutputCDR &cdr
+                                      ACE_ENV_ARG_DECL) const
 {
   if (cdr << this->_rep_id ())
     {
@@ -82,48 +71,47 @@ void CORBA_TypeCode::Bounds::_tao_encode (
   ACE_THROW (CORBA::MARSHAL ());
 }
 
-void CORBA_TypeCode::Bounds::_tao_decode (TAO_InputCDR &
-                                          ACE_ENV_ARG_DECL_NOT_USED)
+void
+CORBA::TypeCode::Bounds::_tao_decode (TAO_InputCDR &
+                                      ACE_ENV_ARG_DECL_NOT_USED)
 {
 }
 
 // ****************************************************************
 
-CORBA_TypeCode::BadKind::BadKind (void)
-  : CORBA_UserException ("IDL:omg.org/CORBA/TypeCode/BadKind:1.0",
-                         "BadKind")
+CORBA::TypeCode::BadKind::BadKind (void)
+  : CORBA::UserException ("IDL:omg.org/CORBA/TypeCode/BadKind:1.0",
+                          "BadKind")
 {
 }
 
-CORBA_TypeCode::BadKind*
-CORBA_TypeCode::BadKind::_downcast (CORBA_Exception *ex)
+CORBA::TypeCode::BadKind*
+CORBA::TypeCode::BadKind::_downcast (CORBA::Exception *ex)
 {
   if (ex->_is_a ("IDL:omg.org/CORBA/TypeCode/BadKind:1.0"))
-    return ACE_dynamic_cast (CORBA_TypeCode::BadKind*, ex);
+    return ACE_dynamic_cast (CORBA::TypeCode::BadKind*, ex);
   return 0;
 }
 
 CORBA::Exception *
-CORBA_TypeCode::BadKind::_tao_duplicate (void) const
+CORBA::TypeCode::BadKind::_tao_duplicate (void) const
 {
   CORBA::Exception *result;
-  ACE_NEW_RETURN (
-      result,
-      CORBA_TypeCode::BadKind (*this),
-      0
-    );
+  ACE_NEW_RETURN (result,
+                  CORBA::TypeCode::BadKind (*this),
+                  0);
   return result;
 }
 
-void CORBA_TypeCode::BadKind::_raise (void)
+void
+CORBA::TypeCode::BadKind::_raise (void)
 {
   TAO_RAISE(*this);
 }
 
-void CORBA_TypeCode::BadKind::_tao_encode (
-    TAO_OutputCDR &cdr
-    ACE_ENV_ARG_DECL
-  ) const
+void
+CORBA::TypeCode::BadKind::_tao_encode (TAO_OutputCDR &cdr
+                                       ACE_ENV_ARG_DECL) const
 {
   if (cdr << this->_rep_id ())
     {
@@ -133,8 +121,9 @@ void CORBA_TypeCode::BadKind::_tao_encode (
   ACE_THROW (CORBA::MARSHAL ());
 }
 
-void CORBA_TypeCode::BadKind::_tao_decode (TAO_InputCDR &
-                                           ACE_ENV_ARG_DECL_NOT_USED)
+void
+CORBA::TypeCode::BadKind::_tao_decode (TAO_InputCDR &
+                                       ACE_ENV_ARG_DECL_NOT_USED)
 {
 }
 
@@ -143,7 +132,7 @@ void CORBA_TypeCode::BadKind::_tao_decode (TAO_InputCDR &
 // Constructor for CONSTANT typecodes with empty parameter lists.
 // These are only created once, and those constants are shared.
 
-CORBA_TypeCode::CORBA_TypeCode (CORBA::TCKind kind)
+CORBA::TypeCode::TypeCode (CORBA::TCKind kind)
   : length_ (0),
     buffer_ (0),
     byte_order_ (0),
@@ -153,23 +142,23 @@ CORBA_TypeCode::CORBA_TypeCode (CORBA::TCKind kind)
     root_tc_base_ (0),
     refcount_ (1),
     orb_owns_ (1),
-    private_state_ (new TC_Private_State (kind)),
+    private_state_ (new TAO::TC_Private_State (kind)),
     non_aligned_buffer_ (0)
 {
 }
 
-CORBA_TypeCode::CORBA_TypeCode (CORBA::TCKind kind,
-                                size_t length,
-                                const char *buffer,
-                                CORBA::Boolean orb_owns_tc,
-                                CORBA::ULong /* size */,
-                                CORBA::TypeCode_ptr parent)
+CORBA::TypeCode::TypeCode (CORBA::TCKind kind,
+                           size_t length,
+                           const char *buffer,
+                           CORBA::Boolean orb_owns_tc,
+                           CORBA::ULong /* size */,
+                           CORBA::TypeCode_ptr parent)
   : length_ (length),
     kind_ (kind),
     parent_ (parent),
     refcount_ (1),
     orb_owns_ (orb_owns_tc),
-    private_state_ (new TC_Private_State (kind)),
+    private_state_ (new TAO::TC_Private_State (kind)),
     non_aligned_buffer_ (0)
 {
   // The CDR code used to interpret TypeCodes requires in-memory
@@ -263,7 +252,7 @@ CORBA_TypeCode::CORBA_TypeCode (CORBA::TCKind kind,
 // Destructor.  For "indirected" typecodes and children, the typecode
 // reuses the buffer owned by its parent.
 
-CORBA_TypeCode::~CORBA_TypeCode (void)
+CORBA::TypeCode::~TypeCode (void)
 {
   // Delete the original, possibly nonaligned, buffer.
   delete [] this->non_aligned_buffer_;
@@ -284,43 +273,38 @@ CORBA_TypeCode::~CORBA_TypeCode (void)
 // Applicable only to struct, union, and except
 
 CORBA::TypeCode_ptr
-CORBA_TypeCode::member_type (CORBA::ULong slot
-                             ACE_ENV_ARG_DECL) const
+CORBA::TypeCode::member_type (CORBA::ULong slot
+                              ACE_ENV_ARG_DECL) const
 {
-  CORBA::TypeCode_ptr typecode = 0;
-
   if (this->private_state_->tc_member_count_known_
       && this->private_state_->tc_member_type_list_known_)
     {
       if (slot < this->private_state_->tc_member_count_)
         {
-          typecode = CORBA::TypeCode::_duplicate (
-                         this->private_state_->tc_member_type_list_[slot]
-                       );
+          return
+            CORBA::TypeCode::_duplicate (
+              this->private_state_->tc_member_type_list_[slot]);
         }
       else
         {
           ACE_THROW_RETURN (CORBA::TypeCode::Bounds (),
-                            0);
+                            CORBA::TypeCode::_nil ());
         }
     }
   else
     {
-      typecode = CORBA::TypeCode::_duplicate (
-                     this->private_member_type (slot
-                                                ACE_ENV_ARG_PARAMETER)
-                   );
-      ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
+      return
+        CORBA::TypeCode::_duplicate (
+          this->private_member_type (slot
+                                     ACE_ENV_ARG_PARAMETER));
     }
-
-  return typecode;
 }
 
 // Applicable only to struct, union, and except
 
 const char *
-CORBA_TypeCode::member_name (CORBA::ULong slot
-                             ACE_ENV_ARG_DECL) const
+CORBA::TypeCode::member_name (CORBA::ULong slot
+                              ACE_ENV_ARG_DECL) const
 {
   if (this->private_state_->tc_member_count_known_
       && this->private_state_->tc_member_name_list_known_)
@@ -344,8 +328,8 @@ CORBA_TypeCode::member_name (CORBA::ULong slot
 
 // Return the label of the i-th member.  Applicable only to CORBA::tk_union
 CORBA::Any_ptr
-CORBA_TypeCode::member_label (CORBA::ULong slot
-                              ACE_ENV_ARG_DECL) const
+CORBA::TypeCode::member_label (CORBA::ULong slot
+                               ACE_ENV_ARG_DECL) const
 {
   CORBA::Any_ptr retval = 0;
 
@@ -368,8 +352,9 @@ CORBA_TypeCode::member_label (CORBA::ULong slot
     }
   else
     {
-      CORBA::Any_ptr label = this->private_member_label (slot
-                                                          ACE_ENV_ARG_PARAMETER);
+      CORBA::Any_ptr label =
+        this->private_member_label (slot
+                                    ACE_ENV_ARG_PARAMETER);
       ACE_CHECK_RETURN (0);
 
       ACE_NEW_RETURN (retval,
@@ -382,26 +367,27 @@ CORBA_TypeCode::member_label (CORBA::ULong slot
 
 // only applicable to CORBA::tk_unions
 CORBA::TypeCode_ptr
-CORBA_TypeCode::discriminator_type (ACE_ENV_SINGLE_ARG_DECL) const
+CORBA::TypeCode::discriminator_type (ACE_ENV_SINGLE_ARG_DECL) const
 {
   if (this->kind_ != CORBA::tk_union)
-    ACE_THROW_RETURN (CORBA::TypeCode::BadKind (), (CORBA::TypeCode_ptr)0);
+    ACE_THROW_RETURN (CORBA::TypeCode::BadKind (),
+                      CORBA::TypeCode::_nil ());
 
   if (this->private_state_->tc_discriminator_type_known_)
-    return CORBA_TypeCode::_duplicate (
-               this->private_state_->tc_discriminator_type_
-             );
+    return
+      CORBA::TypeCode::_duplicate (
+        this->private_state_->tc_discriminator_type_);
 
   CORBA::TypeCode_ptr type =
     this->private_discriminator_type (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
 
-  return CORBA_TypeCode::_duplicate (type);
+  return CORBA::TypeCode::_duplicate (type);
 }
 
 // only applicable to CORBA::tk_unions
 CORBA::Long
-CORBA_TypeCode::default_index (ACE_ENV_SINGLE_ARG_DECL) const
+CORBA::TypeCode::default_index (ACE_ENV_SINGLE_ARG_DECL) const
 {
   if (this->kind_ != CORBA::tk_union)
     ACE_THROW_RETURN (CORBA::TypeCode::BadKind (), 0);
@@ -414,7 +400,7 @@ CORBA_TypeCode::default_index (ACE_ENV_SINGLE_ARG_DECL) const
 
 // returns the length. Applicable only to string, sequence, and arrays
 CORBA::ULong
-CORBA_TypeCode::length (ACE_ENV_SINGLE_ARG_DECL) const
+CORBA::TypeCode::length (ACE_ENV_SINGLE_ARG_DECL) const
 {
   // a switch stmt, unfortunately, doesn't get inlined
   if (this->kind_ == CORBA::tk_sequence
@@ -433,14 +419,14 @@ CORBA_TypeCode::length (ACE_ENV_SINGLE_ARG_DECL) const
 
 // returns the typecode. Applicable only to string, sequence, and arrays
 CORBA::TypeCode_ptr
-CORBA_TypeCode::content_type (ACE_ENV_SINGLE_ARG_DECL) const
+CORBA::TypeCode::content_type (ACE_ENV_SINGLE_ARG_DECL) const
 {
   if (this->kind_ == CORBA::tk_sequence
       || this->kind_ == CORBA::tk_array
       || this->kind_ == CORBA::tk_alias)
     {
       if (this->private_state_->tc_content_type_known_)
-        return CORBA_TypeCode::_duplicate (
+        return CORBA::TypeCode::_duplicate (
                    this->private_state_->tc_content_type_
                  );
       else
@@ -449,7 +435,7 @@ CORBA_TypeCode::content_type (ACE_ENV_SINGLE_ARG_DECL) const
             this->private_content_type (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
 
-          return CORBA_TypeCode::_duplicate (tmp);
+          return CORBA::TypeCode::_duplicate (tmp);
         }
     }
   else
@@ -461,8 +447,8 @@ CORBA_TypeCode::content_type (ACE_ENV_SINGLE_ARG_DECL) const
 }
 
 CORBA::Visibility
-CORBA_TypeCode::member_visibility (CORBA::ULong slot
-                                   ACE_ENV_ARG_DECL) const
+CORBA::TypeCode::member_visibility (CORBA::ULong slot
+                                    ACE_ENV_ARG_DECL) const
 {
   if (this->private_state_->tc_member_count_known_
       && this->private_state_->tc_member_visibility_list_known_)
@@ -489,7 +475,7 @@ CORBA_TypeCode::member_visibility (CORBA::ULong slot
 }
 
 CORBA::ValueModifier
-CORBA_TypeCode::type_modifier (ACE_ENV_SINGLE_ARG_DECL) const
+CORBA::TypeCode::type_modifier (ACE_ENV_SINGLE_ARG_DECL) const
 {
   if (this->private_state_->tc_type_modifier_known_)
     {
@@ -506,11 +492,11 @@ CORBA_TypeCode::type_modifier (ACE_ENV_SINGLE_ARG_DECL) const
 }
 
 CORBA::TypeCode_ptr
-CORBA_TypeCode::concrete_base_type (ACE_ENV_SINGLE_ARG_DECL) const
+CORBA::TypeCode::concrete_base_type (ACE_ENV_SINGLE_ARG_DECL) const
 {
   if (this->private_state_->tc_concrete_base_type_known_)
     {
-      return CORBA_TypeCode::_duplicate (
+      return CORBA::TypeCode::_duplicate (
           this->private_state_->tc_concrete_base_type_
           );
     }
@@ -520,14 +506,14 @@ CORBA_TypeCode::concrete_base_type (ACE_ENV_SINGLE_ARG_DECL) const
         this->private_concrete_base_type (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
 
-      return CORBA_TypeCode::_duplicate (tmp);
+      return CORBA::TypeCode::_duplicate (tmp);
     }
 }
 
 // skip a typecode encoding in a given CDR stream
 // This is just a helper function
 CORBA::Boolean
-CORBA_TypeCode::skip_typecode (TAO_InputCDR &stream)
+CORBA::TypeCode::skip_typecode (TAO_InputCDR &stream)
 {
   CORBA::ULong kind;
   CORBA::ULong temp;
@@ -571,7 +557,7 @@ CORBA_TypeCode::skip_typecode (TAO_InputCDR &stream)
 }
 
 // constructor for the private state
-TC_Private_State::TC_Private_State (CORBA::TCKind kind)
+TAO::TC_Private_State::TC_Private_State (CORBA::TCKind kind)
   : tc_kind_ (kind),
     tc_id_known_ (0),
     tc_name_known_ (0),
@@ -603,12 +589,12 @@ TC_Private_State::TC_Private_State (CORBA::TCKind kind)
 {
 }
 
-// destructor for the private state. In effect, this cleans up all the children
-// and the subtree we hold.
-TC_Private_State::~TC_Private_State (void)
+// Destructor for the private state. In effect, this cleans up all the
+// children and the subtree we hold.
+TAO::TC_Private_State::~TC_Private_State (void)
 {
-  // the following just point into the buffer. So we just make it
-  // point to 0
+  // The following just point into the buffer. So we just make it
+  // point to 0.
   this->tc_id_ = 0;
 
   if (this->tc_name_ != 0)
@@ -617,68 +603,66 @@ TC_Private_State::~TC_Private_State (void)
       this->tc_name_ = 0;
     }
 
-  // determine what kind of children we may have and free the space accordingly
+  // Determine what kind of children we may have and free the space
+  // accordingly.
   switch (this->tc_kind_)
     {
       case CORBA::tk_enum:
-          // free up the member name list
-          if (this->tc_member_name_list_known_)
-            {
-              for (CORBA::ULong i = 0;
-                   i < this->tc_member_count_;
-                   i++)
-                      {
-                        CORBA::string_free (this->tc_member_name_list_ [i]);
-                        this->tc_member_name_list_ [i] = 0;
-                      }
 
-              delete [] this->tc_member_name_list_;
-                    this->tc_member_name_list_ = 0;
-            }
+        // free up the member name list
+        if (this->tc_member_name_list_known_)
+          {
+            for (CORBA::ULong i = 0; i < this->tc_member_count_; ++i)
+              {
+                CORBA::string_free (this->tc_member_name_list_ [i]);
+                this->tc_member_name_list_ [i] = 0;
+              }
+
+            delete [] this->tc_member_name_list_;
+            this->tc_member_name_list_ = 0;
+          }
+
+        break;
 
-          break;
       case CORBA::tk_struct:
       case CORBA::tk_except:
-        {
-          // free up the member name list
-          if (this->tc_member_name_list_known_)
-            {
-              for (CORBA::ULong i = 0;
-                   i < this->tc_member_count_;
-                   i++)
-                      {
-                        CORBA::string_free (this->tc_member_name_list_ [i]);
-                        this->tc_member_name_list_ [i] = 0;
-                      }
 
-              delete [] this->tc_member_name_list_;
-                    this->tc_member_name_list_ = 0;
-            }
+        // Free up the member name list
+        if (this->tc_member_name_list_known_)
+          {
+            for (CORBA::ULong i = 0; i < this->tc_member_count_; ++i)
+              {
+                CORBA::string_free (this->tc_member_name_list_ [i]);
+                this->tc_member_name_list_ [i] = 0;
+              }
 
-          // free up member type list
-          if (this->tc_member_type_list_known_)
-            {
-              for (CORBA::ULong i = 0;
-                   i < this->tc_member_count_;
-                   i++)
-                      {
-                        CORBA::release (this->tc_member_type_list_[i]);
-                      }
+            delete [] this->tc_member_name_list_;
+            this->tc_member_name_list_ = 0;
+          }
 
-              // Now free up the array.
-              delete [] this->tc_member_type_list_;
-                    this->tc_member_type_list_ = 0;
-            }
-          this->tc_member_count_ = 0;
-        }
+        // Free up member type list
+        if (this->tc_member_type_list_known_)
+          {
+            for (CORBA::ULong i = 0; i < this->tc_member_count_; ++i)
+              {
+                CORBA::release (this->tc_member_type_list_[i]);
+              }
+
+            // Now free up the array.
+            delete [] this->tc_member_type_list_;
+            this->tc_member_type_list_ = 0;
+          }
+
+        this->tc_member_count_ = 0;
 
         break;
+
       case CORBA::tk_sequence:
       case CORBA::tk_array:
       case CORBA::tk_alias:
         // Delete the content type only if it has a parent i.e., if it
         // is not acquired from the pool of constant or predefined
-        // typecodes.
+        // TypeCodes.
         if (this->tc_content_type_known_ && this->tc_content_type_ != 0)
           {
             CORBA::release (this->tc_content_type_);
@@ -686,47 +670,43 @@ TC_Private_State::~TC_Private_State (void)
           }
 
         break;
+
       case CORBA::tk_union:
         {
-          // free up the member name list
+          // Free up the member name list.
           if (this->tc_member_name_list_known_)
             {
-              for (CORBA::ULong i = 0;
-                   i < this->tc_member_count_;
-                   i++)
-                      {
-                        CORBA::string_free (this->tc_member_name_list_ [i]);
-                        this->tc_member_name_list_ [i] = 0;
-                      }
+              for (CORBA::ULong i = 0; i < this->tc_member_count_; ++i)
+                {
+                  CORBA::string_free (this->tc_member_name_list_ [i]);
+                  this->tc_member_name_list_ [i] = 0;
+                }
 
               delete [] this->tc_member_name_list_;
             }
 
-          // Free up type list, label list, and finally the discriminator
+          // Free up type list, label list, and finally the
+          // discriminator.
           if (this->tc_member_type_list_known_)
             {
-              for (CORBA::ULong i = 0;
-                   i < this->tc_member_count_;
-                   i++)
-                      {
-                        CORBA::release (this->tc_member_type_list_[i]);
-                      }
+              for (CORBA::ULong i = 0; i < this->tc_member_count_; ++i)
+                {
+                  CORBA::release (this->tc_member_type_list_[i]);
+                }
 
               // Now free up the array.
               delete [] this->tc_member_type_list_;
-                    this->tc_member_type_list_ = 0;
+              this->tc_member_type_list_ = 0;
             }
 
           if (this->tc_member_label_list_known_)
             {
-              for (CORBA::ULong i = 0;
-                   i < this->tc_member_count_;
-                   i++)
+              for (CORBA::ULong i = 0; i < this->tc_member_count_; ++i)
                 // Free up the label (Any_ptr).
                 delete this->tc_member_label_list_[i];
 
               delete [] this->tc_member_label_list_;
-                    this->tc_member_label_list_ = 0;
+              this->tc_member_label_list_ = 0;
             }
 
           this->tc_member_count_ = 0;
@@ -738,67 +718,62 @@ TC_Private_State::~TC_Private_State (void)
         }
 
         break;
-      case CORBA::tk_value:
-        {
-          // Free up the member name list.
-          if (this->tc_member_name_list_known_)
-            {
-              for (CORBA::ULong i = 0;
-                   i < this->tc_member_count_;
-                   i++)
-                {
-                  CORBA::string_free (this->tc_member_name_list_ [i]);
-                  this->tc_member_name_list_ [i] = 0;
-                }
 
-              delete [] this->tc_member_name_list_;
-              this->tc_member_name_list_ = 0;
-            }
+      case CORBA::tk_value:
+        // Free up the member name list.
+        if (this->tc_member_name_list_known_)
+          {
+            for (CORBA::ULong i = 0; i < this->tc_member_count_; ++i)
+              {
+                CORBA::string_free (this->tc_member_name_list_ [i]);
+                this->tc_member_name_list_ [i] = 0;
+              }
 
-          // Free up member type list.
-          if (this->tc_member_type_list_known_)
-            {
-              for (CORBA::ULong i = 0;
-                   i < this->tc_member_count_;
-                   i++)
-                {
-                  CORBA::release (this->tc_member_type_list_[i]);
-                }
+            delete [] this->tc_member_name_list_;
+            this->tc_member_name_list_ = 0;
+          }
 
-              // Now free up the array.
-              delete [] this->tc_member_type_list_;
-              this->tc_member_type_list_ = 0;
-            }
+        // Free up member type list.
+        if (this->tc_member_type_list_known_)
+          {
+            for (CORBA::ULong i = 0; i < this->tc_member_count_; ++i)
+              {
+                CORBA::release (this->tc_member_type_list_[i]);
+              }
 
-          this->tc_member_count_ = 0;
+            // Now free up the array.
+            delete [] this->tc_member_type_list_;
+            this->tc_member_type_list_ = 0;
+          }
 
-          // Free up the member visibility list.
-          if (this->tc_member_visibility_list_known_)
-            {
-              delete [] this->tc_member_visibility_list_;
-              this->tc_member_visibility_list_ = 0;
-            }
+        this->tc_member_count_ = 0;
 
-          // Free up concrete base value typecode.
-          if (this->tc_concrete_base_type_known_)
-            {
-              CORBA::release (this->tc_concrete_base_type_);
-              this->tc_concrete_base_type_ = 0;
-            }
+        // Free up the member visibility list.
+        if (this->tc_member_visibility_list_known_)
+          {
+            delete [] this->tc_member_visibility_list_;
+            this->tc_member_visibility_list_ = 0;
+          }
 
-          break;
-      }
+        // Free up concrete base value typecode.
+        if (this->tc_concrete_base_type_known_)
+          {
+            CORBA::release (this->tc_concrete_base_type_);
+            this->tc_concrete_base_type_ = 0;
+          }
 
-      default:
         break;
+
+    default:
+      break;
     }
 }
 
 // Point of recursion for equal() and equivalent().
 CORBA::Boolean
-CORBA_TypeCode::equ_common (CORBA::TypeCode_ptr tc,
-                            CORBA::Boolean equiv_only
-                            ACE_ENV_ARG_DECL) const
+CORBA::TypeCode::equ_common (CORBA::TypeCode_ptr tc,
+                             CORBA::Boolean equiv_only
+                             ACE_ENV_ARG_DECL) const
 {
   // This will catch applications that haven't initialized an ORB.
   if (CORBA::is_nil (tc))
@@ -815,7 +790,7 @@ CORBA_TypeCode::equ_common (CORBA::TypeCode_ptr tc,
   if (equiv_only)
     {
       CORBA::TypeCode_var rcvr =
-        CORBA::TypeCode::_duplicate (ACE_const_cast (CORBA_TypeCode *,
+        CORBA::TypeCode::_duplicate (ACE_const_cast (CORBA::TypeCode *,
                                                      this));
 
       CORBA::Boolean status = (this->kind_ == CORBA::tk_alias);
@@ -825,7 +800,8 @@ CORBA_TypeCode::equ_common (CORBA::TypeCode_ptr tc,
           rcvr = rcvr->content_type (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_CHECK_RETURN (0);
 
-          status = (rcvr->kind (ACE_ENV_SINGLE_ARG_PARAMETER) == CORBA::tk_alias);
+          status =
+            (rcvr->kind (ACE_ENV_SINGLE_ARG_PARAMETER) == CORBA::tk_alias);
           ACE_CHECK_RETURN (0);
         }
 
@@ -836,7 +812,7 @@ CORBA_TypeCode::equ_common (CORBA::TypeCode_ptr tc,
       // Added by Bala to check for leaks as content_type duplicates the
       // pointers
       CORBA::TypeCode_var tcvar =
-        CORBA::TypeCode::_duplicate (ACE_const_cast (CORBA_TypeCode *,
+        CORBA::TypeCode::_duplicate (ACE_const_cast (CORBA::TypeCode *,
                                                      tc));
 
       while (status)
@@ -861,7 +837,7 @@ CORBA_TypeCode::equ_common (CORBA::TypeCode_ptr tc,
       // typecode kinds are same
       return rcvr->private_equal (tcvar.in (),
                                   equiv_only
-                                   ACE_ENV_ARG_PARAMETER);
+                                  ACE_ENV_ARG_PARAMETER);
     }
 
   CORBA::TCKind kind = tc->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
@@ -880,9 +856,9 @@ CORBA_TypeCode::equ_common (CORBA::TypeCode_ptr tc,
 // and name equivalence i.e., if names are provided, we also check for name
 // equivalence, else resort simply to structural equivalence.
 CORBA::Boolean
-CORBA_TypeCode::private_equal (CORBA::TypeCode_ptr tc,
-                               CORBA::Boolean equiv_only
-                               ACE_ENV_ARG_DECL) const
+CORBA::TypeCode::private_equal (CORBA::TypeCode_ptr tc,
+                                CORBA::Boolean equiv_only
+                                ACE_ENV_ARG_DECL) const
 {
   // We come in here only if the typecode kinds of both are same
   // Handle each complex typecode separately.
@@ -912,43 +888,43 @@ CORBA_TypeCode::private_equal (CORBA::TypeCode_ptr tc,
     case CORBA::tk_objref:
       return this->private_equal_objref (tc,
                                          equiv_only
-                                          ACE_ENV_ARG_PARAMETER);
+                                         ACE_ENV_ARG_PARAMETER);
     case CORBA::tk_struct:
       return this->private_equal_struct (tc,
                                          equiv_only
-                                          ACE_ENV_ARG_PARAMETER);
+                                         ACE_ENV_ARG_PARAMETER);
     case CORBA::tk_union:
       return this->private_equal_union (tc,
                                         equiv_only
-                                         ACE_ENV_ARG_PARAMETER);
+                                        ACE_ENV_ARG_PARAMETER);
     case CORBA::tk_enum:
       return this->private_equal_enum (tc,
                                        equiv_only
-                                        ACE_ENV_ARG_PARAMETER);
+                                       ACE_ENV_ARG_PARAMETER);
     case CORBA::tk_string:
       return this->private_equal_string (tc,
                                          equiv_only
-                                          ACE_ENV_ARG_PARAMETER);
+                                         ACE_ENV_ARG_PARAMETER);
     case CORBA::tk_wstring:
       return this->private_equal_wstring (tc,
                                           equiv_only
-                                           ACE_ENV_ARG_PARAMETER);
+                                          ACE_ENV_ARG_PARAMETER);
     case CORBA::tk_sequence:
       return this->private_equal_sequence (tc,
                                            equiv_only
-                                            ACE_ENV_ARG_PARAMETER);
+                                           ACE_ENV_ARG_PARAMETER);
     case CORBA::tk_array:
       return this->private_equal_array (tc,
                                         equiv_only
-                                         ACE_ENV_ARG_PARAMETER);
+                                        ACE_ENV_ARG_PARAMETER);
     case CORBA::tk_alias:
       return this->private_equal_alias (tc,
                                         equiv_only
-                                         ACE_ENV_ARG_PARAMETER);
+                                        ACE_ENV_ARG_PARAMETER);
     case CORBA::tk_except:
       return this->private_equal_except (tc,
                                          equiv_only
-                                          ACE_ENV_ARG_PARAMETER);
+                                         ACE_ENV_ARG_PARAMETER);
     case CORBA::tk_value:
       return this->private_equal_valuetype (tc,
                                             equiv_only
@@ -966,7 +942,7 @@ CORBA_TypeCode::private_equal (CORBA::TypeCode_ptr tc,
 }
 
 CORBA::Boolean
-CORBA_TypeCode::private_equal_objref (
+CORBA::TypeCode::private_equal_objref (
     CORBA::TypeCode_ptr tc,
     CORBA::Boolean equiv_only
     ACE_ENV_ARG_DECL
@@ -997,8 +973,8 @@ CORBA_TypeCode::private_equal_objref (
           const char *tcname = tc->name (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_CHECK_RETURN (0);
 
-          if ((ACE_OS::strlen (myname) > 1) &&
-              (ACE_OS::strlen (tcname) > 1))
+          if ((ACE_OS::strlen (myname) > 1)
+              && (ACE_OS::strlen (tcname) > 1))
             {
               // both of them specify names, compare them
               if (!ACE_OS::strcmp (myname, tcname))
@@ -1013,7 +989,7 @@ CORBA_TypeCode::private_equal_objref (
 }
 
 CORBA::Boolean
-CORBA_TypeCode::private_equal_struct (
+CORBA::TypeCode::private_equal_struct (
     CORBA::TypeCode_ptr tc,
     CORBA::Boolean equiv_only
     ACE_ENV_ARG_DECL
@@ -1088,7 +1064,7 @@ CORBA_TypeCode::private_equal_struct (
         }
     }
 
-  for (CORBA::ULong i = 0; i < my_count; i++)
+  for (CORBA::ULong i = 0; i < my_count; ++i)
     {
       // Skipped by equivalent().
       if (!equiv_only)
@@ -1111,12 +1087,14 @@ CORBA_TypeCode::private_equal_struct (
         }
 
       // now compare the typecodes of the members
-      CORBA::TypeCode_var my_member_tc = this->member_type (i
-                                                            ACE_ENV_ARG_PARAMETER);
+      CORBA::TypeCode_var my_member_tc =
+        this->member_type (i
+                           ACE_ENV_ARG_PARAMETER);
       ACE_CHECK_RETURN (0);
 
-      CORBA::TypeCode_var tc_member_tc = tc->member_type (i
-                                                          ACE_ENV_ARG_PARAMETER);
+      CORBA::TypeCode_var tc_member_tc =
+        tc->member_type (i
+                         ACE_ENV_ARG_PARAMETER);
       ACE_CHECK_RETURN (0);
 
       // One of our members may be recursive, but not through us.
@@ -1144,9 +1122,9 @@ CORBA_TypeCode::private_equal_struct (
 }
 
 CORBA::Boolean
-CORBA_TypeCode::private_equal_union (CORBA::TypeCode_ptr tc,
-                                     CORBA::Boolean equiv_only
-                                     ACE_ENV_ARG_DECL) const
+CORBA::TypeCode::private_equal_union (CORBA::TypeCode_ptr tc,
+                                      CORBA::Boolean equiv_only
+                                      ACE_ENV_ARG_DECL) const
 {
   // For unions the repoID and names are optional. However, if provided, we
   // must compare them
@@ -1199,7 +1177,7 @@ CORBA_TypeCode::private_equal_union (CORBA::TypeCode_ptr tc,
 
   CORBA::Boolean status = my_discrim->equ_common (tc_discrim.in (),
                                                   equiv_only
-                                                   ACE_ENV_ARG_PARAMETER);
+                                                  ACE_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
   if (!status)
@@ -1245,19 +1223,21 @@ CORBA_TypeCode::private_equal_union (CORBA::TypeCode_ptr tc,
         }
     }
 
-  for (CORBA::ULong i = 0; i < my_count; i++)
+  for (CORBA::ULong i = 0; i < my_count; ++i)
     {
       // First check if labels are same.
 
       // Check if member names are same - skipped by equivalent().
       if (!equiv_only)
         {
-          const char *my_member_name = this->member_name (i
-                                                           ACE_ENV_ARG_PARAMETER);
+          const char *my_member_name =
+            this->member_name (i
+                               ACE_ENV_ARG_PARAMETER);
           ACE_CHECK_RETURN (0);
 
-          const char *tc_member_name = tc->member_name (i
-                                                         ACE_ENV_ARG_PARAMETER);
+          const char *tc_member_name =
+            tc->member_name (i
+                             ACE_ENV_ARG_PARAMETER);
           ACE_CHECK_RETURN (0);
 
           if (ACE_OS::strlen (my_member_name) > 1
@@ -1268,12 +1248,14 @@ CORBA_TypeCode::private_equal_union (CORBA::TypeCode_ptr tc,
         }
 
       // now compare the typecodes of the members
-      CORBA::TypeCode_var my_member_tc = this->member_type (i
-                                                             ACE_ENV_ARG_PARAMETER);
+      CORBA::TypeCode_var my_member_tc =
+        this->member_type (i
+                           ACE_ENV_ARG_PARAMETER);
       ACE_CHECK_RETURN (0);
 
-      CORBA::TypeCode_var tc_member_tc = tc->member_type (i
-                                                           ACE_ENV_ARG_PARAMETER);
+      CORBA::TypeCode_var tc_member_tc =
+        tc->member_type (i
+                         ACE_ENV_ARG_PARAMETER);
       ACE_CHECK_RETURN (0);
 
       // One of our members may be recursive, but not through us.
@@ -1285,7 +1267,7 @@ CORBA_TypeCode::private_equal_union (CORBA::TypeCode_ptr tc,
 
       CORBA::Boolean flag = my_member_tc->equ_common (tc_member_tc.in (),
                                                       equiv_only
-                                                       ACE_ENV_ARG_PARAMETER);
+                                                      ACE_ENV_ARG_PARAMETER);
       ACE_CHECK_RETURN (0);
 
       if (!flag)
@@ -1296,12 +1278,12 @@ CORBA_TypeCode::private_equal_union (CORBA::TypeCode_ptr tc,
 }
 
 CORBA::Boolean
-CORBA_TypeCode::private_equal_enum (CORBA::TypeCode_ptr tc,
-                                    CORBA::Boolean equiv_only
-                                    ACE_ENV_ARG_DECL) const
+CORBA::TypeCode::private_equal_enum (CORBA::TypeCode_ptr tc,
+                                     CORBA::Boolean equiv_only
+                                     ACE_ENV_ARG_DECL) const
 {
-  // For enums the repoID and names are optional. However, if provided, we
-  // must compare them
+  // For enums the repoID and names are optional. However, if
+  // provided, we must compare them.
   const char *my_id = this->id (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
@@ -1350,17 +1332,19 @@ CORBA_TypeCode::private_equal_enum (CORBA::TypeCode_ptr tc,
   if (my_count != tc_count)
     return 0; // number of members don't match
 
-  for (CORBA::ULong i=0; i < my_count; i++)
+  for (CORBA::ULong i=0; i < my_count; ++i)
     {
       // Check if member names are same - skipped by equivalent().
       if (!equiv_only)
         {
-          const char *my_member_name = this->member_name (i
-                                                           ACE_ENV_ARG_PARAMETER);
+          const char *my_member_name =
+            this->member_name (i
+                               ACE_ENV_ARG_PARAMETER);
           ACE_CHECK_RETURN (0);
 
-          const char *tc_member_name = tc->member_name (i
-                                                         ACE_ENV_ARG_PARAMETER);
+          const char *tc_member_name =
+            tc->member_name (i
+                             ACE_ENV_ARG_PARAMETER);
           ACE_CHECK_RETURN (0);
 
           if (ACE_OS::strlen (my_member_name) > 1
@@ -1375,7 +1359,7 @@ CORBA_TypeCode::private_equal_enum (CORBA::TypeCode_ptr tc,
 }
 
 CORBA::Boolean
-CORBA_TypeCode::private_equal_string (
+CORBA::TypeCode::private_equal_string (
     CORBA::TypeCode_ptr tc,
     CORBA::Boolean /* equiv_only */
     ACE_ENV_ARG_DECL
@@ -1392,7 +1376,7 @@ CORBA_TypeCode::private_equal_string (
 }
 
 CORBA::Boolean
-CORBA_TypeCode::private_equal_wstring (
+CORBA::TypeCode::private_equal_wstring (
     CORBA::TypeCode_ptr tc,
     CORBA::Boolean /* equiv_only */
     ACE_ENV_ARG_DECL
@@ -1409,29 +1393,31 @@ CORBA_TypeCode::private_equal_wstring (
 }
 
 CORBA::Boolean
-CORBA_TypeCode::private_equal_sequence (
+CORBA::TypeCode::private_equal_sequence (
     CORBA::TypeCode_ptr tc,
     CORBA::Boolean equiv_only
     ACE_ENV_ARG_DECL
   ) const
 {
-  // this involves comparing the typecodes of the element type as well
-  // as the bounds
-  CORBA::TypeCode_var my_elem = this->content_type (ACE_ENV_SINGLE_ARG_PARAMETER);
+  // This involves comparing the typecodes of the element type as well
+  // as the bounds.
+  CORBA::TypeCode_var my_elem =
+    this->content_type (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
-  CORBA::TypeCode_var tc_elem = tc->content_type (ACE_ENV_SINGLE_ARG_PARAMETER);
+  CORBA::TypeCode_var tc_elem =
+    tc->content_type (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
   CORBA::Boolean status = my_elem->equ_common (tc_elem.in (),
                                                equiv_only
-                                                ACE_ENV_ARG_PARAMETER);
+                                               ACE_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
   if (!status)
     return 0;
 
-  // now check if bounds are same
+  // Now check if bounds are same.
   CORBA::ULong my_len = this->length (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
@@ -1442,23 +1428,23 @@ CORBA_TypeCode::private_equal_sequence (
 }
 
 CORBA::Boolean
-CORBA_TypeCode::private_equal_array (CORBA::TypeCode_ptr tc,
-                                     CORBA::Boolean equiv_only
-                                     ACE_ENV_ARG_DECL) const
+CORBA::TypeCode::private_equal_array (CORBA::TypeCode_ptr tc,
+                                      CORBA::Boolean equiv_only
+                                      ACE_ENV_ARG_DECL) const
 {
   // exactly like sequence
   return this->private_equal_sequence (tc,
                                        equiv_only
-                                        ACE_ENV_ARG_PARAMETER);
+                                       ACE_ENV_ARG_PARAMETER);
 }
 
 CORBA::Boolean
-CORBA_TypeCode::private_equal_alias (CORBA::TypeCode_ptr tc,
-                                     CORBA::Boolean equiv_only
-                                     ACE_ENV_ARG_DECL) const
+CORBA::TypeCode::private_equal_alias (CORBA::TypeCode_ptr tc,
+                                      CORBA::Boolean equiv_only
+                                      ACE_ENV_ARG_DECL) const
 {
-  // for structs the repoID and names are optional. However, if provided,
-  // we must compare them
+  // For structs the repoID and names are optional. However, if
+  // provided, we must compare them.
   const char *my_id = this->id (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
@@ -1471,34 +1457,37 @@ CORBA_TypeCode::private_equal_alias (CORBA::TypeCode_ptr tc,
   const char *tc_name = tc->name (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
-  // compare repoIDs if they exist
+  // Compare repository IDs if they exist.
   if (ACE_OS::strlen (my_id) > 1 && ACE_OS::strlen (tc_id) > 1)
     if (ACE_OS::strcmp (my_id, tc_id)) // not same
       return 0;
 
-  // compare names if they exist
+  // Compare names if they exist.
   if (ACE_OS::strlen (my_name) > 1 && ACE_OS::strlen (tc_name) > 1)
     if (ACE_OS::strcmp (my_name, tc_name)) // not same
       return 0;
 
-  // now compare element typecodes
-  CORBA::TypeCode_var my_elem = this->content_type (ACE_ENV_SINGLE_ARG_PARAMETER);
+  // Now compare element TypeCodes.
+  CORBA::TypeCode_var my_elem =
+    this->content_type (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
-  CORBA::TypeCode_var tc_elem = tc->content_type (ACE_ENV_SINGLE_ARG_PARAMETER);
+  CORBA::TypeCode_var tc_elem =
+    tc->content_type (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
   return my_elem->equ_common (tc_elem.in (),
                               equiv_only
-                               ACE_ENV_ARG_PARAMETER);
+                              ACE_ENV_ARG_PARAMETER);
 }
 
 CORBA::Boolean
-CORBA_TypeCode::private_equal_except (CORBA::TypeCode_ptr tc,
-                                      CORBA::Boolean equiv_only
-                                      ACE_ENV_ARG_DECL) const
+CORBA::TypeCode::private_equal_except (CORBA::TypeCode_ptr tc,
+                                       CORBA::Boolean equiv_only
+                                       ACE_ENV_ARG_DECL) const
 {
-  // exactly similar to structs, except that the repository ID is mandatory
+  // Exactly similar to structs, except that the repository ID is
+  // mandatory.
 
   const char *my_id = this->id (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
@@ -1534,7 +1523,7 @@ CORBA_TypeCode::private_equal_except (CORBA::TypeCode_ptr tc,
         return 0;
     }
 
-  // check if the member count is same
+  // Check if the member count is same
   CORBA::ULong my_count = this->member_count (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
@@ -1544,17 +1533,19 @@ CORBA_TypeCode::private_equal_except (CORBA::TypeCode_ptr tc,
   if (my_count != tc_count)
     return 0; // number of members don't match
 
-  for (CORBA::ULong i=0; i < my_count; i++)
+  for (CORBA::ULong i = 0; i < my_count; ++i)
     {
       // Check if member names are same - skipped by equivalent().
       if (!equiv_only)
         {
-          const char *my_member_name = this->member_name (i
-                                                           ACE_ENV_ARG_PARAMETER);
+          const char *my_member_name =
+            this->member_name (i
+                               ACE_ENV_ARG_PARAMETER);
           ACE_CHECK_RETURN (0);
 
-          const char *tc_member_name = tc->member_name (i
-                                                         ACE_ENV_ARG_PARAMETER);
+          const char *tc_member_name =
+            tc->member_name (i
+                             ACE_ENV_ARG_PARAMETER);
           ACE_CHECK_RETURN (0);
 
           if (ACE_OS::strlen (my_member_name) > 1
@@ -1565,15 +1556,17 @@ CORBA_TypeCode::private_equal_except (CORBA::TypeCode_ptr tc,
         }
 
       // now compare the typecodes of the members
-      CORBA::TypeCode_var my_member_tc = this->member_type (i ACE_ENV_ARG_PARAMETER);
+      CORBA::TypeCode_var my_member_tc =
+        this->member_type (i ACE_ENV_ARG_PARAMETER);
       ACE_CHECK_RETURN (0);
 
-      CORBA::TypeCode_var tc_member_tc = tc->member_type (i ACE_ENV_ARG_PARAMETER);
+      CORBA::TypeCode_var tc_member_tc =
+        tc->member_type (i ACE_ENV_ARG_PARAMETER);
       ACE_CHECK_RETURN (0);
 
       CORBA::Boolean flag = my_member_tc->equ_common (tc_member_tc.in (),
                                                       equiv_only
-                                                       ACE_ENV_ARG_PARAMETER);
+                                                      ACE_ENV_ARG_PARAMETER);
       ACE_CHECK_RETURN (0);
 
       if (!flag)
@@ -1586,7 +1579,7 @@ CORBA_TypeCode::private_equal_except (CORBA::TypeCode_ptr tc,
 
 //@@ boris: This version is incomplete...
 CORBA::Boolean
-CORBA_TypeCode::private_equal_valuetype (
+CORBA::TypeCode::private_equal_valuetype (
     CORBA::TypeCode_ptr tc,
     CORBA::Boolean equiv_only
     ACE_ENV_ARG_DECL
@@ -1610,15 +1603,15 @@ CORBA_TypeCode::private_equal_valuetype (
       // Name check is skipped by equivalent().
       else
         {
-          // same repository IDs. Now check their names
+          // Same repository IDs.  Now check their names.
           const char *myname = this->name (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_CHECK_RETURN (0);
 
           const char *tcname = tc->name (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_CHECK_RETURN (0);
 
-          if ((ACE_OS::strlen (myname) > 1) &&
-              (ACE_OS::strlen (tcname) > 1))
+          if ((ACE_OS::strlen (myname) > 1)
+              && (ACE_OS::strlen (tcname) > 1))
             {
               // both of them specify names, compare them
               if (!ACE_OS::strcmp (myname, tcname))
@@ -1640,7 +1633,7 @@ CORBA_TypeCode::private_equal_valuetype (
 // Valid only for objref, struct, union, enum, alias, and except. Raises
 // BadKind exception for the rest of the cases.
 const char *
-CORBA_TypeCode::private_id (ACE_ENV_SINGLE_ARG_DECL) const
+CORBA::TypeCode::private_id (ACE_ENV_SINGLE_ARG_DECL) const
 {
   switch (this->kind_)
     {
@@ -1680,7 +1673,7 @@ CORBA_TypeCode::private_id (ACE_ENV_SINGLE_ARG_DECL) const
 
 // return the name. The string is owned by the typecode
 const char *
-CORBA_TypeCode::private_name (ACE_ENV_SINGLE_ARG_DECL) const
+CORBA::TypeCode::private_name (ACE_ENV_SINGLE_ARG_DECL) const
 {
   switch (this->kind_)
     {
@@ -1734,7 +1727,7 @@ CORBA_TypeCode::private_name (ACE_ENV_SINGLE_ARG_DECL) const
 // For the rest of the cases, raises the BadKind exception.
 
 CORBA::ULong
-CORBA_TypeCode::private_member_count (ACE_ENV_SINGLE_ARG_DECL) const
+CORBA::TypeCode::private_member_count (ACE_ENV_SINGLE_ARG_DECL) const
 {
   switch (kind_)
     {
@@ -1892,8 +1885,8 @@ CORBA_TypeCode::private_member_count (ACE_ENV_SINGLE_ARG_DECL) const
 //
 
 CORBA::TypeCode_ptr
-CORBA_TypeCode::private_member_type (CORBA::ULong slot
-                                     ACE_ENV_ARG_DECL) const
+CORBA::TypeCode::private_member_type (CORBA::ULong slot
+                                      ACE_ENV_ARG_DECL) const
 {
   CORBA::ULong temp, mcount;
 
@@ -1961,7 +1954,7 @@ CORBA_TypeCode::private_member_type (CORBA::ULong slot
 
             CORBA::TypeCode_ptr& member_type =
               this->private_state_->tc_member_type_list_[i];
-            CORBA_TypeCode::_tao_decode (this,
+            CORBA::TypeCode::_tao_decode (this,
                                          stream,
                                          member_type
                                          ACE_ENV_ARG_PARAMETER);
@@ -2034,7 +2027,7 @@ CORBA_TypeCode::private_member_type (CORBA::ULong slot
         // required one
         ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
 
-        for (CORBA::ULong i = 0; i < mcount; i++)
+        for (CORBA::ULong i = 0; i < mcount; ++i)
           // the ith entry will have the typecode of the ith guy
           {
             // skip member label
@@ -2053,7 +2046,7 @@ CORBA_TypeCode::private_member_type (CORBA::ULong slot
 
             CORBA::TypeCode_ptr& member_type =
               this->private_state_->tc_member_type_list_[i];
-            CORBA_TypeCode::_tao_decode (this,
+            CORBA::TypeCode::_tao_decode (this,
                                          stream,
                                          member_type
                                          ACE_ENV_ARG_PARAMETER);
@@ -2159,7 +2152,7 @@ CORBA_TypeCode::private_member_type (CORBA::ULong slot
 
         // compute the typecodes for all the members and
         // return the required one.
-        for (CORBA::ULong i = 0; i < mcount; i++)
+        for (CORBA::ULong i = 0; i < mcount; ++i)
           // the ith entry will have the typecode of the ith guy
           {
             if (!stream.skip_string ())  // skip the name
@@ -2170,7 +2163,7 @@ CORBA_TypeCode::private_member_type (CORBA::ULong slot
 
             CORBA::TypeCode_ptr& member_type =
               this->private_state_->tc_member_type_list_[i];
-            CORBA_TypeCode::_tao_decode (this,
+            CORBA::TypeCode::_tao_decode (this,
                                          stream,
                                          member_type
                                          ACE_ENV_ARG_PARAMETER);
@@ -2212,8 +2205,8 @@ CORBA_TypeCode::private_member_type (CORBA::ULong slot
 // Applicable only to CORBA::tk_struct, CORBA::tk_union, CORBA::tk_enum, and
 // CORBA::tk_except
 const char *
-CORBA_TypeCode::private_member_name (CORBA::ULong slot
-                                     ACE_ENV_ARG_DECL) const
+CORBA::TypeCode::private_member_name (CORBA::ULong slot
+                                      ACE_ENV_ARG_DECL) const
 {
   CORBA::ULong temp, mcount;
 
@@ -2262,7 +2255,7 @@ CORBA_TypeCode::private_member_name (CORBA::ULong slot
 
         // compute the typecodes for all the members and
         // return the required one.
-        for (CORBA::ULong i = 0; i < mcount; i++)
+        for (CORBA::ULong i = 0; i < mcount; ++i)
           // now read this name
           if (!stream.read_string (
                       this->private_state_->tc_member_name_list_ [i]
@@ -2289,7 +2282,7 @@ CORBA_TypeCode::private_member_name (CORBA::ULong slot
 
         // compute the typecodes for all the members and
           // return the required one.
-        for (CORBA::ULong i = 0; i < mcount; i++)
+        for (CORBA::ULong i = 0; i < mcount; ++i)
           {
             if (!stream.read_string (
                    this->private_state_->tc_member_name_list_ [i]
@@ -2322,18 +2315,19 @@ CORBA_TypeCode::private_member_name (CORBA::ULong slot
           {
             // get the typecode for the discriminator
             CORBA::TypeCode_ptr disc_tc =
-              this->private_discriminator_type_i (ACE_ENV_SINGLE_ARG_PARAMETER);
-            // compute the name for all the members and return the
-            // required one
+              this->private_discriminator_type_i (
+                ACE_ENV_SINGLE_ARG_PARAMETER);
+            // Compute the name for all the members and return the
+            // required one.
             ACE_CHECK_RETURN (0);
 
-            for (CORBA::ULong i = 0; i < mcount; i++)
+            for (CORBA::ULong i = 0; i < mcount; ++i)
               {
-                // the ith entry will have the name of the ith member
+                // The ith entry will have the name of the ith member.
                 CORBA::TypeCode::traverse_status status =
                   TAO_Marshal_Object::perform_skip (disc_tc,
                                                     &stream
-                                                     ACE_ENV_ARG_PARAMETER);
+                                                    ACE_ENV_ARG_PARAMETER);
                 ACE_CHECK_RETURN (0);
 
                 if (status != CORBA::TypeCode::TRAVERSE_CONTINUE)
@@ -2367,8 +2361,8 @@ CORBA_TypeCode::private_member_name (CORBA::ULong slot
 
 // Return member labels for CORBA::tk_union typecodes.
 CORBA::Any_ptr
-CORBA_TypeCode::private_member_label (CORBA::ULong n
-                                      ACE_ENV_ARG_DECL) const
+CORBA::TypeCode::private_member_label (CORBA::ULong n
+                                       ACE_ENV_ARG_DECL) const
 {
   // this function is only applicable to the CORBA::tk_union TC
   if (this->kind_ != CORBA::tk_union)
@@ -2422,7 +2416,7 @@ CORBA_TypeCode::private_member_label (CORBA::ULong n
     this->private_discriminator_type_i (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
-  for (CORBA::ULong i = 0; i < member_count; i++)
+  for (CORBA::ULong i = 0; i < member_count; ++i)
     {
       // Create an any from the portion of the CDR stream created
       // above.....
@@ -2437,7 +2431,7 @@ CORBA_TypeCode::private_member_label (CORBA::ULong n
       int retval =
         TAO_Marshal_Object::perform_skip (disc_tc,
                                           &temp
-                                           ACE_ENV_ARG_PARAMETER);
+                                          ACE_ENV_ARG_PARAMETER);
       ACE_CHECK_RETURN (0);
 
       if (retval != CORBA::TypeCode::TRAVERSE_CONTINUE)
@@ -2475,7 +2469,7 @@ CORBA_TypeCode::private_member_label (CORBA::ULong n
           retval =
             TAO_Marshal_Object::perform_skip (disc_tc,
                                               &stream
-                                               ACE_ENV_ARG_PARAMETER);
+                                              ACE_ENV_ARG_PARAMETER);
           ACE_CHECK_RETURN (0);
 
           if (retval != CORBA::TypeCode::TRAVERSE_CONTINUE)
@@ -2491,7 +2485,7 @@ CORBA_TypeCode::private_member_label (CORBA::ULong n
             TAO_Marshal_Object::perform_append (label_tc,
                                                 &stream,
                                                 &out
-                                                 ACE_ENV_ARG_PARAMETER);
+                                                ACE_ENV_ARG_PARAMETER);
           ACE_CHECK_RETURN (0);
 
           if (retval != CORBA::TypeCode::TRAVERSE_CONTINUE)
@@ -2533,7 +2527,7 @@ CORBA_TypeCode::private_member_label (CORBA::ULong n
 }
 
 CORBA::TypeCode_ptr
-CORBA_TypeCode::private_discriminator_type (
+CORBA::TypeCode::private_discriminator_type (
     ACE_ENV_SINGLE_ARG_DECL
   ) const
 {
@@ -2545,7 +2539,7 @@ CORBA_TypeCode::private_discriminator_type (
 }
 
 CORBA::TypeCode_ptr
-CORBA_TypeCode::private_discriminator_type_i (
+CORBA::TypeCode::private_discriminator_type_i (
     ACE_ENV_SINGLE_ARG_DECL
   ) const
 {
@@ -2561,7 +2555,7 @@ CORBA_TypeCode::private_discriminator_type_i (
       || !stream.skip_string ())  // typedef name
     ACE_THROW_RETURN (CORBA::BAD_TYPECODE (), 0);
 
-  CORBA_TypeCode::_tao_decode (this,
+  CORBA::TypeCode::_tao_decode (this,
                                stream,
                                this->private_state_->tc_discriminator_type_
                                 ACE_ENV_ARG_PARAMETER);
@@ -2572,7 +2566,7 @@ CORBA_TypeCode::private_discriminator_type_i (
 }
 
 CORBA::Long
-CORBA_TypeCode::private_default_index (
+CORBA::TypeCode::private_default_index (
     ACE_ENV_SINGLE_ARG_DECL
   ) const
 {
@@ -2584,7 +2578,7 @@ CORBA_TypeCode::private_default_index (
 }
 
 CORBA::Long
-CORBA_TypeCode::private_default_index_i (
+CORBA::TypeCode::private_default_index_i (
     ACE_ENV_SINGLE_ARG_DECL
   ) const
 {
@@ -2607,7 +2601,7 @@ CORBA_TypeCode::private_default_index_i (
 }
 
 CORBA::Long
-CORBA_TypeCode::private_length (ACE_ENV_SINGLE_ARG_DECL) const
+CORBA::TypeCode::private_length (ACE_ENV_SINGLE_ARG_DECL) const
 {
   TAO_InputCDR stream (this->buffer_+4, this->length_-4,
                        this->byte_order_);
@@ -2661,7 +2655,7 @@ CORBA_TypeCode::private_length (ACE_ENV_SINGLE_ARG_DECL) const
 }
 
 CORBA::TypeCode_ptr
-CORBA_TypeCode::private_content_type (ACE_ENV_SINGLE_ARG_DECL) const
+CORBA::TypeCode::private_content_type (ACE_ENV_SINGLE_ARG_DECL) const
 {
   TAO_InputCDR stream (this->buffer_+4, this->length_-4,
                        this->byte_order_);
@@ -2677,7 +2671,7 @@ CORBA_TypeCode::private_content_type (ACE_ENV_SINGLE_ARG_DECL) const
           return this->private_state_->tc_content_type_;
 
         // retrieve the content type
-        CORBA_TypeCode::_tao_decode (this,
+        CORBA::TypeCode::_tao_decode (this,
                                      stream,
                                      this->private_state_->tc_content_type_
                                       ACE_ENV_ARG_PARAMETER);
@@ -2700,7 +2694,7 @@ CORBA_TypeCode::private_content_type (ACE_ENV_SINGLE_ARG_DECL) const
             || !stream.skip_string ()) // name
           ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
 
-        CORBA_TypeCode::_tao_decode (this,
+        CORBA::TypeCode::_tao_decode (this,
                                      stream,
                                      this->private_state_->tc_content_type_
                                      ACE_ENV_ARG_PARAMETER);
@@ -2718,7 +2712,7 @@ CORBA_TypeCode::private_content_type (ACE_ENV_SINGLE_ARG_DECL) const
 }
 
 CORBA::Visibility
-CORBA_TypeCode::private_member_visibility (CORBA::ULong slot
+CORBA::TypeCode::private_member_visibility (CORBA::ULong slot
                                            ACE_ENV_ARG_DECL) const
 {
   if (this->kind_ != CORBA::tk_value)
@@ -2791,7 +2785,7 @@ CORBA_TypeCode::private_member_visibility (CORBA::ULong slot
 }
 
 CORBA::ValueModifier
-CORBA_TypeCode::private_type_modifier (ACE_ENV_SINGLE_ARG_DECL) const
+CORBA::TypeCode::private_type_modifier (ACE_ENV_SINGLE_ARG_DECL) const
 {
   if (this->kind_ != CORBA::tk_value)
     {
@@ -2834,7 +2828,7 @@ CORBA_TypeCode::private_type_modifier (ACE_ENV_SINGLE_ARG_DECL) const
 }
 
 CORBA::TypeCode_ptr
-CORBA_TypeCode::private_concrete_base_type (ACE_ENV_SINGLE_ARG_DECL) const
+CORBA::TypeCode::private_concrete_base_type (ACE_ENV_SINGLE_ARG_DECL) const
 {
   if (this->kind_ != CORBA::tk_value)
     {
@@ -2871,7 +2865,7 @@ CORBA_TypeCode::private_concrete_base_type (ACE_ENV_SINGLE_ARG_DECL) const
     }
 
   // Retrieve the concrete base typecode.
-  CORBA_TypeCode::_tao_decode (this,
+  CORBA::TypeCode::_tao_decode (this,
                                stream,
                                this->private_state_->tc_concrete_base_type_
                                ACE_ENV_ARG_PARAMETER);
@@ -2884,9 +2878,9 @@ CORBA_TypeCode::private_concrete_base_type (ACE_ENV_SINGLE_ARG_DECL) const
 // ****************************************************************
 
 void
-CORBA_TypeCode::_tao_decode (const CORBA_TypeCode *parent,
+CORBA::TypeCode::_tao_decode (const CORBA::TypeCode *parent,
                              TAO_InputCDR &cdr,
-                             CORBA_TypeCode *&x
+                             CORBA::TypeCode *&x
                              ACE_ENV_ARG_DECL)
 {
   x = 0;
@@ -2914,23 +2908,23 @@ CORBA_TypeCode::_tao_decode (const CORBA_TypeCode *parent,
     CORBA::_tc_TypeCode,
     CORBA::_tc_Principal,
 
-    0, // CORBA::_tc_Object ... type ID is CORBA_Object
-    0, // CORBA_tk_struct
-    0, // CORBA_tk_union
-    0, // CORBA_tk_enum
+    0, // CORBA::_tc_Object ... type ID is CORBA::Object
+    0, // CORBA::tk_struct
+    0, // CORBA::tk_union
+    0, // CORBA::tk_enum
     0, // CORBA::_tc_string ... unbounded
-    0, // CORBA_tk_sequence
-    0, // CORBA_tk_array
-    0, // CORBA_tk_alias
-    0, // CORBA_tk_except
+    0, // CORBA::tk_sequence
+    0, // CORBA::tk_array
+    0, // CORBA::tk_alias
+    0, // CORBA::tk_except
 
     CORBA::_tc_longlong,
     CORBA::_tc_ulonglong,
     CORBA::_tc_longdouble,
     CORBA::_tc_wchar,
     0,  // CORBA::_tc_wstring ... unbounded
-    0,  // CORBA_tk_fixed @@ boris: This is unsupported but I need next value
-    0,  // CORBA_tk_value
+    0,  // CORBA::tk_fixed @@ boris: This is unsupported but I need next value
+    0,  // CORBA::tk_value
   };
 
   if (kind < CORBA::TC_KIND_COUNT && tc_consts [kind] != 0)
@@ -3030,7 +3024,7 @@ CORBA_TypeCode::_tao_decode (const CORBA_TypeCode *parent,
                                 // @@ TODO
                                 // Here we lose the parent
                                 // typecode...
-                                ACE_const_cast(CORBA_TypeCode*,parent)));
+                                ACE_const_cast(CORBA::TypeCode*,parent)));
       return;
     }
 
@@ -3116,7 +3110,7 @@ CORBA_TypeCode::_tao_decode (const CORBA_TypeCode *parent,
                                   cdr.rd_ptr (),
                                   0,
                                   0,
-                                  ACE_const_cast (CORBA_TypeCode*,parent)));
+                                  ACE_const_cast (CORBA::TypeCode*,parent)));
         // skip length number of bytes in the stream, otherwise we may
         // leave the stream in an undefined state
         (void) cdr.skip_bytes (length);
@@ -3139,7 +3133,7 @@ CORBA_TypeCode::_tao_decode (const CORBA_TypeCode *parent,
 // provides.
 
 CORBA::ULong
-CORBA_TypeCode::param_count (ACE_ENV_SINGLE_ARG_DECL) const
+CORBA::TypeCode::param_count (ACE_ENV_SINGLE_ARG_DECL) const
 {
   switch (this->kind_)
     {
@@ -3212,7 +3206,7 @@ CORBA_TypeCode::param_count (ACE_ENV_SINGLE_ARG_DECL) const
 }
 
 CORBA::Any_ptr
-CORBA_TypeCode::parameter (const CORBA::Long /* slot */
+CORBA::TypeCode::parameter (const CORBA::Long /* slot */
                            ACE_ENV_ARG_DECL)
 {
   ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (TAO_DEFAULT_MINOR_CODE,
@@ -3302,7 +3296,7 @@ operator>> (TAO_InputCDR& cdr, CORBA::TypeCode *&x)
 {
   ACE_TRY_NEW_ENV
     {
-      CORBA_TypeCode::_tao_decode (0, cdr, x ACE_ENV_ARG_PARAMETER);
+      CORBA::TypeCode::_tao_decode (0, cdr, x ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -3315,10 +3309,10 @@ operator>> (TAO_InputCDR& cdr, CORBA::TypeCode *&x)
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
 
-template class TAO_Pseudo_Object_Manager<CORBA_TypeCode,CORBA_TypeCode_var>;
+template class TAO_Pseudo_Object_Manager<CORBA::TypeCode, CORBA::TypeCode_var>;
 
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
 
-#pragma instantiate TAO_Pseudo_Object_Manager<CORBA_TypeCode,CORBA_TypeCode_var>
+#pragma instantiate TAO_Pseudo_Object_Manager<CORBA::TypeCode, CORBA::TypeCode_var>
 
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/TAO/tao/Typecode.h b/TAO/tao/Typecode.h
index d3f412fef1d..e186cb2de0a 100644
--- a/TAO/tao/Typecode.h
+++ b/TAO/tao/Typecode.h
@@ -9,12 +9,14 @@
  *  Header file CORBA's "TypeCode" type.
  *
  *  @author  Copyright 1994-1995 by Sun Microsystems, Inc.
+ *  @author  DOC group at Wash U, UCI and Vanderbilt U.
  */
 //=============================================================================
 
 
 #ifndef TAO_TYPECODE_H
 #define TAO_TYPECODE_H
+
 #include "ace/pre.h"
 
 #include "ace/Synch.h"
@@ -25,577 +27,605 @@
 
 #include "tao/Exception.h"
 
-// Forward decl.
+// Forward declarations
 class TAO_InputCDR;
 class TAO_OutputCDR;
 
-// A TypeCode describes data.  This one's as thin a wrapper around CDR
-// octet sequences as is practical.  There are guesses here about how
-// the OMG C++ mapping and CORBA 2.0 IFR specification will interact.
-//
-// NOTE: Use TypeCode_ptr, except in code (e.g. output of and OMG-IDL
-// compiler) that needs to create typecodes from their octet-sequence
-// encodings.
-
-class TC_Private_State;
-
-/**
- * @class CORBA_TypeCode
- *
- * @brief The CORBA TypeCode class. It maintains the in-memory
- * representation of any OMG CORBA IDL data type.
- *
- * Implements the CORBA::TypeCode interface specified by CORBA 2.0
- * spec.  Typecodes essentially consist of just the CDR octets
- * that get marshaled and unmarshaled, and this code knows how to
- * parse those octets and answer questions CORBA's TypeCode APIs
- * require.
- * NOTE: This isn't well tuned performance-wise.  Given how much
- * is variable (byte order, alignment) it's clear tuning has its
- * limits with respect to CDR bytecode interpretation.
- * THREADING NOTE: Typecodes are readonly data structures, and the
- * only mutual exclusion relates to reference counting and
- * construction.
- */
-class TAO_Export CORBA_TypeCode
+namespace TAO
 {
-public:
-
-  // Two "user exceptions" are defined for manipulating TypeCodes. These
-  // two classes are defined inside the TypeCode class.
-  class TAO_Export Bounds : public CORBA_UserException
-  {
-  public:
-    Bounds (void);
-
-    static Bounds* _downcast (CORBA_Exception *ex);
-    static CORBA::Exception *_alloc (void);
-
-    virtual CORBA::Exception *_tao_duplicate (void) const;
-
-    virtual void _raise (void);
+  class TC_Private_State;
+}
 
-    virtual void _tao_encode (TAO_OutputCDR &cdr
-                              ACE_ENV_ARG_DECL_NOT_USED) const;
-    virtual void _tao_decode (TAO_InputCDR &cdr
-                              ACE_ENV_ARG_DECL_NOT_USED);
-  };
-
-  class TAO_Export BadKind : public CORBA_UserException
+namespace CORBA
+{
+  /**
+   * @class TypeCode
+   *
+   * @brief The CORBA TypeCode class. It maintains the in-memory
+   * representation of any OMG CORBA IDL data type.
+   *
+   * Implements the CORBA::TypeCode interface specified by CORBA 2.0
+   * spec.  Typecodes essentially consist of just the CDR octets
+   * that get marshaled and unmarshaled, and this code knows how to
+   * parse those octets and answer questions CORBA's TypeCode APIs
+   * require.
+   * @par
+   * A TypeCode describes data.  This one's as thin a wrapper around
+   * CDR octet sequences as is practical.  There are guesses here
+   * about how the OMG C++ mapping and CORBA 2.0 IfR specification
+   * will interact.
+   *
+   * @note Use TypeCode_ptr, except in code (e.g. output of and
+   *       OMG-IDL / compiler) that needs to create typecodes from
+   *       their octet-sequence encodings.
+   *
+   * @note This isn't well tuned performance-wise.  Given how much is
+   *       variable (byte order, alignment) it's clear tuning has its
+   *       limits with respect to CDR bytecode interpretation.
+   *
+   *
+   * @note (THREADING) Typecodes are readonly data structures, and the
+   *       only mutual exclusion relates to reference counting and
+   *       construction.
+   */
+  class TAO_Export TypeCode
   {
   public:
-    BadKind (void);
 
-    static BadKind* _downcast (CORBA_Exception *ex);
-    static CORBA::Exception *_alloc (void);
+    // Two "user exceptions" are defined for manipulating TypeCodes. These
+    // two classes are defined inside the TypeCode class.
+    class TAO_Export Bounds : public CORBA::UserException
+    {
+    public:
+      Bounds (void);
 
-    virtual CORBA::Exception *_tao_duplicate (void) const;
+      static Bounds* _downcast (CORBA::Exception *ex);
+      static CORBA::Exception *_alloc (void);
 
-    virtual void _raise (void);
+      virtual CORBA::Exception *_tao_duplicate (void) const;
 
-    virtual void _tao_encode (TAO_OutputCDR &cdr
-                              ACE_ENV_ARG_DECL_NOT_USED) const;
-    virtual void _tao_decode (TAO_InputCDR &cdr
-                              ACE_ENV_ARG_DECL_NOT_USED);
-  };
+      virtual void _raise (void);
 
-  static CORBA::TypeCode_ptr _tc_Bounds;
-  static CORBA::TypeCode_ptr _tc_BadKind;
+      virtual void _tao_encode (TAO_OutputCDR &cdr
+                                ACE_ENV_ARG_DECL_NOT_USED) const;
+      virtual void _tao_decode (TAO_InputCDR &cdr
+                                ACE_ENV_ARG_DECL_NOT_USED);
+    };
 
-  /// Duplicates i.e., increments ref count.
-  static CORBA::TypeCode_ptr _duplicate (CORBA::TypeCode_ptr tc);
+    class TAO_Export BadKind : public CORBA::UserException
+    {
+    public:
+      BadKind (void);
 
-  /// Returns a NULL typecode.
-  static CORBA::TypeCode_ptr _nil (void);
+      static BadKind* _downcast (CORBA::Exception *ex);
+      static CORBA::Exception *_alloc (void);
 
-  /// Compares two typecodes. Must be identical in every respect.
-  CORBA::Boolean equal (CORBA::TypeCode_ptr
-                        ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
+      virtual CORBA::Exception *_tao_duplicate (void) const;
 
-  /// Conforms to CORBA 2.3.1 (99-10-07).
-  CORBA::Boolean equivalent (CORBA::TypeCode_ptr
-                             ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
+      virtual void _raise (void);
 
-  /// For all TypeCode kinds, returns the "kind" of the typecode.
-  CORBA::TCKind kind (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
+      virtual void _tao_encode (TAO_OutputCDR &cdr
+                                ACE_ENV_ARG_DECL_NOT_USED) const;
+      virtual void _tao_decode (TAO_InputCDR &cdr
+                                ACE_ENV_ARG_DECL_NOT_USED);
+    };
 
-  /// For tk_{objref,struct,union,enum,alias,except}. Returns the
-  /// repository ID, raises BadKind.
-  const char *id (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
+    static CORBA::TypeCode_ptr _tc_Bounds;
+    static CORBA::TypeCode_ptr _tc_BadKind;
 
-  /// Returns name (), raises (BadKind).
-  const char *name (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
+    /// Duplicates i.e., increments ref count.
+    static CORBA::TypeCode_ptr _duplicate (CORBA::TypeCode_ptr tc);
 
-  /// Returns member_count (), raises (BadKind). Useful for tk_struct,
-  /// tk_union, tk_enum, tk_alias, and tk_except.
-  CORBA::ULong member_count (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
+    /// Returns a NULL typecode.
+    static CORBA::TypeCode_ptr _nil (void);
 
-  /// Returns member_name (...), raises (BadKind, Bounds); Useful for
-  /// tk_struct, tk_union, tk_enum, tk_alias, and tk_except.
-  const char *member_name (CORBA::ULong slot
-                           ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
+    /// Compares two typecodes. Must be identical in every respect.
+    CORBA::Boolean equal (CORBA::TypeCode_ptr
+                          ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
 
-  /// Returns member_type (...), raises (BadKind, Bounds); Useful for
-  /// tk_struct, tk_union, and tk_except.
-  CORBA::TypeCode_ptr member_type (CORBA::ULong slot
-                                   ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
-
-  /// For tk_union. Returns the label. Raises BadKind, Bounds.
-  CORBA::Any_ptr member_label (CORBA::ULong n
+    /// Conforms to CORBA 2.3.1 (99-10-07).
+    CORBA::Boolean equivalent (CORBA::TypeCode_ptr
                                ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
 
-  /// Returns the discriminator type for tk_union. raises (BadKind).
-  CORBA::TypeCode_ptr discriminator_type (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
-
-  /// Returns the default slot for the tk_union. Raises (BadKind).
-  CORBA::Long default_index (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
-
-  /// Returns length, raises (BadKind). Used for tk_string,
-  /// tk_sequence, and tk_array.
-  CORBA::ULong length (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
-
-  /// Returns the content type (element type). Raises (BadKind); Useful
-  /// for tk_sequence, tk_array, and tk_alias.
-  CORBA::TypeCode_ptr content_type (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
-
-  /// Returns the visibility (public/private) of the member at index 'slot'.
-  /// Raises (BadKind, Bounds). Useful for tk_value only.
-  CORBA::Visibility member_visibility (CORBA::ULong slot
-                                       ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
-
-  /// Returns the value modifier. Raises (BadKind). Useful for tk_value only.
-  CORBA::ValueModifier type_modifier (
-      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
-    ) const;
-
-  /// Returns the concrete base type. Raises (BadKind); Useful
-  /// for tk_value only.
-  CORBA::TypeCode_ptr concrete_base_type (
-      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
-      ) const;
+    /// For all TypeCode kinds, returns the "kind" of the typecode.
+    CORBA::TCKind kind (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
 
-  // = Creation/refcounting
+    /// For tk_{objref,struct,union,enum,alias,except}. Returns the
+    /// repository ID, raises BadKind.
+    const char *id (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
 
-  // These aren't really public APIs, but an IDL compiler will need to
-  // be able to create TypeCodes as part of creating stubs.
+    /// Returns name (), raises (BadKind).
+    const char *name (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
 
-  /// This constructor is used only for built-in TypeCode constants,
-  /// with no parameters.
-  CORBA_TypeCode (CORBA::TCKind kind);
+    /// Returns member_count (), raises (BadKind). Useful for tk_struct,
+    /// tk_union, tk_enum, tk_alias, and tk_except.
+    CORBA::ULong member_count (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
 
-  /**
-   * This constructor is used both for typecode constants and for
-   * heap-allocated TypeCodes.  The two are distinguished by the
-   * orb_owns_tc flag passed in by the creator.
-   *
-   * For simple param lists with a single numeric parameter, only
-   * 'length' matters.
-   *
-   * For complex param lists, or simple param lists for which the
-   * parameter is a string or typecode, length _and_ buffer matter.
-   *
-   * For typecodes that are precomputed from the encapsulation stream
-   * of the parent, even the "parent" argument matters because this
-   * implies that all children will share the octet buffers of its
-   * parent
-   */
-  CORBA_TypeCode (CORBA::TCKind kind,
-                  size_t length,
-                  const char *buffer,
-                  CORBA::Boolean orb_owns_tc,
-                  CORBA::ULong size,
-                  CORBA::TypeCode_ptr parent = 0);
-
-  /// destructor
-  ~CORBA_TypeCode (void);
-
-  enum traverse_status
-  {
-    TRAVERSE_STOP,
-    TRAVERSE_CONTINUE
-  };
-  // these are used to indicate the status of marshaling
-
-  // Reference counting operations.
-  CORBA::ULong _incr_refcnt (void);
-  CORBA::ULong _decr_refcnt (void);
-
-  // = Following three are deprecated
-
-  // The following are deprecated in the CORBA 2.2 spec and are
-  // missing altogether from 2.3a (98-12-04), but they are included
-  // here as no-ops so legacy apps won't completely break. They
-  // throw CORBA::NO_IMPLEMENT.
-
-  /// Deprecated in the CORBA 2.2 spec and
-  /// missing altogether from 2.3a (98-12-04),
-  CORBA::Any_ptr parameter (const CORBA::Long slot
-                            ACE_ENV_ARG_DECL_WITH_DEFAULTS);
-
-  /// Deprecated, CORBA 1.2, not fully usable. Returns the number of
-  /// parameters that the typecode takes.
-  CORBA::ULong param_count (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
-
-  /// CDR decoding: the >> operator is not enough because we must also
-  /// respect the parent/child relationship among TypeCodes.
-  static void _tao_decode (const CORBA_TypeCode *parent,
-                           TAO_InputCDR &cdr,
-                           CORBA_TypeCode *&child
-                           ACE_ENV_ARG_DECL);
-
-  // private:
-  //
-  // = The guts of the typecode implementation class
-
-  // This is implemented as a counted set of bytes, in marshaled CDR
-  // format.
+    /// Returns member_name (...), raises (BadKind, Bounds); Useful for
+    /// tk_struct, tk_union, tk_enum, tk_alias, and tk_except.
+    const char *member_name (CORBA::ULong slot
+                             ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
 
-  /// length of the encapsulated stream
-  size_t length_;
+    /// Returns member_type (...), raises (BadKind, Bounds); Useful for
+    /// tk_struct, tk_union, and tk_except.
+    CORBA::TypeCode_ptr member_type (CORBA::ULong slot
+                                     ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
 
-  /// the encapsulated stream
-  const char* buffer_;
+    /// For tk_union. Returns the label. Raises BadKind, Bounds.
+    CORBA::Any_ptr member_label (CORBA::ULong n
+                                 ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
 
-  /// The byte order in the encapsulated stream.
-  CORBA::Long byte_order_;
+    /// Returns the discriminator type for tk_union. raises (BadKind).
+    CORBA::TypeCode_ptr discriminator_type (
+      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
 
-  /// the TypeCode kind
-  CORBA::Long kind_;
+    /// Returns the default slot for the tk_union. Raises (BadKind).
+    CORBA::Long default_index (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
 
-  /**
-   * Indirected typecodes share "buffer" with a parent, and hold a
-   * reference to that parent to ensure its memory is not freed
-   * inappropriately.
-   */
-  CORBA::TypeCode_ptr parent_;
+    /// Returns length, raises (BadKind). Used for tk_string,
+    /// tk_sequence, and tk_array.
+    CORBA::ULong length (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
 
-  /**
-   * my typecode base. Notice that the buffer_ member points to my
-   * encapsulation. However, for indirected typecodes, the offsets will point
-   * to my tk_kind field which should be pointed to be tc_base_
-   */
-  const char *tc_base_;
-
-  /**
-   * base of the topmost level typecode. Applicable only if I have any
-   * parents, else it is the same as tc_base. This helps in case we have
-   * indirections and we need to traverse beyond encapsulation boundaries.
-   */
-  const char *root_tc_base_;
+    /// Returns the content type (element type). Raises (BadKind); Useful
+    /// for tk_sequence, tk_array, and tk_alias.
+    CORBA::TypeCode_ptr content_type (
+      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
 
-  /// skip a typecode encoding in a given CDR stream.  This is just a
-  /// helper function.
-  static CORBA::Boolean skip_typecode (TAO_InputCDR &stream);
+    /// Returns the visibility (public/private) of the member at index
+    /// 'slot'.  Raises (BadKind, Bounds). Useful for tk_value only.
+    CORBA::Visibility member_visibility (CORBA::ULong slot
+                                         ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
 
+    /// Returns the value modifier. Raises (BadKind). Useful for tk_value only.
+    CORBA::ValueModifier type_modifier (
+      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
+
+    /// Returns the concrete base type. Raises (BadKind); Useful
+    /// for tk_value only.
+    CORBA::TypeCode_ptr concrete_base_type (
+      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
+
+    // = Creation/refcounting
+
+    // These aren't really public APIs, but an IDL compiler will need to
+    // be able to create TypeCodes as part of creating stubs.
+
+    /// This constructor is used only for built-in TypeCode constants,
+    /// with no parameters.
+    TypeCode (CORBA::TCKind kind);
+
+    /**
+     * This constructor is used both for typecode constants and for
+     * heap-allocated TypeCodes.  The two are distinguished by the
+     * orb_owns_tc flag passed in by the creator.
+     *
+     * For simple param lists with a single numeric parameter, only
+     * 'length' matters.
+     *
+     * For complex param lists, or simple param lists for which the
+     * parameter is a string or typecode, length _and_ buffer matter.
+     *
+     * For typecodes that are precomputed from the encapsulation stream
+     * of the parent, even the "parent" argument matters because this
+     * implies that all children will share the octet buffers of its
+     * parent
+     */
+    TypeCode (CORBA::TCKind kind,
+                    size_t length,
+                    const char *buffer,
+                    CORBA::Boolean orb_owns_tc,
+                    CORBA::ULong size,
+                    CORBA::TypeCode_ptr parent = 0);
+
+    /// destructor
+    ~TypeCode (void);
+
+    /// These are used to indicate the status of marshaling.
+    enum traverse_status
+      {
+        TRAVERSE_STOP,
+        TRAVERSE_CONTINUE
+      };
+
+    // Reference counting operations.
+    CORBA::ULong _incr_refcnt (void);
+    CORBA::ULong _decr_refcnt (void);
+
+    // = Following three are deprecated
+
+    // The following are deprecated in the CORBA 2.2 spec and are
+    // missing altogether from 2.3a (98-12-04), but they are included
+    // here as no-ops so legacy apps won't completely break. They
+    // throw CORBA::NO_IMPLEMENT.
+
+    /// Deprecated in the CORBA 2.2 spec and
+    /// missing altogether from 2.3a (98-12-04),
+    CORBA::Any_ptr parameter (const CORBA::Long slot
+                              ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+
+    /// Deprecated, CORBA 1.2, not fully usable. Returns the number of
+    /// parameters that the typecode takes.
+    CORBA::ULong param_count (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
+
+    /// CDR decoding: the >> operator is not enough because we must also
+    /// respect the parent/child relationship among TypeCodes.
+    static void _tao_decode (const TypeCode *parent,
+                             TAO_InputCDR &cdr,
+                             TypeCode *&child
+                             ACE_ENV_ARG_DECL);
+
+    // private:
+    //
+    // = The guts of the typecode implementation class
+
+    // This is implemented as a counted set of bytes, in marshaled CDR
+    // format.
+
+    /// length of the encapsulated stream
+    size_t length_;
+
+    /// the encapsulated stream
+    const char* buffer_;
+
+    /// The byte order in the encapsulated stream.
+    CORBA::Long byte_order_;
+
+    /// the TypeCode kind
+    CORBA::Long kind_;
+
+    /**
+     * Indirected typecodes share "buffer" with a parent, and hold a
+     * reference to that parent to ensure its memory is not freed
+     * inappropriately.
+     */
+    CORBA::TypeCode_ptr parent_;
+
+    /**
+     * my typecode base. Notice that the buffer_ member points to my
+     * encapsulation.  However, for indirected typecodes, the offsets
+     * will point to my tk_kind field which should be pointed to be
+     * tc_base_.
+     */
+    const char *tc_base_;
+
+    /**
+     * base of the topmost level typecode. Applicable only if I have
+     * any parents, else it is the same as tc_base. This helps in case
+     * we have indirections and we need to traverse beyond
+     * encapsulation boundaries.
+     */
+    const char *root_tc_base_;
+
+    /// skip a typecode encoding in a given CDR stream.  This is just a
+    /// helper function.
+    static CORBA::Boolean skip_typecode (TAO_InputCDR &stream);
+
+    // Useful for template programming.
 #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-  typedef CORBA_TypeCode_ptr _ptr_type;
-  typedef CORBA_TypeCode_var _var_type;
+    typedef TypeCode_ptr _ptr_type;
+    typedef TypeCode_var _var_type;
 #endif /* __GNUC__ */
-  // Useful for template programming.
-
-private:
-  // = All the private/helper methods
-
-  /**
-   * equal() and equivalent() must both recurse, but their
-   * behavior is somewhat different (as defined in CORBA 2.3).
-   * This function allows us to reuse the same code by acting
-   * as the point of recursion and by adding the equiv_only
-   * flag, to differentiate the behavior where necessary.
-   */
-  CORBA::Boolean equ_common (CORBA::TypeCode_ptr tc,
-                             CORBA::Boolean equiv_only
-                             ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
-
-  /// Compares the typecodes.
-  CORBA::Boolean private_equal (CORBA::TypeCode_ptr tc,
-                                CORBA::Boolean equiv_only
-                                ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
 
-  /// For tk_{objref,struct,union,enum,alias,except}. Returns the
-  /// repository ID, raises BadKind.
-  const char *private_id (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
-
-  /// returns name (), raises (BadKind)
-  const char *private_name (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
-
-  /// returns member_count (), raises (BadKind). Useful for tk_struct,
-  /// tk_union, tk_enum, tk_alias, and tk_except.
-  CORBA::ULong private_member_count (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
-
-  /// returns member_type (...), raises (BadKind, Bounds); Useful for
-  /// tk_struct, tk_union, and tk_except
-  CORBA::TypeCode_ptr private_member_type (
+  private:
+    // = All the private/helper methods
+
+    /**
+     * equal() and equivalent() must both recurse, but their
+     * behavior is somewhat different (as defined in CORBA 2.3).
+     * This function allows us to reuse the same code by acting
+     * as the point of recursion and by adding the equiv_only
+     * flag, to differentiate the behavior where necessary.
+     */
+    CORBA::Boolean equ_common (CORBA::TypeCode_ptr tc,
+                               CORBA::Boolean equiv_only
+                               ACE_ENV_ARG_DECL) const;
+
+    /// Compares the typecodes.
+    CORBA::Boolean private_equal (CORBA::TypeCode_ptr tc,
+                                  CORBA::Boolean equiv_only
+                                  ACE_ENV_ARG_DECL) const;
+
+    /// For tk_{objref,struct,union,enum,alias,except}. Returns the
+    /// repository ID, raises BadKind.
+    const char *private_id (ACE_ENV_SINGLE_ARG_DECL) const;
+
+    /// returns name (), raises (BadKind)
+    const char *private_name (ACE_ENV_SINGLE_ARG_DECL) const;
+
+    /// returns member_count (), raises (BadKind). Useful for tk_struct,
+    /// tk_union, tk_enum, tk_alias, and tk_except.
+    CORBA::ULong private_member_count (
+      ACE_ENV_SINGLE_ARG_DECL) const;
+
+    /// returns member_type (...), raises (BadKind, Bounds); Useful for
+    /// tk_struct, tk_union, and tk_except
+    CORBA::TypeCode_ptr private_member_type (
       CORBA::ULong slot
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS
+      ACE_ENV_ARG_DECL
     ) const;
 
-  /// returns member_name (...), raises (BadKind, Bounds); Useful for
-  /// tk_union, tk_struct, tk_except, and tk_enum
-  const char *private_member_name (CORBA::ULong slot
-                                   ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
+    /// returns member_name (...), raises (BadKind, Bounds); Useful for
+    /// tk_union, tk_struct, tk_except, and tk_enum
+    const char *private_member_name (CORBA::ULong slot
+                                     ACE_ENV_ARG_DECL) const;
 
-  /// For tk_union. Returns the label. Raises BadKind, Bounds.
-  CORBA::Any_ptr private_member_label (CORBA::ULong n
-                                       ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
+    /// For tk_union. Returns the label. Raises BadKind, Bounds.
+    CORBA::Any_ptr private_member_label (CORBA::ULong n
+                                         ACE_ENV_ARG_DECL) const;
 
-  /// returns the discriminator type for tk_union, and acquires the lock
-  /// for the wrapped function below. raises (BadKind)
-  CORBA::TypeCode_ptr private_discriminator_type (
-      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+    /// returns the discriminator type for tk_union, and acquires the lock
+    /// for the wrapped function below. raises (BadKind)
+    CORBA::TypeCode_ptr private_discriminator_type (
+      ACE_ENV_SINGLE_ARG_DECL
     ) const;
 
-  /// Acquires no lock so it can be called internally from blocks
-  /// which have a lock.
-  CORBA::TypeCode_ptr private_discriminator_type_i (
-      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+    /// Acquires no lock so it can be called internally from blocks
+    /// which have a lock.
+    CORBA::TypeCode_ptr private_discriminator_type_i (
+      ACE_ENV_SINGLE_ARG_DECL
     ) const;
 
-  /// returns the default slot for the tk_union. Raises (BadKind);
-  CORBA::Long private_default_index (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
+    /// returns the default slot for the tk_union. Raises (BadKind);
+    CORBA::Long private_default_index (
+      ACE_ENV_SINGLE_ARG_DECL) const;
 
-  /// Acquires no lock so it can be called internally from blocks
-  /// which have a lock.
-  CORBA::Long private_default_index_i (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
+    /// Acquires no lock so it can be called internally from blocks
+    /// which have a lock.
+    CORBA::Long private_default_index_i (
+      ACE_ENV_SINGLE_ARG_DECL) const;
 
-  /// Returns length, raises (BadKind). Used for tk_string,
-  /// tk_sequence, and tk_array.
-  CORBA::Long private_length (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) const;
+    /// Returns length, raises (BadKind). Used for tk_string,
+    /// tk_sequence, and tk_array.
+    CORBA::Long private_length (ACE_ENV_SINGLE_ARG_DECL) const;
 
-  /// Returns the content type (element type). Raises (BadKind); Useful
-  /// for tk_sequence, tk_array, and tk_alias.
-  CORBA::TypeCode_ptr private_content_type (
-      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+    /// Returns the content type (element type). Raises (BadKind); Useful
+    /// for tk_sequence, tk_array, and tk_alias.
+    CORBA::TypeCode_ptr private_content_type (
+      ACE_ENV_SINGLE_ARG_DECL
     ) const;
 
-  /// Returns the visibility (public/private) of the member at index 'slot'.
-  /// Raises (BadKind, Bounds). Useful for tk_value only.
-  CORBA::Visibility private_member_visibility (
-      CORBA::ULong slot
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS
-    ) const;
+    /// Returns the visibility (public/private) of the member at index
+    /// 'slot'.  Raises (BadKind, Bounds). Useful for tk_value only.
+    CORBA::Visibility private_member_visibility (CORBA::ULong slot
+                                                 ACE_ENV_ARG_DECL) const;
 
-  /// Returns the value modifier. Raises (BadKind). Useful for tk_value only.
-  CORBA::ValueModifier private_type_modifier (
-      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+    /// Returns the value modifier. Raises (BadKind).  Useful for
+    /// tk_value only.
+    CORBA::ValueModifier private_type_modifier (
+      ACE_ENV_SINGLE_ARG_DECL
     ) const;
 
-  /// Returns the concrete base type. Raises (BadKind). Useful for tk_value only.
-  CORBA::TypeCode_ptr private_concrete_base_type (
-      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+    /// Returns the concrete base type. Raises (BadKind).  Useful for
+    /// tk_value only. 
+    CORBA::TypeCode_ptr private_concrete_base_type (
+      ACE_ENV_SINGLE_ARG_DECL
     ) const;
 
-  // = All the private helpers testing for equality of typecodes
+    // = All the private helpers testing for equality of typecodes
 
-  /// test equality for typecodes of objrefs
-  CORBA::Boolean private_equal_objref (CORBA::TypeCode_ptr tc,
-                                       CORBA::Boolean equiv_only
-                                       ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
-
-  /// test equality for typecodes of structs
-  CORBA::Boolean private_equal_struct (CORBA::TypeCode_ptr tc,
-                                       CORBA::Boolean equiv_only
-                                       ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
+    /// test equality for typecodes of objrefs
+    CORBA::Boolean private_equal_objref (CORBA::TypeCode_ptr tc,
+                                         CORBA::Boolean equiv_only
+                                         ACE_ENV_ARG_DECL) const;
 
-  /// test equality for typecodes of unions
-  CORBA::Boolean private_equal_union (CORBA::TypeCode_ptr tc,
-                                      CORBA::Boolean equiv_only
-                                      ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
+    /// test equality for typecodes of structs
+    CORBA::Boolean private_equal_struct (CORBA::TypeCode_ptr tc,
+                                         CORBA::Boolean equiv_only
+                                         ACE_ENV_ARG_DECL) const;
 
-  /// test equality for typecodes of enums
-  CORBA::Boolean private_equal_enum (CORBA::TypeCode_ptr tc,
-                                     CORBA::Boolean equiv_only
-                                     ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
+    /// test equality for typecodes of unions
+    CORBA::Boolean private_equal_union (CORBA::TypeCode_ptr tc,
+                                        CORBA::Boolean equiv_only
+                                        ACE_ENV_ARG_DECL) const;
 
-  /// test equality for typecodes of strings
-  CORBA::Boolean private_equal_string (CORBA::TypeCode_ptr tc,
+    /// test equality for typecodes of enums
+    CORBA::Boolean private_equal_enum (CORBA::TypeCode_ptr tc,
                                        CORBA::Boolean equiv_only
-                                       ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
-
-  /// test equality for typecodes of wide strings
-  CORBA::Boolean private_equal_wstring (CORBA::TypeCode_ptr tc,
-                                        CORBA::Boolean equiv_only
-                                        ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
+                                       ACE_ENV_ARG_DECL) const;
 
-  /// test equality for typecodes of sequences
-  CORBA::Boolean private_equal_sequence (CORBA::TypeCode_ptr tc,
+    /// test equality for typecodes of strings
+    CORBA::Boolean private_equal_string (CORBA::TypeCode_ptr tc,
                                          CORBA::Boolean equiv_only
-                                         ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
-
-  /// test equality for typecodes of array
-  CORBA::Boolean private_equal_array (CORBA::TypeCode_ptr tc,
-                                      CORBA::Boolean equiv_only
-                                      ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
-
-  /// test equality for typecodes of typedefs
-  CORBA::Boolean private_equal_alias (CORBA::TypeCode_ptr tc,
-                                      CORBA::Boolean equiv_only
-                                      ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
+                                         ACE_ENV_ARG_DECL) const;
 
-  /// test equality for typecodes of exceptions
-  CORBA::Boolean private_equal_except (CORBA::TypeCode_ptr tc,
-                                       CORBA::Boolean equiv_only
-                                       ACE_ENV_ARG_DECL_WITH_DEFAULTS) const;
-
-  /// test equality for typecodes of exceptions
-  CORBA::Boolean private_equal_valuetype (CORBA::TypeCode_ptr tc,
+    /// test equality for typecodes of wide strings
+    CORBA::Boolean private_equal_wstring (CORBA::TypeCode_ptr tc,
                                           CORBA::Boolean equiv_only
-                                          ACE_ENV_ARG_DECL_WITH_DEFAULTS)
-      const;
-
+                                          ACE_ENV_ARG_DECL) const;
 
-  /// if refcount reaches 0, free this typecode
-  CORBA::ULong refcount_;
+    /// test equality for typecodes of sequences
+    CORBA::Boolean private_equal_sequence (CORBA::TypeCode_ptr tc,
+                                           CORBA::Boolean equiv_only
+                                           ACE_ENV_ARG_DECL) const;
 
-  /// Protect the reference count, this is OK because we do no
-  /// duplicates or releases on the critical path.
-  TAO_SYNCH_MUTEX refcount_lock_;
+    /// test equality for typecodes of array
+    CORBA::Boolean private_equal_array (CORBA::TypeCode_ptr tc,
+                                        CORBA::Boolean equiv_only
+                                        ACE_ENV_ARG_DECL) const;
 
-  /// TAO's approach differs from the SunSoft IIOP. Constant typecodes
-  /// are owned by the ORB and get freed only when the ORB dies.
-  CORBA::Boolean orb_owns_;
+    /// test equality for typecodes of typedefs
+    CORBA::Boolean private_equal_alias (CORBA::TypeCode_ptr tc,
+                                        CORBA::Boolean equiv_only
+                                        ACE_ENV_ARG_DECL) const;
 
-  // If "orb_owns" is false, the value is a not a constant typecode
-  // with both the typecode and the buffer allocated (typically, this
-  // will be created by the IDL compiler generated code)
+    /// test equality for typecodes of exceptions
+    CORBA::Boolean private_equal_except (CORBA::TypeCode_ptr tc,
+                                         CORBA::Boolean equiv_only
+                                         ACE_ENV_ARG_DECL) const;
+
+    /// test equality for typecodes of exceptions
+    CORBA::Boolean private_equal_valuetype (CORBA::TypeCode_ptr tc,
+                                            CORBA::Boolean equiv_only
+                                            ACE_ENV_ARG_DECL) const;
+
+  private:
+
+    // = No copy constructor or assignment operator supported;
+
+    // Use TypeCode_ptr values, duplicate (), release ().
+    TypeCode (const CORBA::TypeCode &src);
+    TypeCode &operator = (const CORBA::TypeCode &src);
+
+  private:
+
+    /// if refcount reaches 0, free this typecode
+    CORBA::ULong refcount_;
+
+    /// Protect the reference count, this is OK because we do no
+    /// duplicates or releases on the critical path.
+    TAO_SYNCH_MUTEX refcount_lock_;
+
+    /// TAO's approach differs from the SunSoft IIOP.  Constant
+    /// TypeCodes are owned by the ORB and get freed only when the ORB
+    /// dies.
+    /**
+     * If "orb_owns" is false, the value is a not a constant typecode
+     * with both the typecode and the buffer allocated (typically,
+     * this will be created by the IDL compiler generated code)
+     */
+    CORBA::Boolean orb_owns_;
+
+    /**
+     * maintains precomputed state. We need a separate class that
+     * maintains the precomputed state since most of the TypeCode class
+     * operations keep the state of the object constant. However, for
+     * the purpose of precomputation, we need to update the state. We
+     * cannot update state directly in the TypeCode class as that
+     * defeats the constness. However, we can keep an object in our
+     * typecode class that remains constant, but we can update its
+     * state.
+     */
+    TAO::TC_Private_State *private_state_;
+
+    /**
+     * Original buffer that may possibly be non-aligned. We still need a
+     * handle to the allocated memory so that all of it can be freed by
+     * the destructor.
+     */
+    char *non_aligned_buffer_;
+  };
 
   /**
-   * maintains precomputed state. We need a separate class that
-   * maintains the precomputed state since most of the TypeCode class
-   * operations keep the state of the object constant. However, for
-   * the purpose of precomputation, we need to update the state. We
-   * cannot update state directly in the TypeCode class as that
-   * defeats the constness. However, we can keep an object in our
-   * typecode class that remains constant, but we can update its
-   * state.
+   * @class TypeCode_var
+   *
+   * @brief A smart pointer for TypeCodes.
+   *
+   * Implements the _var class for the TypeCode pseudo object.
    */
-  TC_Private_State *private_state_;
-
-  // = No copy constructor or assignment operator supported;
-
-  // Use TypeCode_ptr values, duplicate (), release ().
-  CORBA_TypeCode (const CORBA::TypeCode &src);
-  CORBA_TypeCode &operator = (const CORBA::TypeCode &src);
+  class TAO_Export TypeCode_var
+  {
+  public:
+    TypeCode_var (void); // default constructor
+    TypeCode_var (TypeCode_ptr);
+    TypeCode_var (const TypeCode_var &); // copy constructor
+    ~TypeCode_var (void); // destructor
+
+    TypeCode_var &operator= (TypeCode_ptr);
+    TypeCode_var &operator= (const TypeCode_var &);
+    TypeCode_ptr operator-> (void) const;
+
+    /// in, inout, out, _retn
+    operator const TypeCode_ptr &() const;
+    operator TypeCode_ptr &();
+    TypeCode_ptr in (void) const;
+    TypeCode_ptr &inout (void);
+    TypeCode_ptr &out (void);
+    TypeCode_ptr _retn (void);
+    TypeCode_ptr ptr (void) const;
+
+  private:
+    TypeCode_ptr ptr_;
+  };
 
   /**
-   * Original buffer that may possibly be non-aligned. We still need a
-   * handle to the allocated memory so that all of it can be freed by
-   * the destructor.
+   * @class TypeCode_out
+   *
+   * @brief The _out class for TypeCode.
+   *
+   * Implements the _out class for the TypeCode pseudo object.
    */
-  char *non_aligned_buffer_;
-};
+  class TAO_Export TypeCode_out
+  {
+  public:
+    TypeCode_out (TypeCode_ptr &);
+    TypeCode_out (TypeCode_var &);
+    TypeCode_out (const TypeCode_out &);
+    TypeCode_out &operator= (const TypeCode_out &);
+    TypeCode_out &operator= (TypeCode_ptr);
+    operator TypeCode_ptr &();
+    TypeCode_ptr &ptr (void);
+    TypeCode_ptr operator-> (void);
+
+  private:
+    TypeCode_ptr &ptr_;
+
+    /// Assignment from _var not allowed
+    TypeCode_out &operator= (const TypeCode_var &);
+  };
+}  // End CORBA namespace
 
-/**
- * @class TC_Private_State
- *
- * @brief Private state of the TypeCode.
- *
- * Used to store precomputed values
- */
-class TAO_Export TC_Private_State
-{
-public:
-  /// Constructor.
-  TC_Private_State (CORBA::TCKind kind);
-
-  /// Destructor.
-  ~TC_Private_State (void);
-
-  TAO_SYNCH_MUTEX mutex_;
-
-  /// Our kind that will determine what kind of children we may have
-  CORBA::TCKind  tc_kind_;
-
-  // Data members that indicate if the desired quantity
-  // was precomputed or not.
-  CORBA::Boolean tc_id_known_;
-  CORBA::Boolean tc_name_known_;
-  CORBA::Boolean tc_member_count_known_;
-  CORBA::Boolean tc_member_type_list_known_;
-  CORBA::Boolean tc_member_name_list_known_;
-  CORBA::Boolean tc_member_label_list_known_;
-  CORBA::Boolean tc_discriminator_type_known_;
-  CORBA::Boolean tc_default_index_used_known_;
-  CORBA::Boolean tc_length_known_;
-  CORBA::Boolean tc_content_type_known_;
-  CORBA::Boolean tc_discrim_pad_size_known_;
-  CORBA::Boolean tc_member_visibility_list_known_;
-  CORBA::Boolean tc_type_modifier_known_;
-  CORBA::Boolean tc_concrete_base_type_known_;
-
-  // These data members store the precomputed values.
-  char *tc_id_;
-  char *tc_name_;
-  CORBA::ULong tc_member_count_;
-  CORBA::TypeCode_ptr *tc_member_type_list_;
-  char **tc_member_name_list_;
-  CORBA::Any_ptr *tc_member_label_list_;
-  CORBA::TypeCode_ptr tc_discriminator_type_;
-  CORBA::Long tc_default_index_used_;
-  CORBA::ULong tc_length_;
-  CORBA::TypeCode_ptr tc_content_type_;
-  CORBA::Visibility *tc_member_visibility_list_;
-  CORBA::ValueModifier tc_type_modifier_;
-  CORBA::TypeCode_ptr tc_concrete_base_type_;
-};
+// --------------------------------------------------------------
 
-/**
- * @class CORBA_TypeCode_var
- *
- * @brief A smart pointer for TypeCodes.
- *
- * Implements the _var class for the TypeCode pseudo object.
- */
-class TAO_Export CORBA_TypeCode_var
+namespace TAO
 {
-public:
-  CORBA_TypeCode_var (void); // default constructor
-  CORBA_TypeCode_var (CORBA_TypeCode_ptr);
-  CORBA_TypeCode_var (const CORBA_TypeCode_var &); // copy constructor
-  ~CORBA_TypeCode_var (void); // destructor
-
-  CORBA_TypeCode_var &operator= (CORBA_TypeCode_ptr);
-  CORBA_TypeCode_var &operator= (const CORBA_TypeCode_var &);
-  CORBA_TypeCode_ptr operator-> (void) const;
-
-  /// in, inout, out, _retn
-  operator const CORBA_TypeCode_ptr &() const;
-  operator CORBA_TypeCode_ptr &();
-  CORBA_TypeCode_ptr in (void) const;
-  CORBA_TypeCode_ptr &inout (void);
-  CORBA_TypeCode_ptr &out (void);
-  CORBA_TypeCode_ptr _retn (void);
-  CORBA_TypeCode_ptr ptr (void) const;
+  /**
+   * @class TC_Private_State
+   *
+   * @brief Private state of the TypeCode.
+   *
+   * Used to store precomputed values
+   */
+  class TC_Private_State
+  {
+  public:
+    /// Constructor.
+    TC_Private_State (CORBA::TCKind kind);
 
-private:
-  CORBA_TypeCode_ptr ptr_;
-};
+    /// Destructor.
+    ~TC_Private_State (void);
 
-/**
- * @class CORBA_TypeCode_out
- *
- * @brief The _out class for TypeCode.
- *
- * Implements the _out class for the TypeCode pseudo object.
- */
-class TAO_Export CORBA_TypeCode_out
-{
-public:
-  CORBA_TypeCode_out (CORBA_TypeCode_ptr &);
-  CORBA_TypeCode_out (CORBA_TypeCode_var &);
-  CORBA_TypeCode_out (const CORBA_TypeCode_out &);
-  CORBA_TypeCode_out &operator= (const CORBA_TypeCode_out &);
-  CORBA_TypeCode_out &operator= (CORBA_TypeCode_ptr);
-  operator CORBA_TypeCode_ptr &();
-  CORBA_TypeCode_ptr &ptr (void);
-  CORBA_TypeCode_ptr operator-> (void);
+  public:
 
-private:
-  CORBA_TypeCode_ptr &ptr_;
+    TAO_SYNCH_MUTEX mutex_;
+
+    /// Our kind that will determine what kind of children we may have
+    CORBA::TCKind  tc_kind_;
+
+    // Data members that indicate if the desired quantity
+    // was precomputed or not.
+    CORBA::Boolean tc_id_known_;
+    CORBA::Boolean tc_name_known_;
+    CORBA::Boolean tc_member_count_known_;
+    CORBA::Boolean tc_member_type_list_known_;
+    CORBA::Boolean tc_member_name_list_known_;
+    CORBA::Boolean tc_member_label_list_known_;
+    CORBA::Boolean tc_discriminator_type_known_;
+    CORBA::Boolean tc_default_index_used_known_;
+    CORBA::Boolean tc_length_known_;
+    CORBA::Boolean tc_content_type_known_;
+    CORBA::Boolean tc_discrim_pad_size_known_;
+    CORBA::Boolean tc_member_visibility_list_known_;
+    CORBA::Boolean tc_type_modifier_known_;
+    CORBA::Boolean tc_concrete_base_type_known_;
+
+    // These data members store the precomputed values.
+    char *tc_id_;
+    char *tc_name_;
+    CORBA::ULong tc_member_count_;
+    CORBA::TypeCode_ptr *tc_member_type_list_;
+    char **tc_member_name_list_;
+    CORBA::Any_ptr *tc_member_label_list_;
+    CORBA::TypeCode_ptr tc_discriminator_type_;
+    CORBA::Long tc_default_index_used_;
+    CORBA::ULong tc_length_;
+    CORBA::TypeCode_ptr tc_content_type_;
+    CORBA::Visibility *tc_member_visibility_list_;
+    CORBA::ValueModifier tc_type_modifier_;
+    CORBA::TypeCode_ptr tc_concrete_base_type_;
+  };
+}  // End TAO namespace
 
-  /// Assignment from _var not allowed
-  CORBA_TypeCode_out &operator= (const CORBA_TypeCode_var &);
-};
+// --------------------------------------------------------------
 
 /**
  * @class TAO_TypeCodes
@@ -603,7 +633,7 @@ private:
  * @brief This class is a namespace for TypeCode-related static data that
  * is owned by the ORB.
  */
-class TAO_Export TAO_TypeCodes
+class TAO_TypeCodes
 {
 public:
 
@@ -633,4 +663,5 @@ TAO_Export CORBA::Boolean operator>> (TAO_InputCDR& cdr,
 #endif /* __ACE_INLINE__ */
 
 #include "ace/post.h"
+
 #endif /* TAO_TYPECODE_H */
diff --git a/TAO/tao/Typecode.i b/TAO/tao/Typecode.i
index 4066b436c19..703fe1816ee 100644
--- a/TAO/tao/Typecode.i
+++ b/TAO/tao/Typecode.i
@@ -1,15 +1,16 @@
 // -*- C++ -*-
+//
 // $Id$
 
 ACE_INLINE CORBA::ULong
-CORBA_TypeCode::_incr_refcnt (void)
+CORBA::TypeCode::_incr_refcnt (void)
 {
   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, guard, this->refcount_lock_, 0);
   return this->refcount_++;
 }
 
 ACE_INLINE CORBA::ULong
-CORBA_TypeCode::_decr_refcnt (void)
+CORBA::TypeCode::_decr_refcnt (void)
 {
   {
     ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, guard, this->refcount_lock_, 0);
@@ -22,7 +23,7 @@ CORBA_TypeCode::_decr_refcnt (void)
 }
 
 ACE_INLINE CORBA::TypeCode_ptr
-CORBA_TypeCode::_duplicate (CORBA::TypeCode_ptr tc)
+CORBA::TypeCode::_duplicate (CORBA::TypeCode_ptr tc)
 {
   if (tc)
     tc->_incr_refcnt ();
@@ -36,14 +37,14 @@ CORBA::TypeCode::_nil (void)
 }
 
 ACE_INLINE CORBA::TCKind
-CORBA_TypeCode::kind (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) const
+CORBA::TypeCode::kind (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) const
 {
   return (CORBA::TCKind) this->kind_;
 }
 
 // Returns true if the two typecodes are equivalent.
 ACE_INLINE CORBA::Boolean
-CORBA_TypeCode::equivalent (CORBA::TypeCode_ptr tc
+CORBA::TypeCode::equivalent (CORBA::TypeCode_ptr tc
                             ACE_ENV_ARG_DECL) const
 {
   return this->equ_common (tc,
@@ -53,7 +54,7 @@ CORBA_TypeCode::equivalent (CORBA::TypeCode_ptr tc
 
 // Returns true if the two typecodes are identical.
 ACE_INLINE CORBA::Boolean
-CORBA_TypeCode::equal (CORBA::TypeCode_ptr tc
+CORBA::TypeCode::equal (CORBA::TypeCode_ptr tc
                        ACE_ENV_ARG_DECL) const
 {
   return this->equ_common (tc,
@@ -63,7 +64,7 @@ CORBA_TypeCode::equal (CORBA::TypeCode_ptr tc
 
 // returns the Repository ID
 ACE_INLINE const char *
-CORBA_TypeCode::id (ACE_ENV_SINGLE_ARG_DECL) const
+CORBA::TypeCode::id (ACE_ENV_SINGLE_ARG_DECL) const
 {
   // if already precomputed
   if (this->private_state_->tc_id_known_)
@@ -74,7 +75,7 @@ CORBA_TypeCode::id (ACE_ENV_SINGLE_ARG_DECL) const
 
 // returns the string name
 ACE_INLINE const char *
-CORBA_TypeCode::name (ACE_ENV_SINGLE_ARG_DECL) const
+CORBA::TypeCode::name (ACE_ENV_SINGLE_ARG_DECL) const
 {
   // if already precomputed
   if (this->private_state_->tc_name_known_)
@@ -89,7 +90,7 @@ CORBA_TypeCode::name (ACE_ENV_SINGLE_ARG_DECL) const
 // For the rest of the cases, raises the BadKind exception.
 
 ACE_INLINE CORBA::ULong
-CORBA_TypeCode::member_count (ACE_ENV_SINGLE_ARG_DECL) const
+CORBA::TypeCode::member_count (ACE_ENV_SINGLE_ARG_DECL) const
 {
   // if already precomputed
   if (this->private_state_->tc_member_count_known_)
@@ -117,150 +118,150 @@ CORBA::release (CORBA::TypeCode_ptr obj)
 // ****************************************************************
 
 ACE_INLINE
-CORBA_TypeCode_var::CORBA_TypeCode_var (void)
-  : ptr_ (CORBA_TypeCode::_nil ())
+CORBA::TypeCode_var::TypeCode_var (void)
+  : ptr_ (CORBA::TypeCode::_nil ())
 {}
 
 ACE_INLINE
-CORBA_TypeCode_var::CORBA_TypeCode_var (CORBA_TypeCode_ptr p)
+CORBA::TypeCode_var::TypeCode_var (CORBA::TypeCode_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_TypeCode_ptr
-CORBA_TypeCode_var::ptr (void) const
+ACE_INLINE CORBA::TypeCode_ptr
+CORBA::TypeCode_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_TypeCode_var::CORBA_TypeCode_var (const CORBA_TypeCode_var &p)
-  : ptr_ (CORBA_TypeCode::_duplicate (p.ptr ()))
+CORBA::TypeCode_var::TypeCode_var (const CORBA::TypeCode_var &p)
+  : ptr_ (CORBA::TypeCode::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_TypeCode_var::~CORBA_TypeCode_var (void)
+CORBA::TypeCode_var::~TypeCode_var (void)
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_TypeCode_var &
-CORBA_TypeCode_var::operator= (CORBA_TypeCode_ptr p)
+ACE_INLINE CORBA::TypeCode_var &
+CORBA::TypeCode_var::operator= (CORBA::TypeCode_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_TypeCode_var &
-CORBA_TypeCode_var::operator= (const CORBA_TypeCode_var &p)
+ACE_INLINE CORBA::TypeCode_var &
+CORBA::TypeCode_var::operator= (const CORBA::TypeCode_var &p)
 {
   if (this != &p)
     {
       CORBA::release (this->ptr_);
-      this->ptr_ = CORBA_TypeCode::_duplicate (p.ptr ());
+      this->ptr_ = CORBA::TypeCode::_duplicate (p.ptr ());
     }
   return *this;
 }
 
 ACE_INLINE
-CORBA_TypeCode_var::operator const CORBA_TypeCode_ptr &() const
+CORBA::TypeCode_var::operator const CORBA::TypeCode_ptr &() const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_TypeCode_var::operator CORBA_TypeCode_ptr &()
+CORBA::TypeCode_var::operator CORBA::TypeCode_ptr &()
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_TypeCode_ptr
-CORBA_TypeCode_var::operator-> (void) const
+ACE_INLINE CORBA::TypeCode_ptr
+CORBA::TypeCode_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_TypeCode_ptr
-CORBA_TypeCode_var::in (void) const
+ACE_INLINE CORBA::TypeCode_ptr
+CORBA::TypeCode_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_TypeCode_ptr &
-CORBA_TypeCode_var::inout (void)
+ACE_INLINE CORBA::TypeCode_ptr &
+CORBA::TypeCode_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_TypeCode_ptr &
-CORBA_TypeCode_var::out (void)
+ACE_INLINE CORBA::TypeCode_ptr &
+CORBA::TypeCode_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_TypeCode::_nil ();
+  this->ptr_ = CORBA::TypeCode::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_TypeCode_ptr
-CORBA_TypeCode_var::_retn (void)
+ACE_INLINE CORBA::TypeCode_ptr
+CORBA::TypeCode_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_TypeCode_ptr val = this->ptr_;
-  this->ptr_ = CORBA_TypeCode::_nil ();
+  CORBA::TypeCode_ptr val = this->ptr_;
+  this->ptr_ = CORBA::TypeCode::_nil ();
   return val;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_TypeCode_out
+// Inline operations for class CORBA::TypeCode_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_TypeCode_out::CORBA_TypeCode_out (CORBA_TypeCode_ptr &p)
+CORBA::TypeCode_out::TypeCode_out (CORBA::TypeCode_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_TypeCode::_nil ();
+  this->ptr_ = CORBA::TypeCode::_nil ();
 }
 
 ACE_INLINE
-CORBA_TypeCode_out::CORBA_TypeCode_out (CORBA_TypeCode_var &p)
+CORBA::TypeCode_out::TypeCode_out (CORBA::TypeCode_var &p)
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_TypeCode::_nil ();
+  this->ptr_ = CORBA::TypeCode::_nil ();
 }
 
 ACE_INLINE
-CORBA_TypeCode_out::CORBA_TypeCode_out (const CORBA_TypeCode_out &p)
+CORBA::TypeCode_out::TypeCode_out (const CORBA::TypeCode_out &p)
   : ptr_ (p.ptr_)
 {}
 
-ACE_INLINE CORBA_TypeCode_out &
-CORBA_TypeCode_out::operator= (const CORBA_TypeCode_out &p)
+ACE_INLINE CORBA::TypeCode_out &
+CORBA::TypeCode_out::operator= (const CORBA::TypeCode_out &p)
 {
   this->ptr_ = p.ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_TypeCode_out &
-CORBA_TypeCode_out::operator= (CORBA_TypeCode_ptr p)
+ACE_INLINE CORBA::TypeCode_out &
+CORBA::TypeCode_out::operator= (CORBA::TypeCode_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE
-CORBA_TypeCode_out::operator CORBA_TypeCode_ptr &()
+CORBA::TypeCode_out::operator CORBA::TypeCode_ptr &()
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_TypeCode_ptr &
-CORBA_TypeCode_out::ptr (void)
+ACE_INLINE CORBA::TypeCode_ptr &
+CORBA::TypeCode_out::ptr (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_TypeCode_ptr
-CORBA_TypeCode_out::operator-> (void)
+ACE_INLINE CORBA::TypeCode_ptr
+CORBA::TypeCode_out::operator-> (void)
 {
   return this->ptr_;
 }
diff --git a/TAO/tao/Typecode_Constants.cpp b/TAO/tao/Typecode_Constants.cpp
index 0e726865648..16330eaf59b 100644
--- a/TAO/tao/Typecode_Constants.cpp
+++ b/TAO/tao/Typecode_Constants.cpp
@@ -169,7 +169,7 @@ TAO_NAMESPACE_BEGIN (CORBA)
 TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ORBid, 0)
 TAO_NAMESPACE_END
 
-CORBA::TypeCode_ptr CORBA_ORB::_tc_ObjectId = 0;
+CORBA::TypeCode_ptr CORBA::ORB::_tc_ObjectId = 0;
 
 #if (TAO_HAS_MINIMUM_CORBA == 0)
 
@@ -423,12 +423,12 @@ TAO_TypeCodes::init (void)
     CORBA::tk_string,
     0,                      // string length
   };
-  CORBA_ORB::_tc_ObjectId =
+  CORBA::ORB::_tc_ObjectId =
     new CORBA::TypeCode (CORBA::tk_alias,
                          sizeof (_oc_CORBA_ObjectId),
                          (char *) &_oc_CORBA_ObjectId,
                          0,
-                         sizeof (CORBA_ORB::ObjectId));
+                         sizeof (CORBA::ORB::ObjectId));
 
 #if (TAO_HAS_MINIMUM_CORBA == 0)
 
@@ -950,7 +950,7 @@ TAO_TypeCodes::fini (void)
 
 #endif /* TAO_HAS_MINIMUM_CORBA */
 
-  CORBA::release (CORBA_ORB::_tc_ObjectId);
+  CORBA::release (CORBA::ORB::_tc_ObjectId);
 
   // Service types
   CORBA::release (CORBA::_tc_ServiceType);
diff --git a/TAO/tao/ValueBase.cpp b/TAO/tao/ValueBase.cpp
index 5aa1a9fc22e..f7acebce25b 100644
--- a/TAO/tao/ValueBase.cpp
+++ b/TAO/tao/ValueBase.cpp
@@ -1,19 +1,3 @@
-// $Id$
-
-// ============================================================================
-//
-// = LIBRARY
-//     TAO
-//
-// = FILENAME
-//     ValueBase.cpp
-//
-// = AUTHOR
-//     Torsten Kuepper  <kuepper2@lfa.uni-wuppertal.de>
-//
-// ============================================================================
-
-
 #include "tao/CDR.h"
 #include "tao/ORB.h"
 #include "tao/ORB_Core.h"
@@ -29,13 +13,13 @@ ACE_RCSID (tao,
            ValueBase,
            "$Id$")
 
-// destructor
-CORBA_ValueBase::~CORBA_ValueBase (void)
+
+CORBA::ValueBase::~ValueBase (void)
 {
 }
 
-CORBA_ValueBase*
-CORBA_ValueBase::_downcast (CORBA_ValueBase *vt)
+CORBA::ValueBase*
+CORBA::ValueBase::_downcast (CORBA::ValueBase *vt)
 {
   return vt;  // every vt is a CORBA::ValueBase :-)
 }
@@ -57,9 +41,9 @@ CORBA_ValueBase::_downcast (CORBA_ValueBase *vt)
 // (see CORBA 2.3 GIOP 15.3.4)
 
 CORBA::Boolean
-CORBA_ValueBase::_tao_marshal (TAO_OutputCDR &strm,
-                               CORBA_ValueBase *this_,
-                               ptr_arith_t /* formal_type_id */)
+CORBA::ValueBase::_tao_marshal (TAO_OutputCDR &strm,
+                                CORBA::ValueBase *this_,
+                                ptr_arith_t /* formal_type_id */)
 {
   CORBA::Boolean retval = 1;
   // %! yet much to do ... look for +++ !
@@ -126,8 +110,8 @@ CORBA_ValueBase::_tao_marshal (TAO_OutputCDR &strm,
 
 
 CORBA::Boolean
-CORBA_ValueBase::_tao_unmarshal (TAO_InputCDR &strm,
-                                 CORBA_ValueBase *&new_object)
+CORBA::ValueBase::_tao_unmarshal (TAO_InputCDR &strm,
+                                  CORBA::ValueBase *&new_object)
 {
   // This is for the special case only that one unmarshals in order
   // to assign the newly created object directly to a ValueBase pointer.
@@ -174,16 +158,16 @@ CORBA_ValueBase::_tao_unmarshal (TAO_InputCDR &strm,
 
   // Now base must be null or point to the unmarshaled object.
   // Align the pointer to the right subobject.
-//  new_object = CORBA_ValueBase::_downcast (base);
+//  new_object = CORBA::ValueBase::_downcast (base);
   return retval;
 }
 
 
 CORBA::Boolean
-CORBA_ValueBase::_tao_unmarshal_pre (TAO_InputCDR &strm,
-                                     CORBA_ValueFactory &factory,
-                                     CORBA_ValueBase *&valuetype,
-                                     const char * const /* repo_id */)
+CORBA::ValueBase::_tao_unmarshal_pre (TAO_InputCDR &strm,
+                                      CORBA::ValueFactory &factory,
+                                      CORBA::ValueBase *&valuetype,
+                                      const char * const /* repo_id */)
 { // %! dont leak on error case !
   // %! postconditions
   CORBA::Boolean retval = 1;
@@ -266,7 +250,7 @@ CORBA_ValueBase::_tao_unmarshal_pre (TAO_InputCDR &strm,
 }
 
 CORBA::Boolean
-CORBA_ValueBase::_tao_unmarshal_post (TAO_InputCDR &)
+CORBA::ValueBase::_tao_unmarshal_post (TAO_InputCDR &)
 {
   CORBA::Boolean retval = 1;
 
@@ -287,31 +271,33 @@ CORBA_ValueBase::_tao_unmarshal_post (TAO_InputCDR &)
 }
 
 
-// member functions for CORBA_DefaultValueRefCountBase ============
+// member functions for CORBA::DefaultValueRefCountBase ============
 
 // destructor
-CORBA_DefaultValueRefCountBase::~CORBA_DefaultValueRefCountBase (void)
+CORBA::DefaultValueRefCountBase::~DefaultValueRefCountBase (void)
 {
 }
 
 void
-CORBA_DefaultValueRefCountBase::_add_ref (void)
+CORBA::DefaultValueRefCountBase::_add_ref (void)
 {
   this->_tao_add_ref ();
 }
 
 void
-CORBA_DefaultValueRefCountBase::_remove_ref (void)
+CORBA::DefaultValueRefCountBase::_remove_ref (void)
 {
   this->_tao_remove_ref ();
 }
 
 CORBA::ULong
-CORBA_DefaultValueRefCountBase::_refcount_value (void)
+CORBA::DefaultValueRefCountBase::_refcount_value (void)
 {
   return this->_tao_refcount_value ();
 }
 
+// ===========================================================
+
 // some constants
 
 const CORBA::ULong TAO_OBV_GIOP_Flags::Value_tag_base    = 0x7fffff00L;
@@ -326,21 +312,21 @@ const CORBA::ULong TAO_OBV_GIOP_Flags::Type_info_list    = 6;
 
 CORBA::Boolean
 operator<< (TAO_OutputCDR &strm,
-            const CORBA_ValueBase *_tao_valuetype)
+            const CORBA::ValueBase *_tao_valuetype)
 {
-  return CORBA_ValueBase::_tao_marshal (
+  return CORBA::ValueBase::_tao_marshal (
              strm,
-             ACE_const_cast (CORBA_ValueBase *,
+             ACE_const_cast (CORBA::ValueBase *,
                              _tao_valuetype),
-             (ptr_arith_t) &CORBA_ValueBase::_downcast
+             (ptr_arith_t) &CORBA::ValueBase::_downcast
            );
 }
 
 CORBA::Boolean
 operator>> (TAO_InputCDR &strm,
-            CORBA_ValueBase *&_tao_valuetype)
+            CORBA::ValueBase *&_tao_valuetype)
 {
-  return CORBA_ValueBase::_tao_unmarshal (strm,
-                                          _tao_valuetype);
+  return CORBA::ValueBase::_tao_unmarshal (strm,
+                                           _tao_valuetype);
 }
 
diff --git a/TAO/tao/ValueBase.h b/TAO/tao/ValueBase.h
index 8cf1c8fb49f..481c3452c8a 100644
--- a/TAO/tao/ValueBase.h
+++ b/TAO/tao/ValueBase.h
@@ -26,170 +26,186 @@
 #include "ace/Synch_T.h"
 #include "tao/corbafwd.h"
 
-/**
- * @class CORBA_ValueBase
- *
- * @brief Abstract baseclass for Valuetypes
- * (see CORBA 2.3 20.17.5)
- */
-class TAO_Export CORBA_ValueBase
+namespace CORBA
 {
-public:
-  // reference counting
-  /// %! virtual CORBA::ValueBase* _copy_value (void) = 0;
-  virtual void _add_ref (void) = 0;
-  virtual void _remove_ref (void) = 0;
-  virtual CORBA::ULong _refcount_value (void) = 0;
-
-  // dynamic casting
-  static CORBA::ValueBase* _downcast (CORBA::ValueBase*);
-
-  /// TAO extension
-  virtual const char* _tao_obv_repository_id (void) const = 0;
-
-  // TAO internal --------------------------
-
-  /// Marshal a valuetype (see operator<< in tao_idl generated file
-  /// how it is called)
-  static CORBA::Boolean _tao_marshal (TAO_OutputCDR &strm,
-                                      CORBA_ValueBase *_this,
-                                      ptr_arith_t formal_type_id = 0);
-
-  /// Unmarshal a valuetype, if formal type is a pointer to ValueBase
-  static CORBA::Boolean _tao_unmarshal (TAO_InputCDR &strm,
-                                        CORBA_ValueBase *&new_object);
-
-  // static CORBA::Boolean
-  // T::_tao_unmarshal (TAO_InputCDR &, CORBA_ValueBase *&_this)
-  // is typespecific for valuetype T and generated from tao_idl
-  // Use this for unmarshaling.
-
-  /// Both used internally and are called from T::_tao_unmarshal ()
-  static CORBA::Boolean _tao_unmarshal_pre (TAO_InputCDR &strm,
-                                            CORBA_ValueFactory &,
-                                            CORBA_ValueBase *&,
-                                            const char * const repo_id);
-  CORBA::Boolean _tao_unmarshal_post (TAO_InputCDR &strm);
-
-public:  // otherwise these cannot be called from a static function
-  virtual void *_tao_obv_narrow (ptr_arith_t) = 0;
-
-  /// during marshal jump to the most derived part
-  virtual CORBA::Boolean _tao_marshal_v (TAO_OutputCDR &) = 0;
-
-  /// called after obtaining the fresh object from create_for_unmarshal ()
-  virtual CORBA::Boolean _tao_unmarshal_v (TAO_InputCDR &) = 0;
-
-protected:
-  CORBA_ValueBase (void);
-  CORBA_ValueBase (const CORBA_ValueBase&);
-  virtual ~CORBA_ValueBase (void);
-
-private:
-  CORBA_ValueBase & operator= (const CORBA_ValueBase &);
+  extern TAO_Export void add_ref (CORBA::ValueBase *val);
+  extern TAO_Export void remove_ref (CORBA::ValueBase *val);
+
+  /**
+   * @class ValueBase
+   *
+   * @brief Abstract baseclass for Valuetypes
+   *
+   * @see CORBA 2.3 - Section 20.17.5
+   */
+  class TAO_Export ValueBase
+  {
+  public:
+    // reference counting
+    /// %! virtual CORBA::ValueBase* _copy_value (void) = 0;
+    virtual void _add_ref (void) = 0;
+    virtual void _remove_ref (void) = 0;
+    virtual CORBA::ULong _refcount_value (void) = 0;
+
+    // dynamic casting
+    static CORBA::ValueBase* _downcast (CORBA::ValueBase*);
+
+    /// TAO extension
+    virtual const char* _tao_obv_repository_id (void) const = 0;
+
+    // TAO internal --------------------------
+
+    /// Marshal a valuetype (see operator<< in tao_idl generated file
+    /// how it is called)
+    static CORBA::Boolean _tao_marshal (TAO_OutputCDR &strm,
+                                        ValueBase *_this,
+                                        ptr_arith_t formal_type_id = 0);
+
+    /// Unmarshal a valuetype, if formal type is a pointer to
+    /// ValueBase
+    static CORBA::Boolean _tao_unmarshal (TAO_InputCDR &strm,
+                                          ValueBase *&new_object);
+
+    // static CORBA::Boolean
+    // T::_tao_unmarshal (TAO_InputCDR &, ValueBase *&_this)
+    // is typespecific for valuetype T and generated from tao_idl
+    // Use this for unmarshaling.
+
+    /// Both used internally and are called from T::_tao_unmarshal ()
+    static CORBA::Boolean _tao_unmarshal_pre (TAO_InputCDR &strm,
+                                              ValueFactory &,
+                                              ValueBase *&,
+                                              const char * const repo_id);
+    CORBA::Boolean _tao_unmarshal_post (TAO_InputCDR &strm);
+
+  public:  // otherwise these cannot be called from a static function
+
+    virtual void *_tao_obv_narrow (ptr_arith_t) = 0;
+
+    /// during marshal jump to the most derived part
+    virtual CORBA::Boolean _tao_marshal_v (TAO_OutputCDR &) = 0;
+
+    /// called after obtaining the fresh object from create_for_unmarshal ()
+    virtual CORBA::Boolean _tao_unmarshal_v (TAO_InputCDR &) = 0;
+
+  protected:
+    ValueBase (void);
+    ValueBase (const ValueBase&);
+    virtual ~ValueBase (void);
+
+  private:
+    ValueBase & operator= (const ValueBase &);
 
 #ifdef SUN_CC_HAS_PVFC_BUG
-  // Need ugly fix for sun cc "pure virtual function called" bug.
-private:
-  unsigned long tao_sun_cc_pvfc_bug_fix_;
+    // Need ugly fix for sun cc "pure virtual function called" bug.
+  private:
+    unsigned long tao_sun_cc_pvfc_bug_fix_;
 
 #endif /* SUN_CC_HAS_PVFC_BUG */
 
-}; // CORBA_ValueBase
+  }; // ValueBase
+
+  /**
+   * @class ValueBase_var
+   *
+   * @brief _var class for ValueBase
+   */
+  class TAO_Export ValueBase_var
+  {
+  public:
+    ValueBase_var (void);
+    ValueBase_var (CORBA::ValueBase *);
+    ValueBase_var (const ValueBase_var &);
+    ~ValueBase_var (void);
+
+    ValueBase_var &operator= (CORBA::ValueBase *);
+    ValueBase_var &operator= (const ValueBase_var &);
+    CORBA::ValueBase *operator-> (void) const;
+
+    operator const CORBA::ValueBase *() const;
+    operator CORBA::ValueBase *&();
+
+    /// in, inout, out, _retn
+    CORBA::ValueBase *in (void) const;
+    CORBA::ValueBase *&inout (void);
+    CORBA::ValueBase *&out (void);
+    CORBA::ValueBase *_retn (void);
+    CORBA::ValueBase *ptr (void) const;
+
+  private:
+    CORBA::ValueBase *ptr_;
+  };
+
+  /**
+   * @class ValueBase_out
+   *
+   * @brief _out class for CORBA::ValueBase
+   *
+   * _out class for CORBA::ValueBase
+   */
+  class TAO_Export ValueBase_out
+  {
+  public:
+    ValueBase_out (CORBA::ValueBase *&);
+    ValueBase_out (ValueBase_var &);
+    ValueBase_out (const ValueBase_out &);
+    ValueBase_out &operator= (const ValueBase_out &);
+    ValueBase_out &operator= (const ValueBase_var &);
+    ValueBase_out &operator= (CORBA::ValueBase *);
+    operator CORBA::ValueBase *&();
+    CORBA::ValueBase *&ptr (void);
+    CORBA::ValueBase *operator-> (void);
+
+  private:
+    CORBA::ValueBase *&ptr_;
+  };
+
+  /**
+   * @class DefaultValueRefCountBase
+   *
+   * @brief Default mix-in for reference count of a valuetype.
+   *
+   * Default mix-in for reference count of a valuetype.
+   */
+  class TAO_Export DefaultValueRefCountBase
+    : public virtual ValueBase
+  {
+  public:
+    virtual void _add_ref (void);
+    virtual void _remove_ref (void);
+    virtual CORBA::ULong _refcount_value (void);
+
+    /// The _tao variants are inline for fast access from T_var
+    /// (if valuetype T is compiled with optimization for that.) %! (todo)
+    void _tao_add_ref (void);
+    void _tao_remove_ref (void);
+    CORBA::ULong _tao_refcount_value (void);
+
+  protected:
+    DefaultValueRefCountBase (void);
+    DefaultValueRefCountBase (const DefaultValueRefCountBase&);
+    virtual ~DefaultValueRefCountBase ();
+
+  private:
+    void operator= (const DefaultValueRefCountBase &);
+
+  private: // data
+    CORBA::ULong _tao_reference_count_;
+    TAO_SYNCH_MUTEX _tao_reference_count_lock_;
+  }; // DefaultValueRefCountBase
+
+  //  which lock has the lowest memory overhead ?
+  // %! todo refcountbase w/o locking (now memory overhead)
+  // $! todo: debug aids for refcounts
+
+}  // End CORBA namespace
 
 /**
- * @class CORBA_ValueBase_var
- *
- * @brief _var class for ValueBase
- */
-class TAO_Export CORBA_ValueBase_var
-{
-public:
-  CORBA_ValueBase_var (void);
-  CORBA_ValueBase_var (CORBA::ValueBase *);
-  CORBA_ValueBase_var (const CORBA_ValueBase_var &);
-  ~CORBA_ValueBase_var (void);
-
-  CORBA_ValueBase_var &operator= (CORBA::ValueBase *);
-  CORBA_ValueBase_var &operator= (const CORBA_ValueBase_var &);
-  CORBA::ValueBase *operator-> (void) const;
-
-  operator const CORBA::ValueBase *() const;
-  operator CORBA::ValueBase *&();
-
-  /// in, inout, out, _retn
-  CORBA::ValueBase *in (void) const;
-  CORBA::ValueBase *&inout (void);
-  CORBA::ValueBase *&out (void);
-  CORBA::ValueBase *_retn (void);
-  CORBA::ValueBase *ptr (void) const;
-
-private:
-  CORBA::ValueBase *ptr_;
-};
-
-/**
- * @class CORBA_ValueBase_out
+ * @class TAO_OBV_GIOP_Flags
  *
- * @brief _out class for ValueBase
- */
-class TAO_Export CORBA_ValueBase_out
-{
-public:
-  CORBA_ValueBase_out (CORBA::ValueBase *&);
-  CORBA_ValueBase_out (CORBA_ValueBase_var &);
-  CORBA_ValueBase_out (const CORBA_ValueBase_out &);
-  CORBA_ValueBase_out &operator= (const CORBA_ValueBase_out &);
-  CORBA_ValueBase_out &operator= (const CORBA_ValueBase_var &);
-  CORBA_ValueBase_out &operator= (CORBA::ValueBase *);
-  operator CORBA::ValueBase *&();
-  CORBA::ValueBase *&ptr (void);
-  CORBA::ValueBase *operator-> (void);
-
-private:
-  CORBA::ValueBase *&ptr_;
-};
-
-/**
- * @class CORBA_DefaultValueRefCountBase
+ * @brief TAO_OBV_GIOP_Flags
  *
- * @brief Default mix-in for reference count of a valuetype.
- */
-class TAO_Export CORBA_DefaultValueRefCountBase : public virtual CORBA_ValueBase
-{
-
-public:
-  virtual void _add_ref (void);
-  virtual void _remove_ref (void);
-  virtual CORBA::ULong _refcount_value (void);
-
-  /// The _tao variants are inline for fast access from T_var
-  /// (if valuetype T is compiled with optimization for that.) %! (todo)
-  void _tao_add_ref (void);
-  void _tao_remove_ref (void);
-  CORBA::ULong _tao_refcount_value (void);
-
-protected:
-  CORBA_DefaultValueRefCountBase (void);
-  CORBA_DefaultValueRefCountBase (const CORBA_DefaultValueRefCountBase&);
-  virtual ~CORBA_DefaultValueRefCountBase ();
-
-private:
-  void operator= (const CORBA_DefaultValueRefCountBase &);
-
-private: // data
-  CORBA::ULong _tao_reference_count_;
-  TAO_SYNCH_MUTEX _tao_reference_count_lock_;
-}; // CORBA_DefaultValueRefCountBase
-
-// %! which lock has the lowest memory overhead ?
-// %! todo refcountbase w/o locking (now memory overhead)
-// $! todo: debug aids for refcounts
-
-
-/**
- * @class TAO_OBV_GIOP_Flags
- CORBA 2.3: 15.3.4
+ * @see CORBA 2.3 -- Section 15.3.4
  */
 class TAO_OBV_GIOP_Flags
 {
@@ -216,10 +232,10 @@ public:
 };
 
 TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR&, const CORBA_ValueBase *);
+operator<< (TAO_OutputCDR&, const CORBA::ValueBase *);
 
 TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR&, CORBA_ValueBase *&);
+operator>> (TAO_InputCDR&, CORBA::ValueBase *&);
 
 #if defined (__ACE_INLINE__)
 # include "tao/ValueBase.i"
diff --git a/TAO/tao/ValueBase.i b/TAO/tao/ValueBase.i
index 0fe4a816001..ae9643745b5 100644
--- a/TAO/tao/ValueBase.i
+++ b/TAO/tao/ValueBase.i
@@ -1,4 +1,5 @@
 // This may not look like C++, but it's really -*- C++ -*-
+//
 // $Id$
 
 // static operations in namespace CORBA ========================
@@ -21,55 +22,55 @@ CORBA::remove_ref (CORBA::ValueBase *val)
 
 // constructor
 ACE_INLINE
-CORBA_ValueBase::CORBA_ValueBase (void)
+CORBA::ValueBase::ValueBase (void)
 {
 }
 
 // *************************************************************
-// Inline operations for class CORBA_ValueBase_var
+// Inline operations for class CORBA::ValueBase_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ValueBase_var::CORBA_ValueBase_var (void)
+CORBA::ValueBase_var::ValueBase_var (void)
   : ptr_ (0)
 {
 }
 
 ACE_INLINE
-CORBA_ValueBase_var::CORBA_ValueBase_var (CORBA::ValueBase *p)
+CORBA::ValueBase_var::ValueBase_var (CORBA::ValueBase *p)
   : ptr_ (p)
 {
 }
 
 ACE_INLINE
-CORBA_ValueBase_var::~CORBA_ValueBase_var (void)
+CORBA::ValueBase_var::~ValueBase_var (void)
 {
   CORBA::remove_ref (this->ptr_);
 }
 
 ACE_INLINE CORBA::ValueBase *
-CORBA_ValueBase_var::ptr (void) const
+CORBA::ValueBase_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_ValueBase_var::CORBA_ValueBase_var (const CORBA_ValueBase_var &p)
+CORBA::ValueBase_var::ValueBase_var (const CORBA::ValueBase_var &p)
   : ptr_ (p.ptr_)
 {
   p.ptr_->_add_ref ();
 }
 
-ACE_INLINE CORBA_ValueBase_var &
-CORBA_ValueBase_var::operator= (CORBA::ValueBase *p)
+ACE_INLINE CORBA::ValueBase_var &
+CORBA::ValueBase_var::operator= (CORBA::ValueBase *p)
 {
   CORBA::remove_ref (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ValueBase_var &
-CORBA_ValueBase_var::operator= (const CORBA_ValueBase_var &p)
+ACE_INLINE CORBA::ValueBase_var &
+CORBA::ValueBase_var::operator= (const CORBA::ValueBase_var &p)
 {
   if (this != &p)
     {
@@ -82,37 +83,37 @@ CORBA_ValueBase_var::operator= (const CORBA_ValueBase_var &p)
 }
 
 ACE_INLINE
-CORBA_ValueBase_var::operator const CORBA::ValueBase *() const // cast
+CORBA::ValueBase_var::operator const CORBA::ValueBase *() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_ValueBase_var::operator CORBA::ValueBase *&() // cast
+CORBA::ValueBase_var::operator CORBA::ValueBase *&() // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::ValueBase *
-CORBA_ValueBase_var::operator-> (void) const
+CORBA::ValueBase_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::ValueBase *
-CORBA_ValueBase_var::in (void) const
+CORBA::ValueBase_var::in (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::ValueBase *&
-CORBA_ValueBase_var::inout (void)
+CORBA::ValueBase_var::inout (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::ValueBase *&
-CORBA_ValueBase_var::out (void)
+CORBA::ValueBase_var::out (void)
 {
   CORBA::remove_ref (this->ptr_);
   this->ptr_ = 0;
@@ -120,7 +121,7 @@ CORBA_ValueBase_var::out (void)
 }
 
 ACE_INLINE CORBA::ValueBase *
-CORBA_ValueBase_var::_retn (void)
+CORBA::ValueBase_var::_retn (void)
 {
   // Yield ownership of valuebase.
   CORBA::ValueBase *val = this->ptr_;
@@ -129,18 +130,18 @@ CORBA_ValueBase_var::_retn (void)
 }
 
 // *************************************************************
-// Inline operations for class CORBA_ValueBase_out
+// Inline operations for class CORBA::ValueBase_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ValueBase_out::CORBA_ValueBase_out (CORBA::ValueBase *&p)
+CORBA::ValueBase_out::ValueBase_out (CORBA::ValueBase *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ValueBase_out::CORBA_ValueBase_out (CORBA_ValueBase_var &p)
+CORBA::ValueBase_out::ValueBase_out (CORBA::ValueBase_var &p)
   : ptr_ (p.out ())
 {
   this->ptr_->_remove_ref ();
@@ -148,47 +149,47 @@ CORBA_ValueBase_out::CORBA_ValueBase_out (CORBA_ValueBase_var &p)
 }
 
 ACE_INLINE
-CORBA_ValueBase_out::CORBA_ValueBase_out (const CORBA_ValueBase_out &p)
+CORBA::ValueBase_out::ValueBase_out (const CORBA::ValueBase_out &p)
   : ptr_ (p.ptr_)
 {
 }
 
-ACE_INLINE CORBA_ValueBase_out &
-CORBA_ValueBase_out::operator= (const CORBA_ValueBase_out &p)
+ACE_INLINE CORBA::ValueBase_out &
+CORBA::ValueBase_out::operator= (const CORBA::ValueBase_out &p)
 {
   this->ptr_ = p.ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ValueBase_out &
-CORBA_ValueBase_out::operator= (const CORBA_ValueBase_var &p)
+ACE_INLINE CORBA::ValueBase_out &
+CORBA::ValueBase_out::operator= (const CORBA::ValueBase_var &p)
 {
   p.ptr ()->_add_ref ();
   this->ptr_ = p.ptr ();
   return *this;
 }
 
-ACE_INLINE CORBA_ValueBase_out &
-CORBA_ValueBase_out::operator= (CORBA::ValueBase *p)
+ACE_INLINE CORBA::ValueBase_out &
+CORBA::ValueBase_out::operator= (CORBA::ValueBase *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE
-CORBA_ValueBase_out::operator CORBA::ValueBase *&() // cast
+CORBA::ValueBase_out::operator CORBA::ValueBase *&() // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::ValueBase *&
-CORBA_ValueBase_out::ptr (void) // ptr
+CORBA::ValueBase_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::ValueBase *
-CORBA_ValueBase_out::operator-> (void)
+CORBA::ValueBase_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -197,21 +198,21 @@ CORBA_ValueBase_out::operator-> (void)
 
 // constructor
 ACE_INLINE
-CORBA_DefaultValueRefCountBase::CORBA_DefaultValueRefCountBase (void)
-    : _tao_reference_count_ (1)
+CORBA::DefaultValueRefCountBase::DefaultValueRefCountBase (void)
+  : _tao_reference_count_ (1)
 {
 }
 
 
 ACE_INLINE void
-CORBA_DefaultValueRefCountBase::_tao_add_ref (void)
+CORBA::DefaultValueRefCountBase::_tao_add_ref (void)
 {
   ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->_tao_reference_count_lock_);
   ++_tao_reference_count_;
 }
 
 ACE_INLINE void
-CORBA_DefaultValueRefCountBase::_tao_remove_ref (void)
+CORBA::DefaultValueRefCountBase::_tao_remove_ref (void)
 {
   {
     ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->_tao_reference_count_lock_);
@@ -226,9 +227,12 @@ CORBA_DefaultValueRefCountBase::_tao_remove_ref (void)
 }
 
 ACE_INLINE CORBA::ULong
-CORBA_DefaultValueRefCountBase::_tao_refcount_value (void)
+CORBA::DefaultValueRefCountBase::_tao_refcount_value (void)
 {
-  ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, guard, this->_tao_reference_count_lock_,0);
+  ACE_GUARD_RETURN (TAO_SYNCH_MUTEX,
+                    guard,
+                    this->_tao_reference_count_lock_,
+                    0);
   return _tao_reference_count_;
 }
 
diff --git a/TAO/tao/ValueFactory.cpp b/TAO/tao/ValueFactory.cpp
index 0e779a7a03f..6cf497f3750 100644
--- a/TAO/tao/ValueFactory.cpp
+++ b/TAO/tao/ValueFactory.cpp
@@ -1,35 +1,22 @@
-// $Id$
-
-// ============================================================================
-//
-// = LIBRARY
-//     TAO
-//
-// = FILENAME
-//     ValueFactory.cpp
-//
-// = AUTHOR
-//     Torsten Kuepper  <kuepper2@lfa.uni-wuppertal.de>
-//
-// ============================================================================
-
-
 #include "tao/ValueFactory.h"
 
 #if !defined (__ACE_INLINE__)
 # include "tao/ValueFactory.i"
 #endif /* ! __ACE_INLINE__ */
 
+
 ACE_RCSID (tao,
-           ValueFactory, "$Id$")
+           ValueFactory,
+           "$Id$")
+
 
-CORBA_ValueFactoryBase::~CORBA_ValueFactoryBase (void)
+CORBA::ValueFactoryBase::~ValueFactoryBase (void)
 {
 }
 
 // No-op. This should never be called, but it can't be pure virtual.
 CORBA::AbstractBase *
-CORBA_ValueFactoryBase::create_for_unmarshal_abstract (void)
+CORBA::ValueFactoryBase::create_for_unmarshal_abstract (void)
 {
   return 0;
 }
diff --git a/TAO/tao/ValueFactory.h b/TAO/tao/ValueFactory.h
index 2bf8c73c22a..8676a63e442 100644
--- a/TAO/tao/ValueFactory.h
+++ b/TAO/tao/ValueFactory.h
@@ -23,57 +23,61 @@
 
 #include "ace/Synch_T.h"
 
-class TAO_Export CORBA_ValueFactoryBase
+namespace CORBA
 {
-public:
-  CORBA_ValueFactoryBase ();
-  virtual ~CORBA_ValueFactoryBase ();
-
-  // non-virtual is non-standard
-  void _add_ref (void);
-  void _remove_ref (void);
-
-  // private: %!
-  /// In a derived class T use return type TAO_OBV_CREATE_RETURN_TYPE (T)
-  /// (see at definition below)
-  virtual CORBA_ValueBase * create_for_unmarshal (void) = 0;
-
-  // Not pure virtual because this will be overridden only by valuetypes
-  // that support an abstract interface.
-  virtual CORBA_AbstractBase * create_for_unmarshal_abstract (void);
-
-private:
-  CORBA::ULong _tao_reference_count_;
-  TAO_SYNCH_MUTEX _tao_reference_count_lock_;
-}; // CORBA_ValueFactoryBase
-
-/**
- * @class CORBA_ValueFactoryBase_var
- *
- * @brief _var class for ValueFactoryBase
- */
-class TAO_Export CORBA_ValueFactoryBase_var
-{
-public:
-  CORBA_ValueFactoryBase_var (void);
-  CORBA_ValueFactoryBase_var (CORBA::ValueFactoryBase *);
-  CORBA_ValueFactoryBase_var (const CORBA_ValueFactoryBase_var &);
-  ~CORBA_ValueFactoryBase_var (void);
-
-  CORBA_ValueFactoryBase_var &operator= (CORBA::ValueFactoryBase *);
-  CORBA_ValueFactoryBase_var &operator= (const CORBA_ValueFactoryBase_var &);
-  CORBA::ValueFactoryBase *operator-> (void) const;
-
-  /// in, inout, out, _retn
-  CORBA::ValueFactoryBase *in (void) const;
-  CORBA::ValueFactoryBase *&inout (void);
-  CORBA::ValueFactoryBase *&out (void);
-  CORBA::ValueFactoryBase *_retn (void);
-  CORBA::ValueFactoryBase *ptr (void) const;
-
-private:
-  CORBA::ValueFactoryBase *ptr_;
-};
+  class TAO_Export ValueFactoryBase
+  {
+  public:
+    ValueFactoryBase ();
+    virtual ~ValueFactoryBase ();
+
+    // non-virtual is non-standard
+    void _add_ref (void);
+    void _remove_ref (void);
+
+    // private: %!
+    /// In a derived class T use return type TAO_OBV_CREATE_RETURN_TYPE (T)
+    /// (see at definition below)
+    virtual CORBA::ValueBase * create_for_unmarshal (void) = 0;
+
+    // Not pure virtual because this will be overridden only by valuetypes
+    // that support an abstract interface.
+    virtual CORBA::AbstractBase * create_for_unmarshal_abstract (void);
+
+  private:
+    CORBA::ULong _tao_reference_count_;
+    TAO_SYNCH_MUTEX _tao_reference_count_lock_;
+  }; // CORBA_ValueFactoryBase
+
+  /**
+   * @class ValueFactoryBase_var
+   *
+   * @brief _var class for ValueFactoryBase
+   */
+  class TAO_Export ValueFactoryBase_var
+  {
+  public:
+    ValueFactoryBase_var (void);
+    ValueFactoryBase_var (CORBA::ValueFactoryBase *);
+    ValueFactoryBase_var (const ValueFactoryBase_var &);
+    ~ValueFactoryBase_var (void);
+
+    ValueFactoryBase_var &operator= (CORBA::ValueFactoryBase *);
+    ValueFactoryBase_var &operator= (const ValueFactoryBase_var &);
+    CORBA::ValueFactoryBase *operator-> (void) const;
+
+    /// in, inout, out, _retn
+    CORBA::ValueFactoryBase *in (void) const;
+    CORBA::ValueFactoryBase *&inout (void);
+    CORBA::ValueFactoryBase *&out (void);
+    CORBA::ValueFactoryBase *_retn (void);
+    CORBA::ValueFactoryBase *ptr (void) const;
+
+  private:
+    CORBA::ValueFactoryBase *ptr_;
+  };
+
+}  // End CORBA namespace
 
 // Use this macro for writing code that is independend from
 // the compiler support of covariant return types of pointers to
@@ -83,9 +87,9 @@ private:
 // elaborated --- its just a suggestion.)
 
 #ifdef TAO_HAS_OBV_COVARIANT_RETURN
-#  define TAO_OBV_CREATE_RETURN_TYPE(TYPE) TYPE *
+#  define TAO_OBV_CREATE_RETURN_TYPE (TYPE) TYPE *
 #else /*  TAO_HAS_OBV_COVARIANT_RETURN */
-#  define TAO_OBV_CREATE_RETURN_TYPE(TYPE) CORBA::ValueBase *
+#  define TAO_OBV_CREATE_RETURN_TYPE (TYPE) CORBA::ValueBase *
 #endif /* TAO_HAS_OBV_COVARIANT_RETURN */
 
 // (The obtaining of the repository id is currently not yet like the OMG way. %!)
@@ -97,15 +101,16 @@ private:
 // to the newly created one. (A new reference could be obtained with
 // orb->lookup_value_factory (char * repo_id) .)
 
-#define TAO_OBV_REGISTER_FACTORY(FACTORY,VALUETYPE) \
-  { CORBA_ValueFactory factory = new FACTORY; \
-    CORBA_ValueFactory prev_factory = \
+#define TAO_OBV_REGISTER_FACTORY (FACTORY, VALUETYPE) \
+  { CORBA::ValueFactory factory = new FACTORY; \
+    CORBA::ValueFactory prev_factory = \
     TAO_ORB_Core_instance ()->orb ()->register_value_factory (\
-                                   VALUETYPE::_tao_obv_static_repository_id (),\
+      VALUETYPE::_tao_obv_static_repository_id (),\
                                    factory); \
     if (prev_factory) prev_factory->_remove_ref (); \
     factory->_remove_ref (); }
 
+
 #if defined (__ACE_INLINE__)
 # include "tao/ValueFactory.i"
 #endif /* __ACE_INLINE__) */
diff --git a/TAO/tao/ValueFactory.i b/TAO/tao/ValueFactory.i
index 0df4a5d0442..bbb6ad561fe 100644
--- a/TAO/tao/ValueFactory.i
+++ b/TAO/tao/ValueFactory.i
@@ -1,20 +1,22 @@
+// -*- C++ -*-
+//
 // $Id$
 
 ACE_INLINE
-CORBA_ValueFactoryBase::CORBA_ValueFactoryBase ()
+CORBA::ValueFactoryBase::ValueFactoryBase (void)
   : _tao_reference_count_ (1)
 {
 }
 
 ACE_INLINE void
-CORBA_ValueFactoryBase::_add_ref (void)
+CORBA::ValueFactoryBase::_add_ref (void)
 {
   ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->_tao_reference_count_lock_);
   ++_tao_reference_count_;
 }
 
 ACE_INLINE void
-CORBA_ValueFactoryBase::_remove_ref (void)
+CORBA::ValueFactoryBase::_remove_ref (void)
 {
   {
     ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->_tao_reference_count_lock_);
@@ -26,17 +28,17 @@ CORBA_ValueFactoryBase::_remove_ref (void)
 }
 
 // *************************************************************
-// Inline operations for class CORBA_ValueFactoryBase_var
+// Inline operations for class CORBA::ValueFactoryBase_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ValueFactoryBase_var::CORBA_ValueFactoryBase_var (void)
+CORBA::ValueFactoryBase_var::ValueFactoryBase_var (void)
   : ptr_ (0)
 {
 }
 
 ACE_INLINE
-CORBA_ValueFactoryBase_var::CORBA_ValueFactoryBase_var (
+CORBA::ValueFactoryBase_var::ValueFactoryBase_var (
     CORBA::ValueFactoryBase *p
   )
   : ptr_ (p)
@@ -44,7 +46,7 @@ CORBA_ValueFactoryBase_var::CORBA_ValueFactoryBase_var (
 }
 
 ACE_INLINE
-CORBA_ValueFactoryBase_var::~CORBA_ValueFactoryBase_var (void)
+CORBA::ValueFactoryBase_var::~ValueFactoryBase_var (void)
 {
   if (this->ptr_ != 0)
     {
@@ -53,22 +55,22 @@ CORBA_ValueFactoryBase_var::~CORBA_ValueFactoryBase_var (void)
 }
 
 ACE_INLINE CORBA::ValueFactoryBase *
-CORBA_ValueFactoryBase_var::ptr (void) const
+CORBA::ValueFactoryBase_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_ValueFactoryBase_var::CORBA_ValueFactoryBase_var (
-    const CORBA_ValueFactoryBase_var &p
+CORBA::ValueFactoryBase_var::ValueFactoryBase_var (
+    const CORBA::ValueFactoryBase_var &p
   )
   : ptr_ (p.ptr_)
 {
   p.ptr_->_add_ref ();
 }
 
-ACE_INLINE CORBA_ValueFactoryBase_var &
-CORBA_ValueFactoryBase_var::operator= (CORBA::ValueFactoryBase *p)
+ACE_INLINE CORBA::ValueFactoryBase_var &
+CORBA::ValueFactoryBase_var::operator= (CORBA::ValueFactoryBase *p)
 {
   if (this->ptr_ != 0)
     {
@@ -79,8 +81,8 @@ CORBA_ValueFactoryBase_var::operator= (CORBA::ValueFactoryBase *p)
   return *this;
 }
 
-ACE_INLINE CORBA_ValueFactoryBase_var &
-CORBA_ValueFactoryBase_var::operator= (const CORBA_ValueFactoryBase_var &p)
+ACE_INLINE CORBA::ValueFactoryBase_var &
+CORBA::ValueFactoryBase_var::operator= (const CORBA::ValueFactoryBase_var &p)
 {
   if (this != &p)
     {
@@ -97,25 +99,25 @@ CORBA_ValueFactoryBase_var::operator= (const CORBA_ValueFactoryBase_var &p)
 }
 
 ACE_INLINE CORBA::ValueFactoryBase *
-CORBA_ValueFactoryBase_var::operator-> (void) const
+CORBA::ValueFactoryBase_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::ValueFactoryBase *
-CORBA_ValueFactoryBase_var::in (void) const
+CORBA::ValueFactoryBase_var::in (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::ValueFactoryBase *&
-CORBA_ValueFactoryBase_var::inout (void)
+CORBA::ValueFactoryBase_var::inout (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE CORBA::ValueFactoryBase *&
-CORBA_ValueFactoryBase_var::out (void)
+CORBA::ValueFactoryBase_var::out (void)
 {
   if (this->ptr_ != 0)
     {
@@ -127,7 +129,7 @@ CORBA_ValueFactoryBase_var::out (void)
 }
 
 ACE_INLINE CORBA::ValueFactoryBase *
-CORBA_ValueFactoryBase_var::_retn (void)
+CORBA::ValueFactoryBase_var::_retn (void)
 {
   // Yield ownership of valuebase.
   CORBA::ValueFactoryBase *val = this->ptr_;