ChangeLogTag:Sun Apr 30 17:45:29 2000 Carlos O'Ryan <coryan@uci.edu>

13 files changed, 865 insertions, 1035 deletions

diff --git a/TAO/ChangeLogs/ChangeLog-02a b/TAO/ChangeLogs/ChangeLog-02a
index 0ff768c3f08..459118d50e7 100644
--- a/TAO/ChangeLogs/ChangeLog-02a
+++ b/TAO/ChangeLogs/ChangeLog-02a
@@ -1,37 +1,59 @@
+Sun Apr 30 17:45:29 2000  Carlos O'Ryan  <coryan@uci.edu>
+
+        * tao/Messaging.pidl:
+        * tao/MessagingC.h:
+        * tao/MessagingC.i:
+        * tao/MessagingC.cpp:
+        * tao/MessagingS.h:
+        * tao/MessagingS.i:
+        * tao/MessagingS.cpp:
+        * tao/MessagingS_T.h:
+        * tao/MessagingS_T.i:
+        * tao/MessagingS_T.cpp:
+          Regenerate the code with support for valuetypes.  It compiles
+          with AMI enabled and also with AMI disabled on NT.
+
+        * tao/corba.h:
+          Add MessagingS.h again.
+
+        * tests/AMI/run_test.pl:
+          The test was using absolute paths for the IOR files and the
+          programs.
+
 Sun Apr 30 17:07:57 2000  Marina Spivak  <marina@cs.wustl.edu>
 
-	* utils/NamingViewer/NamingTreeCtrl.cpp:
-	  added a patch from Chris Hafey.
+        * utils/NamingViewer/NamingTreeCtrl.cpp:
+          added a patch from Chris Hafey.
 
-	* orbsvcs/orbsvcs/Naming/Persistent_Naming_Context.cpp (list):
-	  A pointer was incremented instead of the value it was pointing
-	  too, causing corruption of the memory-mapped file.  Thanks to
-	  Mathew.Samuel@msdw.com for reporting the problem.  This fixes
-	  bugzilla bug 551.
+        * orbsvcs/orbsvcs/Naming/Persistent_Naming_Context.cpp (list):
+          A pointer was incremented instead of the value it was pointing
+          too, causing corruption of the memory-mapped file.  Thanks to
+          Mathew.Samuel@msdw.com for reporting the problem.  This fixes
+          bugzilla bug 551.
 
-	* orbsvcs/orbsvcs/Naming/Hash_Naming_Context.cpp (destroy):
-	  When Persistent_Naming_Contexts were <destroyed>, their entries weren't
-	  removed from the Persistent_Context_Index.  Changed <destroy>
-	  method to set <destroyed_> variable to a higher value to insure 
-	  complete cleanup.
+        * orbsvcs/orbsvcs/Naming/Hash_Naming_Context.cpp (destroy):
+          When Persistent_Naming_Contexts were <destroyed>, their entries weren't
+          removed from the Persistent_Context_Index.  Changed <destroy>
+          method to set <destroyed_> variable to a higher value to insure
+          complete cleanup.
 
-	* docs/releasenotes/index.html:
-	  Naming section.
+        * docs/releasenotes/index.html:
+          Naming section.
 
 Sun Apr 30 10:48:31 2000  Nanbor Wang  <nanbor@cs.wustl.edu>
 
-	* tao/Pluggable_Messaging.h:
-	* tao/GIOP_Message_Connectors.h:
-	* tao/GIOP_Message_Accept_State.h: Added inclusion of
-	  "Excepption.h" to prevent KCC 3.3e from complaining.
+        * tao/Pluggable_Messaging.h:
+        * tao/GIOP_Message_Connectors.h:
+        * tao/GIOP_Message_Accept_State.h: Added inclusion of
+          "Excepption.h" to prevent KCC 3.3e from complaining.
 
 Sat Apr 29 23:41:02 2000  Nanbor Wang  <nanbor@cs.wustl.edu>
 
-	* tao/diffs/InterceptorC.h.diff:
-	* tao/diffs/InterceptorC.cpp.diff:
-	* tao/InterceptorC.h: Some compilers require the type specified in
-	  throw spec be well defined.  Included "Exception.h" in this
-	  file.  Regenerated Interceptor.pidl.
+        * tao/diffs/InterceptorC.h.diff:
+        * tao/diffs/InterceptorC.cpp.diff:
+        * tao/InterceptorC.h: Some compilers require the type specified in
+          throw spec be well defined.  Included "Exception.h" in this
+          file.  Regenerated Interceptor.pidl.
 
 Sat Apr 29 20:57:34 2000  Carlos O'Ryan  <coryan@uci.edu>
 
diff --git a/TAO/tao/Messaging.pidl b/TAO/tao/Messaging.pidl
index f8d5dbf82a1..48406091212 100644
--- a/TAO/tao/Messaging.pidl
+++ b/TAO/tao/Messaging.pidl
@@ -14,9 +14,12 @@
 //
 //   The command used to generate code from this file is:
 //
-//   tao_idl -o orig -Gp -Gd -Ge 1 -Gv  \
-//       -Wb,export_macro=TAO_Export \
-//       -Wb,export_include="tao/corbafwd.h" Messaging.pidl
+//     tao_idl.exe -o orig -Gp -Gd -Ge 1 -Gv \
+//          -Wb,export_macro=TAO_Export \
+//          -Wb,export_include=corbafwd.h \
+//          -Wb,pre_include="ace/pre.h" \
+//          -Wb,post_include="ace/post.h" \
+//          Messaging.pidl
 //
 //   after the file is generated a patch must be applied.  The patch
 //   fixes the interface repository IDs, disables the code under
@@ -186,6 +189,7 @@ module Messaging
 
   interface ReplyHandler { };
 
+#if 0
   //
   // Base value for the Polling model
   //
@@ -213,6 +217,7 @@ module Messaging
     public string                     op_name;
   };
 #endif
+#endif /* 0 */
 };
 
 #pragma prefix ""
diff --git a/TAO/tao/MessagingC.cpp b/TAO/tao/MessagingC.cpp
index 0feb4d0e342..6ab2469af69 100644
--- a/TAO/tao/MessagingC.cpp
+++ b/TAO/tao/MessagingC.cpp
@@ -12,7 +12,6 @@
 #if (TAO_HAS_CORBA_MESSAGING == 1)
 
 #include "tao/MessagingS.h"
-#include "tao/POA_CORBA.h"
 #include "tao/Stub.h"
 #include "tao/Invocation.h"
 
