Tue Jun 12 18:28:46 2001 Frank Hunleth <fhunleth@cs.wustl.edu>

18 files changed, 6751 insertions, 887 deletions

diff --git a/TAO/ChangeLogs/ChangeLog-02a b/TAO/ChangeLogs/ChangeLog-02a
index 47f1f29cd84..8e29fa7e19f 100644
--- a/TAO/ChangeLogs/ChangeLog-02a
+++ b/TAO/ChangeLogs/ChangeLog-02a
@@ -1,3 +1,36 @@
+Tue Jun 12 18:28:46 2001  Frank Hunleth  <fhunleth@cs.wustl.edu>
+
+        * tao/Policy.pidl:
+        * tao/diffs/PolicyC.cpp.diff:
+        * tao/diffs/PolicyC.h.diff:
+        * tao/diffs/PolicyC.i.diff:
+        * tao/diffs/PolicyS.h.diff:
+          Regenerated diff files and added information to the  
+          instructions in Policy.pidl to make regeneration easier 
+          for the next person.
+
+        * tao/TAO.pidl:
+        * tao/diffs/TAOC.cpp.diff:
+        * tao/diffs/TAOC.h.diff:
+        * tao/diffs/TAOC.i.diff:
+          Regenerated diff files and added instructions to the pidl
+          file since it wasn't specified how this was being done 
+          before.
+
+        * tao/RTCORBA/RTCORBA.pidl:
+        * tao/RTCORBA/diffs/RTCORBAC.cpp.diff:
+        * tao/RTCORBA/diffs/RTCORBAC.h.diff:
+        * tao/RTCORBA/diffs/RTCORBAC.i.diff:
+          Updated instructions in the pidl file.  Also moved the
+          diff files from tao/diffs to under RTCORBA.
+
+        * tao/RTPortableServer/RTPortableServer.pidl:
+        * tao/RTPortableServer/diffs/RTPortableServerC.cpp.diff:
+        * tao/RTPortableServer/diffs/RTPortableServerC.h.diff:
+        * tao/RTPortableServer/diffs/RTPortableServerC.i.diff:
+          Updated instructions in the pidl file.  Also moved the
+          diff files from tao/diffs to under RTPortableServer.
+
 Tue Jun 12 18:21:06 2001  Douglas C. Schmidt  <schmidt@tango.doc.wustl.edu>
 
 	* tao/TAO_Internal.cpp (open_services): Added a missing call to
diff --git a/TAO/tao/Policy.pidl b/TAO/tao/Policy.pidl
index 4bdd915b8f1..e937de6458c 100644
--- a/TAO/tao/Policy.pidl
+++ b/TAO/tao/Policy.pidl
@@ -30,6 +30,7 @@
 //   command used for this is:
 //
 //     tao_idl.exe
+//          -o orig
 //          -Ge 1
 //          -Wb,export_macro=TAO_Export
 //          -Wb,export_include="tao/corbafwd.h"
@@ -51,22 +52,23 @@
 //   patch < diffs/PolicyC.i.diff
 //   patch < diffs/PolicyC.cpp.diff
 //
-//   patch < diffs/PolicyS.cpp.diff
+//   patch < diffs/PolicyS.h.diff
 //
 //   4. You'll have to move the Policy skeleton definition from
 //   PolicyS.h to the POA_CORBA.h by hand.
 //
 //   5. Undo the patches to this pidl file.
 //
+//   patch -R < diffs/Policy.pidl.diff
+//
 //   Note: The diffs were generated with these commands:
 //
 //   diff -wbu Policy.pidl Policy.pidl.mod > diffs/Policy.pidl.diff
 //
-//   diff -wbu PolicyC.h PolicyC.h.mod > diffs/PolicyC.h.diff
-//   diff -wbu PolicyC.i PolicyC.i.mod > diffs/PolicyC.i.diff
-//   diff -wbu PolicyC.cpp PolicyC.cpp.mod > diffs/PolicyC.cpp.diff
-//
-//   diff -wbu PolicyS.cpp PolicyS.cpp.mod > diffs/PolicyS.cpp.diff
+//   diff -wBbu orig/PolicyC.h PolicyC.h > diffs/PolicyC.h.diff
+//   diff -wBbu orig/PolicyC.i PolicyC.i > diffs/PolicyC.i.diff
+//   diff -wBbu orig/PolicyC.cpp PolicyC.cpp > diffs/PolicyC.cpp.diff
+//   diff -wBbu orig/PolicyS.h PolicyS.h > diffs/PolicyS.h.diff
 //
 // ================================================================
 
diff --git a/TAO/tao/RTCORBA/RTCORBA.pidl b/TAO/tao/RTCORBA/RTCORBA.pidl
index 1e45ff0bf5f..b71cb4438c6 100644
--- a/TAO/tao/RTCORBA/RTCORBA.pidl
+++ b/TAO/tao/RTCORBA/RTCORBA.pidl
@@ -23,25 +23,36 @@
 //     3.  Added RT_ORB::create_tcp_protocol_properties which seems
 //         to come and go from the formal specification, but is needed.
 //
-//   This file was used to generate the code in
-//   RTCORBA{C,S,S_T}.{h,i,cpp} The command used to generate code
-//   is:
+//   This file was used to generate the code in RTCORBAC.{h,i,cpp}.
+//   The steps to regenerate the code are as follows:
 //
-//     tao_idl -o orig -Gp -Gd -Ge 1 -Gv
+//   1. Run the tao_idl compiler on the pidl file.  The command used for
+//   this is:
+//
+//     tao_idl -o orig -Gp -Gd -Ge 1
 //          -Wb,export_macro=TAO_RTCORBA_Export
 //          -Wb,export_include="rtcorba_export.h"
 //          -Wb,pre_include="ace/pre.h"
 //          -Wb,post_include="ace/post.h"
 //          RTCORBA.pidl
 //
-//   After the files are generated, patches located in tao/diffs
-//   directory must be applied.  The patches provide the following
-//   fixes: 1) remove several unnecessary includes, e.g., corba.h,
-//   stream.h, Policy.h, 3) add anything else we need into the namespace,
-//   i.e., TAO_Priority_Mapping, and 4) fix "nested_class" occurrences in
-//   .cpp.  These changes are required because the generated code is part
-//   of the TAO library, it hardly makes any sense to change the IDL
-//   compiler to support changes that are very occasional.
+//   2. Then apply the patches in tao/RTCORBA/diffs to the generated code.
+//   The patches provide the following fixes: 1) remove several unnecessary
+//   includes, e.g., corba.h, stream.h, Policy.h, 3) add anything else we
+//   need into the namespace, i.e., TAO_Priority_Mapping, and 4) fix
+//   "nested_class" occurrences in the .cpp.
+//
+//   Apply patches using the following commands:
+//
+//   patch < diffs/RTCORBAC.h.diff
+//   patch < diffs/RTCORBAC.i.diff
+//   patch < diffs/RTCORBAC.cpp.diff
+//
+//   Note: The diffs were generated with these commands:
+//
+//   diff -wBbu orig/RTCORBAC.h RTCORBAC.h > diffs/RTCORBAC.h.diff
+//   diff -wBbu orig/RTCORBAC.i RTCORBAC.i > diffs/RTCORBAC.i.diff
+//   diff -wBbu orig/RTCORBAC.cpp RTCORBAC.cpp > diffs/RTCORBAC.cpp.diff
 //
 // ================================================================
 
