ChangeLogTag:Fri Aug 18 23:20:56 2000 Marina Spivak <marina@cs.wustl.edu>

13 files changed, 2254 insertions, 262 deletions

diff --git a/TAO/ChangeLogs/ChangeLog-02a b/TAO/ChangeLogs/ChangeLog-02a
index f9f60afbf62..a918d58784b 100644
--- a/TAO/ChangeLogs/ChangeLog-02a
+++ b/TAO/ChangeLogs/ChangeLog-02a
@@ -1,3 +1,33 @@
+Fri Aug 18 23:20:56 2000  Marina Spivak  <marina@cs.wustl.edu>
+
+	* tao/RTCORBA.pidl
+	* tao/RTCORBAC.cpp
+	* tao/RTCORBAC.h
+	* tao/RTCORBAC.i
+	* tao/RT_Policy_i.cpp
+	* tao/RT_Policy_i.h
+	* tao/diffs/RTCORBAC.cpp.diff
+	* tao/diffs/RTCORBAC.h.diff
+	* tao/diffs/RTCORBAC.i.diff:
+
+	  Added idl interfaces to allow configuration of UIOP and SHMIOP
+	  protocol properties through RTCORBA's ServerProtocolPolicy
+	  and ClientProtocolPolicy.
+
+	* tao/diffs/TAOC.h.diff
+	* tao/TAO.pidl
+
+	  Updated comments.
+
+	* tao/Policy_Manager.cpp (set_policy_overrides):
+
+	  Only one ServerProtocolPolicy should be included in a
+          given PolicyList (section 4.15.2 of RTCORBA 1.0, i.e.,
+          ptc/99-05-03).
+
+
+
+
 Fri Aug 18 19:30:00 2000  Kirthika  Parameswaran  <kirthika@cs.wustl.edu>
 	Visitors implemented as part of the TAO_IDL to generate
 	infrastructure for Portable Interceptors:
@@ -46,7 +76,7 @@ Fri Aug 18 19:30:00 2000  Kirthika  Parameswaran  <kirthika@cs.wustl.edu>
 	Most of the TAO_IDL changes are to add new visitors for generation
 	of the nested RequestInfo classes per operation of an interface
 	and also to be able to query the RequestInfo classes for argument
-	list etc on demand.	
+	list etc on demand.
 	TAO/tao additions:
 	* tao/PortableInterceptor.{h,i,cpp}:
 	* tao/PortableInterceptorC.{h,i,cpp}:
@@ -56,8 +86,8 @@ Fri Aug 18 19:30:00 2000  Kirthika  Parameswaran  <kirthika@cs.wustl.edu>
 	* tao/IOP_N.pidl:
 	* tao/Request_Info.{h,cpp}:
 	All the above are new Portable Interceptor related additions
-	to TAO/tao.	
-	* tao/ORB.h: 
+	to TAO/tao.
+	* tao/ORB.h:
 	* tao/corba.h:
 	included PortableInterceptor.h
 	* tao/ImplRepoC,S.cpp:
@@ -128,15 +158,15 @@ Fri Aug 18 19:30:00 2000  Kirthika  Parameswaran  <kirthika@cs.wustl.edu>
 	* tests/PortableInterceptors/Benchmark/test.idl:
 	* tests/PortableInterceptors/Benchmark/test_i.cpp:
 	* tests/PortableInterceptors/Benchmark/test_i.h:
-	* tests/PortableInterceptors/Benchmark/marker.h:		
+	* tests/PortableInterceptors/Benchmark/marker.h:
 	* tests/PortableInterceptors/Benchmark/marker.cpp:
 	This is a benchamrking test used and explained in
 	http://www.cs.wustl.edu/~schmidt/PDF/COOTS-00.pdf
-	* TAO/docs/interceptor.html: updated documentation to 
-	reflect these changes.  
+	* TAO/docs/interceptor.html: updated documentation to
+	reflect these changes.
 	Thanks to Nanbor for brainstorming and guidance,
-	Jeff for help on nitty-gritty IDL bugs and Doug on helping 
-	to put all this on white paper! 
+	Jeff for help on nitty-gritty IDL bugs and Doug on helping
+	to put all this on white paper!
 
 Fri Aug 18 17:46:34 2000  Balachandran Natarajan  <bala@cs.wustl.edu>
 
diff --git a/TAO/tao/Policy_Manager.cpp b/TAO/tao/Policy_Manager.cpp
index e23bf45bd52..18fa1a0fd9e 100644
--- a/TAO/tao/Policy_Manager.cpp
+++ b/TAO/tao/Policy_Manager.cpp
@@ -281,6 +281,10 @@ TAO_Policy_Manager_Impl::set_policy_overrides (
       ACE_CHECK;
     }
 