@@ -220,7 +219,7 @@ void *Messaging::RebindPolicy::_tao_QueryInterface (ptr_arith_t type)
   void *retv = 0;
   if (type == ACE_reinterpret_cast
     (ptr_arith_t,
-      &RebindPolicy::_narrow))
+      &ACE_NESTED_CLASS (Messaging, RebindPolicy)::_narrow))
     retv = ACE_reinterpret_cast (void*, this);
   else if (type == ACE_reinterpret_cast
     (ptr_arith_t,
@@ -299,7 +298,7 @@ void *Messaging::SyncScopePolicy::_tao_QueryInterface (ptr_arith_t type)
   void *retv = 0;
   if (type == ACE_reinterpret_cast
     (ptr_arith_t,
-      &SyncScopePolicy::_narrow))
+      &ACE_NESTED_CLASS (Messaging, SyncScopePolicy)::_narrow))
     retv = ACE_reinterpret_cast (void*, this);
   else if (type == ACE_reinterpret_cast
     (ptr_arith_t,
@@ -414,7 +413,7 @@ void *Messaging::RequestPriorityPolicy::_tao_QueryInterface (ptr_arith_t type)
   void *retv = 0;
   if (type == ACE_reinterpret_cast
     (ptr_arith_t,
-      &RequestPriorityPolicy::_narrow))
+      &ACE_NESTED_CLASS (Messaging, RequestPriorityPolicy)::_narrow))
     retv = ACE_reinterpret_cast (void*, this);
   else if (type == ACE_reinterpret_cast
     (ptr_arith_t,
@@ -493,7 +492,7 @@ void *Messaging::ReplyPriorityPolicy::_tao_QueryInterface (ptr_arith_t type)
   void *retv = 0;
   if (type == ACE_reinterpret_cast
     (ptr_arith_t,
-      &ReplyPriorityPolicy::_narrow))
+      &ACE_NESTED_CLASS (Messaging, ReplyPriorityPolicy)::_narrow))
     retv = ACE_reinterpret_cast (void*, this);
   else if (type == ACE_reinterpret_cast
     (ptr_arith_t,
@@ -572,7 +571,7 @@ void *Messaging::RequestStartTimePolicy::_tao_QueryInterface (ptr_arith_t type)
   void *retv = 0;
   if (type == ACE_reinterpret_cast
     (ptr_arith_t,
-      &RequestStartTimePolicy::_narrow))
+      &ACE_NESTED_CLASS (Messaging, RequestStartTimePolicy)::_narrow))
     retv = ACE_reinterpret_cast (void*, this);
   else if (type == ACE_reinterpret_cast
     (ptr_arith_t,
@@ -651,7 +650,7 @@ void *Messaging::RequestEndTimePolicy::_tao_QueryInterface (ptr_arith_t type)
   void *retv = 0;
   if (type == ACE_reinterpret_cast
     (ptr_arith_t,
-      &RequestEndTimePolicy::_narrow))
+      &ACE_NESTED_CLASS (Messaging, RequestEndTimePolicy)::_narrow))
     retv = ACE_reinterpret_cast (void*, this);
   else if (type == ACE_reinterpret_cast
     (ptr_arith_t,
@@ -730,7 +729,7 @@ void *Messaging::ReplyStartTimePolicy::_tao_QueryInterface (ptr_arith_t type)
   void *retv = 0;
   if (type == ACE_reinterpret_cast
     (ptr_arith_t,
-      &ReplyStartTimePolicy::_narrow))
+      &ACE_NESTED_CLASS (Messaging, ReplyStartTimePolicy)::_narrow))
     retv = ACE_reinterpret_cast (void*, this);
   else if (type == ACE_reinterpret_cast
     (ptr_arith_t,
@@ -809,7 +808,7 @@ void *Messaging::ReplyEndTimePolicy::_tao_QueryInterface (ptr_arith_t type)
   void *retv = 0;
   if (type == ACE_reinterpret_cast
     (ptr_arith_t,
-      &ReplyEndTimePolicy::_narrow))
+      &ACE_NESTED_CLASS (Messaging, ReplyEndTimePolicy)::_narrow))
     retv = ACE_reinterpret_cast (void*, this);
   else if (type == ACE_reinterpret_cast
     (ptr_arith_t,
@@ -888,7 +887,7 @@ void *Messaging::RelativeRequestTimeoutPolicy::_tao_QueryInterface (ptr_arith_t
   void *retv = 0;
   if (type == ACE_reinterpret_cast
     (ptr_arith_t,
-      &RelativeRequestTimeoutPolicy::_narrow))
+      &ACE_NESTED_CLASS (Messaging, RelativeRequestTimeoutPolicy)::_narrow))
     retv = ACE_reinterpret_cast (void*, this);
   else if (type == ACE_reinterpret_cast
     (ptr_arith_t,
@@ -967,7 +966,7 @@ void *Messaging::RelativeRoundtripTimeoutPolicy::_tao_QueryInterface (ptr_arith_
   void *retv = 0;
   if (type == ACE_reinterpret_cast
     (ptr_arith_t,
-      &RelativeRoundtripTimeoutPolicy::_narrow))
+      &ACE_NESTED_CLASS (Messaging, RelativeRoundtripTimeoutPolicy)::_narrow))
     retv = ACE_reinterpret_cast (void*, this);
   else if (type == ACE_reinterpret_cast
     (ptr_arith_t,
@@ -1082,7 +1081,7 @@ void *Messaging::RoutingPolicy::_tao_QueryInterface (ptr_arith_t type)
   void *retv = 0;
   if (type == ACE_reinterpret_cast
     (ptr_arith_t,
-      &RoutingPolicy::_narrow))
+      &ACE_NESTED_CLASS (Messaging, RoutingPolicy)::_narrow))
     retv = ACE_reinterpret_cast (void*, this);
   else if (type == ACE_reinterpret_cast
     (ptr_arith_t,
@@ -1161,7 +1160,7 @@ void *Messaging::MaxHopsPolicy::_tao_QueryInterface (ptr_arith_t type)
   void *retv = 0;
   if (type == ACE_reinterpret_cast
     (ptr_arith_t,
-      &MaxHopsPolicy::_narrow))
+      &ACE_NESTED_CLASS (Messaging, MaxHopsPolicy)::_narrow))
     retv = ACE_reinterpret_cast (void*, this);
   else if (type == ACE_reinterpret_cast
     (ptr_arith_t,
@@ -1240,7 +1239,7 @@ void *Messaging::QueueOrderPolicy::_tao_QueryInterface (ptr_arith_t type)
   void *retv = 0;
   if (type == ACE_reinterpret_cast
     (ptr_arith_t,
-      &QueueOrderPolicy::_narrow))
+      &ACE_NESTED_CLASS (Messaging, QueueOrderPolicy)::_narrow))
     retv = ACE_reinterpret_cast (void*, this);
   else if (type == ACE_reinterpret_cast
     (ptr_arith_t,
@@ -1497,78 +1496,77 @@ TAO_NAMESPACE_TYPE (const CORBA::ULong)
 TAO_NAMESPACE_BEGIN (Messaging)
 TAO_NAMESPACE_DEFINE (const CORBA::ULong, INVOCATION_POLICIES, 2U)
 TAO_NAMESPACE_END
-static const CORBA::Long _oc_Messaging_ExceptionHolder[] =
+
+#if (TAO_HAS_AMI_CALLBACK == 1) || (TAO_HAS_AMI_POLLER == 1)
+
+Messaging::ExceptionHolder* Messaging::ExceptionHolder::_downcast (CORBA::ValueBase* v)
 {
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x4d657373), ACE_NTOHL (0x6167696e), ACE_NTOHL (0x672f4578), ACE_NTOHL (0x63657074), ACE_NTOHL (0x696f6e48), ACE_NTOHL (0x6f6c6465), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:Messaging/ExceptionHolder:1.0
-  16, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e486f6c), ACE_NTOHL (0x64657200),  // name = ExceptionHolder
-  3, // member count
-  20, ACE_NTOHL (0x69735f73), ACE_NTOHL (0x79737465), ACE_NTOHL (0x6d5f6578), ACE_NTOHL (0x63657074), ACE_NTOHL (0x696f6e00),  // name = is_system_exception
-  CORBA::tk_boolean,
+  if (v == 0) return 0;
+  return (ExceptionHolder* ) v->_tao_obv_narrow ((ptr_arith_t) &_downcast);
+}
 
-  11, ACE_NTOHL (0x62797465), ACE_NTOHL (0x5f6f7264), ACE_NTOHL (0x65720000),  // name = byte_order
-  CORBA::tk_boolean,
+const char* Messaging::ExceptionHolder::_tao_obv_repository_id () const
+{
+  return this->_tao_obv_static_repository_id ();
+}
 
-  20, ACE_NTOHL (0x6d617273), ACE_NTOHL (0x68616c65), ACE_NTOHL (0x645f6578), ACE_NTOHL (0x63657074), ACE_NTOHL (0x696f6e00),  // name = marshaled_exception
-  CORBA::tk_sequence, // typecode kind
-  12, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_octet,
+void* Messaging::ExceptionHolder::_tao_obv_narrow (ptr_arith_t type_id)
+{
+  if (type_id == (ptr_arith_t) &_downcast)
+    return this;
+  void *rval = 0;
+  return rval;
+}
 
-    0U,
+CORBA::Boolean Messaging::ExceptionHolder::_tao_marshal_v (TAO_OutputCDR & strm)
+{
+  return this->_tao_marshal__Messaging_ExceptionHolder (strm);
+}
 
-};
+CORBA::Boolean Messaging::ExceptionHolder::_tao_unmarshal_v (TAO_InputCDR & strm)
+{
+  return this->_tao_unmarshal__Messaging_ExceptionHolder (strm);
+}
 
-#if (TAO_HAS_AMI_CALLBACK == 1) || (TAO_HAS_AMI_POLLER == 1)
+CORBA::Boolean Messaging::ExceptionHolder::_tao_unmarshal (TAO_InputCDR &strm, Messaging::ExceptionHolder *&new_object)
+{
+  CORBA::Boolean retval = 1;
+  CORBA::ValueBase *base;   // %! should be a _var
+  CORBA::ValueFactory_ptr factory;   // %! should be a _var
+  if (!CORBA::ValueBase::_tao_unmarshal_pre (strm, factory, base,
+          Messaging::ExceptionHolder::_tao_obv_static_repository_id ()) )
+    {
+      return 0;
+    }
+  if (factory != 0)
+    {
+      base = factory->create_for_unmarshal ();
+      factory->_remove_ref ();
+      if (base == 0)  return 0;  // %! except.?
+      //%! ACE_DEBUG ((LM_DEBUG, "Messaging::ExceptionHolder::_tao_unmarshal %s\n", base->_tao_obv_repository_id () ));
+      retval = base->_tao_unmarshal_v (strm);
+      //%! ACE_DEBUG ((LM_DEBUG, "Messaging::ExceptionHolder::_tao_unmarshal retval unmarshal_v is %d\n", retval));
+      if (!retval) return 0;
+    }
+  // Now base must be null or point to the unmarshaled object.
+  // Align the pointer to the right subobject.
+  new_object = Messaging::ExceptionHolder::_downcast (base);
+  // %! unmarshal_post
+  return 1;
+}
 
-static CORBA::TypeCode _tc_TAO_tc_Messaging_ExceptionHolder (CORBA::tk_struct, sizeof (_oc_Messaging_ExceptionHolder), (char *) &_oc_Messaging_ExceptionHolder, 0, sizeof (Messaging::ExceptionHolder));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (Messaging)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ExceptionHolder, &_tc_TAO_tc_Messaging_ExceptionHolder)
-TAO_NAMESPACE_END
 
-#if !defined (_MESSAGING_EXCEPTIONHOLDER__TAO_SEQ_OCTET_CS_)
-#define _MESSAGING_EXCEPTIONHOLDER__TAO_SEQ_OCTET_CS_
+#if !defined (_MESSAGING_EXCEPTIONHOLDER___INIT_CS_)
+#define _MESSAGING_EXCEPTIONHOLDER___INIT_CS_
 
-// *************************************************************
-// Messaging::ExceptionHolder::_tao_seq_Octet
-// *************************************************************
+Messaging::ExceptionHolder_init::~ExceptionHolder_init ()
+{
+}
 
-Messaging::ExceptionHolder::_tao_seq_Octet::_tao_seq_Octet (void)
-{}
-Messaging::ExceptionHolder::_tao_seq_Octet::_tao_seq_Octet (CORBA::ULong max) // uses max size
-  :
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  TAO_Unbounded_Sequence<CORBA::Octet>
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA::Octet>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
- (max)
-{}
-Messaging::ExceptionHolder::_tao_seq_Octet::_tao_seq_Octet (CORBA::ULong max, CORBA::ULong length, CORBA::Octet *buffer, CORBA::Boolean release)
-  :
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  TAO_Unbounded_Sequence<CORBA::Octet>
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA::Octet>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
- (max, length, buffer, release)
-{}
-Messaging::ExceptionHolder::_tao_seq_Octet::_tao_seq_Octet (const _tao_seq_Octet &seq) // copy ctor
-  :
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  TAO_Unbounded_Sequence<CORBA::Octet>
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA::Octet>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
- (seq)
-{}
-Messaging::ExceptionHolder::_tao_seq_Octet::~_tao_seq_Octet (void) // dtor
-{}
-void Messaging::ExceptionHolder::_tao_seq_Octet::_tao_any_destructor (void *x)
+const char*
+Messaging::ExceptionHolder_init::tao_repository_id ()
 {
-  _tao_seq_Octet *tmp = ACE_static_cast (_tao_seq_Octet*,x);
-  delete tmp;
+  return Messaging::ExceptionHolder::_tao_obv_static_repository_id ();
 }
 
 
