Wed Jan 24 12:25:12 UTC 2007 Johnny Willemsen <jwillemsen@remedy.nl>

21 files changed, 155 insertions, 267 deletions

diff --git a/TAO/tao/Messaging/AMH_Response_Handler.cpp b/TAO/tao/Messaging/AMH_Response_Handler.cpp
index 0a1f3912dc9..45d42f11694 100644
--- a/TAO/tao/Messaging/AMH_Response_Handler.cpp
+++ b/TAO/tao/Messaging/AMH_Response_Handler.cpp
@@ -54,21 +54,17 @@ TAO_AMH_Response_Handler::~TAO_AMH_Response_Handler (void)
 
   // If sending the exception to the client fails, then we just give
   // up, release the transport and return.
-  ACE_DECLARE_NEW_CORBA_ENV;
-  ACE_TRY
+  try
     {
       CORBA::NO_RESPONSE ex (CORBA::SystemException::_tao_minor_code
                              (TAO_AMH_REPLY_LOCATION_CODE,
                               EFAULT),
                              CORBA::COMPLETED_NO);
-      this->_tao_rh_send_exception (ex ACE_ENV_ARG_PARAMETER);
-      ACE_TRY_CHECK;
+      this->_tao_rh_send_exception (ex);
     }
-  ACE_CATCHALL
+  catch (...)
     {
     }
-  ACE_ENDTRY;
-  ACE_CHECK;
 }
 
 void
@@ -86,7 +82,7 @@ TAO_AMH_Response_Handler::init(TAO_ServerRequest &server_request,
 }
 
 void
