ChangeLogTag: Wed Nov 15 21:35:17 2000 Balachandran Natarajan <bala@cs.wustl.edu>

29 files changed, 3087 insertions, 2927 deletions

diff --git a/TAO/tao/Asynch_Invocation.cpp b/TAO/tao/Asynch_Invocation.cpp
index 45fd09af7bc..f857f75368e 100644
--- a/TAO/tao/Asynch_Invocation.cpp
+++ b/TAO/tao/Asynch_Invocation.cpp
@@ -5,9 +5,9 @@
 
 ACE_RCSID(tao, Asynch_Invocation, "$Id$")
 
-#if (TAO_HAS_AMI_CALLBACK == 1) \
-     || (TAO_HAS_AMI_POLLER == 1) \
-     || (TAO_HAS_MINIMUM_CORBA == 0)
+#if (TAO_HAS_AMI_CALLBACK == 1)	\
+     ||	(TAO_HAS_AMI_POLLER == 1) \
+     ||	(TAO_HAS_MINIMUM_CORBA == 0)
 
 #include "tao/Timeprobe.h"
 #include "tao/Stub.h"
@@ -47,12 +47,12 @@ enum
 
 // Setup Timeprobes
 ACE_TIMEPROBE_EVENT_DESCRIPTIONS (TAO_Asynch_Invocation_Timeprobe_Description,
-                                  TAO_GIOP_ASYNCH_INVOCATION_INVOKE_START);
+				  TAO_GIOP_ASYNCH_INVOCATION_INVOKE_START);
 
-#endif /* ACE_ENABLE_TIMEPROBES */
+#endif /* ACE_ENABLE_TIMEPROBES	*/
 
 TAO_GIOP_Asynch_Invocation::TAO_GIOP_Asynch_Invocation (void)
-  : rd_ (0)
+  : rd_	(0)
 {
 }
 
@@ -62,45 +62,45 @@ TAO_GIOP_Asynch_Invocation::invoke (CORBA::Environment &ACE_TRY_ENV)
 {
   TAO_FUNCTION_PP_TIMEPROBE (TAO_GIOP_ASYNCH_INVOCATION_INVOKE_START);
 
-  return this->invoke_i (ACE_TRY_ENV);
+  return this->invoke_i	(ACE_TRY_ENV);
 }
 
 // **************************************************************************
 
 int
-TAO_GIOP_Twoway_Asynch_Invocation::invoke_i (CORBA::Environment &ACE_TRY_ENV)
+TAO_GIOP_Twoway_Asynch_Invocation::invoke_i (CORBA::Environment	&ACE_TRY_ENV)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
-  // Register a reply dispatcher for this Asynch_Invocation. Use the
+  // Register a	reply dispatcher for this Asynch_Invocation. Use the
   // heap allocated reply dispatcher.
 
   int retval =
     this->transport_->tms ()->bind_dispatcher (this->op_details_.request_id (),
-                                               this->rd_);
-  if (retval == -1)
+					       this->rd_);
+  if (retval ==	-1)
     {
-      // @@ What is the right way to handle this error?
+      // @@ What is the	right way to handle this error?
       this->close_connection ();
-      ACE_THROW_RETURN (CORBA::INTERNAL (TAO_DEFAULT_MINOR_CODE,
-                                         CORBA::COMPLETED_NO),
-                        TAO_INVOKE_EXCEPTION);
+      ACE_THROW_RETURN (CORBA::INTERNAL	(TAO_DEFAULT_MINOR_CODE,
+					 CORBA::COMPLETED_NO),
+			TAO_INVOKE_EXCEPTION);
     }
 
   // Just send the request, without trying to wait for the reply.
   retval = TAO_GIOP_Invocation::invoke (0,
-                                        ACE_TRY_ENV);
+					ACE_TRY_ENV);
   ACE_CHECK_RETURN (retval);
 
-  if (retval != TAO_INVOKE_OK)
+  if (retval !=	TAO_INVOKE_OK)
     return retval;
 
-  // Everything executed ok; lets remember the transport for later.
+  // Everything	executed ok; lets remember the transport for later.
   this->rd_->transport (this->transport_);
 
-  // We do not wait for the reply. Let us return.
+  // We	do not wait for	the reply. Let us return.
   return TAO_INVOKE_OK;
 }
 
-#endif /* TAO_HAS_AMI_CALLBACK == 1 
-          || TAO_HAS_AMI_POLLER == 1 
-          || TAO_HAS_MINIMUM_CORBA == 0 */
+#endif /* TAO_HAS_AMI_CALLBACK == 1
+	  || TAO_HAS_AMI_POLLER	== 1
+	  || TAO_HAS_MINIMUM_CORBA == 0	*/
diff --git a/TAO/tao/Asynch_Invocation.h b/TAO/tao/Asynch_Invocation.h
index 9ea17ced414..4854a38ff29 100644
--- a/TAO/tao/Asynch_Invocation.h
+++ b/TAO/tao/Asynch_Invocation.h
@@ -33,7 +33,7 @@
 #include "tao/MessagingC.h"
 #include "tao/Asynch_Reply_Dispatcher.h"
 
-class TAO_Export TAO_GIOP_Asynch_Invocation 
+class TAO_Export TAO_GIOP_Asynch_Invocation
   : public TAO_GIOP_Invocation
 {
   // = TITLE
@@ -51,6 +51,7 @@ public:
   TAO_GIOP_Asynch_Invocation (TAO_Stub *stub,
                               const char *operation,
                               CORBA::ULong opname_len,
+                              CORBA::Boolean argument_flag,
                               TAO_ORB_Core *orb_core);
   // Constructor.
 
@@ -68,7 +69,7 @@ protected:
   // Reply dispatcher for the current asynchronous invocation.
 };
 
-class TAO_Export TAO_GIOP_Twoway_Asynch_Invocation 
+class TAO_Export TAO_GIOP_Twoway_Asynch_Invocation
   : public TAO_GIOP_Asynch_Invocation
 {
   // = TITLE
@@ -85,6 +86,7 @@ public:
       TAO_Stub *stub,
       const char *operation,
       CORBA::ULong opname_len_,
+      CORBA::Boolean argument_flag,
       TAO_ORB_Core* orb_core,
       const TAO_Reply_Handler_Skeleton &reply_handler_skel,
       Messaging::ReplyHandler_ptr reply_handler_ptr
@@ -102,8 +104,8 @@ protected:
 #  include "tao/Asynch_Invocation.i"
 #endif /* __ACE_INLINE__ */
 
-#endif /* TAO_HAS_AMI_CALLBACK == 1 
-          || TAO_HAS_AMI_POLLER == 1 
+#endif /* TAO_HAS_AMI_CALLBACK == 1
+          || TAO_HAS_AMI_POLLER == 1
           || TAO_HAS_MINIMUM_CORBA == 0 */
 
 #include "ace/post.h"
diff --git a/TAO/tao/Asynch_Invocation.i b/TAO/tao/Asynch_Invocation.i
index 503151f0cf0..bc73206b139 100644
--- a/TAO/tao/Asynch_Invocation.i
+++ b/TAO/tao/Asynch_Invocation.i
@@ -1,4 +1,4 @@
-// This may look like C, but it's really -*- C++ -*-
+// This	may look like C, but it's really -*- C++ -*-
 //
 // $Id$
 //
@@ -8,13 +8,15 @@ TAO_GIOP_Asynch_Invocation::TAO_GIOP_Asynch_Invocation (
     TAO_Stub *stub,
     const char *operation,
     CORBA::ULong opname_len,
+    CORBA::Boolean argument_flag,
     TAO_ORB_Core *orb_core
   )
-  : TAO_GIOP_Invocation (stub,
-                         operation,
-                         opname_len,
-                         orb_core),
-    rd_ (0)
+  : TAO_GIOP_Invocation	(stub,
+			 operation,
+			 opname_len,
+			 argument_flag,
+			 orb_core),
+    rd_	(0)
 {
 }
 
@@ -25,22 +27,23 @@ TAO_GIOP_Twoway_Asynch_Invocation::TAO_GIOP_Twoway_Asynch_Invocation (
     TAO_Stub *stub,
     const char *operation,
     CORBA::ULong opname_len,
+    CORBA::Boolean argument_flag,
     TAO_ORB_Core *orb_core,
     const TAO_Reply_Handler_Skeleton &reply_handler_skel,
-    Messaging::ReplyHandler_ptr reply_handler_ptr
+    Messaging::ReplyHandler_ptr	reply_handler_ptr
   )
   : TAO_GIOP_Asynch_Invocation (stub,
-                                operation,
-                                opname_len,
-                                orb_core)
+				operation,
+				opname_len,
+				argument_flag,
+				orb_core)
 {
   // New reply dispatcher on the heap, because
-  // we will go out of scope and hand over the
+  // we	will go	out of scope and hand over the
   // reply dispatcher to the ORB.
-  // So this->rd_ is 0, because we do not need to
+  // So	this->rd_ is 0,	because	we do not need to
   // hold a pointer to it.
   ACE_NEW (this->rd_,
-           TAO_Asynch_Reply_Dispatcher (reply_handler_skel,
-                                        reply_handler_ptr));
+	   TAO_Asynch_Reply_Dispatcher (reply_handler_skel,
+					reply_handler_ptr));
 }
-
diff --git a/TAO/tao/CORBANAME_Parser.cpp b/TAO/tao/CORBANAME_Parser.cpp
index 19f8f7b975e..32e469f33cf 100644
--- a/TAO/tao/CORBANAME_Parser.cpp
+++ b/TAO/tao/CORBANAME_Parser.cpp
@@ -18,18 +18,18 @@ int
 TAO_CORBANAME_Parser::match_prefix (const char *ior_string) const
 {
   return (ACE_OS::strncmp (ior_string,
-                           corbaname_prefix,
-                           sizeof corbaname_prefix - 1) == 0);
+			   corbaname_prefix,
+			   sizeof corbaname_prefix - 1)	== 0);
 }
 
 CORBA::Object_ptr
 TAO_CORBANAME_Parser::
 parse_string_dynamic_request_helper (CORBA::Object_ptr naming_context,
-                                     ACE_CString &key_string,
-                                     CORBA::Environment &ACE_TRY_ENV)
+				     ACE_CString &key_string,
+				     CORBA::Environment	&ACE_TRY_ENV)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
-  CORBA::Object_ptr _tao_retval = CORBA::Object::_nil ();
+  CORBA::Object_ptr _tao_retval	= CORBA::Object::_nil ();
 
   CORBA::Object_var _tao_safe_retval (_tao_retval);
 
@@ -41,6 +41,7 @@ parse_string_dynamic_request_helper (CORBA::Object_ptr naming_context,
       istub,
       "resolve_str",
       11,
+      1,
       istub->orb_core ()
     );
 
@@ -49,157 +50,157 @@ parse_string_dynamic_request_helper (CORBA::Object_ptr naming_context,
       _tao_call.start (ACE_TRY_ENV);
       ACE_CHECK_RETURN (CORBA::Object::_nil ());
 
-      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+      CORBA::Short _tao_response_flag =	TAO_TWOWAY_RESPONSE_FLAG;
 
       _tao_call.prepare_header (
-          ACE_static_cast (CORBA::Octet, _tao_response_flag),
-          ACE_TRY_ENV
-        );
+	  ACE_static_cast (CORBA::Octet, _tao_response_flag),
+	  ACE_TRY_ENV
+	);
       ACE_CHECK_RETURN (CORBA::Object::_nil ());
 
-      TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+      TAO_OutputCDR &_tao_out =	_tao_call.out_stream ();
       if (!(
-            (_tao_out << key_string.c_str ())
-          ))
-        ACE_THROW_RETURN (
-            CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_NO),
-            CORBA::Object::_nil ()
-          );
+	    (_tao_out << key_string.c_str ())
+	  ))
+	ACE_THROW_RETURN (
+	    CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_NO),
+	    CORBA::Object::_nil	()
+	  );
 
       int _invoke_status = 0;
       ACE_TRY
-        {
-          _invoke_status = _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          ACE_TRY_CHECK (CORBA::Object::_nil ());
-        }
-      ACE_CATCH (CORBA::UNKNOWN, ex)
-        {
-          ACE_UNUSED_ARG (ex);
-
-          ACE_THROW_RETURN (
-              CORBA::BAD_PARAM (TAO_OMG_VMCID | TAO_OMG_MINOR_BAD_PARAM_10,
-                                CORBA::COMPLETED_YES),
-              CORBA::Object::_nil ()
-            );
-        }
+	{
+	  _invoke_status = _tao_call.invoke (0,	0, ACE_TRY_ENV);
+	  ACE_TRY_CHECK	(CORBA::Object::_nil ());
+	}
+      ACE_CATCH	(CORBA::UNKNOWN, ex)
+	{
+	  ACE_UNUSED_ARG (ex);
+
+	  ACE_THROW_RETURN (
+	      CORBA::BAD_PARAM (TAO_OMG_VMCID |	TAO_OMG_MINOR_BAD_PARAM_10,
+				CORBA::COMPLETED_YES),
+	      CORBA::Object::_nil ()
+	    );
+	}
       ACE_ENDTRY;
       ACE_CHECK_RETURN (CORBA::Object::_nil ());
 
       if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
+	{
+	  _tao_call.restart_flag (1);
+	  continue;
+	}
       if (_invoke_status != TAO_INVOKE_OK)
-        {
-          // @@ Is there any way we can reach this point?  Any
-          //    USER_EXCEPTION response will be caught by the UNKNOWN
-          //    catch block above.  Any SYSTEM_EXCEPTION response will
-          //    be simply raised, and any RESTART is handled
-          //    already...  leave this here "just in case".
-          ACE_THROW_RETURN (
-              CORBA::BAD_PARAM (TAO_OMG_VMCID | TAO_OMG_MINOR_BAD_PARAM_10,
-                                CORBA::COMPLETED_YES),
-              CORBA::Object::_nil ()
-            );
-        }
+	{
+	  // @@	Is there any way we can	reach this point?  Any
+	  //	USER_EXCEPTION response	will be	caught by the UNKNOWN
+	  //	catch block above.  Any	SYSTEM_EXCEPTION response will
+	  //	be simply raised, and any RESTART is handled
+	  //	already...  leave this here "just in case".
+	  ACE_THROW_RETURN (
+	      CORBA::BAD_PARAM (TAO_OMG_VMCID |	TAO_OMG_MINOR_BAD_PARAM_10,
+				CORBA::COMPLETED_YES),
+	      CORBA::Object::_nil ()
+	    );
+	}
       TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
       if (!(
-            (_tao_in >> _tao_safe_retval.inout ())
-          ))
-        {
-          ACE_THROW_RETURN (
-              CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-              CORBA::Object::_nil ()
-            );
-        }
+	    (_tao_in >>	_tao_safe_retval.inout ())
+	  ))
+	{
+	  ACE_THROW_RETURN (
+	      CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+	      CORBA::Object::_nil ()
+	    );
+	}
       break;
     }
 
-  return _tao_safe_retval._retn ();
+  return _tao_safe_retval._retn	();
 }
 
 CORBA::Object_ptr
 TAO_CORBANAME_Parser::parse_string (const char *ior,
-                                    CORBA::ORB_ptr orb,
-                                    CORBA::Environment &ACE_TRY_ENV)
+				    CORBA::ORB_ptr orb,
+				    CORBA::Environment &ACE_TRY_ENV)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
 
   // Skip the prefix, we know it is there because this method in only
   // called if <match_prefix> returns 1.
-  const char *corbaname =
-    ior + sizeof corbaname_prefix - 1;
+  const	char *corbaname	=
+    ior	+ sizeof corbaname_prefix - 1;
 
-  CORBA::Object_ptr obj = CORBA::Object::_nil ();
+  CORBA::Object_ptr obj	= CORBA::Object::_nil ();
 
   ACE_TRY
     {
       char rir_prot [] = "rir:";
 
-      // The position of the seperator between the obj_addr and key
+      // The position of the seperator between the obj_addr and	key
       // string
       CORBA::ULong pos_seperator = 0;
 
-      ACE_CString corbaname_str (corbaname, 0, 1);
+      ACE_CString corbaname_str	(corbaname, 0, 1);
 
       pos_seperator = corbaname_str.find ("#", 0);
 
       // Get the Key String
       ACE_CString key_string =
-        corbaname_str.substring (pos_seperator + 1,
-                                 -1);
+	corbaname_str.substring	(pos_seperator + 1,
+				 -1);
 
-      // Make it in a form understandable by <corbaloc> scheme
-      ACE_CString corbaloc_addr ("corbaloc:", 0, 1);
+      // Make it in a form understandable by <corbaloc>	scheme
+      ACE_CString corbaloc_addr	("corbaloc:", 0, 1);
 
       if (ACE_OS::strncmp (corbaname,
-                           rir_prot,
-                           sizeof (rir_prot)) != 0)
-        {
-          // Implies that <iiop:> protocol is to be used.
-          // So .. we need to get the host address where an object of
-          // type NamingContext can be found.
-          // Get the obj_addr
-          ACE_CString obj_addr = corbaname_str.substring (0,
-                                                          pos_seperator);
+			   rir_prot,
+			   sizeof (rir_prot)) != 0)
+	{
+	  // Implies that <iiop:> protocol is to be used.
+	  // So	.. we need to get the host address where an object of
+	  // type NamingContext	can be found.
+	  // Get the obj_addr
+	  ACE_CString obj_addr = corbaname_str.substring (0,
+							  pos_seperator);
 
-          corbaloc_addr += obj_addr;
+	  corbaloc_addr	+= obj_addr;
 
-        }
+	}
 
-      ACE_CString name_service ("/NameService", 0, 1);
+      ACE_CString name_service ("/NameService",	0, 1);
       corbaloc_addr += name_service;
 
-      // Obtain a reference to the naming context
-      CORBA::Object_var name_context =
-        orb->string_to_object (corbaloc_addr.c_str (),
-                               ACE_TRY_ENV);
+      // Obtain	a reference to the naming context
+      CORBA::Object_var	name_context =
+	orb->string_to_object (corbaloc_addr.c_str (),
+			       ACE_TRY_ENV);
       ACE_TRY_CHECK;
 
       // Check if the Object reference is nil.
-      if (CORBA::is_nil (name_context.in ()))
-        ACE_ERROR_RETURN ((LM_ERROR,
-                           "Cannot resolve Naming Service: CORBANAME_Parser\n"),
-                          0);
+      if (CORBA::is_nil	(name_context.in ()))
+	ACE_ERROR_RETURN ((LM_ERROR,
+			   "Cannot resolve Naming Service: CORBANAME_Parser\n"),
+			  0);
 
       CORBA::Boolean is_a =
-        name_context->_is_a ("IDL:omg.org/CosNaming/NamingContextExt:1.0",
-                             ACE_TRY_ENV);
+	name_context->_is_a ("IDL:omg.org/CosNaming/NamingContextExt:1.0",
+			     ACE_TRY_ENV);
       ACE_TRY_CHECK;
 
       if (!is_a)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "Cannot narrow Naming Service: "
-                             "CORBANAME_Parser\n"),
-                            0);
-        }
-
-      // Make a dynamic request for resolve_str in this naming context
+	{
+	  ACE_ERROR_RETURN ((LM_ERROR,
+			     "Cannot narrow Naming Service: "
+			     "CORBANAME_Parser\n"),
+			    0);
+	}
+
+      // Make a	dynamic	request	for resolve_str	in this	naming context
       obj = this->parse_string_dynamic_request_helper (name_context.in (),
-                                                       key_string,
-                                                       ACE_TRY_ENV);
+						       key_string,
+						       ACE_TRY_ENV);
       ACE_TRY_CHECK;
     }
   ACE_CATCH (CORBA::SystemException, ex)
@@ -207,18 +208,18 @@ TAO_CORBANAME_Parser::parse_string (const char *ior,
       ACE_PRINT_EXCEPTION (ex, "CORBANAME_Parser");
     }
   ACE_ENDTRY;
-  ACE_CHECK_RETURN (CORBA::Object::_nil ());
+  ACE_CHECK_RETURN (CORBA::Object::_nil	());
 
   return obj;
 }
 
 ACE_STATIC_SVC_DEFINE (TAO_CORBANAME_Parser,
-                       ACE_TEXT ("CORBANAME_Parser"),
-                       ACE_SVC_OBJ_T,
-                       &ACE_SVC_NAME (TAO_CORBANAME_Parser),
-                       ACE_Service_Type::DELETE_THIS |
-                                  ACE_Service_Type::DELETE_OBJ,
-                       0)
+		       ACE_TEXT	("CORBANAME_Parser"),
+		       ACE_SVC_OBJ_T,
+		       &ACE_SVC_NAME (TAO_CORBANAME_Parser),
+		       ACE_Service_Type::DELETE_THIS |
+				  ACE_Service_Type::DELETE_OBJ,
+		       0)
 
 ACE_FACTORY_DEFINE (TAO, TAO_CORBANAME_Parser)
 
diff --git a/TAO/tao/DomainC.cpp b/TAO/tao/DomainC.cpp
index 22b19765b15..e7bf877c2a5 100644
--- a/TAO/tao/DomainC.cpp
+++ b/TAO/tao/DomainC.cpp
@@ -1,11 +1,11 @@
 /* -*- 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
-// Distributed Object Computing at Washington University, St. Louis.
+// ******  Code	generated by the The ACE ORB (TAO) IDL Compiler	*******
+// TAO and the TAO IDL Compiler	have been developed by the Center for
+// Distributed Object Computing	at Washington University, St. Louis.
 //
 // Information about TAO is available at:
-//                 http://www.cs.wustl.edu/~schmidt/TAO.html
+//		   http://www.cs.wustl.edu/~schmidt/TAO.html
 
 #include "DomainC.h"
 #include "Stub.h"
@@ -34,63 +34,63 @@ void CORBA_DomainManager::_tao_any_destructor (void *x)
   CORBA::release (tmp);
 }
 
-CORBA_DomainManager_ptr CORBA_DomainManager::_narrow (
+CORBA_DomainManager_ptr	CORBA_DomainManager::_narrow (
     CORBA::Object_ptr obj,
     CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
     return CORBA_DomainManager::_nil ();
-  if (! obj->_is_local ())
+  if (!	obj->_is_local ())
     {
       CORBA::Boolean is_a = obj->_is_a ("IDL:CORBA/DomainManager:1.0", ACE_TRY_ENV);
       ACE_CHECK_RETURN (CORBA_DomainManager::_nil ());
       if (is_a == 0)
-        return CORBA_DomainManager::_nil ();
+	return CORBA_DomainManager::_nil ();
     }
-  return CORBA_DomainManager::_unchecked_narrow (obj, ACE_TRY_ENV);
+  return CORBA_DomainManager::_unchecked_narrow	(obj, ACE_TRY_ENV);
 }
 
-CORBA_DomainManager_ptr CORBA_DomainManager::_unchecked_narrow (
+CORBA_DomainManager_ptr	CORBA_DomainManager::_unchecked_narrow (
     CORBA::Object_ptr obj,
     CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
     return CORBA_DomainManager::_nil ();
-  if (! obj->_is_local ())
+  if (!	obj->_is_local ())
     {
-      TAO_Stub* stub = obj->_stubobj ();
+      TAO_Stub*	stub = obj->_stubobj ();
       if (stub)
-        stub->_incr_refcnt ();
-      CORBA_DomainManager_ptr default_proxy = CORBA_DomainManager::_nil ();
+	stub->_incr_refcnt ();
+      CORBA_DomainManager_ptr default_proxy = CORBA_DomainManager::_nil	();
 
       if (obj->_is_collocated () && _TAO_collocation_CORBA_DomainManager_Stub_Factory_function_pointer != 0)
-        {
-          default_proxy = _TAO_collocation_CORBA_DomainManager_Stub_Factory_function_pointer (obj);
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::CORBA_DomainManager (stub), CORBA_DomainManager::_nil ());
+	{
+	  default_proxy	= _TAO_collocation_CORBA_DomainManager_Stub_Factory_function_pointer (obj);
+	}
+      if (CORBA::is_nil	(default_proxy))
+	ACE_NEW_RETURN (default_proxy, ::CORBA_DomainManager (stub), CORBA_DomainManager::_nil ());
       return default_proxy;
     }
   else
     return
       ACE_reinterpret_cast
-        (
-          CORBA_DomainManager_ptr,
-            obj->_tao_QueryInterface
-              (
-                ACE_reinterpret_cast
-                  (
-                    ptr_arith_t,
-                    &CORBA_DomainManager::_narrow
-                  )
-              )
-        );
+	(
+	  CORBA_DomainManager_ptr,
+	    obj->_tao_QueryInterface
+	      (
+		ACE_reinterpret_cast
+		  (
+		    ptr_arith_t,
+		    &CORBA_DomainManager::_narrow
+		  )
+	      )
+	);
 }
 
 CORBA_DomainManager_ptr
-CORBA_DomainManager::_duplicate (CORBA_DomainManager_ptr obj)
+CORBA_DomainManager::_duplicate	(CORBA_DomainManager_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_add_ref ();
@@ -106,7 +106,7 @@ CORBA::Policy_ptr CORBA_DomainManager::get_domain_policy (
   ))
 {
 
-  CORBA::Policy_ptr _tao_retval = CORBA::Policy::_nil ();
+  CORBA::Policy_ptr _tao_retval	= CORBA::Policy::_nil ();
   CORBA::Policy_var _tao_safe_retval (_tao_retval);
 
 
@@ -119,78 +119,79 @@ CORBA::Policy_ptr CORBA_DomainManager::get_domain_policy (
       istub,
       "get_domain_policy",
       17,
+      1,
       istub->orb_core ()
     );
 
 #if (TAO_HAS_INTERCEPTORS == 1)
     TAO_ClientRequestInterceptor_Adapter
-      _tao_vfr (istub->orb_core ()->client_request_interceptors ());
+      _tao_vfr (istub->orb_core	()->client_request_interceptors	());
 
     CORBA_DomainManager::TAO_ClientRequest_Info_CORBA_DomainManager_get_domain_policy
       ri ("get_domain_policy",
-          _tao_call.service_info (),
-          this,
-          policy_type);
+	  _tao_call.service_info (),
+	  this,
+	  policy_type);
 
   ACE_TRY
     {
 #endif /* TAO_HAS_INTERCEPTORS */
 
-    for (;;)
+    for	(;;)
     {
       _tao_call.start (ACE_TRY_ENV);
       TAO_INTERCEPTOR_CHECK_RETURN (0);
 
       TAO_INTERCEPTOR (
-          ri.request_id (_tao_call.request_id ());
-           _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-        );
+	  ri.request_id	(_tao_call.request_id ());
+	   _tao_vfr.send_request (
+	      &ri,
+	      ACE_TRY_ENV
+	    )
+	);
       TAO_INTERCEPTOR_CHECK_RETURN (0);
-      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+      CORBA::Short _tao_response_flag =	TAO_TWOWAY_RESPONSE_FLAG;
 
       _tao_call.prepare_header (
-          ACE_static_cast (CORBA::Octet, _tao_response_flag), ACE_TRY_ENV
-        );
+	  ACE_static_cast (CORBA::Octet, _tao_response_flag), ACE_TRY_ENV
+	);
       TAO_INTERCEPTOR_CHECK_RETURN (0);
 
-      TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+      TAO_OutputCDR &_tao_out =	_tao_call.out_stream ();
       if (!(
-            (_tao_out << policy_type)
-        ))
+	    (_tao_out << policy_type)
+	))
       TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
 
       int _invoke_status =
-        _tao_call.invoke (0, 0, ACE_TRY_ENV);
-            TAO_INTERCEPTOR_CHECK_RETURN (0);
+	_tao_call.invoke (0, 0,	ACE_TRY_ENV);
+	    TAO_INTERCEPTOR_CHECK_RETURN (0);
 
       if (_invoke_status == TAO_INVOKE_RESTART)
-        continue;
+	continue;
       if (_invoke_status != TAO_INVOKE_OK)
       {
-        TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+	TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
 
       }
       TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
       if (!(
-            (_tao_in >> _tao_safe_retval.inout ())
-        ))
+	    (_tao_in >>	_tao_safe_retval.inout ())
+	))
       TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
     TAO_INTERCEPTOR (
-        CORBA::Policy_ptr  _tao_retval_info = _tao_safe_retval._retn ();
+	CORBA::Policy_ptr  _tao_retval_info = _tao_safe_retval._retn ();
 
-         ri.result (_tao_retval_info);
-        _tao_safe_retval = _tao_retval_info;
+	 ri.result (_tao_retval_info);
+	_tao_safe_retval = _tao_retval_info;
 
     );
 
     TAO_INTERCEPTOR (
-        _tao_vfr.receive_reply (
-          &ri,
-          ACE_TRY_ENV
-        )
+	_tao_vfr.receive_reply (
+	  &ri,
+	  ACE_TRY_ENV
+	)
     );
     TAO_INTERCEPTOR_CHECK_RETURN (0);
     break;
@@ -203,8 +204,8 @@ ACE_CATCHANY
   {
     ri.exception (&ACE_ANY_EXCEPTION);
     _tao_vfr.receive_exception (
-        &ri,
-        ACE_TRY_ENV
+	&ri,
+	ACE_TRY_ENV
       );
     ACE_RE_THROW;
   }
@@ -214,7 +215,7 @@ ACE_CHECK_RETURN (0);
 return _tao_safe_retval._retn ();
 }
 
-CORBA::Boolean CORBA_DomainManager::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+CORBA::Boolean CORBA_DomainManager::_is_a (const CORBA::Char *value, CORBA::Environment	&ACE_TRY_ENV)
 {
   if (
     (!ACE_OS::strcmp ((char *)value, "IDL:CORBA/DomainManager:1.0")) ||
@@ -230,12 +231,12 @@ void *CORBA_DomainManager::_tao_QueryInterface (ptr_arith_t type)
   if (type == ACE_reinterpret_cast
     (ptr_arith_t,
       &CORBA_DomainManager::_narrow))
-    retv = ACE_reinterpret_cast (void*, 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)
-             );
+    retv = ACE_reinterpret_cast	(void*,	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 ();
@@ -250,15 +251,15 @@ const char* CORBA_DomainManager::_interface_repository_id (void) const
 
 #if (TAO_HAS_INTERCEPTORS == 1)
 
-CORBA_DomainManager::TAO_ClientRequest_Info_CORBA_DomainManager_get_domain_policy::TAO_ClientRequest_Info_CORBA_DomainManager_get_domain_policy (
+CORBA_DomainManager::TAO_ClientRequest_Info_CORBA_DomainManager_get_domain_policy::TAO_ClientRequest_Info_CORBA_DomainManager_get_domain_policy	(
     const char *_tao_operation,
     IOP::ServiceContextList &_tao_service_context_list,
     CORBA::Object *_tao_target,
     CORBA::PolicyType &policy_type)
   : TAO_ClientRequestInfo (
-        _tao_operation, 
-        _tao_service_context_list, 
-        _tao_target
+	_tao_operation,
+	_tao_service_context_list,
+	_tao_target
       ),
     policy_type_ (policy_type)
 {}
@@ -268,8 +269,8 @@ CORBA_DomainManager::TAO_ClientRequest_Info_CORBA_DomainManager_get_domain_polic
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   // Generate the arg list on demand
-  CORBA::ULong length = 0;
-  length = this->parameter_list_.length ();
+  CORBA::ULong length =	0;
+  length = this->parameter_list_.length	();
   this->parameter_list_.length (length + 1);
   this->parameter_list_[length].argument <<=  this->policy_type_;
 
@@ -296,15 +297,15 @@ CORBA_DomainManager::TAO_ClientRequest_Info_CORBA_DomainManager_get_domain_polic
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   // Generate the result on demand :
-  this->result_val_ <<= this->result_;
+  this->result_val_ <<=	this->result_;
   return &this->result_val_;
 }
 
 void
 CORBA_DomainManager::TAO_ClientRequest_Info_CORBA_DomainManager_get_domain_policy::result (CORBA::Policy_ptr  result)
 {
-  // update the result
-  this->result_ = result;
+  // update the	result
+  this->result_	= result;
 }
 
 #endif /* TAO_HAS_INTERCEPTORS */
@@ -321,7 +322,7 @@ CORBA_ConstructionPolicy::~CORBA_ConstructionPolicy (void)
 
 void CORBA_ConstructionPolicy::_tao_any_destructor (void *x)
 {
-  CORBA_ConstructionPolicy *tmp = ACE_static_cast (CORBA_ConstructionPolicy*,x);
+  CORBA_ConstructionPolicy *tmp	= ACE_static_cast (CORBA_ConstructionPolicy*,x);
   CORBA::release (tmp);
 }
 
@@ -332,12 +333,12 @@ CORBA_ConstructionPolicy_ptr CORBA_ConstructionPolicy::_narrow (
 {
   if (CORBA::is_nil (obj))
     return CORBA_ConstructionPolicy::_nil ();
-  if (! obj->_is_local ())
+  if (!	obj->_is_local ())
     {
       CORBA::Boolean is_a = obj->_is_a ("IDL:CORBA/ConstructionPolicy:1.0", ACE_TRY_ENV);
       ACE_CHECK_RETURN (CORBA_ConstructionPolicy::_nil ());
       if (is_a == 0)
-        return CORBA_ConstructionPolicy::_nil ();
+	return CORBA_ConstructionPolicy::_nil ();
     }
   return CORBA_ConstructionPolicy::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
@@ -349,35 +350,35 @@ CORBA_ConstructionPolicy_ptr CORBA_ConstructionPolicy::_unchecked_narrow (
 {
   if (CORBA::is_nil (obj))
     return CORBA_ConstructionPolicy::_nil ();
-  if (! obj->_is_local ())
+  if (!	obj->_is_local ())
     {
-      TAO_Stub* stub = obj->_stubobj ();
+      TAO_Stub*	stub = obj->_stubobj ();
       if (stub)
-        stub->_incr_refcnt ();
+	stub->_incr_refcnt ();
       CORBA_ConstructionPolicy_ptr default_proxy = CORBA_ConstructionPolicy::_nil ();
 
       if (obj->_is_collocated () && _TAO_collocation_CORBA_ConstructionPolicy_Stub_Factory_function_pointer != 0)
-        {
-          default_proxy = _TAO_collocation_CORBA_ConstructionPolicy_Stub_Factory_function_pointer (obj);
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::CORBA_ConstructionPolicy (stub), CORBA_ConstructionPolicy::_nil ());
+	{
+	  default_proxy	= _TAO_collocation_CORBA_ConstructionPolicy_Stub_Factory_function_pointer (obj);
+	}
+      if (CORBA::is_nil	(default_proxy))
+	ACE_NEW_RETURN (default_proxy, ::CORBA_ConstructionPolicy (stub), CORBA_ConstructionPolicy::_nil ());
       return default_proxy;
     }
   else
     return
       ACE_reinterpret_cast
-        (
-          CORBA_ConstructionPolicy_ptr,
-            obj->_tao_QueryInterface
-              (
-                ACE_reinterpret_cast
-                  (
-                    ptr_arith_t,
-                    &CORBA_ConstructionPolicy::_narrow
-                  )
-              )
-        );
+	(
+	  CORBA_ConstructionPolicy_ptr,
+	    obj->_tao_QueryInterface
+	      (
+		ACE_reinterpret_cast
+		  (
+		    ptr_arith_t,
+		    &CORBA_ConstructionPolicy::_narrow
+		  )
+	      )
+	);
 }
 
 CORBA_ConstructionPolicy_ptr
@@ -419,11 +420,11 @@ void CORBA_ConstructionPolicy::make_domain_manager (
 
 #if (TAO_HAS_INTERCEPTORS == 1)
 
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr	(
       istub->orb_core ()->client_request_interceptors ()
     );
 
-  CORBA_ConstructionPolicy::TAO_ClientRequest_Info_CORBA_ConstructionPolicy_make_domain_manager ri (
+  CORBA_ConstructionPolicy::TAO_ClientRequest_Info_CORBA_ConstructionPolicy_make_domain_manager	ri (
       "make_domain_manager",
       _tao_call.service_info (),
       this,
@@ -437,52 +438,52 @@ void CORBA_ConstructionPolicy::make_domain_manager (
 #endif /* TAO_HAS_INTERCEPTORS */
 
       for (;;)
-        {
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-
-          TAO_INTERCEPTOR (
-              ri.request_id (_tao_call.request_id ());
-               _tao_vfr.send_request (
-                  &ri,
-                  ACE_TRY_ENV
-                )
-            );
-          TAO_INTERCEPTOR_CHECK;
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag), ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                (_tao_out << object_type) &&
-                (_tao_out << CORBA::Any::from_boolean (constr_policy))
-            ))
-          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL());
-          int _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-                TAO_INTERCEPTOR_CHECK;
-
-          if (_invoke_status == TAO_INVOKE_RESTART)
-            continue;
-          if (_invoke_status != TAO_INVOKE_OK)
-          {
-            TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN(TAO_DEFAULT_MINOR_CODE, 
-                                   CORBA::COMPLETED_YES));
-          }
-
-          TAO_INTERCEPTOR (
-              _tao_vfr.receive_reply (
-                &ri,
-                ACE_TRY_ENV
-              )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          break;
-        }
+	{
+	  _tao_call.start (ACE_TRY_ENV);
+	  TAO_INTERCEPTOR_CHECK;
+
+	  TAO_INTERCEPTOR (
+	      ri.request_id (_tao_call.request_id ());
+	       _tao_vfr.send_request (
+		  &ri,
+		  ACE_TRY_ENV
+		)
+	    );
+	  TAO_INTERCEPTOR_CHECK;
+	  CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+
+	  _tao_call.prepare_header (
+	      ACE_static_cast (CORBA::Octet, _tao_response_flag), ACE_TRY_ENV
+	    );
+	  TAO_INTERCEPTOR_CHECK;
+
+	  TAO_OutputCDR	&_tao_out = _tao_call.out_stream ();
+	  if (!(
+		(_tao_out << object_type) &&
+		(_tao_out << CORBA::Any::from_boolean (constr_policy))
+	    ))
+	  TAO_INTERCEPTOR_THROW	(CORBA::MARSHAL());
+	  int _invoke_status =
+	    _tao_call.invoke (0, 0, ACE_TRY_ENV);
+		TAO_INTERCEPTOR_CHECK;
+
+	  if (_invoke_status ==	TAO_INVOKE_RESTART)
+	    continue;
+	  if (_invoke_status !=	TAO_INVOKE_OK)
+	  {
+	    TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN(TAO_DEFAULT_MINOR_CODE,
+				   CORBA::COMPLETED_YES));
+	  }
+
+	  TAO_INTERCEPTOR (
+	      _tao_vfr.receive_reply (
+		&ri,
+		ACE_TRY_ENV
+	      )
+	  );
+	  TAO_INTERCEPTOR_CHECK;
+	  break;
+	}
 
 #if (TAO_HAS_INTERCEPTORS == 1)
 
@@ -491,9 +492,9 @@ void CORBA_ConstructionPolicy::make_domain_manager (
     {
       ri.exception (&ACE_ANY_EXCEPTION);
       _tao_vfr.receive_exception (
-          &ri,
-          ACE_TRY_ENV
-        );
+	  &ri,
+	  ACE_TRY_ENV
+	);
       ACE_RE_THROW;
     }
   ACE_ENDTRY;
@@ -521,21 +522,21 @@ void *CORBA_ConstructionPolicy::_tao_QueryInterface (ptr_arith_t type)
   if (type == ACE_reinterpret_cast
     (ptr_arith_t,
       &CORBA_ConstructionPolicy::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
+    retv = ACE_reinterpret_cast	(void*,	this);
+  else if (type	== ACE_reinterpret_cast
     (ptr_arith_t,
       &::CORBA::Policy::_narrow))
     retv = ACE_reinterpret_cast
       (
-        void *,
-        ACE_static_cast
-          (
-            CORBA::Policy_ptr,
-            this
-          )
+	void *,
+	ACE_static_cast
+	  (
+	    CORBA::Policy_ptr,
+	    this
+	  )
       );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
+  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)
@@ -549,7 +550,7 @@ const char* CORBA_ConstructionPolicy::_interface_repository_id (void) const
 }
 
 
-#if (TAO_HAS_INTERCEPTORS == 1) && (TAO_HAS_INTERFACE_REPOSITORY == 1)
+#if (TAO_HAS_INTERCEPTORS == 1)	&& (TAO_HAS_INTERFACE_REPOSITORY == 1)
 
 CORBA_ConstructionPolicy::TAO_ClientRequest_Info_CORBA_ConstructionPolicy_make_domain_manager::TAO_ClientRequest_Info_CORBA_ConstructionPolicy_make_domain_manager (
     const char *_tao_operation,
@@ -560,9 +561,9 @@ CORBA_ConstructionPolicy::TAO_ClientRequest_Info_CORBA_ConstructionPolicy_make_d
     CORBA::Environment &
   )
   : TAO_ClientRequestInfo (
-        _tao_operation, 
-        _tao_service_context_list, 
-        _tao_target
+	_tao_operation,
+	_tao_service_context_list,
+	_tao_target
       ),
     object_type_ (object_type),
     constr_policy_ (constr_policy)
@@ -573,13 +574,13 @@ CORBA_ConstructionPolicy::TAO_ClientRequest_Info_CORBA_ConstructionPolicy_make_d
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   // Generate the arg list on demand
-  CORBA::ULong length = 0;
-  length = this->parameter_list_.length ();
+  CORBA::ULong length =	0;
+  length = this->parameter_list_.length	();
   this->parameter_list_.length (length + 1);
   this->parameter_list_[length].argument <<=  this->object_type_;
 
   this->parameter_list_[length].mode = Dynamic::PARAM_IN;
-  length = this->parameter_list_.length ();
+  length = this->parameter_list_.length	();
   this->parameter_list_.length (length + 1);
   this->parameter_list_[length].argument <<= CORBA::Any::from_boolean (this->constr_policy_ );
   this->parameter_list_[length].mode = Dynamic::PARAM_IN;
@@ -613,55 +614,55 @@ CORBA_ConstructionPolicy::TAO_ClientRequest_Info_CORBA_ConstructionPolicy_make_d
 
 #endif /* TAO_HAS_INTERCEPTORS && TAO_HAS_INTERFACE_REPOSITORY */
 
-CORBA_ConstructionPolicy_ptr (*_TAO_collocation_CORBA_ConstructionPolicy_Stub_Factory_function_pointer) (
+CORBA_ConstructionPolicy_ptr (*_TAO_collocation_CORBA_ConstructionPolicy_Stub_Factory_function_pointer)	(
     CORBA::Object_ptr obj
   ) = 0;
 
-void operator<<= (CORBA::Any &_tao_any, CORBA_ConstructionPolicy_ptr _tao_elem)
+void operator<<= (CORBA::Any &_tao_any,	CORBA_ConstructionPolicy_ptr _tao_elem)
 {
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
+  TAO_OutputCDR	stream;
+  if (stream <<	_tao_elem)
     {
       _tao_any._tao_replace (
-          CORBA::_tc_ConstructionPolicy,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin (),
-          1,
-          CORBA_ConstructionPolicy::_duplicate (_tao_elem),
-          CORBA_ConstructionPolicy::_tao_any_destructor
-        );
+	  CORBA::_tc_ConstructionPolicy,
+	  TAO_ENCAP_BYTE_ORDER,
+	  stream.begin (),
+	  1,
+	  CORBA_ConstructionPolicy::_duplicate (_tao_elem),
+	  CORBA_ConstructionPolicy::_tao_any_destructor
+	);
     }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_ConstructionPolicy_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	CORBA_ConstructionPolicy_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
     {
-      _tao_elem = CORBA_ConstructionPolicy::_nil ();
+      _tao_elem	= CORBA_ConstructionPolicy::_nil ();
       CORBA::TypeCode_var type = _tao_any.type ();
       if (!type->equivalent (CORBA::_tc_ConstructionPolicy, ACE_TRY_ENV)) // not equal
-        {
-          return 0;
-        }
+	{
+	  return 0;
+	}
       ACE_TRY_CHECK;
       TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
+	  _tao_any._tao_get_cdr	(),
+	  _tao_any._tao_byte_order ()
+	);
       if (stream >> _tao_elem)
       {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_ConstructionPolicy,
-            1,
-            _tao_elem,
-            CORBA_ConstructionPolicy::_tao_any_destructor
-          );
-        return 1;
+	((CORBA::Any *)&_tao_any)->_tao_replace	(
+	    CORBA::_tc_ConstructionPolicy,
+	    1,
+	    _tao_elem,
+	    CORBA_ConstructionPolicy::_tao_any_destructor
+	  );
+	return 1;
       }
     }
   ACE_CATCHANY
     {
-      _tao_elem = CORBA_ConstructionPolicy::_nil ();
+      _tao_elem	= CORBA_ConstructionPolicy::_nil ();
       return 0;
     }
   ACE_ENDTRY;
@@ -676,34 +677,34 @@ template class TAO_Object_Manager<CORBA_ConstructionPolicy,CORBA_ConstructionPol
 #  pragma instantiate TAO_Object_Manager<CORBA_ConstructionPolicy,CORBA_ConstructionPolicy_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-#endif /* TAO_HAS_MINIMUM_CORBA */
+#endif /* TAO_HAS_MINIMUM_CORBA	*/
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
 
 #if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_DOMAINMANAGERLIST_CS_)
-#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_DOMAINMANAGERLIST_CS_
+#define	__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_DOMAINMANAGERLIST_CS_
 
-// The Base_Sequence functions, please see tao/Sequence.h
+// The Base_Sequence functions,	please see tao/Sequence.h
 void
 _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_allocate_buffer (CORBA::ULong length)
 {
   CORBA_DomainManager **tmp = 0;
-  tmp = _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::allocbuf (length);
+  tmp =	_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::allocbuf (length);
 
   if (this->buffer_ != 0)
     {
-      CORBA_DomainManager **old = ACE_reinterpret_cast (CORBA_DomainManager**, this->buffer_);
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        if (!this->release_)
-          tmp[i] = CORBA_DomainManager::_duplicate (old[i]);
-        else
-          tmp[i] = old[i];
+      CORBA_DomainManager **old	= ACE_reinterpret_cast (CORBA_DomainManager**, this->buffer_);
+      for (CORBA::ULong	i = 0; i < this->length_; ++i)
+	if (!this->release_)
+	  tmp[i] = CORBA_DomainManager::_duplicate (old[i]);
+	else
+	  tmp[i] = old[i];
 
       if (this->release_)
-        delete[] old;
+	delete[] old;
 
     }
-  this->buffer_ = tmp;
+  this->buffer_	= tmp;
 }
 
 void
@@ -712,16 +713,16 @@ _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_deallocate_buffer (void
   if (this->buffer_ == 0 || this->release_ == 0)
     return;
   CORBA_DomainManager **tmp = ACE_reinterpret_cast (CORBA_DomainManager**, this->buffer_);
-  for (CORBA::ULong i = 0; i < this->length_; ++i)
+  for (CORBA::ULong i =	0; i < this->length_; ++i)
     {
       CORBA::release (tmp[i]);
       tmp[i] = CORBA_DomainManager::_nil ();
     }
   _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::freebuf (tmp);
-  this->buffer_ = 0;
+  this->buffer_	= 0;
 }
 
-_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::~_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList (void)
+_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::~_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList	(void)
 {
   this->_deallocate_buffer ();
 }
@@ -731,7 +732,7 @@ _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_shrink_buffer (CORBA::U
 {
   CORBA_DomainManager **tmp = ACE_reinterpret_cast (CORBA_DomainManager**, this->buffer_);
 
-  for (CORBA::ULong i = nl; i < ol; ++i)
+  for (CORBA::ULong i =	nl; i <	ol; ++i)
     {
       CORBA::release (tmp[i]);
       tmp[i] = CORBA_DomainManager::_nil ();
@@ -750,7 +751,7 @@ _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_downcast (
 }
 
 CORBA_Object*
-_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_upcast (void *src) const
+_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_upcast	(void *src) const
 {
   CORBA_DomainManager **tmp = ACE_static_cast (CORBA_DomainManager**, src);
   return *tmp;
@@ -762,7 +763,7 @@ _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_upcast (void *src) cons
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 
 #if !defined (_CORBA_DOMAINMANAGERLIST_CS_)
-#define _CORBA_DOMAINMANAGERLIST_CS_
+#define	_CORBA_DOMAINMANAGERLIST_CS_
 
 // *************************************************************
 // CORBA_DomainManagerList
@@ -771,7 +772,7 @@ _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_upcast (void *src) cons
 CORBA_DomainManagerList::CORBA_DomainManagerList (void)
 {}
 
-CORBA_DomainManagerList::CORBA_DomainManagerList (CORBA::ULong max) // uses max size
+CORBA_DomainManagerList::CORBA_DomainManagerList (CORBA::ULong max) // uses max	size
   :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList
@@ -782,9 +783,9 @@ CORBA_DomainManagerList::CORBA_DomainManagerList (CORBA::ULong max) // uses max
 {}
 
 CORBA_DomainManagerList::CORBA_DomainManagerList (
-    CORBA::ULong max, 
-    CORBA::ULong length, 
-    CORBA_DomainManager_ptr *buffer, 
+    CORBA::ULong max,
+    CORBA::ULong length,
+    CORBA_DomainManager_ptr *buffer,
     CORBA::Boolean release
   )
   :
@@ -793,7 +794,7 @@ CORBA_DomainManagerList::CORBA_DomainManagerList (
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Object_Sequence<CORBA_DomainManager,CORBA_DomainManager_var>
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-  (max, length, buffer, release)
+  (max,	length,	buffer,	release)
 {}
 
 CORBA_DomainManagerList::CORBA_DomainManagerList (
@@ -811,7 +812,7 @@ CORBA_DomainManagerList::CORBA_DomainManagerList (
 CORBA_DomainManagerList::~CORBA_DomainManagerList (void) // dtor
 {}
 
-void CORBA_DomainManagerList::_tao_any_destructor (void *x)
+void CORBA_DomainManagerList::_tao_any_destructor (void	*x)
 {
   CORBA_DomainManagerList *tmp = ACE_static_cast (CORBA_DomainManagerList*,x);
   delete tmp;
@@ -819,59 +820,59 @@ void CORBA_DomainManagerList::_tao_any_destructor (void *x)
 
 #endif /* end #if !defined */
 
-CORBA_DomainManager_ptr (*_TAO_collocation_CORBA_DomainManager_Stub_Factory_function_pointer) (
+CORBA_DomainManager_ptr	(*_TAO_collocation_CORBA_DomainManager_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   ) = 0;
 
-void operator<<= (CORBA::Any &_tao_any, CORBA_DomainManager_ptr _tao_elem)
+void operator<<= (CORBA::Any &_tao_any,	CORBA_DomainManager_ptr	_tao_elem)
 {
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
+  TAO_OutputCDR	stream;
+  if (stream <<	_tao_elem)
     {
       _tao_any._tao_replace (
-          CORBA::_tc_DomainManager,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin (),
-          1,
-          CORBA_DomainManager::_duplicate (_tao_elem),
-          CORBA_DomainManager::_tao_any_destructor
-        );
+	  CORBA::_tc_DomainManager,
+	  TAO_ENCAP_BYTE_ORDER,
+	  stream.begin (),
+	  1,
+	  CORBA_DomainManager::_duplicate (_tao_elem),
+	  CORBA_DomainManager::_tao_any_destructor
+	);
     }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_DomainManager_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	CORBA_DomainManager_ptr	&_tao_elem)
 {
   ACE_TRY_NEW_ENV
     {
-      _tao_elem = CORBA_DomainManager::_nil ();
+      _tao_elem	= CORBA_DomainManager::_nil ();
       CORBA::TypeCode_var type = _tao_any.type ();
-      if (!type->equivalent (CORBA::_tc_DomainManager, ACE_TRY_ENV)) // not equal
-        {
-          return 0;
-        }
+      if (!type->equivalent (CORBA::_tc_DomainManager, ACE_TRY_ENV)) //	not equal
+	{
+	  return 0;
+	}
       ACE_TRY_CHECK;
       TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
+	  _tao_any._tao_get_cdr	(),
+	  _tao_any._tao_byte_order ()
+	);
       if (stream >> _tao_elem)
       {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_DomainManager,
-            1,
-            _tao_elem,
-            CORBA_DomainManager::_tao_any_destructor
-          );
-        return 1;
+	((CORBA::Any *)&_tao_any)->_tao_replace	(
+	    CORBA::_tc_DomainManager,
+	    1,
+	    _tao_elem,
+	    CORBA_DomainManager::_tao_any_destructor
+	  );
+	return 1;
       }
     }
   ACE_CATCHANY
     {
-      _tao_elem = CORBA_DomainManager::_nil ();
+      _tao_elem	= CORBA_DomainManager::_nil ();
       return 0;
     }
   ACE_ENDTRY;
-  _tao_elem = CORBA_DomainManager::_nil ();
+  _tao_elem = CORBA_DomainManager::_nil	();
   return 0;
 }
 
@@ -887,22 +888,22 @@ void operator<<= (
     const CORBA_DomainManagerList &_tao_elem
   ) // copying
 {
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
+  TAO_OutputCDR	stream;
+  if (stream <<	_tao_elem)
     {
       _tao_any._tao_replace (
-          CORBA::_tc_DomainManagerList,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
+	  CORBA::_tc_DomainManagerList,
+	  TAO_ENCAP_BYTE_ORDER,
+	  stream.begin ()
+	);
     }
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA_DomainManagerList *_tao_elem) // non copying
+void operator<<= (CORBA::Any &_tao_any,	CORBA_DomainManagerList	*_tao_elem) // non copying
 {
-  TAO_OutputCDR stream;
+  TAO_OutputCDR	stream;
   stream << *_tao_elem;
-  _tao_any._tao_replace (
+  _tao_any._tao_replace	(
       CORBA::_tc_DomainManagerList,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin (),
@@ -912,7 +913,7 @@ void operator<<= (CORBA::Any &_tao_any, CORBA_DomainManagerList *_tao_elem) // n
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_DomainManagerList *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	CORBA_DomainManagerList	*&_tao_elem)
 {
   return _tao_any >>= ACE_const_cast(
       const CORBA_DomainManagerList*&,
@@ -920,48 +921,48 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_DomainManagerList
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_DomainManagerList *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	const CORBA_DomainManagerList *&_tao_elem)
 {
   _tao_elem = 0;
   ACE_TRY_NEW_ENV
     {
       CORBA::TypeCode_var type = _tao_any.type ();
-      if (!type->equivalent (CORBA::_tc_DomainManagerList, ACE_TRY_ENV)) // not equal
-        {
-          return 0;
-        }
+      if (!type->equivalent (CORBA::_tc_DomainManagerList, ACE_TRY_ENV)) // not	equal
+	{
+	  return 0;
+	}
       ACE_TRY_CHECK;
       if (_tao_any.any_owns_data ())
       {
-        _tao_elem = ACE_static_cast(
-            const CORBA_DomainManagerList*,
-            _tao_any.value ()
-          );
-        return 1;
+	_tao_elem = ACE_static_cast(
+	    const CORBA_DomainManagerList*,
+	    _tao_any.value ()
+	  );
+	return 1;
       }
       else
       {
-        CORBA_DomainManagerList *tmp;
-        ACE_NEW_RETURN (tmp, CORBA_DomainManagerList, 0);
-        TAO_InputCDR stream (
-            _tao_any._tao_get_cdr (),
-            _tao_any._tao_byte_order ()
-          );
-        if (stream >> *tmp)
-        {
-          ((CORBA::Any *)&_tao_any)->_tao_replace (
-              CORBA::_tc_DomainManagerList,
-              1,
-              ACE_static_cast (void *, tmp),
-              CORBA_DomainManagerList::_tao_any_destructor
-            );
-          _tao_elem = tmp;
-          return 1;
-        }
-        else
-        {
-          delete tmp;
-        }
+	CORBA_DomainManagerList	*tmp;
+	ACE_NEW_RETURN (tmp, CORBA_DomainManagerList, 0);
+	TAO_InputCDR stream (
+	    _tao_any._tao_get_cdr (),
+	    _tao_any._tao_byte_order ()
+	  );
+	if (stream >> *tmp)
+	{
+	  ((CORBA::Any *)&_tao_any)->_tao_replace (
+	      CORBA::_tc_DomainManagerList,
+	      1,
+	      ACE_static_cast (void *, tmp),
+	      CORBA_DomainManagerList::_tao_any_destructor
+	    );
+	  _tao_elem = tmp;
+	  return 1;
+	}
+	else
+	{
+	  delete tmp;
+	}
       }
     }
   ACE_CATCHANY
@@ -978,11 +979,11 @@ CORBA::Boolean operator<< (
 {
   if (strm << _tao_sequence.length ())
     {
-      // encode all elements
+      // encode	all elements
       CORBA::Boolean _tao_marshal_flag = 1;
-      for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+      for (CORBA::ULong	i = 0; i < _tao_sequence.length	() && _tao_marshal_flag; i++)
       {
-        _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+	_tao_marshal_flag = (strm << _tao_sequence[i].in ());
       }
       return _tao_marshal_flag;
     }
@@ -997,16 +998,16 @@ CORBA::Boolean operator>> (
   CORBA::ULong _tao_seq_len;
   if (strm >> _tao_seq_len)
     {
-      // set the length of the sequence
+      // set the length	of the sequence
       _tao_sequence.length (_tao_seq_len);
-      // If length is 0 we return true.
+      // If length is 0	we return true.
       if (0 >= _tao_seq_len)
-        return 1;
+	return 1;
       // retrieve all the elements
       CORBA::Boolean _tao_marshal_flag = 1;
-      for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+      for (CORBA::ULong	i = 0; i < _tao_sequence.length	() && _tao_marshal_flag; i++)
       {
-        _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+	_tao_marshal_flag = (strm >> _tao_sequence[i].out ());
       }
       return _tao_marshal_flag;
     }
diff --git a/TAO/tao/DynamicInterface/DII_Invocation.h b/TAO/tao/DynamicInterface/DII_Invocation.h
index f2d64e79199..6ec9d811c54 100644
--- a/TAO/tao/DynamicInterface/DII_Invocation.h
+++ b/TAO/tao/DynamicInterface/DII_Invocation.h
@@ -40,13 +40,14 @@ class TAO_GIOP_DII_Invocation : public TAO_GIOP_Twoway_Invocation
   // = DESCRIPTION
   //    This class replaces just one method - invoke - of its base
   //    class with one of a slightly different signature. The class
-  //    is not exported because it is only instantiated by 
+  //    is not exported because it is only instantiated by
   //    CORBA::Request in this library.
   //
 public:
   TAO_GIOP_DII_Invocation (TAO_Stub *data,
                            const char *operation,
                            CORBA::ULong opname_len,
+                           CORBA::Boolean argument_flag,
                            TAO_ORB_Core *orb_core);
   // Constructor.
 
@@ -72,6 +73,7 @@ class TAO_DynamicInterface_Export TAO_GIOP_DII_Deferred_Invocation
 public:
   TAO_GIOP_DII_Deferred_Invocation (TAO_Stub *data,
                                     TAO_ORB_Core* orb_core,
+                                    CORBA::Boolean argument_flag,
                                     const CORBA::Request_ptr req);
   // Constructor.
 
diff --git a/TAO/tao/DynamicInterface/DII_Invocation.inl b/TAO/tao/DynamicInterface/DII_Invocation.inl
index 36df85f8e81..eb93cac56c0 100644
--- a/TAO/tao/DynamicInterface/DII_Invocation.inl
+++ b/TAO/tao/DynamicInterface/DII_Invocation.inl
@@ -7,10 +7,12 @@ ACE_INLINE
 TAO_GIOP_DII_Invocation::TAO_GIOP_DII_Invocation (TAO_Stub *data,
                                                   const char *operation,
                                                   CORBA::ULong opname_len,
+                                                  CORBA::Boolean argument_flag,
                                                   TAO_ORB_Core *orb_core)
   : TAO_GIOP_Twoway_Invocation (data,
                                 operation,
                                 opname_len,
+                                argument_flag,
                                 orb_core)
 {
 }
@@ -19,11 +21,13 @@ ACE_INLINE
 TAO_GIOP_DII_Deferred_Invocation::TAO_GIOP_DII_Deferred_Invocation (
     TAO_Stub *stub,
     TAO_ORB_Core *orb_core,
+    CORBA::Boolean argument_flag,
     const CORBA::Request_ptr req
   )
   : TAO_GIOP_Invocation (stub,
                          req->operation (),
                          ACE_OS::strlen (req->operation ()),
+                         argument_flag,
                          orb_core)
 {
   // New reply dispatcher on the heap, because
diff --git a/TAO/tao/DynamicInterface/Request.cpp b/TAO/tao/DynamicInterface/Request.cpp
index bb4090eee6a..ec1d3960a9b 100644
--- a/TAO/tao/DynamicInterface/Request.cpp
+++ b/TAO/tao/DynamicInterface/Request.cpp
@@ -105,10 +105,10 @@ CORBA_Request::CORBA_Request (CORBA::Object_ptr obj,
 
   this->exceptions_ = tmp;
 
-  ACE_NEW (this->args_, 
+  ACE_NEW (this->args_,
            CORBA::NVList);
 
-  ACE_NEW (this->result_, 
+  ACE_NEW (this->result_,
            CORBA::NamedValue);
 }
 
@@ -133,9 +133,12 @@ CORBA_Request::~CORBA_Request (void)
 void
 CORBA_Request::invoke (CORBA::Environment &ACE_TRY_ENV)
 {
+  CORBA::Boolean argument_flag = this->args_->count () ? 1 : 0;
+
   TAO_GIOP_DII_Invocation call (this->target_->_stubobj (),
                                 this->opname_,
                                 ACE_OS::strlen (this->opname_),
+                                argument_flag,
                                 this->orb_->orb_core ());
 
   // Loop as needed for forwarding.
@@ -146,7 +149,7 @@ CORBA_Request::invoke (CORBA::Environment &ACE_TRY_ENV)
 
       CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
 
-      call.prepare_header (ACE_static_cast (CORBA::Octet, 
+      call.prepare_header (ACE_static_cast (CORBA::Octet,
                                             flag),
                            ACE_TRY_ENV);
       ACE_CHECK;
@@ -158,7 +161,7 @@ CORBA_Request::invoke (CORBA::Environment &ACE_TRY_ENV)
       ACE_CHECK;
 
       // Make the call ... blocking for the response.
-      int status = call.invoke (this->exceptions_.in (), 
+      int status = call.invoke (this->exceptions_.in (),
                                 ACE_TRY_ENV);
       ACE_CHECK;
 
@@ -209,9 +212,11 @@ CORBA_Request::invoke (CORBA::Environment &ACE_TRY_ENV)
 void
 CORBA_Request::send_oneway (CORBA::Environment &ACE_TRY_ENV)
 {
+  CORBA::Boolean argument_flag = this->args_->count () ? 1 : 0;
   TAO_GIOP_Oneway_Invocation call (this->target_->_stubobj (),
                                    this->opname_,
                                    ACE_OS::strlen (this->opname_),
+                                   argument_flag,
                                    this->orb_->orb_core ());
 
   // Loop as needed for forwarding.
@@ -273,8 +278,10 @@ CORBA_Request::send_deferred (CORBA::Environment &ACE_TRY_ENV)
     this->response_received_ = 0;
   }
 
+  CORBA::Boolean argument_flag = this->args_->count () ? 1: 0;
   TAO_GIOP_DII_Deferred_Invocation call (this->target_->_stubobj (),
                                          this->orb_->orb_core (),
+                                         argument_flag,
                                          this);
 
   // Loop as needed for forwarding.
diff --git a/TAO/tao/GIOP_Message_Accept_State.cpp b/TAO/tao/GIOP_Message_Accept_State.cpp
index 0dc42b409af..e000ee06bbe 100644
--- a/TAO/tao/GIOP_Message_Accept_State.cpp
+++ b/TAO/tao/GIOP_Message_Accept_State.cpp
@@ -659,11 +659,15 @@ TAO_GIOP_Message_Accept_State_12::write_reply_header (
     }
 #endif /*TAO_HAS_MINIMUM_CORBA */
 
-  if (output.align_write_ptr (TAO_GIOP_MESSAGE_ALIGN_PTR) == -1)
+  if (reply.argument_flag_)
     {
-      return 0;
+      // If we have some data to be marshalled, then we align the
+      // pointer to a 8 byte boundary.  Else, we just leave it throu
+      if (output.align_write_ptr (TAO_GIOP_MESSAGE_ALIGN_PTR) == -1)
+        {
+          return 0;
+        }
     }
-
   return 1;
 }
 
@@ -679,9 +683,14 @@ TAO_GIOP_Message_Accept_State_12::write_locate_reply_mesg (
   // Make the header for the locate request
   output.write_ulong (status_info.status);
 
-  if (output.align_write_ptr (TAO_GIOP_MESSAGE_ALIGN_PTR) == -1)
+  if (status_info.status == TAO_GIOP_OBJECT_FORWARD ||
+      status_info.status == TAO_GIOP_OBJECT_FORWARD_PERM)
     {
-      return 0;
+      // We have to send some data, so align the pointer
+      if (output.align_write_ptr (TAO_GIOP_MESSAGE_ALIGN_PTR) == -1)
+        {
+          return 0;
+        }
     }
 
   switch (status_info.status)
diff --git a/TAO/tao/GIOP_Message_Acceptors.cpp b/TAO/tao/GIOP_Message_Acceptors.cpp
index dcf916038f2..21c603a412a 100644
--- a/TAO/tao/GIOP_Message_Acceptors.cpp
+++ b/TAO/tao/GIOP_Message_Acceptors.cpp
@@ -449,6 +449,9 @@ TAO_GIOP_Message_Acceptors::send_reply_exception (
   reply_params.request_id_ = request_id;
   reply_params.svc_ctx_.length (0);
 
+  // We are going to send some data
+  reply_params.argument_flag_ = 1;
+
   // Send back the service context we received.  (RTCORBA relies on
   // this).
   reply_params.service_context_notowned (svc_info);
diff --git a/TAO/tao/GIOP_Message_Connectors.cpp b/TAO/tao/GIOP_Message_Connectors.cpp
index 2a0ceb36a9c..009eda30db7 100644
--- a/TAO/tao/GIOP_Message_Connectors.cpp
+++ b/TAO/tao/GIOP_Message_Connectors.cpp
@@ -16,112 +16,112 @@
 # include "tao/GIOP_Message_Connectors.i"
 #endif /* __ACE_INLINE__ */
 
-ACE_RCSID(tao, GIOP_Message_Connectors, "$Id$")
+ACE_RCSID(tao, GIOP_Message_Connectors,	"$Id$")
 
 
 int
 TAO_GIOP_Message_Connectors::
   parse_reply (TAO_Message_State_Factory &mesg_state,
-               TAO_Pluggable_Reply_Params &params)
+	       TAO_Pluggable_Reply_Params &params)
 {
-  // @@ Bala: See how the message state is a per-protocol thing?
-  //    Wouldn't it be better to have each protocol define its own
-  //    message state and just use that type directly (i.e no
-  //    message_state base class).  As far as i can see (but i may be
-  //    wrong), only very tightly related messaging protocols and
-  //    transport protocols can use the same message state (for
-  //    example GIOP 1.x and GIOP Lite).  Furthermore, if i'm proven
-  //    wrong and there is common functionality among different
-  //    pluggable messaging protocols, we can simply re-factor at that
-  //    point.
-  //    IMHO the right approach is to factor out common functionality
-  //    and interfaces 'a posteriori', otherwise we will define
-  //    ackward interfaces that will have to be changed anyway!
-
-  // @@ Carlos: I agree. But I see a problem. Other than the transport
-  //    classes, we store state information in our Reply despatcers,
-  //    Transport Mux Strategy etc. I would only love to have the
-  //    Message States local to GIOP or say some other protocol. One
-  //    example that spoils this idea is the Mux_Strategies that we
-  //    have. I am ready to hear anything you suggest to get around
-  //    this.
+  // @@	Bala: See how the message state	is a per-protocol thing?
+  //	Wouldn't it be better to have each protocol define its own
+  //	message	state and just use that	type directly (i.e no
+  //	message_state base class).  As far as i	can see	(but i may be
+  //	wrong),	only very tightly related messaging protocols and
+  //	transport protocols can	use the	same message state (for
+  //	example	GIOP 1.x and GIOP Lite).  Furthermore, if i'm proven
+  //	wrong and there	is common functionality	among different
+  //	pluggable messaging protocols, we can simply re-factor at that
+  //	point.
+  //	IMHO the right approach	is to factor out common	functionality
+  //	and interfaces 'a posteriori', otherwise we will define
+  //	ackward	interfaces that	will have to be	changed	anyway!
+
+  // @@	Carlos:	I agree. But I see a problem. Other than the transport
+  //	classes, we store state	information in our Reply despatcers,
+  //	Transport Mux Strategy etc. I would only love to have the
+  //	Message	States local to	GIOP or	say some other protocol. One
+  //	example	that spoils this idea is the Mux_Strategies that we
+  //	have. I	am ready to hear anything you suggest to get around
+  //	this.
 
 
   // Cast to the GIOP Message state
-  TAO_GIOP_Message_State *state = ACE_dynamic_cast (TAO_GIOP_Message_State *,
-                                                    &mesg_state);
+  TAO_GIOP_Message_State *state	= ACE_dynamic_cast (TAO_GIOP_Message_State *,
+						    &mesg_state);
 
   // Read the request id
   if (!state->cdr.read_ulong (params.request_id_))
     {
       if (TAO_debug_level > 0)
-        ACE_DEBUG ((LM_DEBUG,
-                    "TAO (%P|%t|%N|%l) : TAO_GIOP_Message_1_1::parse_reply, "
-                    "extracting request id"));
+	ACE_DEBUG ((LM_DEBUG,
+		    "TAO (%P|%t|%N|%l) : TAO_GIOP_Message_1_1::parse_reply, "
+		    "extracting	request	id"));
       return -1;
     }
 
-  // and the reply status type.  status can be NO_EXCEPTION,
+  // and the reply status type.	 status	can be NO_EXCEPTION,
   // SYSTEM_EXCEPTION, USER_EXCEPTION, LOCATION_FORWARD
 
   // Cannot handle LOCATION_FORWARD_PERM here
-  CORBA::ULong rep_stat = 0;
+  CORBA::ULong rep_stat	= 0;
   if (!state->cdr.read_ulong (rep_stat))
     {
       if (TAO_debug_level > 0)
-        ACE_DEBUG ((LM_DEBUG,
-                    "TAO (%P|%t|%N|%l) : TAO_GIOP_Message_1_1::parse_reply, "
-                    "extracting reply status\n"));
+	ACE_DEBUG ((LM_DEBUG,
+		    "TAO (%P|%t|%N|%l) : TAO_GIOP_Message_1_1::parse_reply, "
+		    "extracting	reply status\n"));
       return -1;
     }
 
-  // @@ Bala: More silly translations!
+  // @@	Bala: More silly translations!
 
-  // @@ Carlos: Please let me know what I can do to mask them from the
-  //    user of this method
+  // @@	Carlos:	Please let me know what	I can do to mask them from the
+  //	user of	this method
 
-  // Pass the right Pluggable interface code to the transport layer
+  // Pass the right Pluggable interface	code to	the transport layer
   switch (rep_stat)
     {
       // Request completed successfully
     case TAO_GIOP_NO_EXCEPTION:
       params.reply_status_ =
-        TAO_PLUGGABLE_MESSAGE_NO_EXCEPTION;
+	TAO_PLUGGABLE_MESSAGE_NO_EXCEPTION;
       break;
 
       // Request terminated with user exception
     case TAO_GIOP_USER_EXCEPTION:
       params.reply_status_ =
-        TAO_PLUGGABLE_MESSAGE_USER_EXCEPTION;
+	TAO_PLUGGABLE_MESSAGE_USER_EXCEPTION;
       break;
-      // Request terminated with system exception
+      // Request terminated with system	exception
     case TAO_GIOP_SYSTEM_EXCEPTION:
       params.reply_status_ =
-        TAO_PLUGGABLE_MESSAGE_SYSTEM_EXCEPTION;
+	TAO_PLUGGABLE_MESSAGE_SYSTEM_EXCEPTION;
       break;
       // Reply is a location forward type
     case TAO_GIOP_LOCATION_FORWARD:
       params.reply_status_ =
-        TAO_PLUGGABLE_MESSAGE_LOCATION_FORWARD;
+	TAO_PLUGGABLE_MESSAGE_LOCATION_FORWARD;
       break;
       // Reply is a location forward perm type
-      // @@For the time being the behaviour of the
-      // LOCATION_FORWARD_PERM would be similar to the
-      // LOCATION_FORWARD as there is a controversy surrounding the
+      // @@For the time	being the behaviour of the
+      // LOCATION_FORWARD_PERM would be	similar	to the
+      // LOCATION_FORWARD as there is a	controversy surrounding	the
       // usage of this in the OMG.
     case TAO_GIOP_LOCATION_FORWARD_PERM:
       params.reply_status_ =
-        TAO_PLUGGABLE_MESSAGE_LOCATION_FORWARD;
+	TAO_PLUGGABLE_MESSAGE_LOCATION_FORWARD;
       break;
       // Reply is a location forward type
     case TAO_GIOP_NEEDS_ADDRESSING_MODE:
       params.reply_status_ =
-        TAO_PLUGGABLE_MESSAGE_NEEDS_ADDRESSING_MODE;
+	TAO_PLUGGABLE_MESSAGE_NEEDS_ADDRESSING_MODE;
       break;
     default:
       if (TAO_debug_level > 0)
-        ACE_DEBUG ((LM_DEBUG,
-                    ACE_TEXT ("(%N|%l) Unknown reply status \n")));
+	ACE_DEBUG ((LM_DEBUG,
+		    ACE_TEXT ("(%N|%l) Unknown reply status \n")));
     }
 
   return 0;
@@ -131,32 +131,32 @@ TAO_GIOP_Message_Connectors::
 int
 TAO_GIOP_Message_Connectors::
   parse_locate_reply (TAO_GIOP_Message_State &state,
-                      TAO_Pluggable_Reply_Params &params)
+		      TAO_Pluggable_Reply_Params &params)
 {
   // Read the request id
   if (!state.cdr.read_ulong (params.request_id_))
     {
       if (TAO_debug_level > 0)
-        ACE_DEBUG ((LM_DEBUG,
-                    ACE_TEXT ("TAO (%P|%t|%N|%l) : TAO_GIOP_Message_1_1::parse_reply, ")
-                    ACE_TEXT ("extracting request id")));
+	ACE_DEBUG ((LM_DEBUG,
+		    ACE_TEXT ("TAO (%P|%t|%N|%l) : TAO_GIOP_Message_1_1::parse_reply, ")
+		    ACE_TEXT ("extracting request id")));
       return -1;
     }
 
-  // and the reply status type.  status can be NO_EXCEPTION,
+  // and the reply status type.	 status	can be NO_EXCEPTION,
   // SYSTEM_EXCEPTION, USER_EXCEPTION, LOCATION_FORWARD
 
   // Cannot handle LOCATION_FORWARD_PERM here
 
-  // Please note here that we are NOT converting to the Pluggable
+  // Please note here that we are NOT converting to the	Pluggable
   // messaging layer exception as this is GIOP specific. Not many
   // messaging protocols have the locate_* messages.
   if (!state.cdr.read_ulong (params.reply_status_))
     {
       if (TAO_debug_level > 0)
-        ACE_DEBUG ((LM_DEBUG,
-                    ACE_TEXT ("TAO (%P|%t) : TAO_GIOP_Message_Connectors::parse_locate_reply, ")
-                    ACE_TEXT ("extracting reply status\n")));
+	ACE_DEBUG ((LM_DEBUG,
+		    ACE_TEXT ("TAO (%P|%t) : TAO_GIOP_Message_Connectors::parse_locate_reply, ")
+		    ACE_TEXT ("extracting reply	status\n")));
       return -1;
     }
 
@@ -170,7 +170,7 @@ TAO_GIOP_Message_Connectors::validate_version (TAO_GIOP_Message_State *state)
 
 {
   // Grab the read pointer
-  char *buf = state->cdr.rd_ptr ();
+  char *buf = state->cdr.rd_ptr	();
 
   if ((buf[TAO_GIOP_VERSION_MAJOR_OFFSET] != this->major_version ()) ||
        (buf[TAO_GIOP_VERSION_MINOR_OFFSET] != this->minor_version ()))
@@ -185,19 +185,19 @@ TAO_GIOP_Message_Connectors::validate_version (TAO_GIOP_Message_State *state)
 
 int
 TAO_GIOP_Message_Connectors::process_client_message (TAO_Transport * /*transport*/,
-                                                     TAO_ORB_Core * /*orb_core*/,
-                                                     TAO_InputCDR & /*input*/,
-                                                     CORBA::Octet /*message_type*/)
+						     TAO_ORB_Core * /*orb_core*/,
+						     TAO_InputCDR & /*input*/,
+						     CORBA::Octet /*message_type*/)
 {
    ACE_NOTSUP_RETURN (-1);
 }
 
 
 CORBA::Boolean
-TAO_GIOP_Message_Connectors::write_reply_header (TAO_OutputCDR & /*cdr*/,
-                                                 TAO_Pluggable_Reply_Params & /*params*/,
-                                                 CORBA::Environment &
-                                                 /*ACE_TRY_ENV*/)
+TAO_GIOP_Message_Connectors::write_reply_header	(TAO_OutputCDR & /*cdr*/,
+						 TAO_Pluggable_Reply_Params & /*params*/,
+						 CORBA::Environment &
+						 /*ACE_TRY_ENV*/)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
    ACE_NOTSUP_RETURN (0);
@@ -211,56 +211,56 @@ TAO_GIOP_Message_Connectors::write_reply_header (TAO_OutputCDR & /*cdr*/,
 CORBA::Boolean
 TAO_GIOP_Message_Connector_10::
   write_request_header (const TAO_Operation_Details &opdetails,
-                        TAO_Target_Specification &spec,
-                        TAO_OutputCDR &msg)
+			TAO_Target_Specification &spec,
+			TAO_OutputCDR &msg)
 {
-  // This is sepecific to GIOP 1.1. So put them here
-  msg << opdetails.service_info ();
+  // This is sepecific to GIOP 1.1. So put them	here
+  msg << opdetails.service_info	();
 
   // First the request id
   msg << opdetails.request_id ();
 
-  const CORBA::Octet response_flags = opdetails.response_flags ();
+  const	CORBA::Octet response_flags = opdetails.response_flags ();
 
-   // @@ (JP) Temporary hack until all of GIOP 1.2 is implemented.
-  if (response_flags == TAO_TWOWAY_RESPONSE_FLAG)
-    msg << CORBA::Any::from_octet (1);
+   // @@ (JP) Temporary	hack until all of GIOP 1.2 is implemented.
+  if (response_flags ==	TAO_TWOWAY_RESPONSE_FLAG)
+    msg	<< CORBA::Any::from_octet (1);
   else
-    msg << CORBA::Any::from_octet (0);
+    msg	<< CORBA::Any::from_octet (0);
 
-  // In this case we cannot recognise anything other than the Object
-  // key as the address disposition variable. But we do a sanity check
+  // In	this case we cannot recognise anything other than the Object
+  // key as the	address	disposition variable. But we do	a sanity check
   // anyway.
-  const TAO_ObjectKey *key = spec.object_key ();
+  const	TAO_ObjectKey *key = spec.object_key ();
   if (key)
     {
-      // Put in the object key
+      // Put in	the object key
       msg << *key;
     }
   else
     {
       if (TAO_debug_level)
-        ACE_DEBUG ((LM_DEBUG,
-                    ACE_TEXT ("(%N |%l) Unable to handle this request \n")));
+	ACE_DEBUG ((LM_DEBUG,
+		    ACE_TEXT ("(%N |%l)	Unable to handle this request \n")));
       return 0;
     }
 
   msg.write_string (opdetails.opname_len (),
-                    opdetails.opname ());
+		    opdetails.opname ());
 
   // Last element of request header is the principal; no portable way
-  // to get it, we just pass empty principal (convention: indicates
-  // "anybody").  Steps upward in security include passing an
-  // unverified user ID, and then verifying the message (i.e. a dummy
-  // service context entry is set up to hold a digital signature for
-  // this message, then patched shortly before it's sent).
+  // to	get it,	we just	pass empty principal (convention: indicates
+  // "anybody").  Steps	upward in security include passing an
+  // unverified	user ID, and then verifying the	message	(i.e. a	dummy
+  // service context entry is set up to	hold a digital signature for
+  // this message, then	patched	shortly	before it's sent).
 
   /***** This has been deprecated in the 2.4 spec ******/
-  //static CORBA::Principal_ptr principal = 0;
-  //msg << principal;
+  //static CORBA::Principal_ptr	principal = 0;
+  //msg	<< principal;
 
   // This is now introduced in 2.4 spec
-  CORBA::OctetSeq req_principal (0);
+  CORBA::OctetSeq req_principal	(0);
   req_principal.length (0);
   msg << req_principal;
 
@@ -276,15 +276,15 @@ TAO_GIOP_Message_Connector_10::
 CORBA::Boolean
 TAO_GIOP_Message_Connector_10::
   write_locate_request_header (CORBA::ULong request_id,
-                               TAO_Target_Specification &spec,
-                               TAO_OutputCDR &msg)
+			       TAO_Target_Specification	&spec,
+			       TAO_OutputCDR &msg)
 {
   msg << request_id;
 
-  // In this case we cannot recognise anything other than the Object
-  // key as the address disposition variable. But we do a sanity check
+  // In	this case we cannot recognise anything other than the Object
+  // key as the	address	disposition variable. But we do	a sanity check
   // anyway.
-  const TAO_ObjectKey *key = spec.object_key ();
+  const	TAO_ObjectKey *key = spec.object_key ();
   if (key)
     {
       // Everything is fine
@@ -293,8 +293,8 @@ TAO_GIOP_Message_Connector_10::
   else
     {
       if (TAO_debug_level)
-        ACE_DEBUG ((LM_DEBUG,
-                    ACE_TEXT ("(%N | %l) Unable to handle this request \n")));
+	ACE_DEBUG ((LM_DEBUG,
+		    ACE_TEXT ("(%N | %l) Unable	to handle this request \n")));
       return 0;
     }
 
@@ -305,51 +305,51 @@ TAO_GIOP_Message_Connector_10::
 int
 TAO_GIOP_Message_Connector_10::
   parse_reply (TAO_Message_State_Factory &mesg_state,
-               TAO_Pluggable_Reply_Params &params)
+	       TAO_Pluggable_Reply_Params &params)
 
 {
   // Cast to the GIOP Message state
-  TAO_GIOP_Message_State *state = ACE_dynamic_cast (TAO_GIOP_Message_State *,
-                                                    &mesg_state);
+  TAO_GIOP_Message_State *state	= ACE_dynamic_cast (TAO_GIOP_Message_State *,
+						    &mesg_state);
 
   switch (state->message_type)
     {
     case TAO_GIOP_REQUEST:
       // In GIOP 1.0 and GIOP 1.1 this is an error,
       ACE_ERROR_RETURN ((LM_ERROR,
-                         ACE_TEXT ("TAO (%P|%t) TAO_GIOP_Message_Connector_10::parse_reply: ")
-                         ACE_TEXT ("request.\n")),
-                        -1);
+			 ACE_TEXT ("TAO	(%P|%t)	TAO_GIOP_Message_Connector_10::parse_reply: ")
+			 ACE_TEXT ("request.\n")),
+			-1);
 
     case TAO_GIOP_CANCELREQUEST:
     case TAO_GIOP_LOCATEREQUEST:
       // Errors
     case TAO_GIOP_CLOSECONNECTION:
       default:
-        ACE_ERROR_RETURN ((LM_ERROR,
-                           ACE_TEXT ("TAO (%P|%t) %N:%l parse_reply: ")
-                           ACE_TEXT ("wrong message.\n")),
-                          -1);
+	ACE_ERROR_RETURN ((LM_ERROR,
+			   ACE_TEXT ("TAO (%P|%t) %N:%l	parse_reply: ")
+			   ACE_TEXT ("wrong message.\n")),
+			  -1);
     case TAO_GIOP_LOCATEREPLY:
       if (this->parse_locate_reply (*state,
-                                    params) == -1)
-        return -1;
+				    params) == -1)
+	return -1;
       break;
     case TAO_GIOP_REPLY:
       if ((state->cdr >> params.svc_ctx_) == 0)
-        {
-          if (TAO_debug_level > 0)
-            ACE_DEBUG ((LM_DEBUG,
-                        ACE_TEXT ("TAO (%P|%t) parse_reply, ")
-                        ACE_TEXT ("extracting context\n")));
-          return -1;
-        }
+	{
+	  if (TAO_debug_level >	0)
+	    ACE_DEBUG ((LM_DEBUG,
+			ACE_TEXT ("TAO (%P|%t) parse_reply, ")
+			ACE_TEXT ("extracting context\n")));
+	  return -1;
+	}
       if (TAO_GIOP_Message_Connectors::parse_reply (*state,
-                                                    params) == -1)
-        return -1;
+						    params) == -1)
+	return -1;
       break;
     case TAO_GIOP_FRAGMENT:
-      // Never happens: why??
+      // Never happens:	why??
       break;
     }
 
@@ -357,14 +357,14 @@ TAO_GIOP_Message_Connector_10::
 }
 
 CORBA::Octet
-TAO_GIOP_Message_Connector_10:: major_version (void)
+TAO_GIOP_Message_Connector_10::	major_version (void)
 {
   // Any harm in hardcoding??
-  return (CORBA::Octet) 1;
+  return (CORBA::Octet)	1;
 }
 
 CORBA::Octet
-TAO_GIOP_Message_Connector_10:: minor_version (void)
+TAO_GIOP_Message_Connector_10::	minor_version (void)
 {
   // Any harm in hardcoding??
   return 0;
@@ -376,10 +376,10 @@ TAO_GIOP_Message_Connector_10:: minor_version (void)
 //////////////////////////////////////////////////////////////////
 
 CORBA::Octet
-TAO_GIOP_Message_Connector_11:: minor_version (void)
+TAO_GIOP_Message_Connector_11::	minor_version (void)
 {
   // Any harm in hardcoding??
-  return (CORBA::Octet) 1;
+  return (CORBA::Octet)	1;
 }
 
 ///////////////////////////////////////////////////////////////////
@@ -389,64 +389,67 @@ TAO_GIOP_Message_Connector_11:: minor_version (void)
 CORBA::Boolean
 TAO_GIOP_Message_Connector_12::
   write_request_header (const TAO_Operation_Details &opdetails,
-                        TAO_Target_Specification &spec,
-                        TAO_OutputCDR &msg)
+			TAO_Target_Specification &spec,
+			TAO_OutputCDR &msg)
 {
   // First the request id
   msg << opdetails.request_id ();
 
-  const CORBA::Octet response_flags = opdetails.response_flags ();
+  const	CORBA::Octet response_flags = opdetails.response_flags ();
 
-  // Here are the Octet values for different policies
-  // '00000000' for SYNC_NONE
-  // '00000000' for SYNC_WITH_TRANSPORT
-  // '00000010' for SYNC_WITH_SERVER
-  // '00000011' for SYNC_WITH_TARGET
-  // '00000011' for regular two ways, but if they are invoked via a
+  // Here are the Octet	values for different policies
+  // '00000000'	for SYNC_NONE
+  // '00000000'	for SYNC_WITH_TRANSPORT
+  // '00000010'	for SYNC_WITH_SERVER
+  // '00000011'	for SYNC_WITH_TARGET
+  // '00000011'	for regular two	ways, but if they are invoked via a
   // DII with INV_NO_RESPONSE flag set then we need to send '00000001'
   //
-  // We have not implemented the policy INV_NO_RESPONSE for DII.
-  if (response_flags == TAO_TWOWAY_RESPONSE_FLAG)
-    msg << CORBA::Any::from_octet (3);
-  // Second the response flags
-  // Sync scope - ignored by server if request is not oneway.
+  // We	have not implemented the policy	INV_NO_RESPONSE	for DII.
+  if (response_flags ==	TAO_TWOWAY_RESPONSE_FLAG)
+    msg	<< CORBA::Any::from_octet (3);
+  // Second the	response flags
+  // Sync scope	- ignored by server if request is not oneway.
   else if (response_flags == CORBA::Octet (TAO::SYNC_NONE) ||
-           response_flags == CORBA::Octet (TAO::SYNC_WITH_TRANSPORT) ||
-           response_flags == CORBA::Octet (TAO::SYNC_EAGER_BUFFERING) ||
-           response_flags == CORBA::Octet (TAO::SYNC_DELAYED_BUFFERING))
+	   response_flags == CORBA::Octet (TAO::SYNC_WITH_TRANSPORT) ||
+	   response_flags == CORBA::Octet (TAO::SYNC_EAGER_BUFFERING) ||
+	   response_flags == CORBA::Octet (TAO::SYNC_DELAYED_BUFFERING))
     // No response required.
-    msg << CORBA::Any::from_octet (0);
+    msg	<< CORBA::Any::from_octet (0);
 
   else if (response_flags == CORBA::Octet (TAO::SYNC_WITH_SERVER))
-    // Return before dispatching to the servant
-    msg << CORBA::Any::from_octet (1);
+    // Return before dispatching to the	servant
+    msg	<< CORBA::Any::from_octet (1);
 
   else if (response_flags == CORBA::Octet (TAO::SYNC_WITH_TARGET))
-    // Return after dispatching servant.
-    msg << CORBA::Any::from_octet (3);
+    // Return after dispatching	servant.
+    msg	<< CORBA::Any::from_octet (3);
   else
-    // Until more flags are defined by the OMG.
+    // Until more flags	are defined by the OMG.
     return 0;
 
   // The reserved field
   CORBA::Octet reserved[3] = {0, 0, 0};
 
-  msg.write_octet_array (reserved, 3);
+  msg.write_octet_array	(reserved, 3);
 
   if (this->marshall_target_spec (spec,
-                                  msg) == 0)
+				  msg) == 0)
     return 0;
 
   // Write the operation name
   msg.write_string (opdetails.opname_len (),
-                    opdetails.opname ());
+		    opdetails.opname ());
 
   // Write the service context list
-  msg << opdetails.service_info ();
+  msg << opdetails.service_info	();
 
-  // We need to align the pointer
-  if (msg.align_write_ptr (TAO_GIOP_MESSAGE_ALIGN_PTR) == -1)
-    return 0;
+  // We	align the pointer only if the operation	has arguments.
+  if (opdetails.argument_flag ())
+    {
+      if (msg.align_write_ptr (TAO_GIOP_MESSAGE_ALIGN_PTR) == -1)
+	return 0;
+    }
 
   return 1;
 }
@@ -455,120 +458,122 @@ TAO_GIOP_Message_Connector_12::
 CORBA::Boolean
 TAO_GIOP_Message_Connector_12::
   write_locate_request_header (CORBA::ULong request_id,
-                               TAO_Target_Specification &spec,
-                               TAO_OutputCDR &msg)
+			       TAO_Target_Specification	&spec,
+			       TAO_OutputCDR &msg)
 {
   // Write the request id
   msg << request_id;
 
   // Write the target address
   if (this->marshall_target_spec (spec,
-                                  msg) == 0)
+				  msg) == 0)
     return 0;
 
-  // We need to align the pointer
-  if (msg.align_write_ptr (TAO_GIOP_MESSAGE_ALIGN_PTR) == -1)
-    return 0;
+  // I dont think we need to align the pointer to an 8 byte boundary
+  // here.
+  // We	need to	align the pointer
+  //  if (msg.align_write_ptr (TAO_GIOP_MESSAGE_ALIGN_PTR) == -1)
+  //  return 0;
 
   // Return success
   return 1;
 }
 
 CORBA::Octet
-TAO_GIOP_Message_Connector_12:: major_version (void)
+TAO_GIOP_Message_Connector_12::	major_version (void)
 {
   // Any harm in hardcoding??
-  return (CORBA::Octet) 1;
+  return (CORBA::Octet)	1;
 }
 
 CORBA::Octet
-TAO_GIOP_Message_Connector_12:: minor_version (void)
+TAO_GIOP_Message_Connector_12::	minor_version (void)
 {
   // Any harm in hardcoding??
-  return (CORBA::Octet) 2;
+  return (CORBA::Octet)	2;
 }
 
 
 CORBA::Boolean
 TAO_GIOP_Message_Connector_12::
   marshall_target_spec (TAO_Target_Specification &spec,
-                        TAO_OutputCDR &msg)
+			TAO_OutputCDR &msg)
 {
   switch (spec.specifier ())
     {
     case TAO_Target_Specification::Key_Addr:
       {
-        // As this is a union send in the discriminant first
-        msg << GIOP::KeyAddr;
-
-        // Get the object key
-        const TAO_ObjectKey *key = spec.object_key ();
-        if (key)
-          {
-            // Marshall in the object key
-            msg << *key;
-          }
-        else
-          {
-            if (TAO_debug_level)
-              ACE_DEBUG ((LM_DEBUG,
-                          ACE_TEXT ("(%N |%l) Unable to handle this request \n")));
-            return 0;
-          }
-        break;
+	// As this is a	union send in the discriminant first
+	msg << GIOP::KeyAddr;
+
+	// Get the object key
+	const TAO_ObjectKey *key = spec.object_key ();
+	if (key)
+	  {
+	    // Marshall	in the object key
+	    msg	<< *key;
+	  }
+	else
+	  {
+	    if (TAO_debug_level)
+	      ACE_DEBUG	((LM_DEBUG,
+			  ACE_TEXT ("(%N |%l) Unable to	handle this request \n")));
+	    return 0;
+	  }
+	break;
       }
     case TAO_Target_Specification::Profile_Addr:
       {
-        // As this is a union send in the discriminant first
-        msg << GIOP::ProfileAddr;
-
-        // Get the profile
-        const IOP::TaggedProfile *pfile = spec.profile ();
-
-        if (pfile)
-          {
-            // Marshall in the object key
-            msg << *pfile;
-          }
-        else
-          {
-            if (TAO_debug_level)
-              ACE_DEBUG ((LM_DEBUG,
-                          ACE_TEXT ("(%N |%l) Unable to handle this request \n")));
-            return 0;
-          }
-        break;
+	// As this is a	union send in the discriminant first
+	msg << GIOP::ProfileAddr;
+
+	// Get the profile
+	const IOP::TaggedProfile *pfile	= spec.profile ();
+
+	if (pfile)
+	  {
+	    // Marshall	in the object key
+	    msg	<< *pfile;
+	  }
+	else
+	  {
+	    if (TAO_debug_level)
+	      ACE_DEBUG	((LM_DEBUG,
+			  ACE_TEXT ("(%N |%l) Unable to	handle this request \n")));
+	    return 0;
+	  }
+	break;
       }
     case TAO_Target_Specification::Reference_Addr:
       {
-        // As this is a union send in the discriminant first
-        msg << GIOP::ReferenceAddr;
-
-        // Get the IOR
-        IOP::IOR *ior;
-        CORBA::ULong index = spec.iop_ior (ior);
-
-        if (ior)
-          {
-            // This is a struct IORAddressingInfo. So, marshall each
-            // member of the struct one after another in the order
-            // defined.
-            msg << index;
-            msg << *ior;
-          }
-        else
-          {
-            if (TAO_debug_level)
-            ACE_DEBUG ((LM_DEBUG,
-                        ACE_TEXT ("(%N |%l) Unable to handle this request \n")));
-            return 0;
-          }
-        break;
+	// As this is a	union send in the discriminant first
+	msg << GIOP::ReferenceAddr;
+
+	// Get the IOR
+	IOP::IOR *ior;
+	CORBA::ULong index = spec.iop_ior (ior);
+
+	if (ior)
+	  {
+	    // This is a struct	IORAddressingInfo. So, marshall	each
+	    // member of the struct one	after another in the order
+	    // defined.
+	    msg	<< index;
+	    msg	<< *ior;
+	  }
+	else
+	  {
+	    if (TAO_debug_level)
+	    ACE_DEBUG ((LM_DEBUG,
+			ACE_TEXT ("(%N |%l) Unable to handle this request \n")));
+	    return 0;
+	  }
+	break;
       }
     default:
       if (TAO_debug_level)
-        ACE_DEBUG ((LM_DEBUG,
-                    ACE_TEXT ("(%N |%l) Unable to handle this request \n")));
+	ACE_DEBUG ((LM_DEBUG,
+		    ACE_TEXT ("(%N |%l)	Unable to handle this request \n")));
       return 0;
     }
 
@@ -578,50 +583,50 @@ TAO_GIOP_Message_Connector_12::
 int
 TAO_GIOP_Message_Connector_12::
 parse_reply (TAO_Message_State_Factory &mesg_state,
-             TAO_Pluggable_Reply_Params &params)
+	     TAO_Pluggable_Reply_Params	&params)
 {
   // Cast to the GIOP Message state
-  TAO_GIOP_Message_State *state = ACE_dynamic_cast (TAO_GIOP_Message_State *,
-                                                    &mesg_state);
+  TAO_GIOP_Message_State *state	= ACE_dynamic_cast (TAO_GIOP_Message_State *,
+						    &mesg_state);
 
 
   switch (state->message_type)
     {
     case TAO_GIOP_REQUEST:
       // We could get this in Bi_Dir GIOP
-      // So, we take some action.
+      // So, we	take some action.
       break;
     case TAO_GIOP_CANCELREQUEST:
     case TAO_GIOP_LOCATEREQUEST:
       // Errors
     case TAO_GIOP_CLOSECONNECTION:
       default:
-        ACE_ERROR_RETURN ((LM_ERROR,
-                           ACE_TEXT ("TAO (%P|%t) %N:%l parse_reply: ")
-                           ACE_TEXT ("wrong message.\n")),
-                          -1);
+	ACE_ERROR_RETURN ((LM_ERROR,
+			   ACE_TEXT ("TAO (%P|%t) %N:%l	parse_reply: ")
+			   ACE_TEXT ("wrong message.\n")),
+			  -1);
     case TAO_GIOP_LOCATEREPLY:
       if (this->parse_locate_reply (*state,
-                                    params) == -1)
-        return -1;
+				    params) == -1)
+	return -1;
       break;
     case TAO_GIOP_REPLY:
       if (TAO_GIOP_Message_Connectors::parse_reply (*state,
-                                                    params)
-          == -1)
-        return -1;
+						    params)
+	  == -1)
+	return -1;
       if ((state->cdr >> params.svc_ctx_) == 0)
-        {
-          if (TAO_debug_level > 0)
-            ACE_DEBUG ((LM_DEBUG,
-                        ACE_TEXT ("TAO (%P|%t) parse_reply, ")
-                        ACE_TEXT ("extracting context\n")));
-          return -1;
-        }
+	{
+	  if (TAO_debug_level >	0)
+	    ACE_DEBUG ((LM_DEBUG,
+			ACE_TEXT ("TAO (%P|%t) parse_reply, ")
+			ACE_TEXT ("extracting context\n")));
+	  return -1;
+	}
       // Rest of the stuff after the switch
       break;
     case TAO_GIOP_FRAGMENT:
-      // Never happens: why??
+      // Never happens:	why??
       break;
     }
 
diff --git a/TAO/tao/IIOP_Connector.cpp b/TAO/tao/IIOP_Connector.cpp
index 8c6cc9182f4..21175313bf7 100644
--- a/TAO/tao/IIOP_Connector.cpp
+++ b/TAO/tao/IIOP_Connector.cpp
@@ -30,6 +30,11 @@ TAO_IIOP_Connect_Creation_Strategy::
 
 }
 
+TAO_IIOP_Connect_Creation_Strategy::
+  ~TAO_IIOP_Connect_Creation_Strategy (void)
+{
+}
+
 int
 TAO_IIOP_Connect_Creation_Strategy::make_svc_handler
   (TAO_IIOP_Client_Connection_Handler *&sh)
diff --git a/TAO/tao/IIOP_Connector.h b/TAO/tao/IIOP_Connector.h
index 1f1a85a8984..3a0abe1e6cf 100644
--- a/TAO/tao/IIOP_Connector.h
+++ b/TAO/tao/IIOP_Connector.h
@@ -55,6 +55,9 @@ public:
   // state/info to the service handler upon creation.  Currently used
   // by IIOP and UIOP to pass protocol configuration properties.
 
+  ~TAO_IIOP_Connect_Creation_Strategy (void);
+  // Default destructor g++, 2.7.2 seems to be needing this
+
   virtual int make_svc_handler (TAO_IIOP_Client_Connection_Handler *&sh);
   // Makes TAO_IIOP_Client_Connection_Handlers
 
diff --git a/TAO/tao/Invocation.cpp b/TAO/tao/Invocation.cpp
index 22bffffb184..447ad42f032 100644
--- a/TAO/tao/Invocation.cpp
+++ b/TAO/tao/Invocation.cpp
@@ -55,32 +55,33 @@ enum
 
 // Setup Timeprobes
 ACE_TIMEPROBE_EVENT_DESCRIPTIONS (TAO_Invocation_Timeprobe_Description,
-                                  TAO_GIOP_INVOCATION_INVOKE_START);
+				  TAO_GIOP_INVOCATION_INVOKE_START);
 
-#endif /* ACE_ENABLE_TIMEPROBES */
+#endif /* ACE_ENABLE_TIMEPROBES	*/
 
-// Normal invocations don't involve any heap al; messages are
-// constructed into stack-based buffers and are read into those
-// buffers too.  Larger buffers are heap-allocated as needed.
+// Normal invocations don't involve any	heap al; messages are
+// constructed into stack-based	buffers	and are	read into those
+// buffers too.	 Larger	buffers	are heap-allocated as needed.
 //
-// The constraint on request IDs is that no two requests from the same
-// client with the same ID are outstanding at the same time.  In
-// single threaded environments, this is met by any number whatever.
-// When multiple threads are used, we eliminate the need for any
-// locked state by using the thread ID as the request ID, since any
-// given thread has at most one request outstanding at a time.
+// The constraint on request IDs is that no two	requests from the same
+// client with the same	ID are outstanding at the same time.  In
+// single threaded environments, this is met by	any number whatever.
+// When	multiple threads are used, we eliminate	the need for any
+// locked state	by using the thread ID as the request ID, since	any
+// given thread	has at most one	request	outstanding at a time.
 //
 // NOTE: this means that if "deferred synchronous" calls get
-// supported, it's done by creating a thread internally to make the
+// supported, it's done	by creating a thread internally	to make	the
 // call.  That is less disruptive (and error prone) in general than
-// restructuring an ORB core in terms of asynchrony.
+// restructuring an ORB	core in	terms of asynchrony.
 // ****************************************************************
 
 TAO_GIOP_Invocation::TAO_GIOP_Invocation (void)
   : stub_ (0),
-    op_details_ (0,
-                 0),
-    out_stream_ (),
+    op_details_	(0,
+		 0,
+		 0),
+    out_stream_	(),
     orb_core_ (0),
     transport_ (0),
     endpoint_selector_ (0),
@@ -95,20 +96,22 @@ TAO_GIOP_Invocation::TAO_GIOP_Invocation (void)
 }
 
 TAO_GIOP_Invocation::TAO_GIOP_Invocation (TAO_Stub *stub,
-                                          const char *operation,
-                                          CORBA::ULong opname_len,
-                                          TAO_ORB_Core *orb_core)
+					  const	char *operation,
+					  CORBA::ULong opname_len,
+					  CORBA::Boolean argument_flag,
+					  TAO_ORB_Core *orb_core)
   : stub_ (stub),
-    op_details_ (operation,
-                 opname_len),
-    out_stream_ (this->buffer_,
-                 sizeof this->buffer_, /* ACE_CDR::DEFAULT_BUFSIZE */
-                 TAO_ENCAP_BYTE_ORDER,
-                 orb_core->output_cdr_buffer_allocator (),
-                 orb_core->output_cdr_dblock_allocator (),
-                 orb_core->orb_params ()->cdr_memcpy_tradeoff (),
-                 orb_core->to_iso8859 (),
-                 orb_core->to_unicode ()),
+    op_details_	(operation,
+		 opname_len,
+		 argument_flag),
+    out_stream_	(this->buffer_,
+		 sizeof	this->buffer_, /* ACE_CDR::DEFAULT_BUFSIZE */
+		 TAO_ENCAP_BYTE_ORDER,
+		 orb_core->output_cdr_buffer_allocator (),
+		 orb_core->output_cdr_dblock_allocator (),
+		 orb_core->orb_params ()->cdr_memcpy_tradeoff (),
+		 orb_core->to_iso8859 (),
+		 orb_core->to_unicode ()),
     orb_core_ (orb_core),
     transport_ (0),
     endpoint_selector_ (0),
@@ -126,66 +129,66 @@ TAO_GIOP_Invocation::~TAO_GIOP_Invocation (void)
 {
 }
 
-// The public API involves creating an invocation, starting it, filling
+// The public API involves creating an invocation, starting it,	filling
 // in request parameters, actually performing the invocation, getting
-// response parameters, and then cleaning up.  Sometimes they must be
-// restarted (e.g. request forwarding).  This is the start/restart entry.
+// response parameters,	and then cleaning up.  Sometimes they must be
+// restarted (e.g. request forwarding).	 This is the start/restart entry.
 
 void
 TAO_GIOP_Invocation::start (CORBA::Environment &ACE_TRY_ENV)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (TAO_GIOP_INVOCATION_START_ENTER);
-  TAO_MINIMAL_TIMEPROBE (TAO_GIOP_INVOCATION_START_ENTER);
+  TAO_MINIMAL_TIMEPROBE	(TAO_GIOP_INVOCATION_START_ENTER);
 
   // First try to bind to the appropriate address.  We do that here
-  // since we may get forwarded to a different objref in the course of
-  // any given call, with new start () call each time.  It's not
+  // since we may get forwarded	to a different objref in the course of
+  // any given call, with new start () call each time.	It's not
   // cached in the objref data since the connections change
-  // asynchronously from objref invocations and this simplifies
-  // connection management.
-  // We also need to bind *before* marshalling, because different
-  // Profiles have different ObjectKeys, thus a change of Profile can
+  // asynchronously from objref	invocations and	this simplifies
+  // connection	management.
+  // We	also need to bind *before* marshalling,	because	different
+  // Profiles have different ObjectKeys, thus a	change of Profile can
   // result in different alignment for the buffer.
   //
-  // THREADING NOTE: this connection is reserved to this call.  Also,
-  // starting at this point in the call, new forwarding information
+  // THREADING NOTE: this connection is	reserved to this call.	Also,
+  // starting at this point in the call, new forwarding	information
   // will not be used until/unless the call is reissued.  Correctness
-  // is not affected, the call will just be forwarded later than it
-  // might be in a more complex implementation.
+  // is	not affected, the call will just be forwarded later than it
+  // might be in a more	complex	implementation.
 
-  // @@ assert is evil, it crashes the program, changed to an
+  // @@	assert is evil,	it crashes the program,	changed	to an
   // exception (coryan)
   // assert (this->stub_ != 0);
 
   if (this->stub_ == 0)
     {
-      ACE_THROW (CORBA::INTERNAL (
-                   CORBA_SystemException::_tao_minor_code (
-                     TAO_DEFAULT_MINOR_CODE,
-                     EINVAL),
-                CORBA::COMPLETED_NO));
+      ACE_THROW	(CORBA::INTERNAL (
+		   CORBA_SystemException::_tao_minor_code (
+		     TAO_DEFAULT_MINOR_CODE,
+		     EINVAL),
+		CORBA::COMPLETED_NO));
     }
 
   // Get a pointer to the connector registry, which might be in
-  // thread-specific storage, depending on the concurrency model.
+  // thread-specific storage, depending	on the concurrency model.
   TAO_Connector_Registry *conn_reg =
-    this->orb_core_->connector_registry ();
+    this->orb_core_->connector_registry	();
 
   if (conn_reg == 0)
     {
-      ACE_THROW (CORBA::INTERNAL (
-                   CORBA_SystemException::_tao_minor_code (
-                     TAO_DEFAULT_MINOR_CODE,
-                     EINVAL),
-                   CORBA::COMPLETED_NO));
+      ACE_THROW	(CORBA::INTERNAL (
+		   CORBA_SystemException::_tao_minor_code (
+		     TAO_DEFAULT_MINOR_CODE,
+		     EINVAL),
+		   CORBA::COMPLETED_NO));
     }
 
-  // Initialize endpoint selection strategy.
+  // Initialize	endpoint selection strategy.
   if (!this->is_selector_initialized_)
     {
       this->orb_core_->endpoint_selector_factory ()->get_selector (this,
-                                                                   ACE_TRY_ENV);
+								   ACE_TRY_ENV);
       ACE_CHECK;
       this->is_selector_initialized_ = 1;
     }
@@ -194,76 +197,76 @@ TAO_GIOP_Invocation::start (CORBA::Environment &ACE_TRY_ENV)
     {
       int has_timeout;
       this->orb_core_->call_timeout_hook (this->stub_,
-                                          has_timeout,
-                                          this->max_wait_time_value_);
+					  has_timeout,
+					  this->max_wait_time_value_);
       if (has_timeout)
-        {
-          this->max_wait_time_ = &this->max_wait_time_value_;
-        }
+	{
+	  this->max_wait_time_ = &this->max_wait_time_value_;
+	}
     }
 
   ACE_Countdown_Time countdown (this->max_wait_time_);
 
-  // Loop until a connection is established or there aren't any more
+  // Loop until	a connection is	established or there aren't any	more
   // profiles to try.
   for (;;)
     {
       // Allow loaded services to select the profile.
       if (this->stub_->service_profile_selection ())
-        {
-          this->profile_ = this->stub_->profile_in_use ();
-          this->endpoint_ = this->profile_->endpoint ();
-        }
+	{
+	  this->profile_ = this->stub_->profile_in_use ();
+	  this->endpoint_ = this->profile_->endpoint ();
+	}
       else
-        {
-          // If loaded services have nothing to say on
-          // profile/endpoint selection, let the strategy do the work.
-          this->endpoint_selector_->select_endpoint (this,
-                                                     ACE_TRY_ENV);
-          ACE_CHECK;
-        }
+	{
+	  // If	loaded services	have nothing to	say on
+	  // profile/endpoint selection, let the strategy do the work.
+	  this->endpoint_selector_->select_endpoint (this,
+						     ACE_TRY_ENV);
+	  ACE_CHECK;
+	}
 
       // Get the transport object.
       if (this->transport_ != 0)
-        {
-          this->transport_->idle ();
-        }
+	{
+	  this->transport_->idle ();
+	}
 
-      // Obtain a connection.
+      // Obtain	a connection.
       int result = conn_reg->connect (this->endpoint_,
-                                      this->transport_,
-                                      this->max_wait_time_,
-                                      ACE_TRY_ENV);
+				      this->transport_,
+				      this->max_wait_time_,
+				      ACE_TRY_ENV);
       ACE_CHECK;
 
       if (result == 0)
-        {
-          // Now that we have the client connection handler object we need to
-          // set the right messaging protocol for in the client side transport.
-          const TAO_GIOP_Version& version = this->profile_->version ();
-          result = this->transport_->messaging_init (version.major,
-                                                     version.minor);
-          if (result == -1)
-            {
-              if (TAO_debug_level > 0)
-                {
-                  ACE_DEBUG ((LM_DEBUG,
-                              ACE_TEXT ("(%N|%l|%p|%t) ")
-                              ACE_TEXT ("messaging_init() failed\n")));
-                }
-            }
-          else
-            break;
-        }
-
-      if (errno == ETIME)
-        {
-          ACE_THROW (CORBA::TIMEOUT (
-              CORBA_SystemException::_tao_minor_code (
-                  TAO_TIMEOUT_CONNECT_MINOR_CODE,
-                  errno),
-              CORBA::COMPLETED_NO));
-        }
+	{
+	  // Now that we have the client connection handler object we need to
+	  // set the right messaging protocol for in the client	side transport.
+	  const	TAO_GIOP_Version& version = this->profile_->version ();
+	  result = this->transport_->messaging_init (version.major,
+						     version.minor);
+	  if (result ==	-1)
+	    {
+	      if (TAO_debug_level > 0)
+		{
+		  ACE_DEBUG ((LM_DEBUG,
+			      ACE_TEXT ("(%N|%l|%p|%t) ")
+			      ACE_TEXT ("messaging_init() failed\n")));
+		}
+	    }
+	  else
+	    break;
+	}
+
+      if (errno	== ETIME)
+	{
+	  ACE_THROW (CORBA::TIMEOUT (
+	      CORBA_SystemException::_tao_minor_code (
+		  TAO_TIMEOUT_CONNECT_MINOR_CODE,
+		  errno),
+	      CORBA::COMPLETED_NO));
+	}
 
       // Try another profile/endpoint.
       this->endpoint_selector_->next (this, ACE_TRY_ENV);
@@ -274,129 +277,129 @@ TAO_GIOP_Invocation::start (CORBA::Environment &ACE_TRY_ENV)
 
   // Obtain unique request id from the RMS.
   this->op_details_.request_id (
-        this->transport_->tms ()->request_id ());
+	this->transport_->tms ()->request_id ());
 
-  // Make sure that you have the right object key
+  // Make sure that you	have the right object key
   this->target_spec_.target_specifier (this->profile_->object_key ());
 }
 
 void
 TAO_GIOP_Invocation::prepare_header (CORBA::Octet response_flags,
-                                     CORBA_Environment &ACE_TRY_ENV)
+				     CORBA_Environment &ACE_TRY_ENV)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   // Then fill in the rest of the RequestHeader
 
   // Fill up the service context lists
   // First lookup at the services to see whether they have anything to
-  // add to the service context lists
-  this->orb_core_->service_context_list (this->stub_,
-                                         this->service_info (),
-                                         this->restart_flag_,
-                                         ACE_TRY_ENV);
+  // add to the	service	context	lists
+  this->orb_core_->service_context_list	(this->stub_,
+					 this->service_info (),
+					 this->restart_flag_,
+					 ACE_TRY_ENV);
   ACE_CHECK;
 
   this->add_rt_service_context (ACE_TRY_ENV);
   ACE_CHECK;
 
-  // The target specification mode
+  // The target	specification mode
   if (this->stub_->addressing_mode () ==
       TAO_Target_Specification::Key_Addr)
     {
       this->target_spec_.target_specifier (
-            this->profile_->object_key ());
+	    this->profile_->object_key ());
     }
-  else if (this->stub_->addressing_mode ()
-             == TAO_Target_Specification::Profile_Addr)
+  else if (this->stub_->addressing_mode	()
+	     ==	TAO_Target_Specification::Profile_Addr)
     {
       this->target_spec_.target_specifier (
-                this->profile_->create_tagged_profile ()
-              );
+		this->profile_->create_tagged_profile ()
+	      );
     }
-  else if (this->stub_->addressing_mode ()
-             == TAO_Target_Specification::Reference_Addr)
+  else if (this->stub_->addressing_mode	()
+	     ==	TAO_Target_Specification::Reference_Addr)
     {
-      // We need to call the method seperately. If there is no
-      // IOP::IOR info, the call would create the info and return the
+      // We need to call the method seperately.	If there is no
+      // IOP::IOR info,	the call would create the info and return the
       // index that we need.
-      // @@Will not work for RT CORBA as the index we get would be
+      // @@Will	not work for RT	CORBA as the index we get would	be
       // wrong.
       CORBA::ULong index = this->create_ior_info ();
       this->target_spec_.target_specifier (this->ior_info_,
-                                           index);
+					   index);
     }
 
-  // Update the response flags
+  // Update the	response flags
   this->op_details_.response_flags (response_flags);
 
   // Send the request for the header
   if (this->transport_->send_request_header (this->op_details_,
-                                             this->target_spec_,
-                                             this->out_stream_)
-        == 0)
+					     this->target_spec_,
+					     this->out_stream_)
+	== 0)
     {
-      ACE_THROW (CORBA::MARSHAL ());
+      ACE_THROW	(CORBA::MARSHAL	());
     }
 }
 
 
-// Send request.
+// Send	request.
 int
 TAO_GIOP_Invocation::invoke (CORBA::Boolean is_roundtrip,
-                             CORBA::Environment &ACE_TRY_ENV)
+			     CORBA::Environment	&ACE_TRY_ENV)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_Countdown_Time countdown (this->max_wait_time_);
 
   if (this->transport_ == 0)
     {
-      ACE_THROW_RETURN (CORBA::INTERNAL (),
-                        TAO_INVOKE_EXCEPTION);
+      ACE_THROW_RETURN (CORBA::INTERNAL	(),
+			TAO_INVOKE_EXCEPTION);
     }
 
-  // @@ Alex: the <is_roundtrip> flag will be tricky when we move to
-  //    AMI: now it is used both to indicate the the CORBA request in
-  //    a twoway and that the send_request() operation should block.
-  //    Even for oneways: with AMI it is possible to wait for a
-  //    response (empty) for oneways, just to make sure that they
-  //    arrive, there are policies to control that.
+  // @@	Alex: the <is_roundtrip> flag will be tricky when we move to
+  //	AMI: now it is used both to indicate the the CORBA request in
+  //	a twoway and that the send_request() operation should block.
+  //	Even for oneways: with AMI it is possible to wait for a
+  //	response (empty) for oneways, just to make sure	that they
+  //	arrive,	there are policies to control that.
 
   int result =
     this->transport_->send_request (this->stub_,
-                                    this->orb_core_,
-                                    this->out_stream_,
-                                    is_roundtrip,
-                                    this->max_wait_time_);
+				    this->orb_core_,
+				    this->out_stream_,
+				    is_roundtrip,
+				    this->max_wait_time_);
 
   //
-  // @@ highly desirable to know whether we wrote _any_ data; if
-  // we wrote none, then there's no chance the call completed and
-  // applications don't have to deal with those nasty
-  // indeterminate states where they can't immediatly tell if
+  // @@	highly desirable to know whether we wrote _any_	data; if
+  // we	wrote none, then there's no chance the call completed and
+  // applications don't	have to	deal with those	nasty
+  // indeterminate states where	they can't immediatly tell if
   // what's safe to do.
   //
-  // @@ also, there might have been a GIOP::CloseConnection
-  // message in the input queue.  If so, this request should be
-  // treated as a (full) "rebind" case.  Can't do that from this
-  // point in the code however!  Some minor restructuring needs to
+  // @@	also, there might have been a GIOP::CloseConnection
+  // message in	the input queue.  If so, this request should be
+  // treated as	a (full) "rebind" case.	 Can't do that from this
+  // point in the code however!	 Some minor restructuring needs	to
   // happen.
   //
 
-  if (result == -1)
+  if (result ==	-1)
     {
-      if (errno == ETIME)
-        {
-          ACE_THROW_RETURN (
-              CORBA::TIMEOUT (
-                  CORBA_SystemException::_tao_minor_code (
-                      TAO_TIMEOUT_SEND_MINOR_CODE,
-                      errno
-                    ),
-                  CORBA::COMPLETED_NO
-                ),
-              TAO_INVOKE_EXCEPTION
-            );
-        }
+      if (errno	== ETIME)
+	{
+	  ACE_THROW_RETURN (
+	      CORBA::TIMEOUT (
+		  CORBA_SystemException::_tao_minor_code (
+		      TAO_TIMEOUT_SEND_MINOR_CODE,
+		      errno
+		    ),
+		  CORBA::COMPLETED_NO
+		),
+	      TAO_INVOKE_EXCEPTION
+	    );
+	}
       this->transport_->close_connection ();
       this->transport_ = 0;
 
@@ -405,9 +408,9 @@ TAO_GIOP_Invocation::invoke (CORBA::Boolean is_roundtrip,
       return TAO_INVOKE_RESTART;
     }
 
-  // Indicate that the endpoint/profile was used successfully.
-  // @@ Maybe the right place to do this is once the reply is
-  //    received? But what about oneways?
+  // Indicate that the endpoint/profile	was used successfully.
+  // @@	Maybe the right	place to do this is once the reply is
+  //	received? But what about oneways?
   this->endpoint_selector_->success (this);
 
   return TAO_INVOKE_OK;
@@ -416,9 +419,9 @@ TAO_GIOP_Invocation::invoke (CORBA::Boolean is_roundtrip,
 int
 TAO_GIOP_Invocation::close_connection (void)
 {
-  // Special case of forwarding -- server was closing the
-  // connection, which just indicates resource constraints, not an
-  // error.  The client is effectively "forwarded" to the same
+  // Special case of forwarding	-- server was closing the
+  // connection, which just indicates resource constraints, not	an
+  // error.  The client	is effectively "forwarded" to the same
   // server!
   //
   // However, we must reinitialize the forwarding chain, since the
@@ -444,12 +447,12 @@ TAO_GIOP_Invocation::close_connection (void)
 
 int
 TAO_GIOP_Invocation::location_forward (TAO_InputCDR &inp_stream,
-                                       CORBA::Environment &ACE_TRY_ENV)
+				       CORBA::Environment &ACE_TRY_ENV)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
-  // It can be assumed that the GIOP header and the reply header
+  // It	can be assumed that the	GIOP header and	the reply header
   // are already handled. Further it can be assumed that the
-  // reply body contains an object reference to the new object.
+  // reply body	contains an object reference to	the new	object.
   // This object pointer will be now extracted.
 
   CORBA::Object_var object = 0;
@@ -457,23 +460,23 @@ TAO_GIOP_Invocation::location_forward (TAO_InputCDR &inp_stream,
   if ( (inp_stream >> object.inout ()) == 0)
     {
       ACE_THROW_RETURN (CORBA::MARSHAL (),
-                        TAO_INVOKE_EXCEPTION);
+			TAO_INVOKE_EXCEPTION);
     }
 
-  // The object pointer has to be changed to a TAO_Stub pointer
-  // in order to obtain the profiles.
+  // The object	pointer	has to be changed to a TAO_Stub	pointer
+  // in	order to obtain	the profiles.
   TAO_Stub *stubobj = object->_stubobj ();
 
   if (stubobj == 0)
     {
-      ACE_THROW_RETURN (CORBA::INTERNAL (),
-                        TAO_INVOKE_EXCEPTION);
+      ACE_THROW_RETURN (CORBA::INTERNAL	(),
+			TAO_INVOKE_EXCEPTION);
     }
 
-  // Modify the state as appropriate to include new forwarding profiles.
+  // Modify the	state as appropriate to	include	new forwarding profiles.
   this->endpoint_selector_->forward (this,
-                                     stubobj->base_profiles (),
-                                     ACE_TRY_ENV);
+				     stubobj->base_profiles (),
+				     ACE_TRY_ENV);
   ACE_CHECK_RETURN (TAO_INVOKE_EXCEPTION);
 
   return TAO_INVOKE_RESTART;
@@ -484,34 +487,34 @@ CORBA::ULong
 TAO_GIOP_Invocation::create_ior_info (void)
 {
   // Get the list of profiles
-  const TAO_MProfile &mprofile = this->stub_->base_profiles ();
+  const	TAO_MProfile &mprofile = this->stub_->base_profiles ();
 
   if (this->ior_info_.profiles.length () == 0)
     {
-      // We are making a copy, it is expensive. We want a copy of the
-      // profiles as we dont want to modify the profile set held by
+      // We are	making a copy, it is expensive.	We want	a copy of the
+      // profiles as we	dont want to modify the	profile	set held by
       // the Stub classes. We may want to hold a lock for doing
-      // that. To avoid unnecssary complications we make a copy and
+      // that. To avoid	unnecssary complications we make a copy	and
       // get the info
 
       // @@ There should be a better way to do this - Bala
       TAO_MProfile *multi_prof =
-        this->stub_->make_profiles ();
+	this->stub_->make_profiles ();
 
-      // Get the number of elements
+      // Get the number	of elements
       CORBA::ULong count = multi_prof->profile_count ();
 
-      // Set the number of elements in the sequence of tagged_profile
+      // Set the number	of elements in the sequence of tagged_profile
       this->ior_info_.profiles.length (count);
 
-      // Call the create_tagged_profile one every member of the
+      // Call the create_tagged_profile	one every member of the
       // profile and make the sequence
-      for (CORBA::ULong index = 0; index < count; ++index)
-        {
-          TAO_Profile *prof = multi_prof->get_profile (index);
+      for (CORBA::ULong	index =	0; index < count; ++index)
+	{
+	  TAO_Profile *prof = multi_prof->get_profile (index);
 
-          this->ior_info_.profiles[index] = prof->create_tagged_profile ();
-        }
+	  this->ior_info_.profiles[index] = prof->create_tagged_profile	();
+	}
 
       delete multi_prof;
     }
@@ -523,8 +526,8 @@ void
 TAO_GIOP_Invocation::add_rt_service_context (CORBA_Environment &ACE_TRY_ENV)
 {
   // RTCORBA-specific processing.
-  // If invocation target supports RTCORBA::CLIENT_PROPAGATED priority
-  // model, we must add IOP::RTCorbaPriority service context to the
+  // If	invocation target supports RTCORBA::CLIENT_PROPAGATED priority
+  // model, we must add	IOP::RTCorbaPriority service context to	the
   // list.
 
 #if (TAO_HAS_RT_CORBA == 1)
@@ -539,58 +542,58 @@ TAO_GIOP_Invocation::add_rt_service_context (CORBA_Environment &ACE_TRY_ENV)
   if (this->endpoint_selection_state_.priority_model_policy_)
     {
       if (this->endpoint_selection_state_.priority_model_policy_->
-          get_priority_model () == RTCORBA::CLIENT_PROPAGATED)
-        {
-          // Encapsulate the priority of the current thread into
-          // a service context.
-          TAO_OutputCDR cdr;
-          if ((cdr << ACE_OutputCDR::from_boolean (TAO_ENCAP_BYTE_ORDER)
-               == 0)
-              || (cdr << this->endpoint_selection_state_.client_priority_)
-              == 0)
-            ACE_THROW (CORBA::MARSHAL ());
-
-          IOP::ServiceContextList &context_list = this->service_info ();
-
-          CORBA::ULong l = context_list.length ();
-          context_list.length (l + 1);
-          context_list[l].context_id = IOP::RTCorbaPriority;
-
-          // Make a *copy* of the CDR stream...
-          CORBA::ULong length = cdr.total_length ();
-          context_list[l].context_data.length (length);
-          CORBA::Octet *buf = context_list[l].context_data.get_buffer ();
-
-          for (const ACE_Message_Block *i = cdr.begin ();
-               i != 0;
-               i = i->cont ())
-            {
-              ACE_OS::memcpy (buf,
-                              i->rd_ptr (),
-                              i->length ());
-              buf += i->length ();
-            }
-        }
+	  get_priority_model ()	== RTCORBA::CLIENT_PROPAGATED)
+	{
+	  // Encapsulate the priority of the current thread into
+	  // a service context.
+	  TAO_OutputCDR	cdr;
+	  if ((cdr << ACE_OutputCDR::from_boolean (TAO_ENCAP_BYTE_ORDER)
+	       == 0)
+	      || (cdr << this->endpoint_selection_state_.client_priority_)
+	      == 0)
+	    ACE_THROW (CORBA::MARSHAL ());
+
+	  IOP::ServiceContextList &context_list	= this->service_info ();
+
+	  CORBA::ULong l = context_list.length ();
+	  context_list.length (l + 1);
+	  context_list[l].context_id = IOP::RTCorbaPriority;
+
+	  // Make a *copy* of the CDR stream...
+	  CORBA::ULong length =	cdr.total_length ();
+	  context_list[l].context_data.length (length);
+	  CORBA::Octet *buf = context_list[l].context_data.get_buffer ();
+
+	  for (const ACE_Message_Block *i = cdr.begin ();
+	       i != 0;
+	       i = i->cont ())
+	    {
+	      ACE_OS::memcpy (buf,
+			      i->rd_ptr	(),
+			      i->length	());
+	      buf += i->length ();
+	    }
+	}
     }
   else
     {
       // The Object does not contain PriorityModel policy in its IOR.
-      // We must be talking to a non-RT ORB.  Do nothing.
+      // We must be talking to a non-RT	ORB.  Do nothing.
     }
 
-  this->rt_context_initialized_ = 1;
+  this->rt_context_initialized_	= 1;
 
 #else
   ACE_UNUSED_ARG (ACE_TRY_ENV);
 
-#endif /* TAO_HAS_RT_CORBA == 1 */
+#endif /* TAO_HAS_RT_CORBA == 1	*/
 }
 
 // ****************************************************************
 
 TAO_GIOP_Synch_Invocation::TAO_GIOP_Synch_Invocation (void)
-  : rd_ (0, 
-         this->op_details_.service_info ())
+  : rd_	(0,
+	 this->op_details_.service_info	())
 {
 }
 
@@ -604,88 +607,88 @@ TAO_GIOP_Synch_Invocation::~TAO_GIOP_Synch_Invocation (void)
 
 int
 TAO_GIOP_Synch_Invocation::invoke_i (CORBA::Boolean is_locate_request,
-                                     CORBA::Environment &ACE_TRY_ENV)
+				     CORBA::Environment	&ACE_TRY_ENV)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
-  // Register a reply dispatcher for this invocation. Use the
-  // preallocated reply dispatcher.
+  // Register a	reply dispatcher for this invocation. Use the
+  // preallocated reply	dispatcher.
 
   // Bind.
 
   TAO_Transport_Mux_Strategy *tms = this->transport_->tms ();
 
   TAO_Bind_Dispatcher_Guard dispatch_guard (this->op_details_.request_id(),
-                                            &this->rd_,
-                                            tms);
+					    &this->rd_,
+					    tms);
   int retval = dispatch_guard.status ();
 
-  if (retval == -1)
+  if (retval ==	-1)
     {
-      // @@ What is the right way to handle this error?
+      // @@ What is the	right way to handle this error?
       this->close_connection ();
 
-      ACE_THROW_RETURN (CORBA::INTERNAL (TAO_DEFAULT_MINOR_CODE,
-                                         CORBA::COMPLETED_NO),
-                        TAO_INVOKE_EXCEPTION);
+      ACE_THROW_RETURN (CORBA::INTERNAL	(TAO_DEFAULT_MINOR_CODE,
+					 CORBA::COMPLETED_NO),
+			TAO_INVOKE_EXCEPTION);
     }
 
   // Just send the request, without trying to wait for the reply.
   retval = TAO_GIOP_Invocation::invoke (1,
-                                        ACE_TRY_ENV);
+					ACE_TRY_ENV);
   ACE_CHECK_RETURN (retval);
 
-  if (retval != TAO_INVOKE_OK)
+  if (retval !=	TAO_INVOKE_OK)
     {
       return retval;
     }
 
   // This blocks until the response is read.  In the current version,
   // there is only one client thread that ever uses this connection,
-  // so most response messages are illegal.
+  // so	most response messages are illegal.
   //
-  // @@ In all MT environments, there's a cancellation point lurking
-  // here; need to investigate.  Client threads would frequently be
+  // @@	In all MT environments,	there's	a cancellation point lurking
+  // here; need	to investigate.	 Client	threads	would frequently be
   // canceled sometime during recv_request ... the correct action to
-  // take on being canceled is to issue a CancelRequest message to the
-  // server and then imediately let other client-side cancellation
+  // take on being canceled is to issue	a CancelRequest	message	to the
+  // server and	then imediately	let other client-side cancellation
   // handlers do their jobs.
   //
-  // In C++, that basically means to unwind the stack using almost
-  // normal procedures: all destructors should fire, and some "catch"
+  // In	C++, that basically means to unwind the	stack using almost
+  // normal procedures:	all destructors	should fire, and some "catch"
   // blocks should probably be able to handle things like releasing
-  // pointers. (Without unwinding the C++ stack, resources that must
-  // be freed by thread cancellation won't be freed, and the process
-  // won't continue to function correctly.)  The tricky part is that
+  // pointers. (Without	unwinding the C++ stack, resources that	must
+  // be	freed by thread	cancellation won't be freed, and the process
+  // won't continue to function	correctly.)  The tricky	part is	that
   // according to POSIX, all C stack frames must also have their
-  // (explicitly coded) handlers called.  We assume a POSIX.1c/C/C++
+  // (explicitly coded)	handlers called.  We assume a POSIX.1c/C/C++
   // environment.
 
   // Get the reply status.
 
   // Wait for the reply.
 
-  if (TAO_debug_level > 0 && this->max_wait_time_ != 0)
+  if (TAO_debug_level >	0 && this->max_wait_time_ != 0)
     {
       CORBA::ULong msecs = this->max_wait_time_->msec ();
 
-      ACE_DEBUG ((LM_DEBUG,
-                  ACE_TEXT ("TAO (%P|%t) Timeout on recv is <%u>\n"),
-                  msecs));
+      ACE_DEBUG	((LM_DEBUG,
+		  ACE_TEXT ("TAO (%P|%t) Timeout on recv is <%u>\n"),
+		  msecs));
     }
 
   int reply_error =
     this->transport_->wait_strategy ()->wait (this->max_wait_time_,
-                                              this->rd_.reply_received ());
+					      this->rd_.reply_received ());
 
 
-  if (TAO_debug_level > 0 && this->max_wait_time_ != 0)
+  if (TAO_debug_level >	0 && this->max_wait_time_ != 0)
     {
       CORBA::ULong msecs = this->max_wait_time_->msec ();
 
-      ACE_DEBUG ((LM_DEBUG,
-                  ACE_TEXT ("TAO (%P|%t) Timeout after recv is <%u> status <%d>\n"),
-                  msecs,
-                  reply_error));
+      ACE_DEBUG	((LM_DEBUG,
+		  ACE_TEXT ("TAO (%P|%t) Timeout after recv is <%u> status <%d>\n"),
+		  msecs,
+		  reply_error));
     }
 
   // Check the reply error.
@@ -693,41 +696,41 @@ TAO_GIOP_Synch_Invocation::invoke_i (CORBA::Boolean is_locate_request,
   if (reply_error == -1)
     {
       // The guard automatically unbinds the dispatcher.
-      if (errno == ETIME)
-        {
-          // Just a timeout, don't close the connection or
-          // anything...
-          ACE_THROW_RETURN (CORBA::TIMEOUT (
-              CORBA_SystemException::_tao_minor_code (
-                  TAO_TIMEOUT_SEND_MINOR_CODE,
-                  errno),
-              CORBA::COMPLETED_NO),
-            TAO_INVOKE_EXCEPTION);
-        }
-
-      // Call the ORB Core which would check whether we need to really
-      // raise an exception or are we going to base our decision on the
-      // loaded services.
+      if (errno	== ETIME)
+	{
+	  // Just a timeout, don't close the connection	or
+	  // anything...
+	  ACE_THROW_RETURN (CORBA::TIMEOUT (
+	      CORBA_SystemException::_tao_minor_code (
+		  TAO_TIMEOUT_SEND_MINOR_CODE,
+		  errno),
+	      CORBA::COMPLETED_NO),
+	    TAO_INVOKE_EXCEPTION);
+	}
+
+      // Call the ORB Core which would check whether we	need to	really
+      // raise an exception or are we going to base our	decision on the
+      // loaded	services.
       return this->orb_core_->service_raise_comm_failure (this,
-                                                          this->profile_,
-                                                          ACE_TRY_ENV);
+							  this->profile_,
+							  ACE_TRY_ENV);
     }
 
-  // @@ Alex: the old version of this had some error handling code,
-  //    like:  this->profile_->reset_hint ()
-  //    Can you make sure we don't forget to do that on exceptions
-  //    and/or errors.
-  //    BTW, think about native exceptions where if the exception is
-  //    raised in the wait() method you won't get a chance
-  //    to do that kind of error handling.  Do you really need
-  //    exceptions in the transport objects?
+  // @@	Alex: the old version of this had some error handling code,
+  //	like:  this->profile_->reset_hint ()
+  //	Can you	make sure we don't forget to do	that on	exceptions
+  //	and/or errors.
+  //	BTW, think about native	exceptions where if the	exception is
+  //	raised in the wait() method you	won't get a chance
+  //	to do that kind	of error handling.  Do you really need
+  //	exceptions in the transport objects?
 
   CORBA::ULong reply_status = this->rd_.reply_status ();
 
   if (is_locate_request)
     {
-      // A locate request checks a different set of enum return values,
-      // so we return to the TAO_GIOP_Locate_Request_Invocation caller
+      // A locate request checks a different set of enum return	values,
+      // so we return to the TAO_GIOP_Locate_Request_Invocation	caller
       // to do that.
       return reply_status;
     }
@@ -735,92 +738,92 @@ TAO_GIOP_Synch_Invocation::invoke_i (CORBA::Boolean is_locate_request,
   switch (reply_status)
     {
     case TAO_PLUGGABLE_MESSAGE_NO_EXCEPTION:
-      // Return so that the STUB can demarshal the reply.
+      // Return	so that	the STUB can demarshal the reply.
       return TAO_INVOKE_OK;
 
     case TAO_PLUGGABLE_MESSAGE_USER_EXCEPTION:
-        // Return so the exception can be handled.
-        return TAO_INVOKE_EXCEPTION;
+	// Return so the exception can be handled.
+	return TAO_INVOKE_EXCEPTION;
 
     case TAO_PLUGGABLE_MESSAGE_SYSTEM_EXCEPTION:
       {
-        // @@ Add the location macros for this exceptions...
-
-        CORBA::String_var type_id;
-
-        if ((this->inp_stream () >> type_id.inout ()) == 0)
-          {
-            // Could not demarshal the exception id, raise an local
-            // CORBA::MARSHAL
-            ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
-                                              CORBA::COMPLETED_MAYBE),
-                              TAO_INVOKE_OK);
-          }
-
-        CORBA::ULong minor = 0;
-        CORBA::ULong completion = 0;
-
-        if ((this->inp_stream () >> minor) == 0
-            || (this->inp_stream () >> completion) == 0)
-          {
-            ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
-                                              CORBA::COMPLETED_MAYBE),
-                              TAO_INVOKE_OK);
-          }
-
-        CORBA::SystemException* ex =
-          TAO_Exceptions::create_system_exception (type_id.in (),
-                                                   ACE_TRY_ENV);
-        ACE_CHECK_RETURN (TAO_INVOKE_OK);
-
-        if (ex == 0)
-          {
-            // @@ We should raise a CORBA::NO_MEMORY, but we ran out
-            //    of memory already. We need a pre-allocated, TSS,
-            //    CORBA::NO_MEMORY instance
-            ACE_NEW_RETURN (ex,
-                            CORBA::UNKNOWN,
-                            TAO_INVOKE_EXCEPTION);
-          }
-
-        ex->minor (minor);
-        ex->completed (CORBA::CompletionStatus (completion));
-
-
-        // @@ There should be a better way to raise this exception!
-        //    This code works for both native and emulated exceptions,
-        //    but it is ugly.
-        ACE_TRY_ENV.exception (ex); // We can not use ACE_THROW here.
-        return TAO_INVOKE_OK;
+	// @@ Add the location macros for this exceptions...
+
+	CORBA::String_var type_id;
+
+	if ((this->inp_stream () >> type_id.inout ()) == 0)
+	  {
+	    // Could not demarshal the exception id, raise an local
+	    // CORBA::MARSHAL
+	    ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
+					      CORBA::COMPLETED_MAYBE),
+			      TAO_INVOKE_OK);
+	  }
+
+	CORBA::ULong minor = 0;
+	CORBA::ULong completion	= 0;
+
+	if ((this->inp_stream () >> minor) == 0
+	    || (this->inp_stream () >> completion) == 0)
+	  {
+	    ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
+					      CORBA::COMPLETED_MAYBE),
+			      TAO_INVOKE_OK);
+	  }
+
+	CORBA::SystemException*	ex =
+	  TAO_Exceptions::create_system_exception (type_id.in (),
+						   ACE_TRY_ENV);
+	ACE_CHECK_RETURN (TAO_INVOKE_OK);
+
+	if (ex == 0)
+	  {
+	    // @@ We should raise a CORBA::NO_MEMORY, but we ran out
+	    //	  of memory already. We	need a pre-allocated, TSS,
+	    //	  CORBA::NO_MEMORY instance
+	    ACE_NEW_RETURN (ex,
+			    CORBA::UNKNOWN,
+			    TAO_INVOKE_EXCEPTION);
+	  }
+
+	ex->minor (minor);
+	ex->completed (CORBA::CompletionStatus (completion));
+
+
+	// @@ There should be a	better way to raise this exception!
+	//    This code	works for both native and emulated exceptions,
+	//    but it is	ugly.
+	ACE_TRY_ENV.exception (ex); // We can not use ACE_THROW	here.
+	return TAO_INVOKE_OK;
       }
       // NOTREACHED.
 
     case TAO_PLUGGABLE_MESSAGE_LOCATION_FORWARD:
-      // Handle the forwarding and return so the stub restarts the
+      // Handle	the forwarding and return so the stub restarts the
       // request!
       return this->location_forward (this->inp_stream (),
-                                     ACE_TRY_ENV);
+				     ACE_TRY_ENV);
     case TAO_PLUGGABLE_MESSAGE_NEEDS_ADDRESSING_MODE:
       {
-        // We have received an exception with a request to change the
-        // addressing mode. First let us read the mode that the
-        // server/agent asks for.
-        CORBA::Short addr_mode = 0;
-        if (this->inp_stream ().read_short (addr_mode) == 0)
-          {
-            // Could not demarshal the addressing disposition, raise an local
-            // CORBA::MARSHAL
-            ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
-                                              CORBA::COMPLETED_MAYBE),
-                              TAO_INVOKE_OK);
-          }
-
-        // Now set this addressing mode in the stub object, so that
-        // the next invocation need not go through this.
-        this->stub_->addressing_mode (addr_mode);
-
-        // Now restart the invocation
-        return TAO_INVOKE_RESTART;
+	// We have received an exception with a	request	to change the
+	// addressing mode. First let us read the mode that the
+	// server/agent	asks for.
+	CORBA::Short addr_mode = 0;
+	if (this->inp_stream ().read_short (addr_mode) == 0)
+	  {
+	    // Could not demarshal the addressing disposition, raise an	local
+	    // CORBA::MARSHAL
+	    ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
+					      CORBA::COMPLETED_MAYBE),
+			      TAO_INVOKE_OK);
+	  }
+
+	// Now set this	addressing mode	in the stub object, so that
+	// the next invocation need not	go through this.
+	this->stub_->addressing_mode (addr_mode);
+
+	// Now restart the invocation
+	return TAO_INVOKE_RESTART;
       }
 
     }
@@ -838,91 +841,91 @@ TAO_GIOP_Twoway_Invocation::start (CORBA_Environment &ACE_TRY_ENV)
   ACE_CHECK;
 
   this->transport_->start_request (this->orb_core_,
-                                   this->target_spec_,
-                                   this->out_stream_,
-                                   ACE_TRY_ENV);
+				   this->target_spec_,
+				   this->out_stream_,
+				   ACE_TRY_ENV);
 }
 
-// Send request, block until any reply comes back, and unmarshal reply
+// Send	request, block until any reply comes back, and unmarshal reply
 // parameters as appropriate.
 
 int
 TAO_GIOP_Twoway_Invocation::invoke (TAO_Exception_Data *excepts,
-                                    CORBA::ULong except_count,
-                                    CORBA::Environment &ACE_TRY_ENV)
+				    CORBA::ULong except_count,
+				    CORBA::Environment &ACE_TRY_ENV)
   ACE_THROW_SPEC ((CORBA::Exception))
 {
   TAO_FUNCTION_PP_TIMEPROBE (TAO_GIOP_INVOCATION_INVOKE_START);
 
   int retval = this->invoke_i (0,
-                               ACE_TRY_ENV);
+			       ACE_TRY_ENV);
   ACE_CHECK_RETURN (retval);
 
-  // A TAO_INVOKE_EXCEPTION status, but no exception raised means that
-  // we have a user exception.
-  // @@ This is a bit brittle, think about a better implementation.
-  if (retval == TAO_INVOKE_EXCEPTION)
+  // A TAO_INVOKE_EXCEPTION status, but	no exception raised means that
+  // we	have a user exception.
+  // @@	This is	a bit brittle, think about a better implementation.
+  if (retval ==	TAO_INVOKE_EXCEPTION)
     {
       // Pull the exception from the stream.
-      CORBA::String_var buf;
+      CORBA::String_var	buf;
 
-      if ((this->inp_stream () >> buf.inout ()) == 0)
-        {
-          // Could not demarshal the exception id, raise an local
-          // CORBA::MARSHAL
-          ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
-                                            CORBA::COMPLETED_MAYBE),
-                            TAO_INVOKE_EXCEPTION);
-        }
+      if ((this->inp_stream () >> buf.inout ())	== 0)
+	{
+	  // Could not demarshal the exception id, raise an local
+	  // CORBA::MARSHAL
+	  ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
+					    CORBA::COMPLETED_MAYBE),
+			    TAO_INVOKE_EXCEPTION);
+	}
 
       // Match the exception interface repository id with the
       // exception in the exception list.
       // This is important to decode the exception.
 
-      for (CORBA::ULong i = 0; i < except_count; ++i)
-        {
-          CORBA::TypeCode_ptr tcp = excepts[i].tc;
-          const char *xid = tcp->id (ACE_TRY_ENV);
-          ACE_CHECK_RETURN (TAO_INVOKE_EXCEPTION);
-
-          if (ACE_OS::strcmp (buf.in (), xid) != 0)
-            {
-              continue;
-            }
-
-          // match
-          CORBA::Exception *exception = excepts[i].alloc ();
-
-          if (exception == 0)
-            {
-              ACE_THROW_RETURN (CORBA::NO_MEMORY (TAO_DEFAULT_MINOR_CODE,
-                                                  CORBA::COMPLETED_YES),
-                                TAO_INVOKE_EXCEPTION);
-            }
-
-          exception->_tao_decode (this->inp_stream (),
-                                  ACE_TRY_ENV);
-          ACE_CHECK_RETURN (TAO_INVOKE_EXCEPTION);
-
-          if (TAO_debug_level > 5)
-            {
-              ACE_DEBUG ((LM_DEBUG,
-                          ACE_TEXT ("TAO: (%P|%t) Raising exception %s\n"),
-                          buf.in ()));
-            }
-
-          // @@ Think about a better way to raise the exception here,
-          //    maybe we need some more macros?
-          ACE_TRY_ENV.exception (exception); // We can not use ACE_THROW here.
-          return TAO_INVOKE_EXCEPTION;
-        }
-
-      // If we couldn't find the right exception, report it as
+      for (CORBA::ULong	i = 0; i < except_count; ++i)
+	{
+	  CORBA::TypeCode_ptr tcp = excepts[i].tc;
+	  const	char *xid = tcp->id (ACE_TRY_ENV);
+	  ACE_CHECK_RETURN (TAO_INVOKE_EXCEPTION);
+
+	  if (ACE_OS::strcmp (buf.in (), xid) != 0)
+	    {
+	      continue;
+	    }
+
+	  // match
+	  CORBA::Exception *exception =	excepts[i].alloc ();
+
+	  if (exception	== 0)
+	    {
+	      ACE_THROW_RETURN (CORBA::NO_MEMORY (TAO_DEFAULT_MINOR_CODE,
+						  CORBA::COMPLETED_YES),
+				TAO_INVOKE_EXCEPTION);
+	    }
+
+	  exception->_tao_decode (this->inp_stream (),
+				  ACE_TRY_ENV);
+	  ACE_CHECK_RETURN (TAO_INVOKE_EXCEPTION);
+
+	  if (TAO_debug_level >	5)
+	    {
+	      ACE_DEBUG	((LM_DEBUG,
+			  ACE_TEXT ("TAO: (%P|%t) Raising exception %s\n"),
+			  buf.in ()));
+	    }
+
+	  // @@	Think about a better way to raise the exception	here,
+	  //	maybe we need some more	macros?
+	  ACE_TRY_ENV.exception	(exception); //	We can not use ACE_THROW here.
+	  return TAO_INVOKE_EXCEPTION;
+	}
+
+      // If we couldn't	find the right exception, report it as
       // CORBA::UNKNOWN.
 
       ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE,
-                                        CORBA::COMPLETED_YES),
-                        TAO_INVOKE_EXCEPTION);
+					CORBA::COMPLETED_YES),
+			TAO_INVOKE_EXCEPTION);
     }
 
   return retval;
@@ -934,19 +937,21 @@ TAO_GIOP_Oneway_Invocation::TAO_GIOP_Oneway_Invocation (
     TAO_Stub *stub,
     const char *operation,
     CORBA::ULong opname_len,
+    CORBA::Boolean argument_flag,
     TAO_ORB_Core *orb_core
   )
   : TAO_GIOP_Synch_Invocation (stub,
-                               operation,
-                               opname_len,
-                               orb_core),
-    sync_scope_ (TAO::SYNC_WITH_TRANSPORT)
+			       operation,
+			       opname_len,
+			       argument_flag,
+			       orb_core),
+    sync_scope_	(TAO::SYNC_WITH_TRANSPORT)
 {
   int has_synchronization = 0;
   int scope = 0;
-  this->orb_core_->call_sync_scope_hook (this->stub_,
-                                         has_synchronization,
-                                         scope);
+  this->orb_core_->call_sync_scope_hook	(this->stub_,
+					 has_synchronization,
+					 scope);
 
   this->sync_scope_ = scope;
 }
@@ -959,50 +964,50 @@ TAO_GIOP_Oneway_Invocation::start (CORBA_Environment &ACE_TRY_ENV)
   ACE_CHECK;
 
   this->transport_->start_request (this->orb_core_,
-                                   this->target_spec_,
-                                   this->out_stream_,
-                                   ACE_TRY_ENV);
+				   this->target_spec_,
+				   this->out_stream_,
+				   ACE_TRY_ENV);
 }
 
 int
 TAO_GIOP_Oneway_Invocation::invoke (CORBA::Environment &ACE_TRY_ENV)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
-  if (this->sync_scope_ == TAO::SYNC_WITH_TRANSPORT
+  if (this->sync_scope_	== TAO::SYNC_WITH_TRANSPORT
       || this->sync_scope_ == TAO::SYNC_NONE
       || this->sync_scope_ == TAO::SYNC_EAGER_BUFFERING
       || this->sync_scope_ == TAO::SYNC_DELAYED_BUFFERING)
     {
       return TAO_GIOP_Invocation::invoke (0,
-                                          ACE_TRY_ENV);
+					  ACE_TRY_ENV);
     }
 
   int retval = this->invoke_i (0,
-                               ACE_TRY_ENV);
+			       ACE_TRY_ENV);
   ACE_CHECK_RETURN (retval);
 
-  // A TAO_INVOKE_EXCEPTION status, but no exception raised means that
-  // we have a user exception.
-  // @@ This is a bit brittle, think about a better implementation.
-  if (retval == TAO_INVOKE_EXCEPTION)
+  // A TAO_INVOKE_EXCEPTION status, but	no exception raised means that
+  // we	have a user exception.
+  // @@	This is	a bit brittle, think about a better implementation.
+  if (retval ==	TAO_INVOKE_EXCEPTION)
     {
       // Pull the exception from the stream.
-      CORBA::String_var buf;
-
-      if ((this->inp_stream () >> buf.inout ()) == 0)
-        {
-          // Could not demarshal the exception id, raise an local
-          // CORBA::MARSHAL
-          ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
-                                            CORBA::COMPLETED_MAYBE),
-                            TAO_INVOKE_EXCEPTION);
-        }
-
-      // This kind of exception shouldn't happen with oneways,
-      // but if it does, we turn it into a CORBA::UNKNOWN exception.
+      CORBA::String_var	buf;
+
+      if ((this->inp_stream () >> buf.inout ())	== 0)
+	{
+	  // Could not demarshal the exception id, raise an local
+	  // CORBA::MARSHAL
+	  ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
+					    CORBA::COMPLETED_MAYBE),
+			    TAO_INVOKE_EXCEPTION);
+	}
+
+      // This kind of exception	shouldn't happen with oneways,
+      // but if	it does, we turn it into a CORBA::UNKNOWN exception.
       ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE,
-                                        CORBA::COMPLETED_YES),
-                        TAO_INVOKE_EXCEPTION);
+					CORBA::COMPLETED_YES),
+			TAO_INVOKE_EXCEPTION);
     }
 
   return retval;
@@ -1018,25 +1023,25 @@ TAO_GIOP_Locate_Request_Invocation::start (CORBA_Environment &ACE_TRY_ENV)
   ACE_CHECK;
 
   this->transport_->start_locate (this->orb_core_,
-                                  this->target_spec_,
-                                  this->op_details_,
-                                  this->out_stream_,
-                                  ACE_TRY_ENV);
+				  this->target_spec_,
+				  this->op_details_,
+				  this->out_stream_,
+				  ACE_TRY_ENV);
 }
 
-// Send request, block until any reply comes back.
+// Send	request, block until any reply comes back.
 int
 TAO_GIOP_Locate_Request_Invocation::invoke (CORBA::Environment &ACE_TRY_ENV)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   if (this->transport_ == 0)
     {
-      ACE_THROW_RETURN (CORBA::INTERNAL (),
-                        TAO_INVOKE_EXCEPTION);
+      ACE_THROW_RETURN (CORBA::INTERNAL	(),
+			TAO_INVOKE_EXCEPTION);
     }
 
   CORBA::ULong locate_status = this->invoke_i (1,
-                                               ACE_TRY_ENV);
+					       ACE_TRY_ENV);
   ACE_CHECK_RETURN (TAO_INVOKE_EXCEPTION);
 
   switch (locate_status)
@@ -1044,55 +1049,55 @@ TAO_GIOP_Locate_Request_Invocation::invoke (CORBA::Environment &ACE_TRY_ENV)
     case TAO_GIOP_OBJECT_HERE:
       break;
     case TAO_GIOP_UNKNOWN_OBJECT:
-      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (TAO_DEFAULT_MINOR_CODE,
-                                                 CORBA::COMPLETED_YES),
-                        TAO_INVOKE_EXCEPTION);
+      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST	(TAO_DEFAULT_MINOR_CODE,
+						 CORBA::COMPLETED_YES),
+			TAO_INVOKE_EXCEPTION);
       // NOTREACHED.
     case TAO_GIOP_OBJECT_FORWARD:
       return this->location_forward (this->inp_stream (),
-                                     ACE_TRY_ENV);
+				     ACE_TRY_ENV);
     case TAO_GIOP_LOC_SYSTEM_EXCEPTION:
       {
-        // Pull the exception from the stream.
-        CORBA::String_var buf;
-
-        if ((this->inp_stream () >> buf.inout ()) == 0)
-          {
-            // Could not demarshal the exception id, raise a local
-            // CORBA::MARSHAL exception.
-            ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
-                                              CORBA::COMPLETED_MAYBE),
-                              TAO_INVOKE_EXCEPTION);
-          }
-
-        // This kind of exception shouldn't happen with oneways,
-        // but if it does, we turn it into a CORBA::UNKNOWN exception.
-        ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE,
-                                          CORBA::COMPLETED_YES),
-                          TAO_INVOKE_EXCEPTION);
+	// Pull	the exception from the stream.
+	CORBA::String_var buf;
+
+	if ((this->inp_stream () >> buf.inout ()) == 0)
+	  {
+	    // Could not demarshal the exception id, raise a local
+	    // CORBA::MARSHAL exception.
+	    ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
+					      CORBA::COMPLETED_MAYBE),
+			      TAO_INVOKE_EXCEPTION);
+	  }
+
+	// This	kind of	exception shouldn't happen with	oneways,
+	// but if it does, we turn it into a CORBA::UNKNOWN exception.
+	ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE,
+					  CORBA::COMPLETED_YES),
+			  TAO_INVOKE_EXCEPTION);
       }
     case TAO_GIOP_LOC_NEEDS_ADDRESSING_MODE:
       {
-        // We have received an exception with a request to change the
-        // addressing mode. First let us read the mode that the
-        // server/agent asks for.
-        CORBA::Short addr_mode = 0;
-
-        if (this->inp_stream ().read_short (addr_mode) == 0)
-          {
-            // Could not demarshal the addressing disposition, raise a local
-            // CORBA::MARSHAL exception.
-            ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
-                                              CORBA::COMPLETED_MAYBE),
-                              TAO_INVOKE_OK);
-          }
-
-        // Now set this addressing mode in the stub object, so that
-        // the next invocation need not go through this.
-        this->stub_->addressing_mode (addr_mode);
-
-        // Restart the invocation.
-        return TAO_INVOKE_RESTART;
+	// We have received an exception with a	request	to change the
+	// addressing mode. First let us read the mode that the
+	// server/agent	asks for.
+	CORBA::Short addr_mode = 0;
+
+	if (this->inp_stream ().read_short (addr_mode) == 0)
+	  {
+	    // Could not demarshal the addressing disposition, raise a local
+	    // CORBA::MARSHAL exception.
+	    ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
+					      CORBA::COMPLETED_MAYBE),
+			      TAO_INVOKE_OK);
+	  }
+
+	// Now set this	addressing mode	in the stub object, so that
+	// the next invocation need not	go through this.
+	this->stub_->addressing_mode (addr_mode);
+
+	// Restart the invocation.
+	return TAO_INVOKE_RESTART;
       }
     }
 
diff --git a/TAO/tao/Invocation.h b/TAO/tao/Invocation.h
index 213091a8ed0..e42dce2cb5b 100644
--- a/TAO/tao/Invocation.h
+++ b/TAO/tao/Invocation.h
@@ -1,4 +1,4 @@
-// This may look like C, but it's really -*- C++ -*-
+// This	may look like C, but it's really -*- C++ -*-
 // $Id$
 
 // ============================================================================
@@ -10,31 +10,31 @@
 //    Invocation.h
 //
 // = DESCRIPTION
-//    Encapsulate the logic for remote invocations, oneways or
+//    Encapsulate the logic for	remote invocations, oneways or
 //    twoways.
 //
 //   THREADING NOTE: Threads should never manipulate another
-//   thread's invocations.  In this implementation, all data
-//   structures used to represent invocations (and parts of them)
+//   thread's invocations.  In this implementation, all	data
+//   structures	used to	represent invocations (and parts of them)
 //   are owned by the thread which created them.  Multiple threads
-//   may make of course concurrent invocations safely, since the
+//   may make of course	concurrent invocations safely, since the
 //   GIOP code is reentrant.
 //
 // = AUTHOR
-//    Carlos O'Ryan <coryan@cs.wustl.edu> and Alexander Babu Arulanthu
+//    Carlos O'Ryan <coryan@cs.wustl.edu> and Alexander	Babu Arulanthu
 //    <alex@cs.wustl.edu>
 //
 // ============================================================================
 
-#ifndef TAO_INVOCATION_H
-#define TAO_INVOCATION_H
+#ifndef	TAO_INVOCATION_H
+#define	TAO_INVOCATION_H
 #include "ace/pre.h"
 
 #include "tao/CDR.h"
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
-#endif /* ACE_LACKS_PRAGMA_ONCE */
+#endif /* ACE_LACKS_PRAGMA_ONCE	*/
 
 #include "tao/Any.h"
 #include "tao/Synch_Reply_Dispatcher.h"
@@ -52,10 +52,10 @@ enum TAO_Invoke_Status
   // invoke() call successful.
 
   TAO_INVOKE_RESTART,
-  // The request must be restarted, a temporary failure has ocurred.
+  // The request must be restarted, a temporary	failure	has ocurred.
 
   TAO_INVOKE_EXCEPTION
-  // An exception was raised.
+  // An	exception was raised.
 };
 
 // ****************************************************************
@@ -63,14 +63,14 @@ enum TAO_Invoke_Status
 class TAO_Export TAO_GIOP_Invocation
 {
   // = TITLE
-  //    Encapsulates common behavior for both oneway and twoway
-  //    invocations.
+  //	Encapsulates common behavior for both oneway and twoway
+  //	invocations.
   //
   // = DESCRIPTION
-  //    This class connects (or lookups a connection from the cache)
-  //    to the remote server, builds the CDR stream for the Request,
-  //    send the CDR stream and expects the response and interprets
-  //    the incoming CDR stream.
+  //	This class connects (or	lookups	a connection from the cache)
+  //	to the remote server, builds the CDR stream for	the Request,
+  //	send the CDR stream and	expects	the response and interprets
+  //	the incoming CDR stream.
 
   friend class TAO_Endpoint_Selector_Factory;
   friend class TAO_Default_Endpoint_Selector;
@@ -83,149 +83,150 @@ class TAO_Export TAO_GIOP_Invocation
 
 public:
   TAO_GIOP_Invocation (void);
-  // Default constructor. This should never get called, it is here
+  // Default constructor. This should never get	called,	it is here
   // only to appease older versions of g++.
 
-  TAO_GIOP_Invocation (TAO_Stub *data,
-                       const char *operation,
-                       CORBA::ULong opname_len,
-                       TAO_ORB_Core *orb_core);
+  TAO_GIOP_Invocation (TAO_Stub	*data,
+		       const char *operation,
+		       CORBA::ULong opname_len,
+		       CORBA::Boolean argument_flag,
+		       TAO_ORB_Core *orb_core);
   // Constructor.
 
   virtual ~TAO_GIOP_Invocation (void);
-  // This destructor is virtual so that the derived synchronous
-  // invocation classes can call <idle> method on the <Transport>, if
+  // This destructor is	virtual	so that	the derived synchronous
+  // invocation	classes	can call <idle>	method on the <Transport>, if
   // they want to. All the synchronous invocations <idle> the
-  // Transport, but asynchronous invocations do not do that.
+  // Transport,	but asynchronous invocations do	not do that.
 
   void prepare_header (CORBA::Octet response_flags,
-                       CORBA_Environment &ACE_TRY_ENV =
-                         TAO_default_environment ())
+		       CORBA_Environment &ACE_TRY_ENV =
+			 TAO_default_environment ())
     ACE_THROW_SPEC ((CORBA::SystemException));
-  // Initialize the Request header.
-  // The <message_size> field of the GIOP header is left blank and
+  // Initialize	the Request header.
+  // The <message_size>	field of the GIOP header is left blank and
   // must be filled later.
   // The function only returns once a connection has been succesfully
-  // established *OR* all profiles have been tried.  In that case it
-  // raises the CORBA::TRANSIENT exception.
+  // established *OR* all profiles have	been tried.  In	that case it
+  // raises the	CORBA::TRANSIENT exception.
 
-  IOP::ServiceContextList& service_info (void);
+  IOP::ServiceContextList& service_info	(void);
   // Accessor to the request ServiceContextList.  Only valid when
   // sending a request message.
 
   CORBA::ULong request_id (void);
-  // Return the request id of this invocation.
+  // Return the	request	id of this invocation.
 
-  TAO_OutputCDR &out_stream (void);
-  // Return the underlying output stream.
+  TAO_OutputCDR	&out_stream (void);
+  // Return the	underlying output stream.
 
   //  CORBA::Boolean restart_flag (void);
   void restart_flag (CORBA::Boolean flag);
   // Set the value for the  restart flag.
 
   int close_connection (void);
-  // resets the forwarding profile and behaves like we are fowarded
+  // resets the	forwarding profile and behaves like we are fowarded
   // (to the same server)
 
-  void start (CORBA_Environment &ACE_TRY_ENV =
-                TAO_default_environment ())
+  void start (CORBA_Environment	&ACE_TRY_ENV =
+		TAO_default_environment	())
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Establishes a connection to the remote server, initializes
   // the GIOP headers in the output CDR.
 
 protected:
   int invoke (CORBA::Boolean is_roundtrip,
-              CORBA_Environment &ACE_TRY_ENV =
-                TAO_default_environment ())
+	      CORBA_Environment	&ACE_TRY_ENV =
+		TAO_default_environment	())
     ACE_THROW_SPEC ((CORBA::SystemException));
-  // Sends the request, does not wait for the response.
-  // Returns TAO_INVOKE_RESTART if the write call failed and the
+  // Sends the request,	does not wait for the response.
+  // Returns TAO_INVOKE_RESTART	if the write call failed and the
   // request must be re-attempted.
-  // Notice that the same profile is tried again because it may be
-  // that the server closed the connection simply to release
+  // Notice that the same profile is tried again because it may	be
+  // that the server closed the	connection simply to release
   // resources.
 
   int location_forward (TAO_InputCDR &inp_stream,
-                        CORBA_Environment &ACE_TRY_ENV =
-                          TAO_default_environment ())
+			CORBA_Environment &ACE_TRY_ENV =
+			  TAO_default_environment ())
     ACE_THROW_SPEC ((CORBA::SystemException));
-  // Helper method, the response for a Request or LocateRequest was a
+  // Helper method, the	response for a Request or LocateRequest	was a
   // LOCATION_FORWARD or TAO_GIOP_OBJECT_FORWARD.
-  // In any case we must demarshal the object reference and setup the
+  // In	any case we must demarshal the object reference	and setup the
   // profiles.
-  // It returns TAO_INVOKE_RESTART unless an exception is raised.
+  // It	returns	TAO_INVOKE_RESTART unless an exception is raised.
 
   CORBA::ULong create_ior_info (void);
-  // Create the IOP::IOR info. We will create the info atmost
-  // once. This method will not work for RTCorba - Bala
+  // Create the	IOP::IOR info. We will create the info atmost
+  // once. This	method will not	work for RTCorba - Bala
 
   void add_rt_service_context (CORBA_Environment &ACE_TRY_ENV =
-                               TAO_default_environment ());
-  // Add RT-related context to the service context list if the
-  // invocation target supports RTCORBA::CLIENT_PROPAGATED priority
-  // model. 
+			       TAO_default_environment ());
+  // Add RT-related context to the service context list	if the
+  // invocation	target supports	RTCORBA::CLIENT_PROPAGATED priority
+  // model.
 
 protected:
   TAO_Stub *stub_;
-  // The object on which this invocation is going.
+  // The object	on which this invocation is going.
 
   char buffer_ [ACE_CDR::DEFAULT_BUFSIZE];
   // Buffer used for both the output and input CDR streams, this is
-  // "safe" because we only one of the streams at a time.
+  // "safe" because we only one	of the streams at a time.
 
-  TAO_Operation_Details  op_details_;
+  TAO_Operation_Details	 op_details_;
   // The relevant operation detail
 
   TAO_Target_Specification target_spec_;
 
-  TAO_OutputCDR out_stream_;
+  TAO_OutputCDR	out_stream_;
   // Stream into which the response is placed.
 
-  TAO_ORB_Core* orb_core_;
-  // The orb_core context where we make this invocation.
+  TAO_ORB_Core*	orb_core_;
+  // The orb_core context where	we make	this invocation.
 
-  TAO_Transport *transport_;
-  // This invocation is using this transport, may change...
+  TAO_Transport	*transport_;
+  // This invocation is	using this transport, may change...
 
   TAO_Invocation_Endpoint_Selector *endpoint_selector_;
-  // Strategy for making decisions about which endpoint/profile to use
+  // Strategy for making decisions about which endpoint/profile	to use
   // for invocation.
 
   int is_selector_initialized_;
   // Flag indicating whether <endpoint_selector_> has been
-  // initialized. 
+  // initialized.
 
 #if (TAO_HAS_RT_CORBA == 1)
 
   TAO_Endpoint_Selection_State endpoint_selection_state_;
-  // Store information used by <endpoint_selector_> for making
-  // endpoint selection decisions.
+  // Store information used by <endpoint_selector_> for	making
+  // endpoint selection	decisions.
 
-#endif /* TAO_HAS_RT_CORBA == 1 */
+#endif /* TAO_HAS_RT_CORBA == 1	*/
 
   TAO_Profile *profile_;
-  // This invocation is using this profile.
+  // This invocation is	using this profile.
 
   TAO_Endpoint *endpoint_;
-  // This invocation is using this endpoint from <profile_>.
+  // This invocation is	using this endpoint from <profile_>.
 
   ACE_Time_Value max_wait_time_value_;
   ACE_Time_Value *max_wait_time_;
-  // The timeout remaining for this request, it is initialized in
+  // The timeout remaining for this request, it	is initialized in
   // start() and updated as required.
 
   IOP::IOR ior_info_;
-  // The ior info. This would be needed for GIOP 1.2, as the clients
-  // could receive an exception from the server asking for this
+  // The ior info. This	would be needed	for GIOP 1.2, as the clients
+  // could receive an exception	from the server	asking for this
   // info. The exception that the client receives is
-  // LOC_NEEDS_ADDRESSING_MODE. If we receive an exception we will
-  // fill up this data atmost *once* and send it to the server.
+  // LOC_NEEDS_ADDRESSING_MODE.	If we receive an exception we will
+  // fill up this data atmost *once* and send it to the	server.
 
   int rt_context_initialized_;
   // Flag indicating whether RTCORBA-specific service context list
-  // processing has taken place.  This is needed because
+  // processing	has taken place.  This is needed because
   // <prepare_header> may get called multiple times, but we only need
-  // to do the service context list processing once.
+  // to	do the service context list processing once.
 
   CORBA::Boolean restart_flag_;
   // This flag is turned on when the previous invocation on an
@@ -239,36 +240,37 @@ protected:
 class TAO_Export TAO_GIOP_Synch_Invocation : public TAO_GIOP_Invocation
 {
   // = TITLE
-  //    TAO_GIOP_Synch_Invocation.
+  //	TAO_GIOP_Synch_Invocation.
   //
   // = DESCRIPTION
-  //    Base class for TAO_GIOP_Twoway_Invocation and 
-  //    TAO_GIOP_Oneway_Invocation.
+  //	Base class for TAO_GIOP_Twoway_Invocation and
+  //	TAO_GIOP_Oneway_Invocation.
   //
 public:
   TAO_GIOP_Synch_Invocation (void);
-  // Default constructor. This should never get called, it is here
+  // Default constructor. This should never get	called,	it is here
   // only to appease older versions of g++.
 
   TAO_GIOP_Synch_Invocation (TAO_Stub *stub,
-                             const char *operation,
-                             CORBA::ULong opname_len,
-                             TAO_ORB_Core *orb_core);
+			     const char	*operation,
+			     CORBA::ULong opname_len,
+			     CORBA::Boolean argument_flag,
+			     TAO_ORB_Core *orb_core);
   // Constructor.
 
   virtual ~TAO_GIOP_Synch_Invocation (void);
   // Destructor.
 
   TAO_InputCDR &inp_stream (void);
-  // Return the underlying input stream. Called by the stub to demarshal
-  // the results of the upcall into whatever return arguments there may be.
+  // Return the	underlying input stream. Called	by the stub to demarshal
+  // the results of the	upcall into whatever return arguments there may	be.
 
 protected:
   int invoke_i (CORBA::Boolean is_locate_request,
-                CORBA::Environment &ACE_TRY_ENV)
+		CORBA::Environment &ACE_TRY_ENV)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Implementation of the invoke() methods, handles the basic
-  // send/reply code and the system exceptions.
+  // send/reply	code and the system exceptions.
 
   TAO_Synch_Reply_Dispatcher rd_;
   // Reply dispatcher for the current synchronous invocation.
@@ -276,77 +278,79 @@ protected:
 
 // ****************************************************************
 
-class TAO_Export TAO_GIOP_Twoway_Invocation 
+class TAO_Export TAO_GIOP_Twoway_Invocation
   : public TAO_GIOP_Synch_Invocation
 {
   // = TITLE
-  //    TAO_GIOP_Twoway_Invocation.
+  //	TAO_GIOP_Twoway_Invocation.
   //
   // = DESCRIPTION
-  //    Sends a two-way request, and expects the reply.
-  //    This class connects (or lookups a connection from the cache) to
-  //    the remote server, builds the CDR stream for the Request, send
-  //    the CDR stream and expects the response and interprets the
-  //    incoming CDR stream.
+  //	Sends a	two-way	request, and expects the reply.
+  //	This class connects (or	lookups	a connection from the cache) to
+  //	the remote server, builds the CDR stream for the Request, send
+  //	the CDR	stream and expects the response	and interprets the
+  //	incoming CDR stream.
   //
 public:
   TAO_GIOP_Twoway_Invocation (TAO_Stub *stub,
-                              const char *operation,
-                              CORBA::ULong opname_len,
-                              TAO_ORB_Core *orb_core);
+			      const char *operation,
+			      CORBA::ULong opname_len,
+			      CORBA::Boolean argument_flag,
+			      TAO_ORB_Core *orb_core);
   // Constructor.
 
   virtual ~TAO_GIOP_Twoway_Invocation (void);
   // Destructor.
 
-  void start (CORBA_Environment &ACE_TRY_ENV =
-                TAO_default_environment ())
+  void start (CORBA_Environment	&ACE_TRY_ENV =
+		TAO_default_environment	())
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Establishes a connection to the remote server, initializes
   // the GIOP headers in the output CDR.
 
   int invoke (TAO_Exception_Data *excepts,
-              CORBA::ULong except_count,
-              CORBA_Environment &ACE_TRY_ENV =
-                TAO_default_environment ())
+	      CORBA::ULong except_count,
+	      CORBA_Environment	&ACE_TRY_ENV =
+		TAO_default_environment	())
     ACE_THROW_SPEC ((CORBA::Exception));
-  // Special purpose invoke method used by the generated stubs. This
-  // accomplishes the same task as the normal invoke except that
-  // Exceptions are allocated and decoded here. This reduces the
-  // footprint of the generated stubs.
+  // Special purpose invoke method used	by the generated stubs.	This
+  // accomplishes the same task	as the normal invoke except that
+  // Exceptions	are allocated and decoded here.	This reduces the
+  // footprint of the generated	stubs.
 };
 
 // ****************************************************************
 
-class TAO_Export TAO_GIOP_Oneway_Invocation 
+class TAO_Export TAO_GIOP_Oneway_Invocation
   : public TAO_GIOP_Synch_Invocation
 {
   // = TITLE
-  //    TAO_GIOP_Oneway_Invocation
+  //	TAO_GIOP_Oneway_Invocation
   //
   // = DESCRIPTION
-  //    Sends a oneway request.
+  //	Sends a	oneway request.
   //
 public:
   TAO_GIOP_Oneway_Invocation (TAO_Stub *stub,
-                              const char *operation,
-                              CORBA::ULong opname_len,
-                              TAO_ORB_Core *orb_core);
+			      const char *operation,
+			      CORBA::ULong opname_len,
+			      CORBA::Boolean argument_flag,
+			      TAO_ORB_Core *orb_core);
   // Constructor.
 
   virtual ~TAO_GIOP_Oneway_Invocation (void);
   // Destructor.
 
-  void start (CORBA_Environment &ACE_TRY_ENV =
-                TAO_default_environment ())
+  void start (CORBA_Environment	&ACE_TRY_ENV =
+		TAO_default_environment	())
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Establishes a connection to the remote server, initializes
   // the GIOP headers in the output CDR.
 
-  int invoke (CORBA_Environment &ACE_TRY_ENV =
-                TAO_default_environment ())
+  int invoke (CORBA_Environment	&ACE_TRY_ENV =
+		TAO_default_environment	())
     ACE_THROW_SPEC ((CORBA::SystemException));
-  // Send request, without blocking for any response.
+  // Send request, without blocking for	any response.
 
   TAO::SyncScope sync_scope (void);
   // Acessor for private member.
@@ -357,7 +361,7 @@ private:
 
 // ****************************************************************
 
-class TAO_Export TAO_GIOP_Locate_Request_Invocation 
+class TAO_Export TAO_GIOP_Locate_Request_Invocation
   : public TAO_GIOP_Synch_Invocation
 {
   // = TITLE
@@ -365,22 +369,22 @@ class TAO_Export TAO_GIOP_Locate_Request_Invocation
   //
 public:
   TAO_GIOP_Locate_Request_Invocation (TAO_Stub *data,
-                                      TAO_ORB_Core *orb_core);
+				      TAO_ORB_Core *orb_core);
   // Constructor.
 
   ~TAO_GIOP_Locate_Request_Invocation (void);
   // Destructor.
 
-  void start (CORBA_Environment &ACE_TRY_ENV =
-                TAO_default_environment ())
+  void start (CORBA_Environment	&ACE_TRY_ENV =
+		TAO_default_environment	())
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Establishes a connection to the remote server, initializes
   // the GIOP headers in the output CDR.
 
-  int invoke (CORBA_Environment &ACE_TRY_ENV =
-                TAO_default_environment ())
+  int invoke (CORBA_Environment	&ACE_TRY_ENV =
+		TAO_default_environment	())
     ACE_THROW_SPEC ((CORBA::SystemException));
-  // Send request, without blocking for any response.
+  // Send request, without blocking for	any response.
 };
 
 // ****************************************************************
diff --git a/TAO/tao/Invocation.i b/TAO/tao/Invocation.i
index fde2229f09c..af4c16b81bf 100644
--- a/TAO/tao/Invocation.i
+++ b/TAO/tao/Invocation.i
@@ -1,4 +1,4 @@
-// This may look like C, but it's really -*- C++ -*-
+// This	may look like C, but it's really -*- C++ -*-
 //
 // $Id$
 //
@@ -6,17 +6,17 @@
 ACE_INLINE IOP::ServiceContextList &
 TAO_GIOP_Invocation::service_info (void)
 {
-  return this->op_details_.service_info ();
+  return this->op_details_.service_info	();
 }
 
 ACE_INLINE CORBA::ULong
-TAO_GIOP_Invocation::request_id (void)
+TAO_GIOP_Invocation::request_id	(void)
 {
   return this->op_details_.request_id ();
 }
 
 ACE_INLINE TAO_OutputCDR &
-TAO_GIOP_Invocation::out_stream (void)
+TAO_GIOP_Invocation::out_stream	(void)
 {
   return this->out_stream_;
 }
@@ -25,7 +25,7 @@ ACE_INLINE void
 TAO_GIOP_Invocation::restart_flag (CORBA::Boolean flag)
 {
   // Set the flag
-  this->restart_flag_ = flag;
+  this->restart_flag_ =	flag;
 }
 
 // ****************************************************************
@@ -35,18 +35,20 @@ TAO_GIOP_Synch_Invocation::TAO_GIOP_Synch_Invocation (
     TAO_Stub *stub,
     const char *operation,
     CORBA::ULong opname_len,
+    CORBA::Boolean argument_flag,
     TAO_ORB_Core *orb_core
   )
-  : TAO_GIOP_Invocation (stub, 
-                         operation, 
-			 opname_len, 
+  : TAO_GIOP_Invocation	(stub,
+			 operation,
+			 opname_len,
+			 argument_flag,
 			 orb_core),
-    rd_ (orb_core, 
-         this->op_details_.service_info ())
+    rd_	(orb_core,
+	 this->op_details_.service_info	())
 {
 }
 
-ACE_INLINE TAO_InputCDR &
+ACE_INLINE TAO_InputCDR	&
 TAO_GIOP_Synch_Invocation::inp_stream (void)
 {
   return this->rd_.reply_cdr ();
@@ -59,24 +61,26 @@ TAO_GIOP_Twoway_Invocation::TAO_GIOP_Twoway_Invocation (
     TAO_Stub *stub,
     const char *operation,
     CORBA::ULong opname_len,
+    CORBA::Boolean argument_flag,
     TAO_ORB_Core *orb_core
   )
-  : TAO_GIOP_Synch_Invocation (stub, 
-			       operation, 
-			       opname_len, 
+  : TAO_GIOP_Synch_Invocation (stub,
+			       operation,
+			       opname_len,
+			       argument_flag,
 			       orb_core)
 {
 }
 
 ACE_INLINE
-TAO_GIOP_Twoway_Invocation::~TAO_GIOP_Twoway_Invocation (void)
+TAO_GIOP_Twoway_Invocation::~TAO_GIOP_Twoway_Invocation	(void)
 {
 }
 
 // ****************************************************************
 
 ACE_INLINE
-TAO_GIOP_Oneway_Invocation::~TAO_GIOP_Oneway_Invocation (void)
+TAO_GIOP_Oneway_Invocation::~TAO_GIOP_Oneway_Invocation	(void)
 {
 }
 
@@ -91,16 +95,16 @@ TAO_GIOP_Oneway_Invocation::sync_scope (void)
 ACE_INLINE
 TAO_GIOP_Locate_Request_Invocation::
 TAO_GIOP_Locate_Request_Invocation (TAO_Stub *stub,
-                                    TAO_ORB_Core *orb_core)
-  : TAO_GIOP_Synch_Invocation (stub, 
-			       0, 
-			       0, 
+				    TAO_ORB_Core *orb_core)
+  : TAO_GIOP_Synch_Invocation (stub,
+			       0,
+			       0,
+			       0,
 			       orb_core)
 {
 }
 
 ACE_INLINE
-TAO_GIOP_Locate_Request_Invocation::~TAO_GIOP_Locate_Request_Invocation (void)
+TAO_GIOP_Locate_Request_Invocation::~TAO_GIOP_Locate_Request_Invocation	(void)
 {
 }
-
diff --git a/TAO/tao/Pluggable_Messaging_Utils.h b/TAO/tao/Pluggable_Messaging_Utils.h
index a9057a1fe36..d6c96cbfc93 100644
--- a/TAO/tao/Pluggable_Messaging_Utils.h
+++ b/TAO/tao/Pluggable_Messaging_Utils.h
@@ -74,9 +74,13 @@ public:
   // a service context list and would like to pass on their contents
   // without a copy.
 
+  CORBA::Boolean argument_flag_;
+  // A flag that indicates if there is any data is going to get
+  // marshalled in the reply
+
 private:
   IOP::ServiceContextList *service_context_;
-  // The service context list that we don't own. 
+  // The service context list that we don't own.
 };
 
 // @@ Bala: this is a GIOPism too, there is no such thing as locate
diff --git a/TAO/tao/PolicyC.cpp b/TAO/tao/PolicyC.cpp
index b042108953e..aeee1ce9ffe 100644
--- a/TAO/tao/PolicyC.cpp
+++ b/TAO/tao/PolicyC.cpp
@@ -1,11 +1,11 @@
 /* -*- 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
-// Distributed Object Computing at Washington University, St. Louis.
+// ******  Code	generated by the The ACE ORB (TAO) IDL Compiler	*******
+// TAO and the TAO IDL Compiler	have been developed by the Center for
+// Distributed Object Computing	at Washington University, St. Louis.
 //
 // Information about TAO is available at:
-//                 http://www.cs.wustl.edu/~schmidt/TAO.html
+//		   http://www.cs.wustl.edu/~schmidt/TAO.html
 
 #include "tao/PolicyC.h"
 #include "tao/Stub.h"
@@ -19,11 +19,11 @@
 
 TAO_NAMESPACE_TYPE (const CORBA::PolicyErrorCode)
 TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (const CORBA::PolicyErrorCode, BAD_POLICY, 0)
+TAO_NAMESPACE_DEFINE (const CORBA::PolicyErrorCode, BAD_POLICY,	0)
 TAO_NAMESPACE_END
 TAO_NAMESPACE_TYPE (const CORBA::PolicyErrorCode)
 TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (const CORBA::PolicyErrorCode, UNSUPPORTED_POLICY, 1)
+TAO_NAMESPACE_DEFINE (const CORBA::PolicyErrorCode, UNSUPPORTED_POLICY,	1)
 TAO_NAMESPACE_END
 TAO_NAMESPACE_TYPE (const CORBA::PolicyErrorCode)
 TAO_NAMESPACE_BEGIN (CORBA)
@@ -42,11 +42,11 @@ TAO_NAMESPACE_END
 
 // default constructor
 CORBA_PolicyError::CORBA_PolicyError (void)
-  : CORBA_UserException ("IDL:omg.org/CORBA/PolicyError:1.0")
+  : CORBA_UserException	("IDL:omg.org/CORBA/PolicyError:1.0")
 {
 }
 
-// destructor - all members are of self managing types
+// destructor -	all members are	of self	managing types
 CORBA_PolicyError::~CORBA_PolicyError (void)
 {
 }
@@ -57,16 +57,16 @@ void CORBA_PolicyError::_tao_any_destructor (void *x)
   delete tmp;
 }
 
-// copy constructor
-CORBA_PolicyError::CORBA_PolicyError (const ::CORBA_PolicyError &_tao_excp)
-  : CORBA_UserException (_tao_excp._id ())
+// copy	constructor
+CORBA_PolicyError::CORBA_PolicyError (const ::CORBA_PolicyError	&_tao_excp)
+  : CORBA_UserException	(_tao_excp._id ())
 {
     this->reason = _tao_excp.reason;
 }
 
 // assignment operator
 CORBA_PolicyError&
-CORBA_PolicyError::operator= (const ::CORBA_PolicyError &_tao_excp)
+CORBA_PolicyError::operator= (const ::CORBA_PolicyError	&_tao_excp)
 {
 
   this->CORBA_UserException::operator= (_tao_excp);
@@ -121,122 +121,122 @@ CORBA::Exception *CORBA_PolicyError::_alloc (void)
 CORBA_PolicyError::CORBA_PolicyError (
   CORBA::PolicyErrorCode _tao_reason
 )
-  : CORBA_UserException  (CORBA::string_dup ("IDL:omg.org/CORBA/PolicyError:1.0"))
+  : CORBA_UserException	 (CORBA::string_dup ("IDL:omg.org/CORBA/PolicyError:1.0"))
 {
     this->reason = _tao_reason;
 }
 
 static const CORBA::Long _oc_CORBA_PolicyError[] =
 {
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x4572726f), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA_PolicyError:1.0
-  18, ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x4572726f), ACE_NTOHL (0x72000000),  // name = CORBA_PolicyError
-  1, // member count
-  7, ACE_NTOHL (0x72656173), ACE_NTOHL (0x6f6e0000),  // name = reason
-  CORBA::tk_alias, // typecode kind for typedefs
+  TAO_ENCAP_BYTE_ORDER,	// byte	order
+  34, ACE_NTOHL	(0x49444c3a), ACE_NTOHL	(0x6f6d672e), ACE_NTOHL	(0x6f72672f), ACE_NTOHL	(0x434f5242), ACE_NTOHL	(0x415f506f), ACE_NTOHL	(0x6c696379), ACE_NTOHL	(0x4572726f), ACE_NTOHL	(0x723a312e), ACE_NTOHL	(0x30000000),  // repository ID	= IDL:omg.org/CORBA_PolicyError:1.0
+  18, ACE_NTOHL	(0x434f5242), ACE_NTOHL	(0x415f506f), ACE_NTOHL	(0x6c696379), ACE_NTOHL	(0x4572726f), ACE_NTOHL	(0x72000000),  // name = CORBA_PolicyError
+  1, //	member count
+  7, ACE_NTOHL (0x72656173), ACE_NTOHL (0x6f6e0000),  // name =	reason
+  CORBA::tk_alias, // typecode kind for	typedefs
   72, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x4572726f), ACE_NTOHL (0x72436f64), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/PolicyErrorCode:1.0
-    16, ACE_NTOHL (0x506f6c69), ACE_NTOHL (0x63794572), ACE_NTOHL (0x726f7243), ACE_NTOHL (0x6f646500),  // name = PolicyErrorCode
+    38,	ACE_NTOHL (0x49444c3a),	ACE_NTOHL (0x6f6d672e),	ACE_NTOHL (0x6f72672f),	ACE_NTOHL (0x434f5242),	ACE_NTOHL (0x412f506f),	ACE_NTOHL (0x6c696379),	ACE_NTOHL (0x4572726f),	ACE_NTOHL (0x72436f64),	ACE_NTOHL (0x653a312e),	ACE_NTOHL (0x30000000),	 // repository ID = IDL:omg.org/CORBA/PolicyErrorCode:1.0
+    16,	ACE_NTOHL (0x506f6c69),	ACE_NTOHL (0x63794572),	ACE_NTOHL (0x726f7243),	ACE_NTOHL (0x6f646500),	 // name = PolicyErrorCode
     CORBA::tk_short,
 
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_PolicyError (CORBA::tk_except, sizeof (_oc_CORBA_PolicyError), (char *) &_oc_CORBA_PolicyError, 0, sizeof (CORBA_PolicyError));
+static CORBA::TypeCode _tc_TAO_tc_CORBA_PolicyError (CORBA::tk_except, sizeof (_oc_CORBA_PolicyError), (char *)	&_oc_CORBA_PolicyError,	0, sizeof (CORBA_PolicyError));
 CORBA::TypeCode_ptr _tc_CORBA_PolicyError = &_tc_TAO_tc_CORBA_PolicyError;
 
 CORBA::TypeCode_ptr
-CORBA_PolicyError::_type (void) const
+CORBA_PolicyError::_type (void)	const
 {
   return _tc_CORBA_PolicyError;
 }
 
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
+
 #if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_INVALIDPOLICIES__TAO_SEQ_USHORT_CS_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_INVALIDPOLICIES__TAO_SEQ_USHORT_CS_
+#define	__TAO_UNBOUNDED_SEQUENCE_CORBA_INVALIDPOLICIES__TAO_SEQ_USHORT_CS_
 
   void
   CORBA_InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::_allocate_buffer (CORBA::ULong length)
   {
     CORBA::UShort* tmp = 0;
-    tmp = _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::allocbuf (length);
-    
+    tmp	= _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::allocbuf (length);
+
     if (this->buffer_ != 0)
     {
-      CORBA::UShort *old = ACE_reinterpret_cast (CORBA::UShort *,this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp[i] = old[i];
-      
+      CORBA::UShort *old = ACE_reinterpret_cast	(CORBA::UShort *,this->buffer_);
+
+      for (CORBA::ULong	i = 0; i < this->length_; ++i)
+	tmp[i] = old[i];
+
       if (this->release_)
-        _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::freebuf (old);
-      
+	_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::freebuf (old);
+
     }
     this->buffer_ = tmp;
   }
-  
+
   void
   CORBA_InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::_deallocate_buffer (void)
   {
-    if (this->buffer_ == 0 || this->release_ == 0)
+    if (this->buffer_ == 0 || this->release_ ==	0)
       return;
-    
+
     CORBA::UShort *tmp = ACE_reinterpret_cast (CORBA::UShort *,this->buffer_);
-    
+
     _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::freebuf (tmp);
     this->buffer_ = 0;
-  } 
-  
+  }
+
   CORBA_InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::~_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (void) // Dtor.
   {
     this->_deallocate_buffer ();
   }
-  
-  
+
+
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 
 #if !defined (_CORBA_INVALIDPOLICIES__TAO_SEQ_USHORT_CS_)
-#define _CORBA_INVALIDPOLICIES__TAO_SEQ_USHORT_CS_
+#define	_CORBA_INVALIDPOLICIES__TAO_SEQ_USHORT_CS_
 
 // *************************************************************
 // CORBA_InvalidPolicies::_tao_seq_UShort
 // *************************************************************
 
-CORBA_InvalidPolicies::_tao_seq_UShort::_tao_seq_UShort (void)
+CORBA_InvalidPolicies::_tao_seq_UShort::_tao_seq_UShort	(void)
 {}
-CORBA_InvalidPolicies::_tao_seq_UShort::_tao_seq_UShort (CORBA::ULong max) // uses max size
-  : 
+CORBA_InvalidPolicies::_tao_seq_UShort::_tao_seq_UShort	(CORBA::ULong max) // uses max size
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<CORBA::UShort>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max)
 {}
-CORBA_InvalidPolicies::_tao_seq_UShort::_tao_seq_UShort (CORBA::ULong max, CORBA::ULong length, CORBA::UShort *buffer, CORBA::Boolean release)
-  : 
+CORBA_InvalidPolicies::_tao_seq_UShort::_tao_seq_UShort	(CORBA::ULong max, CORBA::ULong	length,	CORBA::UShort *buffer, CORBA::Boolean release)
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<CORBA::UShort>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max, length, buffer, release)
 {}
-CORBA_InvalidPolicies::_tao_seq_UShort::_tao_seq_UShort (const _tao_seq_UShort &seq) // copy ctor
-  : 
+CORBA_InvalidPolicies::_tao_seq_UShort::_tao_seq_UShort	(const _tao_seq_UShort &seq) //	copy ctor
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<CORBA::UShort>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (seq)
 {}
-CORBA_InvalidPolicies::_tao_seq_UShort::~_tao_seq_UShort (void) // dtor
+CORBA_InvalidPolicies::_tao_seq_UShort::~_tao_seq_UShort (void)	// dtor
 {}
 void CORBA_InvalidPolicies::_tao_seq_UShort::_tao_any_destructor (void *x)
 {
@@ -249,35 +249,35 @@ void CORBA_InvalidPolicies::_tao_seq_UShort::_tao_any_destructor (void *x)
 
 // default constructor
 CORBA_InvalidPolicies::CORBA_InvalidPolicies (void)
-  : CORBA_UserException ("IDL:omg.org/CORBA/InvalidPolicies:1.0")
+  : CORBA_UserException	("IDL:omg.org/CORBA/InvalidPolicies:1.0")
 {
 }
 
-// destructor - all members are of self managing types
+// destructor -	all members are	of self	managing types
 CORBA_InvalidPolicies::~CORBA_InvalidPolicies (void)
 {
 }
 
-void CORBA_InvalidPolicies::_tao_any_destructor (void *x)
+void CORBA_InvalidPolicies::_tao_any_destructor	(void *x)
 {
-  CORBA_InvalidPolicies *tmp = ACE_static_cast (CORBA_InvalidPolicies*,x);
+  CORBA_InvalidPolicies	*tmp = ACE_static_cast (CORBA_InvalidPolicies*,x);
   delete tmp;
 }
 
-// copy constructor
+// copy	constructor
 CORBA_InvalidPolicies::CORBA_InvalidPolicies (const ::CORBA_InvalidPolicies &_tao_excp)
-  : CORBA_UserException (_tao_excp._id ())
+  : CORBA_UserException	(_tao_excp._id ())
 {
     this->indices = _tao_excp.indices;
 }
 
 // assignment operator
 CORBA_InvalidPolicies&
-CORBA_InvalidPolicies::operator= (const ::CORBA_InvalidPolicies &_tao_excp)
+CORBA_InvalidPolicies::operator= (const	::CORBA_InvalidPolicies	&_tao_excp)
 {
 
   this->CORBA_UserException::operator= (_tao_excp);
-  this->indices = _tao_excp.indices;
+  this->indices	= _tao_excp.indices;
   return *this;
 }
 
@@ -285,7 +285,7 @@ CORBA_InvalidPolicies::operator= (const ::CORBA_InvalidPolicies &_tao_excp)
 CORBA_InvalidPolicies *
 CORBA_InvalidPolicies::_downcast (CORBA::Exception *exc)
 {
-  if (!ACE_OS::strcmp ("IDL:omg.org/CORBA/InvalidPolicies:1.0", exc->_id ())) // same type
+  if (!ACE_OS::strcmp ("IDL:omg.org/CORBA/InvalidPolicies:1.0",	exc->_id ())) // same type
     return ACE_dynamic_cast (CORBA_InvalidPolicies *, exc);
   else
     return 0;
@@ -298,7 +298,7 @@ void CORBA_InvalidPolicies::_raise ()
 }
 
 
-void CORBA_InvalidPolicies::_tao_encode (
+void CORBA_InvalidPolicies::_tao_encode	(
     TAO_OutputCDR &cdr,
     CORBA::Environment &ACE_TRY_ENV) const
 {
@@ -308,7 +308,7 @@ void CORBA_InvalidPolicies::_tao_encode (
 }
 
 
-void CORBA_InvalidPolicies::_tao_decode (
+void CORBA_InvalidPolicies::_tao_decode	(
     TAO_InputCDR &cdr,
     CORBA::Environment &ACE_TRY_ENV)
 {
@@ -318,7 +318,7 @@ void CORBA_InvalidPolicies::_tao_decode (
 }
 
 // TAO extension - the _alloc method
-CORBA::Exception *CORBA_InvalidPolicies::_alloc (void)
+CORBA::Exception *CORBA_InvalidPolicies::_alloc	(void)
 {
   CORBA::Exception *retval = 0;
   ACE_NEW_RETURN (retval, ::CORBA_InvalidPolicies, 0);
@@ -326,20 +326,20 @@ CORBA::Exception *CORBA_InvalidPolicies::_alloc (void)
 }
 
 CORBA_InvalidPolicies::CORBA_InvalidPolicies (
-  const CORBA_InvalidPolicies::_tao_seq_UShort & _tao_indices
+  const	CORBA_InvalidPolicies::_tao_seq_UShort & _tao_indices
 )
-  : CORBA_UserException  (CORBA::string_dup ("IDL:omg.org/CORBA/InvalidPolicies:1.0"))
+  : CORBA_UserException	 (CORBA::string_dup ("IDL:omg.org/CORBA/InvalidPolicies:1.0"))
 {
     this->indices = _tao_indices;
 }
 
 static const CORBA::Long _oc_CORBA_InvalidPolicies[] =
 {
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f496e), ACE_NTOHL (0x76616c69), ACE_NTOHL (0x64506f6c), ACE_NTOHL (0x69636965), ACE_NTOHL (0x733a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA_InvalidPolicies:1.0
-  22, ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f496e), ACE_NTOHL (0x76616c69), ACE_NTOHL (0x64506f6c), ACE_NTOHL (0x69636965), ACE_NTOHL (0x73000000),  // name = CORBA_InvalidPolicies
-  1, // member count
-  8, ACE_NTOHL (0x696e6469), ACE_NTOHL (0x63657300),  // name = indices
+  TAO_ENCAP_BYTE_ORDER,	// byte	order
+  38, ACE_NTOHL	(0x49444c3a), ACE_NTOHL	(0x6f6d672e), ACE_NTOHL	(0x6f72672f), ACE_NTOHL	(0x434f5242), ACE_NTOHL	(0x415f496e), ACE_NTOHL	(0x76616c69), ACE_NTOHL	(0x64506f6c), ACE_NTOHL	(0x69636965), ACE_NTOHL	(0x733a312e), ACE_NTOHL	(0x30000000),  // repository ID	= IDL:omg.org/CORBA_InvalidPolicies:1.0
+  22, ACE_NTOHL	(0x434f5242), ACE_NTOHL	(0x415f496e), ACE_NTOHL	(0x76616c69), ACE_NTOHL	(0x64506f6c), ACE_NTOHL	(0x69636965), ACE_NTOHL	(0x73000000),  // name = CORBA_InvalidPolicies
+  1, //	member count
+  8, ACE_NTOHL (0x696e6469), ACE_NTOHL (0x63657300),  // name =	indices
   CORBA::tk_sequence, // typecode kind
   12, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
@@ -348,8 +348,8 @@ static const CORBA::Long _oc_CORBA_InvalidPolicies[] =
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_InvalidPolicies (CORBA::tk_except, sizeof (_oc_CORBA_InvalidPolicies), (char *) &_oc_CORBA_InvalidPolicies, 0, sizeof (CORBA_InvalidPolicies));
-CORBA::TypeCode_ptr _tc_CORBA_InvalidPolicies = &_tc_TAO_tc_CORBA_InvalidPolicies;
+static CORBA::TypeCode _tc_TAO_tc_CORBA_InvalidPolicies	(CORBA::tk_except, sizeof (_oc_CORBA_InvalidPolicies), (char *)	&_oc_CORBA_InvalidPolicies, 0, sizeof (CORBA_InvalidPolicies));
+CORBA::TypeCode_ptr _tc_CORBA_InvalidPolicies =	&_tc_TAO_tc_CORBA_InvalidPolicies;
 
 CORBA::TypeCode_ptr
 CORBA_InvalidPolicies::_type (void) const
@@ -378,12 +378,12 @@ CORBA_Policy_ptr CORBA_Policy::_narrow (
 {
   if (CORBA::is_nil (obj))
     return CORBA_Policy::_nil ();
-  if (! obj->_is_local ())
+  if (!	obj->_is_local ())
     {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/Policy:1.0", ACE_TRY_ENV);
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/Policy:1.0",	ACE_TRY_ENV);
       ACE_CHECK_RETURN (CORBA_Policy::_nil ());
       if (is_a == 0)
-        return CORBA_Policy::_nil ();
+	return CORBA_Policy::_nil ();
     }
   return CORBA_Policy::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
@@ -395,35 +395,35 @@ CORBA_Policy_ptr CORBA_Policy::_unchecked_narrow (
 {
   if (CORBA::is_nil (obj))
     return CORBA_Policy::_nil ();
-  if (! obj->_is_local ())
+  if (!	obj->_is_local ())
     {
-      TAO_Stub* stub = obj->_stubobj ();
+      TAO_Stub*	stub = obj->_stubobj ();
       if (stub)
-        stub->_incr_refcnt ();
+	stub->_incr_refcnt ();
       CORBA_Policy_ptr default_proxy = CORBA_Policy::_nil ();
 
-      if (obj->_is_collocated () && _TAO_collocation_CORBA_Policy_Stub_Factory_function_pointer != 0)
-        {
-          default_proxy = _TAO_collocation_CORBA_Policy_Stub_Factory_function_pointer (obj);
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, CORBA_Policy (stub), CORBA_Policy::_nil ());
-        return default_proxy;
+      if (obj->_is_collocated () && _TAO_collocation_CORBA_Policy_Stub_Factory_function_pointer	!= 0)
+	{
+	  default_proxy	= _TAO_collocation_CORBA_Policy_Stub_Factory_function_pointer (obj);
+	}
+      if (CORBA::is_nil	(default_proxy))
+	ACE_NEW_RETURN (default_proxy, CORBA_Policy (stub), CORBA_Policy::_nil ());
+	return default_proxy;
     }
-  else 
+  else
     return
       ACE_reinterpret_cast
-        (
-          CORBA_Policy_ptr,
-            obj->_tao_QueryInterface
-              (
-                ACE_reinterpret_cast
-                  (
-                    ptr_arith_t,
-                    &CORBA_Policy::_narrow
-                  )
-              )
-        );
+	(
+	  CORBA_Policy_ptr,
+	    obj->_tao_QueryInterface
+	      (
+		ACE_reinterpret_cast
+		  (
+		    ptr_arith_t,
+		    &CORBA_Policy::_narrow
+		  )
+	      )
+	);
 }
 
 CORBA_Policy_ptr
@@ -441,51 +441,52 @@ CORBA::PolicyType CORBA_Policy::policy_type (
     CORBA::SystemException
   ))
 {
-  
-  CORBA::PolicyType _tao_retval = 0;
-  
-  
+
+  CORBA::PolicyType _tao_retval	= 0;
+
+
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
     ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
 
-  
+
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "_get_policy_type",
       16,
+      0,
       istub->orb_core ()
     );
 
       for (;;)
       {
-        _tao_call.start (ACE_TRY_ENV);
-        ACE_CHECK_RETURN  (_tao_retval);
-
-        CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
-        
-        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
-        ACE_CHECK_RETURN  (_tao_retval);
-
-        int _invoke_status =
-          _tao_call.invoke (0, 0, ACE_TRY_ENV);
-                ACE_CHECK_RETURN  (_tao_retval);
-
-        if (_invoke_status == TAO_INVOKE_RESTART)
-          continue;
-        if (_invoke_status != TAO_INVOKE_OK)
-        {
-          ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
-        }
-        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-        if (!(
-              (_tao_in >> _tao_retval)
-          ))
-          ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
-        break;
-        
+	_tao_call.start	(ACE_TRY_ENV);
+	ACE_CHECK_RETURN  (_tao_retval);
+
+	CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
+
+	_tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),	ACE_TRY_ENV);
+	ACE_CHECK_RETURN  (_tao_retval);
+
+	int _invoke_status =
+	  _tao_call.invoke (0, 0, ACE_TRY_ENV);
+		ACE_CHECK_RETURN  (_tao_retval);
+
+	if (_invoke_status == TAO_INVOKE_RESTART)
+	  continue;
+	if (_invoke_status != TAO_INVOKE_OK)
+	{
+	  ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+	}
+	TAO_InputCDR &_tao_in =	_tao_call.inp_stream ();
+	if (!(
+	      (_tao_in >> _tao_retval)
+	  ))
+	  ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+	break;
+
       }
   return _tao_retval;
 }
@@ -497,54 +498,55 @@ CORBA_Policy_ptr CORBA_Policy::copy (
     CORBA::SystemException
   ))
 {
-  
+
   CORBA_Policy_ptr _tao_retval = CORBA_Policy::_nil ();
   CORBA_Policy_var _tao_safe_retval (_tao_retval);
-  
-  
+
+
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
     ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-  
+
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "copy",
       4,
+      0,
       istub->orb_core ()
     );
 
       for (;;)
       {
-        _tao_call.start (ACE_TRY_ENV);
-        ACE_CHECK_RETURN (0);
-
-        CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
-        
-        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
-        ACE_CHECK_RETURN (0);
-
-        int _invoke_status =
-          _tao_call.invoke (0, 0, ACE_TRY_ENV);
-                ACE_CHECK_RETURN (0);
-
-        if (_invoke_status == TAO_INVOKE_RESTART)
-          continue;
-        if (_invoke_status != TAO_INVOKE_OK)
-        {
-          ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
-
-        }
-        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-        if (!(
-              (_tao_in >> _tao_safe_retval.inout ())
-          ))
-          ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
-
-        break;
-        
+	_tao_call.start	(ACE_TRY_ENV);
+	ACE_CHECK_RETURN (0);
+
+	CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
+
+	_tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),	ACE_TRY_ENV);
+	ACE_CHECK_RETURN (0);
+
+	int _invoke_status =
+	  _tao_call.invoke (0, 0, ACE_TRY_ENV);
+		ACE_CHECK_RETURN (0);
+
+	if (_invoke_status == TAO_INVOKE_RESTART)
+	  continue;
+	if (_invoke_status != TAO_INVOKE_OK)
+	{
+	  ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+	}
+	TAO_InputCDR &_tao_in =	_tao_call.inp_stream ();
+	if (!(
+	      (_tao_in >> _tao_safe_retval.inout ())
+	  ))
+	  ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+	break;
+
       }
-  return _tao_safe_retval._retn ();
+  return _tao_safe_retval._retn	();
 }
 
 void CORBA_Policy::destroy (
@@ -554,46 +556,47 @@ void CORBA_Policy::destroy (
     CORBA::SystemException
   ))
 {
-  
 
-  
-  
+
+
+
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
     ACE_THROW (CORBA::INTERNAL ());
 
-  
+
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "destroy",
       7,
+      0,
       istub->orb_core ()
     );
 
 
       for (;;)
       {
-        _tao_call.start (ACE_TRY_ENV);
-        ACE_CHECK;
-
-        CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
-        
-        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
-        ACE_CHECK;
-
-        int _invoke_status =
-          _tao_call.invoke (0, 0, ACE_TRY_ENV);
-                ACE_CHECK;
-
-        if (_invoke_status == TAO_INVOKE_RESTART)
-          continue;
-        if (_invoke_status != TAO_INVOKE_OK)
-        {
-          ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
-        }
-        
-        break;
-        
+	_tao_call.start	(ACE_TRY_ENV);
+	ACE_CHECK;
+
+	CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
+
+	_tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),	ACE_TRY_ENV);
+	ACE_CHECK;
+
+	int _invoke_status =
+	  _tao_call.invoke (0, 0, ACE_TRY_ENV);
+		ACE_CHECK;
+
+	if (_invoke_status == TAO_INVOKE_RESTART)
+	  continue;
+	if (_invoke_status != TAO_INVOKE_OK)
+	{
+	  ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+	}
+
+	break;
+
       }
 
 }
@@ -608,17 +611,17 @@ CORBA::Boolean CORBA_Policy::_is_a (const CORBA::Char *value, CORBA::Environment
     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
 }
 
-void *CORBA_Policy::_tao_QueryInterface (ptr_arith_t type)
+void *CORBA_Policy::_tao_QueryInterface	(ptr_arith_t type)
 {
   void *retv = 0;
   if (type == ACE_reinterpret_cast
     (ptr_arith_t,
       &CORBA_Policy::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
+    retv = ACE_reinterpret_cast	(void*,	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;
@@ -636,56 +639,56 @@ CORBA_Policy::_tao_encode (TAO_OutputCDR &)
 }
 
 CORBA::Boolean
-CORBA_Policy::_tao_decode (TAO_InputCDR &)
+CORBA_Policy::_tao_decode (TAO_InputCDR	&)
 {
   return 0;
 }
 
 static const CORBA::Long _oc_CORBA_Policy[] =
 {
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA_Policy:1.0
-  13, ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x0),  // name = CORBA_Policy
+  TAO_ENCAP_BYTE_ORDER,	// byte	order
+  29, ACE_NTOHL	(0x49444c3a), ACE_NTOHL	(0x6f6d672e), ACE_NTOHL	(0x6f72672f), ACE_NTOHL	(0x434f5242), ACE_NTOHL	(0x415f506f), ACE_NTOHL	(0x6c696379), ACE_NTOHL	(0x3a312e30), ACE_NTOHL	(0x0),	// repository ID = IDL:omg.org/CORBA_Policy:1.0
+  13, ACE_NTOHL	(0x434f5242), ACE_NTOHL	(0x415f506f), ACE_NTOHL	(0x6c696379), ACE_NTOHL	(0x0),	// name	= CORBA_Policy
 };
 static CORBA::TypeCode _tc_TAO_tc_CORBA_Policy (CORBA::tk_objref, sizeof (_oc_CORBA_Policy), (char *) &_oc_CORBA_Policy, 0, sizeof (CORBA_Policy));
 CORBA::TypeCode_ptr _tc_CORBA_Policy = &_tc_TAO_tc_CORBA_Policy;
 
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
+
 #if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_POLICYLIST_CS_)
-#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_POLICYLIST_CS_
+#define	__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_POLICYLIST_CS_
 
   // The Base_Sequence functions, please see tao/Sequence.h
   void
   _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_allocate_buffer (CORBA::ULong length)
   {
     CORBA_Policy **tmp = 0;
-    tmp = _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::allocbuf (length);
-    
+    tmp	= _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::allocbuf (length);
+
     if (this->buffer_ != 0)
     {
-      CORBA_Policy **old = ACE_reinterpret_cast (CORBA_Policy**, this->buffer_);
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        if (!this->release_)
-          tmp[i] = CORBA_Policy::_duplicate (old[i]);
-        else
-          tmp[i] = old[i];
-        
+      CORBA_Policy **old = ACE_reinterpret_cast	(CORBA_Policy**, this->buffer_);
+      for (CORBA::ULong	i = 0; i < this->length_; ++i)
+	if (!this->release_)
+	  tmp[i] = CORBA_Policy::_duplicate (old[i]);
+	else
+	  tmp[i] = old[i];
+
       if (this->release_)
-        delete[] old;
-      
+	delete[] old;
+
     }
     this->buffer_ = tmp;
   }
-  
+
   void
   _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_deallocate_buffer (void)
   {
-    if (this->buffer_ == 0 || this->release_ == 0)
+    if (this->buffer_ == 0 || this->release_ ==	0)
       return;
     CORBA_Policy **tmp = ACE_reinterpret_cast (CORBA_Policy**, this->buffer_);
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    for	(CORBA::ULong i	= 0; i < this->length_;	++i)
     {
       CORBA::release (tmp[i]);
       tmp[i] = CORBA_Policy::_nil ();
@@ -693,28 +696,28 @@ CORBA::TypeCode_ptr _tc_CORBA_Policy = &_tc_TAO_tc_CORBA_Policy;
     _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::freebuf (tmp);
     this->buffer_ = 0;
   }
-  
+
   _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::~_TAO_Unbounded_Object_Sequence_CORBA_PolicyList (void)
   {
     this->_deallocate_buffer ();
   }
-  
+
   void
-  _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_shrink_buffer (CORBA::ULong	nl, CORBA::ULong ol)
   {
     CORBA_Policy **tmp = ACE_reinterpret_cast (CORBA_Policy**, this->buffer_);
-    
-    for (CORBA::ULong i = nl; i < ol; ++i)
+
+    for	(CORBA::ULong i	= nl; i	< ol; ++i)
     {
       CORBA::release (tmp[i]);
       tmp[i] = CORBA_Policy::_nil ();
     }
   }
-  void 
+  void
   _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_downcast (
       void* target,
       CORBA_Object *src,
-      CORBA_Environment &ACE_TRY_ENV
+      CORBA_Environment	&ACE_TRY_ENV
     )
   {
     CORBA_Policy **tmp = ACE_static_cast (CORBA_Policy**, target);
@@ -727,14 +730,14 @@ CORBA::TypeCode_ptr _tc_CORBA_Policy = &_tc_TAO_tc_CORBA_Policy;
     CORBA_Policy **tmp = ACE_static_cast (CORBA_Policy**, src);
     return *tmp;
   }
-  
+
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 
 #if !defined (_CORBA_POLICYLIST_CS_)
-#define _CORBA_POLICYLIST_CS_
+#define	_CORBA_POLICYLIST_CS_
 
 // *************************************************************
 // CORBA_PolicyList
@@ -743,53 +746,53 @@ CORBA::TypeCode_ptr _tc_CORBA_Policy = &_tc_TAO_tc_CORBA_Policy;
 CORBA_PolicyList::CORBA_PolicyList (void)
 {}
 CORBA_PolicyList::CORBA_PolicyList (CORBA::ULong max) // uses max size
-  : 
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Object_Sequence_CORBA_PolicyList
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Object_Sequence<CORBA_Policy,CORBA_Policy_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max)
 {}
 CORBA_PolicyList::CORBA_PolicyList (CORBA::ULong max, CORBA::ULong length, CORBA_Policy_ptr *buffer, CORBA::Boolean release)
-  : 
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Object_Sequence_CORBA_PolicyList
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Object_Sequence<CORBA_Policy,CORBA_Policy_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max, length, buffer, release)
 {}
 CORBA_PolicyList::CORBA_PolicyList (const CORBA_PolicyList &seq) // copy ctor
-  : 
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Object_Sequence_CORBA_PolicyList
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Object_Sequence<CORBA_Policy,CORBA_Policy_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (seq)
 {}
 CORBA_PolicyList::~CORBA_PolicyList (void) // dtor
 {}
 void CORBA_PolicyList::_tao_any_destructor (void *x)
 {
-  CORBA_PolicyList *tmp = ACE_static_cast (CORBA_PolicyList*,x);
+  CORBA_PolicyList *tmp	= ACE_static_cast (CORBA_PolicyList*,x);
   delete tmp;
 }
 
 
 #endif /* end #if !defined */
 
-static const CORBA::Long _oc_CORBA_PolicyList[] =
+static const CORBA::Long _oc_CORBA_PolicyList[]	=
 {
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x4c697374), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA_PolicyList:1.0
-  17, ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x4c697374), ACE_NTOHL (0x0),  // name = CORBA_PolicyList
+  TAO_ENCAP_BYTE_ORDER,	// byte	order
+  33, ACE_NTOHL	(0x49444c3a), ACE_NTOHL	(0x6f6d672e), ACE_NTOHL	(0x6f72672f), ACE_NTOHL	(0x434f5242), ACE_NTOHL	(0x415f506f), ACE_NTOHL	(0x6c696379), ACE_NTOHL	(0x4c697374), ACE_NTOHL	(0x3a312e30), ACE_NTOHL	(0x0),	// repository ID = IDL:omg.org/CORBA_PolicyList:1.0
+  17, ACE_NTOHL	(0x434f5242), ACE_NTOHL	(0x415f506f), ACE_NTOHL	(0x6c696379), ACE_NTOHL	(0x4c697374), ACE_NTOHL	(0x0),	// name	= CORBA_PolicyList
   CORBA::tk_sequence, // typecode kind
   76, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
     CORBA::tk_objref, // typecode kind
-    60, // encapsulation length
+    60,	// encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
       29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA_Policy:1.0
       13, ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x0),  // name = CORBA_Policy
@@ -802,55 +805,55 @@ CORBA::TypeCode_ptr _tc_CORBA_PolicyList = &_tc_TAO_tc_CORBA_PolicyList;
 
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
+
 #if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_POLICYTYPESEQ_CS_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_POLICYTYPESEQ_CS_
+#define	__TAO_UNBOUNDED_SEQUENCE_CORBA_POLICYTYPESEQ_CS_
 
   void
-  _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::_allocate_buffer (CORBA::ULong length)
+  _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::_allocate_buffer	(CORBA::ULong length)
   {
-    CORBA::ULong* tmp = 0;
-    tmp = _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::allocbuf (length);
-    
+    CORBA::ULong* tmp =	0;
+    tmp	= _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::allocbuf	(length);
+
     if (this->buffer_ != 0)
     {
-      CORBA::ULong *old = ACE_reinterpret_cast (CORBA::ULong *,this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp[i] = old[i];
-      
+      CORBA::ULong *old	= ACE_reinterpret_cast (CORBA::ULong *,this->buffer_);
+
+      for (CORBA::ULong	i = 0; i < this->length_; ++i)
+	tmp[i] = old[i];
+
       if (this->release_)
-        _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::freebuf (old);
-      
+	_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::freebuf (old);
+
     }
     this->buffer_ = tmp;
   }
-  
+
   void
   _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::_deallocate_buffer (void)
   {
-    if (this->buffer_ == 0 || this->release_ == 0)
+    if (this->buffer_ == 0 || this->release_ ==	0)
       return;
-    
-    CORBA::ULong *tmp = ACE_reinterpret_cast (CORBA::ULong *,this->buffer_);
-    
+
+    CORBA::ULong *tmp =	ACE_reinterpret_cast (CORBA::ULong *,this->buffer_);
+
     _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::freebuf (tmp);
     this->buffer_ = 0;
-  } 
-  
+  }
+
   _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::~_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (void) // Dtor.
   {
     this->_deallocate_buffer ();
   }
-  
-  
+
+
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 
 #if !defined (_CORBA_POLICYTYPESEQ_CS_)
-#define _CORBA_POLICYTYPESEQ_CS_
+#define	_CORBA_POLICYTYPESEQ_CS_
 
 // *************************************************************
 // CORBA_PolicyTypeSeq
@@ -858,31 +861,31 @@ CORBA::TypeCode_ptr _tc_CORBA_PolicyList = &_tc_TAO_tc_CORBA_PolicyList;
 
 CORBA_PolicyTypeSeq::CORBA_PolicyTypeSeq (void)
 {}
-CORBA_PolicyTypeSeq::CORBA_PolicyTypeSeq (CORBA::ULong max) // uses max size
-  : 
+CORBA_PolicyTypeSeq::CORBA_PolicyTypeSeq (CORBA::ULong max) // uses max	size
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<CORBA::ULong>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max)
 {}
 CORBA_PolicyTypeSeq::CORBA_PolicyTypeSeq (CORBA::ULong max, CORBA::ULong length, CORBA::ULong *buffer, CORBA::Boolean release)
-  : 
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<CORBA::ULong>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max, length, buffer, release)
 {}
-CORBA_PolicyTypeSeq::CORBA_PolicyTypeSeq (const CORBA_PolicyTypeSeq &seq) // copy ctor
-  : 
+CORBA_PolicyTypeSeq::CORBA_PolicyTypeSeq (const	CORBA_PolicyTypeSeq &seq) // copy ctor
+  :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<CORBA::ULong>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (seq)
 {}
 CORBA_PolicyTypeSeq::~CORBA_PolicyTypeSeq (void) // dtor
@@ -898,14 +901,14 @@ void CORBA_PolicyTypeSeq::_tao_any_destructor (void *x)
 
 static const CORBA::Long _oc_CORBA_PolicyTypeSeq[] =
 {
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x54797065), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA_PolicyTypeSeq:1.0
-  20, ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x54797065), ACE_NTOHL (0x53657100),  // name = CORBA_PolicyTypeSeq
+  TAO_ENCAP_BYTE_ORDER,	// byte	order
+  36, ACE_NTOHL	(0x49444c3a), ACE_NTOHL	(0x6f6d672e), ACE_NTOHL	(0x6f72672f), ACE_NTOHL	(0x434f5242), ACE_NTOHL	(0x415f506f), ACE_NTOHL	(0x6c696379), ACE_NTOHL	(0x54797065), ACE_NTOHL	(0x5365713a), ACE_NTOHL	(0x312e3000),  // repository ID	= IDL:omg.org/CORBA_PolicyTypeSeq:1.0
+  20, ACE_NTOHL	(0x434f5242), ACE_NTOHL	(0x415f506f), ACE_NTOHL	(0x6c696379), ACE_NTOHL	(0x54797065), ACE_NTOHL	(0x53657100),  // name = CORBA_PolicyTypeSeq
   CORBA::tk_sequence, // typecode kind
   80, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_alias, // typecode kind for typedefs
-    64, // encapsulation length
+    CORBA::tk_alias, //	typecode kind for typedefs
+    64,	// encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
       33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x54797065), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/PolicyType:1.0
       11, ACE_NTOHL (0x506f6c69), ACE_NTOHL (0x63795479), ACE_NTOHL (0x70650000),  // name = PolicyType
@@ -915,7 +918,7 @@ static const CORBA::Long _oc_CORBA_PolicyTypeSeq[] =
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_PolicyTypeSeq (CORBA::tk_alias, sizeof (_oc_CORBA_PolicyTypeSeq), (char *) &_oc_CORBA_PolicyTypeSeq, 0, sizeof (CORBA_PolicyTypeSeq));
+static CORBA::TypeCode _tc_TAO_tc_CORBA_PolicyTypeSeq (CORBA::tk_alias,	sizeof (_oc_CORBA_PolicyTypeSeq), (char	*) &_oc_CORBA_PolicyTypeSeq, 0,	sizeof (CORBA_PolicyTypeSeq));
 CORBA::TypeCode_ptr _tc_CORBA_PolicyTypeSeq = &_tc_TAO_tc_CORBA_PolicyTypeSeq;
 
 
@@ -927,15 +930,15 @@ CORBA_PolicyManager::CORBA_PolicyManager (void)
 CORBA_PolicyManager::~CORBA_PolicyManager (void)
 {}
 
-CORBA_PolicyManager_ptr CORBA_PolicyManager::_narrow (
+CORBA_PolicyManager_ptr	CORBA_PolicyManager::_narrow (
     CORBA::Object_ptr obj,
     CORBA::Environment &ACE_TRY_ENV
   )
 {
-  return CORBA_PolicyManager::_unchecked_narrow (obj, ACE_TRY_ENV);
+  return CORBA_PolicyManager::_unchecked_narrow	(obj, ACE_TRY_ENV);
 }
 
-CORBA_PolicyManager_ptr CORBA_PolicyManager::_unchecked_narrow (
+CORBA_PolicyManager_ptr	CORBA_PolicyManager::_unchecked_narrow (
     CORBA::Object_ptr obj,
     CORBA::Environment &
   )
@@ -944,21 +947,21 @@ CORBA_PolicyManager_ptr CORBA_PolicyManager::_unchecked_narrow (
     return CORBA_PolicyManager::_nil ();
   return
       ACE_reinterpret_cast
-        (
-          CORBA_PolicyManager_ptr,
-            obj->_tao_QueryInterface
-              (
-                ACE_reinterpret_cast
-                  (
-                    ptr_arith_t,
-                    &CORBA_PolicyManager::_narrow
-                  )
-              )
-        );
+	(
+	  CORBA_PolicyManager_ptr,
+	    obj->_tao_QueryInterface
+	      (
+		ACE_reinterpret_cast
+		  (
+		    ptr_arith_t,
+		    &CORBA_PolicyManager::_narrow
+		  )
+	      )
+	);
 }
 
 CORBA_PolicyManager_ptr
-CORBA_PolicyManager::_duplicate (CORBA_PolicyManager_ptr obj)
+CORBA_PolicyManager::_duplicate	(CORBA_PolicyManager_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_add_ref ();
@@ -971,11 +974,11 @@ void *CORBA_PolicyManager::_tao_QueryInterface (ptr_arith_t type)
   if (type == ACE_reinterpret_cast
     (ptr_arith_t,
       &CORBA_PolicyManager::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
+    retv = ACE_reinterpret_cast	(void*,	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;
@@ -995,15 +998,15 @@ CORBA_PolicyCurrent::CORBA_PolicyCurrent (void)
 CORBA_PolicyCurrent::~CORBA_PolicyCurrent (void)
 {}
 
-CORBA_PolicyCurrent_ptr CORBA_PolicyCurrent::_narrow (
+CORBA_PolicyCurrent_ptr	CORBA_PolicyCurrent::_narrow (
     CORBA::Object_ptr obj,
     CORBA::Environment &ACE_TRY_ENV
   )
 {
-  return CORBA_PolicyCurrent::_unchecked_narrow (obj, ACE_TRY_ENV);
+  return CORBA_PolicyCurrent::_unchecked_narrow	(obj, ACE_TRY_ENV);
 }
 
-CORBA_PolicyCurrent_ptr CORBA_PolicyCurrent::_unchecked_narrow (
+CORBA_PolicyCurrent_ptr	CORBA_PolicyCurrent::_unchecked_narrow (
     CORBA::Object_ptr obj,
     CORBA::Environment &
   )
@@ -1012,21 +1015,21 @@ CORBA_PolicyCurrent_ptr CORBA_PolicyCurrent::_unchecked_narrow (
     return CORBA_PolicyCurrent::_nil ();
   return
       ACE_reinterpret_cast
-        (
-          CORBA_PolicyCurrent_ptr,
-            obj->_tao_QueryInterface
-              (
-                ACE_reinterpret_cast
-                  (
-                    ptr_arith_t,
-                    &CORBA_PolicyCurrent::_narrow
-                  )
-              )
-        );
+	(
+	  CORBA_PolicyCurrent_ptr,
+	    obj->_tao_QueryInterface
+	      (
+		ACE_reinterpret_cast
+		  (
+		    ptr_arith_t,
+		    &CORBA_PolicyCurrent::_narrow
+		  )
+	      )
+	);
 }
 
 CORBA_PolicyCurrent_ptr
-CORBA_PolicyCurrent::_duplicate (CORBA_PolicyCurrent_ptr obj)
+CORBA_PolicyCurrent::_duplicate	(CORBA_PolicyCurrent_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_add_ref ();
@@ -1039,35 +1042,35 @@ void *CORBA_PolicyCurrent::_tao_QueryInterface (ptr_arith_t type)
   if (type == ACE_reinterpret_cast
     (ptr_arith_t,
       &CORBA_PolicyCurrent::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
+    retv = ACE_reinterpret_cast	(void*,	this);
+  else if (type	== ACE_reinterpret_cast
     (ptr_arith_t,
       &CORBA_PolicyManager::_narrow))
     retv = ACE_reinterpret_cast
       (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_PolicyManager_ptr,
-            this
-          )
+	void *,
+	ACE_static_cast
+	  (
+	    CORBA_PolicyManager_ptr,
+	    this
+	  )
       );
-  else if (type == ACE_reinterpret_cast
+  else if (type	== ACE_reinterpret_cast
     (ptr_arith_t,
       &CORBA_Current::_narrow))
     retv = ACE_reinterpret_cast
       (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_Current_ptr,
-            this
-          )
+	void *,
+	ACE_static_cast
+	  (
+	    CORBA_Current_ptr,
+	    this
+	  )
       );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
+  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;
@@ -1078,30 +1081,30 @@ const char* CORBA_PolicyCurrent::_interface_repository_id (void) const
   return "IDL:omg.org/CORBA/PolicyCurrent:1.0";
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::SetOverrideType _tao_elem)
+void operator<<= (CORBA::Any &_tao_any,	CORBA::SetOverrideType _tao_elem)
 {
-  TAO_OutputCDR stream;
+  TAO_OutputCDR	stream;
   stream << _tao_elem;
-  _tao_any._tao_replace (
+  _tao_any._tao_replace	(
       CORBA::_tc_SetOverrideType,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin ()
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::SetOverrideType &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	CORBA::SetOverrideType &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_SetOverrideType, ACE_TRY_ENV)) // not equal
+    CORBA::TypeCode_var	type = _tao_any.type ();
+    if (!type->equivalent (CORBA::_tc_SetOverrideType, ACE_TRY_ENV)) //	not equal
       {
-        return 0;
+	return 0;
       }
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
+    TAO_InputCDR stream	(
+	_tao_any._tao_get_cdr (),
+	_tao_any._tao_byte_order ()
       );
     if (stream >> _tao_elem)
     {
@@ -1116,22 +1119,22 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::SetOverrideType &
   return 0;
 }
 
-void operator<<= (CORBA::Any &_tao_any, const CORBA_PolicyError &_tao_elem) // copying
+void operator<<= (CORBA::Any &_tao_any,	const CORBA_PolicyError	&_tao_elem) // copying
 {
-  TAO_OutputCDR stream;
+  TAO_OutputCDR	stream;
   stream << _tao_elem;
-  _tao_any._tao_replace (
+  _tao_any._tao_replace	(
       _tc_CORBA_PolicyError,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin ()
     );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA_PolicyError *_tao_elem) // non copying
+void operator<<= (CORBA::Any &_tao_any,	CORBA_PolicyError *_tao_elem) // non copying
 {
-  TAO_OutputCDR stream;
+  TAO_OutputCDR	stream;
   stream << *_tao_elem;
-  _tao_any._tao_replace (
+  _tao_any._tao_replace	(
       _tc_CORBA_PolicyError,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin (),
@@ -1141,7 +1144,7 @@ void operator<<= (CORBA::Any &_tao_any, CORBA_PolicyError *_tao_elem) // non cop
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyError *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	CORBA_PolicyError *&_tao_elem)
 {
   return _tao_any >>= ACE_const_cast(
       const CORBA_PolicyError*&,
@@ -1149,51 +1152,51 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyError *&_tao
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_PolicyError *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	const CORBA_PolicyError	*&_tao_elem)
 {
   _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (_tc_CORBA_PolicyError, ACE_TRY_ENV)) // not equal
+    CORBA::TypeCode_var	type = _tao_any.type ();
+    if (!type->equivalent (_tc_CORBA_PolicyError, ACE_TRY_ENV))	// not equal
       {
-        return 0;
+	return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA_PolicyError *)_tao_any.value ();
+      _tao_elem	= (CORBA_PolicyError *)_tao_any.value ();
       return 1;
     }
     else
     {
-      CORBA_PolicyError *tmp;
+      CORBA_PolicyError	*tmp;
       ACE_NEW_RETURN (tmp, CORBA_PolicyError, 0);
       TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      CORBA::String_var interface_repository_id;
+	  _tao_any._tao_get_cdr	(),
+	  _tao_any._tao_byte_order ()
+	);
+      CORBA::String_var	interface_repository_id;
       if (!(stream >> interface_repository_id.out ()))
-        return 0;
+	return 0;
       if (ACE_OS::strcmp (
-          interface_repository_id.in (),
-          "IDL:omg.org/CORBA/PolicyError:1.0"))
-        return 0;
+	  interface_repository_id.in (),
+	  "IDL:omg.org/CORBA/PolicyError:1.0"))
+	return 0;
       if (stream >> *tmp)
       {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            _tc_CORBA_PolicyError,
-            1,
-            tmp,
-            CORBA_PolicyError::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
+	((CORBA::Any *)&_tao_any)->_tao_replace	(
+	    _tc_CORBA_PolicyError,
+	    1,
+	    tmp,
+	    CORBA_PolicyError::_tao_any_destructor
+	  );
+	_tao_elem = tmp;
+	return 1;
       }
       else
       {
-        delete tmp;
+	delete tmp;
       }
     }
   }
@@ -1204,22 +1207,22 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_PolicyError
   return 0;
 }
 
-void operator<<= (CORBA::Any &_tao_any, const CORBA_InvalidPolicies &_tao_elem) // copying
+void operator<<= (CORBA::Any &_tao_any,	const CORBA_InvalidPolicies &_tao_elem)	// copying
 {
-  TAO_OutputCDR stream;
+  TAO_OutputCDR	stream;
   stream << _tao_elem;
-  _tao_any._tao_replace (
+  _tao_any._tao_replace	(
       _tc_CORBA_InvalidPolicies,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin ()
     );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA_InvalidPolicies *_tao_elem) // non copying
+void operator<<= (CORBA::Any &_tao_any,	CORBA_InvalidPolicies *_tao_elem) // non copying
 {
-  TAO_OutputCDR stream;
+  TAO_OutputCDR	stream;
   stream << *_tao_elem;
-  _tao_any._tao_replace (
+  _tao_any._tao_replace	(
       _tc_CORBA_InvalidPolicies,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin (),
@@ -1229,7 +1232,7 @@ void operator<<= (CORBA::Any &_tao_any, CORBA_InvalidPolicies *_tao_elem) // non
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_InvalidPolicies *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	CORBA_InvalidPolicies *&_tao_elem)
 {
   return _tao_any >>= ACE_const_cast(
       const CORBA_InvalidPolicies*&,
@@ -1237,20 +1240,20 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_InvalidPolicies *&
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_InvalidPolicies *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	const CORBA_InvalidPolicies *&_tao_elem)
 {
   _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
-    CORBA::TypeCode_var type = _tao_any.type ();
+    CORBA::TypeCode_var	type = _tao_any.type ();
     if (!type->equivalent (_tc_CORBA_InvalidPolicies, ACE_TRY_ENV)) // not equal
       {
-        return 0;
+	return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA_InvalidPolicies *)_tao_any.value ();
+      _tao_elem	= (CORBA_InvalidPolicies *)_tao_any.value ();
       return 1;
     }
     else
@@ -1258,30 +1261,30 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_InvalidPolic
       CORBA_InvalidPolicies *tmp;
       ACE_NEW_RETURN (tmp, CORBA_InvalidPolicies, 0);
       TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      CORBA::String_var interface_repository_id;
+	  _tao_any._tao_get_cdr	(),
+	  _tao_any._tao_byte_order ()
+	);
+      CORBA::String_var	interface_repository_id;
       if (!(stream >> interface_repository_id.out ()))
-        return 0;
+	return 0;
       if (ACE_OS::strcmp (
-          interface_repository_id.in (),
-          "IDL:omg.org/CORBA/InvalidPolicies:1.0"))
-        return 0;
+	  interface_repository_id.in (),
+	  "IDL:omg.org/CORBA/InvalidPolicies:1.0"))
+	return 0;
       if (stream >> *tmp)
       {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            _tc_CORBA_InvalidPolicies,
-            1,
-            tmp,
-            CORBA_InvalidPolicies::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
+	((CORBA::Any *)&_tao_any)->_tao_replace	(
+	    _tc_CORBA_InvalidPolicies,
+	    1,
+	    tmp,
+	    CORBA_InvalidPolicies::_tao_any_destructor
+	  );
+	_tao_elem = tmp;
+	return 1;
       }
       else
       {
-        delete tmp;
+	delete tmp;
       }
     }
   }
@@ -1292,54 +1295,54 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_InvalidPolic
   return 0;
 }
 
-CORBA_Policy_ptr (*_TAO_collocation_CORBA_Policy_Stub_Factory_function_pointer) (
+CORBA_Policy_ptr (*_TAO_collocation_CORBA_Policy_Stub_Factory_function_pointer)	(
     CORBA::Object_ptr obj
   ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA_Policy_ptr _tao_elem)
+void operator<<= (CORBA::Any &_tao_any,	CORBA_Policy_ptr _tao_elem)
 {
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
+  TAO_OutputCDR	stream;
+  if (stream <<	_tao_elem)
   {
     _tao_any._tao_replace (
-        _tc_CORBA_Policy, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        CORBA_Policy::_duplicate (_tao_elem),
-        CORBA_Policy::_tao_any_destructor
+	_tc_CORBA_Policy,
+	TAO_ENCAP_BYTE_ORDER,
+	stream.begin (),
+	1,
+	CORBA_Policy::_duplicate (_tao_elem),
+	CORBA_Policy::_tao_any_destructor
       );
   }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_Policy_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	CORBA_Policy_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA_Policy::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
+    _tao_elem =	CORBA_Policy::_nil ();
+    CORBA::TypeCode_var	type = _tao_any.type ();
     if (!type->equivalent (_tc_CORBA_Policy, ACE_TRY_ENV)) // not equal
       {
-        return 0;
+	return 0;
       }
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
+    TAO_InputCDR stream	(
+	_tao_any._tao_get_cdr (),
+	_tao_any._tao_byte_order ()
       );
     if (stream >> _tao_elem)
     {
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          _tc_CORBA_Policy,
-          1,
-          _tao_elem,
-          CORBA_Policy::_tao_any_destructor
-        );
+	  _tc_CORBA_Policy,
+	  1,
+	  _tao_elem,
+	  CORBA_Policy::_tao_any_destructor
+	);
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA_Policy::_nil ();
+    _tao_elem =	CORBA_Policy::_nil ();
     return 0;
   }
   ACE_ENDTRY;
@@ -1350,8 +1353,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_Policy_ptr &_tao_e
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
     template class TAO_Object_Manager<CORBA_Policy,CORBA_Policy_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<CORBA_Policy,CORBA_Policy_var>
+  #elif	defined	(ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate	TAO_Object_Manager<CORBA_Policy,CORBA_Policy_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
 void operator<<= (
@@ -1359,22 +1362,22 @@ void operator<<= (
     const CORBA_PolicyList &_tao_elem
   ) // copying
 {
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
+  TAO_OutputCDR	stream;
+  if (stream <<	_tao_elem)
   {
     _tao_any._tao_replace (
-        _tc_CORBA_PolicyList,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
+	_tc_CORBA_PolicyList,
+	TAO_ENCAP_BYTE_ORDER,
+	stream.begin ()
       );
   }
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA_PolicyList *_tao_elem) // non copying
+void operator<<= (CORBA::Any &_tao_any,	CORBA_PolicyList *_tao_elem) //	non copying
 {
-  TAO_OutputCDR stream;
+  TAO_OutputCDR	stream;
   stream << *_tao_elem;
-  _tao_any._tao_replace (
+  _tao_any._tao_replace	(
       _tc_CORBA_PolicyList,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin (),
@@ -1384,7 +1387,7 @@ void operator<<= (CORBA::Any &_tao_any, CORBA_PolicyList *_tao_elem) // non copy
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyList *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	CORBA_PolicyList *&_tao_elem)
 {
   return _tao_any >>= ACE_const_cast(
       const CORBA_PolicyList*&,
@@ -1392,23 +1395,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyList *&_tao_
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_PolicyList *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	const CORBA_PolicyList *&_tao_elem)
 {
   _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
-    CORBA::TypeCode_var type = _tao_any.type ();
+    CORBA::TypeCode_var	type = _tao_any.type ();
     if (!type->equivalent (_tc_CORBA_PolicyList, ACE_TRY_ENV)) // not equal
       {
-        return 0;
+	return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = ACE_static_cast(
-          const CORBA_PolicyList*,
-          _tao_any.value ()
-        );
+      _tao_elem	= ACE_static_cast(
+	  const	CORBA_PolicyList*,
+	  _tao_any.value ()
+	);
       return 1;
     }
     else
@@ -1416,23 +1419,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_PolicyList *
       CORBA_PolicyList *tmp;
       ACE_NEW_RETURN (tmp, CORBA_PolicyList, 0);
       TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
+	  _tao_any._tao_get_cdr	(),
+	  _tao_any._tao_byte_order ()
+	);
       if (stream >> *tmp)
       {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            _tc_CORBA_PolicyList,
-            1,
-            ACE_static_cast (void *, tmp),
-            CORBA_PolicyList::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
+	((CORBA::Any *)&_tao_any)->_tao_replace	(
+	    _tc_CORBA_PolicyList,
+	    1,
+	    ACE_static_cast (void *, tmp),
+	    CORBA_PolicyList::_tao_any_destructor
+	  );
+	_tao_elem = tmp;
+	return 1;
       }
       else
       {
-        delete tmp;
+	delete tmp;
       }
     }
   }
@@ -1448,22 +1451,22 @@ void operator<<= (
     const CORBA_PolicyTypeSeq &_tao_elem
   ) // copying
 {
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
+  TAO_OutputCDR	stream;
+  if (stream <<	_tao_elem)
   {
     _tao_any._tao_replace (
-        _tc_CORBA_PolicyTypeSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
+	_tc_CORBA_PolicyTypeSeq,
+	TAO_ENCAP_BYTE_ORDER,
+	stream.begin ()
       );
   }
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA_PolicyTypeSeq *_tao_elem) // non copying
+void operator<<= (CORBA::Any &_tao_any,	CORBA_PolicyTypeSeq *_tao_elem)	// non copying
 {
-  TAO_OutputCDR stream;
+  TAO_OutputCDR	stream;
   stream << *_tao_elem;
-  _tao_any._tao_replace (
+  _tao_any._tao_replace	(
       _tc_CORBA_PolicyTypeSeq,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin (),
@@ -1473,7 +1476,7 @@ void operator<<= (CORBA::Any &_tao_any, CORBA_PolicyTypeSeq *_tao_elem) // non c
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyTypeSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	CORBA_PolicyTypeSeq *&_tao_elem)
 {
   return _tao_any >>= ACE_const_cast(
       const CORBA_PolicyTypeSeq*&,
@@ -1481,47 +1484,47 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyTypeSeq *&_t
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_PolicyTypeSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	const CORBA_PolicyTypeSeq *&_tao_elem)
 {
   _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
-    CORBA::TypeCode_var type = _tao_any.type ();
+    CORBA::TypeCode_var	type = _tao_any.type ();
     if (!type->equivalent (_tc_CORBA_PolicyTypeSeq, ACE_TRY_ENV)) // not equal
       {
-        return 0;
+	return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = ACE_static_cast(
-          const CORBA_PolicyTypeSeq*,
-          _tao_any.value ()
-        );
+      _tao_elem	= ACE_static_cast(
+	  const	CORBA_PolicyTypeSeq*,
+	  _tao_any.value ()
+	);
       return 1;
     }
     else
     {
       CORBA_PolicyTypeSeq *tmp;
-      ACE_NEW_RETURN (tmp, CORBA_PolicyTypeSeq, 0);
+      ACE_NEW_RETURN (tmp, CORBA_PolicyTypeSeq,	0);
       TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
+	  _tao_any._tao_get_cdr	(),
+	  _tao_any._tao_byte_order ()
+	);
       if (stream >> *tmp)
       {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            _tc_CORBA_PolicyTypeSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            CORBA_PolicyTypeSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
+	((CORBA::Any *)&_tao_any)->_tao_replace	(
+	    _tc_CORBA_PolicyTypeSeq,
+	    1,
+	    ACE_static_cast (void *, tmp),
+	    CORBA_PolicyTypeSeq::_tao_any_destructor
+	  );
+	_tao_elem = tmp;
+	return 1;
       }
       else
       {
-        delete tmp;
+	delete tmp;
       }
     }
   }
@@ -1535,20 +1538,20 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_PolicyTypeSe
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
     template class TAO_Object_Manager<CORBA_PolicyManager,CORBA_PolicyManager_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<CORBA_PolicyManager,CORBA_PolicyManager_var>
+  #elif	defined	(ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate	TAO_Object_Manager<CORBA_PolicyManager,CORBA_PolicyManager_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
     template class TAO_Object_Manager<CORBA_PolicyCurrent,CORBA_PolicyCurrent_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<CORBA_PolicyCurrent,CORBA_PolicyCurrent_var>
+  #elif	defined	(ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate	TAO_Object_Manager<CORBA_PolicyCurrent,CORBA_PolicyCurrent_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
 
 #if !defined _TAO_CDR_OP_CORBA_InvalidPolicies__tao_seq_UShort_CPP_
-#define _TAO_CDR_OP_CORBA_InvalidPolicies__tao_seq_UShort_CPP_
+#define	_TAO_CDR_OP_CORBA_InvalidPolicies__tao_seq_UShort_CPP_
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
@@ -1573,11 +1576,11 @@ CORBA::Boolean operator>> (
   {
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
+    // If length is 0 we return	true.
+    if (0 >= _tao_seq_len)
       return 1;
-    // retrieve all the elements
-    return strm.read_ushort_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
+    // retrieve	all the	elements
+    return strm.read_ushort_array (_tao_sequence.get_buffer (),	_tao_sequence.length ());
   }
   return 0; // error
 }
@@ -1593,9 +1596,9 @@ CORBA::Boolean operator<< (
   {
     // encode all elements
     CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    for	(CORBA::ULong i	= 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
     {
-      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+      _tao_marshal_flag	= (strm	<< _tao_sequence[i].in ());
     }
     return _tao_marshal_flag;
   }
@@ -1612,14 +1615,14 @@ CORBA::Boolean operator>> (
   {
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
+    // If length is 0 we return	true.
+    if (0 >= _tao_seq_len)
       return 1;
-    // retrieve all the elements
+    // retrieve	all the	elements
     CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    for	(CORBA::ULong i	= 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
     {
-      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+      _tao_marshal_flag	= (strm	>> _tao_sequence[i].out	());
     }
     return _tao_marshal_flag;
   }
@@ -1634,14 +1637,14 @@ CORBA::Boolean operator<< (
   if (strm << _tao_sequence.length ())
   {
     // encode all elements
-    return strm.write_ulong_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
+    return strm.write_ulong_array (_tao_sequence.get_buffer (),	_tao_sequence.length ());
   }
   return 0; // error
 }
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    CORBA_PolicyTypeSeq &_tao_sequence
+    CORBA_PolicyTypeSeq	&_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;
@@ -1649,10 +1652,10 @@ CORBA::Boolean operator>> (
   {
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
+    // If length is 0 we return	true.
+    if (0 >= _tao_seq_len)
       return 1;
-    // retrieve all the elements
+    // retrieve	all the	elements
     return strm.read_ulong_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
   }
   return 0; // error
diff --git a/TAO/tao/PortableServer/ImplRepoC.cpp b/TAO/tao/PortableServer/ImplRepoC.cpp
index 840f65855c6..c89cc142e1b 100644
--- a/TAO/tao/PortableServer/ImplRepoC.cpp
+++ b/TAO/tao/PortableServer/ImplRepoC.cpp
@@ -1,11 +1,11 @@
 /* -*- 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
-// Distributed Object Computing at Washington University, St. Louis.
+// ******  Code	generated by the The ACE ORB (TAO) IDL Compiler	*******
+// TAO and the TAO IDL Compiler	have been developed by the Center for
+// Distributed Object Computing	at Washington University, St. Louis.
 //
 // Information about TAO is available at:
-//                 http://www.cs.wustl.edu/~schmidt/TAO.html
+//		   http://www.cs.wustl.edu/~schmidt/TAO.html
 
 #include "ImplRepoC.h"
 #include "tao/Stub.h"
@@ -19,7 +19,7 @@
 
 void ImplementationRepository::ServerObject::_tao_any_destructor (void *x)
 {
-  ImplementationRepository::ServerObject *tmp = ACE_static_cast (ImplementationRepository::ServerObject*,x);
+  ImplementationRepository::ServerObject *tmp =	ACE_static_cast	(ImplementationRepository::ServerObject*,x);
   CORBA::release (tmp);
 }
 
@@ -30,7 +30,7 @@ ImplementationRepository::ServerObject_ptr ImplementationRepository::ServerObjec
 {
   if (CORBA::is_nil (obj))
     return ServerObject::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:ImplementationRepository/ServerObject:1.0", ACE_TRY_ENV);
+  CORBA::Boolean is_a =	obj->_is_a ("IDL:ImplementationRepository/ServerObject:1.0", ACE_TRY_ENV);
   ACE_CHECK_RETURN (ServerObject::_nil ());
   if (is_a == 0)
     return ServerObject::_nil ();
@@ -47,12 +47,12 @@ ImplementationRepository::ServerObject_ptr ImplementationRepository::ServerObjec
   TAO_Stub* stub = obj->_stubobj ();
   stub->_incr_refcnt ();
   ServerObject_ptr default_proxy = ServerObject::_nil ();
-  if (obj->_is_collocated () && _TAO_collocation_ImplementationRepository_ServerObject_Stub_Factory_function_pointer != 0)
+  if (obj->_is_collocated () &&	_TAO_collocation_ImplementationRepository_ServerObject_Stub_Factory_function_pointer !=	0)
     {
       default_proxy = _TAO_collocation_ImplementationRepository_ServerObject_Stub_Factory_function_pointer (obj);
     }
   if (CORBA::is_nil (default_proxy))
-    ACE_NEW_RETURN (default_proxy, ServerObject (stub), ServerObject::_nil ());
+    ACE_NEW_RETURN (default_proxy, ServerObject	(stub),	ServerObject::_nil ());
   return TAO_ImplementationRepository_ServerObject_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
@@ -80,30 +80,31 @@ void ImplementationRepository::ServerObject::ping (
       istub,
       "ping",
       4,
+      0,
       istub->orb_core ()
     );
 
       for (;;)
       {
-        _tao_call.start (ACE_TRY_ENV);
-        ACE_CHECK;
-        CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
-        // Tremporary hack until GIOP 1.2 is implemented.
-
-        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
-        ACE_CHECK;
-
-        int _invoke_status =
-          _tao_call.invoke (0, 0, ACE_TRY_ENV);
-                ACE_CHECK;
-
-        if (_invoke_status == TAO_INVOKE_RESTART)
-          continue;
-        if (_invoke_status != TAO_INVOKE_OK)
-        {
-          ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
-        }
-        break;
+	_tao_call.start	(ACE_TRY_ENV);
+	ACE_CHECK;
+	CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
+	// Tremporary hack until GIOP 1.2 is implemented.
+
+	_tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),	ACE_TRY_ENV);
+	ACE_CHECK;
+
+	int _invoke_status =
+	  _tao_call.invoke (0, 0, ACE_TRY_ENV);
+		ACE_CHECK;
+
+	if (_invoke_status == TAO_INVOKE_RESTART)
+	  continue;
+	if (_invoke_status != TAO_INVOKE_OK)
+	{
+	  ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+	}
+	break;
       }
 
 }
@@ -125,38 +126,39 @@ void ImplementationRepository::ServerObject::shutdown (
       istub,
       "shutdown",
       8,
+      0,
       istub->orb_core ()
     );
 
       for (;;)
       {
-        _tao_call.start (ACE_TRY_ENV);
-        ACE_CHECK;
+	_tao_call.start	(ACE_TRY_ENV);
+	ACE_CHECK;
 
-        CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
-        // Tremporary hack until GIOP 1.2 is implemented.
+	CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
+	// Tremporary hack until GIOP 1.2 is implemented.
 
-        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
-        ACE_CHECK;
+	_tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),	ACE_TRY_ENV);
+	ACE_CHECK;
 
-        int _invoke_status =
-          _tao_call.invoke (0, 0, ACE_TRY_ENV);
-                ACE_CHECK;
+	int _invoke_status =
+	  _tao_call.invoke (0, 0, ACE_TRY_ENV);
+		ACE_CHECK;
 
-        if (_invoke_status == TAO_INVOKE_RESTART)
-          continue;
-        if (_invoke_status != TAO_INVOKE_OK)
-        {
-          ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
-        }
-        ACE_CHECK;
-        break;
+	if (_invoke_status == TAO_INVOKE_RESTART)
+	  continue;
+	if (_invoke_status != TAO_INVOKE_OK)
+	{
+	  ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+	}
+	ACE_CHECK;
+	break;
 
       }
 
 }
 
-CORBA::Boolean ImplementationRepository::ServerObject::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+CORBA::Boolean ImplementationRepository::ServerObject::_is_a (const CORBA::Char	*value,	CORBA::Environment &ACE_TRY_ENV)
 {
   if (
     (!ACE_OS::strcmp ((char *)value, "IDL:ImplementationRepository/ServerObject:1.0")) ||
@@ -171,11 +173,11 @@ const char* ImplementationRepository::ServerObject::_interface_repository_id (vo
   return "IDL:ImplementationRepository/ServerObject:1.0";
 }
 
-ImplementationRepository::TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory::TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory (int register_proxy_factory)
+ImplementationRepository::TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory::TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory (int	register_proxy_factory)
 {
   if (register_proxy_factory)
     {
-      TAO_ImplementationRepository_ServerObject_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+      TAO_ImplementationRepository_ServerObject_PROXY_FACTORY_ADAPTER::instance	()->register_proxy_factory (this);
     }
 }
 
@@ -184,7 +186,7 @@ ImplementationRepository::TAO_ImplementationRepository_ServerObject_Default_Prox
 }
 
 ImplementationRepository::ServerObject_ptr
-ImplementationRepository::TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory::create_proxy (
+ImplementationRepository::TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory::create_proxy	(
     ::ImplementationRepository::ServerObject_ptr proxy,
     CORBA::Environment &
   )
@@ -200,7 +202,7 @@ ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factor
 
 ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter::~TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter (void)
 {
-  // Making sure the factory which the adapter has is destroyed with it.
+  // Making sure the factory which the adapter has is destroyed	with it.
   if (this->proxy_factory_ != 0)
     delete this->proxy_factory_;
 }
@@ -208,15 +210,15 @@ ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factor
 int
 ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter::register_proxy_factory (
   TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory *df,
-     CORBA::Environment &ACE_TRY_ENV
+     CORBA::Environment	&ACE_TRY_ENV
       )
 {
-  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,	ace_mon,
     this->lock_, 0));
-  // Remove any existing <proxy_factory_> and replace with the new one.
+  // Remove any	existing <proxy_factory_> and replace with the new one.
   this->unregister_proxy_factory (ACE_TRY_ENV);
   this->proxy_factory_ = df;
-  this->delete_proxy_factory_ = 0;
+  this->delete_proxy_factory_ =	0;
 return 0;
 }
 
@@ -225,13 +227,13 @@ ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factor
   CORBA::Environment &
     )
 {
-  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,	ace_mon,
     this->lock_, 0));
   if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
     {
-      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
-      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is
-      // invoked in the destructor of the class too.
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure	that it
+      // doesnt	get into an infinite loop in <unregister_proxy_factory>	as it is
+      // invoked in the	destructor of the class	too.
       this->delete_proxy_factory_ = 1;
       delete this->proxy_factory_;
       this->proxy_factory_ = 0;
@@ -240,18 +242,18 @@ return 0;
 }
 
 ImplementationRepository::ServerObject_ptr
-ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter::create_proxy (
+ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter::create_proxy	(
     ::ImplementationRepository::ServerObject_ptr proxy,
     CORBA::Environment &
   )
 {
-  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,	ace_mon,
     this->lock_, 0));
-  // Verify that an <proxy_factory_> is available else make one.
+  // Verify that an <proxy_factory_> is	available else make one.
   if (this->proxy_factory_ == 0)
     ACE_NEW_RETURN (this->proxy_factory_,
-        TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory (1),
-         0);
+	TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory	(1),
+	 0);
 
 
   return this->proxy_factory_->create_proxy (proxy);
@@ -266,7 +268,7 @@ ImplementationRepository::TAO_ImplementationRepository_ServerObject_Smart_Proxy_
 {
 }
 
-void ImplementationRepository::TAO_ImplementationRepository_ServerObject_Smart_Proxy_Base::ping  (
+void ImplementationRepository::TAO_ImplementationRepository_ServerObject_Smart_Proxy_Base::ping	 (
     CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
@@ -294,80 +296,80 @@ void ImplementationRepository::TAO_ImplementationRepository_ServerObject_Smart_P
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
   defined (ACE_HAS_GNU_REPO)
-template class TAO_Singleton<ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+template class TAO_Singleton<ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter,	ACE_SYNCH_RECURSIVE_MUTEX >;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#pragma instantiate TAO_Singleton<ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#pragma	instantiate TAO_Singleton<ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
 static const CORBA::Long _oc_ImplementationRepository_ServerObject[] =
 {
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  46, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f536572), ACE_NTOHL (0x7665724f), ACE_NTOHL (0x626a6563), ACE_NTOHL (0x743a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:ImplementationRepository/ServerObject:1.0
-  13, ACE_NTOHL (0x53657276), ACE_NTOHL (0x65724f62), ACE_NTOHL (0x6a656374), ACE_NTOHL (0x0),  // name = ServerObject
+  TAO_ENCAP_BYTE_ORDER,	// byte	order
+  46, ACE_NTOHL	(0x49444c3a), ACE_NTOHL	(0x496d706c), ACE_NTOHL	(0x656d656e), ACE_NTOHL	(0x74617469), ACE_NTOHL	(0x6f6e5265), ACE_NTOHL	(0x706f7369), ACE_NTOHL	(0x746f7279), ACE_NTOHL	(0x2f536572), ACE_NTOHL	(0x7665724f), ACE_NTOHL	(0x626a6563), ACE_NTOHL	(0x743a312e), ACE_NTOHL	(0x30000000),  // repository ID	= IDL:ImplementationRepository/ServerObject:1.0
+  13, ACE_NTOHL	(0x53657276), ACE_NTOHL	(0x65724f62), ACE_NTOHL	(0x6a656374), ACE_NTOHL	(0x0),	// name	= ServerObject
 };
-static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerObject (CORBA::tk_objref, sizeof (_oc_ImplementationRepository_ServerObject), (char *) &_oc_ImplementationRepository_ServerObject, 0, sizeof (ImplementationRepository::ServerObject));
+static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerObject	(CORBA::tk_objref, sizeof (_oc_ImplementationRepository_ServerObject), (char *)	&_oc_ImplementationRepository_ServerObject, 0, sizeof (ImplementationRepository::ServerObject));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (ImplementationRepository)
 TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ServerObject, &_tc_TAO_tc_ImplementationRepository_ServerObject)
 TAO_NAMESPACE_END
 static const CORBA::Long _oc_ImplementationRepository_EnvironmentVariable[] =
 {
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  53, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x56617269), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0
-  20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500),  // name = EnvironmentVariable
-  2, // member count
+  TAO_ENCAP_BYTE_ORDER,	// byte	order
+  53, ACE_NTOHL	(0x49444c3a), ACE_NTOHL	(0x496d706c), ACE_NTOHL	(0x656d656e), ACE_NTOHL	(0x74617469), ACE_NTOHL	(0x6f6e5265), ACE_NTOHL	(0x706f7369), ACE_NTOHL	(0x746f7279), ACE_NTOHL	(0x2f456e76), ACE_NTOHL	(0x69726f6e), ACE_NTOHL	(0x6d656e74), ACE_NTOHL	(0x56617269), ACE_NTOHL	(0x61626c65), ACE_NTOHL	(0x3a312e30), ACE_NTOHL	(0x0),	// repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0
+  20, ACE_NTOHL	(0x456e7669), ACE_NTOHL	(0x726f6e6d), ACE_NTOHL	(0x656e7456), ACE_NTOHL	(0x61726961), ACE_NTOHL	(0x626c6500),  // name = EnvironmentVariable
+  2, //	member count
   5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
   CORBA::tk_string,
-  0U, // string length
-  6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000),  // name = value
+  0U, // string	length
+  6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000),  // name =	value
   CORBA::tk_string,
-  0U, // string length
+  0U, // string	length
 };
 static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_EnvironmentVariable (CORBA::tk_struct, sizeof (_oc_ImplementationRepository_EnvironmentVariable), (char *) &_oc_ImplementationRepository_EnvironmentVariable, 0, sizeof (ImplementationRepository::EnvironmentVariable));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (ImplementationRepository)
 TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EnvironmentVariable, &_tc_TAO_tc_ImplementationRepository_EnvironmentVariable)
 TAO_NAMESPACE_END
-void ImplementationRepository::EnvironmentVariable::_tao_any_destructor (void *x)
+void ImplementationRepository::EnvironmentVariable::_tao_any_destructor	(void *x)
 {
-  ImplementationRepository::EnvironmentVariable *tmp = ACE_static_cast (ImplementationRepository::EnvironmentVariable*,x);
+  ImplementationRepository::EnvironmentVariable	*tmp = ACE_static_cast (ImplementationRepository::EnvironmentVariable*,x);
   delete tmp;
 }
 
-static const CORBA::Long _oc_ImplementationRepository_Address[] =
+static const CORBA::Long _oc_ImplementationRepository_Address[]	=
 {
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416464), ACE_NTOHL (0x72657373), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/Address:1.0
-  8, ACE_NTOHL (0x41646472), ACE_NTOHL (0x65737300),  // name = Address
+  TAO_ENCAP_BYTE_ORDER,	// byte	order
+  41, ACE_NTOHL	(0x49444c3a), ACE_NTOHL	(0x496d706c), ACE_NTOHL	(0x656d656e), ACE_NTOHL	(0x74617469), ACE_NTOHL	(0x6f6e5265), ACE_NTOHL	(0x706f7369), ACE_NTOHL	(0x746f7279), ACE_NTOHL	(0x2f416464), ACE_NTOHL	(0x72657373), ACE_NTOHL	(0x3a312e30), ACE_NTOHL	(0x0),	// repository ID = IDL:ImplementationRepository/Address:1.0
+  8, ACE_NTOHL (0x41646472), ACE_NTOHL (0x65737300),  // name =	Address
   CORBA::tk_string,
-  0U, // string length
+  0U, // string	length
 };
 static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Address (CORBA::tk_alias, sizeof (_oc_ImplementationRepository_Address), (char *) &_oc_ImplementationRepository_Address, 0, sizeof (ImplementationRepository::Address));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (ImplementationRepository)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Address, &_tc_TAO_tc_ImplementationRepository_Address)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Address,	&_tc_TAO_tc_ImplementationRepository_Address)
 TAO_NAMESPACE_END
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
 
 #if !defined (__TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_)
-#define __TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_
+#define	__TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_
 
   void
   ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::_allocate_buffer (CORBA::ULong length)
   {
     ImplementationRepository::EnvironmentVariable* tmp = 0;
-    tmp = _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::allocbuf (length);
+    tmp	= _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::allocbuf (length);
 
     if (this->buffer_ != 0)
     {
-      ImplementationRepository::EnvironmentVariable *old = ACE_reinterpret_cast (ImplementationRepository::EnvironmentVariable *,this->buffer_);
+      ImplementationRepository::EnvironmentVariable *old = ACE_reinterpret_cast	(ImplementationRepository::EnvironmentVariable *,this->buffer_);
 
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp[i] = old[i];
+      for (CORBA::ULong	i = 0; i < this->length_; ++i)
+	tmp[i] = old[i];
 
       if (this->release_)
-        _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::freebuf (old);
+	_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::freebuf (old);
 
     }
     this->buffer_ = tmp;
@@ -376,7 +378,7 @@ TAO_NAMESPACE_END
   void
   ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::_deallocate_buffer (void)
   {
-    if (this->buffer_ == 0 || this->release_ == 0)
+    if (this->buffer_ == 0 || this->release_ ==	0)
       return;
 
     ImplementationRepository::EnvironmentVariable *tmp = ACE_reinterpret_cast (ImplementationRepository::EnvironmentVariable *,this->buffer_);
@@ -385,7 +387,7 @@ TAO_NAMESPACE_END
     this->buffer_ = 0;
   }
 
-  ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::~_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList (void) // Dtor.
+  ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::~_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList	(void) // Dtor.
   {
     this->_deallocate_buffer ();
   }
@@ -397,7 +399,7 @@ TAO_NAMESPACE_END
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 
 #if !defined (_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_)
-#define _IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_
+#define	_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_
 
 // *************************************************************
 // ImplementationRepository::EnvironmentList
@@ -423,7 +425,7 @@ ImplementationRepository::EnvironmentList::EnvironmentList (CORBA::ULong max, CO
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (max, length, buffer, release)
 {}
-ImplementationRepository::EnvironmentList::EnvironmentList (const EnvironmentList &seq) // copy ctor
+ImplementationRepository::EnvironmentList::EnvironmentList (const EnvironmentList &seq)	// copy	ctor
   :
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList
@@ -443,13 +445,13 @@ void ImplementationRepository::EnvironmentList::_tao_any_destructor (void *x)
 
 #endif /* end #if !defined */
 
-static const CORBA::Long _oc_ImplementationRepository_EnvironmentList[] =
+static const CORBA::Long _oc_ImplementationRepository_EnvironmentList[]	=
 {
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  49, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x4c697374), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/EnvironmentList:1.0
-  16, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e744c), ACE_NTOHL (0x69737400),  // name = EnvironmentList
+  TAO_ENCAP_BYTE_ORDER,	// byte	order
+  49, ACE_NTOHL	(0x49444c3a), ACE_NTOHL	(0x496d706c), ACE_NTOHL	(0x656d656e), ACE_NTOHL	(0x74617469), ACE_NTOHL	(0x6f6e5265), ACE_NTOHL	(0x706f7369), ACE_NTOHL	(0x746f7279), ACE_NTOHL	(0x2f456e76), ACE_NTOHL	(0x69726f6e), ACE_NTOHL	(0x6d656e74), ACE_NTOHL	(0x4c697374), ACE_NTOHL	(0x3a312e30), ACE_NTOHL	(0x0),	// repository ID = IDL:ImplementationRepository/EnvironmentList:1.0
+  16, ACE_NTOHL	(0x456e7669), ACE_NTOHL	(0x726f6e6d), ACE_NTOHL	(0x656e744c), ACE_NTOHL	(0x69737400),  // name = EnvironmentList
   CORBA::tk_sequence, // typecode kind
-  148, // encapsulation length
+  148, // encapsulation	length
     TAO_ENCAP_BYTE_ORDER, // byte order
     CORBA::tk_struct, // typecode kind
     132, // encapsulation length
@@ -470,72 +472,72 @@ static const CORBA::Long _oc_ImplementationRepository_EnvironmentList[] =
 static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_EnvironmentList (CORBA::tk_alias, sizeof (_oc_ImplementationRepository_EnvironmentList), (char *) &_oc_ImplementationRepository_EnvironmentList, 0, sizeof (ImplementationRepository::EnvironmentList));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (ImplementationRepository)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EnvironmentList, &_tc_TAO_tc_ImplementationRepository_EnvironmentList)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EnvironmentList,	&_tc_TAO_tc_ImplementationRepository_EnvironmentList)
 TAO_NAMESPACE_END
 static const CORBA::Long _oc_ImplementationRepository_ActivationMode[] =
 {
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416374), ACE_NTOHL (0x69766174), ACE_NTOHL (0x696f6e4d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:ImplementationRepository/ActivationMode:1.0
-  15, ACE_NTOHL (0x41637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e4d6f), ACE_NTOHL (0x64650000),  // name = ActivationMode
-  4, // member count
-  7, ACE_NTOHL (0x4e4f524d), ACE_NTOHL (0x414c0000),  // name = NORMAL
-  7, ACE_NTOHL (0x4d414e55), ACE_NTOHL (0x414c0000),  // name = MANUAL
-  11, ACE_NTOHL (0x5045525f), ACE_NTOHL (0x434c4945), ACE_NTOHL (0x4e540000),  // name = PER_CLIENT
-  11, ACE_NTOHL (0x4155544f), ACE_NTOHL (0x5f535441), ACE_NTOHL (0x52540000),  // name = AUTO_START
+  TAO_ENCAP_BYTE_ORDER,	// byte	order
+  48, ACE_NTOHL	(0x49444c3a), ACE_NTOHL	(0x496d706c), ACE_NTOHL	(0x656d656e), ACE_NTOHL	(0x74617469), ACE_NTOHL	(0x6f6e5265), ACE_NTOHL	(0x706f7369), ACE_NTOHL	(0x746f7279), ACE_NTOHL	(0x2f416374), ACE_NTOHL	(0x69766174), ACE_NTOHL	(0x696f6e4d), ACE_NTOHL	(0x6f64653a), ACE_NTOHL	(0x312e3000),  // repository ID	= IDL:ImplementationRepository/ActivationMode:1.0
+  15, ACE_NTOHL	(0x41637469), ACE_NTOHL	(0x76617469), ACE_NTOHL	(0x6f6e4d6f), ACE_NTOHL	(0x64650000),  // name = ActivationMode
+  4, //	member count
+  7, ACE_NTOHL (0x4e4f524d), ACE_NTOHL (0x414c0000),  // name =	NORMAL
+  7, ACE_NTOHL (0x4d414e55), ACE_NTOHL (0x414c0000),  // name =	MANUAL
+  11, ACE_NTOHL	(0x5045525f), ACE_NTOHL	(0x434c4945), ACE_NTOHL	(0x4e540000),  // name = PER_CLIENT
+  11, ACE_NTOHL	(0x4155544f), ACE_NTOHL	(0x5f535441), ACE_NTOHL	(0x52540000),  // name = AUTO_START
 };
-static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ActivationMode (CORBA::tk_enum, sizeof (_oc_ImplementationRepository_ActivationMode), (char *) &_oc_ImplementationRepository_ActivationMode, 0, sizeof (ImplementationRepository::ActivationMode));
+static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ActivationMode (CORBA::tk_enum, sizeof (_oc_ImplementationRepository_ActivationMode), (char *) &_oc_ImplementationRepository_ActivationMode,	0, sizeof (ImplementationRepository::ActivationMode));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (ImplementationRepository)
 TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ActivationMode, &_tc_TAO_tc_ImplementationRepository_ActivationMode)
 TAO_NAMESPACE_END
 static const CORBA::Long _oc_ImplementationRepository_StartupOptions[] =
 {
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f537461), ACE_NTOHL (0x72747570), ACE_NTOHL (0x4f707469), ACE_NTOHL (0x6f6e733a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:ImplementationRepository/StartupOptions:1.0
-  15, ACE_NTOHL (0x53746172), ACE_NTOHL (0x7475704f), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = StartupOptions
-  4, // member count
-  13, ACE_NTOHL (0x636f6d6d), ACE_NTOHL (0x616e645f), ACE_NTOHL (0x6c696e65), ACE_NTOHL (0x0),  // name = command_line
+  TAO_ENCAP_BYTE_ORDER,	// byte	order
+  48, ACE_NTOHL	(0x49444c3a), ACE_NTOHL	(0x496d706c), ACE_NTOHL	(0x656d656e), ACE_NTOHL	(0x74617469), ACE_NTOHL	(0x6f6e5265), ACE_NTOHL	(0x706f7369), ACE_NTOHL	(0x746f7279), ACE_NTOHL	(0x2f537461), ACE_NTOHL	(0x72747570), ACE_NTOHL	(0x4f707469), ACE_NTOHL	(0x6f6e733a), ACE_NTOHL	(0x312e3000),  // repository ID	= IDL:ImplementationRepository/StartupOptions:1.0
+  15, ACE_NTOHL	(0x53746172), ACE_NTOHL	(0x7475704f), ACE_NTOHL	(0x7074696f), ACE_NTOHL	(0x6e730000),  // name = StartupOptions
+  4, //	member count
+  13, ACE_NTOHL	(0x636f6d6d), ACE_NTOHL	(0x616e645f), ACE_NTOHL	(0x6c696e65), ACE_NTOHL	(0x0),	// name	= command_line
   CORBA::tk_string,
-  0U, // string length
-  12, ACE_NTOHL (0x656e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7400),  // name = environment
-  CORBA::tk_alias, // typecode kind for typedefs
-  236, // encapsulation length
+  0U, // string	length
+  12, ACE_NTOHL	(0x656e7669), ACE_NTOHL	(0x726f6e6d), ACE_NTOHL	(0x656e7400),  // name = environment
+  CORBA::tk_alias, // typecode kind for	typedefs
+  236, // encapsulation	length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    49, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x4c697374), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/EnvironmentList:1.0
-    16, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e744c), ACE_NTOHL (0x69737400),  // name = EnvironmentList
-    CORBA::tk_sequence, // typecode kind
+    49,	ACE_NTOHL (0x49444c3a),	ACE_NTOHL (0x496d706c),	ACE_NTOHL (0x656d656e),	ACE_NTOHL (0x74617469),	ACE_NTOHL (0x6f6e5265),	ACE_NTOHL (0x706f7369),	ACE_NTOHL (0x746f7279),	ACE_NTOHL (0x2f456e76),	ACE_NTOHL (0x69726f6e),	ACE_NTOHL (0x6d656e74),	ACE_NTOHL (0x4c697374),	ACE_NTOHL (0x3a312e30),	ACE_NTOHL (0x0),  // repository	ID = IDL:ImplementationRepository/EnvironmentList:1.0
+    16,	ACE_NTOHL (0x456e7669),	ACE_NTOHL (0x726f6e6d),	ACE_NTOHL (0x656e744c),	ACE_NTOHL (0x69737400),	 // name = EnvironmentList
+    CORBA::tk_sequence,	// typecode kind
     148, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_struct, // typecode kind
+      CORBA::tk_struct,	// typecode kind
       132, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        53, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x56617269), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0
-        20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500),  // name = EnvironmentVariable
-        2, // member count
-        5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-        CORBA::tk_string,
-        0U, // string length
-        6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000),  // name = value
-        CORBA::tk_string,
-        0U, // string length
+	TAO_ENCAP_BYTE_ORDER, // byte order
+	53, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x56617269), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0
+	20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500),  //	name = EnvironmentVariable
+	2, // member count
+	5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  //	name = name
+	CORBA::tk_string,
+	0U, // string length
+	6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000),  // name = value
+	CORBA::tk_string,
+	0U, // string length
 
       0U,
 
 
-  18, ACE_NTOHL (0x776f726b), ACE_NTOHL (0x696e675f), ACE_NTOHL (0x64697265), ACE_NTOHL (0x63746f72), ACE_NTOHL (0x79000000),  // name = working_directory
+  18, ACE_NTOHL	(0x776f726b), ACE_NTOHL	(0x696e675f), ACE_NTOHL	(0x64697265), ACE_NTOHL	(0x63746f72), ACE_NTOHL	(0x79000000),  // name = working_directory
   CORBA::tk_string,
-  0U, // string length
-  11, ACE_NTOHL (0x61637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e0000),  // name = activation
+  0U, // string	length
+  11, ACE_NTOHL	(0x61637469), ACE_NTOHL	(0x76617469), ACE_NTOHL	(0x6f6e0000),  // name = activation
   CORBA::tk_enum, // typecode kind
-  136, // encapsulation length
+  136, // encapsulation	length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416374), ACE_NTOHL (0x69766174), ACE_NTOHL (0x696f6e4d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:ImplementationRepository/ActivationMode:1.0
-    15, ACE_NTOHL (0x41637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e4d6f), ACE_NTOHL (0x64650000),  // name = ActivationMode
+    48,	ACE_NTOHL (0x49444c3a),	ACE_NTOHL (0x496d706c),	ACE_NTOHL (0x656d656e),	ACE_NTOHL (0x74617469),	ACE_NTOHL (0x6f6e5265),	ACE_NTOHL (0x706f7369),	ACE_NTOHL (0x746f7279),	ACE_NTOHL (0x2f416374),	ACE_NTOHL (0x69766174),	ACE_NTOHL (0x696f6e4d),	ACE_NTOHL (0x6f64653a),	ACE_NTOHL (0x312e3000),	 // repository ID = IDL:ImplementationRepository/ActivationMode:1.0
+    15,	ACE_NTOHL (0x41637469),	ACE_NTOHL (0x76617469),	ACE_NTOHL (0x6f6e4d6f),	ACE_NTOHL (0x64650000),	 // name = ActivationMode
     4, // member count
-    7, ACE_NTOHL (0x4e4f524d), ACE_NTOHL (0x414c0000),  // name = NORMAL
-    7, ACE_NTOHL (0x4d414e55), ACE_NTOHL (0x414c0000),  // name = MANUAL
-    11, ACE_NTOHL (0x5045525f), ACE_NTOHL (0x434c4945), ACE_NTOHL (0x4e540000),  // name = PER_CLIENT
-    11, ACE_NTOHL (0x4155544f), ACE_NTOHL (0x5f535441), ACE_NTOHL (0x52540000),  // name = AUTO_START
+    7, ACE_NTOHL (0x4e4f524d), ACE_NTOHL (0x414c0000),	// name	= NORMAL
+    7, ACE_NTOHL (0x4d414e55), ACE_NTOHL (0x414c0000),	// name	= MANUAL
+    11,	ACE_NTOHL (0x5045525f),	ACE_NTOHL (0x434c4945),	ACE_NTOHL (0x4e540000),	 // name = PER_CLIENT
+    11,	ACE_NTOHL (0x4155544f),	ACE_NTOHL (0x5f535441),	ACE_NTOHL (0x52540000),	 // name = AUTO_START
 
 };
 static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_StartupOptions (CORBA::tk_struct, sizeof (_oc_ImplementationRepository_StartupOptions), (char *) &_oc_ImplementationRepository_StartupOptions, 0, sizeof (ImplementationRepository::StartupOptions));
@@ -545,62 +547,62 @@ TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_StartupOptions, &_tc_TAO_tc_Imple
 TAO_NAMESPACE_END
 void ImplementationRepository::StartupOptions::_tao_any_destructor (void *x)
 {
-  ImplementationRepository::StartupOptions *tmp = ACE_static_cast (ImplementationRepository::StartupOptions*,x);
+  ImplementationRepository::StartupOptions *tmp	= ACE_static_cast (ImplementationRepository::StartupOptions*,x);
   delete tmp;
 }
 
 static const CORBA::Long _oc_ImplementationRepository_ServerInformation[] =
 {
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  51, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f536572), ACE_NTOHL (0x76657249), ACE_NTOHL (0x6e666f72), ACE_NTOHL (0x6d617469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:ImplementationRepository/ServerInformation:1.0
-  18, ACE_NTOHL (0x53657276), ACE_NTOHL (0x6572496e), ACE_NTOHL (0x666f726d), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e000000),  // name = ServerInformation
-  4, // member count
-  15, ACE_NTOHL (0x6c6f6769), ACE_NTOHL (0x63616c5f), ACE_NTOHL (0x73657276), ACE_NTOHL (0x65720000),  // name = logical_server
+  TAO_ENCAP_BYTE_ORDER,	// byte	order
+  51, ACE_NTOHL	(0x49444c3a), ACE_NTOHL	(0x496d706c), ACE_NTOHL	(0x656d656e), ACE_NTOHL	(0x74617469), ACE_NTOHL	(0x6f6e5265), ACE_NTOHL	(0x706f7369), ACE_NTOHL	(0x746f7279), ACE_NTOHL	(0x2f536572), ACE_NTOHL	(0x76657249), ACE_NTOHL	(0x6e666f72), ACE_NTOHL	(0x6d617469), ACE_NTOHL	(0x6f6e3a31), ACE_NTOHL	(0x2e300000),  // repository ID	= IDL:ImplementationRepository/ServerInformation:1.0
+  18, ACE_NTOHL	(0x53657276), ACE_NTOHL	(0x6572496e), ACE_NTOHL	(0x666f726d), ACE_NTOHL	(0x6174696f), ACE_NTOHL	(0x6e000000),  // name = ServerInformation
+  4, //	member count
+  15, ACE_NTOHL	(0x6c6f6769), ACE_NTOHL	(0x63616c5f), ACE_NTOHL	(0x73657276), ACE_NTOHL	(0x65720000),  // name = logical_server
   CORBA::tk_string,
-  0U, // string length
-  7, ACE_NTOHL (0x73657276), ACE_NTOHL (0x65720000),  // name = server
+  0U, // string	length
+  7, ACE_NTOHL (0x73657276), ACE_NTOHL (0x65720000),  // name =	server
   CORBA::tk_string,
-  0U, // string length
-  8, ACE_NTOHL (0x73746172), ACE_NTOHL (0x74757000),  // name = startup
-  CORBA::tk_struct, // typecode kind
-  560, // encapsulation length
+  0U, // string	length
+  8, ACE_NTOHL (0x73746172), ACE_NTOHL (0x74757000),  // name =	startup
+  CORBA::tk_struct, // typecode	kind
+  560, // encapsulation	length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f537461), ACE_NTOHL (0x72747570), ACE_NTOHL (0x4f707469), ACE_NTOHL (0x6f6e733a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:ImplementationRepository/StartupOptions:1.0
-    15, ACE_NTOHL (0x53746172), ACE_NTOHL (0x7475704f), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = StartupOptions
+    48,	ACE_NTOHL (0x49444c3a),	ACE_NTOHL (0x496d706c),	ACE_NTOHL (0x656d656e),	ACE_NTOHL (0x74617469),	ACE_NTOHL (0x6f6e5265),	ACE_NTOHL (0x706f7369),	ACE_NTOHL (0x746f7279),	ACE_NTOHL (0x2f537461),	ACE_NTOHL (0x72747570),	ACE_NTOHL (0x4f707469),	ACE_NTOHL (0x6f6e733a),	ACE_NTOHL (0x312e3000),	 // repository ID = IDL:ImplementationRepository/StartupOptions:1.0
+    15,	ACE_NTOHL (0x53746172),	ACE_NTOHL (0x7475704f),	ACE_NTOHL (0x7074696f),	ACE_NTOHL (0x6e730000),	 // name = StartupOptions
     4, // member count
-    13, ACE_NTOHL (0x636f6d6d), ACE_NTOHL (0x616e645f), ACE_NTOHL (0x6c696e65), ACE_NTOHL (0x0),  // name = command_line
+    13,	ACE_NTOHL (0x636f6d6d),	ACE_NTOHL (0x616e645f),	ACE_NTOHL (0x6c696e65),	ACE_NTOHL (0x0),  // name = command_line
     CORBA::tk_string,
-    0U, // string length
-    12, ACE_NTOHL (0x656e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7400),  // name = environment
-    CORBA::tk_alias, // typecode kind for typedefs
+    0U,	// string length
+    12,	ACE_NTOHL (0x656e7669),	ACE_NTOHL (0x726f6e6d),	ACE_NTOHL (0x656e7400),	 // name = environment
+    CORBA::tk_alias, //	typecode kind for typedefs
     236, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
       49, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x4c697374), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/EnvironmentList:1.0
       16, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e744c), ACE_NTOHL (0x69737400),  // name = EnvironmentList
       CORBA::tk_sequence, // typecode kind
       148, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        CORBA::tk_struct, // typecode kind
-        132, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          53, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x56617269), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0
-          20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500),  // name = EnvironmentVariable
-          2, // member count
-          5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-          CORBA::tk_string,
-          0U, // string length
-          6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000),  // name = value
-          CORBA::tk_string,
-          0U, // string length
-
-        0U,
-
-
-    18, ACE_NTOHL (0x776f726b), ACE_NTOHL (0x696e675f), ACE_NTOHL (0x64697265), ACE_NTOHL (0x63746f72), ACE_NTOHL (0x79000000),  // name = working_directory
+	TAO_ENCAP_BYTE_ORDER, // byte order
+	CORBA::tk_struct, // typecode kind
+	132, //	encapsulation length
+	  TAO_ENCAP_BYTE_ORDER,	// byte	order
+	  53, ACE_NTOHL	(0x49444c3a), ACE_NTOHL	(0x496d706c), ACE_NTOHL	(0x656d656e), ACE_NTOHL	(0x74617469), ACE_NTOHL	(0x6f6e5265), ACE_NTOHL	(0x706f7369), ACE_NTOHL	(0x746f7279), ACE_NTOHL	(0x2f456e76), ACE_NTOHL	(0x69726f6e), ACE_NTOHL	(0x6d656e74), ACE_NTOHL	(0x56617269), ACE_NTOHL	(0x61626c65), ACE_NTOHL	(0x3a312e30), ACE_NTOHL	(0x0),	// repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0
+	  20, ACE_NTOHL	(0x456e7669), ACE_NTOHL	(0x726f6e6d), ACE_NTOHL	(0x656e7456), ACE_NTOHL	(0x61726961), ACE_NTOHL	(0x626c6500),  // name = EnvironmentVariable
+	  2, //	member count
+	  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+	  CORBA::tk_string,
+	  0U, // string	length
+	  6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000),  // name =	value
+	  CORBA::tk_string,
+	  0U, // string	length
+
+	0U,
+
+
+    18,	ACE_NTOHL (0x776f726b),	ACE_NTOHL (0x696e675f),	ACE_NTOHL (0x64697265),	ACE_NTOHL (0x63746f72),	ACE_NTOHL (0x79000000),	 // name = working_directory
     CORBA::tk_string,
-    0U, // string length
-    11, ACE_NTOHL (0x61637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e0000),  // name = activation
-    CORBA::tk_enum, // typecode kind
+    0U,	// string length
+    11,	ACE_NTOHL (0x61637469),	ACE_NTOHL (0x76617469),	ACE_NTOHL (0x6f6e0000),	 // name = activation
+    CORBA::tk_enum, // typecode	kind
     136, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
       48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416374), ACE_NTOHL (0x69766174), ACE_NTOHL (0x696f6e4d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:ImplementationRepository/ActivationMode:1.0
@@ -613,16 +615,16 @@ static const CORBA::Long _oc_ImplementationRepository_ServerInformation[] =
 
 
   9, ACE_NTOHL (0x6c6f6361), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = location
-  CORBA::tk_alias, // typecode kind for typedefs
+  CORBA::tk_alias, // typecode kind for	typedefs
   72, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416464), ACE_NTOHL (0x72657373), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/Address:1.0
-    8, ACE_NTOHL (0x41646472), ACE_NTOHL (0x65737300),  // name = Address
+    41,	ACE_NTOHL (0x49444c3a),	ACE_NTOHL (0x496d706c),	ACE_NTOHL (0x656d656e),	ACE_NTOHL (0x74617469),	ACE_NTOHL (0x6f6e5265),	ACE_NTOHL (0x706f7369),	ACE_NTOHL (0x746f7279),	ACE_NTOHL (0x2f416464),	ACE_NTOHL (0x72657373),	ACE_NTOHL (0x3a312e30),	ACE_NTOHL (0x0),  // repository	ID = IDL:ImplementationRepository/Address:1.0
+    8, ACE_NTOHL (0x41646472), ACE_NTOHL (0x65737300),	// name	= Address
     CORBA::tk_string,
-    0U, // string length
+    0U,	// string length
 
 };
-static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerInformation (CORBA::tk_struct, sizeof (_oc_ImplementationRepository_ServerInformation), (char *) &_oc_ImplementationRepository_ServerInformation, 0, sizeof (ImplementationRepository::ServerInformation));
+static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerInformation (CORBA::tk_struct,	sizeof (_oc_ImplementationRepository_ServerInformation), (char *) &_oc_ImplementationRepository_ServerInformation, 0, sizeof (ImplementationRepository::ServerInformation));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (ImplementationRepository)
 TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ServerInformation, &_tc_TAO_tc_ImplementationRepository_ServerInformation)
@@ -637,23 +639,23 @@ void ImplementationRepository::ServerInformation::_tao_any_destructor (void *x)
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
 
 #if !defined (__TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_)
-#define __TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_
+#define	__TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_
 
   void
   ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::_allocate_buffer (CORBA::ULong length)
   {
     ImplementationRepository::ServerInformation* tmp = 0;
-    tmp = _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::allocbuf (length);
+    tmp	= _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::allocbuf (length);
 
     if (this->buffer_ != 0)
     {
       ImplementationRepository::ServerInformation *old = ACE_reinterpret_cast (ImplementationRepository::ServerInformation *,this->buffer_);
 
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp[i] = old[i];
+      for (CORBA::ULong	i = 0; i < this->length_; ++i)
+	tmp[i] = old[i];
 
       if (this->release_)
-        _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::freebuf (old);
+	_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::freebuf	(old);
 
     }
     this->buffer_ = tmp;
@@ -662,10 +664,10 @@ void ImplementationRepository::ServerInformation::_tao_any_destructor (void *x)
   void
   ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::_deallocate_buffer (void)
   {
-    if (this->buffer_ == 0 || this->release_ == 0)
+    if (this->buffer_ == 0 || this->release_ ==	0)
       return;
 
-    ImplementationRepository::ServerInformation *tmp = ACE_reinterpret_cast (ImplementationRepository::ServerInformation *,this->buffer_);
+    ImplementationRepository::ServerInformation	*tmp = ACE_reinterpret_cast (ImplementationRepository::ServerInformation *,this->buffer_);
 
     _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::freebuf (tmp);
     this->buffer_ = 0;
@@ -683,7 +685,7 @@ void ImplementationRepository::ServerInformation::_tao_any_destructor (void *x)
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 
 #if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_)
-#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_
+#define	_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_
 
 // *************************************************************
 // ImplementationRepository::ServerInformationList
@@ -718,9 +720,9 @@ ImplementationRepository::ServerInformationList::ServerInformationList (const Se
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */
  (seq)
 {}
-ImplementationRepository::ServerInformationList::~ServerInformationList (void) // dtor
+ImplementationRepository::ServerInformationList::~ServerInformationList	(void) // dtor
 {}
-void ImplementationRepository::ServerInformationList::_tao_any_destructor (void *x)
+void ImplementationRepository::ServerInformationList::_tao_any_destructor (void	*x)
 {
   ImplementationRepository::ServerInformationList *tmp = ACE_static_cast (ImplementationRepository::ServerInformationList*,x);
   delete tmp;
@@ -731,11 +733,11 @@ void ImplementationRepository::ServerInformationList::_tao_any_destructor (void
 
 static const CORBA::Long _oc_ImplementationRepository_ServerInformationList[] =
 {
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  55, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f536572), ACE_NTOHL (0x76657249), ACE_NTOHL (0x6e666f72), ACE_NTOHL (0x6d617469), ACE_NTOHL (0x6f6e4c69), ACE_NTOHL (0x73743a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:ImplementationRepository/ServerInformationList:1.0
-  22, ACE_NTOHL (0x53657276), ACE_NTOHL (0x6572496e), ACE_NTOHL (0x666f726d), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e4c6973), ACE_NTOHL (0x74000000),  // name = ServerInformationList
+  TAO_ENCAP_BYTE_ORDER,	// byte	order
+  55, ACE_NTOHL	(0x49444c3a), ACE_NTOHL	(0x496d706c), ACE_NTOHL	(0x656d656e), ACE_NTOHL	(0x74617469), ACE_NTOHL	(0x6f6e5265), ACE_NTOHL	(0x706f7369), ACE_NTOHL	(0x746f7279), ACE_NTOHL	(0x2f536572), ACE_NTOHL	(0x76657249), ACE_NTOHL	(0x6e666f72), ACE_NTOHL	(0x6d617469), ACE_NTOHL	(0x6f6e4c69), ACE_NTOHL	(0x73743a31), ACE_NTOHL	(0x2e300000),  // repository ID	= IDL:ImplementationRepository/ServerInformationList:1.0
+  22, ACE_NTOHL	(0x53657276), ACE_NTOHL	(0x6572496e), ACE_NTOHL	(0x666f726d), ACE_NTOHL	(0x6174696f), ACE_NTOHL	(0x6e4c6973), ACE_NTOHL	(0x74000000),  // name = ServerInformationList
   CORBA::tk_sequence, // typecode kind
-  828, // encapsulation length
+  828, // encapsulation	length
     TAO_ENCAP_BYTE_ORDER, // byte order
     CORBA::tk_struct, // typecode kind
     812, // encapsulation length
@@ -750,77 +752,77 @@ static const CORBA::Long _oc_ImplementationRepository_ServerInformationList[] =
       CORBA::tk_string,
       0U, // string length
       8, ACE_NTOHL (0x73746172), ACE_NTOHL (0x74757000),  // name = startup
-      CORBA::tk_struct, // typecode kind
+      CORBA::tk_struct,	// typecode kind
       560, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f537461), ACE_NTOHL (0x72747570), ACE_NTOHL (0x4f707469), ACE_NTOHL (0x6f6e733a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:ImplementationRepository/StartupOptions:1.0
-        15, ACE_NTOHL (0x53746172), ACE_NTOHL (0x7475704f), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = StartupOptions
-        4, // member count
-        13, ACE_NTOHL (0x636f6d6d), ACE_NTOHL (0x616e645f), ACE_NTOHL (0x6c696e65), ACE_NTOHL (0x0),  // name = command_line
-        CORBA::tk_string,
-        0U, // string length
-        12, ACE_NTOHL (0x656e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7400),  // name = environment
-        CORBA::tk_alias, // typecode kind for typedefs
-        236, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          49, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x4c697374), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/EnvironmentList:1.0
-          16, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e744c), ACE_NTOHL (0x69737400),  // name = EnvironmentList
-          CORBA::tk_sequence, // typecode kind
-          148, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            CORBA::tk_struct, // typecode kind
-            132, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              53, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x56617269), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0
-              20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500),  // name = EnvironmentVariable
-              2, // member count
-              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-              CORBA::tk_string,
-              0U, // string length
-              6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000),  // name = value
-              CORBA::tk_string,
-              0U, // string length
-
-            0U,
-
-
-        18, ACE_NTOHL (0x776f726b), ACE_NTOHL (0x696e675f), ACE_NTOHL (0x64697265), ACE_NTOHL (0x63746f72), ACE_NTOHL (0x79000000),  // name = working_directory
-        CORBA::tk_string,
-        0U, // string length
-        11, ACE_NTOHL (0x61637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e0000),  // name = activation
-        CORBA::tk_enum, // typecode kind
-        136, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416374), ACE_NTOHL (0x69766174), ACE_NTOHL (0x696f6e4d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:ImplementationRepository/ActivationMode:1.0
-          15, ACE_NTOHL (0x41637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e4d6f), ACE_NTOHL (0x64650000),  // name = ActivationMode
-          4, // member count
-          7, ACE_NTOHL (0x4e4f524d), ACE_NTOHL (0x414c0000),  // name = NORMAL
-          7, ACE_NTOHL (0x4d414e55), ACE_NTOHL (0x414c0000),  // name = MANUAL
-          11, ACE_NTOHL (0x5045525f), ACE_NTOHL (0x434c4945), ACE_NTOHL (0x4e540000),  // name = PER_CLIENT
-          11, ACE_NTOHL (0x4155544f), ACE_NTOHL (0x5f535441), ACE_NTOHL (0x52540000),  // name = AUTO_START
+	TAO_ENCAP_BYTE_ORDER, // byte order
+	48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f537461), ACE_NTOHL (0x72747570), ACE_NTOHL (0x4f707469), ACE_NTOHL (0x6f6e733a), ACE_NTOHL (0x312e3000),  //	repository ID =	IDL:ImplementationRepository/StartupOptions:1.0
+	15, ACE_NTOHL (0x53746172), ACE_NTOHL (0x7475704f), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  //	name = StartupOptions
+	4, // member count
+	13, ACE_NTOHL (0x636f6d6d), ACE_NTOHL (0x616e645f), ACE_NTOHL (0x6c696e65), ACE_NTOHL (0x0),  // name =	command_line
+	CORBA::tk_string,
+	0U, // string length
+	12, ACE_NTOHL (0x656e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7400),  //	name = environment
+	CORBA::tk_alias, // typecode kind for typedefs
+	236, //	encapsulation length
+	  TAO_ENCAP_BYTE_ORDER,	// byte	order
+	  49, ACE_NTOHL	(0x49444c3a), ACE_NTOHL	(0x496d706c), ACE_NTOHL	(0x656d656e), ACE_NTOHL	(0x74617469), ACE_NTOHL	(0x6f6e5265), ACE_NTOHL	(0x706f7369), ACE_NTOHL	(0x746f7279), ACE_NTOHL	(0x2f456e76), ACE_NTOHL	(0x69726f6e), ACE_NTOHL	(0x6d656e74), ACE_NTOHL	(0x4c697374), ACE_NTOHL	(0x3a312e30), ACE_NTOHL	(0x0),	// repository ID = IDL:ImplementationRepository/EnvironmentList:1.0
+	  16, ACE_NTOHL	(0x456e7669), ACE_NTOHL	(0x726f6e6d), ACE_NTOHL	(0x656e744c), ACE_NTOHL	(0x69737400),  // name = EnvironmentList
+	  CORBA::tk_sequence, // typecode kind
+	  148, // encapsulation	length
+	    TAO_ENCAP_BYTE_ORDER, // byte order
+	    CORBA::tk_struct, // typecode kind
+	    132, // encapsulation length
+	      TAO_ENCAP_BYTE_ORDER, // byte order
+	      53, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x56617269), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0
+	      20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500),  // name = EnvironmentVariable
+	      2, // member count
+	      5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+	      CORBA::tk_string,
+	      0U, // string length
+	      6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000),  // name = value
+	      CORBA::tk_string,
+	      0U, // string length
+
+	    0U,
+
+
+	18, ACE_NTOHL (0x776f726b), ACE_NTOHL (0x696e675f), ACE_NTOHL (0x64697265), ACE_NTOHL (0x63746f72), ACE_NTOHL (0x79000000),  //	name = working_directory
+	CORBA::tk_string,
+	0U, // string length
+	11, ACE_NTOHL (0x61637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e0000),  //	name = activation
+	CORBA::tk_enum,	// typecode kind
+	136, //	encapsulation length
+	  TAO_ENCAP_BYTE_ORDER,	// byte	order
+	  48, ACE_NTOHL	(0x49444c3a), ACE_NTOHL	(0x496d706c), ACE_NTOHL	(0x656d656e), ACE_NTOHL	(0x74617469), ACE_NTOHL	(0x6f6e5265), ACE_NTOHL	(0x706f7369), ACE_NTOHL	(0x746f7279), ACE_NTOHL	(0x2f416374), ACE_NTOHL	(0x69766174), ACE_NTOHL	(0x696f6e4d), ACE_NTOHL	(0x6f64653a), ACE_NTOHL	(0x312e3000),  // repository ID	= IDL:ImplementationRepository/ActivationMode:1.0
+	  15, ACE_NTOHL	(0x41637469), ACE_NTOHL	(0x76617469), ACE_NTOHL	(0x6f6e4d6f), ACE_NTOHL	(0x64650000),  // name = ActivationMode
+	  4, //	member count
+	  7, ACE_NTOHL (0x4e4f524d), ACE_NTOHL (0x414c0000),  // name =	NORMAL
+	  7, ACE_NTOHL (0x4d414e55), ACE_NTOHL (0x414c0000),  // name =	MANUAL
+	  11, ACE_NTOHL	(0x5045525f), ACE_NTOHL	(0x434c4945), ACE_NTOHL	(0x4e540000),  // name = PER_CLIENT
+	  11, ACE_NTOHL	(0x4155544f), ACE_NTOHL	(0x5f535441), ACE_NTOHL	(0x52540000),  // name = AUTO_START
 
 
       9, ACE_NTOHL (0x6c6f6361), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = location
-      CORBA::tk_alias, // typecode kind for typedefs
+      CORBA::tk_alias, // typecode kind	for typedefs
       72, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416464), ACE_NTOHL (0x72657373), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/Address:1.0
-        8, ACE_NTOHL (0x41646472), ACE_NTOHL (0x65737300),  // name = Address
-        CORBA::tk_string,
-        0U, // string length
+	TAO_ENCAP_BYTE_ORDER, // byte order
+	41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416464), ACE_NTOHL (0x72657373), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/Address:1.0
+	8, ACE_NTOHL (0x41646472), ACE_NTOHL (0x65737300),  // name = Address
+	CORBA::tk_string,
+	0U, // string length
 
 
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerInformationList (CORBA::tk_alias, sizeof (_oc_ImplementationRepository_ServerInformationList), (char *) &_oc_ImplementationRepository_ServerInformationList, 0, sizeof (ImplementationRepository::ServerInformationList));
+static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerInformationList (CORBA::tk_alias, sizeof (_oc_ImplementationRepository_ServerInformationList),	(char *) &_oc_ImplementationRepository_ServerInformationList, 0, sizeof	(ImplementationRepository::ServerInformationList));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (ImplementationRepository)
 TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ServerInformationList, &_tc_TAO_tc_ImplementationRepository_ServerInformationList)
 TAO_NAMESPACE_END
 void ImplementationRepository::Administration::_tao_any_destructor (void *x)
 {
-  ImplementationRepository::Administration *tmp = ACE_static_cast (ImplementationRepository::Administration*,x);
+  ImplementationRepository::Administration *tmp	= ACE_static_cast (ImplementationRepository::Administration*,x);
   CORBA::release (tmp);
 }
 
@@ -830,11 +832,11 @@ ImplementationRepository::Administration_ptr ImplementationRepository::Administr
   )
 {
   if (CORBA::is_nil (obj))
-    return Administration::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:ImplementationRepository/Administration:1.0", ACE_TRY_ENV);
+    return Administration::_nil	();
+  CORBA::Boolean is_a =	obj->_is_a ("IDL:ImplementationRepository/Administration:1.0", ACE_TRY_ENV);
   ACE_CHECK_RETURN (Administration::_nil ());
   if (is_a == 0)
-    return Administration::_nil ();
+    return Administration::_nil	();
   return Administration::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
@@ -844,11 +846,11 @@ ImplementationRepository::Administration_ptr ImplementationRepository::Administr
   )
 {
   if (CORBA::is_nil (obj))
-    return Administration::_nil ();
+    return Administration::_nil	();
   TAO_Stub* stub = obj->_stubobj ();
   stub->_incr_refcnt ();
   Administration_ptr default_proxy = Administration::_nil ();
-  if (obj->_is_collocated () && _TAO_collocation_ImplementationRepository_Administration_Stub_Factory_function_pointer != 0)
+  if (obj->_is_collocated () &&	_TAO_collocation_ImplementationRepository_Administration_Stub_Factory_function_pointer != 0)
     {
       default_proxy = _TAO_collocation_ImplementationRepository_Administration_Stub_Factory_function_pointer (obj);
     }
@@ -867,12 +869,12 @@ ImplementationRepository::Administration::_duplicate (Administration_ptr obj)
 
 // default constructor
 ImplementationRepository::Administration::AlreadyRegistered::AlreadyRegistered (void)
-  : CORBA_UserException ("IDL:ImplementationRepository/Administration/AlreadyRegistered:1.0")
+  : CORBA_UserException	("IDL:ImplementationRepository/Administration/AlreadyRegistered:1.0")
 {
 }
 
-// destructor - all members are of self managing types
-ImplementationRepository::Administration::AlreadyRegistered::~AlreadyRegistered (void)
+// destructor -	all members are	of self	managing types
+ImplementationRepository::Administration::AlreadyRegistered::~AlreadyRegistered	(void)
 {
 }
 
@@ -882,9 +884,9 @@ void ImplementationRepository::Administration::AlreadyRegistered::_tao_any_destr
   delete tmp;
 }
 
-// copy constructor
+// copy	constructor
 ImplementationRepository::Administration::AlreadyRegistered::AlreadyRegistered (const ::ImplementationRepository::Administration::AlreadyRegistered &_tao_excp)
-  : CORBA_UserException (_tao_excp._id ())
+  : CORBA_UserException	(_tao_excp._id ())
 {
   }
 
@@ -943,12 +945,12 @@ CORBA::Exception *ImplementationRepository::Administration::AlreadyRegistered::_
 
 static const CORBA::Long _oc_ImplementationRepository_Administration_AlreadyRegistered[] =
 {
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  66, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f41646d), ACE_NTOHL (0x696e6973), ACE_NTOHL (0x74726174), ACE_NTOHL (0x696f6e2f), ACE_NTOHL (0x416c7265), ACE_NTOHL (0x61647952), ACE_NTOHL (0x65676973), ACE_NTOHL (0x74657265), ACE_NTOHL (0x643a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:ImplementationRepository/Administration/AlreadyRegistered:1.0
-  18, ACE_NTOHL (0x416c7265), ACE_NTOHL (0x61647952), ACE_NTOHL (0x65676973), ACE_NTOHL (0x74657265), ACE_NTOHL (0x64000000),  // name = AlreadyRegistered
-  0, // member count
+  TAO_ENCAP_BYTE_ORDER,	// byte	order
+  66, ACE_NTOHL	(0x49444c3a), ACE_NTOHL	(0x496d706c), ACE_NTOHL	(0x656d656e), ACE_NTOHL	(0x74617469), ACE_NTOHL	(0x6f6e5265), ACE_NTOHL	(0x706f7369), ACE_NTOHL	(0x746f7279), ACE_NTOHL	(0x2f41646d), ACE_NTOHL	(0x696e6973), ACE_NTOHL	(0x74726174), ACE_NTOHL	(0x696f6e2f), ACE_NTOHL	(0x416c7265), ACE_NTOHL	(0x61647952), ACE_NTOHL	(0x65676973), ACE_NTOHL	(0x74657265), ACE_NTOHL	(0x643a312e), ACE_NTOHL	(0x30000000),  // repository ID	= IDL:ImplementationRepository/Administration/AlreadyRegistered:1.0
+  18, ACE_NTOHL	(0x416c7265), ACE_NTOHL	(0x61647952), ACE_NTOHL	(0x65676973), ACE_NTOHL	(0x74657265), ACE_NTOHL	(0x64000000),  // name = AlreadyRegistered
+  0, //	member count
 };
-static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Administration_AlreadyRegistered (CORBA::tk_except, sizeof (_oc_ImplementationRepository_Administration_AlreadyRegistered), (char *) &_oc_ImplementationRepository_Administration_AlreadyRegistered, 0, sizeof (ImplementationRepository::Administration::AlreadyRegistered));
+static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Administration_AlreadyRegistered (CORBA::tk_except, sizeof (_oc_ImplementationRepository_Administration_AlreadyRegistered), (char *)	&_oc_ImplementationRepository_Administration_AlreadyRegistered,	0, sizeof (ImplementationRepository::Administration::AlreadyRegistered));
 CORBA::TypeCode_ptr ImplementationRepository::Administration::_tc_AlreadyRegistered = &_tc_TAO_tc_ImplementationRepository_Administration_AlreadyRegistered;
 
 CORBA::TypeCode_ptr
@@ -959,24 +961,24 @@ ImplementationRepository::Administration::AlreadyRegistered::_type (void) const
 
 // default constructor
 ImplementationRepository::Administration::CannotActivate::CannotActivate (void)
-  : CORBA_UserException ("IDL:ImplementationRepository/Administration/CannotActivate:1.0")
+  : CORBA_UserException	("IDL:ImplementationRepository/Administration/CannotActivate:1.0")
 {
 }
 
-// destructor - all members are of self managing types
+// destructor -	all members are	of self	managing types
 ImplementationRepository::Administration::CannotActivate::~CannotActivate (void)
 {
 }
 
 void ImplementationRepository::Administration::CannotActivate::_tao_any_destructor (void *x)
 {
-  ImplementationRepository::Administration::CannotActivate *tmp = ACE_static_cast (ImplementationRepository::Administration::CannotActivate*,x);
+  ImplementationRepository::Administration::CannotActivate *tmp	= ACE_static_cast (ImplementationRepository::Administration::CannotActivate*,x);
   delete tmp;
 }
 
-// copy constructor
-ImplementationRepository::Administration::CannotActivate::CannotActivate (const ::ImplementationRepository::Administration::CannotActivate &_tao_excp)
-  : CORBA_UserException (_tao_excp._id ())
+// copy	constructor
+ImplementationRepository::Administration::CannotActivate::CannotActivate (const	::ImplementationRepository::Administration::CannotActivate &_tao_excp)
+  : CORBA_UserException	(_tao_excp._id ())
 {
     this->reason = CORBA::string_dup (_tao_excp.reason.in ());
 }
@@ -987,7 +989,7 @@ ImplementationRepository::Administration::CannotActivate::operator= (const ::Imp
 {
 
   this->CORBA_UserException::operator= (_tao_excp);
-  this->reason = CORBA::string_dup (_tao_excp.reason.in ());
+  this->reason = CORBA::string_dup (_tao_excp.reason.in	());
   return *this;
 }
 
@@ -1036,39 +1038,39 @@ CORBA::Exception *ImplementationRepository::Administration::CannotActivate::_all
 }
 
 ImplementationRepository::Administration::CannotActivate::CannotActivate (
-  const char * _tao_reason
+  const	char * _tao_reason
 )
-  : CORBA_UserException (CORBA::string_dup ("IDL:ImplementationRepository/Administration/CannotActivate:1.0"))
+  : CORBA_UserException	(CORBA::string_dup ("IDL:ImplementationRepository/Administration/CannotActivate:1.0"))
 {
     this->reason = CORBA::string_dup (_tao_reason);
 }
 
 static const CORBA::Long _oc_ImplementationRepository_Administration_CannotActivate[] =
 {
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  63, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f41646d), ACE_NTOHL (0x696e6973), ACE_NTOHL (0x74726174), ACE_NTOHL (0x696f6e2f), ACE_NTOHL (0x43616e6e), ACE_NTOHL (0x6f744163), ACE_NTOHL (0x74697661), ACE_NTOHL (0x74653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:ImplementationRepository/Administration/CannotActivate:1.0
-  15, ACE_NTOHL (0x43616e6e), ACE_NTOHL (0x6f744163), ACE_NTOHL (0x74697661), ACE_NTOHL (0x74650000),  // name = CannotActivate
-  1, // member count
-  7, ACE_NTOHL (0x72656173), ACE_NTOHL (0x6f6e0000),  // name = reason
+  TAO_ENCAP_BYTE_ORDER,	// byte	order
+  63, ACE_NTOHL	(0x49444c3a), ACE_NTOHL	(0x496d706c), ACE_NTOHL	(0x656d656e), ACE_NTOHL	(0x74617469), ACE_NTOHL	(0x6f6e5265), ACE_NTOHL	(0x706f7369), ACE_NTOHL	(0x746f7279), ACE_NTOHL	(0x2f41646d), ACE_NTOHL	(0x696e6973), ACE_NTOHL	(0x74726174), ACE_NTOHL	(0x696f6e2f), ACE_NTOHL	(0x43616e6e), ACE_NTOHL	(0x6f744163), ACE_NTOHL	(0x74697661), ACE_NTOHL	(0x74653a31), ACE_NTOHL	(0x2e300000),  // repository ID	= IDL:ImplementationRepository/Administration/CannotActivate:1.0
+  15, ACE_NTOHL	(0x43616e6e), ACE_NTOHL	(0x6f744163), ACE_NTOHL	(0x74697661), ACE_NTOHL	(0x74650000),  // name = CannotActivate
+  1, //	member count
+  7, ACE_NTOHL (0x72656173), ACE_NTOHL (0x6f6e0000),  // name =	reason
   CORBA::tk_string,
-  0U, // string length
+  0U, // string	length
 };
 static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Administration_CannotActivate (CORBA::tk_except, sizeof (_oc_ImplementationRepository_Administration_CannotActivate), (char *) &_oc_ImplementationRepository_Administration_CannotActivate, 0, sizeof (ImplementationRepository::Administration::CannotActivate));
 CORBA::TypeCode_ptr ImplementationRepository::Administration::_tc_CannotActivate = &_tc_TAO_tc_ImplementationRepository_Administration_CannotActivate;
 
 CORBA::TypeCode_ptr
-ImplementationRepository::Administration::CannotActivate::_type (void) const
+ImplementationRepository::Administration::CannotActivate::_type	(void) const
 {
   return _tc_CannotActivate;
 }
 
 // default constructor
 ImplementationRepository::Administration::NotFound::NotFound (void)
-  : CORBA_UserException ("IDL:ImplementationRepository/Administration/NotFound:1.0")
+  : CORBA_UserException	("IDL:ImplementationRepository/Administration/NotFound:1.0")
 {
 }
 
-// destructor - all members are of self managing types
+// destructor -	all members are	of self	managing types
 ImplementationRepository::Administration::NotFound::~NotFound (void)
 {
 }
@@ -1079,9 +1081,9 @@ void ImplementationRepository::Administration::NotFound::_tao_any_destructor (vo
   delete tmp;
 }
 
-// copy constructor
+// copy	constructor
 ImplementationRepository::Administration::NotFound::NotFound (const ::ImplementationRepository::Administration::NotFound &_tao_excp)
-  : CORBA_UserException (_tao_excp._id ())
+  : CORBA_UserException	(_tao_excp._id ())
 {
   }
 
@@ -1096,7 +1098,7 @@ ImplementationRepository::Administration::NotFound::operator= (const ::Implement
 
 // narrow
 ImplementationRepository::Administration::NotFound *
-ImplementationRepository::Administration::NotFound::_downcast (CORBA::Exception *exc)
+ImplementationRepository::Administration::NotFound::_downcast (CORBA::Exception	*exc)
 {
   if (!ACE_OS::strcmp ("IDL:ImplementationRepository/Administration/NotFound:1.0", exc->_id ())) // same type
     return ACE_dynamic_cast (NotFound *, exc);
@@ -1105,7 +1107,7 @@ ImplementationRepository::Administration::NotFound::_downcast (CORBA::Exception
 }
 
 
-void ImplementationRepository::Administration::NotFound::_raise ()
+void ImplementationRepository::Administration::NotFound::_raise	()
 {
   TAO_RAISE(*this);
 }
@@ -1134,18 +1136,18 @@ void ImplementationRepository::Administration::NotFound::_tao_decode (
 CORBA::Exception *ImplementationRepository::Administration::NotFound::_alloc (void)
 {
   CORBA::Exception *retval = 0;
-  ACE_NEW_RETURN (retval, ::ImplementationRepository::Administration::NotFound, 0);
+  ACE_NEW_RETURN (retval, ::ImplementationRepository::Administration::NotFound,	0);
   return retval;
 }
 
-static const CORBA::Long _oc_ImplementationRepository_Administration_NotFound[] =
+static const CORBA::Long _oc_ImplementationRepository_Administration_NotFound[]	=
 {
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  57, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f41646d), ACE_NTOHL (0x696e6973), ACE_NTOHL (0x74726174), ACE_NTOHL (0x696f6e2f), ACE_NTOHL (0x4e6f7446), ACE_NTOHL (0x6f756e64), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/Administration/NotFound:1.0
+  TAO_ENCAP_BYTE_ORDER,	// byte	order
+  57, ACE_NTOHL	(0x49444c3a), ACE_NTOHL	(0x496d706c), ACE_NTOHL	(0x656d656e), ACE_NTOHL	(0x74617469), ACE_NTOHL	(0x6f6e5265), ACE_NTOHL	(0x706f7369), ACE_NTOHL	(0x746f7279), ACE_NTOHL	(0x2f41646d), ACE_NTOHL	(0x696e6973), ACE_NTOHL	(0x74726174), ACE_NTOHL	(0x696f6e2f), ACE_NTOHL	(0x4e6f7446), ACE_NTOHL	(0x6f756e64), ACE_NTOHL	(0x3a312e30), ACE_NTOHL	(0x0),	// repository ID = IDL:ImplementationRepository/Administration/NotFound:1.0
   9, ACE_NTOHL (0x4e6f7446), ACE_NTOHL (0x6f756e64), ACE_NTOHL (0x0),  // name = NotFound
-  0, // member count
+  0, //	member count
 };
-static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Administration_NotFound (CORBA::tk_except, sizeof (_oc_ImplementationRepository_Administration_NotFound), (char *) &_oc_ImplementationRepository_Administration_NotFound, 0, sizeof (ImplementationRepository::Administration::NotFound));
+static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Administration_NotFound (CORBA::tk_except, sizeof (_oc_ImplementationRepository_Administration_NotFound), (char *) &_oc_ImplementationRepository_Administration_NotFound, 0,	sizeof (ImplementationRepository::Administration::NotFound));
 CORBA::TypeCode_ptr ImplementationRepository::Administration::_tc_NotFound = &_tc_TAO_tc_ImplementationRepository_Administration_NotFound;
 
 CORBA::TypeCode_ptr
@@ -1183,34 +1185,35 @@ void ImplementationRepository::Administration::activate_server (
       istub,
       "activate_server",
       15,
+      1,
       istub->orb_core ()
     );
       for (;;)
       {
-        _tao_call.start (ACE_TRY_ENV);
-        ACE_CHECK;
-        CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
-        // Tremporary hack until GIOP 1.2 is implemented.
-
-        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
-        ACE_CHECK;
-
-        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-        if (!(
-              (_tao_out << server)
-          ))
-          ACE_THROW (CORBA::MARSHAL ());
-        int _invoke_status =
-          _tao_call.invoke (_tao_ImplementationRepository_Administration_activate_server_exceptiondata, 2, ACE_TRY_ENV);
-                ACE_CHECK;
-
-        if (_invoke_status == TAO_INVOKE_RESTART)
-          continue;
-        if (_invoke_status != TAO_INVOKE_OK)
-        {
-          ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
-        }
-        break;
+	_tao_call.start	(ACE_TRY_ENV);
+	ACE_CHECK;
+	CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
+	// Tremporary hack until GIOP 1.2 is implemented.
+
+	_tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),	ACE_TRY_ENV);
+	ACE_CHECK;
+
+	TAO_OutputCDR &_tao_out	= _tao_call.out_stream ();
+	if (!(
+	      (_tao_out	<< server)
+	  ))
+	  ACE_THROW (CORBA::MARSHAL ());
+	int _invoke_status =
+	  _tao_call.invoke (_tao_ImplementationRepository_Administration_activate_server_exceptiondata,	2, ACE_TRY_ENV);
+		ACE_CHECK;
+
+	if (_invoke_status == TAO_INVOKE_RESTART)
+	  continue;
+	if (_invoke_status != TAO_INVOKE_OK)
+	{
+	  ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+	}
+	break;
       }
 
 }
@@ -1243,37 +1246,38 @@ void ImplementationRepository::Administration::register_server (
       istub,
       "register_server",
       15,
+      1,
       istub->orb_core ()
     );
 
       for (;;)
       {
-        _tao_call.start (ACE_TRY_ENV);
-        ACE_CHECK;
-
-        CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
-        // Tremporary hack until GIOP 1.2 is implemented.
-
-        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
-        ACE_CHECK;
-
-        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-        if (!(
-              (_tao_out << server) &&
-              (_tao_out << options)
-          ))
-          ACE_THROW (CORBA::MARSHAL ());
-        int _invoke_status =
-          _tao_call.invoke (_tao_ImplementationRepository_Administration_register_server_exceptiondata, 1, ACE_TRY_ENV);
-                ACE_CHECK;
-
-        if (_invoke_status == TAO_INVOKE_RESTART)
-          continue;
-        if (_invoke_status != TAO_INVOKE_OK)
-        {
-          ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
-        }
-        break;
+	_tao_call.start	(ACE_TRY_ENV);
+	ACE_CHECK;
+
+	CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
+	// Tremporary hack until GIOP 1.2 is implemented.
+
+	_tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),	ACE_TRY_ENV);
+	ACE_CHECK;
+
+	TAO_OutputCDR &_tao_out	= _tao_call.out_stream ();
+	if (!(
+	      (_tao_out	<< server) &&
+	      (_tao_out	<< options)
+	  ))
+	  ACE_THROW (CORBA::MARSHAL ());
+	int _invoke_status =
+	  _tao_call.invoke (_tao_ImplementationRepository_Administration_register_server_exceptiondata,	1, ACE_TRY_ENV);
+		ACE_CHECK;
+
+	if (_invoke_status == TAO_INVOKE_RESTART)
+	  continue;
+	if (_invoke_status != TAO_INVOKE_OK)
+	{
+	  ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+	}
+	break;
       }
 
 }
@@ -1300,35 +1304,36 @@ void ImplementationRepository::Administration::reregister_server (
       istub,
       "reregister_server",
       17,
+      1,
       istub->orb_core ()
     );
       for (;;)
       {
-        _tao_call.start (ACE_TRY_ENV);
-        ACE_CHECK;
-        CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
-        // Tremporary hack until GIOP 1.2 is implemented.
-
-        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
-        ACE_CHECK;
-
-        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-        if (!(
-              (_tao_out << server) &&
-              (_tao_out << options)
-          ))
-          ACE_THROW (CORBA::MARSHAL ());
-        int _invoke_status =
-          _tao_call.invoke (0, 0, ACE_TRY_ENV);
-                ACE_CHECK;
-
-        if (_invoke_status == TAO_INVOKE_RESTART)
-          continue;
-        if (_invoke_status != TAO_INVOKE_OK)
-        {
-          ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
-        }
-        break;
+	_tao_call.start	(ACE_TRY_ENV);
+	ACE_CHECK;
+	CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
+	// Tremporary hack until GIOP 1.2 is implemented.
+
+	_tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),	ACE_TRY_ENV);
+	ACE_CHECK;
+
+	TAO_OutputCDR &_tao_out	= _tao_call.out_stream ();
+	if (!(
+	      (_tao_out	<< server) &&
+	      (_tao_out	<< options)
+	  ))
+	  ACE_THROW (CORBA::MARSHAL ());
+	int _invoke_status =
+	  _tao_call.invoke (0, 0, ACE_TRY_ENV);
+		ACE_CHECK;
+
+	if (_invoke_status == TAO_INVOKE_RESTART)
+	  continue;
+	if (_invoke_status != TAO_INVOKE_OK)
+	{
+	  ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+	}
+	break;
       }
 
 }
@@ -1343,7 +1348,7 @@ void ImplementationRepository::Administration::remove_server (
   ))
 {
 
-  static TAO_Exception_Data _tao_ImplementationRepository_Administration_remove_server_exceptiondata [] =
+  static TAO_Exception_Data _tao_ImplementationRepository_Administration_remove_server_exceptiondata []	=
   {
     {ImplementationRepository::Administration::_tc_NotFound, ImplementationRepository::Administration::NotFound::_alloc}
   };
@@ -1360,36 +1365,37 @@ void ImplementationRepository::Administration::remove_server (
       istub,
       "remove_server",
       13,
+      1,
       istub->orb_core ()
     );
 
       for (;;)
       {
-        _tao_call.start (ACE_TRY_ENV);
-        ACE_CHECK;
-
-        CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
-        // Tremporary hack until GIOP 1.2 is implemented.
-
-        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
-        ACE_CHECK;
-
-        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-        if (!(
-              (_tao_out << server)
-          ))
-          ACE_THROW (CORBA::MARSHAL ());
-        int _invoke_status =
-          _tao_call.invoke (_tao_ImplementationRepository_Administration_remove_server_exceptiondata, 1, ACE_TRY_ENV);
-                ACE_CHECK;
-
-        if (_invoke_status == TAO_INVOKE_RESTART)
-          continue;
-        if (_invoke_status != TAO_INVOKE_OK)
-        {
-          ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
-        }
-        break;
+	_tao_call.start	(ACE_TRY_ENV);
+	ACE_CHECK;
+
+	CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
+	// Tremporary hack until GIOP 1.2 is implemented.
+
+	_tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),	ACE_TRY_ENV);
+	ACE_CHECK;
+
+	TAO_OutputCDR &_tao_out	= _tao_call.out_stream ();
+	if (!(
+	      (_tao_out	<< server)
+	  ))
+	  ACE_THROW (CORBA::MARSHAL ());
+	int _invoke_status =
+	  _tao_call.invoke (_tao_ImplementationRepository_Administration_remove_server_exceptiondata, 1, ACE_TRY_ENV);
+		ACE_CHECK;
+
+	if (_invoke_status == TAO_INVOKE_RESTART)
+	  continue;
+	if (_invoke_status != TAO_INVOKE_OK)
+	{
+	  ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+	}
+	break;
       }
 }
 
@@ -1420,37 +1426,38 @@ void ImplementationRepository::Administration::shutdown_server (
       istub,
       "shutdown_server",
       15,
+      1,
       istub->orb_core ()
     );
 
       for (;;)
       {
-        _tao_call.start (ACE_TRY_ENV);
-        ACE_CHECK;
+	_tao_call.start	(ACE_TRY_ENV);
+	ACE_CHECK;
 
-        CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
-        // Tremporary hack until GIOP 1.2 is implemented.
+	CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
+	// Tremporary hack until GIOP 1.2 is implemented.
 
-        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
-        ACE_CHECK;
+	_tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),	ACE_TRY_ENV);
+	ACE_CHECK;
 
-        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-        if (!(
-              (_tao_out << server)
-          ))
-          ACE_THROW (CORBA::MARSHAL ());
-        int _invoke_status =
-          _tao_call.invoke (_tao_ImplementationRepository_Administration_shutdown_server_exceptiondata, 1, ACE_TRY_ENV);
-                ACE_CHECK;
+	TAO_OutputCDR &_tao_out	= _tao_call.out_stream ();
+	if (!(
+	      (_tao_out	<< server)
+	  ))
+	  ACE_THROW (CORBA::MARSHAL ());
+	int _invoke_status =
+	  _tao_call.invoke (_tao_ImplementationRepository_Administration_shutdown_server_exceptiondata,	1, ACE_TRY_ENV);
+		ACE_CHECK;
 
-        if (_invoke_status == TAO_INVOKE_RESTART)
-          continue;
-        if (_invoke_status != TAO_INVOKE_OK)
-        {
-          ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
-        }
+	if (_invoke_status == TAO_INVOKE_RESTART)
+	  continue;
+	if (_invoke_status != TAO_INVOKE_OK)
+	{
+	  ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+	}
 
-        break;
+	break;
 
       }
 }
@@ -1484,49 +1491,50 @@ char * ImplementationRepository::Administration::server_is_running (
       istub,
       "server_is_running",
       17,
+      1,
       istub->orb_core ()
     );
 
       for (;;)
       {
-        _tao_call.start (ACE_TRY_ENV);
-        ACE_CHECK_RETURN (0);
-
-        CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
-        // Tremporary hack until GIOP 1.2 is implemented.
-
-        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
-        ACE_CHECK_RETURN (0);
-
-        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-        if (!(
-              (_tao_out << server) &&
-              (_tao_out << addr) &&
-              (_tao_out << server_object)
-          ))
-          ACE_THROW_RETURN (CORBA::MARSHAL (), 0);
-
-        int _invoke_status =
-          _tao_call.invoke (_tao_ImplementationRepository_Administration_server_is_running_exceptiondata, 1, ACE_TRY_ENV);
-                ACE_CHECK_RETURN (0);
-
-        if (_invoke_status == TAO_INVOKE_RESTART)
-          continue;
-        if (_invoke_status != TAO_INVOKE_OK)
-        {
-          ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
-
-        }
-        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-        if (!(
-              (_tao_in >> _tao_safe_retval.inout ())
-          ))
-          ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
-
-        break;
+	_tao_call.start	(ACE_TRY_ENV);
+	ACE_CHECK_RETURN (0);
+
+	CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
+	// Tremporary hack until GIOP 1.2 is implemented.
+
+	_tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),	ACE_TRY_ENV);
+	ACE_CHECK_RETURN (0);
+
+	TAO_OutputCDR &_tao_out	= _tao_call.out_stream ();
+	if (!(
+	      (_tao_out	<< server) &&
+	      (_tao_out	<< addr) &&
+	      (_tao_out	<< server_object)
+	  ))
+	  ACE_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+	int _invoke_status =
+	  _tao_call.invoke (_tao_ImplementationRepository_Administration_server_is_running_exceptiondata, 1, ACE_TRY_ENV);
+		ACE_CHECK_RETURN (0);
+
+	if (_invoke_status == TAO_INVOKE_RESTART)
+	  continue;
+	if (_invoke_status != TAO_INVOKE_OK)
+	{
+	  ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+	}
+	TAO_InputCDR &_tao_in =	_tao_call.inp_stream ();
+	if (!(
+	      (_tao_in >> _tao_safe_retval.inout ())
+	  ))
+	  ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+	break;
 
       }
-  return _tao_safe_retval._retn ();
+  return _tao_safe_retval._retn	();
 }
 
 void ImplementationRepository::Administration::server_is_shutting_down (
@@ -1553,37 +1561,38 @@ void ImplementationRepository::Administration::server_is_shutting_down (
       istub,
       "server_is_shutting_down",
       23,
+      1,
       istub->orb_core ()
     );
 
       for (;;)
       {
-        _tao_call.start (ACE_TRY_ENV);
-        ACE_CHECK;
+	_tao_call.start	(ACE_TRY_ENV);
+	ACE_CHECK;
 
-        CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
-        // Tremporary hack until GIOP 1.2 is implemented.
+	CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
+	// Tremporary hack until GIOP 1.2 is implemented.
 
-        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
-        ACE_CHECK;
+	_tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),	ACE_TRY_ENV);
+	ACE_CHECK;
 
-        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-        if (!(
-              (_tao_out << server)
-          ))
-          ACE_THROW (CORBA::MARSHAL ());
-        int _invoke_status =
-          _tao_call.invoke (_tao_ImplementationRepository_Administration_server_is_shutting_down_exceptiondata, 1, ACE_TRY_ENV);
-                ACE_CHECK;
+	TAO_OutputCDR &_tao_out	= _tao_call.out_stream ();
+	if (!(
+	      (_tao_out	<< server)
+	  ))
+	  ACE_THROW (CORBA::MARSHAL ());
+	int _invoke_status =
+	  _tao_call.invoke (_tao_ImplementationRepository_Administration_server_is_shutting_down_exceptiondata,	1, ACE_TRY_ENV);
+		ACE_CHECK;
 
-        if (_invoke_status == TAO_INVOKE_RESTART)
-          continue;
-        if (_invoke_status != TAO_INVOKE_OK)
-        {
-          ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
-        }
+	if (_invoke_status == TAO_INVOKE_RESTART)
+	  continue;
+	if (_invoke_status != TAO_INVOKE_OK)
+	{
+	  ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+	}
 
-        break;
+	break;
 
       }
 
@@ -1613,46 +1622,47 @@ void ImplementationRepository::Administration::find (
     ACE_THROW (CORBA::INTERNAL ());
 
 
-  ACE_NEW (info.ptr (), ImplementationRepository::ServerInformation);
+  ACE_NEW (info.ptr (),	ImplementationRepository::ServerInformation);
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "find",
       4,
+      1,
       istub->orb_core ()
     );
 
 
       for (;;)
       {
-        _tao_call.start (ACE_TRY_ENV);
-        ACE_CHECK;
-        CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
-        // Tremporary hack until GIOP 1.2 is implemented.
-
-        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
-        ACE_CHECK;
-
-        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-        if (!(
-              (_tao_out << server)
-          ))
-          ACE_THROW (CORBA::MARSHAL ());
-        int _invoke_status =
-          _tao_call.invoke (_tao_ImplementationRepository_Administration_find_exceptiondata, 1, ACE_TRY_ENV);
-                ACE_CHECK;
-
-        if (_invoke_status == TAO_INVOKE_RESTART)
-          continue;
-        if (_invoke_status != TAO_INVOKE_OK)
-        {
-          ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
-        }
-        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-        if (!(
-                            (_tao_in >> *info.ptr ())
-          ))
-          ACE_THROW (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
-        break;
+	_tao_call.start	(ACE_TRY_ENV);
+	ACE_CHECK;
+	CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
+	// Tremporary hack until GIOP 1.2 is implemented.
+
+	_tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),	ACE_TRY_ENV);
+	ACE_CHECK;
+
+	TAO_OutputCDR &_tao_out	= _tao_call.out_stream ();
+	if (!(
+	      (_tao_out	<< server)
+	  ))
+	  ACE_THROW (CORBA::MARSHAL ());
+	int _invoke_status =
+	  _tao_call.invoke (_tao_ImplementationRepository_Administration_find_exceptiondata, 1,	ACE_TRY_ENV);
+		ACE_CHECK;
+
+	if (_invoke_status == TAO_INVOKE_RESTART)
+	  continue;
+	if (_invoke_status != TAO_INVOKE_OK)
+	{
+	  ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+	}
+	TAO_InputCDR &_tao_in =	_tao_call.inp_stream ();
+	if (!(
+			    (_tao_in >>	*info.ptr ())
+	  ))
+	  ACE_THROW (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+	break;
 
       }
 
@@ -1660,7 +1670,7 @@ void ImplementationRepository::Administration::find (
 
 void ImplementationRepository::Administration::list (
     CORBA::ULong how_many,
-    ImplementationRepository::ServerInformationList_out server_list,
+    ImplementationRepository::ServerInformationList_out	server_list,
     ImplementationRepository::ServerInformationIterator_out server_iterator,
     CORBA::Environment &ACE_TRY_ENV
   )
@@ -1682,42 +1692,43 @@ void ImplementationRepository::Administration::list (
       istub,
       "list",
       4,
+      1,
       istub->orb_core ()
     );
 
       for (;;)
       {
-        _tao_call.start (ACE_TRY_ENV);
-        ACE_CHECK;
-
-        CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
-        // Tremporary hack until GIOP 1.2 is implemented.
-
-        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
-        ACE_CHECK;
-
-        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-        if (!(
-              (_tao_out << how_many)
-          ))
-          ACE_THROW (CORBA::MARSHAL ());
-        int _invoke_status =
-          _tao_call.invoke (0, 0, ACE_TRY_ENV);
-                ACE_CHECK;
-
-        if (_invoke_status == TAO_INVOKE_RESTART)
-          continue;
-        if (_invoke_status != TAO_INVOKE_OK)
-        {
-          ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
-        }
-        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-        if (!(
-                            (_tao_in >> *server_list.ptr ()) &&
-              (_tao_in >> server_iterator.ptr ())
-          ))
-          ACE_THROW (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
-        break;
+	_tao_call.start	(ACE_TRY_ENV);
+	ACE_CHECK;
+
+	CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
+	// Tremporary hack until GIOP 1.2 is implemented.
+
+	_tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),	ACE_TRY_ENV);
+	ACE_CHECK;
+
+	TAO_OutputCDR &_tao_out	= _tao_call.out_stream ();
+	if (!(
+	      (_tao_out	<< how_many)
+	  ))
+	  ACE_THROW (CORBA::MARSHAL ());
+	int _invoke_status =
+	  _tao_call.invoke (0, 0, ACE_TRY_ENV);
+		ACE_CHECK;
+
+	if (_invoke_status == TAO_INVOKE_RESTART)
+	  continue;
+	if (_invoke_status != TAO_INVOKE_OK)
+	{
+	  ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+	}
+	TAO_InputCDR &_tao_in =	_tao_call.inp_stream ();
+	if (!(
+			    (_tao_in >>	*server_list.ptr ()) &&
+	      (_tao_in >> server_iterator.ptr ())
+	  ))
+	  ACE_THROW (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+	break;
 
       }
 
@@ -1746,7 +1757,7 @@ ImplementationRepository::TAO_ImplementationRepository_Administration_Default_Pr
     }
 }
 
-ImplementationRepository::TAO_ImplementationRepository_Administration_Default_Proxy_Factory::~TAO_ImplementationRepository_Administration_Default_Proxy_Factory (void)
+ImplementationRepository::TAO_ImplementationRepository_Administration_Default_Proxy_Factory::~TAO_ImplementationRepository_Administration_Default_Proxy_Factory	(void)
 {
 }
 
@@ -1765,9 +1776,9 @@ ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Fact
 {
 }
 
-ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter::~TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter (void)
+ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter::~TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter	(void)
 {
-  // Making sure the factory which the adapter has is destroyed with it.
+  // Making sure the factory which the adapter has is destroyed	with it.
   if (this->proxy_factory_ != 0)
     delete this->proxy_factory_;
 }
@@ -1775,15 +1786,15 @@ ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Fact
 int
 ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter::register_proxy_factory (
   TAO_ImplementationRepository_Administration_Default_Proxy_Factory *df,
-     CORBA::Environment &ACE_TRY_ENV
+     CORBA::Environment	&ACE_TRY_ENV
       )
 {
-  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,	ace_mon,
     this->lock_, 0));
-  // Remove any existing <proxy_factory_> and replace with the new one.
+  // Remove any	existing <proxy_factory_> and replace with the new one.
   this->unregister_proxy_factory (ACE_TRY_ENV);
   this->proxy_factory_ = df;
-  this->delete_proxy_factory_ = 0;
+  this->delete_proxy_factory_ =	0;
 return 0;
 }
 
@@ -1792,13 +1803,13 @@ ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Fact
   CORBA::Environment &
     )
 {
-  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,	ace_mon,
     this->lock_, 0));
   if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
     {
-      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
-      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is
-      // invoked in the destructor of the class too.
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure	that it
+      // doesnt	get into an infinite loop in <unregister_proxy_factory>	as it is
+      // invoked in the	destructor of the class	too.
       this->delete_proxy_factory_ = 1;
       delete this->proxy_factory_;
       this->proxy_factory_ = 0;
@@ -1812,13 +1823,13 @@ ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Fact
     CORBA::Environment &
   )
 {
-  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,	ace_mon,
     this->lock_, 0));
-  // Verify that an <proxy_factory_> is available else make one.
+  // Verify that an <proxy_factory_> is	available else make one.
   if (this->proxy_factory_ == 0)
     ACE_NEW_RETURN (this->proxy_factory_,
-        TAO_ImplementationRepository_Administration_Default_Proxy_Factory (1),
-         0);
+	TAO_ImplementationRepository_Administration_Default_Proxy_Factory (1),
+	 0);
 
 
   return this->proxy_factory_->create_proxy (proxy);
@@ -1868,7 +1879,7 @@ void ImplementationRepository::TAO_ImplementationRepository_Administration_Smart
 
 }
 
-void ImplementationRepository::TAO_ImplementationRepository_Administration_Smart_Proxy_Base::reregister_server  (
+void ImplementationRepository::TAO_ImplementationRepository_Administration_Smart_Proxy_Base::reregister_server	(
     const char * server,
     const ImplementationRepository::StartupOptions & options,
     CORBA::Environment &ACE_TRY_ENV
@@ -1973,7 +1984,7 @@ void ImplementationRepository::TAO_ImplementationRepository_Administration_Smart
 
 void ImplementationRepository::TAO_ImplementationRepository_Administration_Smart_Proxy_Base::list  (
     CORBA::ULong how_many,
-    ImplementationRepository::ServerInformationList_out server_list,
+    ImplementationRepository::ServerInformationList_out	server_list,
     ImplementationRepository::ServerInformationIterator_out server_iterator,
     CORBA::Environment &ACE_TRY_ENV
   )
@@ -1994,14 +2005,14 @@ void ImplementationRepository::TAO_ImplementationRepository_Administration_Smart
   defined (ACE_HAS_GNU_REPO)
 template class TAO_Singleton<ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#pragma instantiate TAO_Singleton<ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#pragma	instantiate TAO_Singleton<ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
 static const CORBA::Long _oc_ImplementationRepository_Administration[] =
 {
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f41646d), ACE_NTOHL (0x696e6973), ACE_NTOHL (0x74726174), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:ImplementationRepository/Administration:1.0
-  15, ACE_NTOHL (0x41646d69), ACE_NTOHL (0x6e697374), ACE_NTOHL (0x72617469), ACE_NTOHL (0x6f6e0000),  // name = Administration
+  TAO_ENCAP_BYTE_ORDER,	// byte	order
+  48, ACE_NTOHL	(0x49444c3a), ACE_NTOHL	(0x496d706c), ACE_NTOHL	(0x656d656e), ACE_NTOHL	(0x74617469), ACE_NTOHL	(0x6f6e5265), ACE_NTOHL	(0x706f7369), ACE_NTOHL	(0x746f7279), ACE_NTOHL	(0x2f41646d), ACE_NTOHL	(0x696e6973), ACE_NTOHL	(0x74726174), ACE_NTOHL	(0x696f6e3a), ACE_NTOHL	(0x312e3000),  // repository ID	= IDL:ImplementationRepository/Administration:1.0
+  15, ACE_NTOHL	(0x41646d69), ACE_NTOHL	(0x6e697374), ACE_NTOHL	(0x72617469), ACE_NTOHL	(0x6f6e0000),  // name = Administration
 };
 static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Administration (CORBA::tk_objref, sizeof (_oc_ImplementationRepository_Administration), (char *) &_oc_ImplementationRepository_Administration, 0, sizeof (ImplementationRepository::Administration));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
@@ -2014,21 +2025,21 @@ void ImplementationRepository::ServerInformationIterator::_tao_any_destructor (v
   CORBA::release (tmp);
 }
 
-ImplementationRepository::ServerInformationIterator_ptr ImplementationRepository::ServerInformationIterator::_narrow (
+ImplementationRepository::ServerInformationIterator_ptr	ImplementationRepository::ServerInformationIterator::_narrow (
     CORBA::Object_ptr obj,
     CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
     return ServerInformationIterator::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:ImplementationRepository/ServerInformationIterator:1.0", ACE_TRY_ENV);
+  CORBA::Boolean is_a =	obj->_is_a ("IDL:ImplementationRepository/ServerInformationIterator:1.0", ACE_TRY_ENV);
   ACE_CHECK_RETURN (ServerInformationIterator::_nil ());
   if (is_a == 0)
     return ServerInformationIterator::_nil ();
   return ServerInformationIterator::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-ImplementationRepository::ServerInformationIterator_ptr ImplementationRepository::ServerInformationIterator::_unchecked_narrow (
+ImplementationRepository::ServerInformationIterator_ptr	ImplementationRepository::ServerInformationIterator::_unchecked_narrow (
     CORBA::Object_ptr obj,
     CORBA::Environment &
   )
@@ -2037,18 +2048,18 @@ ImplementationRepository::ServerInformationIterator_ptr ImplementationRepository
     return ServerInformationIterator::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
   stub->_incr_refcnt ();
-  ServerInformationIterator_ptr default_proxy = ServerInformationIterator::_nil ();
-  if (obj->_is_collocated () && _TAO_collocation_ImplementationRepository_ServerInformationIterator_Stub_Factory_function_pointer != 0)
+  ServerInformationIterator_ptr	default_proxy =	ServerInformationIterator::_nil	();
+  if (obj->_is_collocated () &&	_TAO_collocation_ImplementationRepository_ServerInformationIterator_Stub_Factory_function_pointer != 0)
     {
-      default_proxy = _TAO_collocation_ImplementationRepository_ServerInformationIterator_Stub_Factory_function_pointer (obj);
+      default_proxy = _TAO_collocation_ImplementationRepository_ServerInformationIterator_Stub_Factory_function_pointer	(obj);
     }
   if (CORBA::is_nil (default_proxy))
     ACE_NEW_RETURN (default_proxy, ServerInformationIterator (stub), ServerInformationIterator::_nil ());
-  return TAO_ImplementationRepository_ServerInformationIterator_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
+  return TAO_ImplementationRepository_ServerInformationIterator_PROXY_FACTORY_ADAPTER::instance	()->create_proxy (default_proxy);
 }
 
 ImplementationRepository::ServerInformationIterator_ptr
-ImplementationRepository::ServerInformationIterator::_duplicate (ServerInformationIterator_ptr obj)
+ImplementationRepository::ServerInformationIterator::_duplicate	(ServerInformationIterator_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_add_ref ();
@@ -2057,7 +2068,7 @@ ImplementationRepository::ServerInformationIterator::_duplicate (ServerInformati
 
 CORBA::Boolean ImplementationRepository::ServerInformationIterator::next_n (
     CORBA::ULong how_many,
-    ImplementationRepository::ServerInformationList_out server_list,
+    ImplementationRepository::ServerInformationList_out	server_list,
     CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
@@ -2078,45 +2089,46 @@ CORBA::Boolean ImplementationRepository::ServerInformationIterator::next_n (
       istub,
       "next_n",
       6,
+      1,
       istub->orb_core ()
     );
       for (;;)
       {
-        _tao_call.start (ACE_TRY_ENV);
-        ACE_CHECK_RETURN  (_tao_retval);
-
-        ACE_CHECK_RETURN  (_tao_retval);
-        CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
-        // Tremporary hack until GIOP 1.2 is implemented.
-
-        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
-        ACE_CHECK_RETURN  (_tao_retval);
-
-        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-        if (!(
-              (_tao_out << how_many)
-          ))
-          ACE_THROW_RETURN (CORBA::MARSHAL (), _tao_retval);
-
-        int _invoke_status =
-          _tao_call.invoke (0, 0, ACE_TRY_ENV);
-                ACE_CHECK_RETURN  (_tao_retval);
-
-        if (_invoke_status == TAO_INVOKE_RESTART)
-          continue;
-        if (_invoke_status != TAO_INVOKE_OK)
-        {
-          ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
-        }
-        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-        if (!(
-              (_tao_in >> CORBA::Any::to_boolean (_tao_retval)) &&
-                            (_tao_in >> *server_list.ptr ())
-          ))
-          ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
-        break;
+	_tao_call.start	(ACE_TRY_ENV);
+	ACE_CHECK_RETURN  (_tao_retval);
+
+	ACE_CHECK_RETURN  (_tao_retval);
+	CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
+	// Tremporary hack until GIOP 1.2 is implemented.
+
+	_tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),	ACE_TRY_ENV);
+	ACE_CHECK_RETURN  (_tao_retval);
+
+	TAO_OutputCDR &_tao_out	= _tao_call.out_stream ();
+	if (!(
+	      (_tao_out	<< how_many)
+	  ))
+	  ACE_THROW_RETURN (CORBA::MARSHAL (), _tao_retval);
+
+	int _invoke_status =
+	  _tao_call.invoke (0, 0, ACE_TRY_ENV);
+		ACE_CHECK_RETURN  (_tao_retval);
+
+	if (_invoke_status == TAO_INVOKE_RESTART)
+	  continue;
+	if (_invoke_status != TAO_INVOKE_OK)
+	{
+	  ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+	}
+	TAO_InputCDR &_tao_in =	_tao_call.inp_stream ();
+	if (!(
+	      (_tao_in >> CORBA::Any::to_boolean (_tao_retval))	&&
+			    (_tao_in >>	*server_list.ptr ())
+	  ))
+	  ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+	break;
 
       }
   return _tao_retval;
@@ -2142,38 +2154,39 @@ void ImplementationRepository::ServerInformationIterator::destroy (
       istub,
       "destroy",
       7,
+      0,
       istub->orb_core ()
     );
 
       for (;;)
       {
-        _tao_call.start (ACE_TRY_ENV);
-        ACE_CHECK;
+	_tao_call.start	(ACE_TRY_ENV);
+	ACE_CHECK;
 
-        CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
-        // Tremporary hack until GIOP 1.2 is implemented.
+	CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
+	// Tremporary hack until GIOP 1.2 is implemented.
 
-        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
-        ACE_CHECK;
+	_tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),	ACE_TRY_ENV);
+	ACE_CHECK;
 
-        int _invoke_status =
-          _tao_call.invoke (0, 0, ACE_TRY_ENV);
-                ACE_CHECK;
+	int _invoke_status =
+	  _tao_call.invoke (0, 0, ACE_TRY_ENV);
+		ACE_CHECK;
 
-        if (_invoke_status == TAO_INVOKE_RESTART)
-          continue;
-        if (_invoke_status != TAO_INVOKE_OK)
-        {
-          ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
-        }
+	if (_invoke_status == TAO_INVOKE_RESTART)
+	  continue;
+	if (_invoke_status != TAO_INVOKE_OK)
+	{
+	  ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+	}
 
-        break;
+	break;
 
       }
 
 }
 
-CORBA::Boolean ImplementationRepository::ServerInformationIterator::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+CORBA::Boolean ImplementationRepository::ServerInformationIterator::_is_a (const CORBA::Char *value, CORBA::Environment	&ACE_TRY_ENV)
 {
   if (
     (!ACE_OS::strcmp ((char *)value, "IDL:ImplementationRepository/ServerInformationIterator:1.0")) ||
@@ -2192,7 +2205,7 @@ ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator
 {
   if (register_proxy_factory)
     {
-      TAO_ImplementationRepository_ServerInformationIterator_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+      TAO_ImplementationRepository_ServerInformationIterator_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory	(this);
     }
 }
 
@@ -2217,7 +2230,7 @@ ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator
 
 ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator_Proxy_Factory_Adapter::~TAO_ImplementationRepository_ServerInformationIterator_Proxy_Factory_Adapter (void)
 {
-  // Making sure the factory which the adapter has is destroyed with it.
+  // Making sure the factory which the adapter has is destroyed	with it.
   if (this->proxy_factory_ != 0)
     delete this->proxy_factory_;
 }
@@ -2225,15 +2238,15 @@ ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator
 int
 ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator_Proxy_Factory_Adapter::register_proxy_factory (
   TAO_ImplementationRepository_ServerInformationIterator_Default_Proxy_Factory *df,
-     CORBA::Environment &ACE_TRY_ENV
+     CORBA::Environment	&ACE_TRY_ENV
       )
 {
-  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,	ace_mon,
     this->lock_, 0));
-  // Remove any existing <proxy_factory_> and replace with the new one.
+  // Remove any	existing <proxy_factory_> and replace with the new one.
   this->unregister_proxy_factory (ACE_TRY_ENV);
   this->proxy_factory_ = df;
-  this->delete_proxy_factory_ = 0;
+  this->delete_proxy_factory_ =	0;
 return 0;
 }
 
@@ -2242,13 +2255,13 @@ ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator
   CORBA::Environment &
     )
 {
-  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,	ace_mon,
     this->lock_, 0));
   if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
     {
-      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
-      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is
-      // invoked in the destructor of the class too.
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure	that it
+      // doesnt	get into an infinite loop in <unregister_proxy_factory>	as it is
+      // invoked in the	destructor of the class	too.
       this->delete_proxy_factory_ = 1;
       delete this->proxy_factory_;
       this->proxy_factory_ = 0;
@@ -2262,13 +2275,13 @@ ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator
     CORBA::Environment &
   )
 {
-  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,	ace_mon,
     this->lock_, 0));
-  // Verify that an <proxy_factory_> is available else make one.
+  // Verify that an <proxy_factory_> is	available else make one.
   if (this->proxy_factory_ == 0)
     ACE_NEW_RETURN (this->proxy_factory_,
-        TAO_ImplementationRepository_ServerInformationIterator_Default_Proxy_Factory (1),
-         0);
+	TAO_ImplementationRepository_ServerInformationIterator_Default_Proxy_Factory (1),
+	 0);
 
 
   return this->proxy_factory_->create_proxy (proxy);
@@ -2285,7 +2298,7 @@ ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator
 
 CORBA::Boolean ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator_Smart_Proxy_Base::next_n  (
     CORBA::ULong how_many,
-    ImplementationRepository::ServerInformationList_out server_list,
+    ImplementationRepository::ServerInformationList_out	server_list,
     CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
@@ -2300,7 +2313,7 @@ CORBA::Boolean ImplementationRepository::TAO_ImplementationRepository_ServerInfo
 
 }
 
-void ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator_Smart_Proxy_Base::destroy  (
+void ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator_Smart_Proxy_Base::destroy	 (
     CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
@@ -2317,16 +2330,16 @@ void ImplementationRepository::TAO_ImplementationRepository_ServerInformationIte
   defined (ACE_HAS_GNU_REPO)
 template class TAO_Singleton<ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#pragma instantiate TAO_Singleton<ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#pragma	instantiate TAO_Singleton<ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
 static const CORBA::Long _oc_ImplementationRepository_ServerInformationIterator[] =
 {
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  59, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f536572), ACE_NTOHL (0x76657249), ACE_NTOHL (0x6e666f72), ACE_NTOHL (0x6d617469), ACE_NTOHL (0x6f6e4974), ACE_NTOHL (0x65726174), ACE_NTOHL (0x6f723a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:ImplementationRepository/ServerInformationIterator:1.0
-  26, ACE_NTOHL (0x53657276), ACE_NTOHL (0x6572496e), ACE_NTOHL (0x666f726d), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e497465), ACE_NTOHL (0x7261746f), ACE_NTOHL (0x72000000),  // name = ServerInformationIterator
+  TAO_ENCAP_BYTE_ORDER,	// byte	order
+  59, ACE_NTOHL	(0x49444c3a), ACE_NTOHL	(0x496d706c), ACE_NTOHL	(0x656d656e), ACE_NTOHL	(0x74617469), ACE_NTOHL	(0x6f6e5265), ACE_NTOHL	(0x706f7369), ACE_NTOHL	(0x746f7279), ACE_NTOHL	(0x2f536572), ACE_NTOHL	(0x76657249), ACE_NTOHL	(0x6e666f72), ACE_NTOHL	(0x6d617469), ACE_NTOHL	(0x6f6e4974), ACE_NTOHL	(0x65726174), ACE_NTOHL	(0x6f723a31), ACE_NTOHL	(0x2e300000),  // repository ID	= IDL:ImplementationRepository/ServerInformationIterator:1.0
+  26, ACE_NTOHL	(0x53657276), ACE_NTOHL	(0x6572496e), ACE_NTOHL	(0x666f726d), ACE_NTOHL	(0x6174696f), ACE_NTOHL	(0x6e497465), ACE_NTOHL	(0x7261746f), ACE_NTOHL	(0x72000000),  // name = ServerInformationIterator
 };
-static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerInformationIterator (CORBA::tk_objref, sizeof (_oc_ImplementationRepository_ServerInformationIterator), (char *) &_oc_ImplementationRepository_ServerInformationIterator, 0, sizeof (ImplementationRepository::ServerInformationIterator));
+static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerInformationIterator (CORBA::tk_objref,	sizeof (_oc_ImplementationRepository_ServerInformationIterator), (char *) &_oc_ImplementationRepository_ServerInformationIterator, 0, sizeof (ImplementationRepository::ServerInformationIterator));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (ImplementationRepository)
 TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ServerInformationIterator, &_tc_TAO_tc_ImplementationRepository_ServerInformationIterator)
@@ -2334,51 +2347,51 @@ TAO_NAMESPACE_END
 ImplementationRepository::ServerObject_ptr (*_TAO_collocation_ImplementationRepository_ServerObject_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   ) = 0;
-void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerObject_ptr _tao_elem)
+void operator<<= (CORBA::Any &_tao_any,	ImplementationRepository::ServerObject_ptr _tao_elem)
 {
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
+  TAO_OutputCDR	stream;
+  if (stream <<	_tao_elem)
   {
     _tao_any._tao_replace (
-        ImplementationRepository::_tc_ServerObject,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        ImplementationRepository::ServerObject::_duplicate (_tao_elem),
-        ImplementationRepository::ServerObject::_tao_any_destructor
+	ImplementationRepository::_tc_ServerObject,
+	TAO_ENCAP_BYTE_ORDER,
+	stream.begin (),
+	1,
+	ImplementationRepository::ServerObject::_duplicate (_tao_elem),
+	ImplementationRepository::ServerObject::_tao_any_destructor
       );
   }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::ServerObject_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	ImplementationRepository::ServerObject_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = ImplementationRepository::ServerObject::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (ImplementationRepository::_tc_ServerObject, ACE_TRY_ENV)) // not equal
+    _tao_elem =	ImplementationRepository::ServerObject::_nil ();
+    CORBA::TypeCode_var	type = _tao_any.type ();
+    if (!type->equivalent (ImplementationRepository::_tc_ServerObject, ACE_TRY_ENV)) //	not equal
       {
-        return 0;
+	return 0;
       }
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
+    TAO_InputCDR stream	(
+	_tao_any._tao_get_cdr (),
+	_tao_any._tao_byte_order ()
       );
     if (stream >> _tao_elem)
     {
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          ImplementationRepository::_tc_ServerObject,
-          1,
-          _tao_elem,
-          ImplementationRepository::ServerObject::_tao_any_destructor
-        );
+	  ImplementationRepository::_tc_ServerObject,
+	  1,
+	  _tao_elem,
+	  ImplementationRepository::ServerObject::_tao_any_destructor
+	);
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = ImplementationRepository::ServerObject::_nil ();
+    _tao_elem =	ImplementationRepository::ServerObject::_nil ();
     return 0;
   }
   ACE_ENDTRY;
@@ -2393,22 +2406,22 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository
 #  pragma instantiate TAO_Object_Manager<ImplementationRepository::ServerObject,ImplementationRepository::ServerObject_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::EnvironmentVariable &_tao_elem) // copying
+void operator<<= (CORBA::Any &_tao_any,	const ImplementationRepository::EnvironmentVariable &_tao_elem)	// copying
 {
-  TAO_OutputCDR stream;
+  TAO_OutputCDR	stream;
   stream << _tao_elem;
-  _tao_any._tao_replace (
+  _tao_any._tao_replace	(
       ImplementationRepository::_tc_EnvironmentVariable,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin ()
     );
 }
 
-void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::EnvironmentVariable *_tao_elem) // non copying
+void operator<<= (CORBA::Any &_tao_any,	ImplementationRepository::EnvironmentVariable *_tao_elem) // non copying
 {
-  TAO_OutputCDR stream;
+  TAO_OutputCDR	stream;
   stream << *_tao_elem;
-  _tao_any._tao_replace (
+  _tao_any._tao_replace	(
       ImplementationRepository::_tc_EnvironmentVariable,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin (),
@@ -2418,28 +2431,28 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::EnvironmentVar
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::EnvironmentVariable *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	ImplementationRepository::EnvironmentVariable *&_tao_elem)
 {
   return _tao_any >>= ACE_const_cast(ImplementationRepository::EnvironmentVariable*&,_tao_elem);
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::EnvironmentVariable *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	const ImplementationRepository::EnvironmentVariable *&_tao_elem)
 {
   _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
-    CORBA::TypeCode_var type = _tao_any.type ();
+    CORBA::TypeCode_var	type = _tao_any.type ();
     if (!type->equivalent (ImplementationRepository::_tc_EnvironmentVariable, ACE_TRY_ENV)) // not equal
       {
-        return 0;
+	return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = ACE_static_cast(
-          const ImplementationRepository::EnvironmentVariable*,
-          _tao_any.value ()
-        );
+      _tao_elem	= ACE_static_cast(
+	  const	ImplementationRepository::EnvironmentVariable*,
+	  _tao_any.value ()
+	);
       return 1;
     }
     else
@@ -2447,23 +2460,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo
       ImplementationRepository::EnvironmentVariable *tmp;
       ACE_NEW_RETURN (tmp, ImplementationRepository::EnvironmentVariable, 0);
       TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
+	  _tao_any._tao_get_cdr	(),
+	  _tao_any._tao_byte_order ()
+	);
       if (stream >> *tmp)
       {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            ImplementationRepository::_tc_EnvironmentVariable,
-            1,
-            ACE_static_cast (void *, tmp),
-            ImplementationRepository::EnvironmentVariable::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
+	((CORBA::Any *)&_tao_any)->_tao_replace	(
+	    ImplementationRepository::_tc_EnvironmentVariable,
+	    1,
+	    ACE_static_cast (void *, tmp),
+	    ImplementationRepository::EnvironmentVariable::_tao_any_destructor
+	  );
+	_tao_elem = tmp;
+	return 1;
       }
       else
       {
-        delete tmp;
+	delete tmp;
       }
     }
   }
@@ -2479,22 +2492,22 @@ void operator<<= (
     const ImplementationRepository::EnvironmentList &_tao_elem
   ) // copying
 {
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
+  TAO_OutputCDR	stream;
+  if (stream <<	_tao_elem)
   {
     _tao_any._tao_replace (
-        ImplementationRepository::_tc_EnvironmentList,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
+	ImplementationRepository::_tc_EnvironmentList,
+	TAO_ENCAP_BYTE_ORDER,
+	stream.begin ()
       );
   }
 }
 
-void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::EnvironmentList *_tao_elem) // non copying
+void operator<<= (CORBA::Any &_tao_any,	ImplementationRepository::EnvironmentList *_tao_elem) // non copying
 {
-  TAO_OutputCDR stream;
+  TAO_OutputCDR	stream;
   stream << *_tao_elem;
-  _tao_any._tao_replace (
+  _tao_any._tao_replace	(
       ImplementationRepository::_tc_EnvironmentList,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin (),
@@ -2504,7 +2517,7 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::EnvironmentLis
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::EnvironmentList *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	ImplementationRepository::EnvironmentList *&_tao_elem)
 {
   return _tao_any >>= ACE_const_cast(
       const ImplementationRepository::EnvironmentList*&,
@@ -2512,47 +2525,47 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::EnvironmentList *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	const ImplementationRepository::EnvironmentList	*&_tao_elem)
 {
   _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (ImplementationRepository::_tc_EnvironmentList, ACE_TRY_ENV)) // not equal
+    CORBA::TypeCode_var	type = _tao_any.type ();
+    if (!type->equivalent (ImplementationRepository::_tc_EnvironmentList, ACE_TRY_ENV))	// not equal
       {
-        return 0;
+	return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = ACE_static_cast(
-          const ImplementationRepository::EnvironmentList*,
-          _tao_any.value ()
-        );
+      _tao_elem	= ACE_static_cast(
+	  const	ImplementationRepository::EnvironmentList*,
+	  _tao_any.value ()
+	);
       return 1;
     }
     else
     {
-      ImplementationRepository::EnvironmentList *tmp;
+      ImplementationRepository::EnvironmentList	*tmp;
       ACE_NEW_RETURN (tmp, ImplementationRepository::EnvironmentList, 0);
       TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
+	  _tao_any._tao_get_cdr	(),
+	  _tao_any._tao_byte_order ()
+	);
       if (stream >> *tmp)
       {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            ImplementationRepository::_tc_EnvironmentList,
-            1,
-            ACE_static_cast (void *, tmp),
-            ImplementationRepository::EnvironmentList::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
+	((CORBA::Any *)&_tao_any)->_tao_replace	(
+	    ImplementationRepository::_tc_EnvironmentList,
+	    1,
+	    ACE_static_cast (void *, tmp),
+	    ImplementationRepository::EnvironmentList::_tao_any_destructor
+	  );
+	_tao_elem = tmp;
+	return 1;
       }
       else
       {
-        delete tmp;
+	delete tmp;
       }
     }
   }
@@ -2563,30 +2576,30 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo
   return 0;
 }
 
-void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ActivationMode _tao_elem)
+void operator<<= (CORBA::Any &_tao_any,	ImplementationRepository::ActivationMode _tao_elem)
 {
-  TAO_OutputCDR stream;
+  TAO_OutputCDR	stream;
   stream << _tao_elem;
-  _tao_any._tao_replace (
+  _tao_any._tao_replace	(
       ImplementationRepository::_tc_ActivationMode,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin ()
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::ActivationMode &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	ImplementationRepository::ActivationMode &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA::TypeCode_var type = _tao_any.type ();
+    CORBA::TypeCode_var	type = _tao_any.type ();
     if (!type->equivalent (ImplementationRepository::_tc_ActivationMode, ACE_TRY_ENV)) // not equal
       {
-        return 0;
+	return 0;
       }
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
+    TAO_InputCDR stream	(
+	_tao_any._tao_get_cdr (),
+	_tao_any._tao_byte_order ()
       );
     if (stream >> _tao_elem)
     {
@@ -2601,22 +2614,22 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository
   return 0;
 }
 
-void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::StartupOptions &_tao_elem) // copying
+void operator<<= (CORBA::Any &_tao_any,	const ImplementationRepository::StartupOptions &_tao_elem) // copying
 {
-  TAO_OutputCDR stream;
+  TAO_OutputCDR	stream;
   stream << _tao_elem;
-  _tao_any._tao_replace (
+  _tao_any._tao_replace	(
       ImplementationRepository::_tc_StartupOptions,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin ()
     );
 }
 
-void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::StartupOptions *_tao_elem) // non copying
+void operator<<= (CORBA::Any &_tao_any,	ImplementationRepository::StartupOptions *_tao_elem) //	non copying
 {
-  TAO_OutputCDR stream;
+  TAO_OutputCDR	stream;
   stream << *_tao_elem;
-  _tao_any._tao_replace (
+  _tao_any._tao_replace	(
       ImplementationRepository::_tc_StartupOptions,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin (),
@@ -2626,28 +2639,28 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::StartupOptions
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::StartupOptions *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	ImplementationRepository::StartupOptions *&_tao_elem)
 {
   return _tao_any >>= ACE_const_cast(ImplementationRepository::StartupOptions*&,_tao_elem);
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::StartupOptions *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	const ImplementationRepository::StartupOptions *&_tao_elem)
 {
   _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
-    CORBA::TypeCode_var type = _tao_any.type ();
+    CORBA::TypeCode_var	type = _tao_any.type ();
     if (!type->equivalent (ImplementationRepository::_tc_StartupOptions, ACE_TRY_ENV)) // not equal
       {
-        return 0;
+	return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = ACE_static_cast(
-          const ImplementationRepository::StartupOptions*,
-          _tao_any.value ()
-        );
+      _tao_elem	= ACE_static_cast(
+	  const	ImplementationRepository::StartupOptions*,
+	  _tao_any.value ()
+	);
       return 1;
     }
     else
@@ -2655,23 +2668,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo
       ImplementationRepository::StartupOptions *tmp;
       ACE_NEW_RETURN (tmp, ImplementationRepository::StartupOptions, 0);
       TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
+	  _tao_any._tao_get_cdr	(),
+	  _tao_any._tao_byte_order ()
+	);
       if (stream >> *tmp)
       {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            ImplementationRepository::_tc_StartupOptions,
-            1,
-            ACE_static_cast (void *, tmp),
-            ImplementationRepository::StartupOptions::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
+	((CORBA::Any *)&_tao_any)->_tao_replace	(
+	    ImplementationRepository::_tc_StartupOptions,
+	    1,
+	    ACE_static_cast (void *, tmp),
+	    ImplementationRepository::StartupOptions::_tao_any_destructor
+	  );
+	_tao_elem = tmp;
+	return 1;
       }
       else
       {
-        delete tmp;
+	delete tmp;
       }
     }
   }
@@ -2682,22 +2695,22 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo
   return 0;
 }
 
-void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::ServerInformation &_tao_elem) // copying
+void operator<<= (CORBA::Any &_tao_any,	const ImplementationRepository::ServerInformation &_tao_elem) // copying
 {
-  TAO_OutputCDR stream;
+  TAO_OutputCDR	stream;
   stream << _tao_elem;
-  _tao_any._tao_replace (
+  _tao_any._tao_replace	(
       ImplementationRepository::_tc_ServerInformation,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin ()
     );
 }
 
-void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformation *_tao_elem) // non copying
+void operator<<= (CORBA::Any &_tao_any,	ImplementationRepository::ServerInformation *_tao_elem)	// non copying
 {
-  TAO_OutputCDR stream;
+  TAO_OutputCDR	stream;
   stream << *_tao_elem;
-  _tao_any._tao_replace (
+  _tao_any._tao_replace	(
       ImplementationRepository::_tc_ServerInformation,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin (),
@@ -2707,52 +2720,52 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformat
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::ServerInformation *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	ImplementationRepository::ServerInformation *&_tao_elem)
 {
   return _tao_any >>= ACE_const_cast(ImplementationRepository::ServerInformation*&,_tao_elem);
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::ServerInformation *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	const ImplementationRepository::ServerInformation *&_tao_elem)
 {
   _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
-    CORBA::TypeCode_var type = _tao_any.type ();
+    CORBA::TypeCode_var	type = _tao_any.type ();
     if (!type->equivalent (ImplementationRepository::_tc_ServerInformation, ACE_TRY_ENV)) // not equal
       {
-        return 0;
+	return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = ACE_static_cast(
-          const ImplementationRepository::ServerInformation*,
-          _tao_any.value ()
-        );
+      _tao_elem	= ACE_static_cast(
+	  const	ImplementationRepository::ServerInformation*,
+	  _tao_any.value ()
+	);
       return 1;
     }
     else
     {
       ImplementationRepository::ServerInformation *tmp;
-      ACE_NEW_RETURN (tmp, ImplementationRepository::ServerInformation, 0);
+      ACE_NEW_RETURN (tmp, ImplementationRepository::ServerInformation,	0);
       TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
+	  _tao_any._tao_get_cdr	(),
+	  _tao_any._tao_byte_order ()
+	);
       if (stream >> *tmp)
       {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            ImplementationRepository::_tc_ServerInformation,
-            1,
-            ACE_static_cast (void *, tmp),
-            ImplementationRepository::ServerInformation::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
+	((CORBA::Any *)&_tao_any)->_tao_replace	(
+	    ImplementationRepository::_tc_ServerInformation,
+	    1,
+	    ACE_static_cast (void *, tmp),
+	    ImplementationRepository::ServerInformation::_tao_any_destructor
+	  );
+	_tao_elem = tmp;
+	return 1;
       }
       else
       {
-        delete tmp;
+	delete tmp;
       }
     }
   }
@@ -2768,22 +2781,22 @@ void operator<<= (
     const ImplementationRepository::ServerInformationList &_tao_elem
   ) // copying
 {
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
+  TAO_OutputCDR	stream;
+  if (stream <<	_tao_elem)
   {
     _tao_any._tao_replace (
-        ImplementationRepository::_tc_ServerInformationList,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
+	ImplementationRepository::_tc_ServerInformationList,
+	TAO_ENCAP_BYTE_ORDER,
+	stream.begin ()
       );
   }
 }
 
-void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformationList *_tao_elem) // non copying
+void operator<<= (CORBA::Any &_tao_any,	ImplementationRepository::ServerInformationList	*_tao_elem) // non copying
 {
-  TAO_OutputCDR stream;
+  TAO_OutputCDR	stream;
   stream << *_tao_elem;
-  _tao_any._tao_replace (
+  _tao_any._tao_replace	(
       ImplementationRepository::_tc_ServerInformationList,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin (),
@@ -2793,7 +2806,7 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformat
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::ServerInformationList *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	ImplementationRepository::ServerInformationList	*&_tao_elem)
 {
   return _tao_any >>= ACE_const_cast(
       const ImplementationRepository::ServerInformationList*&,
@@ -2801,23 +2814,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::ServerInformationList *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	const ImplementationRepository::ServerInformationList *&_tao_elem)
 {
   _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (ImplementationRepository::_tc_ServerInformationList, ACE_TRY_ENV)) // not equal
+    CORBA::TypeCode_var	type = _tao_any.type ();
+    if (!type->equivalent (ImplementationRepository::_tc_ServerInformationList,	ACE_TRY_ENV)) // not equal
       {
-        return 0;
+	return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = ACE_static_cast(
-          const ImplementationRepository::ServerInformationList*,
-          _tao_any.value ()
-        );
+      _tao_elem	= ACE_static_cast(
+	  const	ImplementationRepository::ServerInformationList*,
+	  _tao_any.value ()
+	);
       return 1;
     }
     else
@@ -2825,23 +2838,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo
       ImplementationRepository::ServerInformationList *tmp;
       ACE_NEW_RETURN (tmp, ImplementationRepository::ServerInformationList, 0);
       TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
+	  _tao_any._tao_get_cdr	(),
+	  _tao_any._tao_byte_order ()
+	);
       if (stream >> *tmp)
       {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            ImplementationRepository::_tc_ServerInformationList,
-            1,
-            ACE_static_cast (void *, tmp),
-            ImplementationRepository::ServerInformationList::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
+	((CORBA::Any *)&_tao_any)->_tao_replace	(
+	    ImplementationRepository::_tc_ServerInformationList,
+	    1,
+	    ACE_static_cast (void *, tmp),
+	    ImplementationRepository::ServerInformationList::_tao_any_destructor
+	  );
+	_tao_elem = tmp;
+	return 1;
       }
       else
       {
-        delete tmp;
+	delete tmp;
       }
     }
   }
@@ -2855,51 +2868,51 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo
 ImplementationRepository::Administration_ptr (*_TAO_collocation_ImplementationRepository_Administration_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   ) = 0;
-void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration_ptr _tao_elem)
+void operator<<= (CORBA::Any &_tao_any,	ImplementationRepository::Administration_ptr _tao_elem)
 {
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
+  TAO_OutputCDR	stream;
+  if (stream <<	_tao_elem)
   {
     _tao_any._tao_replace (
-        ImplementationRepository::_tc_Administration,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        ImplementationRepository::Administration::_duplicate (_tao_elem),
-        ImplementationRepository::Administration::_tao_any_destructor
+	ImplementationRepository::_tc_Administration,
+	TAO_ENCAP_BYTE_ORDER,
+	stream.begin (),
+	1,
+	ImplementationRepository::Administration::_duplicate (_tao_elem),
+	ImplementationRepository::Administration::_tao_any_destructor
       );
   }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::Administration_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	ImplementationRepository::Administration_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = ImplementationRepository::Administration::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
+    _tao_elem =	ImplementationRepository::Administration::_nil ();
+    CORBA::TypeCode_var	type = _tao_any.type ();
     if (!type->equivalent (ImplementationRepository::_tc_Administration, ACE_TRY_ENV)) // not equal
       {
-        return 0;
+	return 0;
       }
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
+    TAO_InputCDR stream	(
+	_tao_any._tao_get_cdr (),
+	_tao_any._tao_byte_order ()
       );
     if (stream >> _tao_elem)
     {
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          ImplementationRepository::_tc_Administration,
-          1,
-          _tao_elem,
-          ImplementationRepository::Administration::_tao_any_destructor
-        );
+	  ImplementationRepository::_tc_Administration,
+	  1,
+	  _tao_elem,
+	  ImplementationRepository::Administration::_tao_any_destructor
+	);
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = ImplementationRepository::Administration::_nil ();
+    _tao_elem =	ImplementationRepository::Administration::_nil ();
     return 0;
   }
   ACE_ENDTRY;
@@ -2914,22 +2927,22 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository
 #  pragma instantiate TAO_Object_Manager<ImplementationRepository::Administration,ImplementationRepository::Administration_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::Administration::AlreadyRegistered &_tao_elem) // copying
+void operator<<= (CORBA::Any &_tao_any,	const ImplementationRepository::Administration::AlreadyRegistered &_tao_elem) // copying
 {
-  TAO_OutputCDR stream;
+  TAO_OutputCDR	stream;
   stream << _tao_elem;
-  _tao_any._tao_replace (
+  _tao_any._tao_replace	(
       ImplementationRepository::Administration::_tc_AlreadyRegistered,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin ()
     );
 }
 
-void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration::AlreadyRegistered *_tao_elem) // non copying
+void operator<<= (CORBA::Any &_tao_any,	ImplementationRepository::Administration::AlreadyRegistered *_tao_elem)	// non copying
 {
-  TAO_OutputCDR stream;
+  TAO_OutputCDR	stream;
   stream << *_tao_elem;
-  _tao_any._tao_replace (
+  _tao_any._tao_replace	(
       ImplementationRepository::Administration::_tc_AlreadyRegistered,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin (),
@@ -2939,7 +2952,7 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::Administration::AlreadyRegistered *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	ImplementationRepository::Administration::AlreadyRegistered *&_tao_elem)
 {
   return _tao_any >>= ACE_const_cast(
       const ImplementationRepository::Administration::AlreadyRegistered*&,
@@ -2947,44 +2960,44 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::Administration::AlreadyRegistered *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	const ImplementationRepository::Administration::AlreadyRegistered *&_tao_elem)
 {
   _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
-    CORBA::TypeCode_var type = _tao_any.type ();
+    CORBA::TypeCode_var	type = _tao_any.type ();
     if (!type->equivalent (ImplementationRepository::Administration::_tc_AlreadyRegistered, ACE_TRY_ENV)) // not equal
       {
-        return 0;
+	return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (ImplementationRepository::Administration::AlreadyRegistered *)_tao_any.value ();
+      _tao_elem	= (ImplementationRepository::Administration::AlreadyRegistered *)_tao_any.value	();
       return 1;
     }
     else
     {
       ImplementationRepository::Administration::AlreadyRegistered *tmp;
-      ACE_NEW_RETURN (tmp, ImplementationRepository::Administration::AlreadyRegistered, 0);
+      ACE_NEW_RETURN (tmp, ImplementationRepository::Administration::AlreadyRegistered,	0);
       TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
+	  _tao_any._tao_get_cdr	(),
+	  _tao_any._tao_byte_order ()
+	);
       if (stream >> *tmp)
       {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            ImplementationRepository::Administration::_tc_AlreadyRegistered,
-            1,
-            tmp,
-            ImplementationRepository::Administration::AlreadyRegistered::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
+	((CORBA::Any *)&_tao_any)->_tao_replace	(
+	    ImplementationRepository::Administration::_tc_AlreadyRegistered,
+	    1,
+	    tmp,
+	    ImplementationRepository::Administration::AlreadyRegistered::_tao_any_destructor
+	  );
+	_tao_elem = tmp;
+	return 1;
       }
       else
       {
-        delete tmp;
+	delete tmp;
       }
     }
   }
@@ -2995,22 +3008,22 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo
   return 0;
 }
 
-void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::Administration::CannotActivate &_tao_elem) // copying
+void operator<<= (CORBA::Any &_tao_any,	const ImplementationRepository::Administration::CannotActivate &_tao_elem) // copying
 {
-  TAO_OutputCDR stream;
+  TAO_OutputCDR	stream;
   stream << _tao_elem;
-  _tao_any._tao_replace (
+  _tao_any._tao_replace	(
       ImplementationRepository::Administration::_tc_CannotActivate,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin ()
     );
 }
 
-void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration::CannotActivate *_tao_elem) // non copying
+void operator<<= (CORBA::Any &_tao_any,	ImplementationRepository::Administration::CannotActivate *_tao_elem) //	non copying
 {
-  TAO_OutputCDR stream;
+  TAO_OutputCDR	stream;
   stream << *_tao_elem;
-  _tao_any._tao_replace (
+  _tao_any._tao_replace	(
       ImplementationRepository::Administration::_tc_CannotActivate,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin (),
@@ -3020,7 +3033,7 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::Administration::CannotActivate *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	ImplementationRepository::Administration::CannotActivate *&_tao_elem)
 {
   return _tao_any >>= ACE_const_cast(
       const ImplementationRepository::Administration::CannotActivate*&,
@@ -3028,20 +3041,20 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::Administration::CannotActivate *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	const ImplementationRepository::Administration::CannotActivate *&_tao_elem)
 {
   _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
-    CORBA::TypeCode_var type = _tao_any.type ();
+    CORBA::TypeCode_var	type = _tao_any.type ();
     if (!type->equivalent (ImplementationRepository::Administration::_tc_CannotActivate, ACE_TRY_ENV)) // not equal
       {
-        return 0;
+	return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (ImplementationRepository::Administration::CannotActivate *)_tao_any.value ();
+      _tao_elem	= (ImplementationRepository::Administration::CannotActivate *)_tao_any.value ();
       return 1;
     }
     else
@@ -3049,23 +3062,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo
       ImplementationRepository::Administration::CannotActivate *tmp;
       ACE_NEW_RETURN (tmp, ImplementationRepository::Administration::CannotActivate, 0);
       TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
+	  _tao_any._tao_get_cdr	(),
+	  _tao_any._tao_byte_order ()
+	);
       if (stream >> *tmp)
       {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            ImplementationRepository::Administration::_tc_CannotActivate,
-            1,
-            tmp,
-            ImplementationRepository::Administration::CannotActivate::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
+	((CORBA::Any *)&_tao_any)->_tao_replace	(
+	    ImplementationRepository::Administration::_tc_CannotActivate,
+	    1,
+	    tmp,
+	    ImplementationRepository::Administration::CannotActivate::_tao_any_destructor
+	  );
+	_tao_elem = tmp;
+	return 1;
       }
       else
       {
-        delete tmp;
+	delete tmp;
       }
     }
   }
@@ -3076,22 +3089,22 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo
   return 0;
 }
 
-void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::Administration::NotFound &_tao_elem) // copying
+void operator<<= (CORBA::Any &_tao_any,	const ImplementationRepository::Administration::NotFound &_tao_elem) //	copying
 {
-  TAO_OutputCDR stream;
+  TAO_OutputCDR	stream;
   stream << _tao_elem;
-  _tao_any._tao_replace (
+  _tao_any._tao_replace	(
       ImplementationRepository::Administration::_tc_NotFound,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin ()
     );
 }
 
-void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration::NotFound *_tao_elem) // non copying
+void operator<<= (CORBA::Any &_tao_any,	ImplementationRepository::Administration::NotFound *_tao_elem) // non copying
 {
-  TAO_OutputCDR stream;
+  TAO_OutputCDR	stream;
   stream << *_tao_elem;
-  _tao_any._tao_replace (
+  _tao_any._tao_replace	(
       ImplementationRepository::Administration::_tc_NotFound,
       TAO_ENCAP_BYTE_ORDER,
       stream.begin (),
@@ -3101,7 +3114,7 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::Administration::NotFound *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	ImplementationRepository::Administration::NotFound *&_tao_elem)
 {
   return _tao_any >>= ACE_const_cast(
       const ImplementationRepository::Administration::NotFound*&,
@@ -3109,20 +3122,20 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository
     );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::Administration::NotFound *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	const ImplementationRepository::Administration::NotFound *&_tao_elem)
 {
   _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (ImplementationRepository::Administration::_tc_NotFound, ACE_TRY_ENV)) // not equal
+    CORBA::TypeCode_var	type = _tao_any.type ();
+    if (!type->equivalent (ImplementationRepository::Administration::_tc_NotFound, ACE_TRY_ENV)) // not	equal
       {
-        return 0;
+	return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (ImplementationRepository::Administration::NotFound *)_tao_any.value ();
+      _tao_elem	= (ImplementationRepository::Administration::NotFound *)_tao_any.value ();
       return 1;
     }
     else
@@ -3130,23 +3143,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo
       ImplementationRepository::Administration::NotFound *tmp;
       ACE_NEW_RETURN (tmp, ImplementationRepository::Administration::NotFound, 0);
       TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
+	  _tao_any._tao_get_cdr	(),
+	  _tao_any._tao_byte_order ()
+	);
       if (stream >> *tmp)
       {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            ImplementationRepository::Administration::_tc_NotFound,
-            1,
-            tmp,
-            ImplementationRepository::Administration::NotFound::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
+	((CORBA::Any *)&_tao_any)->_tao_replace	(
+	    ImplementationRepository::Administration::_tc_NotFound,
+	    1,
+	    tmp,
+	    ImplementationRepository::Administration::NotFound::_tao_any_destructor
+	  );
+	_tao_elem = tmp;
+	return 1;
       }
       else
       {
-        delete tmp;
+	delete tmp;
       }
     }
   }
@@ -3157,58 +3170,58 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo
   return 0;
 }
 
-ImplementationRepository::ServerInformationIterator_ptr (*_TAO_collocation_ImplementationRepository_ServerInformationIterator_Stub_Factory_function_pointer) (
+ImplementationRepository::ServerInformationIterator_ptr	(*_TAO_collocation_ImplementationRepository_ServerInformationIterator_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   ) = 0;
-void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformationIterator_ptr _tao_elem)
+void operator<<= (CORBA::Any &_tao_any,	ImplementationRepository::ServerInformationIterator_ptr	_tao_elem)
 {
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
+  TAO_OutputCDR	stream;
+  if (stream <<	_tao_elem)
   {
     _tao_any._tao_replace (
-        ImplementationRepository::_tc_ServerInformationIterator,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        ImplementationRepository::ServerInformationIterator::_duplicate (_tao_elem),
-        ImplementationRepository::ServerInformationIterator::_tao_any_destructor
+	ImplementationRepository::_tc_ServerInformationIterator,
+	TAO_ENCAP_BYTE_ORDER,
+	stream.begin (),
+	1,
+	ImplementationRepository::ServerInformationIterator::_duplicate	(_tao_elem),
+	ImplementationRepository::ServerInformationIterator::_tao_any_destructor
       );
   }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::ServerInformationIterator_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any,	ImplementationRepository::ServerInformationIterator_ptr	&_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = ImplementationRepository::ServerInformationIterator::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
+    _tao_elem =	ImplementationRepository::ServerInformationIterator::_nil ();
+    CORBA::TypeCode_var	type = _tao_any.type ();
     if (!type->equivalent (ImplementationRepository::_tc_ServerInformationIterator, ACE_TRY_ENV)) // not equal
       {
-        return 0;
+	return 0;
       }
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
+    TAO_InputCDR stream	(
+	_tao_any._tao_get_cdr (),
+	_tao_any._tao_byte_order ()
       );
     if (stream >> _tao_elem)
     {
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          ImplementationRepository::_tc_ServerInformationIterator,
-          1,
-          _tao_elem,
-          ImplementationRepository::ServerInformationIterator::_tao_any_destructor
-        );
+	  ImplementationRepository::_tc_ServerInformationIterator,
+	  1,
+	  _tao_elem,
+	  ImplementationRepository::ServerInformationIterator::_tao_any_destructor
+	);
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = ImplementationRepository::ServerInformationIterator::_nil ();
+    _tao_elem =	ImplementationRepository::ServerInformationIterator::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = ImplementationRepository::ServerInformationIterator::_nil ();
+  _tao_elem = ImplementationRepository::ServerInformationIterator::_nil	();
   return 0;
 }
 
@@ -3228,9 +3241,9 @@ CORBA::Boolean operator<< (
   {
     // encode all elements
     CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    for	(CORBA::ULong i	= 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
     {
-      _tao_marshal_flag = (strm << _tao_sequence[i]);
+      _tao_marshal_flag	= (strm	<< _tao_sequence[i]);
     }
     return _tao_marshal_flag;
   }
@@ -3247,14 +3260,14 @@ CORBA::Boolean operator>> (
   {
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
+    // If length is 0 we return	true.
     if (0 >= _tao_seq_len)
       return 1;
-    // retrieve all the elements
+    // retrieve	all the	elements
     CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    for	(CORBA::ULong i	= 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
     {
-      _tao_marshal_flag = (strm >> _tao_sequence[i]);
+      _tao_marshal_flag	= (strm	>> _tao_sequence[i]);
     }
     return _tao_marshal_flag;
   }
@@ -3270,9 +3283,9 @@ CORBA::Boolean operator<< (
   {
     // encode all elements
     CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    for	(CORBA::ULong i	= 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
     {
-      _tao_marshal_flag = (strm << _tao_sequence[i]);
+      _tao_marshal_flag	= (strm	<< _tao_sequence[i]);
     }
     return _tao_marshal_flag;
   }
@@ -3289,14 +3302,14 @@ CORBA::Boolean operator>> (
   {
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
+    // If length is 0 we return	true.
     if (0 >= _tao_seq_len)
       return 1;
-    // retrieve all the elements
+    // retrieve	all the	elements
     CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    for	(CORBA::ULong i	= 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
     {
-      _tao_marshal_flag = (strm >> _tao_sequence[i]);
+      _tao_marshal_flag	= (strm	>> _tao_sequence[i]);
     }
     return _tao_marshal_flag;
   }
diff --git a/TAO/tao/Remote_Object_Proxy_Impl.cpp b/TAO/tao/Remote_Object_Proxy_Impl.cpp
index a924ce7c12d..f10ae9a55d5 100644
--- a/TAO/tao/Remote_Object_Proxy_Impl.cpp
+++ b/TAO/tao/Remote_Object_Proxy_Impl.cpp
@@ -10,73 +10,74 @@ TAO_Remote_Object_Proxy_Impl::~TAO_Remote_Object_Proxy_Impl(void)
 
 CORBA::Boolean
 TAO_Remote_Object_Proxy_Impl::_is_a (const CORBA::Object_ptr target,
-                                     const CORBA::Char *logical_type_id,
-                                     CORBA_Environment &ACE_TRY_ENV)
+				     const CORBA::Char *logical_type_id,
+				     CORBA_Environment &ACE_TRY_ENV)
 {
   if (target->_stubobj ()->type_id.in () != 0
-      && ACE_OS::strcmp (logical_type_id,
-                         target->_stubobj ()->type_id.in ()) == 0)
+      && ACE_OS::strcmp	(logical_type_id,
+			 target->_stubobj ()->type_id.in ()) ==	0)
     return 1;
 
-  // Here we go remote to answer the question.
+  // Here we go	remote to answer the question.
   CORBA::Boolean _tao_retval = 0;
 
   TAO_Stub *istub = target->_stubobj ();
   if (istub == 0)
     ACE_THROW_RETURN (CORBA::INTERNAL (
-                        CORBA_SystemException::_tao_minor_code (
-                          TAO_DEFAULT_MINOR_CODE,
-                          EINVAL),
-                        CORBA::COMPLETED_NO),
-                      _tao_retval);
+			CORBA_SystemException::_tao_minor_code (
+			  TAO_DEFAULT_MINOR_CODE,
+			  EINVAL),
+			CORBA::COMPLETED_NO),
+		      _tao_retval);
 
   TAO_GIOP_Twoway_Invocation _tao_call (istub,
-                                        "_is_a",
-                                        5,
-                                        istub->orb_core ());
-
-  // Loop until we succeed or we raise an exception.
-  // @@ Nanbor: Do we still need to clear the environment variable?
-  //  ACE_TRY_ENV.clear ();
+					"_is_a",
+					5,
+					1,
+					istub->orb_core	());
+
+  // Loop until	we succeed or we raise an exception.
+  // @@	Nanbor:	Do we still need to clear the environment variable?
+  //  ACE_TRY_ENV.clear	();
   for (;;)
     {
       _tao_call.start (ACE_TRY_ENV);
       ACE_CHECK_RETURN (_tao_retval);
 
-      CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
+      CORBA::Short flag	= TAO_TWOWAY_RESPONSE_FLAG;
 
-      _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                                ACE_TRY_ENV);
+      _tao_call.prepare_header (ACE_static_cast	(CORBA::Octet, flag),
+				ACE_TRY_ENV);
       ACE_CHECK_RETURN (_tao_retval);
 
-      TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+      TAO_OutputCDR &_tao_out =	_tao_call.out_stream ();
       if (!(
-            (_tao_out << logical_type_id)
-            ))
-        ACE_THROW_RETURN (CORBA::MARSHAL (), _tao_retval);
+	    (_tao_out << logical_type_id)
+	    ))
+	ACE_THROW_RETURN (CORBA::MARSHAL (), _tao_retval);
 
       int _invoke_status =
-        _tao_call.invoke (0, 0, ACE_TRY_ENV);
+	_tao_call.invoke (0, 0,	ACE_TRY_ENV);
       ACE_CHECK_RETURN (_tao_retval);
 
       if (_invoke_status == TAO_INVOKE_RESTART)
-        continue;
+	continue;
       // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
+      // cannot	happen
       if (_invoke_status != TAO_INVOKE_OK)
-        {
-          ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE,
-                                            CORBA::COMPLETED_YES),
-                            _tao_retval);
+	{
+	  ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE,
+					    CORBA::COMPLETED_YES),
+			    _tao_retval);
 
-        }
+	}
       break;
     }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(_tao_in >> CORBA::Any::to_boolean (_tao_retval)))
+  TAO_InputCDR &_tao_in	= _tao_call.inp_stream ();
+  if (!(_tao_in	>> CORBA::Any::to_boolean (_tao_retval)))
     ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
-                                      CORBA::COMPLETED_YES),
-                      _tao_retval);
+				      CORBA::COMPLETED_YES),
+		      _tao_retval);
   return _tao_retval;
 
 }
@@ -84,61 +85,62 @@ TAO_Remote_Object_Proxy_Impl::_is_a (const CORBA::Object_ptr target,
 #if (TAO_HAS_MINIMUM_CORBA == 0)
 
 CORBA::Boolean TAO_Remote_Object_Proxy_Impl::_non_existent (const CORBA::Object_ptr target,
-                                                            CORBA_Environment &ACE_TRY_ENV)
+							    CORBA_Environment &ACE_TRY_ENV)
 {
   CORBA::Boolean _tao_retval = 0;
 
   ACE_TRY
     {
-      // Must catch exceptions, if the server raises a
-      // CORBA::OBJECT_NOT_EXIST then we must return 1, instead of
+      // Must catch exceptions,	if the server raises a
+      // CORBA::OBJECT_NOT_EXIST then we must return 1,	instead	of
       // propagating the exception.
-      TAO_Stub *istub = target->_stubobj ();
-      if (istub == 0)
-        ACE_THROW_RETURN (CORBA::INTERNAL (
-                            CORBA_SystemException::_tao_minor_code (
-                              TAO_DEFAULT_MINOR_CODE,
-                              EINVAL),
-                            CORBA::COMPLETED_NO),
-                          _tao_retval);
+      TAO_Stub *istub =	target->_stubobj ();
+      if (istub	== 0)
+	ACE_THROW_RETURN (CORBA::INTERNAL (
+			    CORBA_SystemException::_tao_minor_code (
+			      TAO_DEFAULT_MINOR_CODE,
+			      EINVAL),
+			    CORBA::COMPLETED_NO),
+			  _tao_retval);
 
       TAO_GIOP_Twoway_Invocation _tao_call (istub,
-                                            "_non_existent",
-                                            13,
-                                            istub->orb_core ());
+					    "_non_existent",
+					    13,
+					    1,
+					    istub->orb_core ());
 
       // ACE_TRY_ENV.clear ();
       for (;;)
-        {
-          _tao_call.start (ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-
-          CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
-
-          _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                                    ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-
-          int _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-
-          if (_invoke_status == TAO_INVOKE_RESTART)
-            continue;
-          ACE_ASSERT (_invoke_status != TAO_INVOKE_EXCEPTION);
-          if (_invoke_status != TAO_INVOKE_OK)
-            {
-              ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE,
-                                                CORBA::COMPLETED_YES),
-                                _tao_retval);
-            }
-          break;
-        }
+	{
+	  _tao_call.start (ACE_TRY_ENV);
+	  ACE_TRY_CHECK;
+
+	  CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
+
+	  _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
+				    ACE_TRY_ENV);
+	  ACE_TRY_CHECK;
+
+	  int _invoke_status =
+	    _tao_call.invoke (0, 0, ACE_TRY_ENV);
+	  ACE_TRY_CHECK;
+
+	  if (_invoke_status ==	TAO_INVOKE_RESTART)
+	    continue;
+	  ACE_ASSERT (_invoke_status !=	TAO_INVOKE_EXCEPTION);
+	  if (_invoke_status !=	TAO_INVOKE_OK)
+	    {
+	      ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE,
+						CORBA::COMPLETED_YES),
+				_tao_retval);
+	    }
+	  break;
+	}
       TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
       if (!(
-            (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
-            ))
-        ACE_THROW_RETURN (CORBA::MARSHAL (), _tao_retval);
+	    (_tao_in >>	CORBA::Any::to_boolean (_tao_retval))
+	    ))
+	ACE_THROW_RETURN (CORBA::MARSHAL (), _tao_retval);
     }
   ACE_CATCH (CORBA::OBJECT_NOT_EXIST, ex)
     {
@@ -152,4 +154,4 @@ CORBA::Boolean TAO_Remote_Object_Proxy_Impl::_non_existent (const CORBA::Object_
   return _tao_retval;
 }
 
-#endif /* TAO_HAS_MINIMUM_CORBA == 0 */
+#endif /* TAO_HAS_MINIMUM_CORBA	== 0 */
diff --git a/TAO/tao/Strategies/SHMIOP_Connector.cpp b/TAO/tao/Strategies/SHMIOP_Connector.cpp
index 045686cb32a..e51d6dca207 100644
--- a/TAO/tao/Strategies/SHMIOP_Connector.cpp
+++ b/TAO/tao/Strategies/SHMIOP_Connector.cpp
@@ -25,6 +25,11 @@ TAO_SHMIOP_Connect_Creation_Strategy::
 {
 }
 
+TAO_SHMIOP_Connect_Creation_Strategy::
+  ~TAO_SHMIOP_Connect_Creation_Strategy (void)
+{
+}
+
 int
 TAO_SHMIOP_Connect_Creation_Strategy::make_svc_handler
   (TAO_SHMIOP_Client_Connection_Handler *&sh)
@@ -47,6 +52,11 @@ TAO_SHMIOP_Connector::TAO_SHMIOP_Connector (CORBA::Octet flag)
 {
 }
 
+TAO_SHMIOP_Connector::~TAO_SHMIOP_Connector (void)
+{
+}
+
+
 int
 TAO_SHMIOP_Connector::open (TAO_ORB_Core *orb_core)
 {
diff --git a/TAO/tao/Strategies/SHMIOP_Connector.h b/TAO/tao/Strategies/SHMIOP_Connector.h
index 2ed17ee6338..124aa7bd95d 100644
--- a/TAO/tao/Strategies/SHMIOP_Connector.h
+++ b/TAO/tao/Strategies/SHMIOP_Connector.h
@@ -52,6 +52,9 @@ public:
                                         TAO_ORB_Core* orb_core = 0,
                                         CORBA::Boolean flag = 0);
 
+  ~TAO_SHMIOP_Connect_Creation_Strategy (void);
+  // Default destructor
+
   virtual int make_svc_handler (TAO_SHMIOP_Client_Connection_Handler *&sh);
   // Makes TAO_SHMIOP_Client_Connection_Handlers
 
@@ -80,6 +83,9 @@ public:
   TAO_SHMIOP_Connector (CORBA::Boolean flag = 0);
   // Constructor.
 
+  ~TAO_SHMIOP_Connector (void);
+  // Default destructor
+
   // = The TAO_Connector methods, please check the documentation on
   // Pluggable.h
   int open (TAO_ORB_Core *orb_core);
diff --git a/TAO/tao/Strategies/UIOP_Connector.cpp b/TAO/tao/Strategies/UIOP_Connector.cpp
index 511c09f9a25..3e450e3d48f 100644
--- a/TAO/tao/Strategies/UIOP_Connector.cpp
+++ b/TAO/tao/Strategies/UIOP_Connector.cpp
@@ -27,6 +27,12 @@ TAO_UIOP_Connect_Creation_Strategy::
 {
 }
 
+TAO_UIOP_Connect_Creation_Strategy::
+  ~TAO_UIOP_Connect_Creation_Strategy (void)
+{
+}
+
+
 int
 TAO_UIOP_Connect_Creation_Strategy::make_svc_handler
   (TAO_UIOP_Client_Connection_Handler *&sh)
@@ -53,6 +59,10 @@ TAO_UIOP_Connector::TAO_UIOP_Connector (CORBA::Boolean flag)
 {
 }
 
+TAO_UIOP_Connector::~TAO_UIOP_Connector (void)
+{
+}
+
 int
 TAO_UIOP_Connector::open (TAO_ORB_Core *orb_core)
 {
diff --git a/TAO/tao/Strategies/UIOP_Connector.h b/TAO/tao/Strategies/UIOP_Connector.h
index 0cdc1a606d9..9676bd4d97d 100644
--- a/TAO/tao/Strategies/UIOP_Connector.h
+++ b/TAO/tao/Strategies/UIOP_Connector.h
@@ -58,6 +58,9 @@ public:
   // state/info to the service handler upon creation.  Currently used
   // by IIOP and UIOP to pass protocol configuration properties.
 
+  ~TAO_UIOP_Connect_Creation_Strategy (void);
+  // Destructor
+
   virtual int make_svc_handler (TAO_UIOP_Client_Connection_Handler *&sh);
   // Makes TAO_UIOP_Client_Connection_Handlers
 
@@ -88,6 +91,9 @@ public:
   // @@ Do we want to pass in the tag here or should it be statically
   // defined?
 
+  ~TAO_UIOP_Connector (void);
+  // Destructor
+
   // = The TAO_Connector methods, please check the documentation on
   // Pluggable.h
   int open (TAO_ORB_Core *orb_core);
diff --git a/TAO/tao/TAO_Server_Request.cpp b/TAO/tao/TAO_Server_Request.cpp
index a993d9046b1..997601111b6 100644
--- a/TAO/tao/TAO_Server_Request.cpp
+++ b/TAO/tao/TAO_Server_Request.cpp
@@ -58,7 +58,8 @@ TAO_ServerRequest::TAO_ServerRequest (TAO_Pluggable_Messaging *mesg_base,
     profile_ (orb_core),
     requesting_principal_ (0),
     is_dsi_ (0),
-    dsi_nvlist_align_ (0)
+    dsi_nvlist_align_ (0),
+    argument_flag_ (1)
 {
   ACE_FUNCTION_TIMEPROBE (TAO_SERVER_REQUEST_START);
   // No-op.
@@ -89,7 +90,8 @@ TAO_ServerRequest::TAO_ServerRequest (TAO_Pluggable_Messaging *mesg_base,
     profile_ (orb_core),
     requesting_principal_ (0),
     is_dsi_ (0),
-    dsi_nvlist_align_ (0)
+    dsi_nvlist_align_ (0),
+    argument_flag_ (1)
 {
   profile_.object_key (object_key);
   parse_error = 0;
@@ -128,6 +130,9 @@ TAO_ServerRequest::init_reply (CORBA::Environment &)
   // modifying...) marina
   reply_params.service_context_notowned (&this->service_info_);
 
+  // Are we going to marshall any data with the reply?
+  reply_params.argument_flag_ = this->argument_flag_;
+
   // Forward exception only.
   if (!CORBA::is_nil (this->forward_location_.in ()))
     {
@@ -182,6 +187,9 @@ TAO_ServerRequest::send_no_exception_reply (void)
 
   reply_params.reply_status_ = TAO_GIOP_NO_EXCEPTION;
 
+  // No data anyway.
+  reply_params.argument_flag_ = 0;
+
   // Construct a REPLY header.
   this->mesg_base_->write_reply_header (*this->outgoing_,
                                         reply_params);
diff --git a/TAO/tao/TAO_Server_Request.h b/TAO/tao/TAO_Server_Request.h
index 03da51d2b28..ca55cc1adb0 100644
--- a/TAO/tao/TAO_Server_Request.h
+++ b/TAO/tao/TAO_Server_Request.h
@@ -158,7 +158,12 @@ public:
   void dsi_nvlist_align (ptr_arith_t alignment);
   // Set the member.
 
+  void argument_flag (CORBA::Boolean flag);
+  CORBA::Boolean argument_flag (void);
+  // Get/Set operations for the argument_flag
+
 private:
+
   TAO_Pluggable_Messaging *mesg_base_;
 
   ACE_CString operation_;
@@ -214,6 +219,12 @@ private:
 
   ptr_arith_t dsi_nvlist_align_;
   // Used to pad CDR stream if we have used DSI.
+
+  CORBA::Boolean argument_flag_;
+  // An argument flag to indicate whether there is any data that is
+  // going to get marshalled along as a reply. The default will be 1
+  // which indicates that we have some data that needs to be sent back
+  // to the client.
 };
 
 #if defined (__ACE_INLINE__)
diff --git a/TAO/tao/TAO_Server_Request.i b/TAO/tao/TAO_Server_Request.i
index 8a3945ff85a..dd0418f1bfd 100644
--- a/TAO/tao/TAO_Server_Request.i
+++ b/TAO/tao/TAO_Server_Request.i
@@ -145,3 +145,15 @@ TAO_ServerRequest::dsi_nvlist_align (ptr_arith_t alignment)
 {
   this->dsi_nvlist_align_ = alignment;
 }
+
+ACE_INLINE CORBA::Boolean
+TAO_ServerRequest::argument_flag (void)
+{
+  return this->argument_flag_;
+}
+
+ACE_INLINE void
+TAO_ServerRequest::argument_flag (CORBA::Boolean flag)
+{
+  this->argument_flag_ = flag;
+}
diff --git a/TAO/tao/operation_details.h b/TAO/tao/operation_details.h
index 471261c94b8..b21e3facd54 100644
--- a/TAO/tao/operation_details.h
+++ b/TAO/tao/operation_details.h
@@ -1,4 +1,4 @@
-// This may look like C, but it's really -*- C++ -*-
+// This	may look like C, but it's really -*- C++ -*-
 //     $Id$
 // ============================================================================
 //
@@ -9,18 +9,18 @@
 //    operation_details.h
 //
 // = AUTHOR
-//    Bala Natarajan <bala@cs.wustl.edu> 
+//    Bala Natarajan <bala@cs.wustl.edu>
 // ============================================================================
 
-#ifndef TAO_OPERATION_DETAILS_H
-#define TAO_OPERATION_DETAILS_H
+#ifndef	TAO_OPERATION_DETAILS_H
+#define	TAO_OPERATION_DETAILS_H
 #include "ace/pre.h"
 
 #include "tao/corbafwd.h"
 #include "tao/IOPC.h"
 #include "tao/target_specification.h"
 
-// @@ Bala: Why is this not part of the RequestHeader?!
+// @@ Bala: Why	is this	not part of the	RequestHeader?!
 class TAO_Export TAO_Operation_Details
 {
   // = TITLE
@@ -28,71 +28,81 @@ class TAO_Export TAO_Operation_Details
   //
   // = DESCRIPTION
   //   This class stores some of the "operation" details that would be
-  //   required by the invocation classes. this class is in its
-  //   infancy now but I expect this one to grow as we come with
-  //   different varieties of use cases. 
+  //   required	by the invocation classes. this	class is in its
+  //   infancy now but I expect	this one to grow as we come with
+  //   different varieties of use cases.
 public:
-  TAO_Operation_Details (const char *name,
-                         CORBA::ULong len);
+  TAO_Operation_Details	(const char *name,
+			 CORBA::ULong len,
+			 CORBA::Boolean	argument_flag);
   //Ctor
-  
-  const char* opname (void) const;
+
+  const	char* opname (void) const;
   // Operation name
-  
+
   CORBA::ULong opname_len (void) const;
   // Length of the operation name
-  
+
+  CORBA::Boolean argument_flag (void) const;
+  // Return the	flag that indicates whether the	operation has any
+  // arguments
+
   void response_flags (CORBA::Octet flags);
   // Set the response flags
-  
+
   CORBA::Octet response_flags (void);
   CORBA::Octet response_flags (void) const;
   // Get the response flags
 
-  IOP::ServiceContextList &service_info (void);
-  const IOP::ServiceContextList &service_info (void) const;
+  IOP::ServiceContextList &service_info	(void);
+  const	IOP::ServiceContextList	&service_info (void) const;
   // Get the service context list
 
-  void request_id (CORBA::ULong id);
+  void request_id (CORBA::ULong	id);
 
   CORBA::ULong request_id (void);
   CORBA::ULong request_id (void) const;
   // Get for request id
-  
+
   TAO_Target_Specification::TAO_Target_Address addressing_mode (void);
-  TAO_Target_Specification::TAO_Target_Address 
+  TAO_Target_Specification::TAO_Target_Address
   addressing_mode (void)  const;
-  // Get method for the addressing mode
+  // Get method	for the	addressing mode
+
+  void
+  addressing_mode (CORBA::Short	addr);
+  // Set method	for the	addressing mode
 
-  void 
-  addressing_mode (CORBA::Short addr);
-  // Set method for the addressing mode
-  
 private:
-  const char *opname_;
+  const	char *opname_;
   // Name of the operation being invoked.
 
   CORBA::ULong opname_len_;
   // Precalculated length of opname_.
 
   CORBA::ULong request_id_;
-  // Request ID of this operation.
-  
+  // Request ID	of this	operation.
+
+  CORBA::Boolean argument_flag_;
+  // Flag that indicates whether the operation has any arguments. If
+  // there are any arguments the falg will have	a value	of 1, 0
+  // otherwise.
+
   CORBA::Octet response_flags_;
   // Response flags
-  
+
   IOP::ServiceContextList service_info_;
-  // The ServiceContextList sent to the server side.  Only valid
+  // The ServiceContextList sent to the	server side.  Only valid
   // when sending a request.
-  
+
   // The first element of header is service context list;
-  // transactional context would be acquired here using the
-  // transaction service APIs.  Other kinds of context are as yet
+  // transactional context would be acquired here using	the
+  // transaction service APIs.	Other kinds of context are as yet
   // undefined.
   //
 
   TAO_Target_Specification::TAO_Target_Address addressing_mode_;
-  // Addressing mode for this request. 
+  // Addressing	mode for this request.
 };
 
 #if defined (__ACE_INLINE__)
diff --git a/TAO/tao/operation_details.i b/TAO/tao/operation_details.i
index 736261b89f7..4934a77ceed 100644
--- a/TAO/tao/operation_details.i
+++ b/TAO/tao/operation_details.i
@@ -2,10 +2,12 @@
 //$Id$
 ACE_INLINE
 TAO_Operation_Details::TAO_Operation_Details (const char *name,
-                                              CORBA::ULong len)
+					      CORBA::ULong len,
+					      CORBA::Boolean argument_flag)
   :opname_ (name),
    opname_len_ (len),
    request_id_ (0),
+   argument_flag_ (argument_flag),
    response_flags_ (0),
    addressing_mode_ (TAO_Target_Specification::Key_Addr)
 {
@@ -24,6 +26,12 @@ TAO_Operation_Details::opname_len (void) const
   return this->opname_len_;
 }
 
+ACE_INLINE CORBA::Boolean
+TAO_Operation_Details::argument_flag (void) const
+{
+  return this->argument_flag_;
+}
+
 ACE_INLINE IOP::ServiceContextList &
 TAO_Operation_Details::service_info (void)
 {
@@ -37,7 +45,7 @@ TAO_Operation_Details::service_info (void) const
 }
 
 ACE_INLINE void
-TAO_Operation_Details::request_id (CORBA::ULong id)
+TAO_Operation_Details::request_id (CORBA::ULong	id)
 {
   this->request_id_ = id;
 }
@@ -57,7 +65,7 @@ TAO_Operation_Details::request_id (void) const
 ACE_INLINE void
 TAO_Operation_Details::response_flags (CORBA::Octet flags)
 {
-  this->response_flags_ = flags;
+  this->response_flags_	= flags;
 }
 
 ACE_INLINE CORBA::Octet
@@ -72,27 +80,26 @@ TAO_Operation_Details::response_flags (void) const
   return this->response_flags_;
 }
 
-ACE_INLINE TAO_Target_Specification::TAO_Target_Address 
+ACE_INLINE TAO_Target_Specification::TAO_Target_Address
 TAO_Operation_Details::addressing_mode (void)
 {
   return this->addressing_mode_;
 }
 
-ACE_INLINE TAO_Target_Specification::TAO_Target_Address 
+ACE_INLINE TAO_Target_Specification::TAO_Target_Address
 TAO_Operation_Details::addressing_mode (void) const
 {
   return this->addressing_mode_;
 }
 
-ACE_INLINE void 
+ACE_INLINE void
 TAO_Operation_Details::
-  addressing_mode (CORBA::Short mode) 
+  addressing_mode (CORBA::Short	mode)
 {
   if (mode == 0)
       this->addressing_mode_ = TAO_Target_Specification::Key_Addr;
-  else if (mode == 1)
+  else if (mode	== 1)
     this->addressing_mode_ = TAO_Target_Specification::Profile_Addr;
-  else if (mode == 2)
+  else if (mode	== 2)
       this->addressing_mode_ = TAO_Target_Specification::Reference_Addr;
 }
-