@@ -1662,7 +1660,7 @@ void *Messaging::ReplyHandler::_tao_QueryInterface (ptr_arith_t type)
   void *retv = 0;
   if (type == ACE_reinterpret_cast
     (ptr_arith_t,
-      &ReplyHandler::_narrow))
+      &ACE_NESTED_CLASS (Messaging, ReplyHandler)::_narrow))
     retv = ACE_reinterpret_cast (void*, this);
   else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
     retv = ACE_reinterpret_cast (void *,
@@ -1818,474 +1816,781 @@ Messaging::TAO_Messaging_ReplyHandler_Smart_Proxy_Base::get_proxy (void)
 
 #endif /* TAO_HAS_AMI_CALLBACK == 1 || TAO_HAS_AMI_POLLER == 1 */
 
+#if (TAO_HAS_AMI_CALLBACK == 1)
 
-void operator<<= (CORBA::Any &_tao_any, const Messaging::PriorityRange &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      Messaging::_tc_PriorityRange,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
+    CORBA::Boolean
+  OBV_Messaging::ExceptionHolder::_tao_marshal__Messaging_ExceptionHolder (TAO_OutputCDR &strm){
+    return _tao_marshal_state (strm);
+
+  }
+CORBA::Boolean OBV_Messaging::ExceptionHolder::_tao_unmarshal__Messaging_ExceptionHolder (TAO_InputCDR &strm){
+    return _tao_unmarshal_state (strm);
+
+  }
+  // accessor to set the member
+  void
+  OBV_Messaging::ExceptionHolder::is_system_exception (CORBA::Boolean val) // set
+  {
+    // set the value
+    this->_pd_is_system_exception = val;
+  }
+  // retrieve the member
+  CORBA::Boolean
+  OBV_Messaging::ExceptionHolder::is_system_exception (void) const
+  {
+    return this->_pd_is_system_exception;
+  }
+
+  // accessor to set the member
+  void
+  OBV_Messaging::ExceptionHolder::byte_order (CORBA::Boolean val) // set
+  {
+    // set the value
+    this->_pd_byte_order = val;
+  }
+  // retrieve the member
+  CORBA::Boolean
+  OBV_Messaging::ExceptionHolder::byte_order (void) const
+  {
+    return this->_pd_byte_order;
+  }
 
-void operator<<= (CORBA::Any &_tao_any, Messaging::PriorityRange *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      Messaging::_tc_PriorityRange,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      Messaging::PriorityRange::_tao_any_destructor
-    );
-}
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PriorityRange *&_tao_elem)
+#if !defined (_MESSAGING_EXCEPTIONHOLDER__TAO_SEQ_OCTET_CS_)
+#define _MESSAGING_EXCEPTIONHOLDER__TAO_SEQ_OCTET_CS_
+
+Messaging::ExceptionHolder::_tao_seq_Octet::_tao_seq_Octet (void)
+{}
+Messaging::ExceptionHolder::_tao_seq_Octet::_tao_seq_Octet (CORBA::ULong max) // uses max size
+  :
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  TAO_Unbounded_Sequence<CORBA::Octet>
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::Octet>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+ (max)
+{}
+Messaging::ExceptionHolder::_tao_seq_Octet::_tao_seq_Octet (CORBA::ULong max, CORBA::ULong length, CORBA::Octet *buffer, CORBA::Boolean release)
+  :
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  TAO_Unbounded_Sequence<CORBA::Octet>
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::Octet>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+ (max, length, buffer, release)
+{}
+Messaging::ExceptionHolder::_tao_seq_Octet::_tao_seq_Octet (const _tao_seq_Octet &seq) // copy ctor
+  :
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  TAO_Unbounded_Sequence<CORBA::Octet>
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::Octet>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+ (seq)
+{}
+Messaging::ExceptionHolder::_tao_seq_Octet::~_tao_seq_Octet (void) // dtor
+{}
+void Messaging::ExceptionHolder::_tao_seq_Octet::_tao_any_destructor (void *x)
 {
-  return _tao_any >>= ACE_const_cast(const Messaging::PriorityRange*&,_tao_elem);
+  _tao_seq_Octet *tmp = ACE_static_cast (_tao_seq_Octet*,x);
+  delete tmp;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const Messaging::PriorityRange *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
+  // *************************************************************
+  // Inline operations for class Messaging::ExceptionHolder::_tao_seq_Octet_var
+  // *************************************************************
+
+ACE_INLINE
+  Messaging::ExceptionHolder::_tao_seq_Octet_var::_tao_seq_Octet_var (void) // default constructor
+    : ptr_ (0)
+  {}
+
+  ACE_INLINE
+  Messaging::ExceptionHolder::_tao_seq_Octet_var::_tao_seq_Octet_var (_tao_seq_Octet *p)
+    : ptr_ (p)
+  {}
+
+  ACE_INLINE
+  Messaging::ExceptionHolder::_tao_seq_Octet_var::_tao_seq_Octet_var (const ::Messaging::ExceptionHolder::_tao_seq_Octet_var &p) // copy constructor
   {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (Messaging::_tc_PriorityRange, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
+    if (p.ptr_)
+      ACE_NEW (this->ptr_, ::Messaging::ExceptionHolder::_tao_seq_Octet (*p.ptr_));
+    else
+      this->ptr_ = 0;
+  }
+
+// fixed-size base types only
+  ACE_INLINE
+  Messaging::ExceptionHolder::_tao_seq_Octet_var::_tao_seq_Octet_var (const ::Messaging::ExceptionHolder::_tao_seq_Octet &p)
+  {
+    ACE_NEW (this->ptr_, ::Messaging::ExceptionHolder::_tao_seq_Octet (p));
+  }
+
+  ACE_INLINE
+  Messaging::ExceptionHolder::_tao_seq_Octet_var::~_tao_seq_Octet_var (void) // destructor
+  {
+    delete this->ptr_;
+  }
+
+  ACE_INLINE Messaging::ExceptionHolder::_tao_seq_Octet_var &
+  Messaging::ExceptionHolder::_tao_seq_Octet_var::operator= (_tao_seq_Octet *p)
+  {
+    delete this->ptr_;
+    this->ptr_ = p;
+    return *this;
+  }
+
+  ACE_INLINE Messaging::ExceptionHolder::_tao_seq_Octet_var &
+  Messaging::ExceptionHolder::_tao_seq_Octet_var::operator= (const ::Messaging::ExceptionHolder::_tao_seq_Octet_var &p) // deep copy
+  {
+    if (this != &p)
     {
-      _tao_elem = ACE_static_cast(
-          const Messaging::PriorityRange*,
-          _tao_any.value ()
-        );
-      return 1;
+      delete this->ptr_;
+      ACE_NEW_RETURN (this->ptr_, ::Messaging::ExceptionHolder::_tao_seq_Octet (*p.ptr_), *this);
     }
-    else
+    return *this;
+  }
+
+  // fixed-size types only
+  ACE_INLINE ::Messaging::ExceptionHolder::_tao_seq_Octet_var &
+  Messaging::ExceptionHolder::_tao_seq_Octet_var::operator= (const ::Messaging::ExceptionHolder::_tao_seq_Octet &p)
+  {
+    if (this->ptr_ != &p)
     {
-      Messaging::PriorityRange *tmp;
-      ACE_NEW_RETURN (tmp, Messaging::PriorityRange, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            Messaging::_tc_PriorityRange,
-            1,
-            ACE_static_cast (void *, tmp),
-            Messaging::PriorityRange::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
+      delete this->ptr_;
+      ACE_NEW_RETURN (this->ptr_, ::Messaging::ExceptionHolder::_tao_seq_Octet (p), *this);
     }
+    return *this;
   }
-  ACE_CATCHANY
+
+  ACE_INLINE const ::Messaging::ExceptionHolder::_tao_seq_Octet *
+  Messaging::ExceptionHolder::_tao_seq_Octet_var::operator-> (void) const
   {
+    return this->ptr_;
   }
-  ACE_ENDTRY;
-  return 0;
-}
 
-void operator<<= (CORBA::Any &_tao_any, const Messaging::RoutingTypeRange &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      Messaging::_tc_RoutingTypeRange,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
+  ACE_INLINE ::Messaging::ExceptionHolder::_tao_seq_Octet *
+  Messaging::ExceptionHolder::_tao_seq_Octet_var::operator-> (void)
+  {
+    return this->ptr_;
+  }
 
-void operator<<= (CORBA::Any &_tao_any, Messaging::RoutingTypeRange *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      Messaging::_tc_RoutingTypeRange,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      Messaging::RoutingTypeRange::_tao_any_destructor
-    );
-}
+  ACE_INLINE
+  Messaging::ExceptionHolder::_tao_seq_Octet_var::operator const ::Messaging::ExceptionHolder::_tao_seq_Octet &() const // cast
+  {
+    return *this->ptr_;
+  }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::RoutingTypeRange *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(const Messaging::RoutingTypeRange*&,_tao_elem);
-}
+  ACE_INLINE
+  Messaging::ExceptionHolder::_tao_seq_Octet_var::operator ::Messaging::ExceptionHolder::_tao_seq_Octet &() // cast
+  {
+    return *this->ptr_;
+  }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const Messaging::RoutingTypeRange *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
+  ACE_INLINE
+  Messaging::ExceptionHolder::_tao_seq_Octet_var::operator ::Messaging::ExceptionHolder::_tao_seq_Octet &() const // cast
   {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (Messaging::_tc_RoutingTypeRange, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const Messaging::RoutingTypeRange*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
+    return *this->ptr_;
+  }
+
+  ACE_INLINE CORBA::Octet &
+  Messaging::ExceptionHolder::_tao_seq_Octet_var::operator[] (CORBA::ULong index)
+  {
+    return this->ptr_->operator[] (index);
+  }
+
+  ACE_INLINE const ::Messaging::ExceptionHolder::_tao_seq_Octet &
+  Messaging::ExceptionHolder::_tao_seq_Octet_var::in (void) const
+  {
+    return *this->ptr_;
+  }
+
+  ACE_INLINE ::Messaging::ExceptionHolder::_tao_seq_Octet &
+  Messaging::ExceptionHolder::_tao_seq_Octet_var::inout (void)
+  {
+    return *this->ptr_;
+  }
+
+  // mapping for variable size
+  ACE_INLINE ::Messaging::ExceptionHolder::_tao_seq_Octet *&
+  Messaging::ExceptionHolder::_tao_seq_Octet_var::out (void)
+  {
+    delete this->ptr_;
+    this->ptr_ = 0;
+    return this->ptr_;
+  }
+
+  ACE_INLINE ::Messaging::ExceptionHolder::_tao_seq_Octet *
+  Messaging::ExceptionHolder::_tao_seq_Octet_var::_retn (void)
+  {
+    ::Messaging::ExceptionHolder::_tao_seq_Octet *tmp = this->ptr_;
+    this->ptr_ = 0;
+    return tmp;
+  }
+
+  ACE_INLINE ::Messaging::ExceptionHolder::_tao_seq_Octet *
+  Messaging::ExceptionHolder::_tao_seq_Octet_var::ptr (void) const
+  {
+    return this->ptr_;
+  }
+
+  // *************************************************************
+  // Inline operations for class Messaging::ExceptionHolder::_tao_seq_Octet_out
+  // *************************************************************
+
+  ACE_INLINE
+  Messaging::ExceptionHolder::_tao_seq_Octet_out::_tao_seq_Octet_out (_tao_seq_Octet *&p)
+    : ptr_ (p)
+  {
+    this->ptr_ = 0;
+  }
+
+  ACE_INLINE
+  Messaging::ExceptionHolder::_tao_seq_Octet_out::_tao_seq_Octet_out (_tao_seq_Octet_var &p) // constructor from _var
+    : ptr_ (p.out ())
+  {
+    delete this->ptr_;
+    this->ptr_ = 0;
+  }
+
+  ACE_INLINE
+  Messaging::ExceptionHolder::_tao_seq_Octet_out::_tao_seq_Octet_out (const ::Messaging::ExceptionHolder::_tao_seq_Octet_out &p) // copy constructor
+    : ptr_ (ACE_const_cast (_tao_seq_Octet_out&, p).ptr_)
+  {}
+
+  ACE_INLINE ::Messaging::ExceptionHolder::_tao_seq_Octet_out &
+  Messaging::ExceptionHolder::_tao_seq_Octet_out::operator= (const ::Messaging::ExceptionHolder::_tao_seq_Octet_out &p)
+  {
+    this->ptr_ = ACE_const_cast (_tao_seq_Octet_out&, p).ptr_;
+    return *this;
+  }
+
+  ACE_INLINE ::Messaging::ExceptionHolder::_tao_seq_Octet_out &
+  Messaging::ExceptionHolder::_tao_seq_Octet_out::operator= (_tao_seq_Octet *p)
+  {
+    this->ptr_ = p;
+    return *this;
+  }
+
+  ACE_INLINE
+  Messaging::ExceptionHolder::_tao_seq_Octet_out::operator ::Messaging::ExceptionHolder::_tao_seq_Octet *&() // cast
+  {
+    return this->ptr_;
+  }
+
+  ACE_INLINE ::Messaging::ExceptionHolder::_tao_seq_Octet *&
+  Messaging::ExceptionHolder::_tao_seq_Octet_out::ptr (void) // ptr
+  {
+    return this->ptr_;
+  }
+
+  ACE_INLINE ::Messaging::ExceptionHolder::_tao_seq_Octet *
+  Messaging::ExceptionHolder::_tao_seq_Octet_out::operator-> (void)
+  {
+    return this->ptr_;
+  }
+
+  ACE_INLINE CORBA::Octet &
+  Messaging::ExceptionHolder::_tao_seq_Octet_out::operator[] (CORBA::ULong index)
+  {
+    return this->ptr_->operator[] (index);
+  }
+
+
+#endif /* end #if !defined */
+
+// accessor to set the member
+  void
+  OBV_Messaging::ExceptionHolder::marshaled_exception (const Messaging::ExceptionHolder::_tao_seq_Octet &val)
+  {
+    this->_pd_marshaled_exception = val;
+  }
+
+  // readonly get method
+  const Messaging::ExceptionHolder::_tao_seq_Octet &
+  OBV_Messaging::ExceptionHolder::marshaled_exception (void) const
+  {
+    return this->_pd_marshaled_exception;
+  }
+
+  // read/write get method
+  Messaging::ExceptionHolder::_tao_seq_Octet &
+  OBV_Messaging::ExceptionHolder::marshaled_exception (void)
+  {
+    return this->_pd_marshaled_exception;
+  }
+
+#endif /* TAO_HAS_AMI_CALLBACK == 1 */
+
+
+                void operator<<= (CORBA::Any &_tao_any, const Messaging::PriorityRange &_tao_elem) // copying
+  {
+    TAO_OutputCDR stream;
+    stream << _tao_elem;
+    _tao_any._tao_replace (
+        Messaging::_tc_PriorityRange,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+
+  void operator<<= (CORBA::Any &_tao_any, Messaging::PriorityRange *_tao_elem) // non copying
+  {
+    TAO_OutputCDR stream;
+    stream << *_tao_elem;
+    _tao_any._tao_replace (
+        Messaging::_tc_PriorityRange,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        _tao_elem,
+        Messaging::PriorityRange::_tao_any_destructor
+      );
+  }
+
+  CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PriorityRange *&_tao_elem)
+  {
+    return _tao_any >>= ACE_const_cast(const Messaging::PriorityRange*&,_tao_elem);
+  }
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const Messaging::PriorityRange *&_tao_elem)
+  {
+    _tao_elem = 0;
+    ACE_TRY_NEW_ENV
     {
-      Messaging::RoutingTypeRange *tmp;
-      ACE_NEW_RETURN (tmp, Messaging::RoutingTypeRange, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
+      CORBA::TypeCode_var type = _tao_any.type ();
+      if (!type->equivalent (Messaging::_tc_PriorityRange, ACE_TRY_ENV)) // not equal
+        {
+          return 0;
+        }
+      ACE_TRY_CHECK;
+      if (_tao_any.any_owns_data ())
       {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            Messaging::_tc_RoutingTypeRange,
-            1,
-            ACE_static_cast (void *, tmp),
-            Messaging::RoutingTypeRange::_tao_any_destructor
+        _tao_elem = ACE_static_cast(
+            const Messaging::PriorityRange*,
+            _tao_any.value ()
           );
-        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete tmp;
+        Messaging::PriorityRange *tmp;
+        ACE_NEW_RETURN (tmp, Messaging::PriorityRange, 0);
+        TAO_InputCDR stream (
+            _tao_any._tao_get_cdr (),
+            _tao_any._tao_byte_order ()
+          );
+        if (stream >> *tmp)
+        {
+          ((CORBA::Any *)&_tao_any)->_tao_replace (
+              Messaging::_tc_PriorityRange,
+              1,
+              ACE_static_cast (void *, tmp),
+              Messaging::PriorityRange::_tao_any_destructor
+            );
+          _tao_elem = tmp;
+          return 1;
+        }
+        else
+        {
+          delete tmp;
+        }
       }
     }
+    ACE_CATCHANY
+    {
+    }
+    ACE_ENDTRY;
+    return 0;
   }
-  ACE_CATCHANY
+
+  void operator<<= (CORBA::Any &_tao_any, const Messaging::RoutingTypeRange &_tao_elem) // copying
   {
+    TAO_OutputCDR stream;
+    stream << _tao_elem;
+    _tao_any._tao_replace (
+        Messaging::_tc_RoutingTypeRange,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
   }
-  ACE_ENDTRY;
-  return 0;
-}
 
-void operator<<= (CORBA::Any &_tao_any, const Messaging::PolicyValue &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      Messaging::_tc_PolicyValue,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-void operator<<= (CORBA::Any &_tao_any, Messaging::PolicyValue *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      Messaging::_tc_PolicyValue,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      Messaging::PolicyValue::_tao_any_destructor
-    );
-}
+  void operator<<= (CORBA::Any &_tao_any, Messaging::RoutingTypeRange *_tao_elem) // non copying
+  {
+    TAO_OutputCDR stream;
+    stream << *_tao_elem;
+    _tao_any._tao_replace (
+        Messaging::_tc_RoutingTypeRange,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        _tao_elem,
+        Messaging::RoutingTypeRange::_tao_any_destructor
+      );
+  }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PolicyValue *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(const Messaging::PolicyValue*&,_tao_elem);
-}
+  CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::RoutingTypeRange *&_tao_elem)
+  {
+    return _tao_any >>= ACE_const_cast(const Messaging::RoutingTypeRange*&,_tao_elem);
+  }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const Messaging::PolicyValue *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const Messaging::RoutingTypeRange *&_tao_elem)
   {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (Messaging::_tc_PolicyValue, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
+    _tao_elem = 0;
+    ACE_TRY_NEW_ENV
     {
-      _tao_elem = ACE_static_cast(
-          const Messaging::PolicyValue*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      Messaging::PolicyValue *tmp;
-      ACE_NEW_RETURN (tmp, Messaging::PolicyValue, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
+      CORBA::TypeCode_var type = _tao_any.type ();
+      if (!type->equivalent (Messaging::_tc_RoutingTypeRange, ACE_TRY_ENV)) // not equal
+        {
+          return 0;
+        }
+      ACE_TRY_CHECK;
+      if (_tao_any.any_owns_data ())
       {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            Messaging::_tc_PolicyValue,
-            1,
-            ACE_static_cast (void *, tmp),
-            Messaging::PolicyValue::_tao_any_destructor
+        _tao_elem = ACE_static_cast(
+            const Messaging::RoutingTypeRange*,
+            _tao_any.value ()
           );
-        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete tmp;
+        Messaging::RoutingTypeRange *tmp;
+        ACE_NEW_RETURN (tmp, Messaging::RoutingTypeRange, 0);
+        TAO_InputCDR stream (
+            _tao_any._tao_get_cdr (),
+            _tao_any._tao_byte_order ()
+          );
+        if (stream >> *tmp)
+        {
+          ((CORBA::Any *)&_tao_any)->_tao_replace (
+              Messaging::_tc_RoutingTypeRange,
+              1,
+              ACE_static_cast (void *, tmp),
+              Messaging::RoutingTypeRange::_tao_any_destructor
+            );
+          _tao_elem = tmp;
+          return 1;
+        }
+        else
+        {
+          delete tmp;
+        }
       }
     }
+    ACE_CATCHANY
+    {
+    }
+    ACE_ENDTRY;
+    return 0;
   }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
 
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const Messaging::PolicyValueSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
+  void operator<<= (CORBA::Any &_tao_any, const Messaging::PolicyValue &_tao_elem) // copying
   {
+    TAO_OutputCDR stream;
+    stream << _tao_elem;
     _tao_any._tao_replace (
-        Messaging::_tc_PolicyValueSeq,
+        Messaging::_tc_PolicyValue,
         TAO_ENCAP_BYTE_ORDER,
         stream.begin ()
       );
   }
-}
 
-void operator<<= (CORBA::Any &_tao_any, Messaging::PolicyValueSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      Messaging::_tc_PolicyValueSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      Messaging::PolicyValueSeq::_tao_any_destructor
-    );
-}
+  void operator<<= (CORBA::Any &_tao_any, Messaging::PolicyValue *_tao_elem) // non copying
+  {
+    TAO_OutputCDR stream;
+    stream << *_tao_elem;
+    _tao_any._tao_replace (
+        Messaging::_tc_PolicyValue,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        _tao_elem,
+        Messaging::PolicyValue::_tao_any_destructor
+      );
+  }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PolicyValueSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const Messaging::PolicyValueSeq*&,
-      _tao_elem
-    );
-}
+  CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PolicyValue *&_tao_elem)
+  {
+    return _tao_any >>= ACE_const_cast(const Messaging::PolicyValue*&,_tao_elem);
+  }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const Messaging::PolicyValueSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const Messaging::PolicyValue *&_tao_elem)
   {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (Messaging::_tc_PolicyValueSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
+    _tao_elem = 0;
+    ACE_TRY_NEW_ENV
     {
-      _tao_elem = ACE_static_cast(
-          const Messaging::PolicyValueSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      Messaging::PolicyValueSeq *tmp;
-      ACE_NEW_RETURN (tmp, Messaging::PolicyValueSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
+      CORBA::TypeCode_var type = _tao_any.type ();
+      if (!type->equivalent (Messaging::_tc_PolicyValue, ACE_TRY_ENV)) // not equal
+        {
+          return 0;
+        }
+      ACE_TRY_CHECK;
+      if (_tao_any.any_owns_data ())
       {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            Messaging::_tc_PolicyValueSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            Messaging::PolicyValueSeq::_tao_any_destructor
+        _tao_elem = ACE_static_cast(
+            const Messaging::PolicyValue*,
+            _tao_any.value ()
           );
-        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete tmp;
+        Messaging::PolicyValue *tmp;
+        ACE_NEW_RETURN (tmp, Messaging::PolicyValue, 0);
+        TAO_InputCDR stream (
+            _tao_any._tao_get_cdr (),
+            _tao_any._tao_byte_order ()
+          );
+        if (stream >> *tmp)
+        {
+          ((CORBA::Any *)&_tao_any)->_tao_replace (
+              Messaging::_tc_PolicyValue,
+              1,
+              ACE_static_cast (void *, tmp),
+              Messaging::PolicyValue::_tao_any_destructor
+            );
+          _tao_elem = tmp;
+          return 1;
+        }
+        else
+        {
+          delete tmp;
+        }
       }
     }
+    ACE_CATCHANY
+    {
+    }
+    ACE_ENDTRY;
+    return 0;
   }
-  ACE_CATCHANY
+
+    void operator<<= (
+      CORBA::Any &_tao_any,
+      const Messaging::PolicyValueSeq &_tao_elem
+    ) // copying
   {
+    TAO_OutputCDR stream;
+    if (stream << _tao_elem)
+    {
+      _tao_any._tao_replace (
+          Messaging::_tc_PolicyValueSeq,
+          TAO_ENCAP_BYTE_ORDER,
+          stream.begin ()
+        );
+    }
   }
-  ACE_ENDTRY;
-  return 0;
-}
-
-#if (TAO_HAS_AMI_CALLBACK == 1) || (TAO_HAS_AMI_POLLER == 1)
 
-Messaging::ReplyHandler_ptr (*_TAO_collocation_Messaging_ReplyHandler_Stub_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-void operator<<= (CORBA::Any &_tao_any, Messaging::ReplyHandler_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
+  void operator<<= (CORBA::Any &_tao_any, Messaging::PolicyValueSeq *_tao_elem) // non copying
   {
+    TAO_OutputCDR stream;
+    stream << *_tao_elem;
     _tao_any._tao_replace (
-        Messaging::_tc_ReplyHandler,
+        Messaging::_tc_PolicyValueSeq,
         TAO_ENCAP_BYTE_ORDER,
         stream.begin (),
         1,
-        Messaging::ReplyHandler::_duplicate (_tao_elem),
-        Messaging::ReplyHandler::_tao_any_destructor
+        _tao_elem,
+        Messaging::PolicyValueSeq::_tao_any_destructor
       );
   }
-}
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::ReplyHandler_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
+  CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::PolicyValueSeq *&_tao_elem)
   {
-    _tao_elem = Messaging::ReplyHandler::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (Messaging::_tc_ReplyHandler, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
+    return _tao_any >>= ACE_const_cast(
+        const Messaging::PolicyValueSeq*&,
+        _tao_elem
       );
-    CORBA::Object_var _tao_obj_var;
-    if (stream >> _tao_obj_var.out ())
+  }
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const Messaging::PolicyValueSeq *&_tao_elem)
+  {
+    _tao_elem = 0;
+    ACE_TRY_NEW_ENV
     {
-      _tao_elem = Messaging::ReplyHandler::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      CORBA::TypeCode_var type = _tao_any.type ();
+      if (!type->equivalent (Messaging::_tc_PolicyValueSeq, ACE_TRY_ENV)) // not equal
+        {
+          return 0;
+        }
       ACE_TRY_CHECK;
+      if (_tao_any.any_owns_data ())
+      {
+        _tao_elem = ACE_static_cast(
+            const Messaging::PolicyValueSeq*,
+            _tao_any.value ()
+          );
+        return 1;
+      }
+      else
+      {
+        Messaging::PolicyValueSeq *tmp;
+        ACE_NEW_RETURN (tmp, Messaging::PolicyValueSeq, 0);
+        TAO_InputCDR stream (
+            _tao_any._tao_get_cdr (),
+            _tao_any._tao_byte_order ()
+          );
+        if (stream >> *tmp)
+        {
+          ((CORBA::Any *)&_tao_any)->_tao_replace (
+              Messaging::_tc_PolicyValueSeq,
+              1,
+              ACE_static_cast (void *, tmp),
+              Messaging::PolicyValueSeq::_tao_any_destructor
+            );
+          _tao_elem = tmp;
+          return 1;
+        }
+        else
+        {
+          delete tmp;
+        }
+      }
+    }
+    ACE_CATCHANY
+    {
+    }
+    ACE_ENDTRY;
+    return 0;
+  }
+
+#if (TAO_HAS_AMI_CALLBACK == 1) || (TAO_HAS_AMI_POLLER == 1)
 
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
+  Messaging::ReplyHandler_ptr (*_TAO_collocation_Messaging_ReplyHandler_Stub_Factory_function_pointer) (
+      CORBA::Object_ptr obj
+    ) = 0;
+    void operator<<= (CORBA::Any &_tao_any, Messaging::ReplyHandler_ptr _tao_elem)
+  {
+    TAO_OutputCDR stream;
+    if (stream << _tao_elem)
+    {
+      _tao_any._tao_replace (
           Messaging::_tc_ReplyHandler,
+          TAO_ENCAP_BYTE_ORDER,
+          stream.begin (),
           1,
-          _tao_elem,
+          Messaging::ReplyHandler::_duplicate (_tao_elem),
           Messaging::ReplyHandler::_tao_any_destructor
         );
-      return 1;
     }
   }
-  ACE_CATCHANY
+
+  CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, Messaging::ReplyHandler_ptr &_tao_elem)
   {
+    ACE_TRY_NEW_ENV
+    {
+      _tao_elem = Messaging::ReplyHandler::_nil ();
+      CORBA::TypeCode_var type = _tao_any.type ();
+      if (!type->equivalent (Messaging::_tc_ReplyHandler, ACE_TRY_ENV)) // not equal
+        {
+          return 0;
+        }
+      ACE_TRY_CHECK;
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      CORBA::Object_var _tao_obj_var;
+      if (stream >> _tao_obj_var.out ())
+      {
+        _tao_elem = Messaging::ReplyHandler::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+        ACE_TRY_CHECK;
+
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            Messaging::_tc_ReplyHandler,
+            1,
+            _tao_elem,
+            Messaging::ReplyHandler::_tao_any_destructor
+          );
+        return 1;
+      }
+    }
+    ACE_CATCHANY
+    {
+      _tao_elem = Messaging::ReplyHandler::_nil ();
+      return 0;
+    }
+    ACE_ENDTRY;
     _tao_elem = Messaging::ReplyHandler::_nil ();
     return 0;
   }