-TAO_AMH_Response_Handler::_tao_rh_init_reply (ACE_ENV_SINGLE_ARG_DECL)
+TAO_AMH_Response_Handler::_tao_rh_init_reply (void)
 {
   {
     ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->mutex_);
@@ -99,7 +95,7 @@ TAO_AMH_Response_Handler::_tao_rh_init_reply (ACE_ENV_SINGLE_ARG_DECL)
         // request and is now trying to send back the reply.  Hence we
         // say that the operation has completed but let the server
         // anyway that it is not doing something right.
-        ACE_THROW (CORBA::BAD_INV_ORDER
+        throw ( ::CORBA::BAD_INV_ORDER
                           (CORBA::SystemException::_tao_minor_code
                                   (TAO_AMH_REPLY_LOCATION_CODE,
                                    EEXIST),
@@ -135,7 +131,7 @@ TAO_AMH_Response_Handler::_tao_rh_init_reply (ACE_ENV_SINGLE_ARG_DECL)
 }
 
 void
-TAO_AMH_Response_Handler::_tao_rh_send_reply (ACE_ENV_SINGLE_ARG_DECL)
+TAO_AMH_Response_Handler::_tao_rh_send_reply (void)
 {
 
   {
@@ -145,7 +141,7 @@ TAO_AMH_Response_Handler::_tao_rh_send_reply (ACE_ENV_SINGLE_ARG_DECL)
     // server-app saying it is not doing something right.
     if (this->reply_status_ != TAO_RS_INITIALIZED)
       {
-        ACE_THROW (CORBA::BAD_INV_ORDER (
+        throw ( ::CORBA::BAD_INV_ORDER (
                           CORBA::SystemException::_tao_minor_code (
                                                   TAO_AMH_REPLY_LOCATION_CODE,
                                                   ENOTSUP),
@@ -181,13 +177,13 @@ TAO_AMH_Response_Handler::_tao_rh_send_reply (ACE_ENV_SINGLE_ARG_DECL)
 
 void
 TAO_AMH_Response_Handler::_tao_rh_send_exception (CORBA::Exception &ex
-                                                  ACE_ENV_ARG_DECL)
+                                                  )
 {
   {
     ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->mutex_);
     if (this->reply_status_ != TAO_RS_UNINITIALIZED)
       {
-        ACE_THROW (CORBA::BAD_INV_ORDER (
+        throw ( ::CORBA::BAD_INV_ORDER (
           CORBA::SystemException::_tao_minor_code (
             TAO_AMH_REPLY_LOCATION_CODE,
             ENOTSUP),
@@ -212,7 +208,7 @@ TAO_AMH_Response_Handler::_tao_rh_send_exception (CORBA::Exception &ex
                                                   reply_params,
                                                   ex) == -1)
     {
-      ACE_THROW (CORBA::INTERNAL ());
+      throw ( ::CORBA::INTERNAL ());
     }
 
   // Send the Exception
diff --git a/TAO/tao/Messaging/AMH_Response_Handler.h b/TAO/tao/Messaging/AMH_Response_Handler.h
index 585ed1defea..9f25b914054 100644
--- a/TAO/tao/Messaging/AMH_Response_Handler.h
+++ b/TAO/tao/Messaging/AMH_Response_Handler.h
@@ -99,14 +99,14 @@ protected:
   /// Sets up the various parameters in anticipation of returning a reply
   /// to the client. return/OUT/INOUT arguments are marshalled into the
   /// Output stream after this method has been called.
-  void _tao_rh_init_reply (ACE_ENV_SINGLE_ARG_DECL);
+  void _tao_rh_init_reply (void);
 
   /// Sends the marshalled reply back to the client.
-  void _tao_rh_send_reply (ACE_ENV_SINGLE_ARG_DECL);
+  void _tao_rh_send_reply (void);
 
   /// Send back an exception to the client.
   void _tao_rh_send_exception (CORBA::Exception &ex
-                               ACE_ENV_ARG_DECL);
+                              );
 
 protected:
 
diff --git a/TAO/tao/Messaging/Asynch_Invocation.cpp b/TAO/tao/Messaging/Asynch_Invocation.cpp
index 7296456a0ad..6734704c028 100644
--- a/TAO/tao/Messaging/Asynch_Invocation.cpp
+++ b/TAO/tao/Messaging/Asynch_Invocation.cpp
@@ -40,12 +40,11 @@ namespace TAO
 
   Invocation_Status
   Asynch_Remote_Invocation::remote_invocation (ACE_Time_Value *max_wait_time
-                                               ACE_ENV_ARG_DECL)
+                                               )
     ACE_THROW_SPEC ((CORBA::Exception))
   {
     TAO_Target_Specification tspec;
-    this->init_target_spec (tspec ACE_ENV_ARG_PARAMETER);
-    ACE_CHECK_RETURN (TAO_INVOKE_FAILURE);
+    this->init_target_spec (tspec);
 
     TAO_OutputCDR &cdr =
       this->resolver_.transport ()->messaging_object ()->out_stream ();
@@ -54,8 +53,7 @@ namespace TAO
 
 #if TAO_HAS_INTERCEPTORS == 1
     s =
-      this->send_request_interception (ACE_ENV_SINGLE_ARG_PARAMETER);
-    ACE_CHECK_RETURN (TAO_INVOKE_FAILURE);
+      this->send_request_interception ();
 
     if (s != TAO_INVOKE_SUCCESS)
       return s;
@@ -64,7 +62,7 @@ namespace TAO
     // We have started the interception flow. We need to call the
     // ending interception flow if things go wrong. The purpose of the
     // try block is to take care of the cases when things go wrong.
-    ACE_TRY
+    try
       {
         // Oneway semantics.  See comments for below send_message()
         // call.
@@ -75,12 +73,10 @@ namespace TAO
 
         this->write_header (tspec,
                             cdr
-                            ACE_ENV_ARG_PARAMETER);
-        ACE_TRY_CHECK;
+                           );
 
         this->marshal_data (cdr
-                            ACE_ENV_ARG_PARAMETER);
-        ACE_TRY_CHECK;
+                           );
 
         // Register a reply dispatcher for this invocation. Use the
         // preallocated reply dispatcher.
@@ -115,8 +111,7 @@ namespace TAO
           this->send_message (cdr,
                               TAO_Transport::TAO_ONEWAY_REQUEST,
                               max_wait_time
-                              ACE_ENV_ARG_PARAMETER);
-        ACE_TRY_CHECK;
+                             );
 
 #if TAO_HAS_INTERCEPTORS == 1
         // NOTE: We don't need to do the auto_ptr <> trick. We got here
@@ -132,8 +127,7 @@ namespace TAO
         // proper send, we are supposed to call receiver_other ()
         // interception point. So we do that here
         Invocation_Status tmp =
-          this->receive_other_interception (ACE_ENV_SINGLE_ARG_PARAMETER);
-        ACE_TRY_CHECK;
+          this->receive_other_interception ();
 
         // We got an error during the interception.
         if (s == TAO_INVOKE_SUCCESS && tmp != TAO_INVOKE_SUCCESS)
@@ -152,13 +146,11 @@ namespace TAO
           (void) this->resolver_.transport_released ();
 
       }
-    ACE_CATCHANY
+    catch ( ::CORBA::Exception& ex)
       {
 #if TAO_HAS_INTERCEPTORS == 1
         PortableInterceptor::ReplyStatus const status =
-          this->handle_any_exception (&ACE_ANY_EXCEPTION
-                                      ACE_ENV_ARG_PARAMETER);
-        ACE_TRY_CHECK;
+          this->handle_any_exception (&ACE_ANY_EXCEPTION);
 
         if (status == PortableInterceptor::LOCATION_FORWARD ||
             status == PortableInterceptor::TRANSPORT_RETRY)
@@ -166,28 +158,8 @@ namespace TAO
         else if (status == PortableInterceptor::SYSTEM_EXCEPTION
             || status == PortableInterceptor::USER_EXCEPTION)
 #endif /*TAO_HAS_INTERCEPTORS*/
-          ACE_RE_THROW;
+          throw;
       }
-# if defined (ACE_HAS_EXCEPTIONS) \
-     && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
-    ACE_CATCHALL
-      {
-#if TAO_HAS_INTERCEPTORS == 1
-        PortableInterceptor::ReplyStatus st =
-          this->handle_all_exception (ACE_ENV_SINGLE_ARG_PARAMETER);
-        ACE_TRY_CHECK;
-
-        if (st == PortableInterceptor::LOCATION_FORWARD ||
-            st == PortableInterceptor::TRANSPORT_RETRY)
-          s = TAO_INVOKE_RESTART;
-        else
-#endif /*TAO_HAS_INTERCEPTORS == 1*/
-          ACE_RE_THROW;
-      }
-# endif  /* ACE_HAS_EXCEPTIONS &&
-            ACE_HAS_BROKEN_UNEXPECTED_EXCEPTION*/
-    ACE_ENDTRY;
-    ACE_CHECK_RETURN (TAO_INVOKE_FAILURE);
 
     return s;
   }
diff --git a/TAO/tao/Messaging/Asynch_Invocation.h b/TAO/tao/Messaging/Asynch_Invocation.h
index 930d223bd3c..0aee5c7a088 100644
--- a/TAO/tao/Messaging/Asynch_Invocation.h
+++ b/TAO/tao/Messaging/Asynch_Invocation.h
@@ -56,7 +56,7 @@ namespace TAO
                               bool response_expected = true);
 
     Invocation_Status remote_invocation (ACE_Time_Value *value
-                                         ACE_ENV_ARG_DECL)
+                                         )
       ACE_THROW_SPEC ((CORBA::Exception));
 
   protected:
diff --git a/TAO/tao/Messaging/Asynch_Invocation_Adapter.cpp b/TAO/tao/Messaging/Asynch_Invocation_Adapter.cpp
index f0ef8094e34..e2794ff2189 100644
--- a/TAO/tao/Messaging/Asynch_Invocation_Adapter.cpp
+++ b/TAO/tao/Messaging/Asynch_Invocation_Adapter.cpp
@@ -48,11 +48,10 @@ namespace TAO
   Asynch_Invocation_Adapter::invoke (
     Messaging::ReplyHandler_ptr reply_handler_ptr,
     const TAO_Reply_Handler_Skeleton &reply_handler_skel
-    ACE_ENV_ARG_DECL)
+    )
   {
     TAO_Stub * stub =
-      this->get_stub (ACE_ENV_SINGLE_ARG_PARAMETER);
-    ACE_CHECK;
+      this->get_stub ();
 
     if (TAO_debug_level >= 4)
       {
@@ -99,24 +98,22 @@ namespace TAO
 
         if (rd == 0)
           {
-            ACE_THROW (CORBA::NO_MEMORY ());
+            throw ( ::CORBA::NO_MEMORY ());
           }
 
         this->safe_rd_.reset (rd);
       }
 
-    Invocation_Adapter::invoke (0, 0 ACE_ENV_ARG_PARAMETER);
-    ACE_CHECK;
+    Invocation_Adapter::invoke (0, 0);
   }
 
   void
   Asynch_Invocation_Adapter::invoke (
     TAO::Exception_Data *ex,
     unsigned long ex_count
-    ACE_ENV_ARG_DECL)
+    )
   {
-    Invocation_Adapter::invoke (ex, ex_count  ACE_ENV_ARG_PARAMETER);
-    ACE_CHECK;
+    Invocation_Adapter::invoke (ex, ex_count );
   }
 
   Invocation_Status
@@ -125,7 +122,7 @@ namespace TAO
     TAO_Operation_Details &details,
     CORBA::Object_var &effective_target,
     Collocation_Strategy strat
-    ACE_ENV_ARG_DECL)
+    )
   {
     // When doing a collocation asynch invocation we shouldn't use the
     // stub args but use the skel args
@@ -135,7 +132,7 @@ namespace TAO
                                                     details,
                                                     effective_target,
                                                     strat
-                                                    ACE_ENV_ARG_PARAMETER);
+                                                   );
   }
 
   Invocation_Status
@@ -144,7 +141,7 @@ namespace TAO
     CORBA::Object_var &effective_target,
     Profile_Transport_Resolver &r,
     ACE_Time_Value *&max_wait_time
-    ACE_ENV_ARG_DECL)
+    )
   {
     // Simple sanity check
     if (this->mode_ != TAO_ASYNCHRONOUS_CALLBACK_INVOCATION
@@ -172,8 +169,7 @@ namespace TAO
             this->safe_rd_->schedule_timer (
                 op.request_id (),
                 *max_wait_time
-                ACE_ENV_ARG_PARAMETER);
-            ACE_CHECK_RETURN (TAO_INVOKE_FAILURE);
+               );
           }
       }
 
@@ -186,8 +182,7 @@ namespace TAO
 
     Invocation_Status const s =
       asynch.remote_invocation (max_wait_time
-                                ACE_ENV_ARG_PARAMETER);
-    ACE_CHECK_RETURN (TAO_INVOKE_FAILURE);
+                               );
 
     if (s == TAO_INVOKE_RESTART &&
         asynch.is_forwarded ())