+  // Flag, indicating whether we have already overridden
+  // RTCORBA::ServerProtocolPolicy during this call.
+  int server_protocol_set = 0;
+
   for (CORBA::ULong i = 0; i < policies.length ();  ++i)
     {
       CORBA::Policy_ptr policy = policies[i];
@@ -480,6 +484,17 @@ TAO_Policy_Manager_Impl::set_policy_overrides (
 
         case TAO_RT_SERVER_PROTOCOL_POLICY_TYPE:
           {
+            // Only one ServerProtocolPolicy should be included in a
+            // given PolicyList (section 4.15.2 of RTCORBA 1.0, i.e.,
+            // ptc/99-05-03).
+            // User-caused exceptional conditions can leave the Policy
+            // Manager in an inconsistent state.  It is the
+            // responsibility of the user to return it to consistent state.
+            if (server_protocol_set != 0)
+              ACE_THROW (CORBA::INV_POLICY ());
+            else
+              server_protocol_set = 0;
+
             RTCORBA::ServerProtocolPolicy_var p =
               RTCORBA::ServerProtocolPolicy::_narrow (policy);
 
diff --git a/TAO/tao/RTCORBA.pidl b/TAO/tao/RTCORBA.pidl
index ecd0e4cd45e..0971f9a8b00 100644
--- a/TAO/tao/RTCORBA.pidl
+++ b/TAO/tao/RTCORBA.pidl
@@ -25,6 +25,10 @@
 //         all.  It is unclear whether that was intentional or a
 //         result of sloppiness.  Until the former is proved, the
 //         latter will be assumed and all interfaces made <local>.
+//     3.  Two TAO-specific interfaces, UnixDomainProtocolProperties
+//         and SharedMemoryProtocolProperties, have been added to allow
+//         configuration of TAO's UIOP and SHMEM pluggable protocols
+//         through RTCORBA Protocol Policies.
 //
 //   This file was used to generate the code in
 //   RTCORBA{C,S,S_T}.{h,i,cpp} The command used to generate code
@@ -32,7 +36,7 @@
 //
 //     tao_idl -o orig -Gp -Gd -Ge 1 -Gv \
 //          -Wb,export_macro=TAO_Export \
-//          -Wb,export_include=corbafwd.h \
+//          -Wb,export_include="tao/corbafwd.h" \
 //          -Wb,pre_include="ace/pre.h" \
 //          -Wb,post_include="ace/post.h" \
 //          RTCORBA.pidl
@@ -125,16 +129,36 @@ module RTCORBA
   local interface ProtocolProperties {};
 
   local interface TCPProtocolProperties : ProtocolProperties
-    {
-      attribute long send_buffer_size;
-      attribute long recv_buffer_size;
-      attribute boolean keep_alive;
-      attribute boolean dont_route;
-      attribute boolean no_delay;
-    };
+  {
+    attribute long send_buffer_size;
+    attribute long recv_buffer_size;
+    attribute boolean keep_alive;
+    attribute boolean dont_route;
+    attribute boolean no_delay;
+  };
 
   local interface GIOPProtocolProperties : ProtocolProperties {};
 
+  // Properties for TAO-specific protocols (these protocols &
+  // interfaces are not specified by the OMG).
+
+  // Communication over Unix Domain Sockets (Local IPC).
+  local interface UnixDomainProtocolProperties : ProtocolProperties
+  {
+    attribute long send_buffer_size;
+    attribute long recv_buffer_size;
+  };
+
+  // Communication over Shared Memory.
+  local interface SharedMemoryProtocolProperties : ProtocolProperties
+  {
+    attribute long preallocate_buffer_size;
+    attribute string mmap_filename;
+    attribute string mmap_lockname;
+  };
+
+  // End of TAO-specific interfaces.
+
   struct Protocol
   {
     IOP::ProfileId protocol_type;
@@ -146,16 +170,16 @@ module RTCORBA
   // Server Protocol Policy
   const CORBA::PolicyType SERVER_PROTOCOL_POLICY_TYPE = 0x54410004;
   local interface ServerProtocolPolicy : CORBA::Policy
-    {
-      readonly attribute ProtocolList protocols;
-    };
+  {
+    readonly attribute ProtocolList protocols;
+  };
 
   // Client Protocol Policy
   const CORBA::PolicyType CLIENT_PROTOCOL_POLICY_TYPE = 0x54410005;
   local interface ClientProtocolPolicy : CORBA::Policy
-    {
-      readonly attribute ProtocolList protocols;
-    };
+  {
+    readonly attribute ProtocolList protocols;
+  };
 
   // RT Current.
   local interface Current : CORBA::Current
diff --git a/TAO/tao/RTCORBAC.cpp b/TAO/tao/RTCORBAC.cpp
index 102651dae63..07ab2d369aa 100644
--- a/TAO/tao/RTCORBAC.cpp
+++ b/TAO/tao/RTCORBAC.cpp
@@ -936,6 +936,165 @@ const char* RTCORBA::GIOPProtocolProperties::_interface_repository_id (void) con
   return "IDL:omg.org/RTCORBA/GIOPProtocolProperties:1.0";
 }
 
+// default constructor
+RTCORBA::UnixDomainProtocolProperties::UnixDomainProtocolProperties (void)
+{}
+
+// destructor
+RTCORBA::UnixDomainProtocolProperties::~UnixDomainProtocolProperties (void)
+{}
+
+RTCORBA::UnixDomainProtocolProperties_ptr RTCORBA::UnixDomainProtocolProperties::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  return UnixDomainProtocolProperties::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+RTCORBA::UnixDomainProtocolProperties_ptr RTCORBA::UnixDomainProtocolProperties::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return UnixDomainProtocolProperties::_nil ();
+  return
+      ACE_reinterpret_cast
+        (
+          UnixDomainProtocolProperties_ptr,
+            obj->_tao_QueryInterface
+              (
+                ACE_reinterpret_cast
+                  (
+                    ptr_arith_t,
+                    &UnixDomainProtocolProperties::_narrow
+                  )
+              )
+        );
+}
+
+RTCORBA::UnixDomainProtocolProperties_ptr
+RTCORBA::UnixDomainProtocolProperties::_duplicate (UnixDomainProtocolProperties_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+void *RTCORBA::UnixDomainProtocolProperties::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &RTCORBA::UnixDomainProtocolProperties::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &RTCORBA::ProtocolProperties::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            RTCORBA::ProtocolProperties_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* RTCORBA::UnixDomainProtocolProperties::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/RTCORBA/UnixDomainProtocolProperties:1.0";
+}
+
+
+// default constructor
+RTCORBA::SharedMemoryProtocolProperties::SharedMemoryProtocolProperties (void)
+{}
+
+// destructor
+RTCORBA::SharedMemoryProtocolProperties::~SharedMemoryProtocolProperties (void)
+{}
+
+RTCORBA::SharedMemoryProtocolProperties_ptr RTCORBA::SharedMemoryProtocolProperties::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  return SharedMemoryProtocolProperties::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+RTCORBA::SharedMemoryProtocolProperties_ptr RTCORBA::SharedMemoryProtocolProperties::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return SharedMemoryProtocolProperties::_nil ();
+  return
+      ACE_reinterpret_cast
+        (
+          SharedMemoryProtocolProperties_ptr,
+            obj->_tao_QueryInterface
+              (
+                ACE_reinterpret_cast
+                  (
+                    ptr_arith_t,
+                    &SharedMemoryProtocolProperties::_narrow
+                  )
+              )
+        );
+}
+
+RTCORBA::SharedMemoryProtocolProperties_ptr
+RTCORBA::SharedMemoryProtocolProperties::_duplicate (SharedMemoryProtocolProperties_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+void *RTCORBA::SharedMemoryProtocolProperties::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &RTCORBA::SharedMemoryProtocolProperties::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &RTCORBA::ProtocolProperties::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            RTCORBA::ProtocolProperties_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* RTCORBA::SharedMemoryProtocolProperties::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/RTCORBA/SharedMemoryProtocolProperties:1.0";
+}
+
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
 
@@ -1865,6 +2024,20 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const RTCORBA::PriorityB
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<RTCORBA::UnixDomainProtocolProperties,RTCORBA::UnixDomainProtocolProperties_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<RTCORBA::UnixDomainProtocolProperties,RTCORBA::UnixDomainProtocolProperties_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<RTCORBA::SharedMemoryProtocolProperties,RTCORBA::SharedMemoryProtocolProperties_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<RTCORBA::SharedMemoryProtocolProperties,RTCORBA::SharedMemoryProtocolProperties_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
     template class TAO_Object_Manager<RTCORBA::ServerProtocolPolicy,RTCORBA::ServerProtocolPolicy_var>;
   #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
   #  pragma instantiate TAO_Object_Manager<RTCORBA::ServerProtocolPolicy,RTCORBA::ServerProtocolPolicy_var>
diff --git a/TAO/tao/RTCORBAC.h b/TAO/tao/RTCORBAC.h
index bc43ddbbb46..0700731d4e7 100644
--- a/TAO/tao/RTCORBAC.h
+++ b/TAO/tao/RTCORBAC.h
@@ -1397,6 +1397,316 @@ class TAO_Export GIOPProtocolProperties: public virtual ProtocolProperties
 
 #endif /* end #if !defined */
 
+
+
+#if !defined (_RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___PTR_CH_)
+#define _RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___PTR_CH_
+
+  class UnixDomainProtocolProperties;
+  typedef UnixDomainProtocolProperties *UnixDomainProtocolProperties_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___VAR_CH_)
+#define _RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___VAR_CH_
+
+  class TAO_Export UnixDomainProtocolProperties_var : public TAO_Base_var
+  {
+  public:
+    UnixDomainProtocolProperties_var (void); // default constructor
+    UnixDomainProtocolProperties_var (UnixDomainProtocolProperties_ptr p) : ptr_ (p) {}
+    UnixDomainProtocolProperties_var (const UnixDomainProtocolProperties_var &); // copy constructor
+    ~UnixDomainProtocolProperties_var (void); // destructor
+
+    UnixDomainProtocolProperties_var &operator= (UnixDomainProtocolProperties_ptr);
+    UnixDomainProtocolProperties_var &operator= (const UnixDomainProtocolProperties_var &);
+    UnixDomainProtocolProperties_ptr operator-> (void) const;
+
+    operator const UnixDomainProtocolProperties_ptr &() const;
+    operator UnixDomainProtocolProperties_ptr &();
+    // in, inout, out, _retn
+    UnixDomainProtocolProperties_ptr in (void) const;
+    UnixDomainProtocolProperties_ptr &inout (void);
+    UnixDomainProtocolProperties_ptr &out (void);
+    UnixDomainProtocolProperties_ptr _retn (void);
+    UnixDomainProtocolProperties_ptr ptr (void) const;
+
+  private:
+    UnixDomainProtocolProperties_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    UnixDomainProtocolProperties_var (const TAO_Base_var &rhs);
+    UnixDomainProtocolProperties_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___OUT_CH_)
+#define _RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___OUT_CH_
+
+  class TAO_Export UnixDomainProtocolProperties_out
+  {
+  public:
+    UnixDomainProtocolProperties_out (UnixDomainProtocolProperties_ptr &);
+    UnixDomainProtocolProperties_out (UnixDomainProtocolProperties_var &);
+    UnixDomainProtocolProperties_out (const UnixDomainProtocolProperties_out &);
+    UnixDomainProtocolProperties_out &operator= (const UnixDomainProtocolProperties_out &);
+    UnixDomainProtocolProperties_out &operator= (const UnixDomainProtocolProperties_var &);
+    UnixDomainProtocolProperties_out &operator= (UnixDomainProtocolProperties_ptr);
+    operator UnixDomainProtocolProperties_ptr &();
+    UnixDomainProtocolProperties_ptr &ptr (void);
+    UnixDomainProtocolProperties_ptr operator-> (void);
+
+  private:
+    UnixDomainProtocolProperties_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES_CH_)
+#define _RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES_CH_
+
+class TAO_Export UnixDomainProtocolProperties: public virtual ProtocolProperties
+  {
+  public:
+  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef UnixDomainProtocolProperties_ptr _ptr_type;
+    typedef UnixDomainProtocolProperties_var _var_type;
+  #endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    // 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;
+      }
+
+    virtual CORBA::Long send_buffer_size (
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void send_buffer_size (
+        CORBA::Long send_buffer_size,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::Long recv_buffer_size (
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void recv_buffer_size (
+        CORBA::Long recv_buffer_size,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void *_tao_QueryInterface (ptr_arith_t type);
+
+    virtual const char* _interface_repository_id (void) const;
+
+  protected:
+    UnixDomainProtocolProperties (void);
+    virtual ~UnixDomainProtocolProperties (void);
+  private:
+    UnixDomainProtocolProperties (const UnixDomainProtocolProperties &);
+    void operator= (const UnixDomainProtocolProperties &);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___PTR_CH_)
+#define _RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___PTR_CH_
+
+  class SharedMemoryProtocolProperties;
+  typedef SharedMemoryProtocolProperties *SharedMemoryProtocolProperties_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___VAR_CH_)
+#define _RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___VAR_CH_
+
+  class TAO_Export SharedMemoryProtocolProperties_var : public TAO_Base_var
+  {
+  public:
+    SharedMemoryProtocolProperties_var (void); // default constructor
+    SharedMemoryProtocolProperties_var (SharedMemoryProtocolProperties_ptr p) : ptr_ (p) {}
+    SharedMemoryProtocolProperties_var (const SharedMemoryProtocolProperties_var &); // copy constructor
+    ~SharedMemoryProtocolProperties_var (void); // destructor
+
+    SharedMemoryProtocolProperties_var &operator= (SharedMemoryProtocolProperties_ptr);
+    SharedMemoryProtocolProperties_var &operator= (const SharedMemoryProtocolProperties_var &);
+    SharedMemoryProtocolProperties_ptr operator-> (void) const;
+
+    operator const SharedMemoryProtocolProperties_ptr &() const;
+    operator SharedMemoryProtocolProperties_ptr &();
+    // in, inout, out, _retn
+    SharedMemoryProtocolProperties_ptr in (void) const;
+    SharedMemoryProtocolProperties_ptr &inout (void);
+    SharedMemoryProtocolProperties_ptr &out (void);
+    SharedMemoryProtocolProperties_ptr _retn (void);
+    SharedMemoryProtocolProperties_ptr ptr (void) const;
+
+  private:
+    SharedMemoryProtocolProperties_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    SharedMemoryProtocolProperties_var (const TAO_Base_var &rhs);
+    SharedMemoryProtocolProperties_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___OUT_CH_)
+#define _RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___OUT_CH_
+
+  class TAO_Export SharedMemoryProtocolProperties_out
+  {
+  public:
+    SharedMemoryProtocolProperties_out (SharedMemoryProtocolProperties_ptr &);
+    SharedMemoryProtocolProperties_out (SharedMemoryProtocolProperties_var &);
+    SharedMemoryProtocolProperties_out (const SharedMemoryProtocolProperties_out &);
+    SharedMemoryProtocolProperties_out &operator= (const SharedMemoryProtocolProperties_out &);
+    SharedMemoryProtocolProperties_out &operator= (const SharedMemoryProtocolProperties_var &);
+    SharedMemoryProtocolProperties_out &operator= (SharedMemoryProtocolProperties_ptr);
+    operator SharedMemoryProtocolProperties_ptr &();
+    SharedMemoryProtocolProperties_ptr &ptr (void);
+    SharedMemoryProtocolProperties_ptr operator-> (void);
+
+  private:
+    SharedMemoryProtocolProperties_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES_CH_)
+#define _RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES_CH_
+
+class TAO_Export SharedMemoryProtocolProperties: public virtual ProtocolProperties
+  {
+  public:
+  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef SharedMemoryProtocolProperties_ptr _ptr_type;
+    typedef SharedMemoryProtocolProperties_var _var_type;
+  #endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    // 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;
+      }
+
+    virtual CORBA::Long preallocate_buffer_size (
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void preallocate_buffer_size (
+        CORBA::Long preallocate_buffer_size,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual char * mmap_filename (
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void mmap_filename (
+        const char * mmap_filename,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual char * mmap_lockname (
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void mmap_lockname (
+        const char * mmap_lockname,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void *_tao_QueryInterface (ptr_arith_t type);
+
+    virtual const char* _interface_repository_id (void) const;
+
+  protected:
+    SharedMemoryProtocolProperties (void);
+    virtual ~SharedMemoryProtocolProperties (void);
+  private:
+    SharedMemoryProtocolProperties (const SharedMemoryProtocolProperties &);
+    void operator= (const SharedMemoryProtocolProperties &);
+  };
+
+
+#endif /* end #if !defined */
+
   struct Protocol;
   class Protocol_var;
 
diff --git a/TAO/tao/RTCORBAC.i b/TAO/tao/RTCORBAC.i
index 11fab69c31b..c908bf0dfcb 100644
--- a/TAO/tao/RTCORBAC.i
+++ b/TAO/tao/RTCORBAC.i
@@ -2310,6 +2310,346 @@ RTCORBA::GIOPProtocolProperties_out::operator-> (void)
 
 #endif /* end #if !defined */
 
+
+#if !defined (_RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___VAR_CI_)
+#define _RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___VAR_CI_
+
+// *************************************************************
+// Inline operations for class RTCORBA::UnixDomainProtocolProperties_var
+// *************************************************************
+
+ACE_INLINE
+RTCORBA::UnixDomainProtocolProperties_var::UnixDomainProtocolProperties_var (void) // default constructor
+  : ptr_ (UnixDomainProtocolProperties::_nil ())
+{}
+
+ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr
+RTCORBA::UnixDomainProtocolProperties_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+RTCORBA::UnixDomainProtocolProperties_var::UnixDomainProtocolProperties_var (const ::RTCORBA::UnixDomainProtocolProperties_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (UnixDomainProtocolProperties::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+RTCORBA::UnixDomainProtocolProperties_var::~UnixDomainProtocolProperties_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE RTCORBA::UnixDomainProtocolProperties_var &
+RTCORBA::UnixDomainProtocolProperties_var::operator= (UnixDomainProtocolProperties_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE RTCORBA::UnixDomainProtocolProperties_var &
+RTCORBA::UnixDomainProtocolProperties_var::operator= (const ::RTCORBA::UnixDomainProtocolProperties_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::RTCORBA::UnixDomainProtocolProperties::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE
+RTCORBA::UnixDomainProtocolProperties_var::operator const ::RTCORBA::UnixDomainProtocolProperties_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+RTCORBA::UnixDomainProtocolProperties_var::operator ::RTCORBA::UnixDomainProtocolProperties_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr
+RTCORBA::UnixDomainProtocolProperties_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr
+RTCORBA::UnixDomainProtocolProperties_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr &
+RTCORBA::UnixDomainProtocolProperties_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr &
+RTCORBA::UnixDomainProtocolProperties_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::RTCORBA::UnixDomainProtocolProperties::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr
+RTCORBA::UnixDomainProtocolProperties_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::RTCORBA::UnixDomainProtocolProperties_ptr val = this->ptr_;
+  this->ptr_ = ::RTCORBA::UnixDomainProtocolProperties::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___OUT_CI_)
+#define _RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___OUT_CI_
+
+// *************************************************************
+// Inline operations for class RTCORBA::UnixDomainProtocolProperties_out
+// *************************************************************
+
+ACE_INLINE
+RTCORBA::UnixDomainProtocolProperties_out::UnixDomainProtocolProperties_out (UnixDomainProtocolProperties_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::RTCORBA::UnixDomainProtocolProperties::_nil ();
+}
+
+ACE_INLINE
+RTCORBA::UnixDomainProtocolProperties_out::UnixDomainProtocolProperties_out (UnixDomainProtocolProperties_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::RTCORBA::UnixDomainProtocolProperties::_nil ();
+}
+
+ACE_INLINE
+RTCORBA::UnixDomainProtocolProperties_out::UnixDomainProtocolProperties_out (const ::RTCORBA::UnixDomainProtocolProperties_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (UnixDomainProtocolProperties_out &, p).ptr_)
+{}
+
+ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_out &
+RTCORBA::UnixDomainProtocolProperties_out::operator= (const ::RTCORBA::UnixDomainProtocolProperties_out &p)
+{
+  this->ptr_ = ACE_const_cast (UnixDomainProtocolProperties_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE RTCORBA::UnixDomainProtocolProperties_out &
+RTCORBA::UnixDomainProtocolProperties_out::operator= (const ::RTCORBA::UnixDomainProtocolProperties_var &p)
+{
+  this->ptr_ = ::RTCORBA::UnixDomainProtocolProperties::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE RTCORBA::UnixDomainProtocolProperties_out &
+RTCORBA::UnixDomainProtocolProperties_out::operator= (UnixDomainProtocolProperties_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE
+RTCORBA::UnixDomainProtocolProperties_out::operator ::RTCORBA::UnixDomainProtocolProperties_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr &
+RTCORBA::UnixDomainProtocolProperties_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr
+RTCORBA::UnixDomainProtocolProperties_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___VAR_CI_)
+#define _RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___VAR_CI_
+
+// *************************************************************
+// Inline operations for class RTCORBA::SharedMemoryProtocolProperties_var
+// *************************************************************
+
+ACE_INLINE
+RTCORBA::SharedMemoryProtocolProperties_var::SharedMemoryProtocolProperties_var (void) // default constructor
+  : ptr_ (SharedMemoryProtocolProperties::_nil ())
+{}
+
+ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr
+RTCORBA::SharedMemoryProtocolProperties_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+RTCORBA::SharedMemoryProtocolProperties_var::SharedMemoryProtocolProperties_var (const ::RTCORBA::SharedMemoryProtocolProperties_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (SharedMemoryProtocolProperties::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+RTCORBA::SharedMemoryProtocolProperties_var::~SharedMemoryProtocolProperties_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE RTCORBA::SharedMemoryProtocolProperties_var &
+RTCORBA::SharedMemoryProtocolProperties_var::operator= (SharedMemoryProtocolProperties_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE RTCORBA::SharedMemoryProtocolProperties_var &
+RTCORBA::SharedMemoryProtocolProperties_var::operator= (const ::RTCORBA::SharedMemoryProtocolProperties_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::RTCORBA::SharedMemoryProtocolProperties::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE
+RTCORBA::SharedMemoryProtocolProperties_var::operator const ::RTCORBA::SharedMemoryProtocolProperties_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+RTCORBA::SharedMemoryProtocolProperties_var::operator ::RTCORBA::SharedMemoryProtocolProperties_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr
+RTCORBA::SharedMemoryProtocolProperties_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr
+RTCORBA::SharedMemoryProtocolProperties_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr &
+RTCORBA::SharedMemoryProtocolProperties_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr &
+RTCORBA::SharedMemoryProtocolProperties_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::RTCORBA::SharedMemoryProtocolProperties::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr
+RTCORBA::SharedMemoryProtocolProperties_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::RTCORBA::SharedMemoryProtocolProperties_ptr val = this->ptr_;
+  this->ptr_ = ::RTCORBA::SharedMemoryProtocolProperties::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___OUT_CI_)
+#define _RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___OUT_CI_
+
+// *************************************************************
+// Inline operations for class RTCORBA::SharedMemoryProtocolProperties_out
+// *************************************************************
+
+ACE_INLINE
+RTCORBA::SharedMemoryProtocolProperties_out::SharedMemoryProtocolProperties_out (SharedMemoryProtocolProperties_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::RTCORBA::SharedMemoryProtocolProperties::_nil ();
+}
+
+ACE_INLINE
+RTCORBA::SharedMemoryProtocolProperties_out::SharedMemoryProtocolProperties_out (SharedMemoryProtocolProperties_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::RTCORBA::SharedMemoryProtocolProperties::_nil ();
+}
+
+ACE_INLINE
+RTCORBA::SharedMemoryProtocolProperties_out::SharedMemoryProtocolProperties_out (const ::RTCORBA::SharedMemoryProtocolProperties_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (SharedMemoryProtocolProperties_out &, p).ptr_)
+{}
+
+ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_out &
+RTCORBA::SharedMemoryProtocolProperties_out::operator= (const ::RTCORBA::SharedMemoryProtocolProperties_out &p)
+{
+  this->ptr_ = ACE_const_cast (SharedMemoryProtocolProperties_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE RTCORBA::SharedMemoryProtocolProperties_out &
+RTCORBA::SharedMemoryProtocolProperties_out::operator= (const ::RTCORBA::SharedMemoryProtocolProperties_var &p)
+{
+  this->ptr_ = ::RTCORBA::SharedMemoryProtocolProperties::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE RTCORBA::SharedMemoryProtocolProperties_out &
+RTCORBA::SharedMemoryProtocolProperties_out::operator= (SharedMemoryProtocolProperties_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE
+RTCORBA::SharedMemoryProtocolProperties_out::operator ::RTCORBA::SharedMemoryProtocolProperties_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr &
+RTCORBA::SharedMemoryProtocolProperties_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr
+RTCORBA::SharedMemoryProtocolProperties_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
 // *************************************************************
 // Inline operations for class RTCORBA::Protocol_var
 // *************************************************************
diff --git a/TAO/tao/RT_Policy_i.cpp b/TAO/tao/RT_Policy_i.cpp
index ea54995ff96..03deb6e227f 100644
--- a/TAO/tao/RT_Policy_i.cpp
+++ b/TAO/tao/RT_Policy_i.cpp
@@ -408,6 +408,111 @@ TAO_TCP_Properties::_tao_decode (TAO_InputCDR &in_cdr)
 
 // ****************************************************************
 
+TAO_Unix_Domain_Properties::TAO_Unix_Domain_Properties
+(CORBA::Long send_buffer_size,
+ CORBA::Long recv_buffer_size)
+  : send_buffer_size_ (send_buffer_size),
+    recv_buffer_size_ (recv_buffer_size)
+{
+}
+
+TAO_Unix_Domain_Properties::~TAO_Unix_Domain_Properties (void)
+{
+}
+
+CORBA::Long
+TAO_Unix_Domain_Properties::send_buffer_size (CORBA::Environment &)
+  ACE_THROW_SPEC (())
+{
+  return this->send_buffer_size_;
+}
+
+void
+TAO_Unix_Domain_Properties::send_buffer_size (CORBA::Long send_buffer_size,
+                                              CORBA::Environment &)
+  ACE_THROW_SPEC (())
+{
+  this->send_buffer_size_ = send_buffer_size;
+}
+
+CORBA::Long
+TAO_Unix_Domain_Properties::recv_buffer_size (CORBA::Environment &)
+  ACE_THROW_SPEC (())
+{
+  return this->recv_buffer_size_;
+}
+
+void
+TAO_Unix_Domain_Properties::recv_buffer_size (CORBA::Long recv_buffer_size,
+                                              CORBA::Environment &)
+  ACE_THROW_SPEC (())
+{
+  this->recv_buffer_size_ = recv_buffer_size;
+}
+
+// ****************************************************************
+
+TAO_SMEM_Properties::TAO_SMEM_Properties (CORBA::Long preallocate_buffer_size,
+                                          const char * mmap_filename,
+                                          const char * mmap_lockname)
+  : preallocate_buffer_size_ (preallocate_buffer_size),
+    mmap_filename_ (mmap_filename),
+    mmap_lockname_ (mmap_lockname)
+{
+}
+
+TAO_SMEM_Properties::~TAO_SMEM_Properties (void)
+{
+}
+
+
+CORBA::Long
+TAO_SMEM_Properties::preallocate_buffer_size (CORBA::Environment &)
+  ACE_THROW_SPEC (())
+{
+  return this->preallocate_buffer_size_;
+}
+
+void
+TAO_SMEM_Properties::preallocate_buffer_size (CORBA::Long preallocate_buffer_size,
+                                              CORBA::Environment &)
+  ACE_THROW_SPEC (())
+{
+  this->preallocate_buffer_size_ = preallocate_buffer_size;
+}
+
+char *
+TAO_SMEM_Properties::mmap_filename (CORBA::Environment &)
+  ACE_THROW_SPEC (())
+{
+  return this->mmap_filename_.rep ();
+}
+
+void
+TAO_SMEM_Properties::mmap_filename (const char * mmap_filename,
+                                    CORBA::Environment &)
+  ACE_THROW_SPEC (())
+{
+  this->mmap_filename_.set (mmap_filename);
+}
+
+char *
+TAO_SMEM_Properties::mmap_lockname (CORBA::Environment &)
+  ACE_THROW_SPEC (())
+{
+  return this->mmap_lockname_.rep ();
+}
+
+void
+TAO_SMEM_Properties::mmap_lockname (const char * mmap_lockname,
+                                    CORBA::Environment &)
+  ACE_THROW_SPEC (())
+{
+  this->mmap_lockname_.set (mmap_lockname);
+}
+
+// ****************************************************************
+
 TAO_ServerProtocolPolicy::TAO_ServerProtocolPolicy (const
                                                     RTCORBA::ProtocolList &protocols)
   : RTCORBA::ServerProtocolPolicy (),
@@ -563,7 +668,7 @@ TAO_ClientProtocolPolicy::_tao_decode (TAO_InputCDR &in_cdr)
 {
   CORBA::ULong length;
   CORBA::Boolean is_read_ok = in_cdr >> length;
-  
+
   this->protocols_.length (length);
 
   for (CORBA::ULong i = 0; (i < length) && is_read_ok; i++)
@@ -571,23 +676,23 @@ TAO_ClientProtocolPolicy::_tao_decode (TAO_InputCDR &in_cdr)
       is_read_ok = in_cdr >> this->protocols_[i].protocol_type;
 
       this->protocols_[i].orb_protocol_properties =
-        TAO_Protocol_Properties_Factory::create_orb_protocol_property 
+        TAO_Protocol_Properties_Factory::create_orb_protocol_property
         (this->protocols_[i].protocol_type);
 
       this->protocols_[i].transport_protocol_properties =
-        TAO_Protocol_Properties_Factory::create_transport_protocol_property 
+        TAO_Protocol_Properties_Factory::create_transport_protocol_property
         (this->protocols_[i].protocol_type);
-      
-      if (is_read_ok 
+
+      if (is_read_ok
           && (this->protocols_[i].orb_protocol_properties.ptr () == 0))
         is_read_ok =
           this->protocols_[i].orb_protocol_properties->_tao_decode (in_cdr);
-      
+
       if (is_read_ok
           && (this->protocols_[i].transport_protocol_properties.ptr () == 0))
         is_read_ok =
           this->protocols_[i].transport_protocol_properties->_tao_decode (in_cdr);
-      
+
     }
 
   return is_read_ok;
@@ -602,16 +707,16 @@ TAO_GIOP_Properties::~TAO_GIOP_Properties (void)
 {
 }
 
-CORBA::Boolean 
+CORBA::Boolean
 TAO_GIOP_Properties::_tao_encode (TAO_OutputCDR &out_cdr)
 {
   ACE_UNUSED_ARG (out_cdr);
   return 1;
 }
 
-CORBA::Boolean 
+CORBA::Boolean
 TAO_GIOP_Properties::_tao_decode (TAO_InputCDR &in_cdr)
-{ 
+{
   ACE_UNUSED_ARG (in_cdr);
   return 1;
 }
diff --git a/TAO/tao/RT_Policy_i.h b/TAO/tao/RT_Policy_i.h
index d4cc228bc04..49c39a85edd 100644
--- a/TAO/tao/RT_Policy_i.h
+++ b/TAO/tao/RT_Policy_i.h
@@ -99,9 +99,6 @@ public:
   virtual CORBA::Boolean _tao_decode (TAO_InputCDR &in_cdr);
   // This method reads the object state from a CDR representation.
 
-  // = Override CORBA::LocalObject no-op methods to
-  // provide reference counting.
-
 protected:
 
   friend class TAO_Policy_Factory;
@@ -151,14 +148,11 @@ public:
   virtual CORBA::Policy_ptr copy (CORBA::Environment &ACE_TRY_ENV =
                                   TAO_default_environment ())
     ACE_THROW_SPEC ((CORBA::SystemException));
-  
+
   virtual void destroy (CORBA::Environment &ACE_TRY_ENV =
                         TAO_default_environment ())
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  // = Override CORBA::LocalObject no-op methods to
-  // provide reference counting.
-
 private:
 
   RTCORBA::ThreadpoolId id_;
@@ -201,10 +195,6 @@ public:
   virtual void destroy (CORBA::Environment &ACE_TRY_ENV =
                         TAO_default_environment ())
     ACE_THROW_SPEC ((CORBA::SystemException));
-
-  // = Override CORBA::LocalObject no-op methods to
-  // provide reference counting.
-
 };
 
 ////////////////////////////////////////////////////////////////////////////
@@ -263,9 +253,6 @@ public:
   virtual CORBA::Boolean _tao_decode (TAO_InputCDR &in_cdr);
   // This method reads the object state from a CDR representation.
 
-  // = Override CORBA::LocalObject no-op methods to
-  // provide reference counting.
-
 protected:
 
   friend class TAO_Policy_Factory;
@@ -319,9 +306,6 @@ public:
                         TAO_default_environment ())
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  // = Override CORBA::LocalObject no-op methods to
-  // provide reference counting.
-
 private:
 
   RTCORBA::ProtocolList protocols_;
@@ -382,9 +366,6 @@ public:
   virtual CORBA::Boolean _tao_decode (TAO_InputCDR &in_cdr);
   // This method reads the object state from a CDR representation.
 
-  // = Override CORBA::LocalObject no-op methods to
-  // provide reference counting.
-
 protected:
 
   friend class TAO_Policy_Factory;
@@ -478,9 +459,6 @@ public:
   virtual CORBA::Boolean _tao_decode (TAO_InputCDR &in_cdr);
   // This method reads the object state from a CDR representation.
 
-  // = Override CORBA::LocalObject no-op methods to
-  // provide reference counting.
-
 private:
   // = Attributes.
 
@@ -491,7 +469,120 @@ private:
   CORBA::Boolean no_delay_;
 };
 
-class  TAO_Protocol_Properties_Factory;
+//////////////////////////////////////////////////////////////////////
+
+class TAO_Export TAO_Unix_Domain_Properties :
+  public RTCORBA::ProtocolProperties,
+  public TAO_Local_RefCounted_Object
+{
+  // = TITLE
+  //   RTCORBA::UnixDomainProtocolProperties implementation.
+  //
+  // = DESCRIPTION
+  //   Stores Unix Domain Sockets (Local IPC) Protocol configuration
+  //   properties.
+  //
+public:
+  TAO_Unix_Domain_Properties (CORBA::Long send_buffer_size =
+                              ACE_DEFAULT_MAX_SOCKET_BUFSIZ,
+                              CORBA::Long recv_buffer_size =
+                              ACE_DEFAULT_MAX_SOCKET_BUFSIZ);
+
+  // Constructor.
+
+  virtual ~TAO_Unix_Domain_Properties (void);
+  // Destructor.
+
+  virtual CORBA::Long send_buffer_size (CORBA::Environment
+                                        &ACE_TRY_ENV =
+                                        TAO_default_environment ())
+    ACE_THROW_SPEC (());
+
+  virtual void send_buffer_size (CORBA::Long send_buffer_size,
+                                 CORBA::Environment &ACE_TRY_ENV =
+                                 TAO_default_environment ())
+    ACE_THROW_SPEC (());
+
+  virtual CORBA::Long recv_buffer_size (CORBA::Environment
+                                        &ACE_TRY_ENV =
+                                        TAO_default_environment ())
+    ACE_THROW_SPEC (());
+
+  virtual void recv_buffer_size (CORBA::Long recv_buffer_size,
+                                 CORBA::Environment &ACE_TRY_ENV =
+                                 TAO_default_environment ())
+    ACE_THROW_SPEC (());
+
+private:
+
+  // = Attributes.
+  CORBA::Long send_buffer_size_;
+  CORBA::Long recv_buffer_size_;
+};
+
+//////////////////////////////////////////////////////////////////////
+
+class TAO_Export TAO_SMEM_Properties :
+  public RTCORBA::ProtocolProperties,
+  public TAO_Local_RefCounted_Object
+{
+  // = TITLE
+  //   RTCORBA::SharedMemoryProtocolProperties implementation.
+  //
+  // = DESCRIPTION
+  //   Stores Shared Memory Protocol configuration
+  //   properties.
+  //
+public:
+  TAO_SMEM_Properties (CORBA::Long preallocate_buffer_size = 0,
+                       const char * mmap_filename = 0,
+                       const char * mmap_lockname = 0);
+  // Constructor.
+
+  virtual ~TAO_SMEM_Properties (void);
+  // Destructor.
+
+  // = IDL interface methods.
+
+  virtual CORBA::Long preallocate_buffer_size (CORBA::Environment
+                                               &ACE_TRY_ENV =
+                                               TAO_default_environment
+                                               ())
+    ACE_THROW_SPEC (());
+
+  virtual void preallocate_buffer_size (CORBA::Long preallocate_buffer_size,
+                                        CORBA::Environment
+                                        &ACE_TRY_ENV = TAO_default_environment
+                                        ())
+    ACE_THROW_SPEC (());
+
+  virtual char * mmap_filename (CORBA::Environment &ACE_TRY_ENV =
+                                TAO_default_environment ())
+    ACE_THROW_SPEC (());
+
+  virtual void mmap_filename (const char * mmap_filename,
+                              CORBA::Environment &ACE_TRY_ENV =
+                              TAO_default_environment ())
+    ACE_THROW_SPEC (());
+
+  virtual char * mmap_lockname (CORBA::Environment &ACE_TRY_ENV =
+                                TAO_default_environment ())
+    ACE_THROW_SPEC (());
+
+  virtual void mmap_lockname (const char * mmap_lockname,
+                              CORBA::Environment &ACE_TRY_ENV =
+                              TAO_default_environment ())
+    ACE_THROW_SPEC (());
+
+private:
+
+  // = Attributes.
+  CORBA::Long preallocate_buffer_size_;
+  ACE_CString mmap_filename_;
+  ACE_CString mmap_lockname_;
+};
+
+/////////////////////////////////////////////////////////////////////////
 
 class TAO_Export TAO_GIOP_Properties :
   public RTCORBA::GIOPProtocolProperties,
@@ -501,19 +592,18 @@ public:
   virtual ~TAO_GIOP_Properties ();
 
   // = CDR encoding methods
-  
+
   virtual CORBA::Boolean _tao_encode (TAO_OutputCDR &out_cdr);
 
   virtual CORBA::Boolean _tao_decode (TAO_InputCDR &in_cdr);
 
-  // = Override CORBA::LocalObject no-op methods to
-  // provide reference counting.
-
 protected:
   friend class TAO_Protocol_Properties_Factory;
   TAO_GIOP_Properties (void);
 };
 
+//////////////////////////////////////////////////////////////////////////
+
 class TAO_Export TAO_Protocol_Properties_Factory
 {
 public:
diff --git a/TAO/tao/TAO.pidl b/TAO/tao/TAO.pidl
index b5e0ec7fc14..23b356d2815 100644
--- a/TAO/tao/TAO.pidl
+++ b/TAO/tao/TAO.pidl
@@ -17,7 +17,9 @@
 //
 //   tao_idl -o orig -Gp -Gd -Ge 1 -Gv  \
 //       -Wb,export_macro=TAO_Export \
-//       -Wb,export_include="tao/corbafwd.h" Messaging.pidl
+//       -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
diff --git a/TAO/tao/diffs/RTCORBAC.cpp.diff b/TAO/tao/diffs/RTCORBAC.cpp.diff
index b2c29ceabea..57aa7cbd5b6 100644
--- a/TAO/tao/diffs/RTCORBAC.cpp.diff
+++ b/TAO/tao/diffs/RTCORBAC.cpp.diff
@@ -1,5 +1,5 @@
---- orig/RTCORBAC.cpp	Thu Jun 15 13:59:41 2000
-+++ RTCORBAC.cpp	Fri Jun  9 13:00:53 2000
+--- orig/RTCORBAC.cpp	Sat May 20 22:29:17 2000
++++ RTCORBAC.cpp	Fri Aug 18 20:40:33 2000
 @@ -1,4 +1,4 @@
 -/* -*- C++ -*- $Id$ */
 +/* -*- C++ -*- $Id$ */
@@ -394,7 +394,7 @@
  RTCORBA::ProtocolProperties_ptr RTCORBA::ProtocolProperties::_narrow (
      CORBA::Object_ptr obj,
      CORBA::Environment &ACE_TRY_ENV
-@@ -802,30 +762,40 @@
+@@ -802,30 +762,37 @@
    void *retv = 0;
    if (type == ACE_reinterpret_cast
      (ptr_arith_t,
@@ -415,9 +415,6 @@
 +//////////////////////////////////////////////////////
 +// CDR Encoding Support
 +
-+// @@ Angelo, can you explain to me why these methods here return
-+// true, while same methods in PolicyC.cpp return false?
-+
 +CORBA::Boolean
 +RTCORBA::ProtocolProperties::_tao_encode (TAO_OutputCDR &)
  {
@@ -445,7 +442,7 @@
  
  RTCORBA::TCPProtocolProperties_ptr RTCORBA::TCPProtocolProperties::_narrow (
      CORBA::Object_ptr obj,
-@@ -870,11 +840,11 @@
+@@ -870,11 +837,11 @@
    void *retv = 0;
    if (type == ACE_reinterpret_cast
      (ptr_arith_t,
@@ -459,7 +456,7 @@
      retv = ACE_reinterpret_cast
        (
          void *,
-@@ -887,7 +857,7 @@
+@@ -887,7 +854,7 @@
    else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
      retv = ACE_reinterpret_cast (void *,
        ACE_static_cast (CORBA::Object_ptr, this));
@@ -468,7 +465,7 @@
    if (retv)
      this->_add_ref ();
    return retv;
-@@ -898,15 +868,6 @@
+@@ -898,15 +865,6 @@
    return "IDL:omg.org/RTCORBA/TCPProtocolProperties:1.0";
  }
  
@@ -484,7 +481,7 @@
  RTCORBA::GIOPProtocolProperties_ptr RTCORBA::GIOPProtocolProperties::_narrow (
      CORBA::Object_ptr obj,
      CORBA::Environment &ACE_TRY_ENV
-@@ -950,11 +911,11 @@
+@@ -950,11 +908,11 @@
    void *retv = 0;
    if (type == ACE_reinterpret_cast
      (ptr_arith_t,
@@ -498,7 +495,7 @@
      retv = ACE_reinterpret_cast
        (
          void *,
-@@ -967,7 +928,7 @@
+@@ -967,7 +925,7 @@
    else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
      retv = ACE_reinterpret_cast (void *,
        ACE_static_cast (CORBA::Object_ptr, this));
@@ -507,8 +504,169 @@
    if (retv)
      this->_add_ref ();
    return retv;
-@@ -980,7 +941,7 @@
+@@ -978,9 +936,168 @@
+   return "IDL:omg.org/RTCORBA/GIOPProtocolProperties:1.0";
+ }
  
++// default constructor
++RTCORBA::UnixDomainProtocolProperties::UnixDomainProtocolProperties (void)
++{}
++
++// destructor
++RTCORBA::UnixDomainProtocolProperties::~UnixDomainProtocolProperties (void)
++{}
++
++RTCORBA::UnixDomainProtocolProperties_ptr RTCORBA::UnixDomainProtocolProperties::_narrow (
++    CORBA::Object_ptr obj,
++    CORBA::Environment &ACE_TRY_ENV
++  )
++{
++  return UnixDomainProtocolProperties::_unchecked_narrow (obj, ACE_TRY_ENV);
++}
++
++RTCORBA::UnixDomainProtocolProperties_ptr RTCORBA::UnixDomainProtocolProperties::_unchecked_narrow (
++    CORBA::Object_ptr obj,
++    CORBA::Environment &
++  )
++{
++  if (CORBA::is_nil (obj))
++    return UnixDomainProtocolProperties::_nil ();
++  return
++      ACE_reinterpret_cast
++        (
++          UnixDomainProtocolProperties_ptr,
++            obj->_tao_QueryInterface
++              (
++                ACE_reinterpret_cast
++                  (
++                    ptr_arith_t,
++                    &UnixDomainProtocolProperties::_narrow
++                  )
++              )
++        );
++}
++
++RTCORBA::UnixDomainProtocolProperties_ptr
++RTCORBA::UnixDomainProtocolProperties::_duplicate (UnixDomainProtocolProperties_ptr obj)
++{
++  if (!CORBA::is_nil (obj))
++    obj->_add_ref ();
++  return obj;
++}
++
++void *RTCORBA::UnixDomainProtocolProperties::_tao_QueryInterface (ptr_arith_t type)
++{
++  void *retv = 0;
++  if (type == ACE_reinterpret_cast
++    (ptr_arith_t,
++      &RTCORBA::UnixDomainProtocolProperties::_narrow))
++    retv = ACE_reinterpret_cast (void*, this);
++  else if (type == ACE_reinterpret_cast
++    (ptr_arith_t,
++      &RTCORBA::ProtocolProperties::_narrow))
++    retv = ACE_reinterpret_cast
++      (
++        void *,
++        ACE_static_cast
++          (
++            RTCORBA::ProtocolProperties_ptr,
++            this
++          )
++      );
++  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
++    retv = ACE_reinterpret_cast (void *,
++      ACE_static_cast (CORBA::Object_ptr, this));
++
++  if (retv)
++    this->_add_ref ();
++  return retv;
++}
++
++const char* RTCORBA::UnixDomainProtocolProperties::_interface_repository_id (void) const
++{
++  return "IDL:omg.org/RTCORBA/UnixDomainProtocolProperties:1.0";
++}
++
++
++// default constructor
++RTCORBA::SharedMemoryProtocolProperties::SharedMemoryProtocolProperties (void)
++{}
++
++// destructor
++RTCORBA::SharedMemoryProtocolProperties::~SharedMemoryProtocolProperties (void)
++{}
++
++RTCORBA::SharedMemoryProtocolProperties_ptr RTCORBA::SharedMemoryProtocolProperties::_narrow (
++    CORBA::Object_ptr obj,
++    CORBA::Environment &ACE_TRY_ENV
++  )
++{
++  return SharedMemoryProtocolProperties::_unchecked_narrow (obj, ACE_TRY_ENV);
++}
++
++RTCORBA::SharedMemoryProtocolProperties_ptr RTCORBA::SharedMemoryProtocolProperties::_unchecked_narrow (
++    CORBA::Object_ptr obj,
++    CORBA::Environment &
++  )
++{
++  if (CORBA::is_nil (obj))
++    return SharedMemoryProtocolProperties::_nil ();
++  return
++      ACE_reinterpret_cast
++        (
++          SharedMemoryProtocolProperties_ptr,
++            obj->_tao_QueryInterface
++              (
++                ACE_reinterpret_cast
++                  (
++                    ptr_arith_t,
++                    &SharedMemoryProtocolProperties::_narrow
++                  )
++              )
++        );
++}
++
++RTCORBA::SharedMemoryProtocolProperties_ptr
++RTCORBA::SharedMemoryProtocolProperties::_duplicate (SharedMemoryProtocolProperties_ptr obj)
++{
++  if (!CORBA::is_nil (obj))
++    obj->_add_ref ();
++  return obj;
++}
++
++void *RTCORBA::SharedMemoryProtocolProperties::_tao_QueryInterface (ptr_arith_t type)
++{
++  void *retv = 0;
++  if (type == ACE_reinterpret_cast
++    (ptr_arith_t,
++      &RTCORBA::SharedMemoryProtocolProperties::_narrow))
++    retv = ACE_reinterpret_cast (void*, this);
++  else if (type == ACE_reinterpret_cast
++    (ptr_arith_t,
++      &RTCORBA::ProtocolProperties::_narrow))
++    retv = ACE_reinterpret_cast
++      (
++        void *,
++        ACE_static_cast
++          (
++            RTCORBA::ProtocolProperties_ptr,
++            this
++          )
++      );
++  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
++    retv = ACE_reinterpret_cast (void *,
++      ACE_static_cast (CORBA::Object_ptr, this));
++
++  if (retv)
++    this->_add_ref ();
++  return retv;
++}
++
++const char* RTCORBA::SharedMemoryProtocolProperties::_interface_repository_id (void) const
++{
++  return "IDL:omg.org/RTCORBA/SharedMemoryProtocolProperties:1.0";
++}
++
  
  #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
 -  
@@ -516,7 +674,7 @@
  #if !defined (__TAO_UNBOUNDED_SEQUENCE_RTCORBA_PROTOCOLLIST_CS_)
  #define __TAO_UNBOUNDED_SEQUENCE_RTCORBA_PROTOCOLLIST_CS_
  
-@@ -989,43 +950,43 @@
+@@ -989,43 +1106,43 @@
    {
      RTCORBA::Protocol* tmp = 0;
      tmp = _TAO_Unbounded_Sequence_RTCORBA_ProtocolList::allocbuf (length);
@@ -572,7 +730,7 @@
  
  #if !defined (_RTCORBA_PROTOCOLLIST_CS_)
  #define _RTCORBA_PROTOCOLLIST_CS_
-@@ -1037,30 +998,30 @@
+@@ -1037,30 +1154,30 @@
  RTCORBA::ProtocolList::ProtocolList (void)
  {}
  RTCORBA::ProtocolList::ProtocolList (CORBA::ULong max) // uses max size
@@ -609,7 +767,7 @@
   (seq)
  {}
  RTCORBA::ProtocolList::~ProtocolList (void) // dtor
-@@ -1078,15 +1039,6 @@
+@@ -1078,15 +1195,6 @@
  TAO_NAMESPACE_BEGIN (RTCORBA)
  TAO_NAMESPACE_DEFINE (const CORBA::ULong, SERVER_PROTOCOL_POLICY_TYPE, 1413545988U)
  TAO_NAMESPACE_END
@@ -625,7 +783,7 @@
  RTCORBA::ServerProtocolPolicy_ptr RTCORBA::ServerProtocolPolicy::_narrow (
      CORBA::Object_ptr obj,
      CORBA::Environment &ACE_TRY_ENV
-@@ -1130,11 +1082,11 @@
+@@ -1130,11 +1238,11 @@
    void *retv = 0;
    if (type == ACE_reinterpret_cast
      (ptr_arith_t,
@@ -639,7 +797,7 @@
      retv = ACE_reinterpret_cast
        (
          void *,
-@@ -1147,7 +1099,7 @@
+@@ -1147,7 +1255,7 @@
    else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
      retv = ACE_reinterpret_cast (void *,
        ACE_static_cast (CORBA::Object_ptr, this));
@@ -648,7 +806,7 @@
    if (retv)
      this->_add_ref ();
    return retv;
-@@ -1162,15 +1114,6 @@
+@@ -1162,15 +1270,6 @@
  TAO_NAMESPACE_BEGIN (RTCORBA)
  TAO_NAMESPACE_DEFINE (const CORBA::ULong, CLIENT_PROTOCOL_POLICY_TYPE, 1413545989U)
  TAO_NAMESPACE_END
@@ -664,7 +822,7 @@
  RTCORBA::ClientProtocolPolicy_ptr RTCORBA::ClientProtocolPolicy::_narrow (
      CORBA::Object_ptr obj,
      CORBA::Environment &ACE_TRY_ENV
-@@ -1214,11 +1157,11 @@
+@@ -1214,11 +1313,11 @@
    void *retv = 0;
    if (type == ACE_reinterpret_cast
      (ptr_arith_t,
@@ -678,7 +836,7 @@
      retv = ACE_reinterpret_cast
        (
          void *,
-@@ -1231,7 +1174,7 @@
+@@ -1231,7 +1330,7 @@
    else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
      retv = ACE_reinterpret_cast (void *,
        ACE_static_cast (CORBA::Object_ptr, this));
@@ -687,7 +845,7 @@
    if (retv)
      this->_add_ref ();
    return retv;
-@@ -1242,15 +1185,6 @@
+@@ -1242,15 +1341,6 @@
    return "IDL:omg.org/RTCORBA/ClientProtocolPolicy:1.0";
  }
  
@@ -703,7 +861,7 @@
  RTCORBA::Current_ptr RTCORBA::Current::_narrow (
      CORBA::Object_ptr obj,
      CORBA::Environment &ACE_TRY_ENV
-@@ -1294,11 +1228,11 @@
+@@ -1294,11 +1384,11 @@
    void *retv = 0;
    if (type == ACE_reinterpret_cast
      (ptr_arith_t,
@@ -717,7 +875,7 @@
      retv = ACE_reinterpret_cast
        (
          void *,
-@@ -1311,7 +1245,7 @@
+@@ -1311,7 +1401,7 @@
    else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
      retv = ACE_reinterpret_cast (void *,
        ACE_static_cast (CORBA::Object_ptr, this));
@@ -726,7 +884,7 @@
    if (retv)
      this->_add_ref ();
    return retv;
-@@ -1322,15 +1256,6 @@
+@@ -1322,15 +1412,6 @@
    return "IDL:omg.org/RTCORBA/Current:1.0";
  }
  
@@ -742,7 +900,7 @@
  RTCORBA::Mutex_ptr RTCORBA::Mutex::_narrow (
      CORBA::Object_ptr obj,
      CORBA::Environment &ACE_TRY_ENV
-@@ -1374,12 +1299,12 @@
+@@ -1374,12 +1455,12 @@
    void *retv = 0;
    if (type == ACE_reinterpret_cast
      (ptr_arith_t,
@@ -757,7 +915,7 @@
    if (retv)
      this->_add_ref ();
    return retv;
-@@ -1390,15 +1315,6 @@
+@@ -1390,15 +1471,6 @@
    return "IDL:omg.org/RTCORBA/Mutex:1.0";
  }
  
@@ -773,7 +931,19 @@
  RTCORBA::RTORB_ptr RTCORBA::RTORB::_narrow (
      CORBA::Object_ptr obj,
      CORBA::Environment &ACE_TRY_ENV
-@@ -1464,7 +1380,7 @@
+@@ -1449,9 +1521,9 @@
+ 
+ // copy constructor
+ RTCORBA::RTORB::InvalidThreadpool::InvalidThreadpool (const ::RTCORBA::RTORB::InvalidThreadpool &_tao_excp)
+-  : CORBA_UserException (_tao_excp._type ())
++  : CORBA_UserException (_tao_excp._id ())
+ {
+-  }
++}
+ 
+ // assignment operator
+ RTCORBA::RTORB::InvalidThreadpool&
+@@ -1464,7 +1536,7 @@
  
  // narrow
  RTCORBA::RTORB::InvalidThreadpool *
@@ -782,7 +952,7 @@
  {
    if (!ACE_OS::strcmp ("IDL:omg.org/RTCORBA/RTORB/InvalidThreadpool:1.0", exc->_id ())) // same type
      return ACE_dynamic_cast (InvalidThreadpool *, exc);
-@@ -1507,12 +1423,12 @@
+@@ -1507,12 +1579,12 @@
    void *retv = 0;
    if (type == ACE_reinterpret_cast
      (ptr_arith_t,
@@ -797,7 +967,28 @@
    if (retv)
      this->_add_ref ();
    return retv;
-@@ -2014,7 +1930,7 @@
+@@ -1952,6 +2024,20 @@
+ 
+ #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+     defined (ACE_HAS_GNU_REPO)
++    template class TAO_Object_Manager<RTCORBA::UnixDomainProtocolProperties,RTCORBA::UnixDomainProtocolProperties_var>;
++  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
++  #  pragma instantiate TAO_Object_Manager<RTCORBA::UnixDomainProtocolProperties,RTCORBA::UnixDomainProtocolProperties_var>
++#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
++
++#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
++    defined (ACE_HAS_GNU_REPO)
++    template class TAO_Object_Manager<RTCORBA::SharedMemoryProtocolProperties,RTCORBA::SharedMemoryProtocolProperties_var>;
++  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
++  #  pragma instantiate TAO_Object_Manager<RTCORBA::SharedMemoryProtocolProperties,RTCORBA::SharedMemoryProtocolProperties_var>
++#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
++
++#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
++    defined (ACE_HAS_GNU_REPO)
+     template class TAO_Object_Manager<RTCORBA::ServerProtocolPolicy,RTCORBA::ServerProtocolPolicy_var>;
+   #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+   #  pragma instantiate TAO_Object_Manager<RTCORBA::ServerProtocolPolicy,RTCORBA::ServerProtocolPolicy_var>
+@@ -2014,7 +2100,7 @@
      // set the length of the sequence
      _tao_sequence.length (_tao_seq_len);
      // If length is 0 we return true.
@@ -806,7 +997,7 @@
        return 1;
      // retrieve all the elements
      CORBA::Boolean _tao_marshal_flag = 1;
-@@ -2056,7 +1972,7 @@
+@@ -2056,7 +2142,7 @@
      // set the length of the sequence
      _tao_sequence.length (_tao_seq_len);
      // If length is 0 we return true.
@@ -815,7 +1006,7 @@
        return 1;
      // retrieve all the elements
      CORBA::Boolean _tao_marshal_flag = 1;
-@@ -2069,3 +1985,4 @@
+@@ -2069,3 +2155,4 @@
    return 0; // error
  }
  
diff --git a/TAO/tao/diffs/RTCORBAC.h.diff b/TAO/tao/diffs/RTCORBAC.h.diff
index 9f8ecbed4bc..9fd89995df2 100644
--- a/TAO/tao/diffs/RTCORBAC.h.diff
+++ b/TAO/tao/diffs/RTCORBAC.h.diff
@@ -1,5 +1,5 @@
---- orig/RTCORBAC.h	Thu Jun 15 13:59:40 2000
-+++ RTCORBAC.h	Fri Jun  9 13:00:53 2000
+--- orig/RTCORBAC.h	Sat May 20 22:29:17 2000
++++ RTCORBAC.h	Fri Aug 18 20:19:34 2000
 @@ -1,4 +1,4 @@
 -/* -*- C++ -*- $Id$ */
 +/* -*- C++ -*- $Id$ */
@@ -692,9 +692,9 @@
 +    // CDR Encoder/Decoder methods.
 +
 +    virtual CORBA::Boolean _tao_encode (TAO_OutputCDR &out_cdr);
-+    
++
 +    virtual CORBA::Boolean _tao_decode (TAO_InputCDR &in_cdr);
-+   
++
    protected:
      ProtocolProperties (void);
      virtual ~ProtocolProperties (void);
@@ -908,8 +908,320 @@
      virtual const char* _interface_repository_id (void) const;
  
    protected:
-@@ -1385,7 +1399,7 @@
+@@ -1383,9 +1397,319 @@
+ 
+ #endif /* end #if !defined */
  
++
++
++#if !defined (_RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___PTR_CH_)
++#define _RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___PTR_CH_
++
++  class UnixDomainProtocolProperties;
++  typedef UnixDomainProtocolProperties *UnixDomainProtocolProperties_ptr;
++
++#endif /* end #if !defined */
++
++
++#if !defined (_RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___VAR_CH_)
++#define _RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___VAR_CH_
++
++  class TAO_Export UnixDomainProtocolProperties_var : public TAO_Base_var
++  {
++  public:
++    UnixDomainProtocolProperties_var (void); // default constructor
++    UnixDomainProtocolProperties_var (UnixDomainProtocolProperties_ptr p) : ptr_ (p) {}
++    UnixDomainProtocolProperties_var (const UnixDomainProtocolProperties_var &); // copy constructor
++    ~UnixDomainProtocolProperties_var (void); // destructor
++
++    UnixDomainProtocolProperties_var &operator= (UnixDomainProtocolProperties_ptr);
++    UnixDomainProtocolProperties_var &operator= (const UnixDomainProtocolProperties_var &);
++    UnixDomainProtocolProperties_ptr operator-> (void) const;
++
++    operator const UnixDomainProtocolProperties_ptr &() const;
++    operator UnixDomainProtocolProperties_ptr &();
++    // in, inout, out, _retn
++    UnixDomainProtocolProperties_ptr in (void) const;
++    UnixDomainProtocolProperties_ptr &inout (void);
++    UnixDomainProtocolProperties_ptr &out (void);
++    UnixDomainProtocolProperties_ptr _retn (void);
++    UnixDomainProtocolProperties_ptr ptr (void) const;
++
++  private:
++    UnixDomainProtocolProperties_ptr ptr_;
++    // Unimplemented - prevents widening assignment.
++    UnixDomainProtocolProperties_var (const TAO_Base_var &rhs);
++    UnixDomainProtocolProperties_var &operator= (const TAO_Base_var &rhs);
++  };
++
++
++#endif /* end #if !defined */
++
++
++#if !defined (_RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___OUT_CH_)
++#define _RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___OUT_CH_
++
++  class TAO_Export UnixDomainProtocolProperties_out
++  {
++  public:
++    UnixDomainProtocolProperties_out (UnixDomainProtocolProperties_ptr &);
++    UnixDomainProtocolProperties_out (UnixDomainProtocolProperties_var &);
++    UnixDomainProtocolProperties_out (const UnixDomainProtocolProperties_out &);
++    UnixDomainProtocolProperties_out &operator= (const UnixDomainProtocolProperties_out &);
++    UnixDomainProtocolProperties_out &operator= (const UnixDomainProtocolProperties_var &);
++    UnixDomainProtocolProperties_out &operator= (UnixDomainProtocolProperties_ptr);
++    operator UnixDomainProtocolProperties_ptr &();
++    UnixDomainProtocolProperties_ptr &ptr (void);
++    UnixDomainProtocolProperties_ptr operator-> (void);
++
++  private:
++    UnixDomainProtocolProperties_ptr &ptr_;
++  };
++
++
++#endif /* end #if !defined */
++
++
++#if !defined (_RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES_CH_)
++#define _RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES_CH_
++
++class TAO_Export UnixDomainProtocolProperties: public virtual ProtocolProperties
++  {
++  public:
++  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
++    typedef UnixDomainProtocolProperties_ptr _ptr_type;
++    typedef UnixDomainProtocolProperties_var _var_type;
++  #endif /* ! __GNUC__ || g++ >= 2.8 */
++
++    // 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;
++      }
++
++    virtual CORBA::Long send_buffer_size (
++        CORBA::Environment &ACE_TRY_ENV =
++          TAO_default_environment ()
++      )
++      ACE_THROW_SPEC ((
++        CORBA::SystemException
++      )) = 0;
++
++    virtual void send_buffer_size (
++        CORBA::Long send_buffer_size,
++        CORBA::Environment &ACE_TRY_ENV =
++          TAO_default_environment ()
++      )
++      ACE_THROW_SPEC ((
++        CORBA::SystemException
++      )) = 0;
++
++    virtual CORBA::Long recv_buffer_size (
++        CORBA::Environment &ACE_TRY_ENV =
++          TAO_default_environment ()
++      )
++      ACE_THROW_SPEC ((
++        CORBA::SystemException
++      )) = 0;
++
++    virtual void recv_buffer_size (
++        CORBA::Long recv_buffer_size,
++        CORBA::Environment &ACE_TRY_ENV =
++          TAO_default_environment ()
++      )
++      ACE_THROW_SPEC ((
++        CORBA::SystemException
++      )) = 0;
++
++    virtual void *_tao_QueryInterface (ptr_arith_t type);
++
++    virtual const char* _interface_repository_id (void) const;
++
++  protected:
++    UnixDomainProtocolProperties (void);
++    virtual ~UnixDomainProtocolProperties (void);
++  private:
++    UnixDomainProtocolProperties (const UnixDomainProtocolProperties &);
++    void operator= (const UnixDomainProtocolProperties &);
++  };
++
++
++#endif /* end #if !defined */
++
++
++#if !defined (_RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___PTR_CH_)
++#define _RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___PTR_CH_
++
++  class SharedMemoryProtocolProperties;
++  typedef SharedMemoryProtocolProperties *SharedMemoryProtocolProperties_ptr;
++
++#endif /* end #if !defined */
++
++
++#if !defined (_RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___VAR_CH_)
++#define _RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___VAR_CH_
++
++  class TAO_Export SharedMemoryProtocolProperties_var : public TAO_Base_var
++  {
++  public:
++    SharedMemoryProtocolProperties_var (void); // default constructor
++    SharedMemoryProtocolProperties_var (SharedMemoryProtocolProperties_ptr p) : ptr_ (p) {}
++    SharedMemoryProtocolProperties_var (const SharedMemoryProtocolProperties_var &); // copy constructor
++    ~SharedMemoryProtocolProperties_var (void); // destructor
++
++    SharedMemoryProtocolProperties_var &operator= (SharedMemoryProtocolProperties_ptr);
++    SharedMemoryProtocolProperties_var &operator= (const SharedMemoryProtocolProperties_var &);
++    SharedMemoryProtocolProperties_ptr operator-> (void) const;
++
++    operator const SharedMemoryProtocolProperties_ptr &() const;
++    operator SharedMemoryProtocolProperties_ptr &();
++    // in, inout, out, _retn
++    SharedMemoryProtocolProperties_ptr in (void) const;
++    SharedMemoryProtocolProperties_ptr &inout (void);
++    SharedMemoryProtocolProperties_ptr &out (void);
++    SharedMemoryProtocolProperties_ptr _retn (void);
++    SharedMemoryProtocolProperties_ptr ptr (void) const;
++
++  private:
++    SharedMemoryProtocolProperties_ptr ptr_;
++    // Unimplemented - prevents widening assignment.
++    SharedMemoryProtocolProperties_var (const TAO_Base_var &rhs);
++    SharedMemoryProtocolProperties_var &operator= (const TAO_Base_var &rhs);
++  };
++
++
++#endif /* end #if !defined */
++
++
++#if !defined (_RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___OUT_CH_)
++#define _RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___OUT_CH_
++
++  class TAO_Export SharedMemoryProtocolProperties_out
++  {
++  public:
++    SharedMemoryProtocolProperties_out (SharedMemoryProtocolProperties_ptr &);
++    SharedMemoryProtocolProperties_out (SharedMemoryProtocolProperties_var &);
++    SharedMemoryProtocolProperties_out (const SharedMemoryProtocolProperties_out &);
++    SharedMemoryProtocolProperties_out &operator= (const SharedMemoryProtocolProperties_out &);
++    SharedMemoryProtocolProperties_out &operator= (const SharedMemoryProtocolProperties_var &);
++    SharedMemoryProtocolProperties_out &operator= (SharedMemoryProtocolProperties_ptr);
++    operator SharedMemoryProtocolProperties_ptr &();
++    SharedMemoryProtocolProperties_ptr &ptr (void);
++    SharedMemoryProtocolProperties_ptr operator-> (void);
++
++  private:
++    SharedMemoryProtocolProperties_ptr &ptr_;
++  };
++
++
++#endif /* end #if !defined */
++
++
++#if !defined (_RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES_CH_)
++#define _RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES_CH_
++
++class TAO_Export SharedMemoryProtocolProperties: public virtual ProtocolProperties
++  {
++  public:
++  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
++    typedef SharedMemoryProtocolProperties_ptr _ptr_type;
++    typedef SharedMemoryProtocolProperties_var _var_type;
++  #endif /* ! __GNUC__ || g++ >= 2.8 */
++
++    // 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;
++      }
++
++    virtual CORBA::Long preallocate_buffer_size (
++        CORBA::Environment &ACE_TRY_ENV =
++          TAO_default_environment ()
++      )
++      ACE_THROW_SPEC ((
++        CORBA::SystemException
++      )) = 0;
++
++    virtual void preallocate_buffer_size (
++        CORBA::Long preallocate_buffer_size,
++        CORBA::Environment &ACE_TRY_ENV =
++          TAO_default_environment ()
++      )
++      ACE_THROW_SPEC ((
++        CORBA::SystemException
++      )) = 0;
++
++    virtual char * mmap_filename (
++        CORBA::Environment &ACE_TRY_ENV =
++          TAO_default_environment ()
++      )
++      ACE_THROW_SPEC ((
++        CORBA::SystemException
++      )) = 0;
++
++    virtual void mmap_filename (
++        const char * mmap_filename,
++        CORBA::Environment &ACE_TRY_ENV =
++          TAO_default_environment ()
++      )
++      ACE_THROW_SPEC ((
++        CORBA::SystemException
++      )) = 0;
++
++    virtual char * mmap_lockname (
++        CORBA::Environment &ACE_TRY_ENV =
++          TAO_default_environment ()
++      )
++      ACE_THROW_SPEC ((
++        CORBA::SystemException
++      )) = 0;
++
++    virtual void mmap_lockname (
++        const char * mmap_lockname,
++        CORBA::Environment &ACE_TRY_ENV =
++          TAO_default_environment ()
++      )
++      ACE_THROW_SPEC ((
++        CORBA::SystemException
++      )) = 0;
++
++    virtual void *_tao_QueryInterface (ptr_arith_t type);
++
++    virtual const char* _interface_repository_id (void) const;
++
++  protected:
++    SharedMemoryProtocolProperties (void);
++    virtual ~SharedMemoryProtocolProperties (void);
++  private:
++    SharedMemoryProtocolProperties (const SharedMemoryProtocolProperties &);
++    void operator= (const SharedMemoryProtocolProperties &);
++  };
++
++
++#endif /* end #if !defined */
++
    struct Protocol;
    class Protocol_var;
 -  
@@ -917,7 +1229,7 @@
    struct TAO_Export Protocol
    {
  
-@@ -1405,18 +1419,18 @@
+@@ -1405,18 +1729,18 @@
      Protocol_var (Protocol *);
      Protocol_var (const Protocol_var &); // copy constructor
      ~Protocol_var (void); // destructor
@@ -940,7 +1252,7 @@
      const Protocol &in (void) const;
      Protocol &inout (void);
      Protocol *&out (void);
-@@ -1438,7 +1452,7 @@
+@@ -1438,7 +1762,7 @@
      operator Protocol *&();
      Protocol *&ptr (void);
      Protocol *operator-> (void);
@@ -949,7 +1261,7 @@
    private:
      Protocol *&ptr_;
      // assignment from T_var not allowed
-@@ -1447,7 +1461,7 @@
+@@ -1447,7 +1771,7 @@
  
  
  #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
@@ -958,7 +1270,7 @@
  #if !defined (__TAO_UNBOUNDED_SEQUENCE_RTCORBA_PROTOCOLLIST_CH_)
  #define __TAO_UNBOUNDED_SEQUENCE_RTCORBA_PROTOCOLLIST_CH_
  
-@@ -1455,9 +1469,9 @@
+@@ -1455,9 +1779,9 @@
      {
      public:
        // = Initialization and termination methods.
@@ -970,7 +1282,7 @@
        _TAO_Unbounded_Sequence_RTCORBA_ProtocolList (CORBA::ULong maximum,
          CORBA::ULong length,
          Protocol *data,
-@@ -1474,7 +1488,7 @@
+@@ -1474,7 +1798,7 @@
        virtual void _allocate_buffer (CORBA::ULong length);
        virtual void _deallocate_buffer (void);
        // Implement the TAO_Base_Sequence methods (see Sequence.h)
@@ -979,7 +1291,7 @@
        Protocol *get_buffer (CORBA::Boolean orphan = 0);
        const Protocol *get_buffer (void) const;
        void replace (CORBA::ULong max,
-@@ -1486,32 +1500,32 @@
+@@ -1486,32 +1810,32 @@
  #endif /* end #if !defined */
  
  
@@ -1021,7 +1333,7 @@
        CORBA::Boolean release=0
      );
      ProtocolList (const ProtocolList &); // copy ctor
-@@ -1523,7 +1537,7 @@
+@@ -1523,7 +1847,7 @@
  #endif /* ! __GNUC__ || g++ >= 2.8 */
  
    };
@@ -1030,7 +1342,7 @@
  #endif /* end #if !defined */
  
  
-@@ -1541,19 +1555,19 @@
+@@ -1541,19 +1865,19 @@
      ProtocolList_var (ProtocolList *);
      ProtocolList_var (const ProtocolList_var &); // copy constructor
      ~ProtocolList_var (void); // destructor
@@ -1054,7 +1366,7 @@
      const ProtocolList &in (void) const;
      ProtocolList &inout (void);
      ProtocolList *&out (void);
-@@ -1583,7 +1597,7 @@
+@@ -1583,7 +1907,7 @@
      ProtocolList *&ptr (void);
      ProtocolList *operator-> (void);
      Protocol &operator[] (CORBA::ULong index);
@@ -1063,7 +1375,7 @@
    private:
      ProtocolList *&ptr_;
      // assignment from T_var not allowed
-@@ -1601,7 +1615,7 @@
+@@ -1601,7 +1925,7 @@
  
    class ServerProtocolPolicy;
    typedef ServerProtocolPolicy *ServerProtocolPolicy_ptr;
@@ -1072,7 +1384,7 @@
  #endif /* end #if !defined */
  
  
-@@ -1615,14 +1629,14 @@
+@@ -1615,14 +1939,14 @@
      ServerProtocolPolicy_var (ServerProtocolPolicy_ptr);
      ServerProtocolPolicy_var (const ServerProtocolPolicy_var &); // copy constructor
      ~ServerProtocolPolicy_var (void); // destructor
@@ -1090,7 +1402,7 @@
      ServerProtocolPolicy_ptr in (void) const;
      ServerProtocolPolicy_ptr &inout (void);
      ServerProtocolPolicy_ptr &out (void);
-@@ -1655,7 +1669,7 @@
+@@ -1655,7 +1979,7 @@
      operator ServerProtocolPolicy_ptr &();
      ServerProtocolPolicy_ptr &ptr (void);
      ServerProtocolPolicy_ptr operator-> (void);
@@ -1099,7 +1411,7 @@
    private:
      ServerProtocolPolicy_ptr &ptr_;
    };
-@@ -1679,12 +1693,12 @@
+@@ -1679,12 +2003,12 @@
      static ServerProtocolPolicy_ptr _duplicate (ServerProtocolPolicy_ptr obj);
      static ServerProtocolPolicy_ptr _narrow (
          CORBA::Object_ptr obj,
@@ -1114,7 +1426,7 @@
            TAO_default_environment ()
        );
      static ServerProtocolPolicy_ptr _nil (void)
-@@ -1693,7 +1707,7 @@
+@@ -1693,7 +2017,7 @@
        }
  
      virtual RTCORBA::ProtocolList * protocols (
@@ -1123,7 +1435,7 @@
            TAO_default_environment ()
        )
        ACE_THROW_SPEC ((
-@@ -1701,7 +1715,7 @@
+@@ -1701,7 +2025,7 @@
        )) = 0;
  
      virtual void *_tao_QueryInterface (ptr_arith_t type);
@@ -1132,7 +1444,7 @@
      virtual const char* _interface_repository_id (void) const;
  
    protected:
-@@ -1723,7 +1737,7 @@
+@@ -1723,7 +2047,7 @@
  
    class ClientProtocolPolicy;
    typedef ClientProtocolPolicy *ClientProtocolPolicy_ptr;
@@ -1141,7 +1453,7 @@
  #endif /* end #if !defined */
  
  
-@@ -1737,14 +1751,14 @@
+@@ -1737,14 +2061,14 @@
      ClientProtocolPolicy_var (ClientProtocolPolicy_ptr);
      ClientProtocolPolicy_var (const ClientProtocolPolicy_var &); // copy constructor
      ~ClientProtocolPolicy_var (void); // destructor
@@ -1159,7 +1471,7 @@
      ClientProtocolPolicy_ptr in (void) const;
      ClientProtocolPolicy_ptr &inout (void);
      ClientProtocolPolicy_ptr &out (void);
-@@ -1777,7 +1791,7 @@
+@@ -1777,7 +2101,7 @@
      operator ClientProtocolPolicy_ptr &();
      ClientProtocolPolicy_ptr &ptr (void);
      ClientProtocolPolicy_ptr operator-> (void);
@@ -1168,7 +1480,7 @@
    private:
      ClientProtocolPolicy_ptr &ptr_;
    };
-@@ -1801,12 +1815,12 @@
+@@ -1801,12 +2125,12 @@
      static ClientProtocolPolicy_ptr _duplicate (ClientProtocolPolicy_ptr obj);
      static ClientProtocolPolicy_ptr _narrow (
          CORBA::Object_ptr obj,
@@ -1183,7 +1495,7 @@
            TAO_default_environment ()
        );
      static ClientProtocolPolicy_ptr _nil (void)
-@@ -1815,7 +1829,7 @@
+@@ -1815,7 +2139,7 @@
        }
  
      virtual RTCORBA::ProtocolList * protocols (
@@ -1192,7 +1504,7 @@
            TAO_default_environment ()
        )
        ACE_THROW_SPEC ((
-@@ -1823,7 +1837,7 @@
+@@ -1823,7 +2147,7 @@
        )) = 0;
  
      virtual void *_tao_QueryInterface (ptr_arith_t type);
@@ -1201,7 +1513,7 @@
      virtual const char* _interface_repository_id (void) const;
  
    protected:
-@@ -1843,7 +1857,7 @@
+@@ -1843,7 +2167,7 @@
  
    class Current;
    typedef Current *Current_ptr;
@@ -1210,7 +1522,7 @@
  #endif /* end #if !defined */
  
  
-@@ -1857,14 +1871,14 @@
+@@ -1857,14 +2181,14 @@
      Current_var (Current_ptr);
      Current_var (const Current_var &); // copy constructor
      ~Current_var (void); // destructor
@@ -1228,7 +1540,7 @@
      Current_ptr in (void) const;
      Current_ptr &inout (void);
      Current_ptr &out (void);
-@@ -1897,7 +1911,7 @@
+@@ -1897,7 +2221,7 @@
      operator Current_ptr &();
      Current_ptr &ptr (void);
      Current_ptr operator-> (void);
@@ -1237,7 +1549,7 @@
    private:
      Current_ptr &ptr_;
    };
-@@ -1921,12 +1935,12 @@
+@@ -1921,12 +2245,12 @@
      static Current_ptr _duplicate (Current_ptr obj);
      static Current_ptr _narrow (
          CORBA::Object_ptr obj,
@@ -1252,7 +1564,7 @@
            TAO_default_environment ()
        );
      static Current_ptr _nil (void)
-@@ -1935,7 +1949,7 @@
+@@ -1935,7 +2259,7 @@
        }
  
      virtual RTCORBA::Priority the_priority (
@@ -1261,7 +1573,7 @@
            TAO_default_environment ()
        )
        ACE_THROW_SPEC ((
-@@ -1944,7 +1958,7 @@
+@@ -1944,7 +2268,7 @@
  
      virtual void the_priority (
          RTCORBA::Priority the_priority,
@@ -1270,7 +1582,7 @@
            TAO_default_environment ()
        )
        ACE_THROW_SPEC ((
-@@ -1952,7 +1966,7 @@
+@@ -1952,7 +2276,7 @@
        )) = 0;
  
      virtual void *_tao_QueryInterface (ptr_arith_t type);
@@ -1279,7 +1591,7 @@
      virtual const char* _interface_repository_id (void) const;
  
    protected:
-@@ -1972,7 +1986,7 @@
+@@ -1972,7 +2296,7 @@
  
    class Mutex;
    typedef Mutex *Mutex_ptr;
@@ -1288,7 +1600,7 @@
  #endif /* end #if !defined */
  
  
-@@ -1986,14 +2000,14 @@
+@@ -1986,14 +2310,14 @@
      Mutex_var (Mutex_ptr);
      Mutex_var (const Mutex_var &); // copy constructor
      ~Mutex_var (void); // destructor
@@ -1306,7 +1618,7 @@
      Mutex_ptr in (void) const;
      Mutex_ptr &inout (void);
      Mutex_ptr &out (void);
-@@ -2026,7 +2040,7 @@
+@@ -2026,7 +2350,7 @@
      operator Mutex_ptr &();
      Mutex_ptr &ptr (void);
      Mutex_ptr operator-> (void);
@@ -1315,7 +1627,7 @@
    private:
      Mutex_ptr &ptr_;
    };
-@@ -2050,12 +2064,12 @@
+@@ -2050,12 +2374,12 @@
      static Mutex_ptr _duplicate (Mutex_ptr obj);
      static Mutex_ptr _narrow (
          CORBA::Object_ptr obj,
@@ -1330,7 +1642,7 @@
            TAO_default_environment ()
        );
      static Mutex_ptr _nil (void)
-@@ -2064,7 +2078,7 @@
+@@ -2064,7 +2388,7 @@
        }
  
      virtual void lock (
@@ -1339,7 +1651,7 @@
            TAO_default_environment ()
        )
        ACE_THROW_SPEC ((
-@@ -2072,7 +2086,7 @@
+@@ -2072,7 +2396,7 @@
        )) = 0;
  
      virtual void unlock (
@@ -1348,7 +1660,7 @@
            TAO_default_environment ()
        )
        ACE_THROW_SPEC ((
-@@ -2081,7 +2095,7 @@
+@@ -2081,7 +2405,7 @@
  
      virtual CORBA::Boolean try_lock (
          TimeBase::TimeT max_wait,
@@ -1357,7 +1669,7 @@
            TAO_default_environment ()
        )
        ACE_THROW_SPEC ((
-@@ -2089,7 +2103,7 @@
+@@ -2089,7 +2413,7 @@
        )) = 0;
  
      virtual void *_tao_QueryInterface (ptr_arith_t type);
@@ -1366,7 +1678,7 @@
      virtual const char* _interface_repository_id (void) const;
  
    protected:
-@@ -2103,13 +2117,12 @@
+@@ -2103,13 +2427,12 @@
  
  #endif /* end #if !defined */
  
@@ -1381,7 +1693,7 @@
  #endif /* end #if !defined */
  
  
-@@ -2123,14 +2136,14 @@
+@@ -2123,14 +2446,14 @@
      RTORB_var (RTORB_ptr);
      RTORB_var (const RTORB_var &); // copy constructor
      ~RTORB_var (void); // destructor
@@ -1399,7 +1711,7 @@
      RTORB_ptr in (void) const;
      RTORB_ptr &inout (void);
      RTORB_ptr &out (void);
-@@ -2163,7 +2176,7 @@
+@@ -2163,7 +2486,7 @@
      operator RTORB_ptr &();
      RTORB_ptr &ptr (void);
      RTORB_ptr operator-> (void);
@@ -1408,7 +1720,7 @@
    private:
      RTORB_ptr &ptr_;
    };
-@@ -2187,12 +2200,12 @@
+@@ -2187,12 +2510,12 @@
      static RTORB_ptr _duplicate (RTORB_ptr obj);
      static RTORB_ptr _narrow (
          CORBA::Object_ptr obj,
@@ -1423,7 +1735,7 @@
            TAO_default_environment ()
        );
      static RTORB_ptr _nil (void)
-@@ -2201,7 +2214,7 @@
+@@ -2201,7 +2524,7 @@
        }
  
      virtual RTCORBA::Mutex_ptr create_mutex (
@@ -1432,7 +1744,7 @@
            TAO_default_environment ()
        )
        ACE_THROW_SPEC ((
-@@ -2210,7 +2223,7 @@
+@@ -2210,7 +2533,7 @@
  
      virtual void destroy_mutex (
          RTCORBA::Mutex_ptr the_mutex,
@@ -1441,7 +1753,7 @@
            TAO_default_environment ()
        )
        ACE_THROW_SPEC ((
-@@ -2241,7 +2254,7 @@
+@@ -2241,7 +2564,7 @@
          TAO_InputCDR &,
          CORBA::Environment &);
  
@@ -1450,7 +1762,7 @@
  
  
      // = TAO extension
-@@ -2249,7 +2262,7 @@
+@@ -2249,7 +2572,7 @@
  
    }; // exception RTCORBA::RTORB::InvalidThreadpool
  
@@ -1459,7 +1771,7 @@
  #endif /* end #if !defined */
  
    virtual RTCORBA::ThreadpoolId create_threadpool (
-@@ -2260,7 +2273,7 @@
+@@ -2260,7 +2583,7 @@
        CORBA::Boolean allow_request_buffering,
        CORBA::ULong max_buffered_requests,
        CORBA::ULong max_request_buffer_size,
@@ -1468,7 +1780,7 @@
          TAO_default_environment ()
      )
      ACE_THROW_SPEC ((
-@@ -2274,7 +2287,7 @@
+@@ -2274,7 +2597,7 @@
        CORBA::Boolean allow_request_buffering,
        CORBA::ULong max_buffered_requests,
        CORBA::ULong max_request_buffer_size,
@@ -1477,7 +1789,7 @@
          TAO_default_environment ()
      )
      ACE_THROW_SPEC ((
-@@ -2283,7 +2296,7 @@
+@@ -2283,7 +2606,7 @@
  
    virtual void destroy_threadpool (
        RTCORBA::ThreadpoolId threadpool,
@@ -1486,7 +1798,7 @@
          TAO_default_environment ()
      )
      ACE_THROW_SPEC ((
-@@ -2294,7 +2307,7 @@
+@@ -2294,7 +2617,7 @@
    virtual RTCORBA::PriorityModelPolicy_ptr create_priority_model_policy (
        RTCORBA::PriorityModel priority_model,
        RTCORBA::Priority server_priority,
@@ -1495,7 +1807,7 @@
          TAO_default_environment ()
      )
      ACE_THROW_SPEC ((
-@@ -2303,7 +2316,7 @@
+@@ -2303,7 +2626,7 @@
  
    virtual RTCORBA::ThreadpoolPolicy_ptr create_threadpool_policy (
        RTCORBA::ThreadpoolId threadpool,
@@ -1504,7 +1816,7 @@
          TAO_default_environment ()
      )
      ACE_THROW_SPEC ((
-@@ -2312,7 +2325,7 @@
+@@ -2312,7 +2635,7 @@
  
    virtual RTCORBA::PriorityBandedConnectionPolicy_ptr create_priority_banded_connection_policy (
        const RTCORBA::PriorityBands & priority_bands,
@@ -1513,7 +1825,7 @@
          TAO_default_environment ()
      )
      ACE_THROW_SPEC ((
-@@ -2320,7 +2333,7 @@
+@@ -2320,7 +2643,7 @@
      )) = 0;
  
    virtual RTCORBA::PrivateConnectionPolicy_ptr create_private_connection_policy (
@@ -1522,7 +1834,7 @@
          TAO_default_environment ()
      )
      ACE_THROW_SPEC ((
-@@ -2329,7 +2342,7 @@
+@@ -2329,7 +2652,7 @@
  
    virtual RTCORBA::ServerProtocolPolicy_ptr create_server_protocol_policy (
        const RTCORBA::ProtocolList & protocols,
@@ -1531,7 +1843,7 @@
          TAO_default_environment ()
      )
      ACE_THROW_SPEC ((
-@@ -2338,7 +2351,7 @@
+@@ -2338,7 +2661,7 @@
  
    virtual RTCORBA::ClientProtocolPolicy_ptr create_client_protocol_policy (
        const RTCORBA::ProtocolList & protocols,
@@ -1540,7 +1852,7 @@
          TAO_default_environment ()
      )
      ACE_THROW_SPEC ((
-@@ -2346,7 +2359,7 @@
+@@ -2346,7 +2669,7 @@
      )) = 0;
  
    virtual void *_tao_QueryInterface (ptr_arith_t type);
@@ -1549,7 +1861,7 @@
    virtual const char* _interface_repository_id (void) const;
  
  protected:
-@@ -2360,7 +2373,6 @@
+@@ -2360,7 +2683,6 @@
  
  #endif /* end #if !defined */
  
@@ -1557,7 +1869,7 @@
  }
  TAO_NAMESPACE_CLOSE // module RTCORBA
  
-@@ -2402,7 +2414,7 @@
+@@ -2402,7 +2724,7 @@
  
  #endif /* _TAO_CDR_OP_RTCORBA_ThreadpoolLanes_H_ */
  
@@ -1566,7 +1878,7 @@
  TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, RTCORBA::PriorityModel &);
  TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const RTCORBA::PriorityBand &);
  TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, RTCORBA::PriorityBand &);
-@@ -2432,6 +2444,8 @@
+@@ -2432,6 +2754,8 @@
  #if defined(_MSC_VER) && (_MSC_VER >= 1200)
  #pragma warning(pop)
  #endif /* _MSC_VER */
diff --git a/TAO/tao/diffs/RTCORBAC.i.diff b/TAO/tao/diffs/RTCORBAC.i.diff
index 4119def2a4f..079e8ce1535 100644
--- a/TAO/tao/diffs/RTCORBAC.i.diff
+++ b/TAO/tao/diffs/RTCORBAC.i.diff
@@ -1,5 +1,11 @@
 --- orig/RTCORBAC.i	Sat May 20 22:29:17 2000
-+++ RTCORBAC.i	Sat May 20 15:27:13 2000
++++ RTCORBAC.i	Fri Aug 18 20:23:55 2000
+@@ -1,4 +1,4 @@
+-/* -*- C++ -*- $Id$ */
++/* -*- C++ -*- $Id$ */
+ 
+ // ******  Code generated by the The ACE ORB (TAO) IDL Compiler *******
+ // TAO and the TAO IDL Compiler have been developed by the Center for
 @@ -93,13 +93,13 @@
  }
  
@@ -147,7 +153,15 @@
    ACE_INLINE RTCORBA::ThreadpoolLane *
    RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::get_buffer (CORBA::Boolean orphan)
    {
-@@ -282,13 +282,13 @@
+@@ -261,6 +261,7 @@
+       {
+         result = _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::allocbuf (this->length_);
+         this->buffer_ = result;
++	this->release_ = 1;
+       }
+       else
+       {
+@@ -282,13 +283,13 @@
      }
      return result;
    }
@@ -163,7 +177,7 @@
    ACE_INLINE void
    RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::replace (CORBA::ULong max,
    CORBA::ULong length,
-@@ -305,11 +305,11 @@
+@@ -305,11 +306,11 @@
      this->buffer_ = data;
      this->release_ = release;
    }
@@ -177,7 +191,7 @@
  
  #if !defined (_RTCORBA_THREADPOOLLANES_CI_)
  #define _RTCORBA_THREADPOOLLANES_CI_
-@@ -393,20 +393,20 @@
+@@ -393,20 +394,20 @@
    return this->ptr_;
  }
  
@@ -203,7 +217,7 @@
  {
    return *this->ptr_;
  }
-@@ -429,7 +429,7 @@
+@@ -429,7 +430,7 @@
    return *this->ptr_;
  }
  
@@ -212,7 +226,7 @@
  ACE_INLINE ::RTCORBA::ThreadpoolLanes *&
  RTCORBA::ThreadpoolLanes_var::out (void)
  {
-@@ -490,7 +490,7 @@
+@@ -490,7 +491,7 @@
    return *this;
  }
  
@@ -221,7 +235,7 @@
  RTCORBA::ThreadpoolLanes_out::operator ::RTCORBA::ThreadpoolLanes *&() // cast
  {
    return this->ptr_;
-@@ -517,6 +517,14 @@
+@@ -517,6 +518,14 @@
  
  #endif /* end #if !defined */
  
@@ -236,7 +250,7 @@
  
  #if !defined (_RTCORBA_PRIORITYMODELPOLICY___VAR_CI_)
  #define _RTCORBA_PRIORITYMODELPOLICY___VAR_CI_
-@@ -572,14 +580,14 @@
+@@ -572,14 +581,14 @@
    return *this;
  }
  
@@ -254,7 +268,7 @@
  {
    return this->ptr_;
  }
-@@ -671,7 +679,7 @@
+@@ -671,7 +680,7 @@
    return *this;
  }
  
@@ -263,7 +277,7 @@
  RTCORBA::PriorityModelPolicy_out::operator ::RTCORBA::PriorityModelPolicy_ptr &() // cast
  {
    return this->ptr_;
-@@ -692,6 +700,14 @@
+@@ -692,6 +701,14 @@
  
  #endif /* end #if !defined */
  
@@ -278,7 +292,7 @@
  
  #if !defined (_RTCORBA_THREADPOOLPOLICY___VAR_CI_)
  #define _RTCORBA_THREADPOOLPOLICY___VAR_CI_
-@@ -747,14 +763,14 @@
+@@ -747,14 +764,14 @@
    return *this;
  }
  
@@ -296,7 +310,7 @@
  {
    return this->ptr_;
  }
-@@ -846,7 +862,7 @@
+@@ -846,7 +863,7 @@
    return *this;
  }
  
@@ -305,7 +319,7 @@
  RTCORBA::ThreadpoolPolicy_out::operator ::RTCORBA::ThreadpoolPolicy_ptr &() // cast
  {
    return this->ptr_;
-@@ -867,6 +883,14 @@
+@@ -867,6 +884,14 @@
  
  #endif /* end #if !defined */
  
@@ -320,7 +334,7 @@
  
  #if !defined (_RTCORBA_PRIVATECONNECTIONPOLICY___VAR_CI_)
  #define _RTCORBA_PRIVATECONNECTIONPOLICY___VAR_CI_
-@@ -922,14 +946,14 @@
+@@ -922,14 +947,14 @@
    return *this;
  }
  
@@ -338,7 +352,7 @@
  {
    return this->ptr_;
  }
-@@ -1021,7 +1045,7 @@
+@@ -1021,7 +1046,7 @@
    return *this;
  }
  
@@ -347,7 +361,7 @@
  RTCORBA::PrivateConnectionPolicy_out::operator ::RTCORBA::PrivateConnectionPolicy_ptr &() // cast
  {
    return this->ptr_;
-@@ -1128,13 +1152,13 @@
+@@ -1128,13 +1153,13 @@
  }
  
  ACE_INLINE
@@ -363,7 +377,7 @@
  {
    return *this->ptr_;
  }
-@@ -1151,7 +1175,7 @@
+@@ -1151,7 +1176,7 @@
    return *this->ptr_;
  }
  
@@ -372,7 +386,7 @@
  ACE_INLINE ::RTCORBA::PriorityBand &
  RTCORBA::PriorityBand_var::out (void)
  {
-@@ -1172,7 +1196,7 @@
+@@ -1172,7 +1197,7 @@
  
  
  #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
@@ -381,7 +395,7 @@
  #if !defined (__TAO_UNBOUNDED_SEQUENCE_RTCORBA_PRIORITYBANDS_CI_)
  #define __TAO_UNBOUNDED_SEQUENCE_RTCORBA_PRIORITYBANDS_CI_
  
-@@ -1185,24 +1209,24 @@
+@@ -1185,24 +1210,24 @@
      ACE_NEW_RETURN (retval, RTCORBA::PriorityBand[size], 0);
      return retval;
    }
@@ -410,7 +424,7 @@
    ACE_INLINE
    RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands (CORBA::ULong maximum,
      CORBA::ULong length,
-@@ -1211,7 +1235,7 @@
+@@ -1211,7 +1236,7 @@
    : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
    {
    }
@@ -419,7 +433,7 @@
    ACE_INLINE
    RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands (const _TAO_Unbounded_Sequence_RTCORBA_PriorityBands &rhs)
    // Copy constructor.
-@@ -1221,10 +1245,10 @@
+@@ -1221,10 +1246,10 @@
      {
        RTCORBA::PriorityBand *tmp1 = _TAO_Unbounded_Sequence_RTCORBA_PriorityBands::allocbuf (this->maximum_);
        RTCORBA::PriorityBand * const tmp2 = ACE_reinterpret_cast (RTCORBA::PriorityBand * ACE_CAST_CONST, rhs.buffer_);
@@ -432,7 +446,7 @@
        this->buffer_ = tmp1;
      }
      else
-@@ -1232,14 +1256,14 @@
+@@ -1232,14 +1257,14 @@
        this->buffer_ = 0;
      }
    }
@@ -449,7 +463,7 @@
      if (this->release_)
      {
        if (this->maximum_ < rhs.maximum_)
-@@ -1252,18 +1276,18 @@
+@@ -1252,18 +1277,18 @@
      }
      else
        this->buffer_ = _TAO_Unbounded_Sequence_RTCORBA_PriorityBands::allocbuf (rhs.maximum_);
@@ -473,7 +487,7 @@
    // = Accessors.
    ACE_INLINE RTCORBA::PriorityBand &
    RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands::operator[] (CORBA::ULong i)
-@@ -1273,7 +1297,7 @@
+@@ -1273,7 +1298,7 @@
      RTCORBA::PriorityBand* tmp = ACE_reinterpret_cast(RTCORBA::PriorityBand*,this->buffer_);
      return tmp[i];
    }
@@ -482,7 +496,7 @@
    ACE_INLINE const RTCORBA::PriorityBand &
    RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands::operator[] (CORBA::ULong i) const
    // operator []
-@@ -1282,9 +1306,9 @@
+@@ -1282,9 +1307,9 @@
      RTCORBA::PriorityBand * const tmp = ACE_reinterpret_cast (RTCORBA::PriorityBand* ACE_CAST_CONST, this->buffer_);
      return tmp[i];
    }
@@ -494,7 +508,15 @@
    ACE_INLINE RTCORBA::PriorityBand *
    RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands::get_buffer (CORBA::Boolean orphan)
    {
-@@ -1317,13 +1341,13 @@
+@@ -1296,6 +1321,7 @@
+       {
+         result = _TAO_Unbounded_Sequence_RTCORBA_PriorityBands::allocbuf (this->length_);
+         this->buffer_ = result;
++	this->release_ = 1;
+       }
+       else
+       {
+@@ -1317,13 +1343,13 @@
      }
      return result;
    }
@@ -510,7 +532,7 @@
    ACE_INLINE void
    RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands::replace (CORBA::ULong max,
    CORBA::ULong length,
-@@ -1340,11 +1364,11 @@
+@@ -1340,11 +1366,11 @@
      this->buffer_ = data;
      this->release_ = release;
    }
@@ -524,7 +546,7 @@
  
  #if !defined (_RTCORBA_PRIORITYBANDS_CI_)
  #define _RTCORBA_PRIORITYBANDS_CI_
-@@ -1428,20 +1452,20 @@
+@@ -1428,20 +1454,20 @@
    return this->ptr_;
  }
  
@@ -550,7 +572,7 @@
  {
    return *this->ptr_;
  }
-@@ -1464,7 +1488,7 @@
+@@ -1464,7 +1490,7 @@
    return *this->ptr_;
  }
  
@@ -559,7 +581,7 @@
  ACE_INLINE ::RTCORBA::PriorityBands *&
  RTCORBA::PriorityBands_var::out (void)
  {
-@@ -1525,7 +1549,7 @@
+@@ -1525,7 +1551,7 @@
    return *this;
  }
  
@@ -568,7 +590,7 @@
  RTCORBA::PriorityBands_out::operator ::RTCORBA::PriorityBands *&() // cast
  {
    return this->ptr_;
-@@ -1552,6 +1576,14 @@
+@@ -1552,6 +1578,14 @@
  
  #endif /* end #if !defined */
  
@@ -583,7 +605,7 @@
  
  #if !defined (_RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY___VAR_CI_)
  #define _RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY___VAR_CI_
-@@ -1607,14 +1639,14 @@
+@@ -1607,14 +1641,14 @@
    return *this;
  }
  
@@ -601,7 +623,7 @@
  {
    return this->ptr_;
  }
-@@ -1706,7 +1738,7 @@
+@@ -1706,7 +1740,7 @@
    return *this;
  }
  
@@ -610,7 +632,7 @@
  RTCORBA::PriorityBandedConnectionPolicy_out::operator ::RTCORBA::PriorityBandedConnectionPolicy_ptr &() // cast
  {
    return this->ptr_;
-@@ -1727,6 +1759,14 @@
+@@ -1727,6 +1761,14 @@
  
  #endif /* end #if !defined */
  
@@ -625,7 +647,7 @@
  
  #if !defined (_RTCORBA_PROTOCOLPROPERTIES___VAR_CI_)
  #define _RTCORBA_PROTOCOLPROPERTIES___VAR_CI_
-@@ -1782,14 +1822,14 @@
+@@ -1782,14 +1824,14 @@
    return *this;
  }
  
@@ -643,7 +665,7 @@
  {
    return this->ptr_;
  }
-@@ -1881,7 +1921,7 @@
+@@ -1881,7 +1923,7 @@
    return *this;
  }
  
@@ -652,7 +674,7 @@
  RTCORBA::ProtocolProperties_out::operator ::RTCORBA::ProtocolProperties_ptr &() // cast
  {
    return this->ptr_;
-@@ -1902,6 +1942,14 @@
+@@ -1902,6 +1944,14 @@
  
  #endif /* end #if !defined */
  
@@ -667,7 +689,7 @@
  
  #if !defined (_RTCORBA_TCPPROTOCOLPROPERTIES___VAR_CI_)
  #define _RTCORBA_TCPPROTOCOLPROPERTIES___VAR_CI_
-@@ -1957,14 +2005,14 @@
+@@ -1957,14 +2007,14 @@
    return *this;
  }
  
@@ -685,7 +707,7 @@
  {
    return this->ptr_;
  }
-@@ -2056,7 +2104,7 @@
+@@ -2056,7 +2106,7 @@
    return *this;
  }
  
@@ -694,7 +716,7 @@
  RTCORBA::TCPProtocolProperties_out::operator ::RTCORBA::TCPProtocolProperties_ptr &() // cast
  {
    return this->ptr_;
-@@ -2077,6 +2125,14 @@
+@@ -2077,6 +2127,14 @@
  
  #endif /* end #if !defined */
  
@@ -709,7 +731,7 @@
  
  #if !defined (_RTCORBA_GIOPPROTOCOLPROPERTIES___VAR_CI_)
  #define _RTCORBA_GIOPPROTOCOLPROPERTIES___VAR_CI_
-@@ -2132,14 +2188,14 @@
+@@ -2132,14 +2190,14 @@
    return *this;
  }
  
@@ -727,7 +749,7 @@
  {
    return this->ptr_;
  }
-@@ -2231,7 +2287,7 @@
+@@ -2231,7 +2289,7 @@
    return *this;
  }
  
@@ -736,7 +758,354 @@
  RTCORBA::GIOPProtocolProperties_out::operator ::RTCORBA::GIOPProtocolProperties_ptr &() // cast
  {
    return this->ptr_;
-@@ -2319,20 +2375,20 @@
+@@ -2252,6 +2310,346 @@
+ 
+ #endif /* end #if !defined */
+ 
++
++#if !defined (_RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___VAR_CI_)
++#define _RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___VAR_CI_
++
++// *************************************************************
++// Inline operations for class RTCORBA::UnixDomainProtocolProperties_var
++// *************************************************************
++
++ACE_INLINE
++RTCORBA::UnixDomainProtocolProperties_var::UnixDomainProtocolProperties_var (void) // default constructor
++  : ptr_ (UnixDomainProtocolProperties::_nil ())
++{}
++
++ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr
++RTCORBA::UnixDomainProtocolProperties_var::ptr (void) const
++{
++  return this->ptr_;
++}
++
++ACE_INLINE
++RTCORBA::UnixDomainProtocolProperties_var::UnixDomainProtocolProperties_var (const ::RTCORBA::UnixDomainProtocolProperties_var &p) // copy constructor
++  : TAO_Base_var (),
++    ptr_ (UnixDomainProtocolProperties::_duplicate (p.ptr ()))
++{}
++
++ACE_INLINE
++RTCORBA::UnixDomainProtocolProperties_var::~UnixDomainProtocolProperties_var (void) // destructor
++{
++  CORBA::release (this->ptr_);
++}
++
++ACE_INLINE RTCORBA::UnixDomainProtocolProperties_var &
++RTCORBA::UnixDomainProtocolProperties_var::operator= (UnixDomainProtocolProperties_ptr p)
++{
++  CORBA::release (this->ptr_);
++  this->ptr_ = p;
++  return *this;
++}
++
++ACE_INLINE RTCORBA::UnixDomainProtocolProperties_var &
++RTCORBA::UnixDomainProtocolProperties_var::operator= (const ::RTCORBA::UnixDomainProtocolProperties_var &p)
++{
++  if (this != &p)
++  {
++    CORBA::release (this->ptr_);
++    this->ptr_ = ::RTCORBA::UnixDomainProtocolProperties::_duplicate (p.ptr ());
++  }
++  return *this;
++}
++
++ACE_INLINE
++RTCORBA::UnixDomainProtocolProperties_var::operator const ::RTCORBA::UnixDomainProtocolProperties_ptr &() const // cast
++{
++  return this->ptr_;
++}
++
++ACE_INLINE
++RTCORBA::UnixDomainProtocolProperties_var::operator ::RTCORBA::UnixDomainProtocolProperties_ptr &() // cast
++{
++  return this->ptr_;
++}
++
++ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr
++RTCORBA::UnixDomainProtocolProperties_var::operator-> (void) const
++{
++  return this->ptr_;
++}
++
++ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr
++RTCORBA::UnixDomainProtocolProperties_var::in (void) const
++{
++  return this->ptr_;
++}
++
++ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr &
++RTCORBA::UnixDomainProtocolProperties_var::inout (void)
++{
++  return this->ptr_;
++}
++
++ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr &
++RTCORBA::UnixDomainProtocolProperties_var::out (void)
++{
++  CORBA::release (this->ptr_);
++  this->ptr_ = ::RTCORBA::UnixDomainProtocolProperties::_nil ();
++  return this->ptr_;
++}
++
++ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr
++RTCORBA::UnixDomainProtocolProperties_var::_retn (void)
++{
++  // yield ownership of managed obj reference
++  ::RTCORBA::UnixDomainProtocolProperties_ptr val = this->ptr_;
++  this->ptr_ = ::RTCORBA::UnixDomainProtocolProperties::_nil ();
++  return val;
++}
++
++
++#endif /* end #if !defined */
++
++
++#if !defined (_RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___OUT_CI_)
++#define _RTCORBA_UNIXDOMAINPROTOCOLPROPERTIES___OUT_CI_
++
++// *************************************************************
++// Inline operations for class RTCORBA::UnixDomainProtocolProperties_out
++// *************************************************************
++
++ACE_INLINE
++RTCORBA::UnixDomainProtocolProperties_out::UnixDomainProtocolProperties_out (UnixDomainProtocolProperties_ptr &p)
++  : ptr_ (p)
++{
++  this->ptr_ = ::RTCORBA::UnixDomainProtocolProperties::_nil ();
++}
++
++ACE_INLINE
++RTCORBA::UnixDomainProtocolProperties_out::UnixDomainProtocolProperties_out (UnixDomainProtocolProperties_var &p) // constructor from _var
++  : ptr_ (p.out ())
++{
++  CORBA::release (this->ptr_);
++  this->ptr_ = ::RTCORBA::UnixDomainProtocolProperties::_nil ();
++}
++
++ACE_INLINE
++RTCORBA::UnixDomainProtocolProperties_out::UnixDomainProtocolProperties_out (const ::RTCORBA::UnixDomainProtocolProperties_out &p) // copy constructor
++  : ptr_ (ACE_const_cast (UnixDomainProtocolProperties_out &, p).ptr_)
++{}
++
++ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_out &
++RTCORBA::UnixDomainProtocolProperties_out::operator= (const ::RTCORBA::UnixDomainProtocolProperties_out &p)
++{
++  this->ptr_ = ACE_const_cast (UnixDomainProtocolProperties_out&, p).ptr_;
++  return *this;
++}
++
++ACE_INLINE RTCORBA::UnixDomainProtocolProperties_out &
++RTCORBA::UnixDomainProtocolProperties_out::operator= (const ::RTCORBA::UnixDomainProtocolProperties_var &p)
++{
++  this->ptr_ = ::RTCORBA::UnixDomainProtocolProperties::_duplicate (p.ptr ());
++  return *this;
++}
++
++ACE_INLINE RTCORBA::UnixDomainProtocolProperties_out &
++RTCORBA::UnixDomainProtocolProperties_out::operator= (UnixDomainProtocolProperties_ptr p)
++{
++  this->ptr_ = p;
++  return *this;
++}
++
++ACE_INLINE
++RTCORBA::UnixDomainProtocolProperties_out::operator ::RTCORBA::UnixDomainProtocolProperties_ptr &() // cast
++{
++  return this->ptr_;
++}
++
++ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr &
++RTCORBA::UnixDomainProtocolProperties_out::ptr (void) // ptr
++{
++  return this->ptr_;
++}
++
++ACE_INLINE ::RTCORBA::UnixDomainProtocolProperties_ptr
++RTCORBA::UnixDomainProtocolProperties_out::operator-> (void)
++{
++  return this->ptr_;
++}
++
++
++#endif /* end #if !defined */
++
++
++#if !defined (_RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___VAR_CI_)
++#define _RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___VAR_CI_
++
++// *************************************************************
++// Inline operations for class RTCORBA::SharedMemoryProtocolProperties_var
++// *************************************************************
++
++ACE_INLINE
++RTCORBA::SharedMemoryProtocolProperties_var::SharedMemoryProtocolProperties_var (void) // default constructor
++  : ptr_ (SharedMemoryProtocolProperties::_nil ())
++{}
++
++ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr
++RTCORBA::SharedMemoryProtocolProperties_var::ptr (void) const
++{
++  return this->ptr_;
++}
++
++ACE_INLINE
++RTCORBA::SharedMemoryProtocolProperties_var::SharedMemoryProtocolProperties_var (const ::RTCORBA::SharedMemoryProtocolProperties_var &p) // copy constructor
++  : TAO_Base_var (),
++    ptr_ (SharedMemoryProtocolProperties::_duplicate (p.ptr ()))
++{}
++
++ACE_INLINE
++RTCORBA::SharedMemoryProtocolProperties_var::~SharedMemoryProtocolProperties_var (void) // destructor
++{
++  CORBA::release (this->ptr_);
++}
++
++ACE_INLINE RTCORBA::SharedMemoryProtocolProperties_var &
++RTCORBA::SharedMemoryProtocolProperties_var::operator= (SharedMemoryProtocolProperties_ptr p)
++{
++  CORBA::release (this->ptr_);
++  this->ptr_ = p;
++  return *this;
++}
++
++ACE_INLINE RTCORBA::SharedMemoryProtocolProperties_var &
++RTCORBA::SharedMemoryProtocolProperties_var::operator= (const ::RTCORBA::SharedMemoryProtocolProperties_var &p)
++{
++  if (this != &p)
++  {
++    CORBA::release (this->ptr_);
++    this->ptr_ = ::RTCORBA::SharedMemoryProtocolProperties::_duplicate (p.ptr ());
++  }
++  return *this;
++}
++
++ACE_INLINE
++RTCORBA::SharedMemoryProtocolProperties_var::operator const ::RTCORBA::SharedMemoryProtocolProperties_ptr &() const // cast
++{
++  return this->ptr_;
++}
++
++ACE_INLINE
++RTCORBA::SharedMemoryProtocolProperties_var::operator ::RTCORBA::SharedMemoryProtocolProperties_ptr &() // cast
++{
++  return this->ptr_;
++}
++
++ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr
++RTCORBA::SharedMemoryProtocolProperties_var::operator-> (void) const
++{
++  return this->ptr_;
++}
++
++ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr
++RTCORBA::SharedMemoryProtocolProperties_var::in (void) const
++{
++  return this->ptr_;
++}
++
++ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr &
++RTCORBA::SharedMemoryProtocolProperties_var::inout (void)
++{
++  return this->ptr_;
++}
++
++ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr &
++RTCORBA::SharedMemoryProtocolProperties_var::out (void)
++{
++  CORBA::release (this->ptr_);
++  this->ptr_ = ::RTCORBA::SharedMemoryProtocolProperties::_nil ();
++  return this->ptr_;
++}
++
++ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr
++RTCORBA::SharedMemoryProtocolProperties_var::_retn (void)
++{
++  // yield ownership of managed obj reference
++  ::RTCORBA::SharedMemoryProtocolProperties_ptr val = this->ptr_;
++  this->ptr_ = ::RTCORBA::SharedMemoryProtocolProperties::_nil ();
++  return val;
++}
++
++
++#endif /* end #if !defined */
++
++
++#if !defined (_RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___OUT_CI_)
++#define _RTCORBA_SHAREDMEMORYPROTOCOLPROPERTIES___OUT_CI_
++
++// *************************************************************
++// Inline operations for class RTCORBA::SharedMemoryProtocolProperties_out
++// *************************************************************
++
++ACE_INLINE
++RTCORBA::SharedMemoryProtocolProperties_out::SharedMemoryProtocolProperties_out (SharedMemoryProtocolProperties_ptr &p)
++  : ptr_ (p)
++{
++  this->ptr_ = ::RTCORBA::SharedMemoryProtocolProperties::_nil ();
++}
++
++ACE_INLINE
++RTCORBA::SharedMemoryProtocolProperties_out::SharedMemoryProtocolProperties_out (SharedMemoryProtocolProperties_var &p) // constructor from _var
++  : ptr_ (p.out ())
++{
++  CORBA::release (this->ptr_);
++  this->ptr_ = ::RTCORBA::SharedMemoryProtocolProperties::_nil ();
++}
++
++ACE_INLINE
++RTCORBA::SharedMemoryProtocolProperties_out::SharedMemoryProtocolProperties_out (const ::RTCORBA::SharedMemoryProtocolProperties_out &p) // copy constructor
++  : ptr_ (ACE_const_cast (SharedMemoryProtocolProperties_out &, p).ptr_)
++{}
++
++ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_out &
++RTCORBA::SharedMemoryProtocolProperties_out::operator= (const ::RTCORBA::SharedMemoryProtocolProperties_out &p)
++{
++  this->ptr_ = ACE_const_cast (SharedMemoryProtocolProperties_out&, p).ptr_;
++  return *this;
++}
++
++ACE_INLINE RTCORBA::SharedMemoryProtocolProperties_out &
++RTCORBA::SharedMemoryProtocolProperties_out::operator= (const ::RTCORBA::SharedMemoryProtocolProperties_var &p)
++{
++  this->ptr_ = ::RTCORBA::SharedMemoryProtocolProperties::_duplicate (p.ptr ());
++  return *this;
++}
++
++ACE_INLINE RTCORBA::SharedMemoryProtocolProperties_out &
++RTCORBA::SharedMemoryProtocolProperties_out::operator= (SharedMemoryProtocolProperties_ptr p)
++{
++  this->ptr_ = p;
++  return *this;
++}
++
++ACE_INLINE
++RTCORBA::SharedMemoryProtocolProperties_out::operator ::RTCORBA::SharedMemoryProtocolProperties_ptr &() // cast
++{
++  return this->ptr_;
++}
++
++ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr &
++RTCORBA::SharedMemoryProtocolProperties_out::ptr (void) // ptr
++{
++  return this->ptr_;
++}
++
++ACE_INLINE ::RTCORBA::SharedMemoryProtocolProperties_ptr
++RTCORBA::SharedMemoryProtocolProperties_out::operator-> (void)
++{
++  return this->ptr_;
++}
++
++
++#endif /* end #if !defined */
++
+ // *************************************************************
+ // Inline operations for class RTCORBA::Protocol_var
+ // *************************************************************
+@@ -2319,20 +2717,20 @@
  }
  
  ACE_INLINE
@@ -760,7 +1129,7 @@
  {
    return this->ptr_;
  }
-@@ -2349,7 +2405,7 @@
+@@ -2349,7 +2747,7 @@
    return *this->ptr_;
  }
  
@@ -769,7 +1138,7 @@
  ACE_INLINE ::RTCORBA::Protocol *&
  RTCORBA::Protocol_var::out (void)
  {
-@@ -2410,7 +2466,7 @@
+@@ -2410,7 +2808,7 @@
    return *this;
  }
  
@@ -778,7 +1147,7 @@
  RTCORBA::Protocol_out::operator ::RTCORBA::Protocol *&() // cast
  {
    return this->ptr_;
-@@ -2430,7 +2486,7 @@
+@@ -2430,7 +2828,7 @@
  
  
  #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
@@ -787,7 +1156,7 @@
  #if !defined (__TAO_UNBOUNDED_SEQUENCE_RTCORBA_PROTOCOLLIST_CI_)
  #define __TAO_UNBOUNDED_SEQUENCE_RTCORBA_PROTOCOLLIST_CI_
  
-@@ -2443,24 +2499,24 @@
+@@ -2443,24 +2841,24 @@
      ACE_NEW_RETURN (retval, RTCORBA::Protocol[size], 0);
      return retval;
    }
@@ -816,7 +1185,7 @@
    ACE_INLINE
    RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList (CORBA::ULong maximum,
      CORBA::ULong length,
-@@ -2469,7 +2525,7 @@
+@@ -2469,7 +2867,7 @@
    : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
    {
    }
@@ -825,7 +1194,7 @@
    ACE_INLINE
    RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList (const _TAO_Unbounded_Sequence_RTCORBA_ProtocolList &rhs)
    // Copy constructor.
-@@ -2479,10 +2535,10 @@
+@@ -2479,10 +2877,10 @@
      {
        RTCORBA::Protocol *tmp1 = _TAO_Unbounded_Sequence_RTCORBA_ProtocolList::allocbuf (this->maximum_);
        RTCORBA::Protocol * const tmp2 = ACE_reinterpret_cast (RTCORBA::Protocol * ACE_CAST_CONST, rhs.buffer_);
@@ -838,7 +1207,7 @@
        this->buffer_ = tmp1;
      }
      else
-@@ -2490,14 +2546,14 @@
+@@ -2490,14 +2888,14 @@
        this->buffer_ = 0;
      }
    }
@@ -855,7 +1224,7 @@
      if (this->release_)
      {
        if (this->maximum_ < rhs.maximum_)
-@@ -2510,18 +2566,18 @@
+@@ -2510,18 +2908,18 @@
      }
      else
        this->buffer_ = _TAO_Unbounded_Sequence_RTCORBA_ProtocolList::allocbuf (rhs.maximum_);
@@ -879,7 +1248,7 @@
    // = Accessors.
    ACE_INLINE RTCORBA::Protocol &
    RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList::operator[] (CORBA::ULong i)
-@@ -2531,7 +2587,7 @@
+@@ -2531,7 +2929,7 @@
      RTCORBA::Protocol* tmp = ACE_reinterpret_cast(RTCORBA::Protocol*,this->buffer_);
      return tmp[i];
    }
@@ -888,7 +1257,7 @@
    ACE_INLINE const RTCORBA::Protocol &
    RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList::operator[] (CORBA::ULong i) const
    // operator []
-@@ -2540,9 +2596,9 @@
+@@ -2540,9 +2938,9 @@
      RTCORBA::Protocol * const tmp = ACE_reinterpret_cast (RTCORBA::Protocol* ACE_CAST_CONST, this->buffer_);
      return tmp[i];
    }
@@ -900,7 +1269,15 @@
    ACE_INLINE RTCORBA::Protocol *
    RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList::get_buffer (CORBA::Boolean orphan)
    {
-@@ -2575,13 +2631,13 @@
+@@ -2554,6 +2952,7 @@
+       {
+         result = _TAO_Unbounded_Sequence_RTCORBA_ProtocolList::allocbuf (this->length_);
+         this->buffer_ = result;
++	this->release_ = 1;
+       }
+       else
+       {
+@@ -2575,13 +2974,13 @@
      }
      return result;
    }
@@ -916,7 +1293,7 @@
    ACE_INLINE void
    RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList::replace (CORBA::ULong max,
    CORBA::ULong length,
-@@ -2598,11 +2654,11 @@
+@@ -2598,11 +2997,11 @@
      this->buffer_ = data;
      this->release_ = release;
    }
@@ -930,7 +1307,7 @@
  
  #if !defined (_RTCORBA_PROTOCOLLIST_CI_)
  #define _RTCORBA_PROTOCOLLIST_CI_
-@@ -2667,27 +2723,27 @@
+@@ -2667,27 +3066,27 @@
    return this->ptr_;
  }
  
@@ -964,7 +1341,7 @@
  {
    return this->ptr_;
  }
-@@ -2710,7 +2766,7 @@
+@@ -2710,7 +3109,7 @@
    return *this->ptr_;
  }
  
@@ -973,7 +1350,7 @@
  ACE_INLINE ::RTCORBA::ProtocolList *&
  RTCORBA::ProtocolList_var::out (void)
  {
-@@ -2771,7 +2827,7 @@
+@@ -2771,7 +3170,7 @@
    return *this;
  }
  
@@ -982,7 +1359,7 @@
  RTCORBA::ProtocolList_out::operator ::RTCORBA::ProtocolList *&() // cast
  {
    return this->ptr_;
-@@ -2798,6 +2854,14 @@
+@@ -2798,6 +3197,14 @@
  
  #endif /* end #if !defined */
  
@@ -997,7 +1374,7 @@
  
  #if !defined (_RTCORBA_SERVERPROTOCOLPOLICY___VAR_CI_)
  #define _RTCORBA_SERVERPROTOCOLPOLICY___VAR_CI_
-@@ -2853,14 +2917,14 @@
+@@ -2853,14 +3260,14 @@
    return *this;
  }
  
@@ -1015,7 +1392,7 @@
  {
    return this->ptr_;
  }
-@@ -2952,7 +3016,7 @@
+@@ -2952,7 +3359,7 @@
    return *this;
  }
  
@@ -1024,7 +1401,7 @@
  RTCORBA::ServerProtocolPolicy_out::operator ::RTCORBA::ServerProtocolPolicy_ptr &() // cast
  {
    return this->ptr_;
-@@ -2973,6 +3037,14 @@
+@@ -2973,6 +3380,14 @@
  
  #endif /* end #if !defined */
  
@@ -1039,7 +1416,7 @@
  
  #if !defined (_RTCORBA_CLIENTPROTOCOLPOLICY___VAR_CI_)
  #define _RTCORBA_CLIENTPROTOCOLPOLICY___VAR_CI_
-@@ -3028,14 +3100,14 @@
+@@ -3028,14 +3443,14 @@
    return *this;
  }
  
@@ -1057,7 +1434,7 @@
  {
    return this->ptr_;
  }
-@@ -3127,7 +3199,7 @@
+@@ -3127,7 +3542,7 @@
    return *this;
  }
  
@@ -1066,7 +1443,7 @@
  RTCORBA::ClientProtocolPolicy_out::operator ::RTCORBA::ClientProtocolPolicy_ptr &() // cast
  {
    return this->ptr_;
-@@ -3148,6 +3220,14 @@
+@@ -3148,6 +3563,14 @@
  
  #endif /* end #if !defined */
  
@@ -1081,7 +1458,7 @@
  
  #if !defined (_RTCORBA_CURRENT___VAR_CI_)
  #define _RTCORBA_CURRENT___VAR_CI_
-@@ -3203,14 +3283,14 @@
+@@ -3203,14 +3626,14 @@
    return *this;
  }
  
@@ -1099,7 +1476,7 @@
  {
    return this->ptr_;
  }
-@@ -3302,7 +3382,7 @@
+@@ -3302,7 +3725,7 @@
    return *this;
  }
  
@@ -1108,7 +1485,7 @@
  RTCORBA::Current_out::operator ::RTCORBA::Current_ptr &() // cast
  {
    return this->ptr_;
-@@ -3323,6 +3403,14 @@
+@@ -3323,6 +3746,14 @@
  
  #endif /* end #if !defined */
  
@@ -1123,7 +1500,7 @@
  
  #if !defined (_RTCORBA_MUTEX___VAR_CI_)
  #define _RTCORBA_MUTEX___VAR_CI_
-@@ -3378,14 +3466,14 @@
+@@ -3378,14 +3809,14 @@
    return *this;
  }
  
@@ -1141,7 +1518,7 @@
  {
    return this->ptr_;
  }
-@@ -3477,7 +3565,7 @@
+@@ -3477,7 +3908,7 @@
    return *this;
  }
  
@@ -1150,7 +1527,7 @@
  RTCORBA::Mutex_out::operator ::RTCORBA::Mutex_ptr &() // cast
  {
    return this->ptr_;
-@@ -3498,9 +3586,13 @@
+@@ -3498,9 +3929,13 @@
  
  #endif /* end #if !defined */
  
@@ -1167,7 +1544,7 @@
  
  
  #if !defined (_RTCORBA_RTORB___VAR_CI_)
-@@ -3557,14 +3649,14 @@
+@@ -3557,14 +3992,14 @@
    return *this;
  }
  
@@ -1185,7 +1562,7 @@
  {
    return this->ptr_;
  }
-@@ -3656,7 +3748,7 @@
+@@ -3656,7 +4091,7 @@
    return *this;
  }
  
@@ -1194,7 +1571,7 @@
  RTCORBA::RTORB_out::operator ::RTCORBA::RTORB_ptr &() // cast
  {
    return this->ptr_;
-@@ -3677,6 +3769,10 @@
+@@ -3677,6 +4112,10 @@
  
  #endif /* end #if !defined */
  
@@ -1205,7 +1582,7 @@
  ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const RTCORBA::ThreadpoolLane &_tao_aggregate)
  {
    if (
-@@ -3687,7 +3783,7 @@
+@@ -3687,7 +4126,7 @@
      return 1;
    else
      return 0;
@@ -1214,7 +1591,7 @@
  }
  
  ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, RTCORBA::ThreadpoolLane &_tao_aggregate)
-@@ -3700,7 +3796,7 @@
+@@ -3700,7 +4139,7 @@
      return 1;
    else
      return 0;
@@ -1223,7 +1600,7 @@
  }
  
  
-@@ -3744,7 +3840,7 @@
+@@ -3744,7 +4183,7 @@
      return 1;
    else
      return 0;
@@ -1232,7 +1609,7 @@
  }
  
  ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, RTCORBA::PriorityBand &_tao_aggregate)
-@@ -3756,7 +3852,7 @@
+@@ -3756,7 +4195,7 @@
      return 1;
    else
      return 0;
@@ -1241,7 +1618,7 @@
  }
  
  
-@@ -3773,4 +3869,3 @@
+@@ -3773,4 +4212,3 @@
    );
  
  #endif /* _TAO_CDR_OP_RTCORBA_PriorityBands_I_ */
diff --git a/TAO/tao/diffs/TAOC.h.diff b/TAO/tao/diffs/TAOC.h.diff
index d68d18dd270..3ce7d73e5c5 100644
--- a/TAO/tao/diffs/TAOC.h.diff
+++ b/TAO/tao/diffs/TAOC.h.diff
@@ -1,16 +1,19 @@
---- orig/TAOC.h	Mon May  1 09:12:20 2000
-+++ TAOC.h	Mon May  1 09:14:12 2000
-@@ -9,21 +9,22 @@
+--- orig/TAOC.h	Fri Aug 18 23:18:42 2000
++++ TAOC.h	Tue Jun 27 22:47:12 2000
+@@ -1,4 +1,4 @@
+-/* -*- C++ -*- $Id$ */
++/* -*- C++ -*- $Id$ */
+ 
+ // ******  Code generated by the The ACE ORB (TAO) IDL Compiler *******
+ // TAO and the TAO IDL Compiler have been developed by the Center for
+@@ -9,17 +9,24 @@
  
  #ifndef _TAO_IDL_ORIG_TAOC_H_
  #define _TAO_IDL_ORIG_TAOC_H_
 -
  #include "ace/pre.h"
 -#include "tao/corba.h"
- 
--#if defined (ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION)
--#include "ace/streams.h"
--#endif /* ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION */
++
 +#include "tao/corbafwd.h"
  
  #if !defined (ACE_LACKS_PRAGMA_ONCE)
@@ -28,20 +31,32 @@
 +
 +#endif /* TAO_HAS_CLIENT_PRIORITY_POLICY == 1 ||
 +          TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1 */
++
++#include "tao/Priority_Mapping_Manager.h"
  
  #if defined (TAO_EXPORT_MACRO)
  #undef TAO_EXPORT_MACRO
-@@ -46,6 +47,9 @@
+@@ -42,6 +49,19 @@
  
  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;
-@@ -58,7 +62,7 @@
+@@ -54,7 +74,7 @@
  
    struct PrioritySpecification;
    class PrioritySpecification_var;
@@ -50,7 +65,7 @@
    struct TAO_Export PrioritySpecification
    {
  
-@@ -81,18 +85,18 @@
+@@ -77,18 +97,18 @@
      PrioritySpecification_var (const PrioritySpecification_var &); // copy constructor
      PrioritySpecification_var (const PrioritySpecification &); // fixed-size types only
      ~PrioritySpecification_var (void); // destructor
@@ -73,7 +88,7 @@
      const PrioritySpecification &in (void) const;
      PrioritySpecification &inout (void);
      PrioritySpecification &out (void);
-@@ -115,7 +119,7 @@
+@@ -111,7 +131,7 @@
  
    class ClientPriorityPolicy;
    typedef ClientPriorityPolicy *ClientPriorityPolicy_ptr;
@@ -82,8 +97,12 @@
  #endif /* end #if !defined */
  
  
-@@ -129,14 +133,14 @@
-     ClientPriorityPolicy_var (ClientPriorityPolicy_ptr);
+@@ -122,17 +142,17 @@
+   {
+   public:
+     ClientPriorityPolicy_var (void); // default constructor
+-    ClientPriorityPolicy_var (ClientPriorityPolicy_ptr p) : ptr_ (p) {} 
++    ClientPriorityPolicy_var (ClientPriorityPolicy_ptr);
      ClientPriorityPolicy_var (const ClientPriorityPolicy_var &); // copy constructor
      ~ClientPriorityPolicy_var (void); // destructor
 -    
@@ -100,7 +119,7 @@
      ClientPriorityPolicy_ptr in (void) const;
      ClientPriorityPolicy_ptr &inout (void);
      ClientPriorityPolicy_ptr &out (void);
-@@ -166,7 +170,7 @@
+@@ -165,7 +185,7 @@
      operator ClientPriorityPolicy_ptr &();
      ClientPriorityPolicy_ptr &ptr (void);
      ClientPriorityPolicy_ptr operator-> (void);
@@ -109,7 +128,7 @@
    private:
      ClientPriorityPolicy_ptr &ptr_;
    };
-@@ -190,12 +194,12 @@
+@@ -189,12 +209,12 @@
      static ClientPriorityPolicy_ptr _duplicate (ClientPriorityPolicy_ptr obj);
      static ClientPriorityPolicy_ptr _narrow (
          CORBA::Object_ptr obj,
@@ -124,7 +143,7 @@
            TAO_default_environment ()
        );
      static ClientPriorityPolicy_ptr _nil (void)
-@@ -204,7 +208,7 @@
+@@ -203,7 +223,7 @@
        }
  
      virtual TAO::PrioritySpecification priority_specification (
@@ -133,7 +152,7 @@
            TAO_default_environment ()
        )
        ACE_THROW_SPEC ((
-@@ -212,7 +216,7 @@
+@@ -211,7 +231,7 @@
        )) = 0;
  
      virtual void *_tao_QueryInterface (ptr_arith_t type);
@@ -142,7 +161,7 @@
      virtual const char* _interface_repository_id (void) const;
  
    protected:
-@@ -226,6 +230,10 @@
+@@ -225,6 +245,10 @@
  
  #endif /* end #if !defined */
  
@@ -153,7 +172,7 @@
    typedef CORBA::UShort BufferingConstraintMode;
    typedef CORBA::UShort_out BufferingConstraintMode_out;
      TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_BufferingConstraintMode;
-@@ -240,7 +248,7 @@
+@@ -239,7 +263,7 @@
  
    struct BufferingConstraint;
    class BufferingConstraint_var;
@@ -162,7 +181,7 @@
    struct TAO_Export BufferingConstraint
    {
  
-@@ -264,18 +272,18 @@
+@@ -263,18 +287,18 @@
      BufferingConstraint_var (const BufferingConstraint_var &); // copy constructor
      BufferingConstraint_var (const BufferingConstraint &); // fixed-size types only
      ~BufferingConstraint_var (void); // destructor
@@ -185,7 +204,7 @@
      const BufferingConstraint &in (void) const;
      BufferingConstraint &inout (void);
      BufferingConstraint &out (void);
-@@ -298,7 +306,7 @@
+@@ -297,7 +321,7 @@
  
    class BufferingConstraintPolicy;
    typedef BufferingConstraintPolicy *BufferingConstraintPolicy_ptr;
@@ -194,8 +213,12 @@
  #endif /* end #if !defined */
  
  
-@@ -312,14 +320,14 @@
-     BufferingConstraintPolicy_var (BufferingConstraintPolicy_ptr);
+@@ -308,17 +332,17 @@
+   {
+   public:
+     BufferingConstraintPolicy_var (void); // default constructor
+-    BufferingConstraintPolicy_var (BufferingConstraintPolicy_ptr p) : ptr_ (p) {} 
++    BufferingConstraintPolicy_var (BufferingConstraintPolicy_ptr);
      BufferingConstraintPolicy_var (const BufferingConstraintPolicy_var &); // copy constructor
      ~BufferingConstraintPolicy_var (void); // destructor
 -    
@@ -212,7 +235,7 @@
      BufferingConstraintPolicy_ptr in (void) const;
      BufferingConstraintPolicy_ptr &inout (void);
      BufferingConstraintPolicy_ptr &out (void);
-@@ -349,7 +357,7 @@
+@@ -351,7 +375,7 @@
      operator BufferingConstraintPolicy_ptr &();
      BufferingConstraintPolicy_ptr &ptr (void);
      BufferingConstraintPolicy_ptr operator-> (void);
@@ -221,7 +244,7 @@
    private:
      BufferingConstraintPolicy_ptr &ptr_;
    };
-@@ -373,12 +381,12 @@
+@@ -375,12 +399,12 @@
      static BufferingConstraintPolicy_ptr _duplicate (BufferingConstraintPolicy_ptr obj);
      static BufferingConstraintPolicy_ptr _narrow (
          CORBA::Object_ptr obj,
@@ -236,7 +259,7 @@
            TAO_default_environment ()
        );
      static BufferingConstraintPolicy_ptr _nil (void)
-@@ -387,7 +395,7 @@
+@@ -389,7 +413,7 @@
        }
  
      virtual TAO::BufferingConstraint buffering_constraint (
@@ -245,7 +268,7 @@
            TAO_default_environment ()
        )
        ACE_THROW_SPEC ((
-@@ -395,7 +403,7 @@
+@@ -397,7 +421,7 @@
        )) = 0;
  
      virtual void *_tao_QueryInterface (ptr_arith_t type);
@@ -254,7 +277,7 @@
      virtual const char* _interface_repository_id (void) const;
  
    protected:
-@@ -409,6 +417,8 @@
+@@ -411,6 +435,8 @@
  
  #endif /* end #if !defined */
  
@@ -263,7 +286,7 @@
    typedef CORBA::Short SyncScope;
    typedef CORBA::Short_out SyncScope_out;
      TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_SyncScope;
-@@ -425,25 +435,41 @@
+@@ -427,25 +453,41 @@
  
    TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short SYNC_DELAYED_BUFFERING;