-  ACE_ENDTRY;
-  _tao_elem = Messaging::ReplyHandler::_nil ();
-  return 0;
-}
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<Messaging::ReplyHandler,Messaging::ReplyHandler_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<Messaging::ReplyHandler,Messaging::ReplyHandler_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+      defined (ACE_HAS_GNU_REPO)
+      template class TAO_Object_Manager<Messaging::ReplyHandler,Messaging::ReplyHandler_var>;
+    #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+    #  pragma instantiate TAO_Object_Manager<Messaging::ReplyHandler,Messaging::ReplyHandler_var>
+  #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
 
 #endif /* TAO_HAS_AMI_CALLBACK == 1 || TAO_HAS_AMI_POLLER == 1 */
 
 #if !defined _TAO_CDR_OP_Messaging_PolicyValue__tao_seq_Octet_CPP_
-#define _TAO_CDR_OP_Messaging_PolicyValue__tao_seq_Octet_CPP_
+  #define _TAO_CDR_OP_Messaging_PolicyValue__tao_seq_Octet_CPP_
 
 CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const Messaging::PolicyValue::_tao_seq_Octet &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
+      TAO_OutputCDR &strm,
+      const Messaging::PolicyValue::_tao_seq_Octet &_tao_sequence
+    )
   {
-    // encode all elements
+    if (strm << _tao_sequence.length ())
+    {
+      // encode all elements
 
 #if defined (TAO_NO_COPY_OCTET_SEQUENCES)
-    {
-      TAO_Unbounded_Sequence<CORBA::Octet> *oseq =
-        ACE_static_cast (TAO_Unbounded_Sequence<CORBA::Octet>*, (Messaging::PolicyValue::_tao_seq_Octet *)&_tao_sequence);
-      if (oseq->mb ())
-        return strm.write_octet_array_mb (oseq->mb ());
-      else
-        return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
-    }
+      {
+        TAO_Unbounded_Sequence<CORBA::Octet> *oseq =
+          ACE_static_cast (TAO_Unbounded_Sequence<CORBA::Octet>*, (Messaging::PolicyValue::_tao_seq_Octet *)&_tao_sequence);
+        if (oseq->mb ())
+          return strm.write_octet_array_mb (oseq->mb ());
+        else
+          return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
+      }
 
 #else /* TAO_NO_COPY_OCTET_SEQUENCES */
-    return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
+      return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
 
 #endif /* TAO_NO_COPY_OCTET_SEQUENCES */
+    }
+    return 0; // error
   }