@@ -204,8 +199,7 @@ namespace TAO
         this->object_forwarded (effective_target,
                                 r.stub (),
                                 permanent_forward
-                                ACE_ENV_ARG_PARAMETER);
-        ACE_CHECK_RETURN (TAO_INVOKE_FAILURE);
+                               );
       }
 
     return s;
diff --git a/TAO/tao/Messaging/Asynch_Invocation_Adapter.h b/TAO/tao/Messaging/Asynch_Invocation_Adapter.h
index 0a36175d751..85c7501e9dd 100644
--- a/TAO/tao/Messaging/Asynch_Invocation_Adapter.h
+++ b/TAO/tao/Messaging/Asynch_Invocation_Adapter.h
@@ -43,7 +43,6 @@ class TAO_Asynch_Reply_Dispatcher_Base;
 namespace  CORBA
 {
   class Object;
-  class Environment;
   class SystemException;
 }
 
@@ -75,11 +74,11 @@ namespace TAO
 
     void invoke (Messaging::ReplyHandler_ptr reply_handler_ptr,
                  const TAO_Reply_Handler_Skeleton &reply_handler_skel
-                 ACE_ENV_ARG_DECL);
+                );
 
     virtual void invoke (TAO::Exception_Data *ex,
                          unsigned long ex_count
-                         ACE_ENV_ARG_DECL);
+                        );
   protected:
 
     virtual Invocation_Status invoke_twoway (
@@ -87,14 +86,14 @@ namespace TAO
         CORBA::Object_var &effective_target,
         Profile_Transport_Resolver &r,
         ACE_Time_Value *&max_wait_time
-        ACE_ENV_ARG_DECL);
+       );
 
     virtual Invocation_Status invoke_collocated_i (
         TAO_Stub *stub,
         TAO_Operation_Details &details,
         CORBA::Object_var &effective_target,
         Collocation_Strategy strat
-        ACE_ENV_ARG_DECL);
+       );
 
   private:
     /// Autofunctor to manage the reply dispatcher
diff --git a/TAO/tao/Messaging/Asynch_Reply_Dispatcher.cpp b/TAO/tao/Messaging/Asynch_Reply_Dispatcher.cpp
index a0a4d13cf08..e6273d30a3a 100644
--- a/TAO/tao/Messaging/Asynch_Reply_Dispatcher.cpp
+++ b/TAO/tao/Messaging/Asynch_Reply_Dispatcher.cpp
@@ -121,22 +121,20 @@ TAO_Asynch_Reply_Dispatcher::dispatch_reply (
 
   if (!CORBA::is_nil (this->reply_handler_.in ()))
     {
-      ACE_TRY_NEW_ENV
+      try
         {
           // Call the Reply Handler's skeleton.
           reply_handler_skel_ (this->reply_cdr_,
                                this->reply_handler_.in (),
                                reply_error
-                                ACE_ENV_ARG_PARAMETER);
-          ACE_TRY_CHECK;
+                               );
         }
-      ACE_CATCHANY
+      catch ( ::CORBA::Exception& ex)
         {
           if (TAO_debug_level >= 4)
             ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
                                  "Exception during reply handler");
         }
-      ACE_ENDTRY;
     }
 
   this->decr_refcount ();
@@ -147,7 +145,7 @@ TAO_Asynch_Reply_Dispatcher::dispatch_reply (
 void
 TAO_Asynch_Reply_Dispatcher::connection_closed (void)
 {
-  ACE_TRY_NEW_ENV
+  try
     {
       if (!this->try_dispatch_reply ())
         return;
@@ -166,9 +164,8 @@ TAO_Asynch_Reply_Dispatcher::connection_closed (void)
 
       TAO_OutputCDR out_cdr;
 
-      comm_failure._tao_encode (out_cdr ACE_ENV_ARG_PARAMETER);
+      comm_failure._tao_encode (out_cdr);
 
-      ACE_TRY_CHECK;
 
       // Turn into an output CDR
       TAO_InputCDR cdr (out_cdr);
@@ -178,11 +175,10 @@ TAO_Asynch_Reply_Dispatcher::connection_closed (void)
           this->reply_handler_skel_ (cdr,
                                      this->reply_handler_.in (),
                                      TAO_AMI_REPLY_SYSTEM_EXCEPTION
-                                      ACE_ENV_ARG_PARAMETER);
-          ACE_TRY_CHECK;
+                                     );
         }
     }
-  ACE_CATCHANY
+  catch ( ::CORBA::Exception& ex)
     {
       if (TAO_debug_level >= 4)
         {
@@ -191,7 +187,6 @@ TAO_Asynch_Reply_Dispatcher::connection_closed (void)
         }
 
     }
-  ACE_ENDTRY;
 
   (void) this->decr_refcount ();
 }
@@ -201,9 +196,8 @@ TAO_Asynch_Reply_Dispatcher::connection_closed (void)
 void
 TAO_Asynch_Reply_Dispatcher::reply_timed_out (void)
 {
-  ACE_DECLARE_NEW_CORBA_ENV;
 
-  ACE_TRY
+  try
     {
       // Generate a fake exception....
       CORBA::TIMEOUT timeout_failure (
@@ -214,8 +208,7 @@ TAO_Asynch_Reply_Dispatcher::reply_timed_out (void)
 
       TAO_OutputCDR out_cdr;
 
-      timeout_failure._tao_encode (out_cdr ACE_ENV_ARG_PARAMETER);
-      ACE_TRY_CHECK;
+      timeout_failure._tao_encode (out_cdr);
 
       // This is okay here... Everything relies on our refcount being
       // held by the timeout handler, whose refcount in turn is held
@@ -240,11 +233,10 @@ TAO_Asynch_Reply_Dispatcher::reply_timed_out (void)
           this->reply_handler_skel_ (cdr,
                                      this->reply_handler_.in (),
                                      TAO_AMI_REPLY_SYSTEM_EXCEPTION
-                                      ACE_ENV_ARG_PARAMETER);
-          ACE_TRY_CHECK;
+                                     );
         }
     }
-  ACE_CATCHANY
+  catch ( ::CORBA::Exception& ex)
     {
       if (TAO_debug_level >= 4)
         {
@@ -253,8 +245,6 @@ TAO_Asynch_Reply_Dispatcher::reply_timed_out (void)
         }
 
     }
-  ACE_ENDTRY;
-  ACE_CHECK;
 
   (void) this->decr_refcount ();
 }