diff --git a/TAO/tao/RTCORBA/diffs/RTCORBAC.cpp.diff b/TAO/tao/RTCORBA/diffs/RTCORBAC.cpp.diff
new file mode 100644
index 00000000000..6fca600699e
--- /dev/null
+++ b/TAO/tao/RTCORBA/diffs/RTCORBAC.cpp.diff
@@ -0,0 +1,988 @@
+--- orig/RTCORBAC.cpp	Tue Jun 12 17:56:16 2001
++++ RTCORBAC.cpp	Tue Jun 12 16:14:06 2001
+@@ -1,6 +1,6 @@
+ // -*- C++ -*-
+ //
+-// $Id$
++// $Id$
+ 
+ // ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+ // TAO and the TAO IDL Compiler have been developed by:
+@@ -19,16 +19,18 @@
+ // Information about TAO is available at:
+ //     http://www.cs.wustl.edu/~schmidt/TAO.html
+ 
++#define TAO_RTCORBA_SAFE_INCLUDE
+ #include "RTCORBAC.h"
++#undef TAO_RTCORBA_SAFE_INCLUDE
+ 
+ #include "tao/Stub.h"
+ #include "tao/Invocation.h"
+-#include "tao/PortableInterceptor.h"
++
++#include "tao/TAOS.h"
++#include "tao/Typecode.h"
+ 
+ #if TAO_HAS_INTERCEPTORS == 1
+ #include "tao/RequestInfo_Util.h"
+-#include "tao/ClientRequestInfo.h"
+-#include "tao/ClientInterceptorAdapter.h"
+ #endif  /* TAO_HAS_INTERCEPTORS == 1 */
+ 
+ #if defined (__BORLANDC__)
+@@ -227,9 +229,9 @@
+ TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ThreadpoolLane, &_tc_TAO_tc_RTCORBA_ThreadpoolLane)
+ TAO_NAMESPACE_END
+ 
+-void RTCORBA::ThreadpoolLane::_tao_any_destructor (void *_tao_void_pointer)
++void RTCORBA::ThreadpoolLane::_tao_any_destructor (void *x)
+ {
+-  ThreadpoolLane *tmp = ACE_static_cast (ThreadpoolLane*, _tao_void_pointer);
++  ThreadpoolLane *tmp = ACE_static_cast (ThreadpoolLane*,x);
+   delete tmp;
+ }
+ 
+@@ -320,9 +322,9 @@
+ {}
+ RTCORBA::ThreadpoolLanes::~ThreadpoolLanes (void) // dtor
+ {}
+-void RTCORBA::ThreadpoolLanes::_tao_any_destructor (void *_tao_void_pointer)
++void RTCORBA::ThreadpoolLanes::_tao_any_destructor (void *x)
+ {
+-  ThreadpoolLanes *tmp = ACE_static_cast (ThreadpoolLanes*, _tao_void_pointer);
++  ThreadpoolLanes *tmp = ACE_static_cast (ThreadpoolLanes*,x);
+   delete tmp;
+ }
+ 
+@@ -478,48 +480,6 @@
+ TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_PriorityModel, &_tc_TAO_tc_RTCORBA_PriorityModel)
+ TAO_NAMESPACE_END
+ 
+-RTCORBA::PriorityModelPolicy_ptr
+-tao_RTCORBA_PriorityModelPolicy_duplicate (
+-    RTCORBA::PriorityModelPolicy_ptr p
+-  )
+-{
+-  return RTCORBA::PriorityModelPolicy::_duplicate (p);
+-}
+-
+-void
+-tao_RTCORBA_PriorityModelPolicy_release (
+-    RTCORBA::PriorityModelPolicy_ptr p
+-  )
+-{
+-  CORBA::release (p);
+-}
+-
+-RTCORBA::PriorityModelPolicy_ptr
+-tao_RTCORBA_PriorityModelPolicy_nil (
+-    void
+-  )
+-{
+-  return RTCORBA::PriorityModelPolicy::_nil ();
+-}
+-
+-RTCORBA::PriorityModelPolicy_ptr
+-tao_RTCORBA_PriorityModelPolicy_narrow (
+-    CORBA::Object *p,
+-    CORBA::Environment &ACE_TRY_ENV
+-  )
+-{
+-  return RTCORBA::PriorityModelPolicy::_narrow (p, ACE_TRY_ENV);
+-}
+-
+-CORBA::Object *
+-tao_RTCORBA_PriorityModelPolicy_upcast (
+-    void *src
+-  )
+-{
+-  RTCORBA::PriorityModelPolicy **tmp =
+-    ACE_static_cast (RTCORBA::PriorityModelPolicy **, src);
+-  return *tmp;
+-}
+ 
+ // *************************************************************
+ // Operations for class RTCORBA::PriorityModelPolicy_var
+@@ -643,9 +603,8 @@
+     ACE_static_cast (PriorityModelPolicy **, src);
+   return *tmp;
+ }
+-
+ // *************************************************************
+-// Operations for class RTCORBA::PriorityModelPolicy_out
++// Inline operations for class RTCORBA::PriorityModelPolicy_out
+ // *************************************************************
+ 
+ RTCORBA::PriorityModelPolicy_out::PriorityModelPolicy_out (PriorityModelPolicy_ptr &p)
+@@ -788,48 +747,6 @@
+ TAO_NAMESPACE_BEGIN (RTCORBA)
+ TAO_NAMESPACE_DEFINE (const CORBA::ULong, THREADPOOL_POLICY_TYPE, 41U)
+ TAO_NAMESPACE_END
+-RTCORBA::ThreadpoolPolicy_ptr
+-tao_RTCORBA_ThreadpoolPolicy_duplicate (
+-    RTCORBA::ThreadpoolPolicy_ptr p
+-  )
+-{
+-  return RTCORBA::ThreadpoolPolicy::_duplicate (p);
+-}
+-
+-void
+-tao_RTCORBA_ThreadpoolPolicy_release (
+-    RTCORBA::ThreadpoolPolicy_ptr p
+-  )
+-{
+-  CORBA::release (p);
+-}
+-
+-RTCORBA::ThreadpoolPolicy_ptr
+-tao_RTCORBA_ThreadpoolPolicy_nil (
+-    void
+-  )
+-{
+-  return RTCORBA::ThreadpoolPolicy::_nil ();
+-}
+-
+-RTCORBA::ThreadpoolPolicy_ptr
+-tao_RTCORBA_ThreadpoolPolicy_narrow (
+-    CORBA::Object *p,
+-    CORBA::Environment &ACE_TRY_ENV
+-  )
+-{
+-  return RTCORBA::ThreadpoolPolicy::_narrow (p, ACE_TRY_ENV);
+-}
+-
+-CORBA::Object *
+-tao_RTCORBA_ThreadpoolPolicy_upcast (
+-    void *src
+-  )
+-{
+-  RTCORBA::ThreadpoolPolicy **tmp =
+-    ACE_static_cast (RTCORBA::ThreadpoolPolicy **, src);
+-  return *tmp;
+-}
+ 
+ // *************************************************************
+ // Operations for class RTCORBA::ThreadpoolPolicy_var
+@@ -953,9 +870,8 @@
+     ACE_static_cast (ThreadpoolPolicy **, src);
+   return *tmp;
+ }
+-
+ // *************************************************************
+-// Operations for class RTCORBA::ThreadpoolPolicy_out
++// Inline operations for class RTCORBA::ThreadpoolPolicy_out
+ // *************************************************************
+ 
+ RTCORBA::ThreadpoolPolicy_out::ThreadpoolPolicy_out (ThreadpoolPolicy_ptr &p)
+@@ -1094,48 +1010,6 @@
+   return "IDL:omg.org/RTCORBA/ThreadpoolPolicy:1.0";
+ }
+ 
+-RTCORBA::ProtocolProperties_ptr
+-tao_RTCORBA_ProtocolProperties_duplicate (
+-    RTCORBA::ProtocolProperties_ptr p
+-  )
+-{
+-  return RTCORBA::ProtocolProperties::_duplicate (p);
+-}
+-
+-void
+-tao_RTCORBA_ProtocolProperties_release (
+-    RTCORBA::ProtocolProperties_ptr p
+-  )
+-{
+-  CORBA::release (p);
+-}
+-
+-RTCORBA::ProtocolProperties_ptr
+-tao_RTCORBA_ProtocolProperties_nil (
+-    void
+-  )
+-{
+-  return RTCORBA::ProtocolProperties::_nil ();
+-}
+-
+-RTCORBA::ProtocolProperties_ptr
+-tao_RTCORBA_ProtocolProperties_narrow (
+-    CORBA::Object *p,
+-    CORBA::Environment &ACE_TRY_ENV
+-  )
+-{
+-  return RTCORBA::ProtocolProperties::_narrow (p, ACE_TRY_ENV);
+-}
+-
+-CORBA::Object *
+-tao_RTCORBA_ProtocolProperties_upcast (
+-    void *src
+-  )
+-{
+-  RTCORBA::ProtocolProperties **tmp =
+-    ACE_static_cast (RTCORBA::ProtocolProperties **, src);
+-  return *tmp;
+-}
+ 
+ // *************************************************************
+ // Operations for class RTCORBA::ProtocolProperties_var
+@@ -1259,9 +1133,8 @@
+     ACE_static_cast (ProtocolProperties **, src);
+   return *tmp;
+ }
+-
+ // *************************************************************
+-// Operations for class RTCORBA::ProtocolProperties_out
++// Inline operations for class RTCORBA::ProtocolProperties_out
+ // *************************************************************
+ 
+ RTCORBA::ProtocolProperties_out::ProtocolProperties_out (ProtocolProperties_ptr &p)
+@@ -1475,9 +1348,9 @@
+ {}
+ RTCORBA::ProtocolList::~ProtocolList (void) // dtor
+ {}
+-void RTCORBA::ProtocolList::_tao_any_destructor (void *_tao_void_pointer)
++void RTCORBA::ProtocolList::_tao_any_destructor (void *x)
+ {
+-  ProtocolList *tmp = ACE_static_cast (ProtocolList*, _tao_void_pointer);
++  ProtocolList *tmp = ACE_static_cast (ProtocolList*,x);
+   delete tmp;
+ }
+ 
+@@ -1488,48 +1361,6 @@
+ TAO_NAMESPACE_BEGIN (RTCORBA)
+ TAO_NAMESPACE_DEFINE (const CORBA::ULong, SERVER_PROTOCOL_POLICY_TYPE, 42U)
+ TAO_NAMESPACE_END
+-RTCORBA::ServerProtocolPolicy_ptr
+-tao_RTCORBA_ServerProtocolPolicy_duplicate (
+-    RTCORBA::ServerProtocolPolicy_ptr p
+-  )
+-{
+-  return RTCORBA::ServerProtocolPolicy::_duplicate (p);
+-}
+-
+-void
+-tao_RTCORBA_ServerProtocolPolicy_release (
+-    RTCORBA::ServerProtocolPolicy_ptr p
+-  )
+-{
+-  CORBA::release (p);
+-}
+-
+-RTCORBA::ServerProtocolPolicy_ptr
+-tao_RTCORBA_ServerProtocolPolicy_nil (
+-    void
+-  )
+-{
+-  return RTCORBA::ServerProtocolPolicy::_nil ();
+-}
+-
+-RTCORBA::ServerProtocolPolicy_ptr
+-tao_RTCORBA_ServerProtocolPolicy_narrow (
+-    CORBA::Object *p,
+-    CORBA::Environment &ACE_TRY_ENV
+-  )
+-{
+-  return RTCORBA::ServerProtocolPolicy::_narrow (p, ACE_TRY_ENV);
+-}
+-
+-CORBA::Object *
+-tao_RTCORBA_ServerProtocolPolicy_upcast (
+-    void *src
+-  )
+-{
+-  RTCORBA::ServerProtocolPolicy **tmp =
+-    ACE_static_cast (RTCORBA::ServerProtocolPolicy **, src);
+-  return *tmp;
+-}
+ 
+ // *************************************************************
+ // Operations for class RTCORBA::ServerProtocolPolicy_var
+@@ -1653,9 +1484,8 @@
+     ACE_static_cast (ServerProtocolPolicy **, src);
+   return *tmp;
+ }
+-
+ // *************************************************************
+-// Operations for class RTCORBA::ServerProtocolPolicy_out
++// Inline operations for class RTCORBA::ServerProtocolPolicy_out
+ // *************************************************************
+ 
+ RTCORBA::ServerProtocolPolicy_out::ServerProtocolPolicy_out (ServerProtocolPolicy_ptr &p)
+@@ -1798,48 +1628,6 @@
+ TAO_NAMESPACE_BEGIN (RTCORBA)
+ TAO_NAMESPACE_DEFINE (const CORBA::ULong, CLIENT_PROTOCOL_POLICY_TYPE, 43U)
+ TAO_NAMESPACE_END
+-RTCORBA::ClientProtocolPolicy_ptr
+-tao_RTCORBA_ClientProtocolPolicy_duplicate (
+-    RTCORBA::ClientProtocolPolicy_ptr p
+-  )
+-{
+-  return RTCORBA::ClientProtocolPolicy::_duplicate (p);
+-}
+-
+-void
+-tao_RTCORBA_ClientProtocolPolicy_release (
+-    RTCORBA::ClientProtocolPolicy_ptr p
+-  )
+-{
+-  CORBA::release (p);
+-}
+-
+-RTCORBA::ClientProtocolPolicy_ptr
+-tao_RTCORBA_ClientProtocolPolicy_nil (
+-    void
+-  )
+-{
+-  return RTCORBA::ClientProtocolPolicy::_nil ();
+-}
+-
+-RTCORBA::ClientProtocolPolicy_ptr
+-tao_RTCORBA_ClientProtocolPolicy_narrow (
+-    CORBA::Object *p,
+-    CORBA::Environment &ACE_TRY_ENV
+-  )
+-{
+-  return RTCORBA::ClientProtocolPolicy::_narrow (p, ACE_TRY_ENV);
+-}
+-
+-CORBA::Object *
+-tao_RTCORBA_ClientProtocolPolicy_upcast (
+-    void *src
+-  )
+-{
+-  RTCORBA::ClientProtocolPolicy **tmp =
+-    ACE_static_cast (RTCORBA::ClientProtocolPolicy **, src);
+-  return *tmp;
+-}
+ 
+ // *************************************************************
+ // Operations for class RTCORBA::ClientProtocolPolicy_var
+@@ -1963,9 +1751,8 @@
+     ACE_static_cast (ClientProtocolPolicy **, src);
+   return *tmp;
+ }
+-
+ // *************************************************************
+-// Operations for class RTCORBA::ClientProtocolPolicy_out
++// Inline operations for class RTCORBA::ClientProtocolPolicy_out
+ // *************************************************************
+ 
+ RTCORBA::ClientProtocolPolicy_out::ClientProtocolPolicy_out (ClientProtocolPolicy_ptr &p)
+@@ -2108,48 +1895,6 @@
+ TAO_NAMESPACE_BEGIN (RTCORBA)
+ TAO_NAMESPACE_DEFINE (const CORBA::ULong, PRIVATE_CONNECTION_POLICY_TYPE, 44U)
+ TAO_NAMESPACE_END
+-RTCORBA::PrivateConnectionPolicy_ptr
+-tao_RTCORBA_PrivateConnectionPolicy_duplicate (
+-    RTCORBA::PrivateConnectionPolicy_ptr p
+-  )
+-{
+-  return RTCORBA::PrivateConnectionPolicy::_duplicate (p);
+-}
+-
+-void
+-tao_RTCORBA_PrivateConnectionPolicy_release (
+-    RTCORBA::PrivateConnectionPolicy_ptr p
+-  )
+-{
+-  CORBA::release (p);
+-}
+-
+-RTCORBA::PrivateConnectionPolicy_ptr
+-tao_RTCORBA_PrivateConnectionPolicy_nil (
+-    void
+-  )
+-{
+-  return RTCORBA::PrivateConnectionPolicy::_nil ();
+-}
+-
+-RTCORBA::PrivateConnectionPolicy_ptr
+-tao_RTCORBA_PrivateConnectionPolicy_narrow (
+-    CORBA::Object *p,
+-    CORBA::Environment &ACE_TRY_ENV
+-  )
+-{
+-  return RTCORBA::PrivateConnectionPolicy::_narrow (p, ACE_TRY_ENV);
+-}
+-
+-CORBA::Object *
+-tao_RTCORBA_PrivateConnectionPolicy_upcast (
+-    void *src
+-  )
+-{
+-  RTCORBA::PrivateConnectionPolicy **tmp =
+-    ACE_static_cast (RTCORBA::PrivateConnectionPolicy **, src);
+-  return *tmp;
+-}
+ 
+ // *************************************************************
+ // Operations for class RTCORBA::PrivateConnectionPolicy_var
+@@ -2273,9 +2018,8 @@
+     ACE_static_cast (PrivateConnectionPolicy **, src);
+   return *tmp;
+ }
+-
+ // *************************************************************
+-// Operations for class RTCORBA::PrivateConnectionPolicy_out
++// Inline operations for class RTCORBA::PrivateConnectionPolicy_out
+ // *************************************************************
+ 
+ RTCORBA::PrivateConnectionPolicy_out::PrivateConnectionPolicy_out (PrivateConnectionPolicy_ptr &p)
+@@ -2414,49 +2158,6 @@
+   return "IDL:omg.org/RTCORBA/PrivateConnectionPolicy:1.0";
+ }
+ 
+-RTCORBA::TCPProtocolProperties_ptr
+-tao_RTCORBA_TCPProtocolProperties_duplicate (
+-    RTCORBA::TCPProtocolProperties_ptr p
+-  )
+-{
+-  return RTCORBA::TCPProtocolProperties::_duplicate (p);
+-}
+-
+-void
+-tao_RTCORBA_TCPProtocolProperties_release (
+-    RTCORBA::TCPProtocolProperties_ptr p
+-  )
+-{
+-  CORBA::release (p);
+-}
+-
+-RTCORBA::TCPProtocolProperties_ptr
+-tao_RTCORBA_TCPProtocolProperties_nil (
+-    void
+-  )
+-{
+-  return RTCORBA::TCPProtocolProperties::_nil ();
+-}
+-
+-RTCORBA::TCPProtocolProperties_ptr
+-tao_RTCORBA_TCPProtocolProperties_narrow (
+-    CORBA::Object *p,
+-    CORBA::Environment &ACE_TRY_ENV
+-  )
+-{
+-  return RTCORBA::TCPProtocolProperties::_narrow (p, ACE_TRY_ENV);
+-}
+-
+-CORBA::Object *
+-tao_RTCORBA_TCPProtocolProperties_upcast (
+-    void *src
+-  )
+-{
+-  RTCORBA::TCPProtocolProperties **tmp =
+-    ACE_static_cast (RTCORBA::TCPProtocolProperties **, src);
+-  return *tmp;
+-}
+-
+ // *************************************************************
+ // Operations for class RTCORBA::TCPProtocolProperties_var
+ // *************************************************************
+@@ -2579,9 +2280,8 @@
+     ACE_static_cast (TCPProtocolProperties **, src);
+   return *tmp;
+ }
+-
+ // *************************************************************
+-// Operations for class RTCORBA::TCPProtocolProperties_out
++// Inline operations for class RTCORBA::TCPProtocolProperties_out
+ // *************************************************************
+ 
+ RTCORBA::TCPProtocolProperties_out::TCPProtocolProperties_out (TCPProtocolProperties_ptr &p)
+@@ -2640,6 +2340,21 @@
+ }
+ 
+ 
++//////////////////////////////////////////////////////
++// CDR Encoding Support
++
++CORBA::Boolean
++RTCORBA::ProtocolProperties::_tao_encode (TAO_OutputCDR &)
++{
++  return 1;
++}
++
++CORBA::Boolean
++RTCORBA::ProtocolProperties::_tao_decode (TAO_InputCDR &)
++{
++  return 1;
++}
++
+ // default constructor
+ RTCORBA::TCPProtocolProperties::TCPProtocolProperties ()
+ {
+@@ -2720,48 +2435,6 @@
+   return "IDL:omg.org/RTCORBA/TCPProtocolProperties:1.0";
+ }
+ 
+-RTCORBA::GIOPProtocolProperties_ptr
+-tao_RTCORBA_GIOPProtocolProperties_duplicate (
+-    RTCORBA::GIOPProtocolProperties_ptr p
+-  )
+-{
+-  return RTCORBA::GIOPProtocolProperties::_duplicate (p);
+-}
+-
+-void
+-tao_RTCORBA_GIOPProtocolProperties_release (
+-    RTCORBA::GIOPProtocolProperties_ptr p
+-  )
+-{
+-  CORBA::release (p);
+-}
+-
+-RTCORBA::GIOPProtocolProperties_ptr
+-tao_RTCORBA_GIOPProtocolProperties_nil (
+-    void
+-  )
+-{
+-  return RTCORBA::GIOPProtocolProperties::_nil ();
+-}
+-
+-RTCORBA::GIOPProtocolProperties_ptr
+-tao_RTCORBA_GIOPProtocolProperties_narrow (
+-    CORBA::Object *p,
+-    CORBA::Environment &ACE_TRY_ENV
+-  )
+-{
+-  return RTCORBA::GIOPProtocolProperties::_narrow (p, ACE_TRY_ENV);
+-}
+-
+-CORBA::Object *
+-tao_RTCORBA_GIOPProtocolProperties_upcast (
+-    void *src
+-  )
+-{
+-  RTCORBA::GIOPProtocolProperties **tmp =
+-    ACE_static_cast (RTCORBA::GIOPProtocolProperties **, src);
+-  return *tmp;
+-}
+ 
+ // *************************************************************
+ // Operations for class RTCORBA::GIOPProtocolProperties_var
+@@ -2885,9 +2558,8 @@
+     ACE_static_cast (GIOPProtocolProperties **, src);
+   return *tmp;
+ }
+-
+ // *************************************************************
+-// Operations for class RTCORBA::GIOPProtocolProperties_out
++// Inline operations for class RTCORBA::GIOPProtocolProperties_out
+ // *************************************************************
+ 
+ RTCORBA::GIOPProtocolProperties_out::GIOPProtocolProperties_out (GIOPProtocolProperties_ptr &p)
+@@ -3026,48 +2698,6 @@
+   return "IDL:omg.org/RTCORBA/GIOPProtocolProperties:1.0";
+ }
+ 
+-RTCORBA::UnixDomainProtocolProperties_ptr
+-tao_RTCORBA_UnixDomainProtocolProperties_duplicate (
+-    RTCORBA::UnixDomainProtocolProperties_ptr p
+-  )
+-{
+-  return RTCORBA::UnixDomainProtocolProperties::_duplicate (p);
+-}
+-
+-void
+-tao_RTCORBA_UnixDomainProtocolProperties_release (
+-    RTCORBA::UnixDomainProtocolProperties_ptr p
+-  )
+-{
+-  CORBA::release (p);
+-}
+-
+-RTCORBA::UnixDomainProtocolProperties_ptr
+-tao_RTCORBA_UnixDomainProtocolProperties_nil (
+-    void
+-  )
+-{
+-  return RTCORBA::UnixDomainProtocolProperties::_nil ();
+-}
+-
+-RTCORBA::UnixDomainProtocolProperties_ptr
+-tao_RTCORBA_UnixDomainProtocolProperties_narrow (
+-    CORBA::Object *p,
+-    CORBA::Environment &ACE_TRY_ENV
+-  )
+-{
+-  return RTCORBA::UnixDomainProtocolProperties::_narrow (p, ACE_TRY_ENV);
+-}
+-
+-CORBA::Object *
+-tao_RTCORBA_UnixDomainProtocolProperties_upcast (
+-    void *src
+-  )
+-{
+-  RTCORBA::UnixDomainProtocolProperties **tmp =
+-    ACE_static_cast (RTCORBA::UnixDomainProtocolProperties **, src);
+-  return *tmp;
+-}
+ 
+ // *************************************************************
+ // Operations for class RTCORBA::UnixDomainProtocolProperties_var
+@@ -3191,9 +2821,8 @@
+     ACE_static_cast (UnixDomainProtocolProperties **, src);
+   return *tmp;
+ }
+-
+ // *************************************************************
+-// Operations for class RTCORBA::UnixDomainProtocolProperties_out
++// Inline operations for class RTCORBA::UnixDomainProtocolProperties_out
+ // *************************************************************
+ 
+ RTCORBA::UnixDomainProtocolProperties_out::UnixDomainProtocolProperties_out (UnixDomainProtocolProperties_ptr &p)
+@@ -3332,48 +2961,6 @@
+   return "IDL:omg.org/RTCORBA/UnixDomainProtocolProperties:1.0";
+ }
+ 
+-RTCORBA::SharedMemoryProtocolProperties_ptr
+-tao_RTCORBA_SharedMemoryProtocolProperties_duplicate (
+-    RTCORBA::SharedMemoryProtocolProperties_ptr p
+-  )
+-{
+-  return RTCORBA::SharedMemoryProtocolProperties::_duplicate (p);
+-}
+-
+-void
+-tao_RTCORBA_SharedMemoryProtocolProperties_release (
+-    RTCORBA::SharedMemoryProtocolProperties_ptr p
+-  )
+-{
+-  CORBA::release (p);
+-}
+-
+-RTCORBA::SharedMemoryProtocolProperties_ptr
+-tao_RTCORBA_SharedMemoryProtocolProperties_nil (
+-    void
+-  )
+-{
+-  return RTCORBA::SharedMemoryProtocolProperties::_nil ();
+-}
+-
+-RTCORBA::SharedMemoryProtocolProperties_ptr
+-tao_RTCORBA_SharedMemoryProtocolProperties_narrow (
+-    CORBA::Object *p,
+-    CORBA::Environment &ACE_TRY_ENV
+-  )
+-{
+-  return RTCORBA::SharedMemoryProtocolProperties::_narrow (p, ACE_TRY_ENV);
+-}
+-
+-CORBA::Object *
+-tao_RTCORBA_SharedMemoryProtocolProperties_upcast (
+-    void *src
+-  )
+-{
+-  RTCORBA::SharedMemoryProtocolProperties **tmp =
+-    ACE_static_cast (RTCORBA::SharedMemoryProtocolProperties **, src);
+-  return *tmp;
+-}
+ 
+ // *************************************************************
+ // Operations for class RTCORBA::SharedMemoryProtocolProperties_var
+@@ -3497,9 +3084,8 @@
+     ACE_static_cast (SharedMemoryProtocolProperties **, src);
+   return *tmp;
+ }
+-
+ // *************************************************************
+-// Operations for class RTCORBA::SharedMemoryProtocolProperties_out
++// Inline operations for class RTCORBA::SharedMemoryProtocolProperties_out
+ // *************************************************************
+ 
+ RTCORBA::SharedMemoryProtocolProperties_out::SharedMemoryProtocolProperties_out (SharedMemoryProtocolProperties_ptr &p)
+@@ -3718,9 +3304,9 @@
+ TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_PriorityBand, &_tc_TAO_tc_RTCORBA_PriorityBand)
+ TAO_NAMESPACE_END
+ 
+-void RTCORBA::PriorityBand::_tao_any_destructor (void *_tao_void_pointer)
++void RTCORBA::PriorityBand::_tao_any_destructor (void *x)
+ {
+-  PriorityBand *tmp = ACE_static_cast (PriorityBand*, _tao_void_pointer);
++  PriorityBand *tmp = ACE_static_cast (PriorityBand*,x);
+   delete tmp;
+ }
+ 
+@@ -3811,9 +3397,9 @@
+ {}
+ RTCORBA::PriorityBands::~PriorityBands (void) // dtor
+ {}
+-void RTCORBA::PriorityBands::_tao_any_destructor (void *_tao_void_pointer)
++void RTCORBA::PriorityBands::_tao_any_destructor (void *x)
+ {
+-  PriorityBands *tmp = ACE_static_cast (PriorityBands*, _tao_void_pointer);
++  PriorityBands *tmp = ACE_static_cast (PriorityBands*,x);
+   delete tmp;
+ }
+ 
+@@ -3929,48 +3515,6 @@
+ TAO_NAMESPACE_BEGIN (RTCORBA)
+ TAO_NAMESPACE_DEFINE (const CORBA::ULong, PRIORITY_BANDED_CONNECTION_POLICY_TYPE, 45U)
+ TAO_NAMESPACE_END
+-RTCORBA::PriorityBandedConnectionPolicy_ptr
+-tao_RTCORBA_PriorityBandedConnectionPolicy_duplicate (
+-    RTCORBA::PriorityBandedConnectionPolicy_ptr p
+-  )
+-{
+-  return RTCORBA::PriorityBandedConnectionPolicy::_duplicate (p);
+-}
+-
+-void
+-tao_RTCORBA_PriorityBandedConnectionPolicy_release (
+-    RTCORBA::PriorityBandedConnectionPolicy_ptr p
+-  )
+-{
+-  CORBA::release (p);
+-}
+-
+-RTCORBA::PriorityBandedConnectionPolicy_ptr
+-tao_RTCORBA_PriorityBandedConnectionPolicy_nil (
+-    void
+-  )
+-{
+-  return RTCORBA::PriorityBandedConnectionPolicy::_nil ();
+-}
+-
+-RTCORBA::PriorityBandedConnectionPolicy_ptr
+-tao_RTCORBA_PriorityBandedConnectionPolicy_narrow (
+-    CORBA::Object *p,
+-    CORBA::Environment &ACE_TRY_ENV
+-  )
+-{
+-  return RTCORBA::PriorityBandedConnectionPolicy::_narrow (p, ACE_TRY_ENV);
+-}
+-
+-CORBA::Object *
+-tao_RTCORBA_PriorityBandedConnectionPolicy_upcast (
+-    void *src
+-  )
+-{
+-  RTCORBA::PriorityBandedConnectionPolicy **tmp =
+-    ACE_static_cast (RTCORBA::PriorityBandedConnectionPolicy **, src);
+-  return *tmp;
+-}
+ 
+ // *************************************************************
+ // Operations for class RTCORBA::PriorityBandedConnectionPolicy_var
+@@ -4094,9 +3638,8 @@
+     ACE_static_cast (PriorityBandedConnectionPolicy **, src);
+   return *tmp;
+ }
+-
+ // *************************************************************
+-// Operations for class RTCORBA::PriorityBandedConnectionPolicy_out
++// Inline operations for class RTCORBA::PriorityBandedConnectionPolicy_out
+ // *************************************************************
+ 
+ RTCORBA::PriorityBandedConnectionPolicy_out::PriorityBandedConnectionPolicy_out (PriorityBandedConnectionPolicy_ptr &p)
+@@ -4235,48 +3778,6 @@
+   return "IDL:omg.org/RTCORBA/PriorityBandedConnectionPolicy:1.0";
+ }
+ 
+-RTCORBA::Current_ptr
+-tao_RTCORBA_Current_duplicate (
+-    RTCORBA::Current_ptr p
+-  )
+-{
+-  return RTCORBA::Current::_duplicate (p);
+-}
+-
+-void
+-tao_RTCORBA_Current_release (
+-    RTCORBA::Current_ptr p
+-  )
+-{
+-  CORBA::release (p);
+-}
+-
+-RTCORBA::Current_ptr
+-tao_RTCORBA_Current_nil (
+-    void
+-  )
+-{
+-  return RTCORBA::Current::_nil ();
+-}
+-
+-RTCORBA::Current_ptr
+-tao_RTCORBA_Current_narrow (
+-    CORBA::Object *p,
+-    CORBA::Environment &ACE_TRY_ENV
+-  )
+-{
+-  return RTCORBA::Current::_narrow (p, ACE_TRY_ENV);
+-}
+-
+-CORBA::Object *
+-tao_RTCORBA_Current_upcast (
+-    void *src
+-  )
+-{
+-  RTCORBA::Current **tmp =
+-    ACE_static_cast (RTCORBA::Current **, src);
+-  return *tmp;
+-}
+ 
+ // *************************************************************
+ // Operations for class RTCORBA::Current_var
+@@ -4400,9 +3901,8 @@
+     ACE_static_cast (Current **, src);
+   return *tmp;
+ }
+-
+ // *************************************************************
+-// Operations for class RTCORBA::Current_out
++// Inline operations for class RTCORBA::Current_out
+ // *************************************************************
+ 
+ RTCORBA::Current_out::Current_out (Current_ptr &p)
+@@ -4541,48 +4041,6 @@
+   return "IDL:omg.org/RTCORBA/Current:1.0";
+ }
+ 
+-RTCORBA::Mutex_ptr
+-tao_RTCORBA_Mutex_duplicate (
+-    RTCORBA::Mutex_ptr p
+-  )
+-{
+-  return RTCORBA::Mutex::_duplicate (p);
+-}
+-
+-void
+-tao_RTCORBA_Mutex_release (
+-    RTCORBA::Mutex_ptr p
+-  )
+-{
+-  CORBA::release (p);
+-}
+-
+-RTCORBA::Mutex_ptr
+-tao_RTCORBA_Mutex_nil (
+-    void
+-  )
+-{
+-  return RTCORBA::Mutex::_nil ();
+-}
+-
+-RTCORBA::Mutex_ptr
+-tao_RTCORBA_Mutex_narrow (
+-    CORBA::Object *p,
+-    CORBA::Environment &ACE_TRY_ENV
+-  )
+-{
+-  return RTCORBA::Mutex::_narrow (p, ACE_TRY_ENV);
+-}
+-
+-CORBA::Object *
+-tao_RTCORBA_Mutex_upcast (
+-    void *src
+-  )
+-{
+-  RTCORBA::Mutex **tmp =
+-    ACE_static_cast (RTCORBA::Mutex **, src);
+-  return *tmp;
+-}
+ 
+ // *************************************************************
+ // Operations for class RTCORBA::Mutex_var
+@@ -4706,9 +4164,8 @@
+     ACE_static_cast (Mutex **, src);
+   return *tmp;
+ }
+-
+ // *************************************************************
+-// Operations for class RTCORBA::Mutex_out
++// Inline operations for class RTCORBA::Mutex_out
+ // *************************************************************
+ 
+ RTCORBA::Mutex_out::Mutex_out (Mutex_ptr &p)
+@@ -4835,48 +4292,6 @@
+   return "IDL:omg.org/RTCORBA/Mutex:1.0";
+ }
+ 
+-RTCORBA::RTORB_ptr
+-tao_RTCORBA_RTORB_duplicate (
+-    RTCORBA::RTORB_ptr p
+-  )
+-{
+-  return RTCORBA::RTORB::_duplicate (p);
+-}
+-
+-void
+-tao_RTCORBA_RTORB_release (
+-    RTCORBA::RTORB_ptr p
+-  )
+-{
+-  CORBA::release (p);
+-}
+-
+-RTCORBA::RTORB_ptr
+-tao_RTCORBA_RTORB_nil (
+-    void
+-  )
+-{
+-  return RTCORBA::RTORB::_nil ();
+-}
+-
+-RTCORBA::RTORB_ptr
+-tao_RTCORBA_RTORB_narrow (
+-    CORBA::Object *p,
+-    CORBA::Environment &ACE_TRY_ENV
+-  )
+-{
+-  return RTCORBA::RTORB::_narrow (p, ACE_TRY_ENV);
+-}
+-
+-CORBA::Object *
+-tao_RTCORBA_RTORB_upcast (
+-    void *src
+-  )
+-{
+-  RTCORBA::RTORB **tmp =
+-    ACE_static_cast (RTCORBA::RTORB **, src);
+-  return *tmp;
+-}
+ 
+ // *************************************************************
+ // Operations for class RTCORBA::RTORB_var
+@@ -5000,9 +4415,8 @@
+     ACE_static_cast (RTORB **, src);
+   return *tmp;
+ }
+-
+ // *************************************************************
+-// Operations for class RTCORBA::RTORB_out
++// Inline operations for class RTCORBA::RTORB_out
+ // *************************************************************
+ 
+ RTCORBA::RTORB_out::RTORB_out (RTORB_ptr &p)
+@@ -5224,7 +4638,7 @@
+ 
+ // Narrow.
+ RTCORBA::RTORB::InvalidThreadpool *
+-RTCORBA::RTORB::InvalidThreadpool::_downcast (CORBA::Exception *exc)
++RTCORBA::RTORB::InvalidThreadpool::_narrow (CORBA::Exception *exc)
+ {
+   if (!ACE_OS::strcmp ("IDL:omg.org/RTCORBA/RTORB/InvalidThreadpool:1.0", exc->_id ()))
+     {
+@@ -5782,11 +5196,6 @@
+     // If length is 0 we return true.
+     if (0 >= _tao_seq_len) 
+       return 1;
+-    // Add a check to the length of the sequence
+-    // to make sure it does not exceed the length
+-    // of the stream. (See bug 58.)
+-    if (_tao_seq_len > strm.length())
+-      return 0;
+     // retrieve all the elements
+     CORBA::Boolean _tao_marshal_flag = 1;
+     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+@@ -5829,11 +5238,6 @@
+     // If length is 0 we return true.
+     if (0 >= _tao_seq_len) 
+       return 1;
+-    // Add a check to the length of the sequence
+-    // to make sure it does not exceed the length
+-    // of the stream. (See bug 58.)
+-    if (_tao_seq_len > strm.length())
+-      return 0;
+     // retrieve all the elements
+     CORBA::Boolean _tao_marshal_flag = 1;
+     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
diff --git a/TAO/tao/RTCORBA/diffs/RTCORBAC.h.diff b/TAO/tao/RTCORBA/diffs/RTCORBAC.h.diff
new file mode 100644
index 00000000000..32680ce026e
--- /dev/null
+++ b/TAO/tao/RTCORBA/diffs/RTCORBAC.h.diff
@@ -0,0 +1,1175 @@
+--- orig/RTCORBAC.h	Tue Jun 12 17:56:16 2001
++++ RTCORBAC.h	Tue Jun 12 16:14:06 2001
+@@ -1,6 +1,6 @@
+ // -*- C++ -*-
+ //
+-// $Id$
++// $Id$
+ 
+ // ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+ // TAO and the TAO IDL Compiler have been developed by:
+@@ -23,15 +23,26 @@
+ #define _TAO_IDL_ORIG_RTCORBAC_H_
+ 
+ #include "ace/pre.h"
+-#include "tao/corba.h"
++#include "tao/orbconf.h"
++
++#include "rtcorba_export.h"
+ 
+ #if !defined (ACE_LACKS_PRAGMA_ONCE)
+ # pragma once
+ #endif /* ACE_LACKS_PRAGMA_ONCE */
+ 
+-#include "rtcorba_export.h"
+-#include "IOPC.h"
+-#include "TimeBaseC.h"
++#include "tao/IOPC.h"
++#include "tao/PolicyC.h"
++#include "tao/TimeBaseC.h"
++
++#include "tao/Encodable.h"
++
++#include "Priority_Mapping_Manager.h"
++
++#ifndef TAO_RTCORBA_SAFE_INCLUDE
++#error "You should not include RTCORBAC.h directly, use RTCORBA.h"
++#endif /* !TAO_RTCORBA_SAFE_INCLUDE */
++
+ 
+ #if defined (TAO_EXPORT_MACRO)
+ #undef TAO_EXPORT_MACRO
+@@ -58,6 +69,13 @@
+ 
+ TAO_NAMESPACE  RTCORBA
+ {
++  // TAO-specific
++  typedef TAO_Priority_Mapping_Manager PriorityMappingManager;
++  typedef TAO_Priority_Mapping_Manager *PriorityMappingManager_ptr;
++  typedef TAO_Priority_Mapping_Manager_var PriorityMappingManager_var;
++  typedef TAO_Priority_Mapping_Manager_out PriorityMappingManager_out;
++  // End TAO-specific
++
+   typedef CORBA::Short NativePriority;
+   typedef CORBA::Short_out NativePriority_out;
+   TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_NativePriority;
+@@ -70,6 +88,7 @@
+   
+   TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short maxPriority;
+   
++  typedef TAO_Priority_Mapping PriorityMapping;
+   typedef CORBA::ULong ThreadpoolId;
+   typedef CORBA::ULong_out ThreadpoolId_out;
+   TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ThreadpoolId;
+@@ -89,23 +108,20 @@
+     ACE_NESTED_CLASS (RTCORBA, Priority) lane_priority;
+     CORBA::ULong static_threads;
+     CORBA::ULong dynamic_threads;
+-    
+   };
+   
+   class TAO_RTCORBA_Export ThreadpoolLane_var
+   {
+   public:
+-    ThreadpoolLane_var (void);
++    ThreadpoolLane_var (void); // default constructor
+     ThreadpoolLane_var (ThreadpoolLane *);
+-    ThreadpoolLane_var (const ThreadpoolLane_var &);
+-    // Fixed-size types only.
+-    ThreadpoolLane_var (const ThreadpoolLane &);
+-    ~ThreadpoolLane_var (void);
++    ThreadpoolLane_var (const ThreadpoolLane_var &); // copy constructor
++    ThreadpoolLane_var (const ThreadpoolLane &); // fixed-size types only
++    ~ThreadpoolLane_var (void); // destructor
+     
+     ThreadpoolLane_var &operator= (ThreadpoolLane *);
+     ThreadpoolLane_var &operator= (const ThreadpoolLane_var &);
+-    // Fixed-size types only.
+-    ThreadpoolLane_var &operator= (const ThreadpoolLane &);
++    ThreadpoolLane_var &operator= (const ThreadpoolLane &); // fixed-size types only
+     ThreadpoolLane *operator-> (void);
+     const ThreadpoolLane *operator-> (void) const;
+     
+@@ -134,46 +150,36 @@
+ #if !defined (__TAO_UNBOUNDED_SEQUENCE_RTCORBA_THREADPOOLLANES_CH_)
+ #define __TAO_UNBOUNDED_SEQUENCE_RTCORBA_THREADPOOLLANES_CH_
+   
+-  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes
+-    : public TAO_Unbounded_Base_Sequence
++    class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes : public TAO_Unbounded_Base_Sequence
+   {
+   public:
+     // = Initialization and termination methods.
+-    _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes (void);
++
++      _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes (void); // Default constructor.
+     _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes (CORBA::ULong maximum); 
+-    _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes (
+-        CORBA::ULong maximum,
++      _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes (CORBA::ULong maximum,
+         CORBA::ULong length,
+         ThreadpoolLane *data,
+-        CORBA::Boolean release = 0
+-      );
+-    _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes (
+-        const _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes &rhs
+-      );
+-    _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes &operator= (
+-        const _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes &rhs
+-      );
+-    virtual ~_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes (void);
+-    
++        CORBA::Boolean release = 0);
++      _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes (const _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes &rhs);
++      _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes &operator= (const _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes &rhs);
++      virtual ~_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes (void); // Dtor.
+     // = Accessors.
+     ThreadpoolLane &operator[] (CORBA::ULong i);
+     const ThreadpoolLane &operator[] (CORBA::ULong i) const;
+-    
+     // = Static operations.
+     static ThreadpoolLane *allocbuf (CORBA::ULong size);
+     static void freebuf (ThreadpoolLane *buffer);
+-    
+-    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+     virtual void _allocate_buffer (CORBA::ULong length);
+     virtual void _deallocate_buffer (void);
++      // Implement the TAO_Base_Sequence methods (see Sequence.h)
++
+     ThreadpoolLane *get_buffer (CORBA::Boolean orphan = 0);
+     const ThreadpoolLane *get_buffer (void) const;
+-    void replace (
+-        CORBA::ULong max,
++      void replace (CORBA::ULong max,
+         CORBA::ULong length,
+         ThreadpoolLane *data,
+-        CORBA::Boolean release
+-      );
++        CORBA::Boolean release);
+   };
+   
+ #endif /* end #if !defined */
+@@ -215,7 +221,6 @@
+     typedef ThreadpoolLanes_var _var_type;
+ #endif /* ! __GNUC__ || g++ >= 2.8 */
+     
+-    
+   };
+   
+ #endif /* end #if !defined */
+@@ -231,17 +236,15 @@
+   class TAO_RTCORBA_Export ThreadpoolLanes_var
+   {
+   public:
+-    ThreadpoolLanes_var (void);
++    ThreadpoolLanes_var (void); // default constructor
+     ThreadpoolLanes_var (ThreadpoolLanes *);
+-    ThreadpoolLanes_var (const ThreadpoolLanes_var &);
+-    // Fixed-size base types only.
+-    ThreadpoolLanes_var (const ThreadpoolLanes &);
+-    ~ThreadpoolLanes_var (void);
++    ThreadpoolLanes_var (const ThreadpoolLanes_var &); // copy constructor
++    ThreadpoolLanes_var (const ThreadpoolLanes &); // fixed-size base types only
++    ~ThreadpoolLanes_var (void); // destructor
+     
+     ThreadpoolLanes_var &operator= (ThreadpoolLanes *);
+     ThreadpoolLanes_var &operator= (const ThreadpoolLanes_var &);
+-    // Fixed-size base types only.
+-    ThreadpoolLanes_var &operator= (const ThreadpoolLanes &);
++    ThreadpoolLanes_var &operator= (const ThreadpoolLanes &); // fixed-size base types only
+     ThreadpoolLanes *operator-> (void);
+     const ThreadpoolLanes *operator-> (void) const;
+     
+@@ -285,7 +288,7 @@
+   
+   private:
+     ThreadpoolLanes *&ptr_;
+-    // Assignment from T_var not allowed.
++    // assignment from T_var not allowed
+     void operator= (const ThreadpoolLanes_var &);
+   };
+   
+@@ -301,7 +304,6 @@
+     CLIENT_PROPAGATED,
+     SERVER_DECLARED
+   };
+-  
+   typedef PriorityModel &PriorityModel_out;
+   TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PriorityModel;
+   
+@@ -344,10 +346,7 @@
+     static PriorityModelPolicy_ptr duplicate (PriorityModelPolicy_ptr);
+     static void release (PriorityModelPolicy_ptr);
+     static PriorityModelPolicy_ptr nil (void);
+-    static PriorityModelPolicy_ptr narrow (
+-        CORBA::Object *,
+-        CORBA::Environment &
+-      );
++    static PriorityModelPolicy_ptr narrow (CORBA::Object *, CORBA::Environment &);
+     static CORBA::Object * upcast (void *);
+   
+   private:
+@@ -388,8 +387,7 @@
+ #if !defined (_RTCORBA_PRIORITYMODELPOLICY_CH_)
+ #define _RTCORBA_PRIORITYMODELPOLICY_CH_
+   
+-  class TAO_RTCORBA_Export PriorityModelPolicy
+-    : public virtual CORBA::Policy
++class TAO_RTCORBA_Export PriorityModelPolicy: public virtual CORBA::Policy
+   {
+   public:
+   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+@@ -399,19 +397,16 @@
+ 
+     // the static operations
+     static PriorityModelPolicy_ptr _duplicate (PriorityModelPolicy_ptr obj);
+-    
+     static PriorityModelPolicy_ptr _narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static PriorityModelPolicy_ptr _unchecked_narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static PriorityModelPolicy_ptr _nil (void)
+       {
+         return (PriorityModelPolicy_ptr)0;
+@@ -441,7 +436,6 @@
+     PriorityModelPolicy ();
+     
+     virtual ~PriorityModelPolicy (void);
+-  
+   private:
+     PriorityModelPolicy (const PriorityModelPolicy &);
+     void operator= (const PriorityModelPolicy &);
+@@ -491,10 +485,7 @@
+     static ThreadpoolPolicy_ptr duplicate (ThreadpoolPolicy_ptr);
+     static void release (ThreadpoolPolicy_ptr);
+     static ThreadpoolPolicy_ptr nil (void);
+-    static ThreadpoolPolicy_ptr narrow (
+-        CORBA::Object *,
+-        CORBA::Environment &
+-      );
++    static ThreadpoolPolicy_ptr narrow (CORBA::Object *, CORBA::Environment &);
+     static CORBA::Object * upcast (void *);
+   
+   private:
+@@ -535,8 +526,7 @@
+ #if !defined (_RTCORBA_THREADPOOLPOLICY_CH_)
+ #define _RTCORBA_THREADPOOLPOLICY_CH_
+   
+-  class TAO_RTCORBA_Export ThreadpoolPolicy
+-    : public virtual CORBA::Policy
++class TAO_RTCORBA_Export ThreadpoolPolicy: public virtual CORBA::Policy
+   {
+   public:
+   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+@@ -546,19 +536,16 @@
+ 
+     // the static operations
+     static ThreadpoolPolicy_ptr _duplicate (ThreadpoolPolicy_ptr obj);
+-    
+     static ThreadpoolPolicy_ptr _narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static ThreadpoolPolicy_ptr _unchecked_narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static ThreadpoolPolicy_ptr _nil (void)
+       {
+         return (ThreadpoolPolicy_ptr)0;
+@@ -580,7 +567,6 @@
+     ThreadpoolPolicy ();
+     
+     virtual ~ThreadpoolPolicy (void);
+-  
+   private:
+     ThreadpoolPolicy (const ThreadpoolPolicy &);
+     void operator= (const ThreadpoolPolicy &);
+@@ -628,10 +614,7 @@
+     static ProtocolProperties_ptr duplicate (ProtocolProperties_ptr);
+     static void release (ProtocolProperties_ptr);
+     static ProtocolProperties_ptr nil (void);
+-    static ProtocolProperties_ptr narrow (
+-        CORBA::Object *,
+-        CORBA::Environment &
+-      );
++    static ProtocolProperties_ptr narrow (CORBA::Object *, CORBA::Environment &);
+     static CORBA::Object * upcast (void *);
+   
+   private:
+@@ -672,8 +655,8 @@
+ #if !defined (_RTCORBA_PROTOCOLPROPERTIES_CH_)
+ #define _RTCORBA_PROTOCOLPROPERTIES_CH_
+   
+-  class TAO_RTCORBA_Export ProtocolProperties
+-    : public virtual CORBA_Object
++class TAO_RTCORBA_Export ProtocolProperties : public virtual CORBA_Object,
++                                      public TAO_Encodable
+   {
+   public:
+   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+@@ -683,19 +666,16 @@
+ 
+     // the static operations
+     static ProtocolProperties_ptr _duplicate (ProtocolProperties_ptr obj);
+-    
+     static ProtocolProperties_ptr _narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static ProtocolProperties_ptr _unchecked_narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static ProtocolProperties_ptr _nil (void)
+       {
+         return (ProtocolProperties_ptr)0;
+@@ -705,11 +685,15 @@
+     
+     virtual const char* _interface_repository_id (void) const;
+ 
++    // CDR Encoder/Decoder methods.
++
++    virtual CORBA::Boolean _tao_encode (TAO_OutputCDR &out_cdr);
++    virtual CORBA::Boolean _tao_decode (TAO_InputCDR &in_cdr);
++
+   protected:
+     ProtocolProperties ();
+     
+     virtual ~ProtocolProperties (void);
+-  
+   private:
+     ProtocolProperties (const ProtocolProperties &);
+     void operator= (const ProtocolProperties &);
+@@ -731,16 +715,15 @@
+     IOP::ProfileId protocol_type;
+     ACE_NESTED_CLASS (RTCORBA, ProtocolProperties_var) orb_protocol_properties;
+     ACE_NESTED_CLASS (RTCORBA, ProtocolProperties_var) transport_protocol_properties;
+-    
+   };
+   
+   class TAO_RTCORBA_Export Protocol_var
+   {
+   public:
+-    Protocol_var (void);
++    Protocol_var (void); // default constructor
+     Protocol_var (Protocol *);
+-    Protocol_var (const Protocol_var &);
+-    ~Protocol_var (void);
++    Protocol_var (const Protocol_var &); // copy constructor
++    ~Protocol_var (void); // destructor
+     
+     Protocol_var &operator= (Protocol *);
+     Protocol_var &operator= (const Protocol_var &);
+@@ -750,8 +733,7 @@
+     operator const Protocol &() const;
+     operator Protocol &();
+     operator Protocol &() const;
+-    // Variable-size types only.
+-    operator Protocol *&();
++    operator Protocol *&(); // variable-size types only
+     
+     // in, inout, out, _retn 
+     const Protocol &in (void) const;
+@@ -778,7 +760,7 @@
+     
+   private:
+     Protocol *&ptr_;
+-    // Assignment from T_var not allowed.
++    // assignment from T_var not allowed
+     void operator= (const Protocol_var &);
+   };
+   
+@@ -788,46 +770,36 @@
+ #if !defined (__TAO_UNBOUNDED_SEQUENCE_RTCORBA_PROTOCOLLIST_CH_)
+ #define __TAO_UNBOUNDED_SEQUENCE_RTCORBA_PROTOCOLLIST_CH_
+   
+-  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_RTCORBA_ProtocolList
+-    : public TAO_Unbounded_Base_Sequence
++    class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_RTCORBA_ProtocolList : public TAO_Unbounded_Base_Sequence
+   {
+   public:
+     // = Initialization and termination methods.
+-    _TAO_Unbounded_Sequence_RTCORBA_ProtocolList (void);
++
++      _TAO_Unbounded_Sequence_RTCORBA_ProtocolList (void); // Default constructor.
+     _TAO_Unbounded_Sequence_RTCORBA_ProtocolList (CORBA::ULong maximum); 
+-    _TAO_Unbounded_Sequence_RTCORBA_ProtocolList (
+-        CORBA::ULong maximum,
++      _TAO_Unbounded_Sequence_RTCORBA_ProtocolList (CORBA::ULong maximum,
+         CORBA::ULong length,
+         Protocol *data,
+-        CORBA::Boolean release = 0
+-      );
+-    _TAO_Unbounded_Sequence_RTCORBA_ProtocolList (
+-        const _TAO_Unbounded_Sequence_RTCORBA_ProtocolList &rhs
+-      );
+-    _TAO_Unbounded_Sequence_RTCORBA_ProtocolList &operator= (
+-        const _TAO_Unbounded_Sequence_RTCORBA_ProtocolList &rhs
+-      );
+-    virtual ~_TAO_Unbounded_Sequence_RTCORBA_ProtocolList (void);
+-    
++        CORBA::Boolean release = 0);
++      _TAO_Unbounded_Sequence_RTCORBA_ProtocolList (const _TAO_Unbounded_Sequence_RTCORBA_ProtocolList &rhs);
++      _TAO_Unbounded_Sequence_RTCORBA_ProtocolList &operator= (const _TAO_Unbounded_Sequence_RTCORBA_ProtocolList &rhs);
++      virtual ~_TAO_Unbounded_Sequence_RTCORBA_ProtocolList (void); // Dtor.
+     // = Accessors.
+     Protocol &operator[] (CORBA::ULong i);
+     const Protocol &operator[] (CORBA::ULong i) const;
+-    
+     // = Static operations.
+     static Protocol *allocbuf (CORBA::ULong size);
+     static void freebuf (Protocol *buffer);
+-    
+-    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+     virtual void _allocate_buffer (CORBA::ULong length);
+     virtual void _deallocate_buffer (void);
++      // Implement the TAO_Base_Sequence methods (see Sequence.h)
++
+     Protocol *get_buffer (CORBA::Boolean orphan = 0);
+     const Protocol *get_buffer (void) const;
+-    void replace (
+-        CORBA::ULong max,
++      void replace (CORBA::ULong max,
+         CORBA::ULong length,
+         Protocol *data,
+-        CORBA::Boolean release
+-      );
++        CORBA::Boolean release);
+   };
+   
+ #endif /* end #if !defined */
+@@ -869,7 +841,6 @@
+     typedef ProtocolList_var _var_type;
+ #endif /* ! __GNUC__ || g++ >= 2.8 */
+     
+-    
+   };
+   
+ #endif /* end #if !defined */
+@@ -885,10 +856,10 @@
+   class TAO_RTCORBA_Export ProtocolList_var
+   {
+   public:
+-    ProtocolList_var (void);
++    ProtocolList_var (void); // default constructor
+     ProtocolList_var (ProtocolList *);
+-    ProtocolList_var (const ProtocolList_var &);
+-    ~ProtocolList_var (void);
++    ProtocolList_var (const ProtocolList_var &); // copy constructor
++    ~ProtocolList_var (void); // destructor
+     
+     ProtocolList_var &operator= (ProtocolList *);
+     ProtocolList_var &operator= (const ProtocolList_var &);
+@@ -936,7 +907,7 @@
+   
+   private:
+     ProtocolList *&ptr_;
+-    // Assignment from T_var not allowed.
++    // assignment from T_var not allowed
+     void operator= (const ProtocolList_var &);
+   };
+   
+@@ -984,10 +955,7 @@
+     static ServerProtocolPolicy_ptr duplicate (ServerProtocolPolicy_ptr);
+     static void release (ServerProtocolPolicy_ptr);
+     static ServerProtocolPolicy_ptr nil (void);
+-    static ServerProtocolPolicy_ptr narrow (
+-        CORBA::Object *,
+-        CORBA::Environment &
+-      );
++    static ServerProtocolPolicy_ptr narrow (CORBA::Object *, CORBA::Environment &);
+     static CORBA::Object * upcast (void *);
+   
+   private:
+@@ -1028,8 +996,7 @@
+ #if !defined (_RTCORBA_SERVERPROTOCOLPOLICY_CH_)
+ #define _RTCORBA_SERVERPROTOCOLPOLICY_CH_
+   
+-  class TAO_RTCORBA_Export ServerProtocolPolicy
+-    : public virtual CORBA::Policy
++class TAO_RTCORBA_Export ServerProtocolPolicy: public virtual CORBA::Policy
+   {
+   public:
+   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+@@ -1039,19 +1006,16 @@
+ 
+     // the static operations
+     static ServerProtocolPolicy_ptr _duplicate (ServerProtocolPolicy_ptr obj);
+-    
+     static ServerProtocolPolicy_ptr _narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static ServerProtocolPolicy_ptr _unchecked_narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static ServerProtocolPolicy_ptr _nil (void)
+       {
+         return (ServerProtocolPolicy_ptr)0;
+@@ -1073,7 +1037,6 @@
+     ServerProtocolPolicy ();
+     
+     virtual ~ServerProtocolPolicy (void);
+-  
+   private:
+     ServerProtocolPolicy (const ServerProtocolPolicy &);
+     void operator= (const ServerProtocolPolicy &);
+@@ -1123,10 +1086,7 @@
+     static ClientProtocolPolicy_ptr duplicate (ClientProtocolPolicy_ptr);
+     static void release (ClientProtocolPolicy_ptr);
+     static ClientProtocolPolicy_ptr nil (void);
+-    static ClientProtocolPolicy_ptr narrow (
+-        CORBA::Object *,
+-        CORBA::Environment &
+-      );
++    static ClientProtocolPolicy_ptr narrow (CORBA::Object *, CORBA::Environment &);
+     static CORBA::Object * upcast (void *);
+   
+   private:
+@@ -1167,8 +1127,7 @@
+ #if !defined (_RTCORBA_CLIENTPROTOCOLPOLICY_CH_)
+ #define _RTCORBA_CLIENTPROTOCOLPOLICY_CH_
+   
+-  class TAO_RTCORBA_Export ClientProtocolPolicy
+-    : public virtual CORBA::Policy
++class TAO_RTCORBA_Export ClientProtocolPolicy: public virtual CORBA::Policy
+   {
+   public:
+   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+@@ -1178,19 +1137,16 @@
+ 
+     // the static operations
+     static ClientProtocolPolicy_ptr _duplicate (ClientProtocolPolicy_ptr obj);
+-    
+     static ClientProtocolPolicy_ptr _narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static ClientProtocolPolicy_ptr _unchecked_narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static ClientProtocolPolicy_ptr _nil (void)
+       {
+         return (ClientProtocolPolicy_ptr)0;
+@@ -1212,7 +1168,6 @@
+     ClientProtocolPolicy ();
+     
+     virtual ~ClientProtocolPolicy (void);
+-  
+   private:
+     ClientProtocolPolicy (const ClientProtocolPolicy &);
+     void operator= (const ClientProtocolPolicy &);
+@@ -1262,10 +1217,7 @@
+     static PrivateConnectionPolicy_ptr duplicate (PrivateConnectionPolicy_ptr);
+     static void release (PrivateConnectionPolicy_ptr);
+     static PrivateConnectionPolicy_ptr nil (void);
+-    static PrivateConnectionPolicy_ptr narrow (
+-        CORBA::Object *,
+-        CORBA::Environment &
+-      );
++    static PrivateConnectionPolicy_ptr narrow (CORBA::Object *, CORBA::Environment &);
+     static CORBA::Object * upcast (void *);
+   
+   private:
+@@ -1306,8 +1258,7 @@
+ #if !defined (_RTCORBA_PRIVATECONNECTIONPOLICY_CH_)
+ #define _RTCORBA_PRIVATECONNECTIONPOLICY_CH_
+   
+-  class TAO_RTCORBA_Export PrivateConnectionPolicy
+-    : public virtual CORBA::Policy
++class TAO_RTCORBA_Export PrivateConnectionPolicy: public virtual CORBA::Policy
+   {
+   public:
+   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+@@ -1317,19 +1268,16 @@
+ 
+     // the static operations
+     static PrivateConnectionPolicy_ptr _duplicate (PrivateConnectionPolicy_ptr obj);
+-    
+     static PrivateConnectionPolicy_ptr _narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static PrivateConnectionPolicy_ptr _unchecked_narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static PrivateConnectionPolicy_ptr _nil (void)
+       {
+         return (PrivateConnectionPolicy_ptr)0;
+@@ -1343,7 +1291,6 @@
+     PrivateConnectionPolicy ();
+     
+     virtual ~PrivateConnectionPolicy (void);
+-  
+   private:
+     PrivateConnectionPolicy (const PrivateConnectionPolicy &);
+     void operator= (const PrivateConnectionPolicy &);
+@@ -1391,10 +1338,7 @@
+     static TCPProtocolProperties_ptr duplicate (TCPProtocolProperties_ptr);
+     static void release (TCPProtocolProperties_ptr);
+     static TCPProtocolProperties_ptr nil (void);
+-    static TCPProtocolProperties_ptr narrow (
+-        CORBA::Object *,
+-        CORBA::Environment &
+-      );
++    static TCPProtocolProperties_ptr narrow (CORBA::Object *, CORBA::Environment &);
+     static CORBA::Object * upcast (void *);
+   
+   private:
+@@ -1435,8 +1379,7 @@
+ #if !defined (_RTCORBA_TCPPROTOCOLPROPERTIES_CH_)
+ #define _RTCORBA_TCPPROTOCOLPROPERTIES_CH_
+   
+-  class TAO_RTCORBA_Export TCPProtocolProperties
+-    : public virtual ProtocolProperties
++class TAO_RTCORBA_Export TCPProtocolProperties: public virtual ProtocolProperties
+   {
+   public:
+   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+@@ -1446,19 +1389,16 @@
+ 
+     // the static operations
+     static TCPProtocolProperties_ptr _duplicate (TCPProtocolProperties_ptr obj);
+-    
+     static TCPProtocolProperties_ptr _narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static TCPProtocolProperties_ptr _unchecked_narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static TCPProtocolProperties_ptr _nil (void)
+       {
+         return (TCPProtocolProperties_ptr)0;
+@@ -1557,7 +1497,6 @@
+     TCPProtocolProperties ();
+     
+     virtual ~TCPProtocolProperties (void);
+-  
+   private:
+     TCPProtocolProperties (const TCPProtocolProperties &);
+     void operator= (const TCPProtocolProperties &);
+@@ -1605,10 +1544,7 @@
+     static GIOPProtocolProperties_ptr duplicate (GIOPProtocolProperties_ptr);
+     static void release (GIOPProtocolProperties_ptr);
+     static GIOPProtocolProperties_ptr nil (void);
+-    static GIOPProtocolProperties_ptr narrow (
+-        CORBA::Object *,
+-        CORBA::Environment &
+-      );
++    static GIOPProtocolProperties_ptr narrow (CORBA::Object *, CORBA::Environment &);
+     static CORBA::Object * upcast (void *);
+   
+   private:
+@@ -1649,8 +1585,7 @@
+ #if !defined (_RTCORBA_GIOPPROTOCOLPROPERTIES_CH_)
+ #define _RTCORBA_GIOPPROTOCOLPROPERTIES_CH_
+   
+-  class TAO_RTCORBA_Export GIOPProtocolProperties
+-    : public virtual ProtocolProperties
++class TAO_RTCORBA_Export GIOPProtocolProperties: public virtual ProtocolProperties
+   {
+   public:
+   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+@@ -1660,19 +1595,16 @@
+ 
+     // the static operations
+     static GIOPProtocolProperties_ptr _duplicate (GIOPProtocolProperties_ptr obj);
+-    
+     static GIOPProtocolProperties_ptr _narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static GIOPProtocolProperties_ptr _unchecked_narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static GIOPProtocolProperties_ptr _nil (void)
+       {
+         return (GIOPProtocolProperties_ptr)0;
+@@ -1686,7 +1618,6 @@
+     GIOPProtocolProperties ();
+     
+     virtual ~GIOPProtocolProperties (void);
+-  
+   private:
+     GIOPProtocolProperties (const GIOPProtocolProperties &);
+     void operator= (const GIOPProtocolProperties &);
+@@ -1734,10 +1665,7 @@
+     static UnixDomainProtocolProperties_ptr duplicate (UnixDomainProtocolProperties_ptr);
+     static void release (UnixDomainProtocolProperties_ptr);
+     static UnixDomainProtocolProperties_ptr nil (void);
+-    static UnixDomainProtocolProperties_ptr narrow (
+-        CORBA::Object *,
+-        CORBA::Environment &
+-      );
++    static UnixDomainProtocolProperties_ptr narrow (CORBA::Object *, CORBA::Environment &);
+     static CORBA::Object * upcast (void *);
+   
+   private:
+@@ -1778,8 +1706,7 @@
+ #if !defined (_RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES_CH_)
+ #define _RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES_CH_
+   
+-  class TAO_RTCORBA_Export UnixDomainProtocolProperties
+-    : public virtual ProtocolProperties
++class TAO_RTCORBA_Export UnixDomainProtocolProperties: public virtual ProtocolProperties
+   {
+   public:
+   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+@@ -1789,19 +1716,16 @@
+ 
+     // the static operations
+     static UnixDomainProtocolProperties_ptr _duplicate (UnixDomainProtocolProperties_ptr obj);
+-    
+     static UnixDomainProtocolProperties_ptr _narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static UnixDomainProtocolProperties_ptr _unchecked_narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static UnixDomainProtocolProperties_ptr _nil (void)
+       {
+         return (UnixDomainProtocolProperties_ptr)0;
+@@ -1849,7 +1773,6 @@
+     UnixDomainProtocolProperties ();
+     
+     virtual ~UnixDomainProtocolProperties (void);
+-  
+   private:
+     UnixDomainProtocolProperties (const UnixDomainProtocolProperties &);
+     void operator= (const UnixDomainProtocolProperties &);
+@@ -1897,10 +1820,7 @@
+     static SharedMemoryProtocolProperties_ptr duplicate (SharedMemoryProtocolProperties_ptr);
+     static void release (SharedMemoryProtocolProperties_ptr);
+     static SharedMemoryProtocolProperties_ptr nil (void);
+-    static SharedMemoryProtocolProperties_ptr narrow (
+-        CORBA::Object *,
+-        CORBA::Environment &
+-      );
++    static SharedMemoryProtocolProperties_ptr narrow (CORBA::Object *, CORBA::Environment &);
+     static CORBA::Object * upcast (void *);
+   
+   private:
+@@ -1941,8 +1861,7 @@
+ #if !defined (_RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES_CH_)
+ #define _RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES_CH_
+   
+-  class TAO_RTCORBA_Export SharedMemoryProtocolProperties
+-    : public virtual ProtocolProperties
++class TAO_RTCORBA_Export SharedMemoryProtocolProperties: public virtual ProtocolProperties
+   {
+   public:
+   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+@@ -1952,19 +1871,16 @@
+ 
+     // the static operations
+     static SharedMemoryProtocolProperties_ptr _duplicate (SharedMemoryProtocolProperties_ptr obj);
+-    
+     static SharedMemoryProtocolProperties_ptr _narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static SharedMemoryProtocolProperties_ptr _unchecked_narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static SharedMemoryProtocolProperties_ptr _nil (void)
+       {
+         return (SharedMemoryProtocolProperties_ptr)0;
+@@ -2029,7 +1945,6 @@
+     SharedMemoryProtocolProperties ();
+     
+     virtual ~SharedMemoryProtocolProperties (void);
+-  
+   private:
+     SharedMemoryProtocolProperties (const SharedMemoryProtocolProperties &);
+     void operator= (const SharedMemoryProtocolProperties &);
+@@ -2052,23 +1967,20 @@
+     
+     ACE_NESTED_CLASS (RTCORBA, Priority) low;
+     ACE_NESTED_CLASS (RTCORBA, Priority) high;
+-    
+   };
+   
+   class TAO_RTCORBA_Export PriorityBand_var
+   {
+   public:
+-    PriorityBand_var (void);
++    PriorityBand_var (void); // default constructor
+     PriorityBand_var (PriorityBand *);
+-    PriorityBand_var (const PriorityBand_var &);
+-    // Fixed-size types only.
+-    PriorityBand_var (const PriorityBand &);
+-    ~PriorityBand_var (void);
++    PriorityBand_var (const PriorityBand_var &); // copy constructor
++    PriorityBand_var (const PriorityBand &); // fixed-size types only
++    ~PriorityBand_var (void); // destructor
+     
+     PriorityBand_var &operator= (PriorityBand *);
+     PriorityBand_var &operator= (const PriorityBand_var &);
+-    // Fixed-size types only.
+-    PriorityBand_var &operator= (const PriorityBand &);
++    PriorityBand_var &operator= (const PriorityBand &); // fixed-size types only
+     PriorityBand *operator-> (void);
+     const PriorityBand *operator-> (void) const;
+     
+@@ -2097,46 +2009,36 @@
+ #if !defined (__TAO_UNBOUNDED_SEQUENCE_RTCORBA_PRIORITYBANDS_CH_)
+ #define __TAO_UNBOUNDED_SEQUENCE_RTCORBA_PRIORITYBANDS_CH_
+   
+-  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_RTCORBA_PriorityBands
+-    : public TAO_Unbounded_Base_Sequence
++    class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_RTCORBA_PriorityBands : public TAO_Unbounded_Base_Sequence
+   {
+   public:
+     // = Initialization and termination methods.
+-    _TAO_Unbounded_Sequence_RTCORBA_PriorityBands (void);
++
++      _TAO_Unbounded_Sequence_RTCORBA_PriorityBands (void); // Default constructor.
+     _TAO_Unbounded_Sequence_RTCORBA_PriorityBands (CORBA::ULong maximum); 
+-    _TAO_Unbounded_Sequence_RTCORBA_PriorityBands (
+-        CORBA::ULong maximum,
++      _TAO_Unbounded_Sequence_RTCORBA_PriorityBands (CORBA::ULong maximum,
+         CORBA::ULong length,
+         PriorityBand *data,
+-        CORBA::Boolean release = 0
+-      );
+-    _TAO_Unbounded_Sequence_RTCORBA_PriorityBands (
+-        const _TAO_Unbounded_Sequence_RTCORBA_PriorityBands &rhs
+-      );
+-    _TAO_Unbounded_Sequence_RTCORBA_PriorityBands &operator= (
+-        const _TAO_Unbounded_Sequence_RTCORBA_PriorityBands &rhs
+-      );
+-    virtual ~_TAO_Unbounded_Sequence_RTCORBA_PriorityBands (void);
+-    
++        CORBA::Boolean release = 0);
++      _TAO_Unbounded_Sequence_RTCORBA_PriorityBands (const _TAO_Unbounded_Sequence_RTCORBA_PriorityBands &rhs);
++      _TAO_Unbounded_Sequence_RTCORBA_PriorityBands &operator= (const _TAO_Unbounded_Sequence_RTCORBA_PriorityBands &rhs);
++      virtual ~_TAO_Unbounded_Sequence_RTCORBA_PriorityBands (void); // Dtor.
+     // = Accessors.
+     PriorityBand &operator[] (CORBA::ULong i);
+     const PriorityBand &operator[] (CORBA::ULong i) const;
+-    
+     // = Static operations.
+     static PriorityBand *allocbuf (CORBA::ULong size);
+     static void freebuf (PriorityBand *buffer);
+-    
+-    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+     virtual void _allocate_buffer (CORBA::ULong length);
+     virtual void _deallocate_buffer (void);
++      // Implement the TAO_Base_Sequence methods (see Sequence.h)
++
+     PriorityBand *get_buffer (CORBA::Boolean orphan = 0);
+     const PriorityBand *get_buffer (void) const;
+-    void replace (
+-        CORBA::ULong max,
++      void replace (CORBA::ULong max,
+         CORBA::ULong length,
+         PriorityBand *data,
+-        CORBA::Boolean release
+-      );
++        CORBA::Boolean release);
+   };
+   
+ #endif /* end #if !defined */
+@@ -2178,7 +2080,6 @@
+     typedef PriorityBands_var _var_type;
+ #endif /* ! __GNUC__ || g++ >= 2.8 */
+     
+-    
+   };
+   
+ #endif /* end #if !defined */
+@@ -2194,17 +2095,15 @@
+   class TAO_RTCORBA_Export PriorityBands_var
+   {
+   public:
+-    PriorityBands_var (void);
++    PriorityBands_var (void); // default constructor
+     PriorityBands_var (PriorityBands *);
+-    PriorityBands_var (const PriorityBands_var &);
+-    // Fixed-size base types only.
+-    PriorityBands_var (const PriorityBands &);
+-    ~PriorityBands_var (void);
++    PriorityBands_var (const PriorityBands_var &); // copy constructor
++    PriorityBands_var (const PriorityBands &); // fixed-size base types only
++    ~PriorityBands_var (void); // destructor
+     
+     PriorityBands_var &operator= (PriorityBands *);
+     PriorityBands_var &operator= (const PriorityBands_var &);
+-    // Fixed-size base types only.
+-    PriorityBands_var &operator= (const PriorityBands &);
++    PriorityBands_var &operator= (const PriorityBands &); // fixed-size base types only
+     PriorityBands *operator-> (void);
+     const PriorityBands *operator-> (void) const;
+     
+@@ -2248,7 +2147,7 @@
+   
+   private:
+     PriorityBands *&ptr_;
+-    // Assignment from T_var not allowed.
++    // assignment from T_var not allowed
+     void operator= (const PriorityBands_var &);
+   };
+   
+@@ -2298,10 +2197,7 @@
+     static PriorityBandedConnectionPolicy_ptr duplicate (PriorityBandedConnectionPolicy_ptr);
+     static void release (PriorityBandedConnectionPolicy_ptr);
+     static PriorityBandedConnectionPolicy_ptr nil (void);
+-    static PriorityBandedConnectionPolicy_ptr narrow (
+-        CORBA::Object *,
+-        CORBA::Environment &
+-      );
++    static PriorityBandedConnectionPolicy_ptr narrow (CORBA::Object *, CORBA::Environment &);
+     static CORBA::Object * upcast (void *);
+   
+   private:
+@@ -2342,8 +2238,7 @@
+ #if !defined (_RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY_CH_)
+ #define _RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY_CH_
+   
+-  class TAO_RTCORBA_Export PriorityBandedConnectionPolicy
+-    : public virtual CORBA::Policy
++class TAO_RTCORBA_Export PriorityBandedConnectionPolicy: public virtual CORBA::Policy
+   {
+   public:
+   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+@@ -2353,19 +2248,16 @@
+ 
+     // the static operations
+     static PriorityBandedConnectionPolicy_ptr _duplicate (PriorityBandedConnectionPolicy_ptr obj);
+-    
+     static PriorityBandedConnectionPolicy_ptr _narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static PriorityBandedConnectionPolicy_ptr _unchecked_narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static PriorityBandedConnectionPolicy_ptr _nil (void)
+       {
+         return (PriorityBandedConnectionPolicy_ptr)0;
+@@ -2387,7 +2279,6 @@
+     PriorityBandedConnectionPolicy ();
+     
+     virtual ~PriorityBandedConnectionPolicy (void);
+-  
+   private:
+     PriorityBandedConnectionPolicy (const PriorityBandedConnectionPolicy &);
+     void operator= (const PriorityBandedConnectionPolicy &);
+@@ -2435,10 +2326,7 @@
+     static Current_ptr duplicate (Current_ptr);
+     static void release (Current_ptr);
+     static Current_ptr nil (void);
+-    static Current_ptr narrow (
+-        CORBA::Object *,
+-        CORBA::Environment &
+-      );
++    static Current_ptr narrow (CORBA::Object *, CORBA::Environment &);
+     static CORBA::Object * upcast (void *);
+   
+   private:
+@@ -2479,8 +2367,7 @@
+ #if !defined (_RTCORBA_CURRENT_CH_)
+ #define _RTCORBA_CURRENT_CH_
+   
+-  class TAO_RTCORBA_Export Current
+-    : public virtual CORBA::Current
++class TAO_RTCORBA_Export Current: public virtual CORBA::Current
+   {
+   public:
+   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+@@ -2490,19 +2377,16 @@
+ 
+     // the static operations
+     static Current_ptr _duplicate (Current_ptr obj);
+-    
+     static Current_ptr _narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static Current_ptr _unchecked_narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static Current_ptr _nil (void)
+       {
+         return (Current_ptr)0;
+@@ -2533,7 +2417,6 @@
+     Current ();
+     
+     virtual ~Current (void);
+-  
+   private:
+     Current (const Current &);
+     void operator= (const Current &);
+@@ -2581,10 +2464,7 @@
+     static Mutex_ptr duplicate (Mutex_ptr);
+     static void release (Mutex_ptr);
+     static Mutex_ptr nil (void);
+-    static Mutex_ptr narrow (
+-        CORBA::Object *,
+-        CORBA::Environment &
+-      );
++    static Mutex_ptr narrow (CORBA::Object *, CORBA::Environment &);
+     static CORBA::Object * upcast (void *);
+   
+   private:
+@@ -2625,8 +2505,7 @@
+ #if !defined (_RTCORBA_MUTEX_CH_)
+ #define _RTCORBA_MUTEX_CH_
+   
+-  class TAO_RTCORBA_Export Mutex
+-    : public virtual CORBA_Object
++class TAO_RTCORBA_Export Mutex : public virtual CORBA_Object
+   {
+   public:
+   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+@@ -2636,19 +2515,16 @@
+ 
+     // the static operations
+     static Mutex_ptr _duplicate (Mutex_ptr obj);
+-    
+     static Mutex_ptr _narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static Mutex_ptr _unchecked_narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static Mutex_ptr _nil (void)
+       {
+         return (Mutex_ptr)0;
+@@ -2687,7 +2563,6 @@
+     Mutex ();
+     
+     virtual ~Mutex (void);
+-  
+   private:
+     Mutex (const Mutex &);
+     void operator= (const Mutex &);
+@@ -2735,10 +2610,7 @@
+     static RTORB_ptr duplicate (RTORB_ptr);
+     static void release (RTORB_ptr);
+     static RTORB_ptr nil (void);
+-    static RTORB_ptr narrow (
+-        CORBA::Object *,
+-        CORBA::Environment &
+-      );
++    static RTORB_ptr narrow (CORBA::Object *, CORBA::Environment &);
+     static CORBA::Object * upcast (void *);
+   
+   private:
+@@ -2779,8 +2651,7 @@
+ #if !defined (_RTCORBA_RTORB_CH_)
+ #define _RTCORBA_RTORB_CH_
+   
+-  class TAO_RTCORBA_Export RTORB
+-    : public virtual CORBA_Object
++class TAO_RTCORBA_Export RTORB : public virtual CORBA_Object
+   {
+   public:
+   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+@@ -2790,19 +2661,16 @@
+ 
+     // the static operations
+     static RTORB_ptr _duplicate (RTORB_ptr obj);
+-    
+     static RTORB_ptr _narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static RTORB_ptr _unchecked_narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static RTORB_ptr _nil (void)
+       {
+         return (RTORB_ptr)0;
+@@ -2930,7 +2798,7 @@
+           CORBA::Environment &
+         );
+       
+-      static InvalidThreadpool *_downcast (CORBA::Exception *);
++      static InvalidThreadpool *_narrow (CORBA::Exception *);
+ 
+ 
+       // = TAO extension.
+@@ -3041,7 +2909,6 @@
+     RTORB ();
+     
+     virtual ~RTORB (void);
+-  
+   private:
+     RTORB (const RTORB &);
+     void operator= (const RTORB &);
diff --git a/TAO/tao/RTCORBA/diffs/RTCORBAC.i.diff b/TAO/tao/RTCORBA/diffs/RTCORBAC.i.diff
new file mode 100644
index 00000000000..dfc6a105dda
--- /dev/null
+++ b/TAO/tao/RTCORBA/diffs/RTCORBAC.i.diff
@@ -0,0 +1,715 @@
+--- orig/RTCORBAC.i	Tue Jun 12 17:56:16 2001
++++ RTCORBAC.i	Tue Jun 12 16:14:06 2001
+@@ -1,6 +1,6 @@
+ // -*- C++ -*-
+ //
+-// $Id$
++// $Id$
+ 
+ // ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+ // TAO and the TAO IDL Compiler have been developed by:
+@@ -574,6 +574,49 @@
+ #if !defined (_RTCORBA_PRIORITYMODELPOLICY___CI_)
+ #define _RTCORBA_PRIORITYMODELPOLICY___CI_
+ 
++ACE_INLINE RTCORBA::PriorityModelPolicy_ptr
++tao_RTCORBA_PriorityModelPolicy_duplicate (
++    RTCORBA::PriorityModelPolicy_ptr p
++  )
++{
++  return RTCORBA::PriorityModelPolicy::_duplicate (p);
++}
++
++ACE_INLINE void
++tao_RTCORBA_PriorityModelPolicy_release (
++    RTCORBA::PriorityModelPolicy_ptr p
++  )
++{
++  CORBA::release (p);
++}
++
++ACE_INLINE RTCORBA::PriorityModelPolicy_ptr
++tao_RTCORBA_PriorityModelPolicy_nil (
++    void
++  )
++{
++  return RTCORBA::PriorityModelPolicy::_nil ();
++}
++
++ACE_INLINE RTCORBA::PriorityModelPolicy_ptr
++tao_RTCORBA_PriorityModelPolicy_narrow (
++    CORBA::Object *p,
++    CORBA::Environment &ACE_TRY_ENV
++  )
++{
++  return RTCORBA::PriorityModelPolicy::_narrow (p, ACE_TRY_ENV);
++}
++
++ACE_INLINE CORBA::Object *
++tao_RTCORBA_PriorityModelPolicy_upcast (
++    void *src
++  )
++{
++  RTCORBA::PriorityModelPolicy **tmp =
++    ACE_static_cast (RTCORBA::PriorityModelPolicy **, src);
++  return *tmp;
++}
++
+ 
+ #endif /* end #if !defined */
+ 
+@@ -581,6 +624,49 @@
+ #if !defined (_RTCORBA_THREADPOOLPOLICY___CI_)
+ #define _RTCORBA_THREADPOOLPOLICY___CI_
+ 
++ACE_INLINE RTCORBA::ThreadpoolPolicy_ptr
++tao_RTCORBA_ThreadpoolPolicy_duplicate (
++    RTCORBA::ThreadpoolPolicy_ptr p
++  )
++{
++  return RTCORBA::ThreadpoolPolicy::_duplicate (p);
++}
++
++ACE_INLINE void
++tao_RTCORBA_ThreadpoolPolicy_release (
++    RTCORBA::ThreadpoolPolicy_ptr p
++  )
++{
++  CORBA::release (p);
++}
++
++ACE_INLINE RTCORBA::ThreadpoolPolicy_ptr
++tao_RTCORBA_ThreadpoolPolicy_nil (
++    void
++  )
++{
++  return RTCORBA::ThreadpoolPolicy::_nil ();
++}
++
++ACE_INLINE RTCORBA::ThreadpoolPolicy_ptr
++tao_RTCORBA_ThreadpoolPolicy_narrow (
++    CORBA::Object *p,
++    CORBA::Environment &ACE_TRY_ENV
++  )
++{
++  return RTCORBA::ThreadpoolPolicy::_narrow (p, ACE_TRY_ENV);
++}
++
++ACE_INLINE CORBA::Object *
++tao_RTCORBA_ThreadpoolPolicy_upcast (
++    void *src
++  )
++{
++  RTCORBA::ThreadpoolPolicy **tmp =
++    ACE_static_cast (RTCORBA::ThreadpoolPolicy **, src);
++  return *tmp;
++}
++
+ 
+ #endif /* end #if !defined */
+ 
+@@ -588,6 +674,49 @@
+ #if !defined (_RTCORBA_PROTOCOLPROPERTIES___CI_)
+ #define _RTCORBA_PROTOCOLPROPERTIES___CI_
+ 
++ACE_INLINE RTCORBA::ProtocolProperties_ptr
++tao_RTCORBA_ProtocolProperties_duplicate (
++    RTCORBA::ProtocolProperties_ptr p
++  )
++{
++  return RTCORBA::ProtocolProperties::_duplicate (p);
++}
++
++ACE_INLINE void
++tao_RTCORBA_ProtocolProperties_release (
++    RTCORBA::ProtocolProperties_ptr p
++  )
++{
++  CORBA::release (p);
++}
++
++ACE_INLINE RTCORBA::ProtocolProperties_ptr
++tao_RTCORBA_ProtocolProperties_nil (
++    void
++  )
++{
++  return RTCORBA::ProtocolProperties::_nil ();
++}
++
++ACE_INLINE RTCORBA::ProtocolProperties_ptr
++tao_RTCORBA_ProtocolProperties_narrow (
++    CORBA::Object *p,
++    CORBA::Environment &ACE_TRY_ENV
++  )
++{
++  return RTCORBA::ProtocolProperties::_narrow (p, ACE_TRY_ENV);
++}
++
++ACE_INLINE CORBA::Object *
++tao_RTCORBA_ProtocolProperties_upcast (
++    void *src
++  )
++{
++  RTCORBA::ProtocolProperties **tmp =
++    ACE_static_cast (RTCORBA::ProtocolProperties **, src);
++  return *tmp;
++}
++
+ 
+ #endif /* end #if !defined */
+ 
+@@ -1182,6 +1311,49 @@
+ #if !defined (_RTCORBA_SERVERPROTOCOLPOLICY___CI_)
+ #define _RTCORBA_SERVERPROTOCOLPOLICY___CI_
+ 
++ACE_INLINE RTCORBA::ServerProtocolPolicy_ptr
++tao_RTCORBA_ServerProtocolPolicy_duplicate (
++    RTCORBA::ServerProtocolPolicy_ptr p
++  )
++{
++  return RTCORBA::ServerProtocolPolicy::_duplicate (p);
++}
++
++ACE_INLINE void
++tao_RTCORBA_ServerProtocolPolicy_release (
++    RTCORBA::ServerProtocolPolicy_ptr p
++  )
++{
++  CORBA::release (p);
++}
++
++ACE_INLINE RTCORBA::ServerProtocolPolicy_ptr
++tao_RTCORBA_ServerProtocolPolicy_nil (
++    void
++  )
++{
++  return RTCORBA::ServerProtocolPolicy::_nil ();
++}
++
++ACE_INLINE RTCORBA::ServerProtocolPolicy_ptr
++tao_RTCORBA_ServerProtocolPolicy_narrow (
++    CORBA::Object *p,
++    CORBA::Environment &ACE_TRY_ENV
++  )
++{
++  return RTCORBA::ServerProtocolPolicy::_narrow (p, ACE_TRY_ENV);
++}
++
++ACE_INLINE CORBA::Object *
++tao_RTCORBA_ServerProtocolPolicy_upcast (
++    void *src
++  )
++{
++  RTCORBA::ServerProtocolPolicy **tmp =
++    ACE_static_cast (RTCORBA::ServerProtocolPolicy **, src);
++  return *tmp;
++}
++
+ 
+ #endif /* end #if !defined */
+ 
+@@ -1189,6 +1361,49 @@
+ #if !defined (_RTCORBA_CLIENTPROTOCOLPOLICY___CI_)
+ #define _RTCORBA_CLIENTPROTOCOLPOLICY___CI_
+ 
++ACE_INLINE RTCORBA::ClientProtocolPolicy_ptr
++tao_RTCORBA_ClientProtocolPolicy_duplicate (
++    RTCORBA::ClientProtocolPolicy_ptr p
++  )
++{
++  return RTCORBA::ClientProtocolPolicy::_duplicate (p);
++}
++
++ACE_INLINE void
++tao_RTCORBA_ClientProtocolPolicy_release (
++    RTCORBA::ClientProtocolPolicy_ptr p
++  )
++{
++  CORBA::release (p);
++}
++
++ACE_INLINE RTCORBA::ClientProtocolPolicy_ptr
++tao_RTCORBA_ClientProtocolPolicy_nil (
++    void
++  )
++{
++  return RTCORBA::ClientProtocolPolicy::_nil ();
++}
++
++ACE_INLINE RTCORBA::ClientProtocolPolicy_ptr
++tao_RTCORBA_ClientProtocolPolicy_narrow (
++    CORBA::Object *p,
++    CORBA::Environment &ACE_TRY_ENV
++  )
++{
++  return RTCORBA::ClientProtocolPolicy::_narrow (p, ACE_TRY_ENV);
++}
++
++ACE_INLINE CORBA::Object *
++tao_RTCORBA_ClientProtocolPolicy_upcast (
++    void *src
++  )
++{
++  RTCORBA::ClientProtocolPolicy **tmp =
++    ACE_static_cast (RTCORBA::ClientProtocolPolicy **, src);
++  return *tmp;
++}
++
+ 
+ #endif /* end #if !defined */
+ 
+@@ -1196,6 +1411,49 @@
+ #if !defined (_RTCORBA_PRIVATECONNECTIONPOLICY___CI_)
+ #define _RTCORBA_PRIVATECONNECTIONPOLICY___CI_
+ 
++ACE_INLINE RTCORBA::PrivateConnectionPolicy_ptr
++tao_RTCORBA_PrivateConnectionPolicy_duplicate (
++    RTCORBA::PrivateConnectionPolicy_ptr p
++  )
++{
++  return RTCORBA::PrivateConnectionPolicy::_duplicate (p);
++}
++
++ACE_INLINE void
++tao_RTCORBA_PrivateConnectionPolicy_release (
++    RTCORBA::PrivateConnectionPolicy_ptr p
++  )
++{
++  CORBA::release (p);
++}
++
++ACE_INLINE RTCORBA::PrivateConnectionPolicy_ptr
++tao_RTCORBA_PrivateConnectionPolicy_nil (
++    void
++  )
++{
++  return RTCORBA::PrivateConnectionPolicy::_nil ();
++}
++
++ACE_INLINE RTCORBA::PrivateConnectionPolicy_ptr
++tao_RTCORBA_PrivateConnectionPolicy_narrow (
++    CORBA::Object *p,
++    CORBA::Environment &ACE_TRY_ENV
++  )
++{
++  return RTCORBA::PrivateConnectionPolicy::_narrow (p, ACE_TRY_ENV);
++}
++
++ACE_INLINE CORBA::Object *
++tao_RTCORBA_PrivateConnectionPolicy_upcast (
++    void *src
++  )
++{
++  RTCORBA::PrivateConnectionPolicy **tmp =
++    ACE_static_cast (RTCORBA::PrivateConnectionPolicy **, src);
++  return *tmp;
++}
++
+ 
+ #endif /* end #if !defined */
+ 
+@@ -1203,6 +1461,49 @@
+ #if !defined (_RTCORBA_TCPPROTOCOLPROPERTIES___CI_)
+ #define _RTCORBA_TCPPROTOCOLPROPERTIES___CI_
+ 
++ACE_INLINE RTCORBA::TCPProtocolProperties_ptr
++tao_RTCORBA_TCPProtocolProperties_duplicate (
++    RTCORBA::TCPProtocolProperties_ptr p
++  )
++{
++  return RTCORBA::TCPProtocolProperties::_duplicate (p);
++}
++
++ACE_INLINE void
++tao_RTCORBA_TCPProtocolProperties_release (
++    RTCORBA::TCPProtocolProperties_ptr p
++  )
++{
++  CORBA::release (p);
++}
++
++ACE_INLINE RTCORBA::TCPProtocolProperties_ptr
++tao_RTCORBA_TCPProtocolProperties_nil (
++    void
++  )
++{
++  return RTCORBA::TCPProtocolProperties::_nil ();
++}
++
++ACE_INLINE RTCORBA::TCPProtocolProperties_ptr
++tao_RTCORBA_TCPProtocolProperties_narrow (
++    CORBA::Object *p,
++    CORBA::Environment &ACE_TRY_ENV
++  )
++{
++  return RTCORBA::TCPProtocolProperties::_narrow (p, ACE_TRY_ENV);
++}
++
++ACE_INLINE CORBA::Object *
++tao_RTCORBA_TCPProtocolProperties_upcast (
++    void *src
++  )
++{
++  RTCORBA::TCPProtocolProperties **tmp =
++    ACE_static_cast (RTCORBA::TCPProtocolProperties **, src);
++  return *tmp;
++}
++
+ 
+ #endif /* end #if !defined */
+ 
+@@ -1210,6 +1511,49 @@
+ #if !defined (_RTCORBA_GIOPPROTOCOLPROPERTIES___CI_)
+ #define _RTCORBA_GIOPPROTOCOLPROPERTIES___CI_
+ 
++ACE_INLINE RTCORBA::GIOPProtocolProperties_ptr
++tao_RTCORBA_GIOPProtocolProperties_duplicate (
++    RTCORBA::GIOPProtocolProperties_ptr p
++  )
++{
++  return RTCORBA::GIOPProtocolProperties::_duplicate (p);
++}
++
++ACE_INLINE void
++tao_RTCORBA_GIOPProtocolProperties_release (
++    RTCORBA::GIOPProtocolProperties_ptr p
++  )
++{
++  CORBA::release (p);
++}
++
++ACE_INLINE RTCORBA::GIOPProtocolProperties_ptr
++tao_RTCORBA_GIOPProtocolProperties_nil (
++    void
++  )
++{
++  return RTCORBA::GIOPProtocolProperties::_nil ();
++}
++
++ACE_INLINE RTCORBA::GIOPProtocolProperties_ptr
++tao_RTCORBA_GIOPProtocolProperties_narrow (
++    CORBA::Object *p,
++    CORBA::Environment &ACE_TRY_ENV
++  )
++{
++  return RTCORBA::GIOPProtocolProperties::_narrow (p, ACE_TRY_ENV);
++}
++
++ACE_INLINE CORBA::Object *
++tao_RTCORBA_GIOPProtocolProperties_upcast (
++    void *src
++  )
++{
++  RTCORBA::GIOPProtocolProperties **tmp =
++    ACE_static_cast (RTCORBA::GIOPProtocolProperties **, src);
++  return *tmp;
++}
++
+ 
+ #endif /* end #if !defined */
+ 
+@@ -1217,6 +1561,49 @@
+ #if !defined (_RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___CI_)
+ #define _RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___CI_
+ 
++ACE_INLINE RTCORBA::UnixDomainProtocolProperties_ptr
++tao_RTCORBA_UnixDomainProtocolProperties_duplicate (
++    RTCORBA::UnixDomainProtocolProperties_ptr p
++  )
++{
++  return RTCORBA::UnixDomainProtocolProperties::_duplicate (p);
++}
++
++ACE_INLINE void
++tao_RTCORBA_UnixDomainProtocolProperties_release (
++    RTCORBA::UnixDomainProtocolProperties_ptr p
++  )
++{
++  CORBA::release (p);
++}
++
++ACE_INLINE RTCORBA::UnixDomainProtocolProperties_ptr
++tao_RTCORBA_UnixDomainProtocolProperties_nil (
++    void
++  )
++{
++  return RTCORBA::UnixDomainProtocolProperties::_nil ();
++}
++
++ACE_INLINE RTCORBA::UnixDomainProtocolProperties_ptr
++tao_RTCORBA_UnixDomainProtocolProperties_narrow (
++    CORBA::Object *p,
++    CORBA::Environment &ACE_TRY_ENV
++  )
++{
++  return RTCORBA::UnixDomainProtocolProperties::_narrow (p, ACE_TRY_ENV);
++}
++
++ACE_INLINE CORBA::Object *
++tao_RTCORBA_UnixDomainProtocolProperties_upcast (
++    void *src
++  )
++{
++  RTCORBA::UnixDomainProtocolProperties **tmp =
++    ACE_static_cast (RTCORBA::UnixDomainProtocolProperties **, src);
++  return *tmp;
++}
++
+ 
+ #endif /* end #if !defined */
+ 
+@@ -1224,6 +1611,49 @@
+ #if !defined (_RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___CI_)
+ #define _RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___CI_
+ 
++ACE_INLINE RTCORBA::SharedMemoryProtocolProperties_ptr
++tao_RTCORBA_SharedMemoryProtocolProperties_duplicate (
++    RTCORBA::SharedMemoryProtocolProperties_ptr p
++  )
++{
++  return RTCORBA::SharedMemoryProtocolProperties::_duplicate (p);
++}
++
++ACE_INLINE void
++tao_RTCORBA_SharedMemoryProtocolProperties_release (
++    RTCORBA::SharedMemoryProtocolProperties_ptr p
++  )
++{
++  CORBA::release (p);
++}
++
++ACE_INLINE RTCORBA::SharedMemoryProtocolProperties_ptr
++tao_RTCORBA_SharedMemoryProtocolProperties_nil (
++    void
++  )
++{
++  return RTCORBA::SharedMemoryProtocolProperties::_nil ();
++}
++
++ACE_INLINE RTCORBA::SharedMemoryProtocolProperties_ptr
++tao_RTCORBA_SharedMemoryProtocolProperties_narrow (
++    CORBA::Object *p,
++    CORBA::Environment &ACE_TRY_ENV
++  )
++{
++  return RTCORBA::SharedMemoryProtocolProperties::_narrow (p, ACE_TRY_ENV);
++}
++
++ACE_INLINE CORBA::Object *
++tao_RTCORBA_SharedMemoryProtocolProperties_upcast (
++    void *src
++  )
++{
++  RTCORBA::SharedMemoryProtocolProperties **tmp =
++    ACE_static_cast (RTCORBA::SharedMemoryProtocolProperties **, src);
++  return *tmp;
++}
++
+ 
+ #endif /* end #if !defined */
+ 
+@@ -1782,6 +2212,49 @@
+ #if !defined (_RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY___CI_)
+ #define _RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY___CI_
+ 
++ACE_INLINE RTCORBA::PriorityBandedConnectionPolicy_ptr
++tao_RTCORBA_PriorityBandedConnectionPolicy_duplicate (
++    RTCORBA::PriorityBandedConnectionPolicy_ptr p
++  )
++{
++  return RTCORBA::PriorityBandedConnectionPolicy::_duplicate (p);
++}
++
++ACE_INLINE void
++tao_RTCORBA_PriorityBandedConnectionPolicy_release (
++    RTCORBA::PriorityBandedConnectionPolicy_ptr p
++  )
++{
++  CORBA::release (p);
++}
++
++ACE_INLINE RTCORBA::PriorityBandedConnectionPolicy_ptr
++tao_RTCORBA_PriorityBandedConnectionPolicy_nil (
++    void
++  )
++{
++  return RTCORBA::PriorityBandedConnectionPolicy::_nil ();
++}
++
++ACE_INLINE RTCORBA::PriorityBandedConnectionPolicy_ptr
++tao_RTCORBA_PriorityBandedConnectionPolicy_narrow (
++    CORBA::Object *p,
++    CORBA::Environment &ACE_TRY_ENV
++  )
++{
++  return RTCORBA::PriorityBandedConnectionPolicy::_narrow (p, ACE_TRY_ENV);
++}
++
++ACE_INLINE CORBA::Object *
++tao_RTCORBA_PriorityBandedConnectionPolicy_upcast (
++    void *src
++  )
++{
++  RTCORBA::PriorityBandedConnectionPolicy **tmp =
++    ACE_static_cast (RTCORBA::PriorityBandedConnectionPolicy **, src);
++  return *tmp;
++}
++
+ 
+ #endif /* end #if !defined */
+ 
+@@ -1789,6 +2262,49 @@
+ #if !defined (_RTCORBA_CURRENT___CI_)
+ #define _RTCORBA_CURRENT___CI_
+ 
++ACE_INLINE RTCORBA::Current_ptr
++tao_RTCORBA_Current_duplicate (
++    RTCORBA::Current_ptr p
++  )
++{
++  return RTCORBA::Current::_duplicate (p);
++}
++
++ACE_INLINE void
++tao_RTCORBA_Current_release (
++    RTCORBA::Current_ptr p
++  )
++{
++  CORBA::release (p);
++}
++
++ACE_INLINE RTCORBA::Current_ptr
++tao_RTCORBA_Current_nil (
++    void
++  )
++{
++  return RTCORBA::Current::_nil ();
++}
++
++ACE_INLINE RTCORBA::Current_ptr
++tao_RTCORBA_Current_narrow (
++    CORBA::Object *p,
++    CORBA::Environment &ACE_TRY_ENV
++  )
++{
++  return RTCORBA::Current::_narrow (p, ACE_TRY_ENV);
++}
++
++ACE_INLINE CORBA::Object *
++tao_RTCORBA_Current_upcast (
++    void *src
++  )
++{
++  RTCORBA::Current **tmp =
++    ACE_static_cast (RTCORBA::Current **, src);
++  return *tmp;
++}
++
+ 
+ #endif /* end #if !defined */
+ 
+@@ -1796,6 +2312,49 @@
+ #if !defined (_RTCORBA_MUTEX___CI_)
+ #define _RTCORBA_MUTEX___CI_
+ 
++ACE_INLINE RTCORBA::Mutex_ptr
++tao_RTCORBA_Mutex_duplicate (
++    RTCORBA::Mutex_ptr p
++  )
++{
++  return RTCORBA::Mutex::_duplicate (p);
++}
++
++ACE_INLINE void
++tao_RTCORBA_Mutex_release (
++    RTCORBA::Mutex_ptr p
++  )
++{
++  CORBA::release (p);
++}
++
++ACE_INLINE RTCORBA::Mutex_ptr
++tao_RTCORBA_Mutex_nil (
++    void
++  )
++{
++  return RTCORBA::Mutex::_nil ();
++}
++
++ACE_INLINE RTCORBA::Mutex_ptr
++tao_RTCORBA_Mutex_narrow (
++    CORBA::Object *p,
++    CORBA::Environment &ACE_TRY_ENV
++  )
++{
++  return RTCORBA::Mutex::_narrow (p, ACE_TRY_ENV);
++}
++
++ACE_INLINE CORBA::Object *
++tao_RTCORBA_Mutex_upcast (
++    void *src
++  )
++{
++  RTCORBA::Mutex **tmp =
++    ACE_static_cast (RTCORBA::Mutex **, src);
++  return *tmp;
++}
++
+ 
+ #endif /* end #if !defined */
+ 
+@@ -1811,6 +2370,49 @@
+ #if !defined (_RTCORBA_RTORB___CI_)
+ #define _RTCORBA_RTORB___CI_
+ 
++ACE_INLINE RTCORBA::RTORB_ptr
++tao_RTCORBA_RTORB_duplicate (
++    RTCORBA::RTORB_ptr p
++  )
++{
++  return RTCORBA::RTORB::_duplicate (p);
++}
++
++ACE_INLINE void
++tao_RTCORBA_RTORB_release (
++    RTCORBA::RTORB_ptr p
++  )
++{
++  CORBA::release (p);
++}
++
++ACE_INLINE RTCORBA::RTORB_ptr
++tao_RTCORBA_RTORB_nil (
++    void
++  )
++{
++  return RTCORBA::RTORB::_nil ();
++}
++
++ACE_INLINE RTCORBA::RTORB_ptr
++tao_RTCORBA_RTORB_narrow (
++    CORBA::Object *p,
++    CORBA::Environment &ACE_TRY_ENV
++  )
++{
++  return RTCORBA::RTORB::_narrow (p, ACE_TRY_ENV);
++}
++
++ACE_INLINE CORBA::Object *
++tao_RTCORBA_RTORB_upcast (
++    void *src
++  )
++{
++  RTCORBA::RTORB **tmp =
++    ACE_static_cast (RTCORBA::RTORB **, src);
++  return *tmp;
++}
++
+ 
+ #endif /* end #if !defined */
+ 
+@@ -1912,4 +2514,3 @@
+   );
+ 
+ #endif /* _TAO_CDR_OP_RTCORBA_PriorityBands_I_ */
+-
diff --git a/TAO/tao/RTPortableServer/RTPortableServer.pidl b/TAO/tao/RTPortableServer/RTPortableServer.pidl
index c01f8a3f6d7..ea952725c80 100644
--- a/TAO/tao/RTPortableServer/RTPortableServer.pidl
+++ b/TAO/tao/RTPortableServer/RTPortableServer.pidl
@@ -12,40 +12,44 @@
 // = DESCRIPTION
 //
 //   This file was used to generate the code in RTPortableServerC.{h,i,cpp}
+//   The steps to regenerate the code are as follows:
 //
-//   The command used to generate code from this file is:
+//   1. Run the tao_idl compiler on the pidl file.  The command used for
+//   this is:
 //
-//     tao_idl.exe \
-//          -Ge 1 \
-//          -Wb,export_macro=TAO_RTPortableServer_Export \
-//          -Wb,export_include="rtportableserver_export.h" \
-//          -Wb,pre_include="ace/pre.h" \
-//          -Wb,post_include="ace/post.h" \
+//     tao_idl.exe
+//          -o orig -Ge 1
+//          -Wb,export_macro=TAO_RTPortableServer_Export
+//          -Wb,export_include="rtportableserver_export.h"
+//          -Wb,pre_include="ace/pre.h"
+//          -Wb,post_include="ace/post.h"
 //          RTPortableServer.pidl
 //
-//   After the file is generated a patch from the diffs directory must
-//   be applied.  The patch fixes include file dependencies and makes
+//   2. Then apply the patches in tao/RTPortableServer/diffs to the
+//   generated code.  The patch fixes include file dependencies and makes
 //   the inheritance of RTPortableServer::POA from PortableServer::POA
 //   non-virtual.  This was to make sure that classes casting from
 //   PortableServer::POA to TAO_POA can still do so.
 //
 //   Apply patches using the following commands:
 //
-//   patch < diffs\RTPortableServerC.h.diff
-//   patch < diffs\RTPortableServerC.cpp.diff
+//   patch < diffs/RTPortableServerC.h.diff
+//   patch < diffs/RTPortableServerC.i.diff
+//   patch < diffs/RTPortableServerC.cpp.diff
 //
 //   Note: The diffs were generated with these commands:
 //
-//   diff -wub RTPortableServerC.h RTPortableServerC.h.mod > diffs\RTPortableServerC.h.diff
-//   diff -wub RTPortableServerC.cpp RTPortableServerC.cpp.mod > diffs\RTPortableServerC.cpp.diff
+//   diff -wBbu orig/RTPortableServerC.h RTPortableServerC.h > diffs/RTPortableServerC.h.diff
+//   diff -wBbu orig/RTPortableServerC.i RTPortableServerC.i > diffs/RTPortableServerC.i.diff
+//   diff -wBbu orig/RTPortableServerC.cpp RTPortableServerC.cpp > diffs/RTPortableServerC.cpp.diff
 //
 // ================================================================
 
 #ifndef _RT_PORTABLE_SERVER_IDL_
 #define _RT_PORTABLE_SERVER_IDL_
 
-#include <PortableServer.pidl>
-#include <RTCORBA.pidl>
+#include <../PortableServer/PortableServer.pidl>
+#include <../RTCORBA/RTCORBA.pidl>
 
 #pragma prefix "omg.org"
 
diff --git a/TAO/tao/RTPortableServer/diffs/RTPortableServerC.cpp.diff b/TAO/tao/RTPortableServer/diffs/RTPortableServerC.cpp.diff
new file mode 100644
index 00000000000..5b98780112f
--- /dev/null
+++ b/TAO/tao/RTPortableServer/diffs/RTPortableServerC.cpp.diff
@@ -0,0 +1,86 @@
+--- orig/RTPortableServerC.cpp	Tue Jun 12 18:17:14 2001
++++ RTPortableServerC.cpp	Tue Jun 12 16:19:19 2001
+@@ -1,6 +1,6 @@
+ // -*- C++ -*-
+ //
+-// $Id$
++// $Id$
+ 
+ // ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+ // TAO and the TAO IDL Compiler have been developed by:
+@@ -21,16 +21,6 @@
+ 
+ #include "RTPortableServerC.h"
+ 
+-#include "tao/Stub.h"
+-#include "tao/Invocation.h"
+-#include "tao/PortableInterceptor.h"
+-
+-#if TAO_HAS_INTERCEPTORS == 1
+-#include "tao/RequestInfo_Util.h"
+-#include "tao/ClientRequestInfo.h"
+-#include "tao/ClientInterceptorAdapter.h"
+-#endif  /* TAO_HAS_INTERCEPTORS == 1 */
+-
+ #if defined (__BORLANDC__)
+ #pragma option -w-rvl -w-rch -w-ccc -w-aus
+ #endif /* __BORLANDC__ */
+@@ -39,49 +29,6 @@
+ #include "RTPortableServerC.i"
+ #endif /* !defined INLINE */
+ 
+-RTPortableServer::POA_ptr
+-tao_RTPortableServer_POA_duplicate (
+-    RTPortableServer::POA_ptr p
+-  )
+-{
+-  return RTPortableServer::POA::_duplicate (p);
+-}
+-
+-void
+-tao_RTPortableServer_POA_release (
+-    RTPortableServer::POA_ptr p
+-  )
+-{
+-  CORBA::release (p);
+-}
+-
+-RTPortableServer::POA_ptr
+-tao_RTPortableServer_POA_nil (
+-    void
+-  )
+-{
+-  return RTPortableServer::POA::_nil ();
+-}
+-
+-RTPortableServer::POA_ptr
+-tao_RTPortableServer_POA_narrow (
+-    CORBA::Object *p,
+-    CORBA::Environment &ACE_TRY_ENV
+-  )
+-{
+-  return RTPortableServer::POA::_narrow (p, ACE_TRY_ENV);
+-}
+-
+-CORBA::Object *
+-tao_RTPortableServer_POA_upcast (
+-    void *src
+-  )
+-{
+-  RTPortableServer::POA **tmp =
+-    ACE_static_cast (RTPortableServer::POA **, src);
+-  return *tmp;
+-}
+-
+ // *************************************************************
+ // Operations for class RTPortableServer::POA_var
+ // *************************************************************
+@@ -206,7 +153,7 @@
+ }
+ 
+ // *************************************************************
+-// Operations for class RTPortableServer::POA_out
++// Inline operations for class RTPortableServer::POA_out
+ // *************************************************************
+ 
+ RTPortableServer::POA_out::POA_out (POA_ptr &p)
diff --git a/TAO/tao/RTPortableServer/diffs/RTPortableServerC.h.diff b/TAO/tao/RTPortableServer/diffs/RTPortableServerC.h.diff
new file mode 100644
index 00000000000..454a9dea9fb
--- /dev/null
+++ b/TAO/tao/RTPortableServer/diffs/RTPortableServerC.h.diff
@@ -0,0 +1,79 @@
+--- orig/RTPortableServerC.h	Tue Jun 12 18:17:14 2001
++++ RTPortableServerC.h	Tue Jun 12 16:19:19 2001
+@@ -1,6 +1,6 @@
+ // -*- C++ -*-
+ //
+-// $Id$
++// $Id$
+ 
+ // ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+ // TAO and the TAO IDL Compiler have been developed by:
+@@ -23,15 +23,14 @@
+ #define _TAO_IDL_ORIG_RTPORTABLESERVERC_H_
+ 
+ #include "ace/pre.h"
+-#include "tao/corba.h"
++#include "rtportableserver_export.h"
++#include "tao/PortableServer/PortableServerC.h"
+ 
+ #if !defined (ACE_LACKS_PRAGMA_ONCE)
+ # pragma once
+ #endif /* ACE_LACKS_PRAGMA_ONCE */
+ 
+-#include "rtportableserver_export.h"
+-#include "../PortableServer/PortableServerC.h"
+-#include "../RTCORBA/RTCORBAC.h"
++#include "tao/RTCORBA/RTCORBA.h"
+ 
+ #if defined (TAO_EXPORT_MACRO)
+ #undef TAO_EXPORT_MACRO
+@@ -97,10 +96,7 @@
+     static POA_ptr duplicate (POA_ptr);
+     static void release (POA_ptr);
+     static POA_ptr nil (void);
+-    static POA_ptr narrow (
+-        CORBA::Object *,
+-        CORBA::Environment &
+-      );
++    static POA_ptr narrow (CORBA::Object *, CORBA::Environment &);
+     static CORBA::Object * upcast (void *);
+   
+   private:
+@@ -141,8 +137,7 @@
+ #if !defined (_RTPORTABLESERVER_POA_CH_)
+ #define _RTPORTABLESERVER_POA_CH_
+   
+-  class TAO_RTPortableServer_Export POA
+-    : public virtual PortableServer::POA
++class TAO_RTPortableServer_Export POA: public virtual PortableServer::POA
+   {
+   public:
+   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+@@ -152,19 +147,16 @@
+ 
+     // the static operations
+     static POA_ptr _duplicate (POA_ptr obj);
+-    
+     static POA_ptr _narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static POA_ptr _unchecked_narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static POA_ptr _nil (void)
+       {
+         return (POA_ptr)0;
+@@ -227,7 +219,6 @@
+     POA ();
+     
+     virtual ~POA (void);
+-  
+   private:
+     POA (const POA &);
+     void operator= (const POA &);
diff --git a/TAO/tao/RTPortableServer/diffs/RTPortableServerC.i.diff b/TAO/tao/RTPortableServer/diffs/RTPortableServerC.i.diff
new file mode 100644
index 00000000000..af4585d5f5f
--- /dev/null
+++ b/TAO/tao/RTPortableServer/diffs/RTPortableServerC.i.diff
@@ -0,0 +1,60 @@
+--- orig/RTPortableServerC.i	Tue Jun 12 18:17:14 2001
++++ RTPortableServerC.i	Tue Jun 12 16:19:19 2001
+@@ -1,6 +1,6 @@
+ // -*- C++ -*-
+ //
+-// $Id$
++// $Id$
+ 
+ // ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+ // TAO and the TAO IDL Compiler have been developed by:
+@@ -22,6 +22,49 @@
+ 
+ #if !defined (_RTPORTABLESERVER_POA___CI_)
+ #define _RTPORTABLESERVER_POA___CI_
++
++ACE_INLINE RTPortableServer::POA_ptr
++tao_RTPortableServer_POA_duplicate (
++    RTPortableServer::POA_ptr p
++  )
++{
++  return RTPortableServer::POA::_duplicate (p);
++}
++
++ACE_INLINE void
++tao_RTPortableServer_POA_release (
++    RTPortableServer::POA_ptr p
++  )
++{
++  CORBA::release (p);
++}
++
++ACE_INLINE RTPortableServer::POA_ptr
++tao_RTPortableServer_POA_nil (
++    void
++  )
++{
++  return RTPortableServer::POA::_nil ();
++}
++
++ACE_INLINE RTPortableServer::POA_ptr
++tao_RTPortableServer_POA_narrow (
++    CORBA::Object *p,
++    CORBA::Environment &ACE_TRY_ENV
++  )
++{
++  return RTPortableServer::POA::_narrow (p, ACE_TRY_ENV);
++}
++
++ACE_INLINE CORBA::Object *
++tao_RTPortableServer_POA_upcast (
++    void *src
++  )
++{
++  RTPortableServer::POA **tmp =
++    ACE_static_cast (RTPortableServer::POA **, src);
++  return *tmp;
++}
+ 
+ 
+ #endif /* end #if !defined */
diff --git a/TAO/tao/TAO.pidl b/TAO/tao/TAO.pidl
index c228378bf9b..88f795de422 100644
--- a/TAO/tao/TAO.pidl
+++ b/TAO/tao/TAO.pidl
@@ -13,21 +13,32 @@
 //   This file contains TAO-specific idl interfaces (not part of CORBA
 //   2.3).
 //
-//   The command used to generate code from this file is:
+//   The steps to regenerate the code are as follows:
 //
-//   tao_idl -o orig -Gp -Gd -Ge 1 -Gv  \
-//       -Wb,export_macro=TAO_Export \
-//       -Wb,pre_include="ace/pre.h" \
-//       -Wb,post_include="ace/post.h" \
+//   1. Run the tao_idl compiler on the pidl file.  The command used for
+//   this is:
+//
+//   tao_idl -o orig -Ge 1
+//       -Wb,export_macro=TAO_Export
+//       -Wb,pre_include="ace/pre.h"
+//       -Wb,post_include="ace/post.h"
 //       -Wb,export_include="tao/corbafwd.h" TAO.pidl
 //
-//   after the file is generated a patch must be applied.  The patch
-//   fixes the interface repository IDs, disables the code under
-//   certain configurations, and eliminates cycles in the include
-//   dependencies.  Those changes are required because the generated
-//   code is part of the TAO library, it hardly makes any sense to
-//   change the IDL compiler to support changes that are very
-//   occasional.
+//   2. Then patch the generated code.  The patch fixes the interface
+//   repository IDs, disables the code under certain configurations,
+//   and eliminates cycles in the include dependencies.
+//
+//   Apply patches using the following commands:
+//
+//   patch < diffs/TAOC.h.diff
+//   patch < diffs/TAOC.i.diff
+//   patch < diffs/TAOC.cpp.diff
+//
+//   Note: The diffs were generated with these commands:
+//
+//   diff -wBbu orig/TAOC.h TAOC.h > diffs/TAOC.h.diff
+//   diff -wBbu orig/TAOC.i TAOC.i > diffs/TAOC.i.diff
+//   diff -wBbu orig/TAOC.cpp TAOC.cpp > diffs/TAOC.cpp.diff
 //
 // ================================================================
 
diff --git a/TAO/tao/diffs/PolicyC.cpp.diff b/TAO/tao/diffs/PolicyC.cpp.diff
index ab65f71b6b7..a0d09b6c87c 100644
--- a/TAO/tao/diffs/PolicyC.cpp.diff
+++ b/TAO/tao/diffs/PolicyC.cpp.diff
@@ -1,5 +1,5 @@
---- orig/PolicyC.cpp	Tue Apr 24 23:49:03 2001
-+++ PolicyC.cpp	Tue Apr 24 13:44:40 2001
+--- orig/PolicyC.cpp	Tue Jun 12 17:22:53 2001
++++ PolicyC.cpp	Tue Jun 12 13:58:12 2001
 @@ -1,6 +1,6 @@
  // -*- C++ -*-
  //
@@ -8,15 +8,7 @@
  
  // ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
  // TAO and the TAO IDL Compiler have been developed by:
-@@ -23,6 +23,7 @@
- 
- #include "tao/Stub.h"
- #include "tao/Invocation.h"
-+#include "tao/PortableInterceptor.h"
- #include "tao/ClientRequestInfo.h"
- #if TAO_HAS_INTERCEPTORS == 1
- #include "tao/RequestInfo_Util.h"
-@@ -36,124 +37,34 @@
+@@ -39,124 +39,34 @@
  #include "PolicyC.i"
  #endif /* !defined INLINE */
  
@@ -159,16 +151,85 @@
  {
  }
  
-@@ -188,7 +99,7 @@
- CORBA_PolicyError *
- CORBA_PolicyError::_downcast (CORBA::Exception *exc)
+@@ -165,22 +75,22 @@
+ {
+ }
+ 
+-void CORBA_PolicyError::_tao_any_destructor (void *_tao_void_pointer)
++void CORBA_PolicyError::_tao_any_destructor (void *x)
+ {
+-  CORBA_PolicyError *tmp = ACE_static_cast (CORBA_PolicyError*, _tao_void_pointer);
++  CORBA_PolicyError *tmp = ACE_static_cast (CORBA_PolicyError*,x);
+   delete tmp;
+ }
+ 
+ // Copy constructor.
+-CORBA_PolicyError::CORBA_PolicyError (const ::CORBA_PolicyError &_tao_excp)
++CORBA_PolicyError::CORBA_PolicyError (const ::CORBA::PolicyError &_tao_excp)
+   : CORBA_UserException (_tao_excp._id ())
+ {
+   this->reason = _tao_excp.reason;
+ }
+ 
+ // Assignment operator.
+-CORBA_PolicyError&
+-CORBA_PolicyError::operator= (const ::CORBA_PolicyError &_tao_excp)
++CORBA::PolicyError&
++CORBA::PolicyError::operator= (const ::CORBA::PolicyError &_tao_excp)
+ {
+   this->CORBA_UserException::operator= (_tao_excp);
+   this->reason = _tao_excp.reason;
+@@ -188,10 +98,10 @@
+ }
+ 
+ // Narrow.
+-CORBA_PolicyError *
+-CORBA_PolicyError::_downcast (CORBA::Exception *exc)
++CORBA::PolicyError *
++CORBA::PolicyError::_downcast (CORBA::Exception *exc)
  {
 -  if (!ACE_OS::strcmp ("IDL:omg.org/CORBA_PolicyError:1.0", exc->_id ()))
 +  if (!ACE_OS::strcmp ("IDL:omg.org/CORBA/PolicyError:1.0", exc->_id ()))
      {
        return ACE_dynamic_cast (CORBA_PolicyError *, exc);
      }
-@@ -240,7 +151,7 @@
+@@ -201,12 +111,12 @@
+     }
+ }
+ 
+-void CORBA_PolicyError::_raise ()
++void CORBA::PolicyError::_raise ()
+ {
+   TAO_RAISE (*this);
+ }
+ 
+-void CORBA_PolicyError::_tao_encode (
++void CORBA::PolicyError::_tao_encode (
+     TAO_OutputCDR &cdr,
+     CORBA::Environment &ACE_TRY_ENV
+   ) const
+@@ -219,7 +129,7 @@
+   ACE_THROW (CORBA::MARSHAL ());
+ }
+ 
+-void CORBA_PolicyError::_tao_decode (
++void CORBA::PolicyError::_tao_decode (
+     TAO_InputCDR &cdr,
+     CORBA::Environment &ACE_TRY_ENV
+   )
+@@ -233,84 +143,25 @@
+ }
+ 
+ // TAO extension - the _alloc method.
+-CORBA::Exception *CORBA_PolicyError::_alloc (void)
++CORBA::Exception *CORBA::PolicyError::_alloc (void)
+ {
+   CORBA::Exception *retval = 0;
+-  ACE_NEW_RETURN (retval, ::CORBA_PolicyError, 0);
++  ACE_NEW_RETURN (retval, ::CORBA::PolicyError, 0);
+   return retval;
+ }
+ 
  CORBA_PolicyError::CORBA_PolicyError (
      CORBA::PolicyErrorCode _tao_reason
    )
@@ -177,7 +238,88 @@
  {
    this->reason = _tao_reason;
  }
-@@ -408,7 +319,7 @@
+ 
+-static const CORBA::Long _oc_CORBA_PolicyError[] =
+-{
+-  TAO_ENCAP_BYTE_ORDER, // byte order
+-  34,
+-  ACE_NTOHL (0x49444c3a), 
+-  ACE_NTOHL (0x6f6d672e), 
+-  ACE_NTOHL (0x6f72672f), 
+-  ACE_NTOHL (0x434f5242), 
+-  ACE_NTOHL (0x415f506f), 
+-  ACE_NTOHL (0x6c696379), 
+-  ACE_NTOHL (0x4572726f), 
+-  ACE_NTOHL (0x723a312e), 
+-  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA_PolicyError:1.0
+-  18,
+-  ACE_NTOHL (0x434f5242), 
+-  ACE_NTOHL (0x415f506f), 
+-  ACE_NTOHL (0x6c696379), 
+-  ACE_NTOHL (0x4572726f), 
+-  ACE_NTOHL (0x72000000),  // name = CORBA_PolicyError
+-  1, // member count
+-  7,
+-  ACE_NTOHL (0x72656173), 
+-  ACE_NTOHL (0x6f6e0000),  // name = reason
+-  CORBA::tk_alias, // typecode kind for typedefs
+-  72, // encapsulation length
+-    TAO_ENCAP_BYTE_ORDER, // byte order
+-    38,
+-    ACE_NTOHL (0x49444c3a), 
+-    ACE_NTOHL (0x6f6d672e), 
+-    ACE_NTOHL (0x6f72672f), 
+-    ACE_NTOHL (0x434f5242), 
+-    ACE_NTOHL (0x412f506f), 
+-    ACE_NTOHL (0x6c696379), 
+-    ACE_NTOHL (0x4572726f), 
+-    ACE_NTOHL (0x72436f64), 
+-    ACE_NTOHL (0x653a312e), 
+-    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/PolicyErrorCode:1.0
+-    16,
+-    ACE_NTOHL (0x506f6c69), 
+-    ACE_NTOHL (0x63794572), 
+-    ACE_NTOHL (0x726f7243), 
+-    ACE_NTOHL (0x6f646500),  // name = PolicyErrorCode
+-    CORBA::tk_short,
+-
+-
+-};
+-
+-static CORBA::TypeCode _tc_TAO_tc_CORBA_PolicyError (
+-    CORBA::tk_except,
+-    sizeof (_oc_CORBA_PolicyError),
+-    (char *) &_oc_CORBA_PolicyError,
+-    0,
+-    sizeof (CORBA_PolicyError)
+-  );
+-
+-CORBA::TypeCode_ptr _tc_CORBA_PolicyError =
+-  &_tc_TAO_tc_CORBA_PolicyError;
+-
+-
+ // TAO extension - the virtual _type method.
+-CORBA::TypeCode_ptr CORBA_PolicyError::_type (void) const
++CORBA::TypeCode_ptr CORBA::PolicyError::_type (void) const
+ {
+-  return ::_tc_CORBA_PolicyError;
++  return ::CORBA::_tc_PolicyError;
+ }
+ 
+ 
+@@ -400,9 +251,9 @@
+ {}
+ CORBA_InvalidPolicies::_tao_seq_UShort::~_tao_seq_UShort (void) // dtor
+ {}
+-void CORBA_InvalidPolicies::_tao_seq_UShort::_tao_any_destructor (void *_tao_void_pointer)
++void CORBA_InvalidPolicies::_tao_seq_UShort::_tao_any_destructor (void *x)
+ {
+-  _tao_seq_UShort *tmp = ACE_static_cast (_tao_seq_UShort*, _tao_void_pointer);
++  _tao_seq_UShort *tmp = ACE_static_cast (_tao_seq_UShort*,x);
+   delete tmp;
+ }
+ 
+@@ -411,7 +262,7 @@
  
  // Default constructor.
  CORBA_InvalidPolicies::CORBA_InvalidPolicies (void)
@@ -186,7 +328,19 @@
  {
  }
  
-@@ -443,7 +354,7 @@
+@@ -420,9 +271,9 @@
+ {
+ }
+ 
+-void CORBA_InvalidPolicies::_tao_any_destructor (void *_tao_void_pointer)
++void CORBA_InvalidPolicies::_tao_any_destructor (void *x)
+ {
+-  CORBA_InvalidPolicies *tmp = ACE_static_cast (CORBA_InvalidPolicies*, _tao_void_pointer);
++  CORBA_InvalidPolicies *tmp = ACE_static_cast (CORBA_InvalidPolicies*,x);
+   delete tmp;
+ }
+ 
+@@ -446,7 +297,7 @@
  CORBA_InvalidPolicies *
  CORBA_InvalidPolicies::_downcast (CORBA::Exception *exc)
  {
@@ -195,7 +349,7 @@
      {
        return ACE_dynamic_cast (CORBA_InvalidPolicies *, exc);
      }
-@@ -495,7 +406,7 @@
+@@ -498,94 +349,48 @@
  CORBA_InvalidPolicies::CORBA_InvalidPolicies (
      const CORBA_InvalidPolicies::_tao_seq_UShort & _tao_indices
    )
@@ -204,68 +358,513 @@
  {
    this->indices = _tao_indices;
  }
-@@ -552,49 +463,6 @@
-   return ::_tc_CORBA_InvalidPolicies;
+ 
+-static const CORBA::Long _oc_CORBA_InvalidPolicies[] =
+-{
+-  TAO_ENCAP_BYTE_ORDER, // byte order
+-  38,
+-  ACE_NTOHL (0x49444c3a), 
+-  ACE_NTOHL (0x6f6d672e), 
+-  ACE_NTOHL (0x6f72672f), 
+-  ACE_NTOHL (0x434f5242), 
+-  ACE_NTOHL (0x415f496e), 
+-  ACE_NTOHL (0x76616c69), 
+-  ACE_NTOHL (0x64506f6c), 
+-  ACE_NTOHL (0x69636965), 
+-  ACE_NTOHL (0x733a312e), 
+-  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA_InvalidPolicies:1.0
+-  22,
+-  ACE_NTOHL (0x434f5242), 
+-  ACE_NTOHL (0x415f496e), 
+-  ACE_NTOHL (0x76616c69), 
+-  ACE_NTOHL (0x64506f6c), 
+-  ACE_NTOHL (0x69636965), 
+-  ACE_NTOHL (0x73000000),  // name = CORBA_InvalidPolicies
+-  1, // member count
+-  8,
+-  ACE_NTOHL (0x696e6469), 
+-  ACE_NTOHL (0x63657300),  // name = indices
+-  CORBA::tk_sequence, // typecode kind
+-  12, // encapsulation length
+-    TAO_ENCAP_BYTE_ORDER, // byte order
+-    CORBA::tk_ushort,
+-
+-    0U,
+-
+-};
+-
+-static CORBA::TypeCode _tc_TAO_tc_CORBA_InvalidPolicies (
+-    CORBA::tk_except,
+-    sizeof (_oc_CORBA_InvalidPolicies),
+-    (char *) &_oc_CORBA_InvalidPolicies,
+-    0,
+-    sizeof (CORBA_InvalidPolicies)
+-  );
+-
+-CORBA::TypeCode_ptr _tc_CORBA_InvalidPolicies =
+-  &_tc_TAO_tc_CORBA_InvalidPolicies;
+-
+-
+ // TAO extension - the virtual _type method.
+ CORBA::TypeCode_ptr CORBA_InvalidPolicies::_type (void) const
+ {
+-  return ::_tc_CORBA_InvalidPolicies;
++  return ::CORBA::_tc_InvalidPolicies;
  }
  
 -CORBA_Policy_ptr
--tao_CORBA_Policy_duplicate (
++CORBA::Policy_ptr
+ tao_CORBA_Policy_duplicate (
 -    CORBA_Policy_ptr p
--  )
--{
++    CORBA::Policy_ptr p
+   )
+ {
 -  return CORBA_Policy::_duplicate (p);
--}
--
--void
--tao_CORBA_Policy_release (
++  return CORBA::Policy::_duplicate (p);
+ }
+ 
+ void
+ tao_CORBA_Policy_release (
 -    CORBA_Policy_ptr p
--  )
--{
--  CORBA::release (p);
--}
--
++    CORBA::Policy_ptr p
+   )
+ {
+   CORBA::release (p);
+ }
+ 
 -CORBA_Policy_ptr
--tao_CORBA_Policy_nil (
--    void
--  )
--{
++CORBA::Policy_ptr
+ tao_CORBA_Policy_nil (
+     void
+   )
+ {
 -  return CORBA_Policy::_nil ();
--}
--
++  return CORBA::Policy::_nil ();
+ }
+ 
 -CORBA_Policy_ptr
--tao_CORBA_Policy_narrow (
--    CORBA::Object *p,
--    CORBA::Environment &ACE_TRY_ENV
--  )
--{
++CORBA::Policy_ptr
+ tao_CORBA_Policy_narrow (
+     CORBA::Object *p,
+     CORBA::Environment &ACE_TRY_ENV
+   )
+ {
 -  return CORBA_Policy::_narrow (p, ACE_TRY_ENV);
--}
--
--CORBA::Object *
--tao_CORBA_Policy_upcast (
--    void *src
--  )
--{
++  return CORBA::Policy::_narrow (p, ACE_TRY_ENV);
+ }
+ 
+ CORBA::Object *
+@@ -593,26 +398,26 @@
+     void *src
+   )
+ {
 -  CORBA_Policy **tmp =
 -    ACE_static_cast (CORBA_Policy **, src);
--  return *tmp;
--}
--
++  CORBA::Policy **tmp =
++    ACE_static_cast (CORBA::Policy **, src);
+   return *tmp;
+ }
+ 
  // *************************************************************
- // Operations for class CORBA_Policy_var
+-// Operations for class CORBA_Policy_var
++// Operations for class CORBA::Policy_var
  // *************************************************************
-@@ -717,9 +585,8 @@
-     ACE_static_cast (CORBA_Policy **, src);
-   return *tmp;
+ 
+ CORBA_Policy_var::CORBA_Policy_var (void) // default constructor
+   : ptr_ (CORBA_Policy::_nil ())
+ {}
+ 
+-::CORBA_Policy_ptr
++::CORBA::Policy_ptr
+ CORBA_Policy_var::ptr (void) const
+ {
+   return this->ptr_;
  }
--
+ 
+-CORBA_Policy_var::CORBA_Policy_var (const ::CORBA_Policy_var &p) // copy constructor
++CORBA_Policy_var::CORBA_Policy_var (const ::CORBA::Policy_var &p) // copy constructor
+   : TAO_Base_var (),
+     ptr_ (CORBA_Policy::_duplicate (p.ptr ()))
+ {}
+@@ -622,7 +427,7 @@
+   CORBA::release (this->ptr_);
+ }
+ 
+-CORBA_Policy_var &
++CORBA::Policy_var &
+ CORBA_Policy_var::operator= (CORBA_Policy_ptr p)
+ {
+   CORBA::release (this->ptr_);
+@@ -630,66 +435,66 @@
+   return *this;
+ }
+ 
+-CORBA_Policy_var &
+-CORBA_Policy_var::operator= (const ::CORBA_Policy_var &p)
++CORBA::Policy_var &
++CORBA_Policy_var::operator= (const ::CORBA::Policy_var &p)
+ {
+   if (this != &p)
+   {
+     CORBA::release (this->ptr_);
+-    this->ptr_ = ::CORBA_Policy::_duplicate (p.ptr ());
++    this->ptr_ = ::CORBA::Policy::_duplicate (p.ptr ());
+   }
+   return *this;
+ }
+ 
+-CORBA_Policy_var::operator const ::CORBA_Policy_ptr &() const // cast
++CORBA_Policy_var::operator const ::CORBA::Policy_ptr &() const // cast
+ {
+   return this->ptr_;
+ }
+ 
+-CORBA_Policy_var::operator ::CORBA_Policy_ptr &() // cast 
++CORBA_Policy_var::operator ::CORBA::Policy_ptr &() // cast
+ {
+   return this->ptr_;
+ }
+ 
+-::CORBA_Policy_ptr
++::CORBA::Policy_ptr
+ CORBA_Policy_var::operator-> (void) const
+ {
+   return this->ptr_;
+ }
+ 
+-::CORBA_Policy_ptr
++::CORBA::Policy_ptr
+ CORBA_Policy_var::in (void) const
+ {
+   return this->ptr_;
+ }
+ 
+-::CORBA_Policy_ptr &
++::CORBA::Policy_ptr &
+ CORBA_Policy_var::inout (void)
+ {
+   return this->ptr_;
+ }
+ 
+-::CORBA_Policy_ptr &
++::CORBA::Policy_ptr &
+ CORBA_Policy_var::out (void)
+ {
+   CORBA::release (this->ptr_);
+-  this->ptr_ = ::CORBA_Policy::_nil ();
++  this->ptr_ = ::CORBA::Policy::_nil ();
+   return this->ptr_;
+ }
+ 
+-::CORBA_Policy_ptr
++::CORBA::Policy_ptr
+ CORBA_Policy_var::_retn (void)
+ {
+   // yield ownership of managed obj reference
+-  ::CORBA_Policy_ptr val = this->ptr_;
+-  this->ptr_ = ::CORBA_Policy::_nil ();
++  ::CORBA::Policy_ptr val = this->ptr_;
++  this->ptr_ = ::CORBA::Policy::_nil ();
+   return val;
+ }
+ 
+-::CORBA_Policy_ptr
++::CORBA::Policy_ptr
+ CORBA_Policy_var::duplicate (CORBA_Policy_ptr p)
+ {
+-  return ::CORBA_Policy::_duplicate (p);
++  return ::CORBA::Policy::_duplicate (p);
+ }
+ 
+ void
+@@ -698,19 +503,19 @@
+   CORBA::release (p);
+ }
+ 
+-::CORBA_Policy_ptr
++::CORBA::Policy_ptr
+ CORBA_Policy_var::nil (void)
+ {
+-  return ::CORBA_Policy::_nil ();
++  return ::CORBA::Policy::_nil ();
+ }
+ 
+-::CORBA_Policy_ptr
++::CORBA::Policy_ptr
+ CORBA_Policy_var::narrow (
+     CORBA::Object *p,
+     CORBA::Environment &ACE_TRY_ENV
+   )
+ {
+-  return ::CORBA_Policy::_narrow (p, ACE_TRY_ENV);
++  return ::CORBA::Policy::_narrow (p, ACE_TRY_ENV);
+ }
+ 
+ CORBA::Object *
+@@ -722,20 +527,20 @@
+ }
+ 
  // *************************************************************
--// Inline operations for class CORBA_Policy_out
-+// Operations for class CORBA_Policy_out
+-// Operations for class CORBA_Policy_out
++// Operations for class CORBA::Policy_out
  // *************************************************************
  
  CORBA_Policy_out::CORBA_Policy_out (CORBA_Policy_ptr &p)
-@@ -1608,7 +1475,7 @@
+   : ptr_ (p)
+ {
+-  this->ptr_ = ::CORBA_Policy::_nil ();
++  this->ptr_ = ::CORBA::Policy::_nil ();
+ }
+ 
+ CORBA_Policy_out::CORBA_Policy_out (CORBA_Policy_var &p) // constructor from _var
+   : ptr_ (p.out ())
+ {
+   CORBA::release (this->ptr_);
+-  this->ptr_ = ::CORBA_Policy::_nil ();
++  this->ptr_ = ::CORBA::Policy::_nil ();
+ }
+ 
+ CORBA_Policy_out::CORBA_Policy_out (const ::CORBA_Policy_out &p) // copy constructor
+@@ -743,38 +548,38 @@
+ {}
+ 
+ ::CORBA_Policy_out &
+-CORBA_Policy_out::operator= (const ::CORBA_Policy_out &p)
++CORBA_Policy_out::operator= (const ::CORBA::Policy_out &p)
+ {
+   this->ptr_ = ACE_const_cast (CORBA_Policy_out&, p).ptr_;
+   return *this;
+ }
+ 
+-CORBA_Policy_out &
+-CORBA_Policy_out::operator= (const ::CORBA_Policy_var &p)
++CORBA::Policy_out &
++CORBA_Policy_out::operator= (const ::CORBA::Policy_var &p)
+ {
+-  this->ptr_ = ::CORBA_Policy::_duplicate (p.ptr ());
++  this->ptr_ = ::CORBA::Policy::_duplicate (p.ptr ());
+   return *this;
+ }
+ 
+-CORBA_Policy_out &
++CORBA::Policy_out &
+ CORBA_Policy_out::operator= (CORBA_Policy_ptr p)
+ {
+   this->ptr_ = p;
+   return *this;
+ }
+ 
+-CORBA_Policy_out::operator ::CORBA_Policy_ptr &() // cast
++CORBA_Policy_out::operator ::CORBA::Policy_ptr &() // cast
+ {
+   return this->ptr_;
+ }
+ 
+-::CORBA_Policy_ptr &
++::CORBA::Policy_ptr &
+ CORBA_Policy_out::ptr (void) // ptr
+ {
+   return this->ptr_;
+ }
+ 
+-::CORBA_Policy_ptr
++::CORBA::Policy_ptr
+ CORBA_Policy_out::operator-> (void)
+ {
+   return this->ptr_;
+@@ -903,13 +708,13 @@
+     )
+     ACE_THROW_SPEC ((CORBA::SystemException));
+ 
+-  void result (CORBA_Policy_ptr result);
++  void result (CORBA::Policy_ptr result);
+ 
+ private:
+   TAO_ClientRequestInfo_CORBA_Policy_copy (const TAO_ClientRequestInfo_CORBA_Policy_copy &);
+   void operator= (const TAO_ClientRequestInfo_CORBA_Policy_copy &);
+ 
+-  CORBA_Policy_ptr _result;
++  CORBA::Policy_ptr _result;
+ };
+ 
+ TAO_ClientRequestInfo_CORBA_Policy_copy::TAO_ClientRequestInfo_CORBA_Policy_copy (
+@@ -962,7 +767,7 @@
+ }
+ 
+ void 
+-TAO_ClientRequestInfo_CORBA_Policy_copy::result (CORBA_Policy_ptr result)
++TAO_ClientRequestInfo_CORBA_Policy_copy::result (CORBA::Policy_ptr result)
+ {
+   // update the result 
+   this->_result = result;
+@@ -1055,16 +860,16 @@
+ //                Base & Remote Proxy  Implementation. 
+ //
+ 
+-_TAO_CORBA_Policy_Proxy_Impl::_TAO_CORBA_Policy_Proxy_Impl (void)
++CORBA_TAO_Policy_Proxy_Impl::CORBA_TAO_Policy_Proxy_Impl (void)
+ {}
+ 
+-_TAO_CORBA_Policy_Remote_Proxy_Impl::_TAO_CORBA_Policy_Remote_Proxy_Impl (void)
++CORBA_TAO_Policy_Remote_Proxy_Impl::CORBA_TAO_Policy_Remote_Proxy_Impl (void)
+ {}
+ 
+ // Remote Implementation of the IDL interface methods
+ 
+-CORBA::PolicyType _TAO_CORBA_Policy_Remote_Proxy_Impl::policy_type (
+-    CORBA_Object *_collocated_tao_target_,
++CORBA::PolicyType CORBA_TAO_Policy_Remote_Proxy_Impl::policy_type (
++    CORBA::Object_ptr _collocated_tao_target_,
+     CORBA::Environment &ACE_TRY_ENV
+   )
+   ACE_THROW_SPEC ((
+@@ -1151,7 +956,7 @@
+           if (_invoke_status == TAO_INVOKE_EXCEPTION)
+             {
+               TAO_INTERCEPTOR_THROW_RETURN (
+-                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
++                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                 _tao_retval
+               );
+               
+@@ -1229,8 +1034,8 @@
+ return _tao_retval;
+ }
+ 
+-CORBA_Policy_ptr _TAO_CORBA_Policy_Remote_Proxy_Impl::copy (
+-    CORBA_Object *_collocated_tao_target_,
++CORBA::Policy_ptr CORBA_TAO_Policy_Remote_Proxy_Impl::copy (
++    CORBA::Object_ptr _collocated_tao_target_,
+     CORBA::Environment &ACE_TRY_ENV
+   )
+   ACE_THROW_SPEC ((
+@@ -1238,8 +1043,8 @@
+   ))
+ {
+   
+-  CORBA_Policy_ptr _tao_retval = CORBA_Policy::_nil ();
+-  CORBA_Policy_var _tao_safe_retval (_tao_retval);
++  CORBA::Policy_ptr _tao_retval = CORBA::Policy::_nil ();
++  CORBA::Policy_var _tao_safe_retval (_tao_retval);
+   
+   
+   TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+@@ -1318,7 +1123,7 @@
+           if (_invoke_status == TAO_INVOKE_EXCEPTION)
+             {
+               TAO_INTERCEPTOR_THROW_RETURN (
+-                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
++                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                 0
+               );
+               
+@@ -1350,7 +1155,7 @@
+             }
+           
+ #if TAO_HAS_INTERCEPTORS == 1
+-          CORBA_Policy_ptr _tao_retval_info = _tao_safe_retval._retn ();
++          CORBA::Policy_ptr _tao_retval_info = _tao_safe_retval._retn ();
+           ri.result (_tao_retval_info);
+           _tao_safe_retval = _tao_retval_info;
+           
+@@ -1397,8 +1202,8 @@
+ return _tao_safe_retval._retn ();
+ }
+ 
+-void _TAO_CORBA_Policy_Remote_Proxy_Impl::destroy (
+-    CORBA_Object *_collocated_tao_target_,
++void CORBA_TAO_Policy_Remote_Proxy_Impl::destroy (
++    CORBA::Object_ptr _collocated_tao_target_,
+     CORBA::Environment &ACE_TRY_ENV
+   )
+   ACE_THROW_SPEC ((
+@@ -1485,7 +1290,7 @@
+           if (_invoke_status == TAO_INVOKE_EXCEPTION)
+             {
+               TAO_INTERCEPTOR_THROW (
+-                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES)
++                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+               );
+               
+             }
+@@ -1559,37 +1364,37 @@
+ //           Remote & Base  Proxy Broker Implementation
+ //
+ 
+-_TAO_CORBA_Policy_Proxy_Broker::_TAO_CORBA_Policy_Proxy_Broker (void)
++CORBA_TAO_Policy_Proxy_Broker::CORBA_TAO_Policy_Proxy_Broker (void)
+ {
+ }
+ 
+-_TAO_CORBA_Policy_Proxy_Broker::~_TAO_CORBA_Policy_Proxy_Broker (void)
++CORBA_TAO_Policy_Proxy_Broker::~CORBA_TAO_Policy_Proxy_Broker (void)
+ {
+ }
+ 
+-_TAO_CORBA_Policy_Proxy_Broker * (*_TAO_CORBA_Policy_Proxy_Broker_Factory_function_pointer) (
++CORBA_TAO_Policy_Proxy_Broker * (*CORBA_CORBA_TAO_Policy_Proxy_Broker_Factory_function_pointer) (
+     CORBA::Object_ptr obj
+   ) = 0;
+ 
+ // Factory Member function Implementation.
+-_TAO_CORBA_Policy_Remote_Proxy_Broker *
+-_TAO_CORBA_Policy_Remote_Proxy_Broker::the_TAO_CORBA_Policy_Remote_Proxy_Broker (void)
++CORBA_TAO_Policy_Remote_Proxy_Broker *
++CORBA_TAO_Policy_Remote_Proxy_Broker::the_CORBA_TAO_Policy_Remote_Proxy_Broker (void)
+ {
+-  static ::_TAO_CORBA_Policy_Remote_Proxy_Broker remote_proxy_broker;
++  static CORBA_TAO_Policy_Remote_Proxy_Broker remote_proxy_broker;
+   return &remote_proxy_broker;
+ }
+ 
+-_TAO_CORBA_Policy_Remote_Proxy_Broker::_TAO_CORBA_Policy_Remote_Proxy_Broker (void)
++CORBA_TAO_Policy_Remote_Proxy_Broker::CORBA_TAO_Policy_Remote_Proxy_Broker (void)
+ {
+ }
+ 
+-_TAO_CORBA_Policy_Remote_Proxy_Broker::~_TAO_CORBA_Policy_Remote_Proxy_Broker (void)
++CORBA_TAO_Policy_Remote_Proxy_Broker::~CORBA_TAO_Policy_Remote_Proxy_Broker (void)
+ {
+ }
+ 
+-_TAO_CORBA_Policy_Proxy_Impl&
+-_TAO_CORBA_Policy_Remote_Proxy_Broker::select_proxy (
+-  ::CORBA_Policy *,
++CORBA_TAO_Policy_Proxy_Impl&
++CORBA_TAO_Policy_Remote_Proxy_Broker::select_proxy (
++  ::CORBA::Policy *,
+   CORBA::Environment &
+ )
+ {
+@@ -1616,20 +1421,20 @@
+ CORBA_Policy::CORBA_Policy_setup_collocation (int collocated)
+ {
+   if (collocated)
+-    this->the_TAO_CORBA_Policy_Proxy_Broker_ =
+-      ::_TAO_CORBA_Policy_Proxy_Broker_Factory_function_pointer (this);
++    this->the_CORBA_TAO_Policy_Proxy_Broker_ =
++      ::CORBA_CORBA_TAO_Policy_Proxy_Broker_Factory_function_pointer (this);
+   else
+-    this->the_TAO_CORBA_Policy_Proxy_Broker_ =
+-      ::_TAO_CORBA_Policy_Remote_Proxy_Broker::the_TAO_CORBA_Policy_Remote_Proxy_Broker ();
++    this->the_CORBA_TAO_Policy_Proxy_Broker_ =
++      CORBA_TAO_Policy_Remote_Proxy_Broker::the_CORBA_TAO_Policy_Remote_Proxy_Broker ();
+ }
+ 
+-void CORBA_Policy::_tao_any_destructor (void *_tao_void_pointer)
++void CORBA_Policy::_tao_any_destructor (void *x)
+ {
+-  CORBA_Policy *tmp = ACE_static_cast (CORBA_Policy*, _tao_void_pointer);
++  CORBA_Policy *tmp = ACE_static_cast (CORBA_Policy*,x);
+   CORBA::release (tmp);
+ }
+ 
+-CORBA_Policy_ptr CORBA_Policy::_narrow (
++CORBA::Policy_ptr CORBA_Policy::_narrow (
+     CORBA::Object_ptr obj,
+     CORBA::Environment &ACE_TRY_ENV
+   )
+@@ -1638,7 +1443,7 @@
      return CORBA_Policy::_nil ();
    if (! obj->_is_local ())
      {
@@ -274,7 +873,60 @@
        ACE_CHECK_RETURN (CORBA_Policy::_nil ());
        if (is_a == 0)
          return CORBA_Policy::_nil ();
-@@ -1676,7 +1543,7 @@
+@@ -1646,29 +1451,31 @@
+   return CORBA_Policy::_unchecked_narrow (obj, ACE_TRY_ENV);
+ }
+ 
+-CORBA_Policy_ptr CORBA_Policy::_unchecked_narrow (
++CORBA::Policy_ptr CORBA_Policy::_unchecked_narrow (
+     CORBA::Object_ptr obj,
+     CORBA::Environment &
+   )
+ {
+   if (CORBA::is_nil (obj))
+     return CORBA_Policy::_nil ();
++
+   if (! obj->_is_local ())
+     {
+       TAO_Stub* stub = obj->_stubobj ();
+       if (stub)
+         stub->_incr_refcnt ();
++
+       CORBA_Policy_ptr default_proxy = CORBA_Policy::_nil ();
+ 
+       if (
+           !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+           stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+-          obj->_is_collocated () &&_TAO_CORBA_Policy_Proxy_Broker_Factory_function_pointer != 0
++          obj->_is_collocated () &&CORBA_CORBA_TAO_Policy_Proxy_Broker_Factory_function_pointer != 0
+         )
+       {
+         ACE_NEW_RETURN (
+           default_proxy,
+-          ::CORBA_Policy (
++          ::CORBA::Policy (
+             stub,
+             1,
+             obj->_servant ()),
+@@ -1676,7 +1483,7 @@
+           CORBA_Policy::_nil ());
+         }
+       if (CORBA::is_nil (default_proxy))
+-        ACE_NEW_RETURN (default_proxy, ::CORBA_Policy (stub, 0, obj->_servant ()), CORBA_Policy::_nil ());
++        ACE_NEW_RETURN (default_proxy, ::CORBA::Policy (stub, 0, obj->_servant ()), CORBA_Policy::_nil ());
+         return default_proxy;
+       }
+     else 
+@@ -1695,7 +1502,7 @@
+           );
+ }
+ 
+-CORBA_Policy_ptr
++CORBA::Policy_ptr
+ CORBA_Policy::_duplicate (CORBA_Policy_ptr obj)
+ {
+   if (!CORBA::is_nil (obj))
+@@ -1706,14 +1513,14 @@
  CORBA::Boolean CORBA_Policy::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
  {
    if (
@@ -283,7 +935,15 @@
      (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
    return 1; // success using local knowledge
    else
-@@ -1701,7 +1568,19 @@
+     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+ }
+ 
+-void *CORBA_Policy::_tao_QueryInterface (ptr_arith_t type)
++void *CORBA::Policy::_tao_QueryInterface (ptr_arith_t type)
+ {
+   void *retv = 0;
+   if (type == ACE_reinterpret_cast
+@@ -1731,7 +1538,32 @@
  
  const char* CORBA_Policy::_interface_repository_id (void) const
  {
@@ -301,78 +961,397 @@
 +CORBA_Policy::_tao_decode (TAO_InputCDR &)
 +{
 +  return 0;
++}
++
++TAO_Cached_Policy_Type
++CORBA_Policy::_tao_cached_type (void) const
++{
++  // By default, all policies are uncached.
++  return TAO_CACHED_POLICY_UNCACHED;
++}
++
++TAO_Policy_Scope
++CORBA_Policy::_tao_scope (void) const
++{
++  return TAO_POLICY_DEFAULT_SCOPE;
  }
  
  CORBA::PolicyType CORBA_Policy::policy_type (
-@@ -2134,49 +2013,6 @@
- CORBA::TypeCode_ptr _tc_CORBA_PolicyTypeSeq =
-   &_tc_TAO_tc_CORBA_PolicyTypeSeq;
+@@ -1741,8 +1573,8 @@
+     CORBA::SystemException
+   ))
+ {
+-  _TAO_CORBA_Policy_Proxy_Impl &proxy = 
+-    this->the_TAO_CORBA_Policy_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
++  CORBA_TAO_Policy_Proxy_Impl &proxy =
++    this->the_CORBA_TAO_Policy_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+   ACE_CHECK_RETURN (0);
+   
+   return proxy.policy_type (
+@@ -1751,15 +1583,15 @@
+     );
+ }
  
--CORBA_PolicyManager_ptr
--tao_CORBA_PolicyManager_duplicate (
--    CORBA_PolicyManager_ptr p
--  )
--{
--  return CORBA_PolicyManager::_duplicate (p);
--}
--
--void
--tao_CORBA_PolicyManager_release (
--    CORBA_PolicyManager_ptr p
--  )
+-CORBA_Policy_ptr CORBA_Policy::copy (
++CORBA::Policy_ptr CORBA_Policy::copy (
+     CORBA::Environment &ACE_TRY_ENV
+   )
+   ACE_THROW_SPEC ((
+     CORBA::SystemException
+   ))
+ {
+-  _TAO_CORBA_Policy_Proxy_Impl &proxy = 
+-    this->the_TAO_CORBA_Policy_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
++  CORBA_TAO_Policy_Proxy_Impl &proxy =
++    this->the_CORBA_TAO_Policy_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+   ACE_CHECK_RETURN (0);
+   
+   return proxy.copy (
+@@ -1768,15 +1600,15 @@
+     );
+ }
+ 
+-void CORBA_Policy::destroy (
++void CORBA::Policy::destroy (
+     CORBA::Environment &ACE_TRY_ENV
+   )
+   ACE_THROW_SPEC ((
+     CORBA::SystemException
+   ))
+ {
+-  _TAO_CORBA_Policy_Proxy_Impl &proxy = 
+-    this->the_TAO_CORBA_Policy_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
++  CORBA_TAO_Policy_Proxy_Impl &proxy =
++    this->the_CORBA_TAO_Policy_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+   ACE_CHECK;
+   
+   proxy.destroy (
+@@ -1785,37 +1617,6 @@
+     );
+ }
+ 
+-static const CORBA::Long _oc_CORBA_Policy[] =
 -{
--  CORBA::release (p);
--}
+-  TAO_ENCAP_BYTE_ORDER, // byte order
+-  29,
+-  ACE_NTOHL (0x49444c3a), 
+-  ACE_NTOHL (0x6f6d672e), 
+-  ACE_NTOHL (0x6f72672f), 
+-  ACE_NTOHL (0x434f5242), 
+-  ACE_NTOHL (0x415f506f), 
+-  ACE_NTOHL (0x6c696379), 
+-  ACE_NTOHL (0x3a312e30), 
+-  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA_Policy:1.0
+-  13,
+-  ACE_NTOHL (0x434f5242), 
+-  ACE_NTOHL (0x415f506f), 
+-  ACE_NTOHL (0x6c696379), 
+-  ACE_NTOHL (0x0),  // name = CORBA_Policy
+-};
 -
--CORBA_PolicyManager_ptr
--tao_CORBA_PolicyManager_nil (
--    void
--  )
--{
--  return CORBA_PolicyManager::_nil ();
--}
+-static CORBA::TypeCode _tc_TAO_tc_CORBA_Policy (
+-    CORBA::tk_objref,
+-    sizeof (_oc_CORBA_Policy),
+-    (char *) &_oc_CORBA_Policy,
+-    0,
+-    sizeof (CORBA_Policy)
+-  );
 -
--CORBA_PolicyManager_ptr
--tao_CORBA_PolicyManager_narrow (
--    CORBA::Object *p,
--    CORBA::Environment &ACE_TRY_ENV
--  )
--{
--  return CORBA_PolicyManager::_narrow (p, ACE_TRY_ENV);
--}
+-CORBA::TypeCode_ptr _tc_CORBA_Policy =
+-  &_tc_TAO_tc_CORBA_Policy;
 -
--CORBA::Object *
--tao_CORBA_PolicyManager_upcast (
--    void *src
--  )
--{
--  CORBA_PolicyManager **tmp =
--    ACE_static_cast (CORBA_PolicyManager **, src);
--  return *tmp;
--}
 -
+ #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+ 
+ #if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_POLICYLIST_CS_)
+@@ -1825,17 +1626,17 @@
+ void
+ _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_allocate_buffer (CORBA::ULong length)
+ {
+-  CORBA_Policy **tmp = 0;
++    CORBA::Policy **tmp = 0;
+   tmp = _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::allocbuf (length);
+   
+   if (this->buffer_ != 0)
+   {
+-    CORBA_Policy **old = ACE_reinterpret_cast (CORBA_Policy**, this->buffer_);
++      CORBA::Policy **old = ACE_reinterpret_cast (CORBA::Policy**, this->buffer_);
+     for (CORBA::ULong i = 0; i < this->length_; ++i)
+       {
+         if (!this->release_)
+           {
+-            tmp[i] = CORBA_Policy::_duplicate (old[i]);
++              tmp[i] = CORBA::Policy::_duplicate (old[i]);
+           }
+         else
+           {
+@@ -1856,12 +1657,12 @@
+ {
+   if (this->buffer_ == 0 || this->release_ == 0)
+     return;
+-  CORBA_Policy **tmp = ACE_reinterpret_cast (CORBA_Policy**, this->buffer_);
++    CORBA::Policy **tmp = ACE_reinterpret_cast (CORBA::Policy**, this->buffer_);
+   
+   for (CORBA::ULong i = 0; i < this->length_; ++i)
+     {
+       CORBA::release (tmp[i]);
+-      tmp[i] = CORBA_Policy::_nil ();
++        tmp[i] = CORBA::Policy::_nil ();
+     }
+   
+   _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::freebuf (tmp);
+@@ -1876,12 +1677,12 @@
+ void
+ _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+ {
+-  CORBA_Policy **tmp = ACE_reinterpret_cast (CORBA_Policy**, this->buffer_);
++    CORBA::Policy **tmp = ACE_reinterpret_cast (CORBA::Policy**, this->buffer_);
+   
+   for (CORBA::ULong i = nl; i < ol; ++i)
+     {
+       CORBA::release (tmp[i]);
+-      tmp[i] = CORBA_Policy::_nil ();
++        tmp[i] = CORBA::Policy::_nil ();
+     }
+ }
+ 
+@@ -1892,15 +1693,15 @@
+     CORBA_Environment &ACE_TRY_ENV
+   )
+ {
+-  CORBA_Policy **tmp = ACE_static_cast (CORBA_Policy**, target);
+-  *tmp = CORBA_Policy::_narrow (src, ACE_TRY_ENV);
++    CORBA::Policy **tmp = ACE_static_cast (CORBA::Policy**, target);
++    *tmp = CORBA::Policy::_narrow (src, ACE_TRY_ENV);
+   ACE_CHECK;
+ }
+ 
+ CORBA_Object*
+ _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_upcast (void *src) const
+ {
+-  CORBA_Policy **tmp = ACE_static_cast (CORBA_Policy**, src);
++    CORBA::Policy **tmp = ACE_static_cast (CORBA::Policy**, src);
+   return *tmp;
+ }
+ 
+@@ -1913,7 +1714,7 @@
+ #define _CORBA_POLICYLIST_CS_
+ 
  // *************************************************************
- // Operations for class CORBA_PolicyManager_var
+-// CORBA_PolicyList
++// CORBA::PolicyList
  // *************************************************************
-@@ -2299,9 +2135,8 @@
-     ACE_static_cast (CORBA_PolicyManager **, src);
-   return *tmp;
+ 
+ CORBA_PolicyList::CORBA_PolicyList (void)
+@@ -1923,16 +1724,16 @@
+ #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+ _TAO_Unbounded_Object_Sequence_CORBA_PolicyList
+ #else /* TAO_USE_SEQUENCE_TEMPLATES */
+-TAO_Unbounded_Object_Sequence<CORBA_Policy,CORBA_Policy_var>
++  TAO_Unbounded_Object_Sequence<CORBA::Policy,CORBA::Policy_var>
+ #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  (max)
+ {}
+-CORBA_PolicyList::CORBA_PolicyList (CORBA::ULong max, CORBA::ULong length, CORBA_Policy_ptr *buffer, CORBA::Boolean release)
++CORBA_PolicyList::CORBA_PolicyList (CORBA::ULong max, CORBA::ULong length, CORBA::Policy_ptr *buffer, CORBA::Boolean release)
+   : 
+ #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+ _TAO_Unbounded_Object_Sequence_CORBA_PolicyList
+ #else /* TAO_USE_SEQUENCE_TEMPLATES */
+-TAO_Unbounded_Object_Sequence<CORBA_Policy,CORBA_Policy_var>
++  TAO_Unbounded_Object_Sequence<CORBA::Policy,CORBA::Policy_var>
+ #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  (max, length, buffer, release)
+ {}
+@@ -1941,77 +1742,21 @@
+ #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+ _TAO_Unbounded_Object_Sequence_CORBA_PolicyList
+ #else /* TAO_USE_SEQUENCE_TEMPLATES */
+-TAO_Unbounded_Object_Sequence<CORBA_Policy,CORBA_Policy_var>
++  TAO_Unbounded_Object_Sequence<CORBA::Policy,CORBA::Policy_var>
+ #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  (seq)
+ {}
+ CORBA_PolicyList::~CORBA_PolicyList (void) // dtor
+ {}
+-void CORBA_PolicyList::_tao_any_destructor (void *_tao_void_pointer)
++void CORBA_PolicyList::_tao_any_destructor (void *x)
+ {
+-  CORBA_PolicyList *tmp = ACE_static_cast (CORBA_PolicyList*, _tao_void_pointer);
++  CORBA_PolicyList *tmp = ACE_static_cast (CORBA_PolicyList*,x);
+   delete tmp;
  }
+ 
+ 
+ #endif /* end #if !defined */
+ 
+-static const CORBA::Long _oc_CORBA_PolicyList[] =
+-{
+-  TAO_ENCAP_BYTE_ORDER, // byte order
+-  33,
+-  ACE_NTOHL (0x49444c3a), 
+-  ACE_NTOHL (0x6f6d672e), 
+-  ACE_NTOHL (0x6f72672f), 
+-  ACE_NTOHL (0x434f5242), 
+-  ACE_NTOHL (0x415f506f), 
+-  ACE_NTOHL (0x6c696379), 
+-  ACE_NTOHL (0x4c697374), 
+-  ACE_NTOHL (0x3a312e30), 
+-  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA_PolicyList:1.0
+-  17,
+-  ACE_NTOHL (0x434f5242), 
+-  ACE_NTOHL (0x415f506f), 
+-  ACE_NTOHL (0x6c696379), 
+-  ACE_NTOHL (0x4c697374), 
+-  ACE_NTOHL (0x0),  // name = CORBA_PolicyList
+-  CORBA::tk_sequence, // typecode kind
+-  76, // encapsulation length
+-    TAO_ENCAP_BYTE_ORDER, // byte order
+-    CORBA::tk_objref, // typecode kind
+-    60, // encapsulation length
+-      TAO_ENCAP_BYTE_ORDER, // byte order
+-      29,
+-      ACE_NTOHL (0x49444c3a), 
+-      ACE_NTOHL (0x6f6d672e), 
+-      ACE_NTOHL (0x6f72672f), 
+-      ACE_NTOHL (0x434f5242), 
+-      ACE_NTOHL (0x415f506f), 
+-      ACE_NTOHL (0x6c696379), 
+-      ACE_NTOHL (0x3a312e30), 
+-      ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA_Policy:1.0
+-      13,
+-      ACE_NTOHL (0x434f5242), 
+-      ACE_NTOHL (0x415f506f), 
+-      ACE_NTOHL (0x6c696379), 
+-      ACE_NTOHL (0x0),  // name = CORBA_Policy
+-
+-    0U,
+-
+-};
+-
+-static CORBA::TypeCode _tc_TAO_tc_CORBA_PolicyList (
+-    CORBA::tk_alias,
+-    sizeof (_oc_CORBA_PolicyList),
+-    (char *) &_oc_CORBA_PolicyList,
+-    0,
+-    sizeof (CORBA_PolicyList)
+-  );
 -
+-CORBA::TypeCode_ptr _tc_CORBA_PolicyList =
+-  &_tc_TAO_tc_CORBA_PolicyList;
+-
+-
+ #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+ 
+ #if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_POLICYTYPESEQ_CS_)
+@@ -2064,7 +1809,7 @@
+ #define _CORBA_POLICYTYPESEQ_CS_
+ 
  // *************************************************************
--// Inline operations for class CORBA_PolicyManager_out
-+// Operations for class CORBA_PolicyManager_out
+-// CORBA_PolicyTypeSeq
++// CORBA::PolicyTypeSeq
  // *************************************************************
  
- CORBA_PolicyManager_out::CORBA_PolicyManager_out (CORBA_PolicyManager_ptr &p)
-@@ -2425,345 +2260,9 @@
+ CORBA_PolicyTypeSeq::CORBA_PolicyTypeSeq (void)
+@@ -2098,72 +1843,15 @@
+ {}
+ CORBA_PolicyTypeSeq::~CORBA_PolicyTypeSeq (void) // dtor
+ {}
+-void CORBA_PolicyTypeSeq::_tao_any_destructor (void *_tao_void_pointer)
++void CORBA_PolicyTypeSeq::_tao_any_destructor (void *x)
+ {
+-  CORBA_PolicyTypeSeq *tmp = ACE_static_cast (CORBA_PolicyTypeSeq*, _tao_void_pointer);
++  CORBA_PolicyTypeSeq *tmp = ACE_static_cast (CORBA_PolicyTypeSeq*,x);
+   delete tmp;
+ }
  
- const char* CORBA_PolicyManager::_interface_repository_id (void) const
+ 
+ #endif /* end #if !defined */
+ 
+-static const CORBA::Long _oc_CORBA_PolicyTypeSeq[] =
+-{
+-  TAO_ENCAP_BYTE_ORDER, // byte order
+-  36,
+-  ACE_NTOHL (0x49444c3a), 
+-  ACE_NTOHL (0x6f6d672e), 
+-  ACE_NTOHL (0x6f72672f), 
+-  ACE_NTOHL (0x434f5242), 
+-  ACE_NTOHL (0x415f506f), 
+-  ACE_NTOHL (0x6c696379), 
+-  ACE_NTOHL (0x54797065), 
+-  ACE_NTOHL (0x5365713a), 
+-  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA_PolicyTypeSeq:1.0
+-  20,
+-  ACE_NTOHL (0x434f5242), 
+-  ACE_NTOHL (0x415f506f), 
+-  ACE_NTOHL (0x6c696379), 
+-  ACE_NTOHL (0x54797065), 
+-  ACE_NTOHL (0x53657100),  // name = CORBA_PolicyTypeSeq
+-  CORBA::tk_sequence, // typecode kind
+-  80, // encapsulation length
+-    TAO_ENCAP_BYTE_ORDER, // byte order
+-    CORBA::tk_alias, // typecode kind for typedefs
+-    64, // encapsulation length
+-      TAO_ENCAP_BYTE_ORDER, // byte order
+-      33,
+-      ACE_NTOHL (0x49444c3a), 
+-      ACE_NTOHL (0x6f6d672e), 
+-      ACE_NTOHL (0x6f72672f), 
+-      ACE_NTOHL (0x434f5242), 
+-      ACE_NTOHL (0x412f506f), 
+-      ACE_NTOHL (0x6c696379), 
+-      ACE_NTOHL (0x54797065), 
+-      ACE_NTOHL (0x3a312e30), 
+-      ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/PolicyType:1.0
+-      11,
+-      ACE_NTOHL (0x506f6c69), 
+-      ACE_NTOHL (0x63795479), 
+-      ACE_NTOHL (0x70650000),  // name = PolicyType
+-      CORBA::tk_ulong,
+-
+-
+-    0U,
+-
+-};
+-
+-static CORBA::TypeCode _tc_TAO_tc_CORBA_PolicyTypeSeq (
+-    CORBA::tk_alias,
+-    sizeof (_oc_CORBA_PolicyTypeSeq),
+-    (char *) &_oc_CORBA_PolicyTypeSeq,
+-    0,
+-    sizeof (CORBA_PolicyTypeSeq)
+-  );
+-
+-CORBA::TypeCode_ptr _tc_CORBA_PolicyTypeSeq =
+-  &_tc_TAO_tc_CORBA_PolicyTypeSeq;
+-
+ CORBA_PolicyManager_ptr
+ tao_CORBA_PolicyManager_duplicate (
+     CORBA_PolicyManager_ptr p
+@@ -2404,7 +2092,7 @@
+     CORBA::Environment &ACE_TRY_ENV
+   )
  {
--  return "IDL:omg.org/CORBA_PolicyManager:1.0";
-+  return "IDL:omg.org/CORBA/PolicyManager:1.0";
+-  return CORBA_PolicyManager::_unchecked_narrow (obj, ACE_TRY_ENV);
++  return CORBA::PolicyManager::_unchecked_narrow (obj, ACE_TRY_ENV);
  }
  
+ CORBA_PolicyManager_ptr CORBA_PolicyManager::_unchecked_narrow (
+@@ -2414,6 +2102,7 @@
+ {
+   if (CORBA::is_nil (obj))
+     return CORBA_PolicyManager::_nil ();
++
+   return
+       ACE_reinterpret_cast
+         (
+@@ -2455,320 +2144,26 @@
+ 
+ const char* CORBA_PolicyManager::_interface_repository_id (void) const
+ {
+-  return "IDL:omg.org/CORBA_PolicyManager:1.0";
+-}
+-
 -CORBA_Current_ptr
 -tao_CORBA_Current_duplicate (
 -    CORBA_Current_ptr p
@@ -540,7 +1519,7 @@
 -}
 -
 -// *************************************************************
--// Inline operations for class CORBA_Current_out
+-// Operations for class CORBA_Current_out
 -// *************************************************************
 -
 -CORBA_Current_out::CORBA_Current_out (CORBA_Current_ptr &p)
@@ -665,74 +1644,170 @@
 -const char* CORBA_Current::_interface_repository_id (void) const
 -{
 -  return "IDL:omg.org/CORBA_Current:1.0";
--}
--
++  return "IDL:omg.org/CORBA/PolicyManager:1.0";
+ }
+ 
 -CORBA_PolicyCurrent_ptr
--tao_CORBA_PolicyCurrent_duplicate (
++CORBA::PolicyCurrent_ptr
+ tao_CORBA_PolicyCurrent_duplicate (
 -    CORBA_PolicyCurrent_ptr p
--  )
--{
++    CORBA::PolicyCurrent_ptr p
+   )
+ {
 -  return CORBA_PolicyCurrent::_duplicate (p);
--}
--
--void
--tao_CORBA_PolicyCurrent_release (
++  return CORBA::PolicyCurrent::_duplicate (p);
+ }
+ 
+ void
+ tao_CORBA_PolicyCurrent_release (
 -    CORBA_PolicyCurrent_ptr p
--  )
--{
--  CORBA::release (p);
--}
--
++    CORBA::PolicyCurrent_ptr p
+   )
+ {
+   CORBA::release (p);
+ }
+ 
 -CORBA_PolicyCurrent_ptr
--tao_CORBA_PolicyCurrent_nil (
--    void
--  )
--{
--  return CORBA_PolicyCurrent::_nil ();
++CORBA::PolicyCurrent_ptr
+ tao_CORBA_PolicyCurrent_nil (
+     void
+   )
+@@ -3002,6 +2397,7 @@
+ {
+   if (CORBA::is_nil (obj))
+     return CORBA_PolicyCurrent::_nil ();
++
+   return
+       ACE_reinterpret_cast
+         (
+@@ -3052,7 +2448,7 @@
+         void *,
+         ACE_static_cast
+           (
+-            CORBA_Current_ptr,
++            CORBA::Current_ptr,
+             this
+           )
+       );
+@@ -3067,90 +2463,50 @@
+ 
+ const char* CORBA_PolicyCurrent::_interface_repository_id (void) const
+ {
+-  return "IDL:omg.org/CORBA_PolicyCurrent:1.0";
 -}
 -
--CORBA_PolicyCurrent_ptr
--tao_CORBA_PolicyCurrent_narrow (
--    CORBA::Object *p,
--    CORBA::Environment &ACE_TRY_ENV
--  )
+-void operator<<= (CORBA::Any &_tao_any, CORBA::SetOverrideType _tao_elem)
 -{
--  return CORBA_PolicyCurrent::_narrow (p, ACE_TRY_ENV);
+-  TAO_OutputCDR stream;
+-  stream << _tao_elem;
+-  _tao_any._tao_replace (
+-      CORBA::_tc_SetOverrideType,
+-      TAO_ENCAP_BYTE_ORDER,
+-      stream.begin ()
+-    );
 -}
 -
--CORBA::Object *
--tao_CORBA_PolicyCurrent_upcast (
--    void *src
--  )
+-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::SetOverrideType &_tao_elem)
 -{
--  CORBA_PolicyCurrent **tmp =
--    ACE_static_cast (CORBA_PolicyCurrent **, src);
--  return *tmp;
--}
+-  ACE_TRY_NEW_ENV
+-  {
+-    CORBA::TypeCode_var type = _tao_any.type ();
+-    
+-    CORBA::Boolean result = type->equivalent (CORBA::_tc_SetOverrideType, ACE_TRY_ENV);
+-    ACE_TRY_CHECK;
+-    
+-    if (!result)
+-      return 0; // not equivalent
+-    
+-    TAO_InputCDR stream (
+-        _tao_any._tao_get_cdr (),
+-        _tao_any._tao_byte_order ()
+-      );
+-    if (stream >> _tao_elem)
+-    {
+-      return 1;
+-    }
+-  }
+-  ACE_CATCHANY
+-  {
+-    return 0;
+-  }
+-  ACE_ENDTRY;
+-  return 0;
++  return "IDL:omg.org/CORBA/PolicyCurrent:1.0";
+ }
  
- // *************************************************************
- // Operations for class CORBA_PolicyCurrent_var
-@@ -2887,9 +2386,8 @@
-     ACE_static_cast (CORBA_PolicyCurrent **, src);
-   return *tmp;
+-void operator<<= (CORBA::Any &_tao_any, const CORBA_PolicyError &_tao_elem) // copying
++void operator<<= (CORBA::Any &_tao_any, const CORBA::PolicyError &_tao_elem) // copying
+ {
+   TAO_OutputCDR stream;
+   stream << _tao_elem;
+   _tao_any._tao_replace (
+-      _tc_CORBA_PolicyError,
++      CORBA::_tc_PolicyError,
+       TAO_ENCAP_BYTE_ORDER,
+       stream.begin ()
+     );
  }
--
- // *************************************************************
--// Inline operations for class CORBA_PolicyCurrent_out
-+// Operations for class CORBA_PolicyCurrent_out
- // *************************************************************
  
- CORBA_PolicyCurrent_out::CORBA_PolicyCurrent_out (CORBA_PolicyCurrent_ptr &p)
-@@ -3037,7 +2535,7 @@
+-void operator<<= (CORBA::Any &_tao_any, CORBA_PolicyError *_tao_elem) // non copying
++void operator<<= (CORBA::Any &_tao_any, CORBA::PolicyError *_tao_elem) // non copying
+ {
+   TAO_OutputCDR stream;
+   stream << *_tao_elem;
+   _tao_any._tao_replace (
+-      _tc_CORBA_PolicyError,
++      CORBA::_tc_PolicyError,
+       TAO_ENCAP_BYTE_ORDER,
+       stream.begin (),
+       1,
+       _tao_elem,
+-      CORBA_PolicyError::_tao_any_destructor
++      CORBA::PolicyError::_tao_any_destructor
+     );
+ }
  
- const char* CORBA_PolicyCurrent::_interface_repository_id (void) const
+-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyError *&_tao_elem)
++CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PolicyError *&_tao_elem)
  {
--  return "IDL:omg.org/CORBA_PolicyCurrent:1.0";
-+  return "IDL:omg.org/CORBA/PolicyCurrent:1.0";
+   return _tao_any >>= ACE_const_cast(
+-      const CORBA_PolicyError*&,
++      const CORBA::PolicyError*&,
+       _tao_elem
+     );
  }
  
- void operator<<= (CORBA::Any &_tao_any, CORBA::SetOverrideType _tao_elem)
-@@ -3144,7 +2642,7 @@
+-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_PolicyError *&_tao_elem)
++CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::PolicyError *&_tao_elem)
+ {
+   _tao_elem = 0;
+   ACE_TRY_NEW_ENV
+   {
+     CORBA::TypeCode_var type = _tao_any.type ();
+     
+-    CORBA::Boolean result = type->equivalent (_tc_CORBA_PolicyError, ACE_TRY_ENV);
++    CORBA::Boolean result = type->equivalent (CORBA::_tc_PolicyError, ACE_TRY_ENV);
+     ACE_TRY_CHECK;
+     
+     if (!result)
+@@ -3158,13 +2514,13 @@
+     
+     if (_tao_any.any_owns_data ())
+     {
+-      _tao_elem = (CORBA_PolicyError *)_tao_any.value ();
++      _tao_elem = (CORBA::PolicyError *)_tao_any.value ();
+       return 1;
+     }
+     else
+     {
+-      CORBA_PolicyError *tmp;
+-      ACE_NEW_RETURN (tmp, CORBA_PolicyError, 0);
++      CORBA::PolicyError *tmp;
++      ACE_NEW_RETURN (tmp, CORBA::PolicyError, 0);
+       TAO_InputCDR stream (
+           _tao_any._tao_get_cdr (),
+           _tao_any._tao_byte_order ()
+@@ -3174,15 +2530,15 @@
          return 0;
        if (ACE_OS::strcmp (
            interface_repository_id.in (),
@@ -741,7 +1816,44 @@
          return 0;
        if (stream >> *tmp)
        {
-@@ -3234,7 +2732,7 @@
+         ((CORBA::Any *)&_tao_any)->_tao_replace (
+-            _tc_CORBA_PolicyError,
++            CORBA::_tc_PolicyError,
+             1,
+             tmp,
+-            CORBA_PolicyError::_tao_any_destructor
++            CORBA::PolicyError::_tao_any_destructor
+           );
+         _tao_elem = tmp;
+         return 1;
+@@ -3205,7 +2561,7 @@
+   TAO_OutputCDR stream;
+   stream << _tao_elem;
+   _tao_any._tao_replace (
+-      _tc_CORBA_InvalidPolicies,
++      CORBA::_tc_InvalidPolicies,
+       TAO_ENCAP_BYTE_ORDER,
+       stream.begin ()
+     );
+@@ -3216,7 +2572,7 @@
+   TAO_OutputCDR stream;
+   stream << *_tao_elem;
+   _tao_any._tao_replace (
+-      _tc_CORBA_InvalidPolicies,
++      CORBA::_tc_InvalidPolicies,
+       TAO_ENCAP_BYTE_ORDER,
+       stream.begin (),
+       1,
+@@ -3240,7 +2596,7 @@
+   {
+     CORBA::TypeCode_var type = _tao_any.type ();
+     
+-    CORBA::Boolean result = type->equivalent (_tc_CORBA_InvalidPolicies, ACE_TRY_ENV);
++    CORBA::Boolean result = type->equivalent (CORBA::_tc_InvalidPolicies, ACE_TRY_ENV);
+     ACE_TRY_CHECK;
+     
+     if (!result)
+@@ -3264,12 +2620,12 @@
          return 0;
        if (ACE_OS::strcmp (
            interface_repository_id.in (),
@@ -750,7 +1862,315 @@
          return 0;
        if (stream >> *tmp)
        {
-@@ -3512,13 +3010,6 @@
+         ((CORBA::Any *)&_tao_any)->_tao_replace (
+-            _tc_CORBA_InvalidPolicies,
++            CORBA::_tc_InvalidPolicies,
+             1,
+             tmp,
+             CORBA_InvalidPolicies::_tao_any_destructor
+@@ -3290,30 +2646,30 @@
+   return 0;
+ }
+ 
+-void operator<<= (CORBA::Any &_tao_any, CORBA_Policy_ptr _tao_elem)
++void operator<<= (CORBA::Any &_tao_any, CORBA::Policy_ptr _tao_elem)
+ {
+   TAO_OutputCDR stream;
+   if (stream << _tao_elem)
+   {
+     _tao_any._tao_replace (
+-        _tc_CORBA_Policy, 
++        CORBA::_tc_Policy,
+         TAO_ENCAP_BYTE_ORDER,
+         stream.begin (),
+         1,
+-        CORBA_Policy::_duplicate (_tao_elem),
+-        CORBA_Policy::_tao_any_destructor
++        CORBA::Policy::_duplicate (_tao_elem),
++        CORBA::Policy::_tao_any_destructor
+       );
+   }
+ }
+ 
+-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_Policy_ptr &_tao_elem)
++CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Policy_ptr &_tao_elem)
+ {
+   ACE_TRY_NEW_ENV
+   {
+-    _tao_elem = CORBA_Policy::_nil ();
++    _tao_elem = CORBA::Policy::_nil ();
+     CORBA::TypeCode_var type = _tao_any.type ();
+     
+-    CORBA::Boolean result = type->equivalent (_tc_CORBA_Policy, ACE_TRY_ENV);
++    CORBA::Boolean result = type->equivalent (CORBA::_tc_Policy, ACE_TRY_ENV);
+     ACE_TRY_CHECK;
+     
+     if (!result)
+@@ -3326,77 +2682,77 @@
+     if (stream >> _tao_elem)
+     {
+       ((CORBA::Any *)&_tao_any)->_tao_replace (
+-          _tc_CORBA_Policy,
++          CORBA::_tc_Policy,
+           1,
+           _tao_elem,
+-          CORBA_Policy::_tao_any_destructor
++          CORBA::Policy::_tao_any_destructor
+         );
+       return 1;
+     }
+   }
+   ACE_CATCHANY
+   {
+-    _tao_elem = CORBA_Policy::_nil ();
++    _tao_elem = CORBA::Policy::_nil ();
+     return 0;
+   }
+   ACE_ENDTRY;
+-  _tao_elem = CORBA_Policy::_nil ();
++  _tao_elem = CORBA::Policy::_nil ();
+   return 0;
+ }
+ 
+ #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+     defined (ACE_HAS_GNU_REPO)
+-    template class TAO_Object_Manager<CORBA_Policy,CORBA_Policy_var>;
++    template class TAO_Object_Manager<CORBA::Policy,CORBA::Policy_var>;
+   #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+-  #  pragma instantiate TAO_Object_Manager<CORBA_Policy,CORBA_Policy_var>
++  #  pragma instantiate TAO_Object_Manager<CORBA::Policy,CORBA::Policy_var>
+ #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+ 
+ void operator<<= (
+     CORBA::Any &_tao_any,
+-    const CORBA_PolicyList &_tao_elem
++    const CORBA::PolicyList &_tao_elem
+   ) // copying
+ {
+   TAO_OutputCDR stream;
+   if (stream << _tao_elem)
+   {
+     _tao_any._tao_replace (
+-        _tc_CORBA_PolicyList,
++        CORBA::_tc_PolicyList,
+         TAO_ENCAP_BYTE_ORDER,
+         stream.begin ()
+       );
+   }
+ }
+ 
+-void operator<<= (CORBA::Any &_tao_any, CORBA_PolicyList *_tao_elem) // non copying
++void operator<<= (CORBA::Any &_tao_any, CORBA::PolicyList *_tao_elem) // non copying
+ {
+   TAO_OutputCDR stream;
+   stream << *_tao_elem;
+   _tao_any._tao_replace (
+-      _tc_CORBA_PolicyList,
++      CORBA::_tc_PolicyList,
+       TAO_ENCAP_BYTE_ORDER,
+       stream.begin (),
+       1,
+       _tao_elem,
+-      CORBA_PolicyList::_tao_any_destructor
++      CORBA::PolicyList::_tao_any_destructor
+     );
+ }
+ 
+-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyList *&_tao_elem)
++CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PolicyList *&_tao_elem)
+ {
+   return _tao_any >>= ACE_const_cast(
+-      const CORBA_PolicyList*&,
++      const CORBA::PolicyList*&,
+       _tao_elem
+     );
+ }
+ 
+-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_PolicyList *&_tao_elem)
++CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::PolicyList *&_tao_elem)
+ {
+   _tao_elem = 0;
+   ACE_TRY_NEW_ENV
+   {
+     CORBA::TypeCode_var type = _tao_any.type ();
+     
+-    CORBA::Boolean result = type->equivalent (_tc_CORBA_PolicyList, ACE_TRY_ENV);
++    CORBA::Boolean result = type->equivalent (CORBA::_tc_PolicyList, ACE_TRY_ENV);
+     ACE_TRY_CHECK;
+     
+     if (!result)
+@@ -3405,15 +2761,15 @@
+     if (_tao_any.any_owns_data ())
+     {
+       _tao_elem = ACE_static_cast(
+-          const CORBA_PolicyList*,
++          const CORBA::PolicyList*,
+           _tao_any.value ()
+         );
+       return 1;
+     }
+     else
+     {
+-      CORBA_PolicyList *tmp;
+-      ACE_NEW_RETURN (tmp, CORBA_PolicyList, 0);
++      CORBA::PolicyList *tmp;
++      ACE_NEW_RETURN (tmp, CORBA::PolicyList, 0);
+       TAO_InputCDR stream (
+           _tao_any._tao_get_cdr (),
+           _tao_any._tao_byte_order ()
+@@ -3421,10 +2777,10 @@
+       if (stream >> *tmp)
+       {
+         ((CORBA::Any *)&_tao_any)->_tao_replace (
+-            _tc_CORBA_PolicyList,
++            CORBA::_tc_PolicyList,
+             1,
+             ACE_static_cast (void *, tmp),
+-            CORBA_PolicyList::_tao_any_destructor
++            CORBA::PolicyList::_tao_any_destructor
+           );
+         _tao_elem = tmp;
+         return 1;
+@@ -3444,50 +2800,50 @@
+ 
+ void operator<<= (
+     CORBA::Any &_tao_any,
+-    const CORBA_PolicyTypeSeq &_tao_elem
++    const CORBA::PolicyTypeSeq &_tao_elem
+   ) // copying
+ {
+   TAO_OutputCDR stream;
+   if (stream << _tao_elem)
+   {
+     _tao_any._tao_replace (
+-        _tc_CORBA_PolicyTypeSeq,
++        CORBA::_tc_PolicyTypeSeq,
+         TAO_ENCAP_BYTE_ORDER,
+         stream.begin ()
+       );
+   }
+ }
+ 
+-void operator<<= (CORBA::Any &_tao_any, CORBA_PolicyTypeSeq *_tao_elem) // non copying
++void operator<<= (CORBA::Any &_tao_any, CORBA::PolicyTypeSeq *_tao_elem) // non copying
+ {
+   TAO_OutputCDR stream;
+   stream << *_tao_elem;
+   _tao_any._tao_replace (
+-      _tc_CORBA_PolicyTypeSeq,
++      CORBA::_tc_PolicyTypeSeq,
+       TAO_ENCAP_BYTE_ORDER,
+       stream.begin (),
+       1,
+       _tao_elem,
+-      CORBA_PolicyTypeSeq::_tao_any_destructor
++      CORBA::PolicyTypeSeq::_tao_any_destructor
+     );
+ }
+ 
+-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyTypeSeq *&_tao_elem)
++CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PolicyTypeSeq *&_tao_elem)
+ {
+   return _tao_any >>= ACE_const_cast(
+-      const CORBA_PolicyTypeSeq*&,
++      const CORBA::PolicyTypeSeq*&,
+       _tao_elem
+     );
+ }
+ 
+-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_PolicyTypeSeq *&_tao_elem)
++CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::PolicyTypeSeq *&_tao_elem)
+ {
+   _tao_elem = 0;
+   ACE_TRY_NEW_ENV
+   {
+     CORBA::TypeCode_var type = _tao_any.type ();
+     
+-    CORBA::Boolean result = type->equivalent (_tc_CORBA_PolicyTypeSeq, ACE_TRY_ENV);
++    CORBA::Boolean result = type->equivalent (CORBA::_tc_PolicyTypeSeq, ACE_TRY_ENV);
+     ACE_TRY_CHECK;
+     
+     if (!result)
+@@ -3496,15 +2852,15 @@
+     if (_tao_any.any_owns_data ())
+     {
+       _tao_elem = ACE_static_cast(
+-          const CORBA_PolicyTypeSeq*,
++          const CORBA::PolicyTypeSeq*,
+           _tao_any.value ()
+         );
+       return 1;
+     }
+     else
+     {
+-      CORBA_PolicyTypeSeq *tmp;
+-      ACE_NEW_RETURN (tmp, CORBA_PolicyTypeSeq, 0);
++      CORBA::PolicyTypeSeq *tmp;
++      ACE_NEW_RETURN (tmp, CORBA::PolicyTypeSeq, 0);
+       TAO_InputCDR stream (
+           _tao_any._tao_get_cdr (),
+           _tao_any._tao_byte_order ()
+@@ -3512,10 +2868,10 @@
+       if (stream >> *tmp)
+       {
+         ((CORBA::Any *)&_tao_any)->_tao_replace (
+-            _tc_CORBA_PolicyTypeSeq,
++            CORBA::_tc_PolicyTypeSeq,
+             1,
+             ACE_static_cast (void *, tmp),
+-            CORBA_PolicyTypeSeq::_tao_any_destructor
++            CORBA::PolicyTypeSeq::_tao_any_destructor
+           );
+         _tao_elem = tmp;
+         return 1;
+@@ -3533,6 +2889,46 @@
+   return 0;
+ }
+ 
++void operator<<= (CORBA::Any &_tao_any, CORBA::SetOverrideType _tao_elem)
++{
++  TAO_OutputCDR stream;
++  stream << _tao_elem;
++  _tao_any._tao_replace (
++      CORBA::_tc_SetOverrideType,
++      TAO_ENCAP_BYTE_ORDER,
++      stream.begin ()
++    );
++}
++
++CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::SetOverrideType &_tao_elem)
++{
++  ACE_TRY_NEW_ENV
++  {
++    CORBA::TypeCode_var type = _tao_any.type ();
++
++    CORBA::Boolean result = type->equivalent (CORBA::_tc_SetOverrideType, ACE_TRY_ENV);
++    ACE_TRY_CHECK;
++
++    if (!result)
++      return 0; // not equivalent
++
++    TAO_InputCDR stream (
++        _tao_any._tao_get_cdr (),
++        _tao_any._tao_byte_order ()
++      );
++    if (stream >> _tao_elem)
++    {
++      return 1;
++    }
++  }
++  ACE_CATCHANY
++  {
++    return 0;
++  }
++  ACE_ENDTRY;
++  return 0;
++}
++
+ #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+     defined (ACE_HAS_GNU_REPO)
+     template class TAO_Object_Manager<CORBA_PolicyManager,CORBA_PolicyManager_var>;
+@@ -3542,13 +2938,6 @@
  
  #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
      defined (ACE_HAS_GNU_REPO)
@@ -764,41 +2184,70 @@
      template class TAO_Object_Manager<CORBA_PolicyCurrent,CORBA_PolicyCurrent_var>;
    #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
    #  pragma instantiate TAO_Object_Manager<CORBA_PolicyCurrent,CORBA_PolicyCurrent_var>
-@@ -3554,11 +3045,6 @@
-     // If length is 0 we return true.
-     if (0 >= _tao_seq_len) 
-       return 1;
--    // Add a check to the length of the sequence
--    // to make sure it does not exceed the length
--    // of the stream. (See bug 58.)
--    if (_tao_seq_len > strm.length())
--      return 0;
-     // retrieve all the elements
-     return strm.read_ushort_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
-   }
-@@ -3634,11 +3120,6 @@
-     // If length is 0 we return true.
-     if (0 >= _tao_seq_len) 
-       return 1;
--    // Add a check to the length of the sequence
--    // to make sure it does not exceed the length
--    // of the stream. (See bug 58.)
--    if (_tao_seq_len > strm.length())
--      return 0;
-     // retrieve all the elements
-     CORBA::Boolean _tao_marshal_flag = 1;
-     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-@@ -3676,14 +3157,8 @@
-     // If length is 0 we return true.
-     if (0 >= _tao_seq_len) 
-       return 1;
--    // Add a check to the length of the sequence
--    // to make sure it does not exceed the length
--    // of the stream. (See bug 58.)
--    if (_tao_seq_len > strm.length())
--      return 0;
-     // retrieve all the elements
-     return strm.read_ulong_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
+@@ -3599,7 +2988,7 @@
+ 
+ CORBA::Boolean operator<< (
+     TAO_OutputCDR &strm,
+-    const CORBA_Policy_ptr _tao_objref
++    const CORBA::Policy_ptr _tao_objref
+   )
+ {
+   CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+@@ -3608,7 +2997,7 @@
+ 
+ CORBA::Boolean operator>> (
+     TAO_InputCDR &strm,
+-    CORBA_Policy_ptr &_tao_objref
++    CORBA::Policy_ptr &_tao_objref
+   )
+ {
+   ACE_TRY_NEW_ENV
+@@ -3618,7 +3007,7 @@
+       return 0;
+     // narrow to the right type
+     _tao_objref =
+-      CORBA_Policy::_unchecked_narrow (
++      CORBA::Policy::_unchecked_narrow (
+           obj.in (),
+           ACE_TRY_ENV
+         );
+@@ -3635,7 +3024,7 @@
+ 
+ CORBA::Boolean operator<< (
+     TAO_OutputCDR &strm,
+-    const CORBA_PolicyList &_tao_sequence
++    const CORBA::PolicyList &_tao_sequence
+   )
+ {
+   if (strm << _tao_sequence.length ())
+@@ -3653,7 +3042,7 @@
+ 
+ CORBA::Boolean operator>> (
+     TAO_InputCDR &strm,
+-    CORBA_PolicyList &_tao_sequence
++    CORBA::PolicyList &_tao_sequence
+   )
+ {
+   CORBA::ULong _tao_seq_len;
+@@ -3682,7 +3071,7 @@
+ 
+ CORBA::Boolean operator<< (
+     TAO_OutputCDR &strm,
+-    const CORBA_PolicyTypeSeq &_tao_sequence
++    const CORBA::PolicyTypeSeq &_tao_sequence
+   )
+ {
+   if (strm << _tao_sequence.length ())
+@@ -3695,7 +3084,7 @@
+ 
+ CORBA::Boolean operator>> (
+     TAO_InputCDR &strm,
+-    CORBA_PolicyTypeSeq &_tao_sequence
++    CORBA::PolicyTypeSeq &_tao_sequence
+   )
+ {
+   CORBA::ULong _tao_seq_len;
+@@ -3716,4 +3105,3 @@
    }
    return 0; // error
  }
diff --git a/TAO/tao/diffs/PolicyC.h.diff b/TAO/tao/diffs/PolicyC.h.diff
index 04e6a86ee07..a710a18922f 100644
--- a/TAO/tao/diffs/PolicyC.h.diff
+++ b/TAO/tao/diffs/PolicyC.h.diff
@@ -1,5 +1,5 @@
---- orig/PolicyC.h	Tue Apr 24 23:49:03 2001
-+++ PolicyC.h	Tue Apr 24 13:44:40 2001
+--- orig/PolicyC.h	Tue Jun 12 17:22:53 2001
++++ PolicyC.h	Tue Jun 12 13:58:13 2001
 @@ -1,6 +1,6 @@
  // -*- C++ -*-
  //
@@ -8,35 +8,30 @@
  
  // ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
  // TAO and the TAO IDL Compiler have been developed by:
-@@ -19,17 +19,23 @@
- // Information about TAO is available at:
- //     http://www.cs.wustl.edu/~schmidt/TAO.html
- 
--#ifndef _TAO_IDL_POLICYC_H_
--#define _TAO_IDL_POLICYC_H_
-+#ifndef _TAO_IDL_ORIG_POLICYC_H_
-+#define _TAO_IDL_ORIG_POLICYC_H_
+@@ -23,13 +23,20 @@
+ #define _TAO_IDL_ORIG_POLICYC_H_
  
  #include "ace/pre.h"
 -#include "tao/corba.h"
-+#include "tao/CurrentC.h"
++
++#include "TAO_Export.h"
  
  #if !defined (ACE_LACKS_PRAGMA_ONCE)
  # pragma once
  #endif /* ACE_LACKS_PRAGMA_ONCE */
  
 -#include "tao/corbafwd.h"
-+#include "TAO_Export.h"
 +#include "Encodable.h"
 +#include "Exception.h"
 +#include "Environment.h"
 +#include "Sequence.h"
 +#include "CDR.h"
 +#include "Remote_Object_Proxy_Impl.h"
++#include "CurrentC.h"
  
  #if defined (TAO_EXPORT_MACRO)
  #undef TAO_EXPORT_MACRO
-@@ -54,29 +60,6 @@
+@@ -54,30 +61,6 @@
  #pragma option push -w-rvl -w-rch -w-ccc -w-inl
  #endif /* __BORLANDC__ */
  
@@ -44,21 +39,22 @@
 -{
 -  typedef CORBA::Short PolicyErrorCode;
 -  typedef CORBA::Short_out PolicyErrorCode_out;
--    TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PolicyErrorCode;
--
+-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PolicyErrorCode;
+-  
 -  typedef CORBA::ULong PolicyType;
 -  typedef CORBA::ULong_out PolicyType_out;
--    TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PolicyType;
--
+-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PolicyType;
+-  
 -  enum SetOverrideType
 -  {
--        SET_OVERRIDE,
--        ADD_OVERRIDE    
+-    SET_OVERRIDE,
+-    ADD_OVERRIDE
 -  };
+-  
 -  typedef SetOverrideType &SetOverrideType_out;
 -  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_SetOverrideType;
--
--
+-  
+-  
 -}
 -TAO_NAMESPACE_CLOSE // module CORBA
 -
@@ -66,25 +62,754 @@
  #if !defined (_CORBA_POLICYERROR_CH_)
  #define _CORBA_POLICYERROR_CH_
  
-@@ -348,6 +331,7 @@
- class _TAO_CORBA_Policy_Remote_Proxy_Broker;
+@@ -120,9 +103,7 @@
+   // = TAO extension.
+   static CORBA::Exception *_alloc (void);
+   virtual CORBA::TypeCode_ptr _type (void) const;
+-}; // Exception CORBA_PolicyError.
+-
+-extern TAO_Export CORBA::TypeCode_ptr  _tc_CORBA_PolicyError;
++  }; // Exception CORBA::PolicyError.
+ 
+ 
+ #endif /* end #if !defined */
+@@ -140,46 +121,36 @@
+ #if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_INVALIDPOLICIES__TAO_SEQ_USHORT_CH_)
+ #define __TAO_UNBOUNDED_SEQUENCE_CORBA_INVALIDPOLICIES__TAO_SEQ_USHORT_CH_
+   
+-  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort
+-    : public TAO_Unbounded_Base_Sequence
++      class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort : public TAO_Unbounded_Base_Sequence
+   {
+   public:
+     // = Initialization and termination methods.
+-    _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (void);
++
++        _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (void); // Default constructor.
+     _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (CORBA::ULong maximum); 
+-    _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (
+-        CORBA::ULong maximum,
++        _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (CORBA::ULong maximum,
+         CORBA::ULong length,
+         CORBA::UShort *data,
+-        CORBA::Boolean release = 0
+-      );
+-    _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (
+-        const _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort &rhs
+-      );
+-    _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort &operator= (
+-        const _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort &rhs
+-      );
+-    virtual ~_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (void);
+-    
++          CORBA::Boolean release = 0);
++        _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (const _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort &rhs);
++        _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort &operator= (const _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort &rhs);
++        virtual ~_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (void); // Dtor.
+     // = Accessors.
+     CORBA::UShort &operator[] (CORBA::ULong i);
+     const CORBA::UShort &operator[] (CORBA::ULong i) const;
+-    
+     // = Static operations.
+     static CORBA::UShort *allocbuf (CORBA::ULong size);
+     static void freebuf (CORBA::UShort *buffer);
+-    
+-    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+     virtual void _allocate_buffer (CORBA::ULong length);
+     virtual void _deallocate_buffer (void);
++        // Implement the TAO_Base_Sequence methods (see Sequence.h)
++
+     CORBA::UShort *get_buffer (CORBA::Boolean orphan = 0);
+     const CORBA::UShort *get_buffer (void) const;
+-    void replace (
+-        CORBA::ULong max,
++        void replace (CORBA::ULong max,
+         CORBA::ULong length,
+         CORBA::UShort *data,
+-        CORBA::Boolean release
+-      );
++          CORBA::Boolean release);
+   };
+   
+ #endif /* end #if !defined */
+@@ -191,6 +162,7 @@
+ #define _CORBA_INVALIDPOLICIES__TAO_SEQ_USHORT_CH_
+   
+   class _tao_seq_UShort;
++    class _tao_seq_UShort_var;
+   
+   // *************************************************************
+   // _tao_seq_UShort
+@@ -216,11 +188,14 @@
+     ~_tao_seq_UShort (void);
+     static void _tao_any_destructor (void*);
+     
++#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
++      typedef _tao_seq_UShort_var _var_type;
++#endif /* ! __GNUC__ || g++ >= 2.8 */
++
+   };
+   
+ #endif /* end #if !defined */
+   
+-  
+ #if !defined (__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+   typedef _tao_seq_UShort _indices_seq;
+ #endif /* ! __GNUC__ || ACE_HAS_GNUG_PRE_2_8 */
+@@ -261,23 +236,11 @@
+   // = TAO extension.
+   static CORBA::Exception *_alloc (void);
+   virtual CORBA::TypeCode_ptr _type (void) const;
+-}; // Exception CORBA_InvalidPolicies.
+-
+-extern TAO_Export CORBA::TypeCode_ptr  _tc_CORBA_InvalidPolicies;
++  }; // Exception CORBA::InvalidPolicies.
+ 
+ 
+ #endif /* end #if !defined */
  
- class TAO_Export CORBA_Policy : public virtual CORBA_Object
-+                              , public virtual TAO_Encodable
+-
+-#if !defined (_CORBA_POLICY___PTR_CH_)
+-#define _CORBA_POLICY___PTR_CH_
+-
+-class CORBA_Policy;
+-typedef CORBA_Policy *CORBA_Policy_ptr;
+-
+-#endif /* end #if !defined */
+-
+-
+ #if !defined (_CORBA_POLICY___VAR_CH_)
+ #define _CORBA_POLICY___VAR_CH_
+ 
+@@ -307,10 +270,7 @@
+   static CORBA_Policy_ptr duplicate (CORBA_Policy_ptr);
+   static void release (CORBA_Policy_ptr);
+   static CORBA_Policy_ptr nil (void);
+-  static CORBA_Policy_ptr narrow (
+-      CORBA::Object *,
+-      CORBA::Environment &
+-    );
++    static CORBA_Policy_ptr narrow (CORBA::Object *, CORBA::Environment &);
+   static CORBA::Object * upcast (void *);
+ 
+ private:
+@@ -352,13 +312,14 @@
+ #define _CORBA_POLICY_CH_
+ 
+ // Forward Classes Declaration
+-class _TAO_CORBA_Policy_Proxy_Impl;
+-class _TAO_CORBA_Policy_Remote_Proxy_Impl;
+-class _TAO_CORBA_Policy_Proxy_Broker;
+-class _TAO_CORBA_Policy_Remote_Proxy_Broker;
++  class CORBA_TAO_Policy_Proxy_Impl;
++  class CORBA_TAO_Policy_Remote_Proxy_Impl;
++  class CORBA_TAO_Policy_Proxy_Broker;
++  class CORBA_TAO_Policy_Remote_Proxy_Broker;
+ 
+ class TAO_Export CORBA_Policy
+-  : public virtual CORBA_Object
++  : public virtual CORBA_Object,
++    public virtual TAO_Encodable
  {
  public:
  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-@@ -407,6 +391,9 @@
+@@ -368,19 +329,16 @@
+ 
+   // the static operations
+   static CORBA_Policy_ptr _duplicate (CORBA_Policy_ptr obj);
+-  
+   static CORBA_Policy_ptr _narrow (
+       CORBA::Object_ptr obj,
+       CORBA::Environment &ACE_TRY_ENV = 
+         TAO_default_environment ()
+     );
+-  
+   static CORBA_Policy_ptr _unchecked_narrow (
+       CORBA::Object_ptr obj,
+       CORBA::Environment &ACE_TRY_ENV = 
+         TAO_default_environment ()
+     );
+-  
+   static CORBA_Policy_ptr _nil (void)
+     {
+       return (CORBA_Policy_ptr)0;
+@@ -396,7 +354,7 @@
+       CORBA::SystemException
+     ));
+   
+-  virtual CORBA_Policy_ptr copy (
++    virtual CORBA::Policy_ptr copy (
+       CORBA::Environment &ACE_TRY_ENV = 
+         TAO_default_environment ()
+     )
+@@ -417,17 +375,26 @@
+       CORBA::Environment &ACE_TRY_ENV = 
+         TAO_default_environment ()
+     );
+-  
+   virtual void *_tao_QueryInterface (ptr_arith_t type);
    
    virtual const char* _interface_repository_id (void) const;
  
-+  virtual CORBA::Boolean _tao_encode (TAO_OutputCDR &);
-+  virtual CORBA::Boolean _tao_decode (TAO_InputCDR &);
++    virtual CORBA::Boolean _tao_encode (TAO_OutputCDR &);
++    virtual CORBA::Boolean _tao_decode (TAO_InputCDR &);
++
++    // Return the cached policy type for this policy.  See orbconf.h.
++    virtual TAO_Cached_Policy_Type _tao_cached_type (void) const;
++
++    // Returns the scope at which this policy can be applied. See orbconf.h.
++    virtual TAO_Policy_Scope _tao_scope (void) const;
++
+ private:
+-  _TAO_CORBA_Policy_Proxy_Broker *the_TAO_CORBA_Policy_Proxy_Broker_;
++    CORBA_TAO_Policy_Proxy_Broker *the_CORBA_TAO_Policy_Proxy_Broker_;
+   
+ protected:
+   CORBA_Policy (int collocated = 0);
+   
++    protected:
+   // This methods travese the inheritance tree and set the
+   // parents piece of the given class in the right mode
+   virtual void CORBA_Policy_setup_collocation (int collocated);
+@@ -438,41 +405,41 @@
+       TAO_Abstract_ServantBase *servant = 0
+     );
+   
+-  friend class _TAO_CORBA_Policy_Remote_Proxy_Impl;
+-  friend class _TAO_CORBA_Policy_ThruPOA_Proxy_Impl;
+-  friend class _TAO_CORBA_Policy_Direct_Proxy_Impl;
++      friend class CORBA_TAO_Policy_Remote_Proxy_Impl;
++      friend class CORBA_TAO_Policy_ThruPOA_Proxy_Impl;
++      friend class CORBA_TAO_Policy_Direct_Proxy_Impl;
+   
+   virtual ~CORBA_Policy (void);
+-
+ private:
+   CORBA_Policy (const CORBA_Policy &);
+   void operator= (const CORBA_Policy &);
+ };
+ 
++
+ // The Proxy Implementations are used by each interface to
+ // perform a call. Each different implementation encapsulate
+ // an invocation logics.
+ 
+ 
+ ///////////////////////////////////////////////////////////////////////
+-//                    Base Proxy Impl. Declaration
++  //                    Base  Impl. Declaration
+ //
+ 
+-class TAO_Export _TAO_CORBA_Policy_Proxy_Impl
+-  : public virtual TAO_Object_Proxy_Impl
++  class TAO_Export CORBA_TAO_Policy_Proxy_Impl : public virtual TAO_Object_Proxy_Impl
+ {
+ public:
+-  virtual ~_TAO_CORBA_Policy_Proxy_Impl (void) { }
++    virtual ~CORBA_TAO_Policy_Proxy_Impl (void) { }
++
+   virtual CORBA::PolicyType policy_type (
+-      CORBA_Object *_collocated_tao_target_,
++        CORBA::Object_ptr _collocated_tao_target_,
+       CORBA::Environment &ACE_TRY_ENV
+     )
+     ACE_THROW_SPEC ((
+       CORBA::SystemException
+     )) = 0;
+   
+-  virtual CORBA_Policy_ptr copy (
+-      CORBA_Object *_collocated_tao_target_,
++    virtual CORBA::Policy_ptr copy (
++        CORBA::Object_ptr _collocated_tao_target_,
+       CORBA::Environment &ACE_TRY_ENV
+     )
+     ACE_THROW_SPEC ((
+@@ -480,45 +447,45 @@
+     )) = 0;
+   
+   virtual void destroy (
+-      CORBA_Object *_collocated_tao_target_,
++        CORBA::Object_ptr _collocated_tao_target_,
+       CORBA::Environment &ACE_TRY_ENV
+     )
+     ACE_THROW_SPEC ((
+       CORBA::SystemException
+     )) = 0;
+   
+-  
+ protected:
+-  _TAO_CORBA_Policy_Proxy_Impl (void);
+-};
++    CORBA_TAO_Policy_Proxy_Impl (void);
+ 
++  };
+ //
+-//               End Base Proxy Impl. Declaration
++  //                Base  Proxy Impl. Declaration
+ ///////////////////////////////////////////////////////////////////////
+ 
+ 
+ ///////////////////////////////////////////////////////////////////////
+-//                Remote Proxy Impl. Declaration
++//                    Remote  Impl. Declaration
+ //
+ 
+-class TAO_Export _TAO_CORBA_Policy_Remote_Proxy_Impl
+-  : public virtual _TAO_CORBA_Policy_Proxy_Impl,
++class TAO_Export CORBA_TAO_Policy_Remote_Proxy_Impl :
++  public virtual CORBA_TAO_Policy_Proxy_Impl,
+     public virtual TAO_Remote_Object_Proxy_Impl
+ {
+ public:
+-  _TAO_CORBA_Policy_Remote_Proxy_Impl (void);
++  CORBA_TAO_Policy_Remote_Proxy_Impl (void);
++
++  virtual ~CORBA_TAO_Policy_Remote_Proxy_Impl (void) { }
+   
+-  virtual ~_TAO_CORBA_Policy_Remote_Proxy_Impl (void) { }
+   virtual CORBA::PolicyType policy_type (
+-      CORBA_Object *_collocated_tao_target_,
++      CORBA::Object_ptr _collocated_tao_target_,
+       CORBA::Environment &ACE_TRY_ENV
+     )
+     ACE_THROW_SPEC ((
+       CORBA::SystemException
+     ));
+   
+-  virtual CORBA_Policy_ptr copy (
+-      CORBA_Object *_collocated_tao_target_,
++virtual CORBA::Policy_ptr copy (
++      CORBA::Object_ptr _collocated_tao_target_,
+       CORBA::Environment &ACE_TRY_ENV
+     )
+     ACE_THROW_SPEC ((
+@@ -526,41 +493,42 @@
+     ));
+   
+   virtual void destroy (
+-      CORBA_Object *_collocated_tao_target_,
++      CORBA::Object_ptr _collocated_tao_target_,
+       CORBA::Environment &ACE_TRY_ENV
+     )
+     ACE_THROW_SPEC ((
+       CORBA::SystemException
+     ));
+   
+-  
+ };
+ 
+ //
+-//             End Remote Proxy Impl. Declaration
++//                Base  Proxy Impl. Declaration
+ ///////////////////////////////////////////////////////////////////////
+ 
++
+ // The Proxy Brokers are used by each interface to get
+ // the right proxy for performing a call. In the new 
+ // collocation scheme, the proxy to be used can vary on
+ // a call by call basis.
+ 
+ 
++
+ ///////////////////////////////////////////////////////////////////////
+ //                 Base Proxy Broker Declaration 
+ //
+ 
+-class TAO_Export _TAO_CORBA_Policy_Proxy_Broker
++class TAO_Export CORBA_TAO_Policy_Proxy_Broker
+ {
+ public:
+-  virtual ~_TAO_CORBA_Policy_Proxy_Broker (void);
+-  virtual _TAO_CORBA_Policy_Proxy_Impl &select_proxy (
++  virtual ~CORBA_TAO_Policy_Proxy_Broker (void);
++  virtual CORBA_TAO_Policy_Proxy_Impl &select_proxy (
+       CORBA_Policy *object,
+-      CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
++    CORBA_Environment &ACE_TRY_ENV
+     ) = 0;
+   
+ protected:
+-  _TAO_CORBA_Policy_Proxy_Broker (void);
++  CORBA_TAO_Policy_Proxy_Broker (void);
+   
+ };
+ 
+@@ -573,29 +541,29 @@
+ //                 Remote Proxy Broker Declaration 
+ //
+ 
+-class TAO_Export _TAO_CORBA_Policy_Remote_Proxy_Broker
+-  : public virtual _TAO_CORBA_Policy_Proxy_Broker
++class TAO_Export CORBA_TAO_Policy_Remote_Proxy_Broker : public virtual CORBA_TAO_Policy_Proxy_Broker
+ {
+ public: 
+-  _TAO_CORBA_Policy_Remote_Proxy_Broker (void);
++  CORBA_TAO_Policy_Remote_Proxy_Broker (void);
+   
+-  virtual ~_TAO_CORBA_Policy_Remote_Proxy_Broker (void);
++  virtual ~CORBA_TAO_Policy_Remote_Proxy_Broker (void);
+   
+-  virtual _TAO_CORBA_Policy_Proxy_Impl &select_proxy (
++  virtual CORBA_TAO_Policy_Proxy_Impl &select_proxy (
+       CORBA_Policy *object,
+       CORBA_Environment &ACE_TRY_ENV
+     );
+   
+ private:
+-  _TAO_CORBA_Policy_Remote_Proxy_Impl remote_proxy_impl_;
+-
+-public:
++  CORBA_TAO_Policy_Remote_Proxy_Impl remote_proxy_impl_;
+   // This member function is used to get an handle to the unique instance
+   // of the Remote Proxy Broker that is available for a given
+   // interface.
+-  static _TAO_CORBA_Policy_Remote_Proxy_Broker *the_TAO_CORBA_Policy_Remote_Proxy_Broker (void);
++
++public:
++  static CORBA_TAO_Policy_Remote_Proxy_Broker *the_CORBA_TAO_Policy_Remote_Proxy_Broker (void);
+ };
+ 
++
+ //
+ //              End Remote Proxy Broker Declaration 
+ ///////////////////////////////////////////////////////////////////////
+@@ -603,52 +571,35 @@
+ 
+ #endif /* end #if !defined */
+ 
+-extern TAO_Export CORBA::TypeCode_ptr  _tc_CORBA_Policy;
+-
+ 
+ #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+ 
+ #if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_POLICYLIST_CH_)
+ #define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_POLICYLIST_CH_
+ 
+-class _TAO_Unbounded_Object_Sequence_CORBA_PolicyList
+-  : public TAO_Unbounded_Base_Sequence
++  class _TAO_Unbounded_Object_Sequence_CORBA_PolicyList : public TAO_Unbounded_Base_Sequence
+ {
+ public:
+   // = Initialization and termination methods.
++
+   _TAO_Unbounded_Object_Sequence_CORBA_PolicyList (void);
+   _TAO_Unbounded_Object_Sequence_CORBA_PolicyList (CORBA::ULong maximum);
+-  _TAO_Unbounded_Object_Sequence_CORBA_PolicyList (
+-      CORBA::ULong maximum,
++    _TAO_Unbounded_Object_Sequence_CORBA_PolicyList (CORBA::ULong maximum,
+       CORBA::ULong length,
+       CORBA_Policy* *value,
+-      CORBA::Boolean release = 0
+-    );
+-  _TAO_Unbounded_Object_Sequence_CORBA_PolicyList (
+-      const _TAO_Unbounded_Object_Sequence_CORBA_PolicyList &rhs
+-    );
+-  _TAO_Unbounded_Object_Sequence_CORBA_PolicyList &operator= (
+-      const _TAO_Unbounded_Object_Sequence_CORBA_PolicyList &rhs
+-    );
++      CORBA::Boolean release = 0);
++    _TAO_Unbounded_Object_Sequence_CORBA_PolicyList(const _TAO_Unbounded_Object_Sequence_CORBA_PolicyList &rhs);
+   virtual ~_TAO_Unbounded_Object_Sequence_CORBA_PolicyList (void);
+-  
+-  // = Accessors.
+-  TAO_Object_Manager<CORBA_Policy,CORBA_Policy_var> operator[] (CORBA::ULong index) const;
+-  
+-  // = Static operations.
++    _TAO_Unbounded_Object_Sequence_CORBA_PolicyList &operator= (const _TAO_Unbounded_Object_Sequence_CORBA_PolicyList &rhs);
++    TAO_Object_Manager<CORBA::Policy,CORBA::Policy_var> operator[] (CORBA::ULong index) const;
+   static CORBA_Policy **allocbuf (CORBA::ULong nelems);
+   static void freebuf (CORBA_Policy **buffer);
+-  
+-  // Implement the TAO_Base_Sequence methods (see Sequence.h)
++    // The Base_Sequence functions, please see tao/Sequence.h
+   virtual void _allocate_buffer (CORBA::ULong length);
+   virtual void _deallocate_buffer (void);
+   CORBA_Policy* *get_buffer (CORBA::Boolean orphan = 0);
+   const CORBA_Policy* *get_buffer (void) const;
+-  virtual void _shrink_buffer (
+-      CORBA::ULong nl,
+-      CORBA::ULong ol
+-    );
+-  
++    virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+   virtual void _downcast (
+       void* target,
+       CORBA_Object *src,
+@@ -656,6 +607,7 @@
+         TAO_default_environment ()
+     );
+   virtual CORBA_Object* _upcast (void *src) const;
++
+ };
+ 
+ #endif /* end #if !defined */
+@@ -666,11 +618,8 @@
+ #if !defined (_CORBA_POLICYLIST_CH_)
+ #define _CORBA_POLICYLIST_CH_
+ 
+-class CORBA_PolicyList;
+-class CORBA_PolicyList_var;
+-
+ // *************************************************************
+-// CORBA_PolicyList
++// PolicyList
+ // *************************************************************
+ 
+ class TAO_Export CORBA_PolicyList : public 
+@@ -697,7 +646,6 @@
+   typedef CORBA_PolicyList_var _var_type;
+ #endif /* ! __GNUC__ || g++ >= 2.8 */
+   
+-  
+ };
+ 
+ #endif /* end #if !defined */
+@@ -707,16 +655,16 @@
+ #define _CORBA_POLICYLIST___VAR_CH_
+ 
+ // *************************************************************
+-// class CORBA_PolicyList_var
++// class CORBA::PolicyList_var
+ // *************************************************************
+ 
+ class TAO_Export CORBA_PolicyList_var
+ {
+ public:
+-  CORBA_PolicyList_var (void);
++  CORBA_PolicyList_var (void); // default constructor
+   CORBA_PolicyList_var (CORBA_PolicyList *);
+-  CORBA_PolicyList_var (const CORBA_PolicyList_var &);
+-  ~CORBA_PolicyList_var (void);
++  CORBA_PolicyList_var (const CORBA_PolicyList_var &); // copy constructor
++  ~CORBA_PolicyList_var (void); // destructor
+   
+   CORBA_PolicyList_var &operator= (CORBA_PolicyList *);
+   CORBA_PolicyList_var &operator= (const CORBA_PolicyList_var &);
+@@ -763,61 +711,49 @@
+ 
+ private:
+   CORBA_PolicyList *&ptr_;
+-  // Assignment from T_var not allowed.
++  // assignment from T_var not allowed
+   void operator= (const CORBA_PolicyList_var &);
+ };
+ 
+ 
+ #endif /* end #if !defined */
+ 
+-extern TAO_Export CORBA::TypeCode_ptr  _tc_CORBA_PolicyList;
+-
+ 
+ #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+ 
+ #if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_POLICYTYPESEQ_CH_)
+ #define __TAO_UNBOUNDED_SEQUENCE_CORBA_POLICYTYPESEQ_CH_
+ 
+-class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq
+-  : public TAO_Unbounded_Base_Sequence
++  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq : public TAO_Unbounded_Base_Sequence
+ {
+ public:
+   // = Initialization and termination methods.
+-  _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (void);
 +
++    _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (void); // Default constructor.
+   _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (CORBA::ULong maximum); 
+-  _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (
+-      CORBA::ULong maximum,
++    _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (CORBA::ULong maximum,
+       CORBA::ULong length,
+       CORBA::ULong *data,
+-      CORBA::Boolean release = 0
+-    );
+-  _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (
+-      const _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq &rhs
+-    );
+-  _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq &operator= (
+-      const _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq &rhs
+-    );
+-  virtual ~_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (void);
+-  
++      CORBA::Boolean release = 0);
++    _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (const _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq &rhs);
++    _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq &operator= (const _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq &rhs);
++    virtual ~_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (void); // Dtor.
+   // = Accessors.
+   CORBA::ULong &operator[] (CORBA::ULong i);
+   const CORBA::ULong &operator[] (CORBA::ULong i) const;
+-  
+   // = Static operations.
+   static CORBA::ULong *allocbuf (CORBA::ULong size);
+   static void freebuf (CORBA::ULong *buffer);
+-  
+-  // Implement the TAO_Base_Sequence methods (see Sequence.h)
+   virtual void _allocate_buffer (CORBA::ULong length);
+   virtual void _deallocate_buffer (void);
++    // Implement the TAO_Base_Sequence methods (see Sequence.h)
++
+   CORBA::ULong *get_buffer (CORBA::Boolean orphan = 0);
+   const CORBA::ULong *get_buffer (void) const;
+-  void replace (
+-      CORBA::ULong max,
++    void replace (CORBA::ULong max,
+       CORBA::ULong length,
+       CORBA::ULong *data,
+-      CORBA::Boolean release
+-    );
++      CORBA::Boolean release);
+ };
+ 
+ #endif /* end #if !defined */
+@@ -832,7 +768,7 @@
+ class CORBA_PolicyTypeSeq_var;
+ 
+ // *************************************************************
+-// CORBA_PolicyTypeSeq
++// PolicyTypeSeq
+ // *************************************************************
+ 
+ class TAO_Export CORBA_PolicyTypeSeq : public 
+@@ -859,7 +795,6 @@
+   typedef CORBA_PolicyTypeSeq_var _var_type;
+ #endif /* ! __GNUC__ || g++ >= 2.8 */
+   
+-  
+ };
+ 
+ #endif /* end #if !defined */
+@@ -869,23 +804,21 @@
+ #define _CORBA_POLICYTYPESEQ___VAR_CH_
+ 
+ // *************************************************************
+-// class CORBA_PolicyTypeSeq_var
++// class CORBA::PolicyTypeSeq_var
+ // *************************************************************
+ 
+ class TAO_Export CORBA_PolicyTypeSeq_var
+ {
+ public:
+-  CORBA_PolicyTypeSeq_var (void);
++  CORBA_PolicyTypeSeq_var (void); // default constructor
+   CORBA_PolicyTypeSeq_var (CORBA_PolicyTypeSeq *);
+-  CORBA_PolicyTypeSeq_var (const CORBA_PolicyTypeSeq_var &);
+-  // Fixed-size base types only.
+-  CORBA_PolicyTypeSeq_var (const CORBA_PolicyTypeSeq &);
+-  ~CORBA_PolicyTypeSeq_var (void);
++  CORBA_PolicyTypeSeq_var (const CORBA_PolicyTypeSeq_var &); // copy constructor
++  CORBA_PolicyTypeSeq_var (const CORBA_PolicyTypeSeq &); // fixed-size base types only
++  ~CORBA_PolicyTypeSeq_var (void); // destructor
+   
+   CORBA_PolicyTypeSeq_var &operator= (CORBA_PolicyTypeSeq *);
+   CORBA_PolicyTypeSeq_var &operator= (const CORBA_PolicyTypeSeq_var &);
+-  // Fixed-size base types only.
+-  CORBA_PolicyTypeSeq_var &operator= (const CORBA_PolicyTypeSeq &);
++  CORBA_PolicyTypeSeq_var &operator= (const CORBA_PolicyTypeSeq &); // fixed-size base types only
+   CORBA_PolicyTypeSeq *operator-> (void);
+   const CORBA_PolicyTypeSeq *operator-> (void) const;
+   
+@@ -929,24 +862,13 @@
+ 
  private:
-   _TAO_CORBA_Policy_Proxy_Broker *the_TAO_CORBA_Policy_Proxy_Broker_;
+   CORBA_PolicyTypeSeq *&ptr_;
+-  // Assignment from T_var not allowed.
++  // assignment from T_var not allowed
+   void operator= (const CORBA_PolicyTypeSeq_var &);
+ };
+ 
+ 
+ #endif /* end #if !defined */
+ 
+-extern TAO_Export CORBA::TypeCode_ptr  _tc_CORBA_PolicyTypeSeq;
+-
+-
+-#if !defined (_CORBA_POLICYMANAGER___PTR_CH_)
+-#define _CORBA_POLICYMANAGER___PTR_CH_
+-
+-class CORBA_PolicyManager;
+-typedef CORBA_PolicyManager *CORBA_PolicyManager_ptr;
+-
+-#endif /* end #if !defined */
+-
+ 
+ #if !defined (_CORBA_POLICYMANAGER___VAR_CH_)
+ #define _CORBA_POLICYMANAGER___VAR_CH_
+@@ -977,10 +899,7 @@
+   static CORBA_PolicyManager_ptr duplicate (CORBA_PolicyManager_ptr);
+   static void release (CORBA_PolicyManager_ptr);
+   static CORBA_PolicyManager_ptr nil (void);
+-  static CORBA_PolicyManager_ptr narrow (
+-      CORBA::Object *,
+-      CORBA::Environment &
+-    );
++  static CORBA_PolicyManager_ptr narrow (CORBA::Object *, CORBA::Environment &);
+   static CORBA::Object * upcast (void *);
+ 
+ private:
+@@ -1021,8 +940,7 @@
+ #if !defined (_CORBA_POLICYMANAGER_CH_)
+ #define _CORBA_POLICYMANAGER_CH_
+ 
+-class TAO_Export CORBA_PolicyManager
+-  : public virtual CORBA_Object
++class TAO_Export CORBA_PolicyManager : public virtual CORBA::Object
+ {
+ public:
+ #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+@@ -1032,26 +950,23 @@
+ 
+   // the static operations
+   static CORBA_PolicyManager_ptr _duplicate (CORBA_PolicyManager_ptr obj);
+-  
+   static CORBA_PolicyManager_ptr _narrow (
+       CORBA::Object_ptr obj,
+       CORBA::Environment &ACE_TRY_ENV = 
+         TAO_default_environment ()
+     );
+-  
+   static CORBA_PolicyManager_ptr _unchecked_narrow (
+       CORBA::Object_ptr obj,
+       CORBA::Environment &ACE_TRY_ENV = 
+         TAO_default_environment ()
+     );
+-  
+   static CORBA_PolicyManager_ptr _nil (void)
+     {
+       return (CORBA_PolicyManager_ptr)0;
+     }
    
-@@ -1039,127 +1026,6 @@
+-  virtual CORBA_PolicyList * get_policy_overrides (
+-      const CORBA_PolicyTypeSeq & ts,
++  virtual CORBA::PolicyList * get_policy_overrides (
++      const CORBA::PolicyTypeSeq & ts,
+       CORBA::Environment &ACE_TRY_ENV = 
+         TAO_default_environment ()
+     )
+@@ -1060,14 +975,14 @@
+     )) = 0;
+   
+   virtual void set_policy_overrides (
+-      const CORBA_PolicyList & policies,
++      const CORBA::PolicyList & policies,
+       CORBA::SetOverrideType set_add,
+       CORBA::Environment &ACE_TRY_ENV = 
+         TAO_default_environment ()
+     )
+     ACE_THROW_SPEC ((
+       CORBA::SystemException,
+-      CORBA_InvalidPolicies
++      CORBA::InvalidPolicies
+     )) = 0;
+   
+   virtual void *_tao_QueryInterface (ptr_arith_t type);
+@@ -1078,7 +993,6 @@
+   CORBA_PolicyManager ();
+   
+   virtual ~CORBA_PolicyManager (void);
+-
+ private:
+   CORBA_PolicyManager (const CORBA_PolicyManager &);
+   void operator= (const CORBA_PolicyManager &);
+@@ -1088,144 +1002,6 @@
  #endif /* end #if !defined */
  
  
@@ -126,7 +851,10 @@
 -  static CORBA_Current_ptr duplicate (CORBA_Current_ptr);
 -  static void release (CORBA_Current_ptr);
 -  static CORBA_Current_ptr nil (void);
--  static CORBA_Current_ptr narrow (CORBA::Object *, CORBA::Environment &);
+-  static CORBA_Current_ptr narrow (
+-      CORBA::Object *,
+-      CORBA::Environment &
+-    );
 -  static CORBA::Object * upcast (void *);
 -
 -private:
@@ -167,7 +895,8 @@
 -#if !defined (_CORBA_CURRENT_CH_)
 -#define _CORBA_CURRENT_CH_
 -
--class TAO_Export CORBA_Current : public virtual CORBA_Object
+-class TAO_Export CORBA_Current
+-  : public virtual CORBA_Object
 -{
 -public:
 -#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -177,21 +906,24 @@
 -
 -  // the static operations
 -  static CORBA_Current_ptr _duplicate (CORBA_Current_ptr obj);
+-  
 -  static CORBA_Current_ptr _narrow (
 -      CORBA::Object_ptr obj,
 -      CORBA::Environment &ACE_TRY_ENV = 
 -        TAO_default_environment ()
 -    );
+-  
 -  static CORBA_Current_ptr _unchecked_narrow (
 -      CORBA::Object_ptr obj,
 -      CORBA::Environment &ACE_TRY_ENV = 
 -        TAO_default_environment ()
 -    );
+-  
 -  static CORBA_Current_ptr _nil (void)
 -    {
 -      return (CORBA_Current_ptr)0;
 -    }
--
+-  
 -  virtual void *_tao_QueryInterface (ptr_arith_t type);
 -  
 -  virtual const char* _interface_repository_id (void) const;
@@ -200,6 +932,7 @@
 -  CORBA_Current ();
 -  
 -  virtual ~CORBA_Current (void);
+-
 -private:
 -  CORBA_Current (const CORBA_Current &);
 -  void operator= (const CORBA_Current &);
@@ -209,10 +942,195 @@
 -#endif /* end #if !defined */
 -
 -
- #if !defined (_CORBA_POLICYCURRENT___PTR_CH_)
- #define _CORBA_POLICYCURRENT___PTR_CH_
+-#if !defined (_CORBA_POLICYCURRENT___PTR_CH_)
+-#define _CORBA_POLICYCURRENT___PTR_CH_
+-
+-class CORBA_PolicyCurrent;
+-typedef CORBA_PolicyCurrent *CORBA_PolicyCurrent_ptr;
+-
+-#endif /* end #if !defined */
+-
+-
+ #if !defined (_CORBA_POLICYCURRENT___VAR_CH_)
+ #define _CORBA_POLICYCURRENT___VAR_CH_
+ 
+@@ -1255,10 +1031,7 @@
+   static CORBA_PolicyCurrent_ptr duplicate (CORBA_PolicyCurrent_ptr);
+   static void release (CORBA_PolicyCurrent_ptr);
+   static CORBA_PolicyCurrent_ptr nil (void);
+-  static CORBA_PolicyCurrent_ptr narrow (
+-      CORBA::Object *,
+-      CORBA::Environment &
+-    );
++  static CORBA_PolicyCurrent_ptr narrow (CORBA::Object *, CORBA::Environment &);
+   static CORBA::Object * upcast (void *);
+ 
+ private:
+@@ -1299,9 +1072,7 @@
+ #if !defined (_CORBA_POLICYCURRENT_CH_)
+ #define _CORBA_POLICYCURRENT_CH_
+ 
+-class TAO_Export CORBA_PolicyCurrent
+-  : public virtual CORBA_PolicyManager, 
+-    public virtual CORBA_Current
++class TAO_Export CORBA_PolicyCurrent: public virtual CORBA_PolicyManager, public virtual CORBA_Current
+ {
+ public:
+ #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+@@ -1311,19 +1082,16 @@
+ 
+   // the static operations
+   static CORBA_PolicyCurrent_ptr _duplicate (CORBA_PolicyCurrent_ptr obj);
+-  
+   static CORBA_PolicyCurrent_ptr _narrow (
+       CORBA::Object_ptr obj,
+       CORBA::Environment &ACE_TRY_ENV = 
+         TAO_default_environment ()
+     );
+-  
+   static CORBA_PolicyCurrent_ptr _unchecked_narrow (
+       CORBA::Object_ptr obj,
+       CORBA::Environment &ACE_TRY_ENV = 
+         TAO_default_environment ()
+     );
+-  
+   static CORBA_PolicyCurrent_ptr _nil (void)
+     {
+       return (CORBA_PolicyCurrent_ptr)0;
+@@ -1337,7 +1105,6 @@
+   CORBA_PolicyCurrent ();
+   
+   virtual ~CORBA_PolicyCurrent (void);
+-
+ private:
+   CORBA_PolicyCurrent (const CORBA_PolicyCurrent &);
+   void operator= (const CORBA_PolicyCurrent &);
+@@ -1346,74 +1113,73 @@
+ 
+ #endif /* end #if !defined */
+ 
++
+ // Proxy Broker Factory function pointer declarations.
+ 
+ extern TAO_Export
+-_TAO_CORBA_Policy_Proxy_Broker *
+-(*_TAO_CORBA_Policy_Proxy_Broker_Factory_function_pointer) (
++CORBA_TAO_Policy_Proxy_Broker *
++(*CORBA_CORBA_TAO_Policy_Proxy_Broker_Factory_function_pointer) (
+     CORBA::Object_ptr obj
+   );
+ 
++TAO_Export void operator<<= (CORBA::Any &, const CORBA::PolicyError &); // copying version
++TAO_Export void operator<<= (CORBA::Any &, CORBA::PolicyError*); // noncopying version
++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::PolicyError *&); // deprecated
++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::PolicyError *&);
++TAO_Export void operator<<= (CORBA::Any &, const CORBA::InvalidPolicies &); // copying version
++TAO_Export void operator<<= (CORBA::Any &, CORBA::InvalidPolicies*); // noncopying version
++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::InvalidPolicies *&); // deprecated
++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::InvalidPolicies *&);
++// Any operators for interface CORBA::Policy
++TAO_Export void operator<<= (CORBA::Any &, CORBA::Policy_ptr);
++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Policy *&);
++TAO_Export void operator<<= (CORBA::Any &, const CORBA::PolicyList &); // copying version
++TAO_Export void operator<<= (CORBA::Any &, CORBA::PolicyList*); // noncopying version
++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::PolicyList *&); // deprecated
++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::PolicyList *&);
++TAO_Export void operator<<= (CORBA::Any &, const CORBA::PolicyTypeSeq &); // copying version
++TAO_Export void operator<<= (CORBA::Any &, CORBA::PolicyTypeSeq*); // noncopying version
++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::PolicyTypeSeq *&); // deprecated
++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::PolicyTypeSeq *&);
+ TAO_Export void operator<<= (CORBA::Any &, CORBA::SetOverrideType);
+ TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::SetOverrideType &);
+-TAO_Export void operator<<= (CORBA::Any &, const CORBA_PolicyError &); // copying version
+-TAO_Export void operator<<= (CORBA::Any &, CORBA_PolicyError*); // noncopying version
+-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_PolicyError *&); // deprecated
+-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA_PolicyError *&);
+-TAO_Export void operator<<= (CORBA::Any &, const CORBA_InvalidPolicies &); // copying version
+-TAO_Export void operator<<= (CORBA::Any &, CORBA_InvalidPolicies*); // noncopying version
+-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_InvalidPolicies *&); // deprecated
+-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA_InvalidPolicies *&);
+-// Any operators for interface CORBA_Policy
+-TAO_Export void operator<<= (CORBA::Any &, CORBA_Policy_ptr);
+-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_Policy *&);
+-TAO_Export void operator<<= (CORBA::Any &, const CORBA_PolicyList &); // copying version
+-TAO_Export void operator<<= (CORBA::Any &, CORBA_PolicyList*); // noncopying version
+-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_PolicyList *&); // deprecated
+-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA_PolicyList *&);
+-TAO_Export void operator<<= (CORBA::Any &, const CORBA_PolicyTypeSeq &); // copying version
+-TAO_Export void operator<<= (CORBA::Any &, CORBA_PolicyTypeSeq*); // noncopying version
+-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_PolicyTypeSeq *&); // deprecated
+-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA_PolicyTypeSeq *&);
+ 
+ #ifndef __ACE_INLINE__
+ 
+-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::SetOverrideType &); // 
+-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::SetOverrideType &);
+-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_PolicyError &);
+-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_PolicyError &);
++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::PolicyError &);
++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::PolicyError &);
+ 
+-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_InvalidPolicies &);
+-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_InvalidPolicies &);
++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::InvalidPolicies &);
++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::InvalidPolicies &);
+ 
+ #if !defined _TAO_CDR_OP_CORBA_InvalidPolicies__tao_seq_UShort_H_
+ #define _TAO_CDR_OP_CORBA_InvalidPolicies__tao_seq_UShort_H_
+ 
+ TAO_Export CORBA::Boolean operator<< (
+     TAO_OutputCDR &,
+-    const CORBA_InvalidPolicies::_tao_seq_UShort &
++    const CORBA::InvalidPolicies::_tao_seq_UShort &
+   );
+ TAO_Export CORBA::Boolean operator>> (
+     TAO_InputCDR &,
+-    CORBA_InvalidPolicies::_tao_seq_UShort &
++    CORBA::InvalidPolicies::_tao_seq_UShort &
+   );
+ 
+ #endif /* _TAO_CDR_OP_CORBA_InvalidPolicies__tao_seq_UShort_H_ */
+ 
+ 
+-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_Policy_ptr );
+-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_Policy_ptr &);
++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::Policy_ptr );
++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::Policy_ptr &);
+ 
+ #if !defined _TAO_CDR_OP_CORBA_PolicyList_H_
+ #define _TAO_CDR_OP_CORBA_PolicyList_H_
+ 
+ TAO_Export CORBA::Boolean operator<< (
+     TAO_OutputCDR &,
+-    const CORBA_PolicyList &
++    const CORBA::PolicyList &
+   );
+ TAO_Export CORBA::Boolean operator>> (
+     TAO_InputCDR &,
+-    CORBA_PolicyList &
++    CORBA::PolicyList &
+   );
+ 
+ #endif /* _TAO_CDR_OP_CORBA_PolicyList_H_ */
+@@ -1424,21 +1190,23 @@
+ 
+ TAO_Export CORBA::Boolean operator<< (
+     TAO_OutputCDR &,
+-    const CORBA_PolicyTypeSeq &
++    const CORBA::PolicyTypeSeq &
+   );
+ TAO_Export CORBA::Boolean operator>> (
+     TAO_InputCDR &,
+-    CORBA_PolicyTypeSeq &
++    CORBA::PolicyTypeSeq &
+   );
+ 
+ #endif /* _TAO_CDR_OP_CORBA_PolicyTypeSeq_H_ */
+ 
++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::SetOverrideType &); //
++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::SetOverrideType &);
  
-@@ -1372,7 +1238,7 @@
+ #endif /* __ACE_INLINE__ */
  
  
  #if defined (__ACE_INLINE__)
diff --git a/TAO/tao/diffs/PolicyC.i.diff b/TAO/tao/diffs/PolicyC.i.diff
index 84fedf75c3a..2e0a0797da3 100644
--- a/TAO/tao/diffs/PolicyC.i.diff
+++ b/TAO/tao/diffs/PolicyC.i.diff
@@ -1,5 +1,5 @@
---- orig/PolicyC.i	Tue Apr 24 23:49:03 2001
-+++ PolicyC.i	Tue Apr 24 13:44:41 2001
+--- orig/PolicyC.i	Tue Jun 12 17:22:53 2001
++++ PolicyC.i	Thu Jun  7 00:04:48 2001
 @@ -1,6 +1,6 @@
  // -*- C++ -*-
  //
@@ -8,170 +8,535 @@
  
  // ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
  // TAO and the TAO IDL Compiler have been developed by:
-@@ -207,6 +207,49 @@
- #if !defined (_CORBA_POLICY___CI_)
- #define _CORBA_POLICY___CI_
- 
-+ACE_INLINE CORBA_Policy_ptr
-+tao_CORBA_Policy_duplicate (
-+    CORBA_Policy_ptr p
-+  )
-+{
-+  return CORBA_Policy::_duplicate (p);
-+}
-+
-+ACE_INLINE void
-+tao_CORBA_Policy_release (
-+    CORBA_Policy_ptr p
-+  )
-+{
-+  CORBA::release (p);
-+}
-+
-+ACE_INLINE CORBA_Policy_ptr
-+tao_CORBA_Policy_nil (
-+    void
-+  )
-+{
-+  return CORBA_Policy::_nil ();
-+}
-+
-+ACE_INLINE CORBA_Policy_ptr
-+tao_CORBA_Policy_narrow (
-+    CORBA::Object *p,
-+    CORBA::Environment &ACE_TRY_ENV
-+  )
-+{
-+  return CORBA_Policy::_narrow (p, ACE_TRY_ENV);
-+}
-+
-+ACE_INLINE CORBA::Object *
-+tao_CORBA_Policy_upcast (
-+    void *src
-+  )
-+{
-+  CORBA_Policy **tmp =
-+    ACE_static_cast (CORBA_Policy **, src);
-+  return *tmp;
-+}
-+
+@@ -20,11 +20,11 @@
+ //     http://www.cs.wustl.edu/~schmidt/TAO.html
+ 
+ // *************************************************************
+-// Inline operations for exception CORBA_PolicyError
++// Inline operations for exception CORBA::PolicyError
+ // *************************************************************
+ 
+ // *************************************************************
+-// Inline operations for exception CORBA_InvalidPolicies
++// Inline operations for exception CORBA::InvalidPolicies
+ // *************************************************************
+ 
+ 
+@@ -35,7 +35,7 @@
+ 
+ // = Static operations.
+ ACE_INLINE CORBA::UShort *
+-CORBA_InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::allocbuf (CORBA::ULong size)
++  CORBA::InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::allocbuf (CORBA::ULong size)
+ // Allocate storage for the sequence.
+ {
+   CORBA::UShort *retval = 0;
+@@ -43,25 +43,25 @@
+   return retval;
+ }
+ 
+-ACE_INLINE void CORBA_InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::freebuf (CORBA::UShort *buffer)
++  ACE_INLINE void CORBA::InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::freebuf (CORBA::UShort *buffer)
+ // Free the sequence.
+ {
+   delete [] buffer;
+ }
+ 
  ACE_INLINE
- CORBA_Policy::CORBA_Policy (
-     TAO_Stub *objref,
-@@ -1005,12 +1048,48 @@
- #if !defined (_CORBA_POLICYMANAGER___CI_)
- #define _CORBA_POLICYMANAGER___CI_
- 
-+ACE_INLINE CORBA_PolicyManager_ptr
-+tao_CORBA_PolicyManager_duplicate (
-+    CORBA_PolicyManager_ptr p
-+  )
-+{
-+  return CORBA_PolicyManager::_duplicate (p);
-+}
+-CORBA_InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (void) // Default constructor.
++  CORBA::InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (void) // Default constructor.
+ {
+ }
  
--#endif /* end #if !defined */
-+ACE_INLINE void
-+tao_CORBA_PolicyManager_release (
-+    CORBA_PolicyManager_ptr p
-+  )
-+{
-+  CORBA::release (p);
-+}
-+
-+ACE_INLINE CORBA_PolicyManager_ptr
-+tao_CORBA_PolicyManager_nil (
-+    void
-+  )
-+{
-+  return CORBA_PolicyManager::_nil ();
-+}
+ ACE_INLINE
+-CORBA_InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (CORBA::ULong maximum) // Constructor using a maximum length value.
++  CORBA::InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (CORBA::ULong maximum) // Constructor using a maximum length value.
+   : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::allocbuf (maximum))
+ {
+ }
  
-+ACE_INLINE CORBA_PolicyManager_ptr
-+tao_CORBA_PolicyManager_narrow (
-+    CORBA::Object *p,
-+    CORBA::Environment &ACE_TRY_ENV
-+  )
-+{
-+  return CORBA_PolicyManager::_narrow (p, ACE_TRY_ENV);
-+}
+ ACE_INLINE
+-CORBA_InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (CORBA::ULong maximum,
++  CORBA::InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (CORBA::ULong maximum,
+   CORBA::ULong length,
+   CORBA::UShort *data,
+   CORBA::Boolean release)
+@@ -70,7 +70,7 @@
+ }
  
--#if !defined (_CORBA_CURRENT___CI_)
--#define _CORBA_CURRENT___CI_
-+ACE_INLINE CORBA::Object *
-+tao_CORBA_PolicyManager_upcast (
-+    void *src
-+  )
-+{
-+  CORBA_PolicyManager **tmp =
-+    ACE_static_cast (CORBA_PolicyManager **, src);
-+  return *tmp;
-+}
+ ACE_INLINE
+-CORBA_InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (const _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort &rhs)
++  CORBA::InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (const _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort &rhs)
+ // Copy constructor.
+   : TAO_Unbounded_Base_Sequence (rhs)
+ {
+@@ -90,8 +90,8 @@
+   }
+ }
  
+-ACE_INLINE CORBA_InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort &
+-CORBA_InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::operator= (const _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort &rhs)
++  ACE_INLINE CORBA::InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort &
++  CORBA::InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::operator= (const _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort &rhs)
+ // Assignment operator.
+ {
+   if (this == &rhs)
+@@ -123,7 +123,7 @@
  
- #endif /* end #if !defined */
-@@ -1019,6 +1098,49 @@
- #if !defined (_CORBA_POLICYCURRENT___CI_)
- #define _CORBA_POLICYCURRENT___CI_
- 
-+ACE_INLINE CORBA_PolicyCurrent_ptr
-+tao_CORBA_PolicyCurrent_duplicate (
-+    CORBA_PolicyCurrent_ptr p
-+  )
-+{
-+  return CORBA_PolicyCurrent::_duplicate (p);
-+}
-+
-+ACE_INLINE void
-+tao_CORBA_PolicyCurrent_release (
-+    CORBA_PolicyCurrent_ptr p
-+  )
-+{
-+  CORBA::release (p);
-+}
-+
-+ACE_INLINE CORBA_PolicyCurrent_ptr
-+tao_CORBA_PolicyCurrent_nil (
-+    void
-+  )
-+{
-+  return CORBA_PolicyCurrent::_nil ();
-+}
-+
-+ACE_INLINE CORBA_PolicyCurrent_ptr
-+tao_CORBA_PolicyCurrent_narrow (
-+    CORBA::Object *p,
-+    CORBA::Environment &ACE_TRY_ENV
-+  )
-+{
-+  return CORBA_PolicyCurrent::_narrow (p, ACE_TRY_ENV);
-+}
-+
-+ACE_INLINE CORBA::Object *
-+tao_CORBA_PolicyCurrent_upcast (
-+    void *src
-+  )
-+{
-+  CORBA_PolicyCurrent **tmp =
-+    ACE_static_cast (CORBA_PolicyCurrent **, src);
-+  return *tmp;
-+}
-+
+ // = Accessors.
+ ACE_INLINE CORBA::UShort &
+-CORBA_InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::operator[] (CORBA::ULong i)
++  CORBA::InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::operator[] (CORBA::ULong i)
+ // operator []
+ {
+   ACE_ASSERT (i < this->maximum_);
+@@ -132,7 +132,7 @@
+ }
+ 
+ ACE_INLINE const CORBA::UShort &
+-CORBA_InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::operator[] (CORBA::ULong i) const
++  CORBA::InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::operator[] (CORBA::ULong i) const
+ // operator []
+ {
+   ACE_ASSERT (i < this->maximum_);
+@@ -143,7 +143,7 @@
+ // Implement the TAO_Base_Sequence methods (see Sequence.h)
+ 
+ ACE_INLINE CORBA::UShort *
+-CORBA_InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::get_buffer (CORBA::Boolean orphan)
++  CORBA::InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::get_buffer (CORBA::Boolean orphan)
+ {
+   CORBA::UShort *result = 0;
+   if (orphan == 0)
+@@ -177,13 +177,13 @@
+ }
+ 
+ ACE_INLINE const CORBA::UShort *
+-CORBA_InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::get_buffer (void) const
++  CORBA::InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::get_buffer (void) const
+ {
+   return ACE_reinterpret_cast(const CORBA::UShort * ACE_CAST_CONST, this->buffer_);
+ }
+ 
+ ACE_INLINE void
+-CORBA_InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::replace (CORBA::ULong max,
++  CORBA::InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::replace (CORBA::ULong max,
+ CORBA::ULong length,
+ CORBA::UShort *data,
+ CORBA::Boolean release)
+@@ -227,23 +227,23 @@
+ #if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_POLICYLIST_CI_)
+ #define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_POLICYLIST_CI_
+ 
+-ACE_INLINE CORBA_Policy **
++  ACE_INLINE CORBA::Policy **
+ _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::allocbuf (CORBA::ULong nelems)
+ {
+-  CORBA_Policy **buf = 0;
++    CORBA::Policy **buf = 0;
+   
+-  ACE_NEW_RETURN (buf, CORBA_Policy*[nelems], 0);
++    ACE_NEW_RETURN (buf, CORBA::Policy*[nelems], 0);
+   
+   for (CORBA::ULong i = 0; i < nelems; i++)
+     {
+-      buf[i] = CORBA_Policy::_nil ();
++        buf[i] = CORBA::Policy::_nil ();
+     }
+   
+   return buf;
+ }
+ 
+ ACE_INLINE void 
+-_TAO_Unbounded_Object_Sequence_CORBA_PolicyList::freebuf (CORBA_Policy **buffer)
++  _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::freebuf (CORBA::Policy **buffer)
+ {
+   if (buffer == 0)
+     return;
+@@ -264,7 +264,7 @@
+ ACE_INLINE
+ _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList (CORBA::ULong maximum,
+   CORBA::ULong length,
+-  CORBA_Policy* *value,
++    CORBA::Policy* *value,
+   CORBA::Boolean release)
+ : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+ {
+@@ -276,12 +276,12 @@
+ {
+   if (rhs.buffer_ != 0)
+   {
+-    CORBA_Policy **tmp1 = _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::allocbuf (this->maximum_);
+-    CORBA_Policy ** const tmp2 = ACE_reinterpret_cast (CORBA_Policy ** ACE_CAST_CONST, rhs.buffer_);
++      CORBA::Policy **tmp1 = _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::allocbuf (this->maximum_);
++      CORBA::Policy ** const tmp2 = ACE_reinterpret_cast (CORBA::Policy ** ACE_CAST_CONST, rhs.buffer_);
+     
+     for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+       {
+-        tmp1[i] = CORBA_Policy::_duplicate (tmp2[i]);
++          tmp1[i] = CORBA::Policy::_duplicate (tmp2[i]);
+       }
+     
+     this->buffer_ = tmp1;
+@@ -300,12 +300,12 @@
+   
+   if (this->release_)
+   {
+-    CORBA_Policy **tmp = ACE_reinterpret_cast (CORBA_Policy **, this->buffer_);
++      CORBA::Policy **tmp = ACE_reinterpret_cast (CORBA::Policy **, this->buffer_);
+     
+     for (CORBA::ULong i = 0; i < this->length_; ++i)
+     {
+       CORBA::release (tmp[i]);
+-      tmp[i] = CORBA_Policy::_nil ();
++        tmp[i] = CORBA::Policy::_nil ();
+     }
+     if (this->maximum_ < rhs.maximum_)
+     {
+@@ -318,30 +318,30 @@
+   
+   TAO_Unbounded_Base_Sequence::operator= (rhs);
+   
+-  CORBA_Policy **tmp1 = ACE_reinterpret_cast (CORBA_Policy **, this->buffer_);
+-  CORBA_Policy ** const tmp2 = ACE_reinterpret_cast (CORBA_Policy ** ACE_CAST_CONST, rhs.buffer_);
++    CORBA::Policy **tmp1 = ACE_reinterpret_cast (CORBA::Policy **, this->buffer_);
++    CORBA::Policy ** const tmp2 = ACE_reinterpret_cast (CORBA::Policy ** ACE_CAST_CONST, rhs.buffer_);
+   
+   for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+     {
+-      tmp1[i] = CORBA_Policy::_duplicate (tmp2[i]);
++        tmp1[i] = CORBA::Policy::_duplicate (tmp2[i]);
+     }
+   
+   return *this;
+ }
+ 
+-ACE_INLINE TAO_Object_Manager<CORBA_Policy,CORBA_Policy_var>
++  ACE_INLINE TAO_Object_Manager<CORBA::Policy,CORBA::Policy_var>
+ _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::operator[] (CORBA::ULong index) const
+ // read-write accessor
+ {
+   ACE_ASSERT (index < this->maximum_);
+-  CORBA_Policy ** const tmp = ACE_reinterpret_cast (CORBA_Policy ** ACE_CAST_CONST, this->buffer_);
+-  return TAO_Object_Manager<CORBA_Policy,CORBA_Policy_var> (tmp + index, this->release_);
++    CORBA::Policy ** const tmp = ACE_reinterpret_cast (CORBA::Policy ** ACE_CAST_CONST, this->buffer_);
++    return TAO_Object_Manager<CORBA::Policy,CORBA::Policy_var> (tmp + index, this->release_);
+ }
+ 
+-ACE_INLINE CORBA_Policy* *
++  ACE_INLINE CORBA::Policy* *
+ _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::get_buffer (CORBA::Boolean orphan)
+ {
+-  CORBA_Policy **result = 0;
++    CORBA::Policy **result = 0;
+   if (orphan == 0)
+   {
+     // We retain ownership.
+@@ -353,7 +353,7 @@
+     }
+     else
+     {
+-      result = ACE_reinterpret_cast (CORBA_Policy**, this->buffer_);
++        result = ACE_reinterpret_cast (CORBA::Policy**, this->buffer_);
+     }
+   }
+   else // if (orphan == 1)
+@@ -362,7 +362,7 @@
+     {
+       // We set the state back to default and relinquish
+       // ownership.
+-      result = ACE_reinterpret_cast(CORBA_Policy**,this->buffer_);
++        result = ACE_reinterpret_cast(CORBA::Policy**,this->buffer_);
+       this->maximum_ = 0;
+       this->length_ = 0;
+       this->buffer_ = 0;
+@@ -372,10 +372,10 @@
+   return result;
+ }
+ 
+-ACE_INLINE const CORBA_Policy* *
++  ACE_INLINE const CORBA::Policy* *
+ _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::get_buffer (void) const
+ {
+-  return ACE_reinterpret_cast(const CORBA_Policy ** ACE_CAST_CONST, this->buffer_);
++    return ACE_reinterpret_cast(const CORBA::Policy ** ACE_CAST_CONST, this->buffer_);
+ }
+ 
+ 
+@@ -489,7 +489,7 @@
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE TAO_Object_Manager<CORBA_Policy, CORBA_Policy_var>
++ACE_INLINE TAO_Object_Manager<CORBA::Policy, CORBA::Policy_var>
+ CORBA_PolicyList_var::operator[] (CORBA::ULong index)
+ {
+   return this->ptr_->operator[] (index);
+@@ -586,7 +586,7 @@
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE TAO_Object_Manager<CORBA_Policy, CORBA_Policy_var>
++ACE_INLINE TAO_Object_Manager<CORBA::Policy, CORBA::Policy_var>
+ CORBA_PolicyList_out::operator[] (CORBA::ULong index)
+ {
+   return this->ptr_->operator[] (index);
+@@ -776,7 +776,7 @@
+ #define _CORBA_POLICYTYPESEQ_CI_
+ 
+ // *************************************************************
+-// Inline operations for class CORBA_PolicyTypeSeq_var
++// Inline operations for class CORBA::PolicyTypeSeq_var
+ // *************************************************************
+ 
+ ACE_INLINE
+@@ -790,17 +790,17 @@
+ {}
+ 
+ ACE_INLINE
+-CORBA_PolicyTypeSeq_var::CORBA_PolicyTypeSeq_var (const ::CORBA_PolicyTypeSeq_var &p) // copy constructor
++CORBA_PolicyTypeSeq_var::CORBA_PolicyTypeSeq_var (const CORBA_PolicyTypeSeq_var &p) // copy constructor
+ {
+   if (p.ptr_)
+-    ACE_NEW (this->ptr_, ::CORBA_PolicyTypeSeq (*p.ptr_));
++    ACE_NEW (this->ptr_, CORBA_PolicyTypeSeq (*p.ptr_));
+   else
+     this->ptr_ = 0;
+ }
+ 
+ // fixed-size base types only
+ ACE_INLINE
+-CORBA_PolicyTypeSeq_var::CORBA_PolicyTypeSeq_var (const ::CORBA_PolicyTypeSeq &p)
++CORBA_PolicyTypeSeq_var::CORBA_PolicyTypeSeq_var (const CORBA_PolicyTypeSeq &p)
+ {
+   ACE_NEW (this->ptr_, ::CORBA_PolicyTypeSeq (p));
+ }
+@@ -849,42 +849,42 @@
+ 
+ // fixed-size types only
+ ACE_INLINE ::CORBA_PolicyTypeSeq_var &
+-CORBA_PolicyTypeSeq_var::operator= (const ::CORBA_PolicyTypeSeq &p)
++CORBA_PolicyTypeSeq_var::operator= (const ::CORBA::PolicyTypeSeq &p)
+ {
+   if (this->ptr_ != &p)
+   {
+     delete this->ptr_;
+-    ACE_NEW_RETURN (this->ptr_, ::CORBA_PolicyTypeSeq (p), *this);
++    ACE_NEW_RETURN (this->ptr_, ::CORBA::PolicyTypeSeq (p), *this);
+   }
+   return *this;
+ }
+ 
+-ACE_INLINE const ::CORBA_PolicyTypeSeq *
++ACE_INLINE const ::CORBA::PolicyTypeSeq *
+ CORBA_PolicyTypeSeq_var::operator-> (void) const
+ {
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE ::CORBA_PolicyTypeSeq *
++ACE_INLINE ::CORBA::PolicyTypeSeq *
+ CORBA_PolicyTypeSeq_var::operator-> (void)
+ {
+   return this->ptr_;
+ }
+ 
+ ACE_INLINE 
+-CORBA_PolicyTypeSeq_var::operator const ::CORBA_PolicyTypeSeq &() const // cast
++CORBA_PolicyTypeSeq_var::operator const ::CORBA::PolicyTypeSeq &() const // cast
+ {
+   return *this->ptr_;
+ }
+ 
+ ACE_INLINE 
+-CORBA_PolicyTypeSeq_var::operator ::CORBA_PolicyTypeSeq &() // cast 
++CORBA_PolicyTypeSeq_var::operator ::CORBA::PolicyTypeSeq &() // cast
+ {
+   return *this->ptr_;
+ }
+ 
+ ACE_INLINE 
+-CORBA_PolicyTypeSeq_var::operator ::CORBA_PolicyTypeSeq &() const // cast 
++CORBA_PolicyTypeSeq_var::operator ::CORBA::PolicyTypeSeq &() const // cast
+ {
+   return *this->ptr_;
+ }
+@@ -901,20 +901,20 @@
+   return ACE_const_cast (const CORBA::PolicyType &, this->ptr_->operator[] (index));
+ }
+ 
+-ACE_INLINE const ::CORBA_PolicyTypeSeq &
++ACE_INLINE const ::CORBA::PolicyTypeSeq &
+ CORBA_PolicyTypeSeq_var::in (void) const
+ {
+   return *this->ptr_;
+ }
+ 
+-ACE_INLINE ::CORBA_PolicyTypeSeq &
++ACE_INLINE ::CORBA::PolicyTypeSeq &
+ CORBA_PolicyTypeSeq_var::inout (void)
+ {
+   return *this->ptr_;
+ }
+ 
+ // mapping for variable size 
+-ACE_INLINE ::CORBA_PolicyTypeSeq *&
++ACE_INLINE ::CORBA::PolicyTypeSeq *&
+ CORBA_PolicyTypeSeq_var::out (void)
+ {
+   delete this->ptr_;
+@@ -922,15 +922,15 @@
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE ::CORBA_PolicyTypeSeq *
++ACE_INLINE ::CORBA::PolicyTypeSeq *
+ CORBA_PolicyTypeSeq_var::_retn (void)
+ {
+-  ::CORBA_PolicyTypeSeq *tmp = this->ptr_;
++  ::CORBA::PolicyTypeSeq *tmp = this->ptr_;
+   this->ptr_ = 0;
+   return tmp;
+ }
+ 
+-ACE_INLINE ::CORBA_PolicyTypeSeq *
++ACE_INLINE ::CORBA::PolicyTypeSeq *
+ CORBA_PolicyTypeSeq_var::ptr (void) const
+ {
+   return this->ptr_;
+@@ -975,18 +975,18 @@
+ }
+ 
+ ACE_INLINE 
+-CORBA_PolicyTypeSeq_out::operator ::CORBA_PolicyTypeSeq *&() // cast
++CORBA_PolicyTypeSeq_out::operator ::CORBA::PolicyTypeSeq *&() // cast
+ {
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE ::CORBA_PolicyTypeSeq *&
++ACE_INLINE ::CORBA::PolicyTypeSeq *&
+ CORBA_PolicyTypeSeq_out::ptr (void) // ptr
+ {
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE ::CORBA_PolicyTypeSeq *
++ACE_INLINE ::CORBA::PolicyTypeSeq *
+ CORBA_PolicyTypeSeq_out::operator-> (void)
+ {
+   return this->ptr_;
+@@ -1022,26 +1022,7 @@
  
  #endif /* end #if !defined */
  
-@@ -1112,12 +1234,12 @@
+-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::SetOverrideType &_tao_enumval)
+-{
+-  CORBA::ULong _tao_temp = _tao_enumval;
+-  return strm << _tao_temp;
+-}
+-
+-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::SetOverrideType &_tao_enumval)
+-{
+-  CORBA::ULong _tao_temp = 0;
+-  CORBA::Boolean _tao_result = strm >> _tao_temp;
+-  
+-  if (_tao_result == 1)
+-    {
+-      _tao_enumval = ACE_static_cast (CORBA::SetOverrideType, _tao_temp);
+-    }
+-  
+-  return _tao_result;
+-}
+-
+-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_PolicyError &_tao_aggregate)
++ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::PolicyError &_tao_aggregate)
+ {
+   // first marshal the repository ID
+   if (strm << _tao_aggregate._id ())
+@@ -1058,7 +1039,7 @@
+     return 0;
+ }
+ 
+-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm,CORBA_PolicyError &_tao_aggregate)
++ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm,CORBA::PolicyError &_tao_aggregate)
+ {
+   // now marshal the members
+   if (
+@@ -1075,16 +1056,16 @@
+ 
+ CORBA::Boolean TAO_Export operator<< (
+     TAO_OutputCDR &,
+-    const CORBA_InvalidPolicies::_tao_seq_UShort &
++    const CORBA::InvalidPolicies::_tao_seq_UShort &
+   );
+ CORBA::Boolean TAO_Export operator>> (
+     TAO_InputCDR &,
+-    CORBA_InvalidPolicies::_tao_seq_UShort &
++    CORBA::InvalidPolicies::_tao_seq_UShort &
+   );
+ 
+ #endif /* _TAO_CDR_OP_CORBA_InvalidPolicies__tao_seq_UShort_I_ */
+ 
+-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_InvalidPolicies &_tao_aggregate)
++ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::InvalidPolicies &_tao_aggregate)
+ {
+   // first marshal the repository ID
+   if (strm << _tao_aggregate._id ())
+@@ -1101,7 +1082,7 @@
      return 0;
  }
  
--TAO_Export CORBA::Boolean operator<< (
-+CORBA::Boolean TAO_Export operator<< (
+-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm,CORBA_InvalidPolicies &_tao_aggregate)
++ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm,CORBA::InvalidPolicies &_tao_aggregate)
+ {
+   // now marshal the members
+   if (
+@@ -1114,12 +1095,12 @@
+ 
+ TAO_Export CORBA::Boolean operator<< (
      TAO_OutputCDR &,
-     const CORBA_Policy_ptr
+-    const CORBA_Policy_ptr
++    const CORBA::Policy_ptr
+   );
+ 
+ TAO_Export CORBA::Boolean operator>> (
+     TAO_InputCDR &,
+-    CORBA_Policy_ptr &
++    CORBA::Policy_ptr &
    );
  
--TAO_Export CORBA::Boolean operator>> (
-+CORBA::Boolean TAO_Export operator>> (
+ 
+@@ -1143,12 +1124,30 @@
+ 
+ CORBA::Boolean TAO_Export operator<< (
+     TAO_OutputCDR &,
+-    const CORBA_PolicyTypeSeq &
++    const CORBA::PolicyTypeSeq &
+   );
+ CORBA::Boolean TAO_Export operator>> (
      TAO_InputCDR &,
-     CORBA_Policy_ptr &
+-    CORBA_PolicyTypeSeq &
++    CORBA::PolicyTypeSeq &
    );
+ 
+ #endif /* _TAO_CDR_OP_CORBA_PolicyTypeSeq_I_ */
+ 
++ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::SetOverrideType &_tao_enumval)
++{
++  CORBA::ULong _tao_temp = _tao_enumval;
++  return strm << _tao_temp;
++}
++
++ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::SetOverrideType &_tao_enumval)
++{
++  CORBA::ULong _tao_temp = 0;
++  CORBA::Boolean _tao_result = strm >> _tao_temp;
++
++  if (_tao_result == 1)
++    {
++      _tao_enumval = ACE_static_cast (CORBA::SetOverrideType, _tao_temp);
++    }
++
++  return _tao_result;
++}
diff --git a/TAO/tao/diffs/PolicyS.h.diff b/TAO/tao/diffs/PolicyS.h.diff
index bfb2cc7e888..fa5fb24e86e 100644
--- a/TAO/tao/diffs/PolicyS.h.diff
+++ b/TAO/tao/diffs/PolicyS.h.diff
@@ -1,126 +1,288 @@
---- orig/PolicyS.h	Mon Apr 30 21:23:11 2001
-+++ PolicyS.h	Mon Apr 30 21:20:13 2001
-@@ -1,6 +1,6 @@
- // -*- C++ -*-
- //
+--- orig/PolicyS.h	Tue Jun 12 17:22:53 2001
++++ PolicyS.h	Fri Dec 15 14:06:49 2000
+@@ -1,268 +1,23 @@
+-// -*- C++ -*-
+-//
 -// $Id$
-+// $Id$
- 
- // ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
- // TAO and the TAO IDL Compiler have been developed by:
-@@ -19,11 +19,11 @@
- // Information about TAO is available at:
- //     http://www.cs.wustl.edu/~schmidt/TAO.html
- 
--#ifndef _TAO_IDL_POLICYS_H_
--#define _TAO_IDL_POLICYS_H_
-+#ifndef _TAO_IDL_ORIG_POLICYS_H_
-+#define _TAO_IDL_ORIG_POLICYS_H_
- 
- #include "ace/pre.h"
+-
+-// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+-// TAO and the TAO IDL Compiler have been developed by:
+-//       Center for Distributed Object Computing
+-//       Washington University
+-//       St. Louis, MO
+-//       USA
+-//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+-// and
+-//       Distributed Object Computing Laboratory
+-//       University of California at Irvine
+-//       Irvine, CA
+-//       USA
+-//       http://doc.ece.uci.edu/
+-//
+-// Information about TAO is available at:
+-//     http://www.cs.wustl.edu/~schmidt/TAO.html
+-
+-#ifndef _TAO_IDL_ORIG_POLICYS_H_
+-#define _TAO_IDL_ORIG_POLICYS_H_
+-
+-#include "ace/pre.h"
 -#include "PolicyC.h"
+-
++/* -*- C++ -*- $Id$ */
++//=============================================================================
++/**
++ *  @file   PolicyS.h
++ *
++ *  $Id$
++ *
++ * The file is almost empty and only present to keep other IDL files
++ * that include Policy.pidl happy.
++ *
++ */
++//=============================================================================
++
++#ifndef TAO_PIDL_POLICY_S_H
++#define TAO_PIDL_POLICY_S_H
 +#include "tao/PolicyC.h"
  
- 
  #if !defined (ACE_LACKS_PRAGMA_ONCE)
-@@ -35,6 +35,8 @@
- #include "tao/PortableServer/Collocated_Object.h"
- #include "tao/PortableServer/ThruPOA_Object_Proxy_Impl.h"
- #include "tao/PortableServer/Direct_Object_Proxy_Impl.h"
-+#include "tao/PortableInterceptor.h"
-+
- #if defined(_MSC_VER)
- #if (_MSC_VER >= 1200)
- #pragma warning(push)
-@@ -46,15 +48,11 @@
- #pragma option push -w-rvl -w-rch -w-ccc -w-inl
- #endif /* __BORLANDC__ */
+ # pragma once
+ #endif /* ACE_LACKS_PRAGMA_ONCE */
  
+-#include "tao/PortableServer/PortableServer.h"
+-#include "tao/PortableServer/Servant_Base.h"
+-#include "tao/PortableServer/Collocated_Object.h"
+-#include "tao/PortableServer/ThruPOA_Object_Proxy_Impl.h"
+-#include "tao/PortableServer/Direct_Object_Proxy_Impl.h"
+-#if defined(_MSC_VER)
+-#if (_MSC_VER >= 1200)
+-#pragma warning(push)
+-#endif /* _MSC_VER >= 1200 */
+-#pragma warning(disable:4250)
+-#endif /* _MSC_VER */
+-
+-#if defined (__BORLANDC__)
+-#pragma option push -w-rvl -w-rch -w-ccc -w-inl
+-#endif /* __BORLANDC__ */
+-
 -TAO_NAMESPACE  POA_CORBA
 -{
 -}
 -TAO_NAMESPACE_CLOSE // module CORBA
 -
- class POA_CORBA_Policy;
- typedef POA_CORBA_Policy *POA_CORBA_Policy_ptr;
- // Forward Classes Declaration
- class _TAO_CORBA_Policy_ThruPOA_Proxy_Impl;
-+class _TAO_CORBA_Policy_Direct_Proxy_Impl;
- class _TAO_CORBA_Policy_Strategized_Proxy_Broker;
- 
- class TAO_PortableServer_Export POA_CORBA_Policy :  public virtual PortableServer::ServantBase
-@@ -184,6 +182,7 @@
-   );
- 
- private:
-+
-   // Helper methods that takes care to create the proxy
-   // as soon as their use is necessary.
-   void create_proxy (
-@@ -191,6 +190,8 @@
-     CORBA::Environment &ACE_TRY_ENV
-   );
-   
-+private:
-+
-   // Caches the proxy implementations. The proxy implementation
-   // are totally stateless, and those can be shared by all the
-   // instances of a given IDL interface type.
-@@ -249,11 +250,56 @@
-       CORBA::SystemException
-     ));
- 
+-class POA_CORBA_Policy;
+-typedef POA_CORBA_Policy *POA_CORBA_Policy_ptr;
+-// Forward Classes Declaration
+-class _TAO_CORBA_Policy_ThruPOA_Proxy_Impl;
+-class _TAO_CORBA_Policy_Strategized_Proxy_Broker;
 -
- };
- 
-+
- //
- //                ThruPOA  Proxy Impl. Declaration
-+///////////////////////////////////////////////////////////////////////
-+
-+
-+///////////////////////////////////////////////////////////////////////
-+//                    Direct  Impl. Declaration
-+//
-+
-+class TAO_PortableServer_Export _TAO_CORBA_Policy_Direct_Proxy_Impl :
-+  public virtual _TAO_CORBA_Policy_Proxy_Impl,
-+  public virtual TAO_Direct_Object_Proxy_Impl
-+{
-+public:
-+  _TAO_CORBA_Policy_Direct_Proxy_Impl (void);
-+
-+  virtual ~_TAO_CORBA_Policy_Direct_Proxy_Impl (void) { }
-+
-+    virtual CORBA::PolicyType policy_type (
-+      CORBA_Object *_collocated_tao_target_,
-+      CORBA::Environment &ACE_TRY_ENV
-+    )
-+    ACE_THROW_SPEC ((
-+      CORBA::SystemException
-+    ));
-+
-+  virtual CORBA_Policy_ptr copy (
-+      CORBA_Object *_collocated_tao_target_,
-+      CORBA::Environment &ACE_TRY_ENV
-+    )
-+    ACE_THROW_SPEC ((
-+      CORBA::SystemException
-+    ));
-+
-+  virtual void destroy (
-+      CORBA_Object *_collocated_tao_target_,
-+      CORBA::Environment &ACE_TRY_ENV
-+    )
-+    ACE_THROW_SPEC ((
-+      CORBA::SystemException
-+    ));
-+
-+};
-+
-+
-+//
-+//                Direct  Proxy Impl. Declaration
- ///////////////////////////////////////////////////////////////////////
- 
+-class TAO_Export POA_CORBA_Policy :  public virtual PortableServer::ServantBase
+-{
+-protected:
+-  POA_CORBA_Policy (void);
+-
+-public:
+-  POA_CORBA_Policy (const POA_CORBA_Policy& rhs);
+-  virtual ~POA_CORBA_Policy (void);
+-
+-
+-  virtual CORBA::Boolean _is_a (
+-      const char* logical_type_id,
+-      CORBA::Environment &ACE_TRY_ENV = 
+-        TAO_default_environment ()
+-    );
+-
+-  virtual void* _downcast (
+-      const char* logical_type_id
+-    );
+-
+-  static void _is_a_skel (
+-      TAO_ServerRequest &req,
+-      void *obj,
+-      void *servant_upcall,
+-      CORBA::Environment &ACE_TRY_ENV
+-    );
+-
+-  static void _non_existent_skel (
+-      TAO_ServerRequest &req,
+-      void *obj,
+-      void *servant_upcall,
+-      CORBA::Environment &ACE_TRY_ENV
+-    );
+-
+-  static void _interface_skel (
+-      TAO_ServerRequest &req,
+-      void *obj,
+-      void *servant_upcall,
+-      CORBA::Environment &ACE_TRY_ENV
+-    );
+-
+-  virtual void _dispatch (
+-      TAO_ServerRequest &req,
+-      void *_servant_upcall,
+-      CORBA::Environment &ACE_TRY_ENV
+-    );
+-
+-  ::CORBA_Policy *_this (
+-      CORBA::Environment &ACE_TRY_ENV = 
+-        TAO_default_environment ()
+-    );
+-
+-  virtual const char* _interface_repository_id (void) const;
+-
+-  virtual CORBA::PolicyType policy_type (
+-      CORBA::Environment &ACE_TRY_ENV = 
+-        TAO_default_environment ()
+-    )
+-    ACE_THROW_SPEC ((
+-      CORBA::SystemException
+-    )) = 0;
+-  
+-    static void _get_policy_type_skel (
+-      TAO_ServerRequest &_tao_req,
+-      void *_tao_obj,
+-      void *_tao_servant_upcall,
+-      CORBA::Environment &ACE_TRY_ENV
+-    );
+-
+-  virtual CORBA_Policy_ptr copy (
+-      CORBA::Environment &ACE_TRY_ENV = 
+-        TAO_default_environment ()
+-    )
+-    ACE_THROW_SPEC ((
+-      CORBA::SystemException
+-    )) = 0;
+-  
+-    static void copy_skel (
+-      TAO_ServerRequest &_tao_req,
+-      void *_tao_obj,
+-      void *_tao_servant_upcall,
+-      CORBA::Environment &ACE_TRY_ENV
+-    );
+-
+-  virtual void destroy (
+-      CORBA::Environment &ACE_TRY_ENV = 
+-        TAO_default_environment ()
+-    )
+-    ACE_THROW_SPEC ((
+-      CORBA::SystemException
+-    )) = 0;
+-  
+-    static void destroy_skel (
+-      TAO_ServerRequest &_tao_req,
+-      void *_tao_obj,
+-      void *_tao_servant_upcall,
+-      CORBA::Environment &ACE_TRY_ENV
+-    );
+-
+-
+-};
+-
+-
+-///////////////////////////////////////////////////////////////////////
+-//               Strategized Proxy Broker Declaration 
+-//
+-
+-class TAO_Export _TAO_CORBA_Policy_Strategized_Proxy_Broker : public virtual ::_TAO_CORBA_Policy_Proxy_Broker
+-{
+-public: 
+-  _TAO_CORBA_Policy_Strategized_Proxy_Broker (void);
+-  
+-  virtual ~_TAO_CORBA_Policy_Strategized_Proxy_Broker (void);
+-  
+-  virtual ::_TAO_CORBA_Policy_Proxy_Impl &select_proxy (
+-    ::CORBA_Policy *object,
+-    CORBA_Environment &ACE_TRY_ENV
+-  );
+-
+-private:
+-  // Helper methods that takes care to create the proxy
+-  // as soon as their use is necessary.
+-  void create_proxy (
+-    int collocation_strategy,
+-    CORBA::Environment &ACE_TRY_ENV
+-  );
+-  
+-  // Caches the proxy implementations. The proxy implementation
+-  // are totally stateless, and those can be shared by all the
+-  // instances of a given IDL interface type.
+-  ::_TAO_CORBA_Policy_Proxy_Impl
+-  *proxy_cache_[TAO_Collocation_Strategies::CS_LAST];
+-  
+-  TAO_SYNCH_MUTEX mutex_;
+-  // This funxtion is used to get an handle to the unique instance
+-  // of the Strategized Proxy Broker that is available for a given
+-  // interface.
+-
+-public:
+-  static _TAO_CORBA_Policy_Strategized_Proxy_Broker *the_TAO_CORBA_Policy_Strategized_Proxy_Broker (void);
+-};
+-
+-
+-//
+-//            End Strategized Proxy Broker Declaration 
+-///////////////////////////////////////////////////////////////////////
+-
+-
+-///////////////////////////////////////////////////////////////////////
+-//                    ThruPOA  Impl. Declaration
+-//
+-
+-class TAO_Export _TAO_CORBA_Policy_ThruPOA_Proxy_Impl : 
+-  public virtual ::_TAO_CORBA_Policy_Proxy_Impl,
+-  public virtual TAO_ThruPOA_Object_Proxy_Impl
+-{
+-public:
+-  _TAO_CORBA_Policy_ThruPOA_Proxy_Impl (void);
+-  
+-  virtual ~_TAO_CORBA_Policy_ThruPOA_Proxy_Impl (void) { }
+-  
+-  virtual CORBA::PolicyType policy_type (
+-      CORBA_Object *_collocated_tao_target_,
+-      CORBA::Environment &ACE_TRY_ENV
+-    )
+-    ACE_THROW_SPEC ((
+-      CORBA::SystemException
+-    ));
+-  
+-  virtual CORBA_Policy_ptr copy (
+-      CORBA_Object *_collocated_tao_target_,
+-      CORBA::Environment &ACE_TRY_ENV
+-    )
+-    ACE_THROW_SPEC ((
+-      CORBA::SystemException
+-    ));
+-  
+-  virtual void destroy (
+-      CORBA_Object *_collocated_tao_target_,
+-      CORBA::Environment &ACE_TRY_ENV
+-    )
+-    ACE_THROW_SPEC ((
+-      CORBA::SystemException
+-    ));
+-  
+-  
+-};
+-
+-//
+-//                ThruPOA  Proxy Impl. Declaration
+-///////////////////////////////////////////////////////////////////////
+-
+-
+-#include "PolicyS_T.h"
+-
+-#if defined (__ACE_INLINE__)
+-#include "PolicyS.i"
+-#endif /* defined INLINE */
+-
+-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+-#pragma warning(pop)
+-#endif /* _MSC_VER */
+-
+-#if defined (__BORLANDC__)
+-#pragma option pop
+-#endif /* __BORLANDC__ */
  
+-#include "ace/post.h"
+-#endif /* ifndef */
++#endif /* TAO_PIDL_POLICY_S_H*/
diff --git a/TAO/tao/diffs/TAOC.cpp.diff b/TAO/tao/diffs/TAOC.cpp.diff
index 80a65fd86d3..2749cd4f337 100644
--- a/TAO/tao/diffs/TAOC.cpp.diff
+++ b/TAO/tao/diffs/TAOC.cpp.diff
@@ -1,5 +1,5 @@
---- orig/TAOC.cpp	Wed Apr 25 00:17:55 2001
-+++ TAOC.cpp	Tue Apr 24 13:44:43 2001
+--- orig/TAOC.cpp	Tue Jun 12 17:41:13 2001
++++ TAOC.cpp	Tue Jun 12 13:58:15 2001
 @@ -1,6 +1,6 @@
  // -*- C++ -*-
  //
@@ -8,15 +8,18 @@
  
  // ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
  // TAO and the TAO IDL Compiler have been developed by:
-@@ -21,21 +21,14 @@
+@@ -21,24 +21,15 @@
  
  #include "TAOC.h"
  
 -#include "tao/Stub.h"
 -#include "tao/Invocation.h"
--#include "tao/ClientRequestInfo.h"
+-#include "tao/PortableInterceptor.h"
+-
 -#if TAO_HAS_INTERCEPTORS == 1
 -#include "tao/RequestInfo_Util.h"
+-#include "tao/ClientRequestInfo.h"
+-#include "tao/ClientInterceptorAdapter.h"
 -#endif  /* TAO_HAS_INTERCEPTORS == 1 */
 -
 -#if defined (__BORLANDC__)
@@ -28,94 +31,25 @@
  #include "TAOC.i"
  #endif /* !defined INLINE */
  
-+#if (TAO_HAS_CLIENT_PRIORITY_POLICY == 1)
 +
- static const CORBA::Long _oc_TAO_PrioritySelectionMode[] =
++#if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1)
++
+ static const CORBA::Long _oc_TAO_BufferingConstraintMode[] =
  {
    TAO_ENCAP_BYTE_ORDER, // byte order
-@@ -171,48 +164,6 @@
- TAO_NAMESPACE_BEGIN (TAO)
- TAO_NAMESPACE_DEFINE (const CORBA::ULong, CLIENT_PRIORITY_POLICY_TYPE, 1413545984U)
+@@ -187,9 +178,9 @@
+ TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_BufferingConstraint, &_tc_TAO_tc_TAO_BufferingConstraint)
  TAO_NAMESPACE_END
--TAO::ClientPriorityPolicy_ptr
--tao_TAO_ClientPriorityPolicy_duplicate (
--    TAO::ClientPriorityPolicy_ptr p
--  )
--{
--  return TAO::ClientPriorityPolicy::_duplicate (p);
--}
--
--void
--tao_TAO_ClientPriorityPolicy_release (
--    TAO::ClientPriorityPolicy_ptr p
--  )
--{
--  CORBA::release (p);
--}
--
--TAO::ClientPriorityPolicy_ptr
--tao_TAO_ClientPriorityPolicy_nil (
--    void
--  )
--{
--  return TAO::ClientPriorityPolicy::_nil ();
--}
--
--TAO::ClientPriorityPolicy_ptr
--tao_TAO_ClientPriorityPolicy_narrow (
--    CORBA::Object *p,
--    CORBA::Environment &ACE_TRY_ENV
--  )
--{
--  return TAO::ClientPriorityPolicy::_narrow (p, ACE_TRY_ENV);
--}
--
--CORBA::Object *
--tao_TAO_ClientPriorityPolicy_upcast (
--    void *src
--  )
--{
--  TAO::ClientPriorityPolicy **tmp =
--    ACE_static_cast (TAO::ClientPriorityPolicy **, src);
--  return *tmp;
--}
  
- // *************************************************************
- // Operations for class TAO::ClientPriorityPolicy_var
-@@ -336,7 +287,6 @@
-     ACE_static_cast (ClientPriorityPolicy **, src);
-   return *tmp;
- }
--
- // *************************************************************
- // Inline operations for class TAO::ClientPriorityPolicy_out
- // *************************************************************
-@@ -449,11 +399,11 @@
-   void *retv = 0;
-   if (type == ACE_reinterpret_cast
-     (ptr_arith_t,
--      &ACE_NESTED_CLASS (::TAO, ClientPriorityPolicy)::_narrow))
-+      &ClientPriorityPolicy::_narrow))
-     retv = ACE_reinterpret_cast (void*, this);
-   else if (type == ACE_reinterpret_cast
-     (ptr_arith_t,
--      &::CORBA::Policy::_narrow))
-+      &CORBA::Policy::_narrow))
-     retv = ACE_reinterpret_cast
-       (
-         void *,
-@@ -477,6 +427,10 @@
-   return "IDL:TAO/ClientPriorityPolicy:1.0";
+-void TAO::BufferingConstraint::_tao_any_destructor (void *_tao_void_pointer)
++void TAO::BufferingConstraint::_tao_any_destructor (void *x)
+ {
+-  BufferingConstraint *tmp = ACE_static_cast (BufferingConstraint*, _tao_void_pointer);
++  BufferingConstraint *tmp = ACE_static_cast (BufferingConstraint*,x);
+   delete tmp;
  }
  
-+#endif /* TAO_HAS_CLIENT_PRIORITY_POLICY == 1 */
-+
-+#if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1)
-+
- static const CORBA::Long _oc_TAO_BufferingConstraintMode[] =
- {
-   TAO_ENCAP_BYTE_ORDER, // byte order
-@@ -635,48 +589,6 @@
+@@ -197,48 +188,6 @@
  TAO_NAMESPACE_BEGIN (TAO)
  TAO_NAMESPACE_DEFINE (const CORBA::ULong, BUFFERING_CONSTRAINT_POLICY_TYPE, 1413545985U)
  TAO_NAMESPACE_END
@@ -164,15 +98,18 @@
  
  // *************************************************************
  // Operations for class TAO::BufferingConstraintPolicy_var
-@@ -800,7 +712,6 @@
+@@ -362,9 +311,8 @@
      ACE_static_cast (BufferingConstraintPolicy **, src);
    return *tmp;
  }
 -
  // *************************************************************
- // Inline operations for class TAO::BufferingConstraintPolicy_out
+-// Operations for class TAO::BufferingConstraintPolicy_out
++// Inline operations for class TAO::BufferingConstraintPolicy_out
  // *************************************************************
-@@ -913,11 +824,11 @@
+ 
+ TAO::BufferingConstraintPolicy_out::BufferingConstraintPolicy_out (BufferingConstraintPolicy_ptr &p)
+@@ -475,11 +423,11 @@
    void *retv = 0;
    if (type == ACE_reinterpret_cast
      (ptr_arith_t,
@@ -186,7 +123,7 @@
      retv = ACE_reinterpret_cast
        (
          void *,
-@@ -941,6 +852,8 @@
+@@ -503,6 +451,8 @@
    return "IDL:TAO/BufferingConstraintPolicy:1.0";
  }
  
@@ -195,51 +132,18 @@
  static const CORBA::Long _oc_TAO_SyncScope[] =
  {
    TAO_ENCAP_BYTE_ORDER, // byte order
-@@ -996,6 +909,9 @@
+@@ -558,6 +508,10 @@
  TAO_NAMESPACE_BEGIN (TAO)
  TAO_NAMESPACE_DEFINE (const CORBA::Short, SYNC_DELAYED_BUFFERING, -2)
  TAO_NAMESPACE_END
 +
-+#if (TAO_HAS_CLIENT_PRIORITY_POLICY == 1)
-+
- void operator<<= (CORBA::Any &_tao_any, const TAO::PrioritySpecification &_tao_elem) // copying
- {
-   TAO_OutputCDR stream;
-@@ -1032,12 +948,14 @@
-   ACE_TRY_NEW_ENV
-   {
-     CORBA::TypeCode_var type = _tao_any.type ();
--    
--    CORBA::Boolean result = type->equivalent (TAO::_tc_PrioritySpecification, ACE_TRY_ENV);
-+    CORBA::Boolean result =
-+      type->equivalent (TAO::_tc_PrioritySpecification, ACE_TRY_ENV);
-     ACE_TRY_CHECK;
-     
-     if (!result)
--      return 0; // not equivalent
-+      {
-+        return 0;
-+      }
-     
-     if (_tao_any.any_owns_data ())
-     {
-@@ -1079,12 +997,9 @@
-   return 0;
- }
- 
--#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
--    defined (ACE_HAS_GNU_REPO)
--    template class TAO_Object_Manager<TAO::ClientPriorityPolicy,TAO::ClientPriorityPolicy_var>;
--  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
--  #  pragma instantiate TAO_Object_Manager<TAO::ClientPriorityPolicy,TAO::ClientPriorityPolicy_var>
--#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-+#endif /* TAO_HAS_CLIENT_PRIORITY_POLICY == 1 */
 +
 +#if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1)
- 
++
  void operator<<= (CORBA::Any &_tao_any, const TAO::BufferingConstraint &_tao_elem) // copying
  {
-@@ -1122,12 +1037,14 @@
+   TAO_OutputCDR stream;
+@@ -594,12 +548,14 @@
    ACE_TRY_NEW_ENV
    {
      CORBA::TypeCode_var type = _tao_any.type ();
@@ -257,7 +161,7 @@
      
      if (_tao_any.any_owns_data ())
      {
-@@ -1169,10 +1086,4 @@
+@@ -641,10 +597,4 @@
    return 0;
  }
  
diff --git a/TAO/tao/diffs/TAOC.h.diff b/TAO/tao/diffs/TAOC.h.diff
index 96d4fcb851c..1f1ea50a547 100644
--- a/TAO/tao/diffs/TAOC.h.diff
+++ b/TAO/tao/diffs/TAOC.h.diff
@@ -1,5 +1,5 @@
---- orig/TAOC.h	Wed Apr 25 00:17:55 2001
-+++ TAOC.h	Tue Apr 24 13:44:43 2001
+--- orig/TAOC.h	Tue Jun 12 17:41:13 2001
++++ TAOC.h	Tue Jun 12 13:58:15 2001
 @@ -1,6 +1,6 @@
  // -*- C++ -*-
  //
@@ -8,7 +8,7 @@
  
  // ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
  // TAO and the TAO IDL Compiler have been developed by:
-@@ -19,19 +19,33 @@
+@@ -19,19 +19,29 @@
  // Information about TAO is available at:
  //     http://www.cs.wustl.edu/~schmidt/TAO.html
  
@@ -34,61 +34,97 @@
 -#include "tao/corbafwd.h"
 -#include "PolicyC.h"
 -#include "TimeBaseC.h"
-+#if (TAO_HAS_CLIENT_PRIORITY_POLICY == 1 || \
-+     TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1)
++#if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1)
 +
 +#include "tao/PolicyC.h"
 +#include "tao/TimeBaseC.h"
 +
-+#endif /* TAO_HAS_CLIENT_PRIORITY_POLICY == 1 ||
-+          TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1 */
-+
-+#include "tao/Priority_Mapping_Manager.h"
++#endif /* TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1 */
  
  #if defined (TAO_EXPORT_MACRO)
  #undef TAO_EXPORT_MACRO
-@@ -58,6 +72,19 @@
+@@ -58,6 +68,9 @@
  
  TAO_NAMESPACE  TAO
  {
 +
-+#if (TAO_HAS_RT_CORBA == 1)
-+
-+  typedef TAO_Priority_Mapping_Manager PriorityMappingManager;
-+  typedef TAO_Priority_Mapping_Manager *PriorityMappingManager_ptr;
-+  typedef TAO_Priority_Mapping_Manager_var PriorityMappingManager_var;
-+  typedef TAO_Priority_Mapping_Manager_out PriorityMappingManager_out;
-+
-+#endif /* TAO_HAS_RT_CORBA == 1 */
-+
-+
-+#if (TAO_HAS_CLIENT_PRIORITY_POLICY == 1)
-+
-   typedef CORBA::Short PrioritySelectionMode;
-   typedef CORBA::Short_out PrioritySelectionMode_out;
-     TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PrioritySelectionMode;
-@@ -239,8 +266,7 @@
-     virtual const char* _interface_repository_id (void) const;
- 
-   protected:
--    ClientPriorityPolicy ();
--    
-+    ClientPriorityPolicy (void);
-     virtual ~ClientPriorityPolicy (void);
-   private:
-     ClientPriorityPolicy (const ClientPriorityPolicy &);
-@@ -250,6 +276,10 @@
- 
- #endif /* end #if !defined */
- 
-+#endif /* TAO_HAS_CLIENT_PRIORITY_POLICY == 1 */
-+
 +#if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1)
 +
    typedef CORBA::UShort BufferingConstraintMode;
    typedef CORBA::UShort_out BufferingConstraintMode_out;
-     TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_BufferingConstraintMode;
-@@ -434,8 +464,7 @@
+   TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_BufferingConstraintMode;
+@@ -86,23 +99,20 @@
+     TimeBase::TimeT timeout;
+     CORBA::ULong message_count;
+     CORBA::ULong message_bytes;
+-    
+   };
+   
+   class TAO_Export BufferingConstraint_var
+   {
+   public:
+-    BufferingConstraint_var (void);
++    BufferingConstraint_var (void); // default constructor
+     BufferingConstraint_var (BufferingConstraint *);
+-    BufferingConstraint_var (const BufferingConstraint_var &);
+-    // Fixed-size types only.
+-    BufferingConstraint_var (const BufferingConstraint &);
+-    ~BufferingConstraint_var (void);
++    BufferingConstraint_var (const BufferingConstraint_var &); // copy constructor
++    BufferingConstraint_var (const BufferingConstraint &); // fixed-size types only
++    ~BufferingConstraint_var (void); // destructor
+     
+     BufferingConstraint_var &operator= (BufferingConstraint *);
+     BufferingConstraint_var &operator= (const BufferingConstraint_var &);
+-    // Fixed-size types only.
+-    BufferingConstraint_var &operator= (const BufferingConstraint &);
++    BufferingConstraint_var &operator= (const BufferingConstraint &); // fixed-size types only
+     BufferingConstraint *operator-> (void);
+     const BufferingConstraint *operator-> (void) const;
+     
+@@ -166,10 +176,7 @@
+     static BufferingConstraintPolicy_ptr duplicate (BufferingConstraintPolicy_ptr);
+     static void release (BufferingConstraintPolicy_ptr);
+     static BufferingConstraintPolicy_ptr nil (void);
+-    static BufferingConstraintPolicy_ptr narrow (
+-        CORBA::Object *,
+-        CORBA::Environment &
+-      );
++    static BufferingConstraintPolicy_ptr narrow (CORBA::Object *, CORBA::Environment &);
+     static CORBA::Object * upcast (void *);
+   
+   private:
+@@ -210,8 +217,7 @@
+ #if !defined (_TAO_BUFFERINGCONSTRAINTPOLICY_CH_)
+ #define _TAO_BUFFERINGCONSTRAINTPOLICY_CH_
+   
+-  class TAO_Export BufferingConstraintPolicy
+-    : public virtual CORBA::Policy
++class TAO_Export BufferingConstraintPolicy: public virtual CORBA::Policy
+   {
+   public:
+   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+@@ -221,19 +227,16 @@
+ 
+     // the static operations
+     static BufferingConstraintPolicy_ptr _duplicate (BufferingConstraintPolicy_ptr obj);
+-    
+     static BufferingConstraintPolicy_ptr _narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static BufferingConstraintPolicy_ptr _unchecked_narrow (
+         CORBA::Object_ptr obj,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       );
+-    
+     static BufferingConstraintPolicy_ptr _nil (void)
+       {
+         return (BufferingConstraintPolicy_ptr)0;
+@@ -252,10 +255,8 @@
      virtual const char* _interface_repository_id (void) const;
  
    protected:
@@ -96,33 +132,27 @@
 -    
 +    BufferingConstraintPolicy (void);
      virtual ~BufferingConstraintPolicy (void);
+-  
    private:
      BufferingConstraintPolicy (const BufferingConstraintPolicy &);
-@@ -445,6 +474,8 @@
- 
+     void operator= (const BufferingConstraintPolicy &);
+@@ -264,6 +265,8 @@
+   
  #endif /* end #if !defined */
- 
+   
 +#endif /* TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1 */
 +
    typedef CORBA::Short SyncScope;
    typedef CORBA::Short_out SyncScope_out;
-     TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_SyncScope;
-@@ -461,25 +492,41 @@
- 
+   TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_SyncScope;
+@@ -280,19 +283,26 @@
+   
    TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short SYNC_DELAYED_BUFFERING;
- 
--
+   
+-  
  }
  TAO_NAMESPACE_CLOSE // module TAO
  
-+#if (TAO_HAS_CLIENT_PRIORITY_POLICY == 1)
-+
- TAO_Export void operator<<= (CORBA::Any &, const TAO::PrioritySpecification &); // copying version
- TAO_Export void operator<<= (CORBA::Any &, TAO::PrioritySpecification*); // noncopying version
- TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO::PrioritySpecification *&); // deprecated
- TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const TAO::PrioritySpecification *&);
-+#endif /* TAO_HAS_CLIENT_PRIORITY_POLICY == 1 */
-+
 +#if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1)
 +
  TAO_Export void operator<<= (CORBA::Any &, const TAO::BufferingConstraint &); // copying version
@@ -134,13 +164,6 @@
 +
  #ifndef __ACE_INLINE__
  
-+#if (TAO_HAS_CLIENT_PRIORITY_POLICY == 1)
-+
- TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const TAO::PrioritySpecification &);
- TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, TAO::PrioritySpecification &);
-+
-+#endif /* TAO_HAS_CLIENT_PRIORITY_POLICY == 1 */
-+
 +#if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1)
 +
  TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const TAO::BufferingConstraint &);
diff --git a/TAO/tao/diffs/TAOC.i.diff b/TAO/tao/diffs/TAOC.i.diff
index 5f13661f046..1929df1049d 100644
--- a/TAO/tao/diffs/TAOC.i.diff
+++ b/TAO/tao/diffs/TAOC.i.diff
@@ -1,5 +1,5 @@
---- orig/TAOC.i	Wed Apr 25 00:17:55 2001
-+++ TAOC.i	Tue Apr 24 13:44:43 2001
+--- orig/TAOC.i	Tue Jun 12 17:41:13 2001
++++ TAOC.i	Tue Jun 12 13:58:15 2001
 @@ -1,6 +1,6 @@
  // -*- C++ -*-
  //
@@ -8,124 +8,26 @@
  
  // ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
  // TAO and the TAO IDL Compiler have been developed by:
-@@ -23,6 +23,8 @@
- // Inline operations for class TAO::PrioritySpecification_var
- // *************************************************************
- 
-+#if (TAO_HAS_CLIENT_PRIORITY_POLICY == 1)
-+
- ACE_INLINE
- TAO::PrioritySpecification_var::PrioritySpecification_var (void) // default constructor
-   : ptr_ (0)
-@@ -75,12 +77,12 @@
-         }
-       else
-         {
--          PrioritySpecification *deep_copy =
--            new PrioritySpecification (*p.ptr_);
-+          TAO::PrioritySpecification *deep_copy = 
-+            new TAO::PrioritySpecification (*p.ptr_);
-           
-           if (deep_copy != 0)
-             {
--              PrioritySpecification *tmp = deep_copy;
-+              TAO::PrioritySpecification *tmp = deep_copy;
-               deep_copy = this->ptr_;
-               this->ptr_ = tmp;
-               delete deep_copy;
-@@ -164,13 +166,84 @@
-   return this->ptr_;
- }
- 
--
- #if !defined (_TAO_CLIENTPRIORITYPOLICY___CI_)
- #define _TAO_CLIENTPRIORITYPOLICY___CI_
+@@ -20,6 +20,12 @@
+ //     http://www.cs.wustl.edu/~schmidt/TAO.html
  
-+ACE_INLINE TAO::ClientPriorityPolicy_ptr
-+tao_TAO_ClientPriorityPolicy_duplicate (
-+    TAO::ClientPriorityPolicy_ptr p
-+  )
-+{
-+  return TAO::ClientPriorityPolicy::_duplicate (p);
-+}
-+
-+ACE_INLINE void
-+tao_TAO_ClientPriorityPolicy_release (
-+    TAO::ClientPriorityPolicy_ptr p
-+  )
-+{
-+  CORBA::release (p);
-+}
-+
-+ACE_INLINE TAO::ClientPriorityPolicy_ptr
-+tao_TAO_ClientPriorityPolicy_nil (
-+    void
-+  )
-+{
-+  return TAO::ClientPriorityPolicy::_nil ();
-+}
-+
-+ACE_INLINE TAO::ClientPriorityPolicy_ptr
-+tao_TAO_ClientPriorityPolicy_narrow (
-+    CORBA::Object *p,
-+    CORBA::Environment &ACE_TRY_ENV
-+  )
-+{
-+  return TAO::ClientPriorityPolicy::_narrow (p, ACE_TRY_ENV);
-+}
-+
-+ACE_INLINE CORBA::Object *
-+tao_TAO_ClientPriorityPolicy_upcast (
-+    void *src
-+  )
-+{
-+  TAO::ClientPriorityPolicy **tmp =
-+    ACE_static_cast (TAO::ClientPriorityPolicy **, src);
-+  return *tmp;
-+}
-+
- 
- #endif /* end #if !defined */
- 
-+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const TAO::PrioritySpecification &_tao_aggregate)
-+{
-+  if (
-+    (strm << _tao_aggregate.mode) &&
-+    (strm << _tao_aggregate.min_priority) &&
-+    (strm << _tao_aggregate.max_priority)
-+  )
-+    return 1;
-+  else
-+    return 0;
-+
-+}
-+
-+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, TAO::PrioritySpecification &_tao_aggregate)
-+{
-+  if (
-+    (strm >> _tao_aggregate.mode) &&
-+    (strm >> _tao_aggregate.min_priority) &&
-+    (strm >> _tao_aggregate.max_priority)
-+  )
-+    return 1;
-+  else
-+    return 0;
-+
-+}
-+#endif /* TAO_HAS_CLIENT_PRIORITY_POLICY == 1 */
+ // *************************************************************
++// Inline operations for class TAO::PrioritySpecification_var
++// *************************************************************
 +
 +#if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1)
 +
- // *************************************************************
++// *************************************************************
  // Inline operations for class TAO::BufferingConstraint_var
  // *************************************************************
-@@ -227,12 +300,12 @@
+ 
+@@ -75,12 +81,12 @@
          }
        else
          {
 -          BufferingConstraint *deep_copy =
 -            new BufferingConstraint (*p.ptr_);
-+          TAO::BufferingConstraint *deep_copy = 
++          TAO::BufferingConstraint *deep_copy =
 +            new TAO::BufferingConstraint (*p.ptr_);
            
            if (deep_copy != 0)
@@ -135,7 +37,7 @@
                deep_copy = this->ptr_;
                this->ptr_ = tmp;
                delete deep_copy;
-@@ -316,39 +389,55 @@
+@@ -164,10 +170,52 @@
    return this->ptr_;
  }
  
@@ -143,44 +45,27 @@
  #if !defined (_TAO_BUFFERINGCONSTRAINTPOLICY___CI_)
  #define _TAO_BUFFERINGCONSTRAINTPOLICY___CI_
  
--
--#endif /* end #if !defined */
--
--ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const TAO::PrioritySpecification &_tao_aggregate)
--{
--  if (
--    (strm << _tao_aggregate.mode) &&
--    (strm << _tao_aggregate.min_priority) &&
--    (strm << _tao_aggregate.max_priority)
 +ACE_INLINE TAO::BufferingConstraintPolicy_ptr
 +tao_TAO_BufferingConstraintPolicy_duplicate (
 +    TAO::BufferingConstraintPolicy_ptr p
-   )
--    return 1;
--  else
--    return 0;
++  )
 +{
 +  return TAO::BufferingConstraintPolicy::_duplicate (p);
 +}
-   
++
 +ACE_INLINE void
 +tao_TAO_BufferingConstraintPolicy_release (
 +    TAO::BufferingConstraintPolicy_ptr p
 +  )
 +{
 +  CORBA::release (p);
- }
- 
--ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, TAO::PrioritySpecification &_tao_aggregate)
++}
++
 +ACE_INLINE TAO::BufferingConstraintPolicy_ptr
 +tao_TAO_BufferingConstraintPolicy_nil (
 +    void
 +  )
- {
--  if (
--    (strm >> _tao_aggregate.mode) &&
--    (strm >> _tao_aggregate.min_priority) &&
--    (strm >> _tao_aggregate.max_priority)
++{
 +  return TAO::BufferingConstraintPolicy::_nil ();
 +}
 +
@@ -188,14 +73,11 @@
 +tao_TAO_BufferingConstraintPolicy_narrow (
 +    CORBA::Object *p,
 +    CORBA::Environment &ACE_TRY_ENV
-   )
--    return 1;
--  else
--    return 0;
++  )
 +{
 +  return TAO::BufferingConstraintPolicy::_narrow (p, ACE_TRY_ENV);
 +}
-   
++
 +ACE_INLINE CORBA::Object *
 +tao_TAO_BufferingConstraintPolicy_upcast (
 +    void *src
@@ -204,15 +86,12 @@
 +  TAO::BufferingConstraintPolicy **tmp =
 +    ACE_static_cast (TAO::BufferingConstraintPolicy **, src);
 +  return *tmp;
- }
- 
-+
-+#endif /* end #if !defined */
++}
 +
- ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const TAO::BufferingConstraint &_tao_aggregate)
- {
-   if (
-@@ -377,3 +466,4 @@
+ 
+ #endif /* end #if !defined */
+ 
+@@ -199,3 +247,4 @@
    
  }