-  return 0; // error
-}
 
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    Messaging::PolicyValue::_tao_seq_Octet &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
+  CORBA::Boolean operator>> (
+      TAO_InputCDR &strm,
+      Messaging::PolicyValue::_tao_seq_Octet &_tao_sequence
+    )
   {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len)
-      return 1;
-    // retrieve all the elements
+    CORBA::ULong _tao_seq_len;
+    if (strm >> _tao_seq_len)
+    {
+      // set the length of the sequence
+      _tao_sequence.length (_tao_seq_len);
+      // If length is 0 we return true.
+      if (0 >= _tao_seq_len)
+        return 1;
+      // retrieve all the elements
 
 #if defined (TAO_NO_COPY_OCTET_SEQUENCES)
-    if (ACE_BIT_DISABLED (strm.start ()->flags (),ACE_Message_Block::DONT_DELETE))
-    {
-      TAO_Unbounded_Sequence<CORBA::Octet> *oseq =
-        ACE_static_cast(TAO_Unbounded_Sequence<CORBA::Octet>*, &_tao_sequence);
-      oseq->replace (_tao_seq_len, strm.start ());
-      oseq->mb ()->wr_ptr (oseq->mb()->rd_ptr () + _tao_seq_len);
-      strm.skip_bytes (_tao_seq_len);
-      return 1;
-    }
-    else
-      return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_seq_len);
+      if (ACE_BIT_DISABLED (strm.start ()->flags (),ACE_Message_Block::DONT_DELETE))
+      {
+        TAO_Unbounded_Sequence<CORBA::Octet> *oseq =
+          ACE_static_cast(TAO_Unbounded_Sequence<CORBA::Octet>*, &_tao_sequence);
+        oseq->replace (_tao_seq_len, strm.start ());
+        oseq->mb ()->wr_ptr (oseq->mb()->rd_ptr () + _tao_seq_len);
+        strm.skip_bytes (_tao_seq_len);
+        return 1;
+      }
+      else
+        return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_seq_len);
 
 #else /* TAO_NO_COPY_OCTET_SEQUENCES */
-    return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
+      return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
 
 #endif /* TAO_NO_COPY_OCTET_SEQUENCES */
+    }
+    return 0; // error
   }
-  return 0; // error
-}
 
 #endif /* _TAO_CDR_OP_Messaging_PolicyValue__tao_seq_Octet_CPP_ */
 
@@ -2331,77 +2636,4 @@ CORBA::Boolean operator>> (
   return 0; // error
 }
 
-
-#if (TAO_HAS_AMI_CALLBACK == 1) || (TAO_HAS_AMI_POLLER == 1)
-
-#if !defined _TAO_CDR_OP_Messaging_ExceptionHolder__tao_seq_Octet_CPP_
-#define _TAO_CDR_OP_Messaging_ExceptionHolder__tao_seq_Octet_CPP_
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const Messaging::ExceptionHolder::_tao_seq_Octet &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-
-#if defined (TAO_NO_COPY_OCTET_SEQUENCES)
-    {
-      TAO_Unbounded_Sequence<CORBA::Octet> *oseq =
-        ACE_static_cast (TAO_Unbounded_Sequence<CORBA::Octet>*, (Messaging::ExceptionHolder::_tao_seq_Octet *)&_tao_sequence);
-      if (oseq->mb ())
-        return strm.write_octet_array_mb (oseq->mb ());
-      else
-        return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
-    }
-
-#else /* TAO_NO_COPY_OCTET_SEQUENCES */
-    return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
-
-#endif /* TAO_NO_COPY_OCTET_SEQUENCES */
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    Messaging::ExceptionHolder::_tao_seq_Octet &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len)
-      return 1;
-    // retrieve all the elements
-
-#if defined (TAO_NO_COPY_OCTET_SEQUENCES)
-    if (ACE_BIT_DISABLED (strm.start ()->flags (),ACE_Message_Block::DONT_DELETE))
-    {
-      TAO_Unbounded_Sequence<CORBA::Octet> *oseq =
-        ACE_static_cast(TAO_Unbounded_Sequence<CORBA::Octet>*, &_tao_sequence);
-      oseq->replace (_tao_seq_len, strm.start ());
-      oseq->mb ()->wr_ptr (oseq->mb()->rd_ptr () + _tao_seq_len);
-      strm.skip_bytes (_tao_seq_len);
-      return 1;
-    }
-    else
-      return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_seq_len);
-
-#else /* TAO_NO_COPY_OCTET_SEQUENCES */
-    return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
-
-#endif /* TAO_NO_COPY_OCTET_SEQUENCES */
-  }
-  return 0; // error
-}
-
-#endif /* _TAO_CDR_OP_Messaging_ExceptionHolder__tao_seq_Octet_CPP_ */
-
-#endif /* TAO_HAS_AMI_CALLBACK == 1 || TAO_HAS_AMI_POLLER == 1 */
-
 #endif /* TAO_HAS_CORBA_MESSAGING == 1 */