@@ -262,7 +252,7 @@ TAO_Asynch_Reply_Dispatcher::reply_timed_out (void)
 long
 TAO_Asynch_Reply_Dispatcher::schedule_timer (CORBA::ULong request_id,
                                              const ACE_Time_Value &max_wait_time
-                                             ACE_ENV_ARG_DECL)
+                                             )
 {
   if (this->timeout_handler_ == 0)
     {
diff --git a/TAO/tao/Messaging/Asynch_Reply_Dispatcher.h b/TAO/tao/Messaging/Asynch_Reply_Dispatcher.h
index 5b315547813..4989fb659f4 100644
--- a/TAO/tao/Messaging/Asynch_Reply_Dispatcher.h
+++ b/TAO/tao/Messaging/Asynch_Reply_Dispatcher.h
@@ -60,7 +60,7 @@ public:
   /// Install the timeout handler
   long schedule_timer (CORBA::ULong request_id,
                        const ACE_Time_Value &max_wait_time
-                       ACE_ENV_ARG_DECL);
+                      );
 
 private:
   /// Skeleton for the call back method in the Reply Handler.
diff --git a/TAO/tao/Messaging/Connection_Timeout_Policy_i.cpp b/TAO/tao/Messaging/Connection_Timeout_Policy_i.cpp
index b621a85b375..1aa3051b9a2 100644
--- a/TAO/tao/Messaging/Connection_Timeout_Policy_i.cpp
+++ b/TAO/tao/Messaging/Connection_Timeout_Policy_i.cpp
@@ -38,7 +38,7 @@ TAO_ConnectionTimeoutPolicy::TAO_ConnectionTimeoutPolicy (
 
 TimeBase::TimeT
 TAO_ConnectionTimeoutPolicy::relative_expiry (
-    ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
+    void)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   return this->relative_expiry_;
@@ -46,7 +46,7 @@ TAO_ConnectionTimeoutPolicy::relative_expiry (
 
 CORBA::PolicyType
 TAO_ConnectionTimeoutPolicy::policy_type (
-    ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
+    void)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   return TAO::CONNECTION_TIMEOUT_POLICY_TYPE;
@@ -58,7 +58,7 @@ TAO_ConnectionTimeoutPolicy::hook (TAO_ORB_Core *orb_core,
                                    bool &has_timeout,
                                    ACE_Time_Value &time_value)
 {
-  ACE_TRY_NEW_ENV
+  try
     {
       CORBA::Policy_var policy = 0;
 
@@ -67,16 +67,14 @@ TAO_ConnectionTimeoutPolicy::hook (TAO_ORB_Core *orb_core,
           policy =
             orb_core->get_cached_policy_including_current (
               TAO_CACHED_POLICY_CONNECTION_TIMEOUT
-              ACE_ENV_ARG_PARAMETER);
-          ACE_TRY_CHECK;
+             );
         }
       else
         {
           policy =
             stub->get_cached_policy (
               TAO_CACHED_POLICY_CONNECTION_TIMEOUT
-              ACE_ENV_ARG_PARAMETER);
-          ACE_TRY_CHECK;
+             );
         }
 
       if (CORBA::is_nil (policy.in ()))
@@ -88,11 +86,9 @@ TAO_ConnectionTimeoutPolicy::hook (TAO_ORB_Core *orb_core,
       TAO::ConnectionTimeoutPolicy_var p =
         TAO::ConnectionTimeoutPolicy::_narrow (
           policy.in ()
-          ACE_ENV_ARG_PARAMETER);
-      ACE_TRY_CHECK;
+         );
 
-      TimeBase::TimeT t = p->relative_expiry (ACE_ENV_SINGLE_ARG_PARAMETER);
-      ACE_TRY_CHECK;
+      TimeBase::TimeT t = p->relative_expiry ();
       TimeBase::TimeT seconds = t / 10000000u;
       TimeBase::TimeT microseconds = (t % 10000000u) / 10;
       time_value.set (ACE_U64_TO_U32 (seconds),
@@ -108,16 +104,15 @@ TAO_ConnectionTimeoutPolicy::hook (TAO_ORB_Core *orb_core,
                       time_value.msec ()));
         }
     }
-  ACE_CATCHANY
+  catch ( ::CORBA::Exception&)
     {
       // Ignore all exceptions...
     }
-  ACE_ENDTRY;
 }
 
 CORBA::Policy_ptr
 TAO_ConnectionTimeoutPolicy::create (const CORBA::Any& val
-                                            ACE_ENV_ARG_DECL)
+                                            )
 {
   // Future policy implementors: notice how the following code is
   // exception safe!
@@ -132,7 +127,6 @@ TAO_ConnectionTimeoutPolicy::create (const CORBA::Any& val
                     TAO_ConnectionTimeoutPolicy (value),
                     CORBA::NO_MEMORY (TAO::VMCID,
                                       CORBA::COMPLETED_NO));
-  ACE_CHECK_RETURN (CORBA::Policy::_nil ());
 
   return tmp;
 }
@@ -148,7 +142,7 @@ TAO_ConnectionTimeoutPolicy::clone (void) const
 }
 
 CORBA::Policy_ptr
-TAO_ConnectionTimeoutPolicy::copy (ACE_ENV_SINGLE_ARG_DECL)
+TAO_ConnectionTimeoutPolicy::copy (void)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   // Future policy implementors: notice how the following code is
@@ -158,13 +152,12 @@ TAO_ConnectionTimeoutPolicy::copy (ACE_ENV_SINGLE_ARG_DECL)
                     TAO_ConnectionTimeoutPolicy (*this),
                     CORBA::NO_MEMORY (TAO::VMCID,
                                       CORBA::COMPLETED_NO));
-  ACE_CHECK_RETURN (CORBA::Policy::_nil ());
 
   return tmp;
 }
 
 void
-TAO_ConnectionTimeoutPolicy::destroy (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
+TAO_ConnectionTimeoutPolicy::destroy (void)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
 }
diff --git a/TAO/tao/Messaging/Connection_Timeout_Policy_i.h b/TAO/tao/Messaging/Connection_Timeout_Policy_i.h
index 9e334a307a7..67d4e401033 100644
--- a/TAO/tao/Messaging/Connection_Timeout_Policy_i.h
+++ b/TAO/tao/Messaging/Connection_Timeout_Policy_i.h
@@ -64,22 +64,22 @@ public:
   /// Helper method for the implementation of
   /// CORBA::ORB::create_policy.
   static CORBA::Policy_ptr create (const CORBA::Any& val
-                                   ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+                                   );
 
   /// Returns a copy of <this>.
   virtual TAO_ConnectionTimeoutPolicy *clone (void) const;
 
   // = The TAO::ConnectionTinoutPolicy methods