diff --git a/TAO/tao/MessagingC.h b/TAO/tao/MessagingC.h
index 4d9fd57131a..7657bd0b6a0 100644
--- a/TAO/tao/MessagingC.h
+++ b/TAO/tao/MessagingC.h
@@ -7,10 +7,10 @@
 // Information about TAO is available at:
 //                 http://www.cs.wustl.edu/~schmidt/TAO.html
 
-#ifndef _TAO_IDL_MESSAGINGC_H_
-#define _TAO_IDL_MESSAGINGC_H_
-#include "ace/pre.h"
+#ifndef _TAO_IDL_ORIG_MESSAGINGC_H_
+#define _TAO_IDL_ORIG_MESSAGINGC_H_
 
+#include "ace/pre.h"
 #include "tao/orbconf.h"
 
 #if (TAO_HAS_CORBA_MESSAGING == 1)
@@ -193,7 +193,7 @@ TAO_NAMESPACE  Messaging
 #if !defined (_MESSAGING_REBINDPOLICY_CH_)
 #define _MESSAGING_REBINDPOLICY_CH_
 
-  class TAO_Export RebindPolicy: public virtual CORBA::Policy
+class TAO_Export RebindPolicy: public virtual CORBA::Policy
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -316,7 +316,7 @@ TAO_NAMESPACE  Messaging
 #if !defined (_MESSAGING_SYNCSCOPEPOLICY_CH_)
 #define _MESSAGING_SYNCSCOPEPOLICY_CH_
 
-  class TAO_Export SyncScopePolicy: public virtual CORBA::Policy
+class TAO_Export SyncScopePolicy: public virtual CORBA::Policy
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -489,7 +489,7 @@ TAO_NAMESPACE  Messaging
 #if !defined (_MESSAGING_REQUESTPRIORITYPOLICY_CH_)
 #define _MESSAGING_REQUESTPRIORITYPOLICY_CH_
 
-  class TAO_Export RequestPriorityPolicy: public virtual CORBA::Policy
+class TAO_Export RequestPriorityPolicy: public virtual CORBA::Policy
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -608,7 +608,7 @@ TAO_NAMESPACE  Messaging
 #if !defined (_MESSAGING_REPLYPRIORITYPOLICY_CH_)
 #define _MESSAGING_REPLYPRIORITYPOLICY_CH_
 
-  class TAO_Export ReplyPriorityPolicy: public virtual CORBA::Policy
+class TAO_Export ReplyPriorityPolicy: public virtual CORBA::Policy
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -731,7 +731,7 @@ TAO_NAMESPACE  Messaging
 #if !defined (_MESSAGING_REQUESTSTARTTIMEPOLICY_CH_)
 #define _MESSAGING_REQUESTSTARTTIMEPOLICY_CH_
 
-  class TAO_Export RequestStartTimePolicy: public virtual CORBA::Policy
+class TAO_Export RequestStartTimePolicy: public virtual CORBA::Policy
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -854,7 +854,7 @@ TAO_NAMESPACE  Messaging
 #if !defined (_MESSAGING_REQUESTENDTIMEPOLICY_CH_)
 #define _MESSAGING_REQUESTENDTIMEPOLICY_CH_
 
-  class TAO_Export RequestEndTimePolicy: public virtual CORBA::Policy
+class TAO_Export RequestEndTimePolicy: public virtual CORBA::Policy
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -977,7 +977,7 @@ TAO_NAMESPACE  Messaging
 #if !defined (_MESSAGING_REPLYSTARTTIMEPOLICY_CH_)
 #define _MESSAGING_REPLYSTARTTIMEPOLICY_CH_
 
-  class TAO_Export ReplyStartTimePolicy: public virtual CORBA::Policy
+class TAO_Export ReplyStartTimePolicy: public virtual CORBA::Policy
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -1100,7 +1100,7 @@ TAO_NAMESPACE  Messaging
 #if !defined (_MESSAGING_REPLYENDTIMEPOLICY_CH_)
 #define _MESSAGING_REPLYENDTIMEPOLICY_CH_
 
-  class TAO_Export ReplyEndTimePolicy: public virtual CORBA::Policy
+class TAO_Export ReplyEndTimePolicy: public virtual CORBA::Policy
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -1223,7 +1223,7 @@ TAO_NAMESPACE  Messaging
 #if !defined (_MESSAGING_RELATIVEREQUESTTIMEOUTPOLICY_CH_)
 #define _MESSAGING_RELATIVEREQUESTTIMEOUTPOLICY_CH_
 
-  class TAO_Export RelativeRequestTimeoutPolicy: public virtual CORBA::Policy
+class TAO_Export RelativeRequestTimeoutPolicy: public virtual CORBA::Policy
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -1346,7 +1346,7 @@ TAO_NAMESPACE  Messaging
 #if !defined (_MESSAGING_RELATIVEROUNDTRIPTIMEOUTPOLICY_CH_)
 #define _MESSAGING_RELATIVEROUNDTRIPTIMEOUTPOLICY_CH_
 
-  class TAO_Export RelativeRoundtripTimeoutPolicy: public virtual CORBA::Policy
+class TAO_Export RelativeRoundtripTimeoutPolicy: public virtual CORBA::Policy
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -1519,7 +1519,7 @@ TAO_NAMESPACE  Messaging
 #if !defined (_MESSAGING_ROUTINGPOLICY_CH_)
 #define _MESSAGING_ROUTINGPOLICY_CH_
 
-  class TAO_Export RoutingPolicy: public virtual CORBA::Policy
+class TAO_Export RoutingPolicy: public virtual CORBA::Policy
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -1642,7 +1642,7 @@ TAO_NAMESPACE  Messaging
 #if !defined (_MESSAGING_MAXHOPSPOLICY_CH_)
 #define _MESSAGING_MAXHOPSPOLICY_CH_
 
-  class TAO_Export MaxHopsPolicy: public virtual CORBA::Policy
+class TAO_Export MaxHopsPolicy: public virtual CORBA::Policy
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -1765,7 +1765,7 @@ TAO_NAMESPACE  Messaging
 #if !defined (_MESSAGING_QUEUEORDERPOLICY_CH_)
 #define _MESSAGING_QUEUEORDERPOLICY_CH_
 
-  class TAO_Export QueueOrderPolicy: public virtual CORBA::Policy
+class TAO_Export QueueOrderPolicy: public virtual CORBA::Policy
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -2156,7 +2156,7 @@ TAO_NAMESPACE  Messaging
 
 #if (TAO_HAS_AMI_CALLBACK == 1) || (TAO_HAS_AMI_POLLER == 1)
 
-  // valuetype class
+// valuetype class
   class ExceptionHolder;
   typedef ExceptionHolder *ExceptionHolder_ptr;
 
@@ -2404,6 +2404,7 @@ TAO_NAMESPACE  Messaging
 
 #endif /* end #if !defined */
 
+
 #if !defined (_MESSAGING_REPLYHANDLER___PTR_CH_)
 #define _MESSAGING_REPLYHANDLER___PTR_CH_
 
@@ -2472,7 +2473,7 @@ TAO_NAMESPACE  Messaging
 #if !defined (_MESSAGING_REPLYHANDLER_CH_)
 #define _MESSAGING_REPLYHANDLER_CH_
 
-  class TAO_Export ReplyHandler : public virtual CORBA_Object
+class TAO_Export ReplyHandler : public virtual CORBA_Object
   {
   public:
   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -2588,157 +2589,45 @@ class TAO_Export TAO_Messaging_ReplyHandler_Proxy_Factory_Adapter
 
 #endif /* TAO_HAS_SMART_PROXIES */
 
+
 #endif /* end #if !defined */
 
   TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ReplyHandler;
 
 #endif /* TAO_HAS_AMI_CALLBACK == 1 || TAO_HAS_AMI_POLLER == 1 */
 
-#if (TAO_HAS_AMI_POLLER == 1)
-
-// valuetype class
-  class Poller;
-  typedef Poller *Poller_ptr;
-
-#if !defined (_MESSAGING_POLLER___VAR_CH_)
-#define _MESSAGING_POLLER___VAR_CH_
-
-  class TAO_Export Poller_var
-  {
-  public:
-    Poller_var (void); // default constructor
-    Poller_var (Poller*);
-    Poller_var (const Poller*); // (TAO extension)
-    Poller_var (const Poller_var &); // copy constructor
-    ~Poller_var (void); // destructor
-
-    Poller_var &operator= (Poller*);
-    Poller_var &operator= (const Poller_var &);
-    Poller* operator-> (void) const;
-
-    operator const Poller* () const;
-    operator Poller* ();
-    // in, inout, out, _retn
-    Poller* in (void) const;
-    Poller* &inout (void);
-    Poller* &out (void);
-    Poller* _retn (void);
-    Poller* ptr (void) const;
-
-  private:
-    Poller* ptr_;
-  };
-
-
-#endif /* end #if !defined */
-
-
-#if !defined (_MESSAGING_POLLER___OUT_CH_)
-#define _MESSAGING_POLLER___OUT_CH_
-
-  class TAO_Export Poller_out
-  {
-  public:
-    Poller_out (Poller* &);
-    Poller_out (Poller_var &);
-    Poller_out (const Poller_out &);
-    Poller_out &operator= (const Poller_out &);
-    Poller_out &operator= (const Poller_var &);
-    Poller_out &operator= (Poller*);
-    operator Poller* &();
-    Poller* &ptr (void);
-    Poller* operator-> (void);
-
-  private:
-    Poller* &ptr_;
-  };
-
-
-#endif /* end #if !defined */
-
-
-#if !defined (_MESSAGING_POLLER___INIT_CH_)
-#define _MESSAGING_POLLER___INIT_CH_
-
-  class TAO_Export Poller_init : public CORBA_ValueFactoryBase
-  {
-  public:
-    virtual ~Poller_init ();
-    virtual const char* tao_repository_id ();
-
-    // create () goes here
-
-  };
-
-#endif /* end #if !defined */
-
-
-#if !defined (_MESSAGING_POLLER_CH_)
-#define _MESSAGING_POLLER_CH_
-
-  class TAO_Export Poller : public virtual CORBA_ValueBase
-  {
-  public:
-  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-    typedef Poller* _ptr_type;
-    typedef Poller_var _var_type;
-  #endif /* ! __GNUC__ || g++ >= 2.8 */
-
-    static Poller* _downcast (CORBA::ValueBase* );
-    // The address of static _downcast is implicit used as type id
-
-    // (TAO extensions or internals)
-    static CORBA::Boolean _tao_unmarshal (TAO_InputCDR &, Poller *&);
-    virtual const char* _tao_obv_repository_id () const;
-    static const char* _tao_obv_static_repository_id ();
-  public:
-    virtual CORBA::Object_ptr operation_target (    CORBA::Environment &ACE_TRY_ENV =
-      TAO_default_environment ()) = 0;
-    virtual char * operation_name (    CORBA::Environment &ACE_TRY_ENV =
-      TAO_default_environment ()) = 0;
-    virtual Messaging::ReplyHandler_ptr associated_handler (    CORBA::Environment &ACE_TRY_ENV =
-      TAO_default_environment ()) = 0;
-    virtual void associated_handler (Messaging::ReplyHandler_ptr,
-    CORBA::Environment &ACE_TRY_ENV =
-      TAO_default_environment ()) = 0;
-    virtual CORBA::Boolean is_from_poller (    CORBA::Environment &ACE_TRY_ENV =
-      TAO_default_environment ()) = 0;
-    virtual void target (CORBA::Object_ptr) = 0;    // set
-    virtual CORBA::Object_ptr target (void) const = 0;     // get method
-
-    virtual void op_name (char *) = 0;     // set
-    virtual void op_name (const char *) = 0;     // set
-    virtual void op_name (const CORBA::String_var&) = 0;     // set
-    virtual const char *op_name (void) const = 0;     // get method
-
+}
+TAO_NAMESPACE_CLOSE // module Messaging
 
-  protected:
-    Poller ();           // default constructor
-    virtual ~Poller ();
+// Typedef for the Reply Handler Skeleton.
+// This is handcrafted not generated by the IDL compiler.
 
-    // TAO internals
-    virtual void *_tao_obv_narrow (ptr_arith_t);
-    virtual CORBA::Boolean _tao_marshal_v (TAO_OutputCDR &);
-    virtual CORBA::Boolean _tao_unmarshal_v (TAO_InputCDR &);
+class TAO_InputCDR;
 
-  private:
-    Poller (const Poller &);
-    void operator= (const Poller &);
+enum TAO_AMI_Reply_Status
+{
+  TAO_AMI_REPLY_OK,
+  // Reply is normal.
 
-  protected:
-    virtual CORBA::Boolean _tao_marshal__Messaging_Poller (TAO_OutputCDR &) = 0;
-    virtual CORBA::Boolean _tao_unmarshal__Messaging_Poller (TAO_InputCDR &) = 0;
+  TAO_AMI_REPLY_NOT_OK,
+  // Reply is not normal and no exceptions
 
-  };
+  TAO_AMI_REPLY_USER_EXCEPTION,
+  // An user exception was raised.
 
-#endif /* end #if !defined */
+  TAO_AMI_REPLY_SYSTEM_EXCEPTION
+  // An system exception was raised.
+};
 
-#endif /* TAO_HAS_AMI_POLLER == 1 */
 
-}
-TAO_NAMESPACE_CLOSE // module Messaging
+#if (TAO_HAS_AMI_CALLBACK == 1)
 
-#if (TAO_HAS_AMI_CALLBACK == 1) || (TAO_HAS_AMI_POLLER == 1)
+typedef void (*TAO_Reply_Handler_Skeleton)(
+    TAO_InputCDR &,
+    Messaging::ReplyHandler *,
+    CORBA::ULong reply_status,
+    CORBA::Environment &
+    );
 
 TAO_NAMESPACE  OBV_Messaging
 {
@@ -2747,7 +2636,7 @@ TAO_NAMESPACE  OBV_Messaging
 #define _MESSAGING_EXCEPTIONHOLDER___OBV_CH_
 
   // OBV_ class
-  class ExceptionHolder : public virtual Messaging::ExceptionHolder
+  class TAO_Export ExceptionHolder : public virtual Messaging::ExceptionHolder
   {
   public:
     virtual void is_system_exception (CORBA::Boolean);    // set
@@ -2780,72 +2669,9 @@ TAO_NAMESPACE  OBV_Messaging
 
 #endif /* end #if !defined */
 
-
-#if !defined (_MESSAGING_POLLER___OBV_CH_)
-#define _MESSAGING_POLLER___OBV_CH_
-
-  // OBV_ class
-  class Poller : public virtual Messaging::Poller
-  {
-  public:
-    virtual void target (CORBA::Object_ptr);    // set
-    virtual CORBA::Object_ptr target (void) const;     // get method
-
-    virtual void op_name (char *);     // set
-    virtual void op_name (const char *);     // set
-    virtual void op_name (const CORBA::String_var&);     // set
-    virtual const char *op_name (void) const;     // get method
-
-
-  protected:
-    virtual CORBA::Boolean _tao_marshal__Messaging_Poller (TAO_OutputCDR &);
-    virtual CORBA::Boolean _tao_unmarshal__Messaging_Poller (TAO_InputCDR &);
-    CORBA::Boolean _tao_marshal_state (TAO_OutputCDR &);
-    CORBA::Boolean _tao_unmarshal_state (TAO_InputCDR &);
-
-
-  private:
-        CORBA::Object_var _pd_target;
-    TAO_String_Manager _pd_op_name;
-  };
-
-#endif /* end #if !defined */
-
 }
 TAO_NAMESPACE_CLOSE
 
-#endif /* TAO_HAS_AMI_CALLBACK == 1 || TAO_HAS_AMI_POLLER == 1 */
-
-// Typedef for the Reply Handler Skeleton.
-// This is handcrafted not generated by the IDL compiler.
-
-class TAO_InputCDR;
-
-enum TAO_AMI_Reply_Status
-{
-  TAO_AMI_REPLY_OK,
-  // Reply is normal.
-
-  TAO_AMI_REPLY_NOT_OK,
-  // Reply is not normal and no exceptions
-
-  TAO_AMI_REPLY_USER_EXCEPTION,
-  // An user exception was raised.
-
-  TAO_AMI_REPLY_SYSTEM_EXCEPTION
-  // An system exception was raised.
-};
-
-
-#if (TAO_HAS_AMI_CALLBACK == 1)
-
-typedef void (*TAO_Reply_Handler_Skeleton)(
-    TAO_InputCDR &,
-    Messaging::ReplyHandler *,
-    CORBA::ULong reply_status,
-    CORBA::Environment &
-    );
-
 #endif /* TAO_HAS_AMI_CALLBACK == 1 */
 
 #if (TAO_HAS_PRIORITY_POLICIES == 1)
@@ -2935,23 +2761,8 @@ TAO_Export CORBA::Boolean operator>> (
 
 #if (TAO_HAS_AMI_CALLBACK == 1) || (TAO_HAS_AMI_POLLER == 1)
 
-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::ExceptionHolder &);
-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::ExceptionHolder &);
-
-#if !defined _TAO_CDR_OP_Messaging_ExceptionHolder__tao_seq_Octet_H_
-#define _TAO_CDR_OP_Messaging_ExceptionHolder__tao_seq_Octet_H_
-
-TAO_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const Messaging::ExceptionHolder::_tao_seq_Octet &
-  );
-TAO_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    Messaging::ExceptionHolder::_tao_seq_Octet &
-  );
-
-#endif /* _TAO_CDR_OP_Messaging_ExceptionHolder__tao_seq_Octet_H_ */
-
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::ExceptionHolder *); //
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::ExceptionHolder *&);
 TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::ReplyHandler_ptr );
 TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::ReplyHandler_ptr &);
 
@@ -2970,4 +2781,5 @@ TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::ReplyHandler_pt
 
 #endif /* TAO_HAS_CORBA_MESSAGING */
 
+#include "ace/post.h"
 #endif /* ifndef */
diff --git a/TAO/tao/MessagingC.i b/TAO/tao/MessagingC.i
index 68ecf4100cd..8d1c5fbfc0e 100644
--- a/TAO/tao/MessagingC.i
+++ b/TAO/tao/MessagingC.i
@@ -3820,209 +3820,6 @@ Messaging::ReplyHandler_out::operator-> (void)
 
 #endif /* TAO_HAS_AMI_CALLBACK == 1 || TAO_HAS_AMI_POLLER == 1 */
 