-  virtual TimeBase::TimeT relative_expiry (ACE_ENV_SINGLE_ARG_DECL)
+  virtual TimeBase::TimeT relative_expiry (void)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  virtual CORBA::PolicyType policy_type (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
+  virtual CORBA::PolicyType policy_type (void)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  virtual CORBA::Policy_ptr copy (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
+  virtual CORBA::Policy_ptr copy (void)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  virtual void destroy (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
+  virtual void destroy (void)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
   /// Change the CORBA representation to the ACE representation.
diff --git a/TAO/tao/Messaging/ExceptionHolder_i.cpp b/TAO/tao/Messaging/ExceptionHolder_i.cpp
index a03294907a5..b66bcba0eb5 100644
--- a/TAO/tao/Messaging/ExceptionHolder_i.cpp
+++ b/TAO/tao/Messaging/ExceptionHolder_i.cpp
@@ -44,7 +44,7 @@ namespace TAO
   }
 
   void ExceptionHolder::raise_exception (
-        ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+        void
     )
     {
       TAO_Messaging_Helper::exception_holder_raise (
@@ -54,15 +54,15 @@ namespace TAO
         this->marshaled_exception ().length (),
         this->byte_order (),
         this->is_system_exception ()
-        ACE_ENV_ARG_PARAMETER);
+       );
       }
 
   void ExceptionHolder::raise_exception_with_list (
-      const ::Dynamic::ExceptionList & ACE_ENV_ARG_DECL_WITH_DEFAULTS
+      const ::Dynamic::ExceptionList &
     )
     {
       // todo convert exceptionlist to something we can really use.
-      this->raise_exception (ACE_ENV_SINGLE_ARG_PARAMETER);
+      this->raise_exception ();
     }
 
   CORBA::ValueBase*
@@ -72,7 +72,6 @@ namespace TAO
     ACE_NEW_THROW_EX (ret_val,
                       ExceptionHolder,
                       CORBA::NO_MEMORY ());
-    ACE_CHECK_RETURN (0);
 
     // @todo According to the latest corba spec we should be able to
     // pass this to the ExceptionHolder constructor but the TAO_IDL
@@ -86,13 +85,12 @@ namespace TAO
 
   CORBA::ValueBase *
   ExceptionHolderFactory::create_for_unmarshal (
-    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
+    void)
   {
     TAO::ExceptionHolder* ret_val = 0;
     ACE_NEW_THROW_EX (ret_val,
                       ExceptionHolder,
                       CORBA::NO_MEMORY ());
-    ACE_CHECK_RETURN (0);
 
     return ret_val;
   }
diff --git a/TAO/tao/Messaging/ExceptionHolder_i.h b/TAO/tao/Messaging/ExceptionHolder_i.h
index f19f4308d58..ea07d781443 100644
--- a/TAO/tao/Messaging/ExceptionHolder_i.h
+++ b/TAO/tao/Messaging/ExceptionHolder_i.h
@@ -60,10 +60,10 @@ namespace TAO
     void set_exception_data (::TAO::Exception_Data* data,
                              ::CORBA::ULong exceptions_count);
 
-    virtual void raise_exception (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
+    virtual void raise_exception (void);
 
     virtual void raise_exception_with_list (
-        const ::Dynamic::ExceptionList & exc_list ACE_ENV_ARG_DECL_WITH_DEFAULTS
+        const ::Dynamic::ExceptionList & exc_list
       );
 
     virtual CORBA::ValueBase* _copy_value (void);
@@ -91,7 +91,7 @@ namespace TAO
   {
   public:
     virtual CORBA::ValueBase * create_for_unmarshal (
-      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
+      void);
   };
 
 }
diff --git a/TAO/tao/Messaging/Messaging.cpp b/TAO/tao/Messaging/Messaging.cpp
index 9f0c1f164cf..8380851f05b 100644
--- a/TAO/tao/Messaging/Messaging.cpp
+++ b/TAO/tao/Messaging/Messaging.cpp
@@ -33,7 +33,7 @@ exception_holder_raise (TAO::Exception_Data *exception_data,
                         CORBA::ULong marshaled_data_length,
                         CORBA::Boolean byte_order,
                         CORBA::Boolean is_system_exception
-                        ACE_ENV_ARG_DECL)
+                        )
 {
   TAO_InputCDR _tao_in ((const char*) marshaled_data,
                         marshaled_data_length,
@@ -45,7 +45,7 @@ exception_holder_raise (TAO::Exception_Data *exception_data,
     {
       // Could not demarshal the exception id, raise a local
       // CORBA::MARSHAL
-      ACE_THROW (CORBA::MARSHAL (TAO::VMCID,
+      throw ( ::CORBA::MARSHAL (TAO::VMCID,
                                  CORBA::COMPLETED_YES));
     }
 
@@ -55,7 +55,7 @@ exception_holder_raise (TAO::Exception_Data *exception_data,
       CORBA::ULong completion = 0;
       if ((_tao_in >> minor) == 0 ||
           (_tao_in >> completion) == 0)
-        ACE_THROW (CORBA::MARSHAL (TAO::VMCID,
+        throw ( ::CORBA::MARSHAL (TAO::VMCID,
                                    CORBA::COMPLETED_MAYBE));
 
       CORBA::SystemException* exception =
@@ -72,9 +72,7 @@ exception_holder_raise (TAO::Exception_Data *exception_data,
       exception->completed (CORBA::CompletionStatus (completion));
 
       // Raise the exception.
-#if defined (TAO_HAS_EXCEPTIONS)
       ACE_Auto_Basic_Ptr<CORBA::SystemException> e_ptr(exception);
-#endif
       ACE_ENV_RAISE (exception);
 
       return;
@@ -91,15 +89,12 @@ exception_holder_raise (TAO::Exception_Data *exception_data,
       CORBA::Exception * const exception = exception_data[i].alloc ();
 
       if (exception == 0)
-        ACE_THROW (CORBA::NO_MEMORY (TAO::VMCID,
+        throw ( ::CORBA::NO_MEMORY (TAO::VMCID,
                                      CORBA::COMPLETED_YES));
-      exception->_tao_decode (_tao_in ACE_ENV_ARG_PARAMETER);
-      ACE_CHECK;
+      exception->_tao_decode (_tao_in);
 
       // Raise the exception.
-#if defined (TAO_HAS_EXCEPTIONS)
       ACE_Auto_Basic_Ptr<CORBA::Exception> e_ptr (exception);
-#endif
       ACE_ENV_RAISE (exception);
 
       return;
@@ -111,7 +106,7 @@ exception_holder_raise (TAO::Exception_Data *exception_data,
   // @@ It would seem like if the remote exception is a
   //    UserException we can assume that the request was
   //    completed.
-  ACE_THROW (CORBA::UNKNOWN (TAO::VMCID,
+  throw ( ::CORBA::UNKNOWN (TAO::VMCID,
                              CORBA::COMPLETED_YES));
 }
 
diff --git a/TAO/tao/Messaging/Messaging.h b/TAO/tao/Messaging/Messaging.h
index 4c4647e5432..04f69d33aa5 100644
--- a/TAO/tao/Messaging/Messaging.h
+++ b/TAO/tao/Messaging/Messaging.h
@@ -64,7 +64,7 @@ typedef void (*TAO_Reply_Handler_Skeleton)(
     TAO_InputCDR &,
     Messaging::ReplyHandler_ptr,
     CORBA::ULong reply_status
-    ACE_ENV_ARG_DECL_NOT_USED
+
     );
 
 namespace TAO
@@ -89,7 +89,7 @@ namespace TAO_Messaging_Helper
            CORBA::ULong marshaled_data_length,
            CORBA::Boolean byte_order,
            CORBA::Boolean is_system_exception
-           ACE_ENV_ARG_DECL);
+          );
 }
 
 TAO_END_VERSIONED_NAMESPACE_DECL
diff --git a/TAO/tao/Messaging/Messaging_Loader.cpp b/TAO/tao/Messaging/Messaging_Loader.cpp
index de5d02cbc7c..3b2dc178316 100644
--- a/TAO/tao/Messaging/Messaging_Loader.cpp
+++ b/TAO/tao/Messaging/Messaging_Loader.cpp
@@ -37,8 +37,7 @@ TAO_Messaging_Loader::init (int,
     PortableInterceptor::ORBInitializer::_nil ();
   PortableInterceptor::ORBInitializer_var orb_initializer;
 
-  ACE_DECLARE_NEW_CORBA_ENV;
-  ACE_TRY
+  try
     {
       /// Register the Messaging ORBInitializer.
 
@@ -49,15 +48,13 @@ TAO_Messaging_Loader::init (int,
                             TAO::VMCID,
                             ENOMEM),
                           CORBA::COMPLETED_NO));
-      ACE_TRY_CHECK;
 
       orb_initializer = temp_orb_initializer;
 
       PortableInterceptor::register_orb_initializer (orb_initializer.in ()
-                                                     ACE_ENV_ARG_PARAMETER);
-      ACE_TRY_CHECK;
+                                                    );
     }
-  ACE_CATCHANY
+  catch ( ::CORBA::Exception& ex)
     {
       if (TAO_debug_level > 0)
         {
@@ -66,7 +63,6 @@ TAO_Messaging_Loader::init (int,
         }
       return -1;
     }
-  ACE_ENDTRY;
 
   return 0;
 }
diff --git a/TAO/tao/Messaging/Messaging_ORBInitializer.cpp b/TAO/tao/Messaging/Messaging_ORBInitializer.cpp
index 82a57e50c9e..6d036909a46 100644
--- a/TAO/tao/Messaging/Messaging_ORBInitializer.cpp
+++ b/TAO/tao/Messaging/Messaging_ORBInitializer.cpp
@@ -17,9 +17,7 @@ ACE_RCSID (Messaging,
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
 void
-TAO_Messaging_ORBInitializer::pre_init (
-    PortableInterceptor::ORBInitInfo_ptr
-    ACE_ENV_ARG_DECL_NOT_USED)
+TAO_Messaging_ORBInitializer::pre_init (PortableInterceptor::ORBInitInfo_ptr)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
 #if (TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1)
@@ -40,30 +38,22 @@ TAO_Messaging_ORBInitializer::pre_init (
 
 void
 TAO_Messaging_ORBInitializer::post_init (
-    PortableInterceptor::ORBInitInfo_ptr info
-    ACE_ENV_ARG_DECL)
-  ACE_THROW_SPEC ((CORBA::SystemException))
+  PortableInterceptor::ORBInitInfo_ptr info)
+    ACE_THROW_SPEC ((CORBA::SystemException))
 {
-  this->register_policy_factories (info
-                                   ACE_ENV_ARG_PARAMETER);
-  ACE_CHECK;
+  this->register_policy_factories (info);
 
-  this->register_value_factory (info
-                                ACE_ENV_ARG_PARAMETER);
-  ACE_CHECK;
+  this->register_value_factory (info);
 }
 
 void
 TAO_Messaging_ORBInitializer::register_value_factory (
-  PortableInterceptor::ORBInitInfo_ptr info
-  ACE_ENV_ARG_DECL)
+  PortableInterceptor::ORBInitInfo_ptr info)
 {
   // Narrow to a TAO_ORBInitInfo object to get access to the
   // orb_core() TAO extension.
   TAO_ORBInitInfo_var tao_info =
-    TAO_ORBInitInfo::_narrow (info
-                              ACE_ENV_ARG_PARAMETER);
-  ACE_CHECK;
+    TAO_ORBInitInfo::_narrow (info);
 
   if (CORBA::is_nil (tao_info.in ()))
     {
@@ -74,7 +64,7 @@ TAO_Messaging_ORBInitializer::register_value_factory (
                     "\"PortableInterceptor::ORBInitInfo_ptr\" to\n"
                     "(%P|%t)   \"TAO_ORBInitInfo *.\"\n"));
 
-      ACE_THROW (CORBA::INTERNAL ());
+      throw ( ::CORBA::INTERNAL ());
     }
 
   TAO::ExceptionHolderFactory *base_factory = 0;
@@ -84,14 +74,11 @@ TAO_Messaging_ORBInitializer::register_value_factory (
 
   tao_info->orb_core()->orb ()->register_value_factory (
         Messaging::ExceptionHolder::_tao_obv_static_repository_id (),
-        base_factory
-        ACE_ENV_ARG_PARAMETER);
-  ACE_TRY_CHECK;
+        base_factory);
 }
 void
 TAO_Messaging_ORBInitializer::register_policy_factories (
-  PortableInterceptor::ORBInitInfo_ptr info
-  ACE_ENV_ARG_DECL)
+  PortableInterceptor::ORBInitInfo_ptr info)
 {
   // Register the Messaging policy factories.
 
@@ -103,7 +90,6 @@ TAO_Messaging_ORBInitializer::register_policy_factories (
                           TAO::VMCID,
                           ENOMEM),
                         CORBA::COMPLETED_NO));
-  ACE_CHECK;
 
 
   PortableInterceptor::PolicyFactory_var policy_factory =
@@ -160,14 +146,11 @@ TAO_Messaging_ORBInitializer::register_policy_factories (
   const CORBA::PolicyType *end = type + sizeof (type) / sizeof (type[0]);
   for (CORBA::PolicyType *i = type; i != end; ++i)
     {
-      ACE_TRY
+      try
         {
-          info->register_policy_factory (*i,
-                                         policy_factory.in ()
-                                         ACE_ENV_ARG_PARAMETER);
-          ACE_TRY_CHECK;
+          info->register_policy_factory (*i, policy_factory.in ());
         }
-      ACE_CATCH (CORBA::BAD_INV_ORDER, ex)
+      catch ( ::CORBA::BAD_INV_ORDER& ex)
         {
           if (ex.minor () == (CORBA::OMGVMCID | 16))
             {
@@ -177,15 +160,13 @@ TAO_Messaging_ORBInitializer::register_policy_factories (
               // should do no more work in this ORBInitializer.
               return;
             }
-          ACE_RE_THROW;
+          throw;
         }
-      ACE_CATCHANY
+      catch ( ::CORBA::Exception&)
         {
           // Rethrow any other exceptions...
-          ACE_RE_THROW;
+          throw;
         }
-      ACE_ENDTRY;
-      ACE_CHECK;
     }
 }
 
diff --git a/TAO/tao/Messaging/Messaging_ORBInitializer.h b/TAO/tao/Messaging/Messaging_ORBInitializer.h
index e5d57c2a72d..443118bf601 100644
--- a/TAO/tao/Messaging/Messaging_ORBInitializer.h
+++ b/TAO/tao/Messaging/Messaging_ORBInitializer.h
@@ -49,12 +49,10 @@ public:
    */
   //@{
 
-  virtual void pre_init (PortableInterceptor::ORBInitInfo_ptr info
-                         ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+  virtual void pre_init (PortableInterceptor::ORBInitInfo_ptr info)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  virtual void post_init (PortableInterceptor::ORBInitInfo_ptr info
-                          ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+  virtual void post_init (PortableInterceptor::ORBInitInfo_ptr info)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
   //@}
@@ -62,14 +60,10 @@ public:
 private:
 
   /// Register Messaging policy factories.
-  void register_policy_factories (
-    PortableInterceptor::ORBInitInfo_ptr info
-    ACE_ENV_ARG_DECL);
+  void register_policy_factories (PortableInterceptor::ORBInitInfo_ptr info);
 
   /// Register ExceptionHolder value factory
-  void register_value_factory (
-    PortableInterceptor::ORBInitInfo_ptr info
-    ACE_ENV_ARG_DECL);
+  void register_value_factory (PortableInterceptor::ORBInitInfo_ptr info);
 };
 
 TAO_END_VERSIONED_NAMESPACE_DECL
diff --git a/TAO/tao/Messaging/Messaging_PolicyFactory.cpp b/TAO/tao/Messaging/Messaging_PolicyFactory.cpp
index 7fcda386a8b..278d07e5ec6 100644
--- a/TAO/tao/Messaging/Messaging_PolicyFactory.cpp
+++ b/TAO/tao/Messaging/Messaging_PolicyFactory.cpp
@@ -18,8 +18,7 @@ TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
 CORBA::Policy_ptr
 TAO_Messaging_PolicyFactory::create_buffering_constraint_policy (
-    const CORBA::Any& val
-    ACE_ENV_ARG_DECL)
+    const CORBA::Any& val)
 {
   TAO::BufferingConstraint *buffering_constraint = 0;
   if ((val >>= buffering_constraint) == 0)
@@ -30,7 +29,6 @@ TAO_Messaging_PolicyFactory::create_buffering_constraint_policy (
   ACE_NEW_THROW_EX (servant,
                     TAO_Buffering_Constraint_Policy (*buffering_constraint),
                     CORBA::NO_MEMORY ());
-  ACE_CHECK_RETURN (CORBA::Policy::_nil ());
 
   return servant;
 }
@@ -40,33 +38,32 @@ TAO_Messaging_PolicyFactory::create_buffering_constraint_policy (
 CORBA::Policy_ptr
 TAO_Messaging_PolicyFactory::create_policy (
     CORBA::PolicyType type,
-    const CORBA::Any &value
-    ACE_ENV_ARG_DECL)
+    const CORBA::Any &value)
   ACE_THROW_SPEC ((CORBA::SystemException,
                    CORBA::PolicyError))
 {
 #if (TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1)
   if (type == Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE)
     return TAO_RelativeRoundtripTimeoutPolicy::create (value
-                                                       ACE_ENV_ARG_PARAMETER);
+                                                      );
 #endif /* TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1 */
 
 #if (TAO_HAS_CONNECTION_TIMEOUT_POLICY == 1)
   if (type == TAO::CONNECTION_TIMEOUT_POLICY_TYPE)
     return TAO_ConnectionTimeoutPolicy::create (value
-                                                ACE_ENV_ARG_PARAMETER);
+                                               );
 #endif /* TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1 */
 
 #if (TAO_HAS_SYNC_SCOPE_POLICY == 1)
   if (type == Messaging::SYNC_SCOPE_POLICY_TYPE)
     return TAO_Sync_Scope_Policy::create (value
-                                          ACE_ENV_ARG_PARAMETER);
+                                         );
 #endif  /* TAO_HAS_SYNC_SCOPE_POLICY == 1 */
 
 #if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1)
   if (type == TAO::BUFFERING_CONSTRAINT_POLICY_TYPE)
     return this->create_buffering_constraint_policy (value
-                                                     ACE_ENV_ARG_PARAMETER);
+                                                    );
 #endif /* TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1 */
 
   if (
diff --git a/TAO/tao/Messaging/Messaging_PolicyFactory.h b/TAO/tao/Messaging/Messaging_PolicyFactory.h
index c2b36ed1a43..a2e5d63eae0 100644
--- a/TAO/tao/Messaging/Messaging_PolicyFactory.h
+++ b/TAO/tao/Messaging/Messaging_PolicyFactory.h
@@ -43,15 +43,13 @@ class TAO_Messaging_PolicyFactory
 public:
 
   virtual CORBA::Policy_ptr create_policy (CORBA::PolicyType type,
-                                           const CORBA::Any & value
-                                           ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+                                           const CORBA::Any & value)
     ACE_THROW_SPEC ((CORBA::SystemException,
                      CORBA::PolicyError));
 private:
 #if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1)
   CORBA::Policy_ptr
-  create_buffering_constraint_policy (const CORBA::Any& val
-                                      ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+  create_buffering_constraint_policy (const CORBA::Any& val);
 #endif /* TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1 */
 };
 
diff --git a/TAO/tao/Messaging/Messaging_Policy_i.cpp b/TAO/tao/Messaging/Messaging_Policy_i.cpp
index 39d4cc2b50a..7eba31507a7 100644
--- a/TAO/tao/Messaging/Messaging_Policy_i.cpp
+++ b/TAO/tao/Messaging/Messaging_Policy_i.cpp
@@ -42,7 +42,7 @@ TAO_RelativeRoundtripTimeoutPolicy::TAO_RelativeRoundtripTimeoutPolicy (
 
 TimeBase::TimeT
 TAO_RelativeRoundtripTimeoutPolicy::relative_expiry (
-    ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
+    void)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   return this->relative_expiry_;
@@ -50,7 +50,7 @@ TAO_RelativeRoundtripTimeoutPolicy::relative_expiry (
 
 CORBA::PolicyType
 TAO_RelativeRoundtripTimeoutPolicy::policy_type (
-    ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
+    void)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   return Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE;
@@ -62,7 +62,7 @@ TAO_RelativeRoundtripTimeoutPolicy::hook (TAO_ORB_Core *orb_core,
                                           bool &has_timeout,
                                           ACE_Time_Value &time_value)
 {
-  ACE_TRY_NEW_ENV
+  try
     {
       CORBA::Policy_var policy = 0;
 
@@ -71,15 +71,13 @@ TAO_RelativeRoundtripTimeoutPolicy::hook (TAO_ORB_Core *orb_core,
           policy =
             orb_core->get_cached_policy_including_current (
               TAO_CACHED_POLICY_RELATIVE_ROUNDTRIP_TIMEOUT
-              ACE_ENV_ARG_PARAMETER);
-          ACE_TRY_CHECK;
+             );
         }
       else
         {
           policy =
             stub->get_cached_policy (TAO_CACHED_POLICY_RELATIVE_ROUNDTRIP_TIMEOUT
-                                     ACE_ENV_ARG_PARAMETER);
-          ACE_TRY_CHECK;
+                                    );
         }
 
       if (CORBA::is_nil (policy.in ()))
@@ -91,15 +89,13 @@ TAO_RelativeRoundtripTimeoutPolicy::hook (TAO_ORB_Core *orb_core,
       Messaging::RelativeRoundtripTimeoutPolicy_var p =
         Messaging::RelativeRoundtripTimeoutPolicy::_narrow (
           policy.in ()
-          ACE_ENV_ARG_PARAMETER);
-      ACE_TRY_CHECK;
+         );
 
-      TimeBase::TimeT t = p->relative_expiry (ACE_ENV_SINGLE_ARG_PARAMETER);
-      ACE_TRY_CHECK;
+      TimeBase::TimeT t = p->relative_expiry ();
       TimeBase::TimeT seconds = t / 10000000u;
       TimeBase::TimeT microseconds = (t % 10000000u) / 10;
-      time_value.set (ACE_U64_TO_U32 (seconds),
-                      ACE_U64_TO_U32 (microseconds));
+      time_value.set (seconds,
+                      microseconds);
 
       // Set the flag once all operations complete successfully
       has_timeout = true;
@@ -111,16 +107,14 @@ TAO_RelativeRoundtripTimeoutPolicy::hook (TAO_ORB_Core *orb_core,
                       time_value.msec ()));
         }
     }
-  ACE_CATCHANY
+  catch ( ::CORBA::Exception&)
     {
       // Ignore all exceptions...
     }
-  ACE_ENDTRY;
 }
 
 CORBA::Policy_ptr
-TAO_RelativeRoundtripTimeoutPolicy::create (const CORBA::Any& val
-                                            ACE_ENV_ARG_DECL)
+TAO_RelativeRoundtripTimeoutPolicy::create (const CORBA::Any& val)
 {
   // Future policy implementors: notice how the following code is
   // exception safe!
@@ -135,7 +129,6 @@ TAO_RelativeRoundtripTimeoutPolicy::create (const CORBA::Any& val
                     TAO_RelativeRoundtripTimeoutPolicy (value),
                     CORBA::NO_MEMORY (TAO::VMCID,
                                       CORBA::COMPLETED_NO));
-  ACE_CHECK_RETURN (CORBA::Policy::_nil ());
 
   return tmp;
 }
@@ -151,23 +144,22 @@ TAO_RelativeRoundtripTimeoutPolicy::clone (void) const
 }
 
 CORBA::Policy_ptr
-TAO_RelativeRoundtripTimeoutPolicy::copy (ACE_ENV_SINGLE_ARG_DECL)
+TAO_RelativeRoundtripTimeoutPolicy::copy (void)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   // Future policy implementors: notice how the following code is
   // exception safe!
 
-  TAO_RelativeRoundtripTimeoutPolicy* tmp;
+  TAO_RelativeRoundtripTimeoutPolicy* tmp = 0;
   ACE_NEW_THROW_EX (tmp, TAO_RelativeRoundtripTimeoutPolicy (*this),
                     CORBA::NO_MEMORY (TAO::VMCID,
                                       CORBA::COMPLETED_NO));
-  ACE_CHECK_RETURN (CORBA::Policy::_nil ());
 
   return tmp;
 }
 
 void
-TAO_RelativeRoundtripTimeoutPolicy::destroy (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
+TAO_RelativeRoundtripTimeoutPolicy::destroy (void)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
 }
@@ -184,8 +176,8 @@ TAO_RelativeRoundtripTimeoutPolicy::set_time_value (ACE_Time_Value &time_value)
   TimeBase::TimeT t = this->relative_expiry_;
   TimeBase::TimeT seconds = t / 10000000u;
   TimeBase::TimeT microseconds = (t % 10000000u) / 10;
-  time_value.set (ACE_U64_TO_U32 (seconds),
-                  ACE_U64_TO_U32 (microseconds));
+  time_value.set (seconds,
+                  microseconds);
 
   if (TAO_debug_level > 0)
     {
@@ -222,7 +214,7 @@ TAO_Sync_Scope_Policy::TAO_Sync_Scope_Policy (const TAO_Sync_Scope_Policy &rhs)
 }
 
 CORBA::PolicyType
-TAO_Sync_Scope_Policy::policy_type (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
+TAO_Sync_Scope_Policy::policy_type (void)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   return Messaging::SYNC_SCOPE_POLICY_TYPE;
@@ -234,7 +226,7 @@ TAO_Sync_Scope_Policy::hook (TAO_ORB_Core *orb_core,
                              bool &has_synchronization,
                              Messaging::SyncScope &scope)
 {
-  ACE_TRY_NEW_ENV
+  try
     {
       CORBA::Policy_var policy = 0;
 
@@ -243,47 +235,42 @@ TAO_Sync_Scope_Policy::hook (TAO_ORB_Core *orb_core,
           policy =
             orb_core->get_cached_policy_including_current (
               TAO_CACHED_POLICY_SYNC_SCOPE
-              ACE_ENV_ARG_PARAMETER);
-          ACE_TRY_CHECK;
+             );
         }
       else
         {
           policy =
             stub->get_cached_policy (TAO_CACHED_POLICY_SYNC_SCOPE
-                                     ACE_ENV_ARG_PARAMETER);
-          ACE_TRY_CHECK;
+                                    );
         }
 
       if (CORBA::is_nil (policy.in ()))
         {
-          has_synchronization = 0;
+          has_synchronization = false;
           return;
         }
       Messaging::SyncScopePolicy_var p =
         Messaging::SyncScopePolicy::_narrow (policy.in ());
-      ACE_TRY_CHECK;
 
       if (CORBA::is_nil (p.in ()))
-        ACE_THROW (CORBA::INTERNAL (
+        throw ( ::CORBA::INTERNAL (
                 CORBA::SystemException::_tao_minor_code (
                   TAO_POLICY_NARROW_CODE,
                   0),
                 CORBA::COMPLETED_NO));
 
       has_synchronization = true;
-      scope = p->synchronization (ACE_ENV_SINGLE_ARG_PARAMETER);
-      ACE_TRY_CHECK;
+      scope = p->synchronization ();
     }
-  ACE_CATCHANY
+  catch ( ::CORBA::Exception&)
     {
       // Ignore all exceptions...
     }
-  ACE_ENDTRY;
 }
 
 CORBA::Policy_ptr
 TAO_Sync_Scope_Policy::create (const CORBA::Any& val
-                               ACE_ENV_ARG_DECL)
+                               )
 {
   Messaging::SyncScope synchronization;
   if ((val >>= synchronization) == 0)
@@ -294,7 +281,6 @@ TAO_Sync_Scope_Policy::create (const CORBA::Any& val
   ACE_NEW_THROW_EX (servant,
                     TAO_Sync_Scope_Policy (synchronization),
                     CORBA::NO_MEMORY ());
-  ACE_CHECK_RETURN (CORBA::Policy::_nil ());
 
   return servant;
 }
@@ -310,27 +296,26 @@ TAO_Sync_Scope_Policy::clone (void) const
 }
 
 Messaging::SyncScope
-TAO_Sync_Scope_Policy::synchronization (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
+TAO_Sync_Scope_Policy::synchronization (void)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   return this->synchronization_;
 }
 
 CORBA::Policy_ptr
-TAO_Sync_Scope_Policy::copy (ACE_ENV_SINGLE_ARG_DECL)
+TAO_Sync_Scope_Policy::copy (void)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   TAO_Sync_Scope_Policy *servant = 0;
   ACE_NEW_THROW_EX (servant,
                     TAO_Sync_Scope_Policy (*this),
                     CORBA::NO_MEMORY ());
-  ACE_CHECK_RETURN (CORBA::Policy::_nil ());
 
   return servant;
 }
 
 void
-TAO_Sync_Scope_Policy::destroy (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
+TAO_Sync_Scope_Policy::destroy (void)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
 }
diff --git a/TAO/tao/Messaging/Messaging_Policy_i.h b/TAO/tao/Messaging/Messaging_Policy_i.h
index 8e1d7ce59f2..dea4905a49a 100644
--- a/TAO/tao/Messaging/Messaging_Policy_i.h
+++ b/TAO/tao/Messaging/Messaging_Policy_i.h
@@ -57,22 +57,22 @@ public:
   /// Helper method for the implementation of
   /// CORBA::ORB::create_policy.
   static CORBA::Policy_ptr create (const CORBA::Any& val
-                                   ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+                                   );
 
   /// Returns a copy of <this>.
   virtual TAO_RelativeRoundtripTimeoutPolicy *clone (void) const;
 
   // = The Messaging::RelativeRoundtripTimeoutPolicy methods
-  virtual TimeBase::TimeT relative_expiry (ACE_ENV_SINGLE_ARG_DECL)
+  virtual TimeBase::TimeT relative_expiry (void)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  virtual CORBA::PolicyType policy_type (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
+  virtual CORBA::PolicyType policy_type (void)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  virtual CORBA::Policy_ptr copy (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
+  virtual CORBA::Policy_ptr copy (void)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  virtual void destroy (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
+  virtual void destroy (void)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
   /// Change the CORBA representation to the ACE representation.
@@ -122,25 +122,25 @@ public:
   /// Helper method for the implementation of
   /// CORBA::ORB::create_policy.
   static CORBA::Policy_ptr create (const CORBA::Any& val
-                                   ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+                                   );
 
   /// Returns a copy of <this>.
   virtual TAO_Sync_Scope_Policy *clone (void) const;
 
   // = The Messaging::SyncScopePolicy methods.
 
-  virtual Messaging::SyncScope synchronization (ACE_ENV_SINGLE_ARG_DECL)
+  virtual Messaging::SyncScope synchronization (void)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
   void get_synchronization (Messaging::SyncScope &synchronization) const;
 
-  virtual CORBA::PolicyType policy_type (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
+  virtual CORBA::PolicyType policy_type (void)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  virtual CORBA::Policy_ptr copy (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
+  virtual CORBA::Policy_ptr copy (void)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  virtual void destroy (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
+  virtual void destroy (void)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
   // Return the cached policy type for this policy.