-#if (TAO_HAS_AMI_POLLER == 1)
-
-ACE_INLINE
-Messaging::Poller::Poller () // default constructor
-{}
-
-ACE_INLINE
-Messaging::Poller::~Poller () // destructor
-{}
-
-ACE_INLINE const char*
-Messaging::Poller::_tao_obv_static_repository_id ()
-{
-  return "IDL:omg.org/Messaging/Poller:1.0";
-}
-
-
-#if !defined (_MESSAGING_POLLER___VAR_CI_)
-#define _MESSAGING_POLLER___VAR_CI_
-
-// *************************************************************
-// Inline operations for class Messaging::Poller_var
-// *************************************************************
-
-ACE_INLINE
-Messaging::Poller_var::Poller_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-Messaging::Poller_var::Poller_var (Messaging::Poller* p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-Messaging::Poller_var::Poller_var (const Messaging::Poller* p)
-  : ptr_ (ACE_const_cast(Messaging::Poller*, p))
-{}
-
-ACE_INLINE Messaging::Poller*
-Messaging::Poller_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-Messaging::Poller_var::Poller_var (const Messaging::Poller_var &p) // copy constructor
-{
-  CORBA::add_ref (p.ptr ());
-  this->ptr_ = p.ptr ();
-}
-
-ACE_INLINE
-Messaging::Poller_var::~Poller_var (void) // destructor
-{
-  CORBA::remove_ref (this->ptr_);
-}
-
-ACE_INLINE Messaging::Poller_var &
-Messaging::Poller_var::operator= (Messaging::Poller* p)
-{
-  CORBA::remove_ref (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE Messaging::Poller_var &
-Messaging::Poller_var::operator= (const Messaging::Poller_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::remove_ref (this->ptr_);
-    Poller* tmp = p.ptr ();
-    CORBA::add_ref (tmp);
-    this->ptr_ = tmp;
-  }
-  return *this;
-}
-
-ACE_INLINE
-Messaging::Poller_var::operator const Messaging::Poller* () const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-Messaging::Poller_var::operator Messaging::Poller* () // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE Messaging::Poller*
-Messaging::Poller_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE Messaging::Poller*
-Messaging::Poller_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE Messaging::Poller* &
-Messaging::Poller_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE Messaging::Poller* &
-Messaging::Poller_var::out (void)
-{
-  CORBA::remove_ref (this->ptr_);
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE Messaging::Poller*
-Messaging::Poller_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  Poller* tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-
-#endif /* end #if !defined */
-
-
-#if !defined (_MESSAGING_POLLER___OUT_CI_)
-#define _MESSAGING_POLLER___OUT_CI_
-
-// *************************************************************
-// Inline operations for class Messaging::Poller_out
-// *************************************************************
-
-ACE_INLINE
-Messaging::Poller_out::Poller_out (Messaging::Poller* &p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-Messaging::Poller_out::Poller_out (Messaging::Poller_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::remove_ref (this->ptr_);
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-Messaging::Poller_out::Poller_out (const Messaging::Poller_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (Messaging::Poller_out&,p).ptr_)
-{}
-
-ACE_INLINE Messaging::Poller_out &
-Messaging::Poller_out::operator= (const Messaging::Poller_out &p)
-{
-  this->ptr_ = ACE_const_cast (Messaging::Poller_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE Messaging::Poller_out &
-Messaging::Poller_out::operator= (const Messaging::Poller_var &p)
-{
-  Poller* tmp = p.ptr ();
-  CORBA::add_ref (tmp);
-  this->ptr_ = tmp;
-  return *this;
-}
-
-ACE_INLINE Messaging::Poller_out &
-Messaging::Poller_out::operator= (Messaging::Poller* p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE
-Messaging::Poller_out::operator Messaging::Poller* &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE Messaging::Poller* &
-Messaging::Poller_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE Messaging::Poller*
-Messaging::Poller_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-
-#endif /* end #if !defined */
-
-#endif /* TAO_HAS_AMI_POLLER == 1 */
-
 ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const Messaging::PriorityRange &_tao_aggregate)
 {
   if (
@@ -4219,47 +4016,3 @@ operator>> (
 }
 
 #endif /* TAO_HAS_AMI_CALLBACK == 1 || TAO_HAS_AMI_POLLER == 1 */
-
-#if (TAO_HAS_AMI_POLLER == 1)
-
-ACE_INLINE CORBA::Boolean
-operator<< (TAO_OutputCDR &strm, const Messaging::Poller *_tao_valuetype)
-{
-  return CORBA_ValueBase::_tao_marshal (strm,
-    ACE_const_cast (Messaging::Poller*, _tao_valuetype),
-    (ptr_arith_t) &Messaging::Poller::_downcast);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (TAO_InputCDR &strm, Messaging::Poller *&_tao_valuetype)
-{
-  return Messaging::Poller::_tao_unmarshal (strm, _tao_valuetype);
-}
-
-ACE_INLINE CORBA::Boolean
-OBV_Messaging::Poller::_tao_marshal_state (TAO_OutputCDR &strm)
-{
-  if (
-    (strm << _pd_target.in ()) &&
-    (strm << _pd_op_name.in ())
-  )
-    return 1;
-  else
-    return 0;
-
-}
-
-ACE_INLINE CORBA::Boolean
-OBV_Messaging::Poller::_tao_unmarshal_state (TAO_InputCDR &strm)
-{
-  if (
-    (strm >> _pd_target.out ()) &&
-    (strm >> _pd_op_name.out ())
-  )
-    return 1;
-  else
-    return 0;
-
-}
-
-#endif /* TAO_HAS_AMI_POLLER == 1 */
diff --git a/TAO/tao/MessagingS.cpp b/TAO/tao/MessagingS.cpp
index e215b9c90f2..9009588a760 100644
--- a/TAO/tao/MessagingS.cpp
+++ b/TAO/tao/MessagingS.cpp
@@ -11,16 +11,15 @@
 
 #if (TAO_HAS_CORBA_MESSAGING == 1)
 
-#include "tao/MessagingS.h"
-#include "tao/POA_CORBA.h"
-#include "tao/Operation_Table.h"
-#include "tao/Server_Request.h"
-#include "tao/Stub.h"
-#include "tao/ORB_Core.h"
-#include "tao/Object_Adapter.h"
+#include "MessagingS.h"
+#include "Operation_Table.h"
+#include "Server_Request.h"
+#include "Stub.h"
+#include "ORB_Core.h"
+#include "Object_Adapter.h"
 
 #if !defined (__ACE_INLINE__)
-#include "tao/MessagingS.i"
+#include "MessagingS.i"
 #endif /* !defined INLINE */
 
 ACE_RCSID(tao, MessagingS, "$Id$")
@@ -34,9 +33,9 @@ private:
 public:
  const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
 };
-/* starting time is 14:51:17 */
+/* starting time is 12:21:06 */
 /* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: /export/kelvar/coryan/head/ACE_wrappers/build/Linux/bin/gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_Messaging_ReplyHandler_Perfect_Hash_OpTable -N lookup  */
+/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_Messaging_ReplyHandler_Perfect_Hash_OpTable -N lookup  */
 unsigned int
 TAO_Messaging_ReplyHandler_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
 {
@@ -124,7 +123,7 @@ TAO_Messaging_ReplyHandler_Perfect_Hash_OpTable::lookup (const char *str, unsign
     }
   return 0;
 }
-/* ending time is 14:51:17 */
+/* ending time is 12:21:06 */
 static TAO_Messaging_ReplyHandler_Perfect_Hash_OpTable tao_Messaging_ReplyHandler_optable;
 
 Messaging::ReplyHandler_ptr _TAO_collocation_POA_Messaging_ReplyHandler_Stub_Factory (
diff --git a/TAO/tao/MessagingS.h b/TAO/tao/MessagingS.h
index 0bb048f9afc..cafd22c1bca 100644
--- a/TAO/tao/MessagingS.h
+++ b/TAO/tao/MessagingS.h
@@ -7,17 +7,20 @@
 // Information about TAO is available at:
 //                 http://www.cs.wustl.edu/~schmidt/TAO.html
 
-#ifndef _TAO_IDL_TMP_MESSAGINGS_H_
-#define _TAO_IDL_TMP_MESSAGINGS_H_
+#ifndef _TAO_IDL_ORIG_MESSAGINGS_H_
+#define _TAO_IDL_ORIG_MESSAGINGS_H_
+
 #include "ace/pre.h"
 
-#include "tao/orbconf.h"
+#include "orbconf.h"
 
 #if (TAO_HAS_CORBA_MESSAGING == 1)
 
-#include "tao/TimeBaseS.h"
-#include "tao/POA_CORBA.h"
-#include "tao/MessagingC.h"
+#include "TimeBaseS.h"
+#include "MessagingC.h"
+#include "POAC.h"
+#include "Servant_Base.h"
+
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
diff --git a/TAO/tao/MessagingS.i b/TAO/tao/MessagingS.i
index 9386d854853..d41d475fa1a 100644
--- a/TAO/tao/MessagingS.i
+++ b/TAO/tao/MessagingS.i
@@ -6,3 +6,4 @@
 //
 // Information about TAO is available at:
 //                 http://www.cs.wustl.edu/~schmidt/TAO.html
+
diff --git a/TAO/tao/MessagingS_T.cpp b/TAO/tao/MessagingS_T.cpp
index bcdb31c08ef..44b2c4f35cb 100644
--- a/TAO/tao/MessagingS_T.cpp
+++ b/TAO/tao/MessagingS_T.cpp
@@ -7,8 +7,8 @@
 // Information about TAO is available at:
 //                 http://www.cs.wustl.edu/~schmidt/TAO.html
 
-#ifndef _TAO_IDL_TMP_MESSAGINGS_T_CPP_
-#define _TAO_IDL_TMP_MESSAGINGS_T_CPP_
+#ifndef _TAO_IDL_ORIG_MESSAGINGS_T_CPP_
+#define _TAO_IDL_ORIG_MESSAGINGS_T_CPP_
 
 #include "MessagingS_T.h"
 
diff --git a/TAO/tao/MessagingS_T.h b/TAO/tao/MessagingS_T.h
index 73d05f29831..11c18ac244b 100644
--- a/TAO/tao/MessagingS_T.h
+++ b/TAO/tao/MessagingS_T.h
@@ -7,9 +7,10 @@
 // Information about TAO is available at:
 //                 http://www.cs.wustl.edu/~schmidt/TAO.html
 
-#ifndef _TAO_IDL_TMP_MESSAGINGS_T_H_
-#define _TAO_IDL_TMP_MESSAGINGS_T_H_
+#ifndef _TAO_IDL_ORIG_MESSAGINGS_T_H_
+#define _TAO_IDL_ORIG_MESSAGINGS_T_H_
 
+#include "ace/pre.h"
 #if defined(_MSC_VER)
 #if (_MSC_VER >= 1200)
 #pragma warning(push)
@@ -36,4 +37,5 @@
 #pragma warning(pop)
 #endif /* _MSC_VER */
 
+#include "ace/post.h"
 #endif /* ifndef */
diff --git a/TAO/tao/MessagingS_T.i b/TAO/tao/MessagingS_T.i
index 46cda2a7a51..e14ce71aea7 100644
--- a/TAO/tao/MessagingS_T.i
+++ b/TAO/tao/MessagingS_T.i
@@ -8,7 +8,7 @@
 //                 http://www.cs.wustl.edu/~schmidt/TAO.html
 
 
-#if (TAO_HAS_AMI_POLLER == 1)
+#if (TAO_HAS_AMI_CALLBACK == 1)
 #if defined (ACE_HAS_USING_KEYWORD)
 template <class T> ACE_INLINE
 POA_Messaging::ReplyHandler_tie<T>::ReplyHandler_tie (T &t)
@@ -88,4 +88,4 @@ POA_Messaging::ReplyHandler_tie<T>::_default_POA (CORBA::Environment &ACE_TRY_EN
 }
 
 #endif /* ACE_HAS_USING_KEYWORD */
-#endif /* TAO_HAS_AMI_POLLER == 1 */
+#endif /* TAO_HAS_AMI_CALLBACK == 1 */
diff --git a/TAO/tao/corba.h b/TAO/tao/corba.h
index f9fad745621..bd87b3430df 100644
--- a/TAO/tao/corba.h
+++ b/TAO/tao/corba.h
@@ -94,6 +94,7 @@
 #include "tao/BoundsC.h"
 #include "tao/TAOC.h"
 #include "tao/MessagingC.h"
+#include "tao/MessagingS.h"
 
 #if !defined (ACE_NESTED_CLASS)
 #if defined (ACE_WIN32)
diff --git a/TAO/tests/AMI/run_test.pl b/TAO/tests/AMI/run_test.pl
index 4b069ef43bb..8a09172996d 100755
--- a/TAO/tests/AMI/run_test.pl
+++ b/TAO/tests/AMI/run_test.pl
@@ -10,7 +10,7 @@ require ACEutils;
 use Cwd;
 
 $cwd = getcwd();
-$client_conf="$cwd$DIR_SEPARATOR" . "muxed.conf";
+$client_conf="$DIR_SEPARATOR" . "muxed.conf";
 $client_process="simple_client";
 $debug_level='5';
 $threads='2';
@@ -27,8 +27,8 @@ foreach $i (@ARGV) {
   }
 }
 
-$iorfile = "$cwd$DIR_SEPARATOR" . "server.ior";
-$SV = Process::Create ($EXEPREFIX."server$EXE_EXT ",
+$iorfile = "server.ior";
+$SV = Process::Create ($EXEPREFIX."server$EXE_EXT",
 			  " -ORBdebuglevel $debug_level"
 			  . "-d -o $iorfile");
 
@@ -38,7 +38,7 @@ if (ACE::waitforfile_timed ($iorfile, 5) == -1) {
   exit 1;
 }
 
-$CL = Process::Create ($EXEPREFIX."$client_process$EXE_EXT ",
+$CL = Process::Create ($EXEPREFIX."$client_process$EXE_EXT",
 			  " -ORBsvcconf $client_conf "
 			  . "-ORBdebuglevel $debug_level"
 			  . " -k file://$iorfile "