Merged corba-env-clean branch.

1 files changed, 218 insertions, 209 deletions

diff --git a/TAO/tao/ORB.cpp b/TAO/tao/ORB.cpp
index 10b92fd26c5..a5dd633a5e9 100644
--- a/TAO/tao/ORB.cpp
+++ b/TAO/tao/ORB.cpp
@@ -135,16 +135,16 @@ void CORBA_ORB::InvalidName::_raise (void)
   TAO_RAISE(*this);
 }
 
-void CORBA_ORB::InvalidName::_tao_encode (TAO_OutputCDR &cdr,
-                                          CORBA::Environment &ACE_TRY_ENV) const
+void CORBA_ORB::InvalidName::_tao_encode (TAO_OutputCDR &cdr
+                                          TAO_ENV_ARG_DECL) const
 {
   if (cdr << *this)
     return;
   ACE_THROW (CORBA::MARSHAL ());
 }
 
-void CORBA_ORB::InvalidName::_tao_decode (TAO_InputCDR &cdr,
-                                          CORBA::Environment &ACE_TRY_ENV)
+void CORBA_ORB::InvalidName::_tao_decode (TAO_InputCDR &cdr
+                                          TAO_ENV_ARG_DECL)
 {
   if (cdr >> *this)
     return;
@@ -185,19 +185,19 @@ CORBA_ORB::~CORBA_ORB (void)
 }
 
 void
-CORBA_ORB::shutdown (CORBA::Boolean wait_for_completion,
-                     CORBA::Environment &ACE_TRY_ENV)
+CORBA_ORB::shutdown (CORBA::Boolean wait_for_completion
+                     TAO_ENV_ARG_DECL)
 {
-  this->check_shutdown (ACE_TRY_ENV);
+  this->check_shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK;
 
-  this->orb_core ()->shutdown (wait_for_completion,
-                               ACE_TRY_ENV);
+  this->orb_core ()->shutdown (wait_for_completion
+                                TAO_ENV_ARG_PARAMETER);
   ACE_CHECK;
 }
 
 void
-CORBA_ORB::destroy (CORBA::Environment &ACE_TRY_ENV)
+CORBA_ORB::destroy (TAO_ENV_SINGLE_ARG_DECL)
 {
   if (this->orb_core () == 0)
     {
@@ -219,7 +219,7 @@ CORBA_ORB::destroy (CORBA::Environment &ACE_TRY_ENV)
                   this->orb_core ()->orbid ()));
     }
 
-  this->orb_core ()->destroy (ACE_TRY_ENV);
+  this->orb_core ()->destroy (TAO_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK;
 
   // Now invalidate the pointer to the ORB_Core that created this
@@ -228,55 +228,55 @@ CORBA_ORB::destroy (CORBA::Environment &ACE_TRY_ENV)
 }
 
 void
-CORBA_ORB::run (CORBA::Environment &ACE_TRY_ENV)
+CORBA_ORB::run (TAO_ENV_SINGLE_ARG_DECL)
 {
-  this->run (0, ACE_TRY_ENV);
+  this->run (0 TAO_ENV_ARG_PARAMETER);
 }
 
 void
-CORBA_ORB::run (ACE_Time_Value &tv, CORBA::Environment &ACE_TRY_ENV)
+CORBA_ORB::run (ACE_Time_Value &tv TAO_ENV_ARG_DECL)
 {
-  this->run (&tv, ACE_TRY_ENV);
+  this->run (&tv TAO_ENV_ARG_PARAMETER);
 }
 
 void
-CORBA_ORB::run (ACE_Time_Value *tv,
-                CORBA::Environment &ACE_TRY_ENV)
+CORBA_ORB::run (ACE_Time_Value *tv
+                TAO_ENV_ARG_DECL)
 {
-  this->check_shutdown (ACE_TRY_ENV);
+  this->check_shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK;
 
-  this->orb_core ()->run (tv, 0, ACE_TRY_ENV);
+  this->orb_core ()->run (tv, 0 TAO_ENV_ARG_PARAMETER);
 }
 
 void
-CORBA_ORB::perform_work (CORBA::Environment &ACE_TRY_ENV)
+CORBA_ORB::perform_work (TAO_ENV_SINGLE_ARG_DECL)
 {
-  this->perform_work (0, ACE_TRY_ENV);
+  this->perform_work (0 TAO_ENV_ARG_PARAMETER);
 }
 
 void
-CORBA_ORB::perform_work (ACE_Time_Value &tv, CORBA::Environment &ACE_TRY_ENV)
+CORBA_ORB::perform_work (ACE_Time_Value &tv TAO_ENV_ARG_DECL)
 {
-  this->perform_work (&tv, ACE_TRY_ENV);
+  this->perform_work (&tv TAO_ENV_ARG_PARAMETER);
 }
 
 void
-CORBA_ORB::perform_work (ACE_Time_Value *tv,
-                         CORBA::Environment &ACE_TRY_ENV)
+CORBA_ORB::perform_work (ACE_Time_Value *tv
+                         TAO_ENV_ARG_DECL)
 {
   // This method should not be called if the ORB has been shutdown.
-  this->check_shutdown (ACE_TRY_ENV);
+  this->check_shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK;
 
-  this->orb_core ()->run (tv, 1, ACE_TRY_ENV);
+  this->orb_core ()->run (tv, 1 TAO_ENV_ARG_PARAMETER);
 }
 
 CORBA::Boolean
-CORBA_ORB::work_pending (ACE_Time_Value &tv, CORBA_Environment &ACE_TRY_ENV)
+CORBA_ORB::work_pending (ACE_Time_Value &tv TAO_ENV_ARG_DECL)
 {
   // This method should not be called if the ORB has been shutdown.
-  this->check_shutdown (ACE_TRY_ENV);
+  this->check_shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
   int result = this->orb_core_->reactor ()->work_pending (tv);
@@ -290,10 +290,10 @@ CORBA_ORB::work_pending (ACE_Time_Value &tv, CORBA_Environment &ACE_TRY_ENV)
 }
 
 CORBA::Boolean
-CORBA_ORB::work_pending (CORBA_Environment &ACE_TRY_ENV)
+CORBA_ORB::work_pending (TAO_ENV_SINGLE_ARG_DECL)
 {
   // This method should not be called if the ORB has been shutdown.
-  this->check_shutdown (ACE_TRY_ENV);
+  this->check_shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
   int result = this->orb_core_->reactor ()->work_pending ();
@@ -310,8 +310,8 @@ CORBA_ORB::work_pending (CORBA_Environment &ACE_TRY_ENV)
 
 void
 CORBA_ORB::create_list (CORBA::Long count,
-                        CORBA::NVList_ptr &new_list,
-                        CORBA_Environment &ACE_TRY_ENV)
+                        CORBA::NVList_ptr &new_list
+                        TAO_ENV_ARG_DECL)
 {
   ACE_ASSERT (CORBA::ULong (count) <= UINT_MAX);
 
@@ -348,21 +348,21 @@ CORBA_ORB::create_list (CORBA::Long count,
 }
 
 void
-CORBA_ORB::create_exception_list (CORBA::ExceptionList_ptr &list,
-                                  CORBA_Environment &ACE_TRY_ENV)
+CORBA_ORB::create_exception_list (CORBA::ExceptionList_ptr &list
+                                  TAO_ENV_ARG_DECL)
 {
   TAO_Dynamic_Adapter *dynamic_adapter =
     ACE_Dynamic_Service<TAO_Dynamic_Adapter>::instance (
         TAO_ORB_Core::dynamic_adapter_name ()
       );
 
-  dynamic_adapter->create_exception_list (list,
-                                          ACE_TRY_ENV);
+  dynamic_adapter->create_exception_list (list
+                                           TAO_ENV_ARG_PARAMETER);
 }
 
 void
-CORBA_ORB::create_environment (CORBA::Environment_ptr &environment,
-                               CORBA_Environment &ACE_TRY_ENV)
+CORBA_ORB::create_environment (CORBA::Environment_ptr &environment
+                               TAO_ENV_ARG_DECL)
 {
   ACE_NEW_THROW_EX (environment, CORBA::Environment (),
                     CORBA::NO_MEMORY (
@@ -373,8 +373,8 @@ CORBA_ORB::create_environment (CORBA::Environment_ptr &environment,
 }
 
 void
-CORBA_ORB::create_named_value (CORBA::NamedValue_ptr &nv,
-                               CORBA_Environment &ACE_TRY_ENV)
+CORBA_ORB::create_named_value (CORBA::NamedValue_ptr &nv
+                               TAO_ENV_ARG_DECL)
 {
   ACE_NEW_THROW_EX (nv,
                     CORBA::NamedValue,
@@ -390,8 +390,8 @@ CORBA_ORB::create_named_value (CORBA::NamedValue_ptr &nv,
 
 CORBA::Boolean
 CORBA_ORB::get_service_information (CORBA::ServiceType /* service_type */,
-                                    CORBA::ServiceInformation_out /* service_information */,
-                                    CORBA::Environment &ACE_TRY_ENV)
+                                    CORBA::ServiceInformation_out /* service_information */
+                                    TAO_ENV_ARG_DECL)
 {
   ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (
                       CORBA_SystemException::_tao_minor_code (
@@ -402,8 +402,8 @@ CORBA_ORB::get_service_information (CORBA::ServiceType /* service_type */,
 }
 
 void
-CORBA_ORB::create_context_list (CORBA::ContextList_ptr &,
-                                CORBA_Environment &ACE_TRY_ENV)
+CORBA_ORB::create_context_list (CORBA::ContextList_ptr &
+                                TAO_ENV_ARG_DECL)
 {
   ACE_THROW (CORBA::NO_IMPLEMENT (
                CORBA_SystemException::_tao_minor_code (
@@ -413,8 +413,8 @@ CORBA_ORB::create_context_list (CORBA::ContextList_ptr &,
 }
 
 void
-CORBA_ORB::get_default_context (CORBA::Context_ptr &,
-                                CORBA_Environment &ACE_TRY_ENV)
+CORBA_ORB::get_default_context (CORBA::Context_ptr &
+                                TAO_ENV_ARG_DECL)
 {
   ACE_THROW (CORBA::NO_IMPLEMENT (
                CORBA_SystemException::_tao_minor_code (
@@ -424,8 +424,8 @@ CORBA_ORB::get_default_context (CORBA::Context_ptr &,
 }
 
 void
-CORBA_ORB::send_multiple_requests_oneway (const CORBA_ORB_RequestSeq &,
-                                          CORBA_Environment &ACE_TRY_ENV)
+CORBA_ORB::send_multiple_requests_oneway (const CORBA_ORB_RequestSeq &
+                                          TAO_ENV_ARG_DECL)
 {
   ACE_THROW (CORBA::NO_IMPLEMENT (
                CORBA_SystemException::_tao_minor_code (
@@ -435,8 +435,8 @@ CORBA_ORB::send_multiple_requests_oneway (const CORBA_ORB_RequestSeq &,
 }
 
 void
-CORBA_ORB::send_multiple_requests_deferred (const CORBA_ORB_RequestSeq &,
-                                            CORBA_Environment &ACE_TRY_ENV)
+CORBA_ORB::send_multiple_requests_deferred (const CORBA_ORB_RequestSeq &
+                                            TAO_ENV_ARG_DECL)
 {
   ACE_THROW (CORBA::NO_IMPLEMENT (
                CORBA_SystemException::_tao_minor_code (
@@ -446,8 +446,8 @@ CORBA_ORB::send_multiple_requests_deferred (const CORBA_ORB_RequestSeq &,
 }
 
 void
-CORBA_ORB::get_next_response (CORBA_Request_ptr &,
-                              CORBA_Environment &ACE_TRY_ENV)
+CORBA_ORB::get_next_response (CORBA_Request_ptr &
+                              TAO_ENV_ARG_DECL)
 {
   ACE_THROW (CORBA::NO_IMPLEMENT (
                CORBA_SystemException::_tao_minor_code (
@@ -457,7 +457,7 @@ CORBA_ORB::get_next_response (CORBA_Request_ptr &,
 }
 
 CORBA::Boolean
-CORBA_ORB::poll_next_response (CORBA_Environment &ACE_TRY_ENV)
+CORBA_ORB::poll_next_response (TAO_ENV_SINGLE_ARG_DECL)
 {
   ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (
                       CORBA_SystemException::_tao_minor_code (
@@ -473,8 +473,8 @@ CORBA::TypeCode_ptr
 CORBA_ORB::create_struct_tc (
     const char *id,
     const char *name,
-    const CORBA_StructMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
+    const CORBA_StructMemberSeq & members
+    TAO_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
@@ -491,8 +491,8 @@ CORBA_ORB::create_struct_tc (
 
   return adapter->create_struct_tc (id,
                                     name,
-                                    members,
-                                    ACE_TRY_ENV);
+                                    members
+                                     TAO_ENV_ARG_PARAMETER);
 }
 
 CORBA::TypeCode_ptr
@@ -500,8 +500,8 @@ CORBA_ORB::create_union_tc (
     const char *id,
     const char *name,
     CORBA::TypeCode_ptr discriminator_type,
-    const CORBA_UnionMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
+    const CORBA_UnionMemberSeq & members
+    TAO_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
@@ -519,16 +519,16 @@ CORBA_ORB::create_union_tc (
   return adapter->create_union_tc (id,
                                    name,
                                    discriminator_type,
-                                   members,
-                                   ACE_TRY_ENV);
+                                   members
+                                    TAO_ENV_ARG_PARAMETER);
 }
 
 CORBA::TypeCode_ptr
 CORBA_ORB::create_enum_tc (
     const char *id,
     const char *name,
-    const CORBA_EnumMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
+    const CORBA_EnumMemberSeq & members
+    TAO_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
@@ -545,16 +545,16 @@ CORBA_ORB::create_enum_tc (
 
   return adapter->create_enum_tc (id,
                                   name,
-                                  members,
-                                  ACE_TRY_ENV);
+                                  members
+                                   TAO_ENV_ARG_PARAMETER);
 }
 
 CORBA::TypeCode_ptr
 CORBA_ORB::create_alias_tc (
     const char *id,
     const char *name,
-    CORBA::TypeCode_ptr original_type,
-    CORBA::Environment &ACE_TRY_ENV
+    CORBA::TypeCode_ptr original_type
+    TAO_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
@@ -571,16 +571,16 @@ CORBA_ORB::create_alias_tc (
 
   return adapter->create_alias_tc (id,
                                    name,
-                                   original_type,
-                                   ACE_TRY_ENV);
+                                   original_type
+                                    TAO_ENV_ARG_PARAMETER);
 }
 
 CORBA::TypeCode_ptr
 CORBA_ORB::create_exception_tc (
     const char *id,
     const char *name,
-    const CORBA_StructMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
+    const CORBA_StructMemberSeq & members
+    TAO_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
@@ -597,15 +597,15 @@ CORBA_ORB::create_exception_tc (
 
   return adapter->create_exception_tc (id,
                                        name,
-                                       members,
-                                       ACE_TRY_ENV);
+                                       members
+                                        TAO_ENV_ARG_PARAMETER);
 }
 
 CORBA::TypeCode_ptr
 CORBA_ORB::create_interface_tc (
     const char *id,
-    const char *name,
-    CORBA::Environment &ACE_TRY_ENV
+    const char *name
+    TAO_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
@@ -621,14 +621,14 @@ CORBA_ORB::create_interface_tc (
     }
 
   return adapter->create_interface_tc (id,
-                                       name,
-                                       ACE_TRY_ENV);
+                                       name
+                                        TAO_ENV_ARG_PARAMETER);
 }
 
 CORBA::TypeCode_ptr
 CORBA_ORB::create_string_tc (
-    CORBA::ULong bound,
-    CORBA::Environment &ACE_TRY_ENV
+    CORBA::ULong bound
+    TAO_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
@@ -643,14 +643,14 @@ CORBA_ORB::create_string_tc (
                         CORBA::TypeCode::_nil ());
     }
 
-  return adapter->create_string_tc (bound,
-                                    ACE_TRY_ENV);
+  return adapter->create_string_tc (bound
+                                     TAO_ENV_ARG_PARAMETER);
 }
 
 CORBA::TypeCode_ptr
 CORBA_ORB::create_wstring_tc (
-    CORBA::ULong bound,
-    CORBA::Environment &ACE_TRY_ENV
+    CORBA::ULong bound
+    TAO_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
@@ -665,15 +665,15 @@ CORBA_ORB::create_wstring_tc (
                         CORBA::TypeCode::_nil ());
     }
 
-  return adapter->create_wstring_tc (bound,
-                                     ACE_TRY_ENV);
+  return adapter->create_wstring_tc (bound
+                                      TAO_ENV_ARG_PARAMETER);
 }
 
 CORBA::TypeCode_ptr
 CORBA_ORB::create_fixed_tc (
     CORBA::UShort digits,
-    CORBA::UShort scale,
-    CORBA::Environment &ACE_TRY_ENV
+    CORBA::UShort scale
+    TAO_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
@@ -689,15 +689,15 @@ CORBA_ORB::create_fixed_tc (
     }
 
   return adapter->create_fixed_tc (digits,
-                                   scale,
-                                   ACE_TRY_ENV);
+                                   scale
+                                    TAO_ENV_ARG_PARAMETER);
 }
 
 CORBA::TypeCode_ptr
 CORBA_ORB::create_sequence_tc (
     CORBA::ULong bound,
-    CORBA::TypeCode_ptr element_type,
-    CORBA::Environment &ACE_TRY_ENV
+    CORBA::TypeCode_ptr element_type
+    TAO_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
@@ -713,15 +713,15 @@ CORBA_ORB::create_sequence_tc (
     }
 
   return adapter->create_sequence_tc (bound,
-                                      element_type,
-                                      ACE_TRY_ENV);
+                                      element_type
+                                       TAO_ENV_ARG_PARAMETER);
 }
 
 CORBA::TypeCode_ptr
 CORBA_ORB::create_array_tc (
     CORBA::ULong length,
-    CORBA::TypeCode_ptr element_type,
-    CORBA::Environment &ACE_TRY_ENV
+    CORBA::TypeCode_ptr element_type
+    TAO_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
@@ -737,8 +737,8 @@ CORBA_ORB::create_array_tc (
     }
 
   return adapter->create_array_tc (length,
-                                   element_type,
-                                   ACE_TRY_ENV);
+                                   element_type
+                                    TAO_ENV_ARG_PARAMETER);
 }
 
 CORBA::TypeCode_ptr
@@ -747,8 +747,8 @@ CORBA_ORB::create_value_tc (
     const char *name,
     CORBA::ValueModifier type_modifier,
     CORBA::TypeCode_ptr concrete_base,
-    const CORBA_ValueMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
+    const CORBA_ValueMemberSeq & members
+    TAO_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
@@ -767,16 +767,16 @@ CORBA_ORB::create_value_tc (
                                    name,
                                    type_modifier,
                                    concrete_base,
-                                   members,
-                                   ACE_TRY_ENV);
+                                   members
+                                    TAO_ENV_ARG_PARAMETER);
 }
 
 CORBA::TypeCode_ptr
 CORBA_ORB::create_value_box_tc (
     const char *id,
     const char *name,
-    CORBA::TypeCode_ptr boxed_type,
-    CORBA::Environment &ACE_TRY_ENV
+    CORBA::TypeCode_ptr boxed_type
+    TAO_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
@@ -793,15 +793,15 @@ CORBA_ORB::create_value_box_tc (
 
   return adapter->create_value_box_tc (id,
                                        name,
-                                       boxed_type,
-                                       ACE_TRY_ENV);
+                                       boxed_type
+                                        TAO_ENV_ARG_PARAMETER);
 }
 
 CORBA::TypeCode_ptr
 CORBA_ORB::create_native_tc (
     const char *id,
-    const char *name,
-    CORBA::Environment &ACE_TRY_ENV
+    const char *name
+    TAO_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
@@ -817,14 +817,14 @@ CORBA_ORB::create_native_tc (
     }
 
   return adapter->create_native_tc (id,
-                                    name,
-                                    ACE_TRY_ENV);
+                                    name
+                                     TAO_ENV_ARG_PARAMETER);
 }
 
 CORBA::TypeCode_ptr
 CORBA_ORB::create_recursive_tc (
-    const char *id,
-    CORBA::Environment &ACE_TRY_ENV
+    const char *id
+    TAO_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
@@ -839,15 +839,15 @@ CORBA_ORB::create_recursive_tc (
                         CORBA::TypeCode::_nil ());
     }
 
-  return adapter->create_recursive_tc (id,
-                                       ACE_TRY_ENV);
+  return adapter->create_recursive_tc (id
+                                        TAO_ENV_ARG_PARAMETER);
 }
 
 CORBA::TypeCode_ptr
 CORBA_ORB::create_abstract_interface_tc (
     const char *id,
-    const char *name,
-    CORBA::Environment &ACE_TRY_ENV
+    const char *name
+    TAO_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
@@ -863,15 +863,15 @@ CORBA_ORB::create_abstract_interface_tc (
     }
 
   return adapter->create_abstract_interface_tc (id,
-                                                name,
-                                                ACE_TRY_ENV);
+                                                name
+                                                 TAO_ENV_ARG_PARAMETER);
 }
 
 CORBA::TypeCode_ptr
 CORBA_ORB::create_local_interface_tc (
     const char *id,
-    const char *name,
-    CORBA::Environment &ACE_TRY_ENV
+    const char *name
+    TAO_ENV_ARG_DECL
   )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
@@ -887,8 +887,8 @@ CORBA_ORB::create_local_interface_tc (
     }
 
   return adapter->create_local_interface_tc (id,
-                                             name,
-                                             ACE_TRY_ENV);
+                                             name
+                                              TAO_ENV_ARG_PARAMETER);
 }
 
 // ****************************************************************
@@ -896,20 +896,20 @@ CORBA_ORB::create_local_interface_tc (
 #endif /* TAO_HAS_MINIMUM_CORBA */
 
 CORBA_Object_ptr
-CORBA_ORB::resolve_root_poa (CORBA::Environment &ACE_TRY_ENV
+CORBA_ORB::resolve_root_poa (TAO_ENV_SINGLE_ARG_DECL
                              )
 {
-  return this->orb_core_->root_poa (ACE_TRY_ENV);
+  return this->orb_core_->root_poa (TAO_ENV_SINGLE_ARG_PARAMETER);
 }
 
 CORBA_Object_ptr
-CORBA_ORB::resolve_poa_current (CORBA::Environment &)
+CORBA_ORB::resolve_poa_current (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
 {
   return this->orb_core_->poa_current ();
 }
 
 CORBA_Object_ptr
-CORBA_ORB::resolve_policy_manager (CORBA::Environment &)
+CORBA_ORB::resolve_policy_manager (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
 {
 
 #if (TAO_HAS_CORBA_MESSAGING == 1)
@@ -930,7 +930,7 @@ CORBA_ORB::resolve_policy_manager (CORBA::Environment &)
 }
 
 CORBA_Object_ptr
-CORBA_ORB::resolve_policy_current (CORBA::Environment &)
+CORBA_ORB::resolve_policy_current (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
 {
 
 #if (TAO_HAS_CORBA_MESSAGING == 1)
@@ -947,8 +947,8 @@ CORBA_ORB::resolve_policy_current (CORBA::Environment &)
 
 CORBA_Object_ptr
 CORBA_ORB::resolve_service (MCAST_SERVICEID mcast_service_id,
-                            ACE_Time_Value * /*timeout*/,
-                            CORBA::Environment& ACE_TRY_ENV)
+                            ACE_Time_Value * /*timeout*/
+                            TAO_ENV_ARG_DECL)
 {
   const char *env_service_ior [] =
   {
@@ -970,10 +970,9 @@ CORBA_ORB::resolve_service (MCAST_SERVICEID mcast_service_id,
  if (ACE_OS::strcmp (service_ior.c_str (), "") != 0)
    {
      return_value =
-       this->string_to_object (service_ior.c_str (),
-                               ACE_TRY_ENV);
+       this->string_to_object (service_ior.c_str () TAO_ENV_ARG_PARAMETER);
      ACE_CHECK_RETURN (CORBA_Object::_nil ());
-     
+
      // Return ior.
      return return_value._retn ();
    }
@@ -983,54 +982,56 @@ CORBA_ORB::resolve_service (MCAST_SERVICEID mcast_service_id,
 }
 
 CORBA_Object_ptr
-CORBA_ORB::resolve_initial_references (const char *name,
-                                       CORBA_Environment &ACE_TRY_ENV)
+CORBA_ORB::resolve_initial_references (const char *name
+                                       TAO_ENV_ARG_DECL)
 {
   return this->resolve_initial_references (name,
-                                           0,
-                                           ACE_TRY_ENV);
+                                           0
+                                            TAO_ENV_ARG_PARAMETER);
 }
 
 CORBA_Object_ptr
 CORBA_ORB::resolve_initial_references (const char *name,
-                                       ACE_Time_Value *timeout,
-                                       CORBA_Environment &ACE_TRY_ENV)
+                                       ACE_Time_Value *timeout
+                                       TAO_ENV_ARG_DECL)
 {
   // This method should not be called if the ORB has been shutdown.
-  this->check_shutdown (ACE_TRY_ENV);
+  this->check_shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (CORBA::Object::_nil ());
 
   if (ACE_OS::strcmp (name, TAO_OBJID_ROOTPOA) == 0)
-    return this->resolve_root_poa (ACE_TRY_ENV);
+    return this->resolve_root_poa (TAO_ENV_SINGLE_ARG_PARAMETER);
 
   else if (ACE_OS::strcmp (name, TAO_OBJID_POACURRENT) == 0)
-    return this->resolve_poa_current (ACE_TRY_ENV);
+    return this->resolve_poa_current (TAO_ENV_SINGLE_ARG_PARAMETER);
 
   else if (ACE_OS::strcmp (name, TAO_OBJID_POLICYMANAGER) == 0)
-    return this->resolve_policy_manager (ACE_TRY_ENV);
+    return this->resolve_policy_manager (TAO_ENV_SINGLE_ARG_PARAMETER);
 
   else if (ACE_OS::strcmp (name, TAO_OBJID_POLICYCURRENT) == 0)
-    return this->resolve_policy_current (ACE_TRY_ENV);
+    return this->resolve_policy_current (TAO_ENV_SINGLE_ARG_PARAMETER);
 
   else if (ACE_OS::strcmp (name, TAO_OBJID_IORMANIPULATION) == 0)
-    return this->orb_core ()->resolve_ior_manipulation (ACE_TRY_ENV);
+    return this->orb_core ()->resolve_ior_manipulation (TAO_ENV_SINGLE_ARG_PARAMETER);
 
   else if (ACE_OS::strcmp (name, TAO_OBJID_IORTABLE) == 0)
-    return this->orb_core ()->resolve_ior_table (ACE_TRY_ENV);
+    return this->orb_core ()->resolve_ior_table (TAO_ENV_SINGLE_ARG_PARAMETER);
 
   else if (ACE_OS::strcmp (name, TAO_OBJID_DYNANYFACTORY) == 0)
-    return this->orb_core ()->resolve_dynanyfactory (ACE_TRY_ENV);
+    return this->orb_core ()->resolve_dynanyfactory (TAO_ENV_SINGLE_ARG_PARAMETER);
 
   else if (ACE_OS::strcmp (name, TAO_OBJID_TYPECODEFACTORY) == 0)
-    return this->orb_core ()->resolve_typecodefactory (ACE_TRY_ENV);
+    return this->orb_core ()->resolve_typecodefactory (TAO_ENV_SINGLE_ARG_PARAMETER);
+
 
   // -----------------------------------------------------------------
 
   // Search the object reference table.  This search must occur before
   // the InitRef table search, since it may contain local objects.
   CORBA::Object_var result =
-    this->orb_core ()->object_ref_table ().resolve_initial_references (name,
-                                                                       ACE_TRY_ENV);
+    this->orb_core ()->object_ref_table ().resolve_initial_references (
+      name
+      TAO_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (CORBA::Object::_nil ());
 
   if (!CORBA::is_nil (result.in ()))
@@ -1046,33 +1047,37 @@ CORBA_ORB::resolve_initial_references (const char *name,
   // to find the basic services...
   if (ACE_OS::strcmp (name, TAO_OBJID_NAMESERVICE) == 0)
     {
-      result = this->resolve_service (NAMESERVICE, timeout, ACE_TRY_ENV);
+      result = this->resolve_service (NAMESERVICE, timeout
+                                      TAO_ENV_ARG_PARAMETER);
       ACE_CHECK_RETURN (CORBA::Object::_nil ());
-      
+
       if (!CORBA::is_nil (result.in ()))
         return result._retn ();
     }
   else if (ACE_OS::strcmp (name, TAO_OBJID_TRADINGSERVICE) == 0)
     {
-      result = this->resolve_service (TRADINGSERVICE, timeout, ACE_TRY_ENV);
+      result = this->resolve_service (TRADINGSERVICE, timeout
+                                      TAO_ENV_ARG_PARAMETER);
       ACE_CHECK_RETURN (CORBA::Object::_nil ());
-      
+
       if (!CORBA::is_nil (result.in ()))
         return result._retn ();
     }
   else if (ACE_OS::strcmp (name, TAO_OBJID_IMPLREPOSERVICE) == 0)
     {
-      result = this->resolve_service (IMPLREPOSERVICE, timeout, ACE_TRY_ENV);
+      result = this->resolve_service (IMPLREPOSERVICE, timeout
+                                      TAO_ENV_ARG_PARAMETER);
       ACE_CHECK_RETURN (CORBA::Object::_nil ());
-      
+
       if (!CORBA::is_nil (result.in ()))
         return result._retn ();
     }
   else if (ACE_OS::strcmp (name, TAO_OBJID_INTERFACEREP) == 0)
     {
-      result = this->resolve_service (INTERFACEREPOSERVICE, timeout, ACE_TRY_ENV);
+      result = this->resolve_service (INTERFACEREPOSERVICE, timeout
+                                      TAO_ENV_ARG_PARAMETER);
       ACE_CHECK_RETURN (CORBA::Object::_nil ());
-      
+
       if (!CORBA::is_nil (result.in ()))
         return result._retn ();
     }
@@ -1080,31 +1085,31 @@ CORBA_ORB::resolve_initial_references (const char *name,
   // Is not one of the well known services, try to find it in the
   // InitRef table....check the defaultinitref values also.
 
-  result = this->orb_core ()->resolve_rir (name, ACE_TRY_ENV);
+  result = this->orb_core ()->resolve_rir (name TAO_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (CORBA::Object::_nil ());
 
   if (!CORBA::is_nil (result.in ()))
     return result._retn ();
   // -----------------------------------------------------------------
-  
+
   ACE_THROW_RETURN (CORBA::ORB::InvalidName (), CORBA::Object::_nil ());
 }
 
 CORBA_ORB_ObjectIdList_ptr
-CORBA_ORB::list_initial_services (CORBA::Environment &ACE_TRY_ENV)
+CORBA_ORB::list_initial_services (TAO_ENV_SINGLE_ARG_DECL)
 {
-  this->check_shutdown (ACE_TRY_ENV);
+  this->check_shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
-  return this->orb_core ()->list_initial_references (ACE_TRY_ENV);
+  return this->orb_core ()->list_initial_references (TAO_ENV_SINGLE_ARG_PARAMETER);
 }
 
 void
-CORBA_ORB::check_shutdown (CORBA_Environment &ACE_TRY_ENV)
+CORBA_ORB::check_shutdown (TAO_ENV_SINGLE_ARG_DECL)
 {
   if (this->orb_core () != 0)
     {
-      this->orb_core ()->check_shutdown (ACE_TRY_ENV);
+      this->orb_core ()->check_shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
       ACE_CHECK;
     }
   else
@@ -1124,7 +1129,7 @@ CORBA_ORB::check_shutdown (CORBA_Environment &ACE_TRY_ENV)
 // ****************************************************************
 
 void
-CORBA_ORB::init_orb_globals (CORBA::Environment &ACE_TRY_ENV)
+CORBA_ORB::init_orb_globals (TAO_ENV_SINGLE_ARG_DECL)
 {
   // This method should be invoked atomically.  It is the caller's
   // responsibility to ensure that this condition is satisfied.
@@ -1143,7 +1148,7 @@ CORBA_ORB::init_orb_globals (CORBA::Environment &ACE_TRY_ENV)
   TAO_TypeCodes::init ();
 
   // initialize the system exceptions
-  TAO_Exceptions::init (ACE_TRY_ENV);
+  TAO_Exceptions::init (TAO_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK;
 
   // Verify some of the basic implementation requirements.  This test
@@ -1190,8 +1195,8 @@ CORBA_ORB::init_orb_globals (CORBA::Environment &ACE_TRY_ENV)
   PortableInterceptor::ORBInitializer_var cf_initializer =
     tmp_cf_initializer;
 
-  PortableInterceptor::register_orb_initializer (cf_initializer.in (),
-                                                 ACE_TRY_ENV);
+  PortableInterceptor::register_orb_initializer (cf_initializer.in ()
+                                                  TAO_ENV_ARG_PARAMETER);
   ACE_CHECK;
 
   // -------------------------------------------------------------
@@ -1215,8 +1220,8 @@ CORBA_ORB::init_orb_globals (CORBA::Environment &ACE_TRY_ENV)
   ACE_CHECK;
   orb_initializer = temp_orb_initializer;
 
-  PortableInterceptor::register_orb_initializer (orb_initializer.in (),
-                                                 ACE_TRY_ENV);
+  PortableInterceptor::register_orb_initializer (orb_initializer.in ()
+                                                  TAO_ENV_ARG_PARAMETER);
   ACE_CHECK;
 #endif  /* TAO_HAS_CORBA_MESSAGING == 1 */
 
@@ -1236,8 +1241,8 @@ CORBA_ORB::init_orb_globals (CORBA::Environment &ACE_TRY_ENV)
   ACE_CHECK;
   pi_initializer = temp_pi_initializer;
 
-  PortableInterceptor::register_orb_initializer (pi_initializer.in (),
-                                                 ACE_TRY_ENV);
+  PortableInterceptor::register_orb_initializer (pi_initializer.in ()
+                                                  TAO_ENV_ARG_PARAMETER);
   ACE_CHECK;
 #endif  /* TAO_HAS_INTERCEPTORS == 1 */
 }
@@ -1292,6 +1297,10 @@ CORBA::ORB_init (int &argc,
                  const char *orbid,
                  CORBA_Environment &ACE_TRY_ENV)
 {
+  // This ugly ifdef will go away once we've merged the two ORB_init's.
+#if defined (TAO_HAS_EXCEPTIONS) && !defined (TAO_ENV_BKWD_COMPAT)
+  ACE_UNUSED_ARG (ACE_TRY_ENV);
+#endif
 
   // Using ACE_Static_Object_Lock::instance() precludes <ORB_init>
   // from being called within a static object CTOR.
@@ -1303,7 +1312,7 @@ CORBA::ORB_init (int &argc,
   if (TAO_Singleton_Manager::instance ()->init () == -1)
     return CORBA::ORB::_nil ();
 
-  CORBA_ORB::init_orb_globals (ACE_TRY_ENV);
+  CORBA_ORB::init_orb_globals (TAO_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (CORBA::ORB::_nil ());
 
   // Make sure the following is done after the global ORB
@@ -1441,12 +1450,12 @@ CORBA::ORB_init (int &argc,
 
   // Call the ORBInitializer::pre_init() on each registered ORB
   // initializer.
-  TAO_ORBInitializer_Registry::instance ()->pre_init (orb_init_info.in (),
-                                                      ACE_TRY_ENV);
+  TAO_ORBInitializer_Registry::instance ()->pre_init (orb_init_info.in ()
+                                                       TAO_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (CORBA::ORB::_nil ());
 
   // Initialize the ORB Core instance.
-  result = safe_oc->init (argc, argv, ACE_TRY_ENV);
+  result = safe_oc->init (argc, argv TAO_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (CORBA::ORB::_nil ());
 
   // Check for errors and return nil pseudo-reference on error.
@@ -1460,8 +1469,8 @@ CORBA::ORB_init (int &argc,
 
   // Call the ORBInitializer::post_init() on each registered ORB
   // initializer.
-  TAO_ORBInitializer_Registry::instance ()->post_init (orb_init_info.in (),
-                                                       ACE_TRY_ENV);
+  TAO_ORBInitializer_Registry::instance ()->post_init (orb_init_info.in ()
+                                                        TAO_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (CORBA::ORB::_nil ());
 
   // Invalidate the ORBInitInfo instance to prevent future
@@ -1489,11 +1498,11 @@ CORBA::ORB_init (int &argc,
 
 // Objref stringification.
 char *
-CORBA_ORB::object_to_string (CORBA::Object_ptr obj,
-                             CORBA::Environment &ACE_TRY_ENV)
+CORBA_ORB::object_to_string (CORBA::Object_ptr obj
+                             TAO_ENV_ARG_DECL)
 {
   // This method should not be called if the ORB has been shutdown.
-  this->check_shutdown (ACE_TRY_ENV);
+  this->check_shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
   if (!CORBA::is_nil (obj) && obj->_is_local ())
@@ -1620,7 +1629,7 @@ CORBA_ORB::object_to_string (CORBA::Object_ptr obj,
       // For now we just use the first profile.
       TAO_Profile *profile = mp.get_profile (0);
 
-      return profile->to_string (ACE_TRY_ENV);
+      return profile->to_string (TAO_ENV_SINGLE_ARG_PARAMETER);
     }
 }
 
@@ -1628,11 +1637,11 @@ CORBA_ORB::object_to_string (CORBA::Object_ptr obj,
 // <resolve_name_service> with an IOR <multicast_to_service>.
 
 CORBA::Object_ptr
-CORBA_ORB::string_to_object (const char *str,
-                             CORBA::Environment &ACE_TRY_ENV)
+CORBA_ORB::string_to_object (const char *str
+                             TAO_ENV_ARG_DECL)
 {
   // This method should not be called if the ORB has been shutdown.
-  this->check_shutdown (ACE_TRY_ENV);
+  this->check_shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (CORBA::Object::_nil ());
 
   // Check for NULL pointer
@@ -1650,35 +1659,35 @@ CORBA_ORB::string_to_object (const char *str,
   if (ior_parser != 0)
     {
       return ior_parser->parse_string (str,
-                                       this,
-                                       ACE_TRY_ENV);
+                                       this
+                                        TAO_ENV_ARG_PARAMETER);
     }
 
 
   if (ACE_OS::strncmp (str,
                        ior_prefix,
                        sizeof ior_prefix - 1) == 0)
-    return this->ior_string_to_object (str + sizeof ior_prefix - 1,
-                                       ACE_TRY_ENV);
+    return this->ior_string_to_object (str + sizeof ior_prefix - 1
+                                        TAO_ENV_ARG_PARAMETER);
   else
-    return this->url_ior_string_to_object (str, ACE_TRY_ENV);
+    return this->url_ior_string_to_object (str TAO_ENV_ARG_PARAMETER);
 }
 
 // ****************************************************************
 
 CORBA::Policy_ptr
 CORBA_ORB::create_policy (CORBA::PolicyType type,
-                          const CORBA::Any& val,
-                          CORBA::Environment &ACE_TRY_ENV)
+                          const CORBA::Any& val
+                          TAO_ENV_ARG_DECL)
 {
-  this->check_shutdown (ACE_TRY_ENV);
+  this->check_shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (CORBA::Policy::_nil ());
 
   /// Attempt to obtain the policy from the policy factory registry.
   return
     this->orb_core_->policy_factory_registry ()->create_policy (type,
-                                                                val,
-                                                                ACE_TRY_ENV);
+                                                                val
+                                                                 TAO_ENV_ARG_PARAMETER);
 }
 
 // Destringify OMG-specified "IOR" string.
@@ -1687,8 +1696,8 @@ CORBA_ORB::create_policy (CORBA::PolicyType type,
 // implementations ...
 
 CORBA::Object_ptr
-CORBA_ORB::ior_string_to_object (const char *str,
-                                 CORBA::Environment &ACE_TRY_ENV)
+CORBA_ORB::ior_string_to_object (const char *str
+                                 TAO_ENV_ARG_DECL)
 {
   // Unhex the bytes, and make a CDR deencapsulation stream from the
   // resulting data.
@@ -1746,8 +1755,8 @@ CORBA_ORB::ior_string_to_object (const char *str,
 // Convert an URL style IOR in an object
 
 CORBA::Object_ptr
-CORBA_ORB::url_ior_string_to_object (const char* str,
-                                     CORBA::Environment& ACE_TRY_ENV)
+CORBA_ORB::url_ior_string_to_object (const char* str
+                                     TAO_ENV_ARG_DECL)
 {
   TAO_MProfile mprofile;
   // It is safe to declare this on the stack since the contents of
@@ -1758,8 +1767,8 @@ CORBA_ORB::url_ior_string_to_object (const char* str,
 
   int retv =
     this->orb_core_->connector_registry ()->make_mprofile (str,
-                                                           mprofile,
-                                                           ACE_TRY_ENV);
+                                                           mprofile
+                                                            TAO_ENV_ARG_PARAMETER);
 
   ACE_CHECK_RETURN (CORBA::Object::_nil ());   // Return nil.
 
@@ -1775,8 +1784,8 @@ CORBA_ORB::url_ior_string_to_object (const char* str,
 
   // Now make the TAO_Stub.
   TAO_Stub *data = this->orb_core_->create_stub ((char *) 0,
-                                                 mprofile,
-                                                 ACE_TRY_ENV);
+                                                 mprofile
+                                                  TAO_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (CORBA::Object::_nil ());
 
   TAO_Stub_Auto_Ptr safe_objdata (data);
@@ -1858,8 +1867,8 @@ operator>>(TAO_InputCDR& cdr, TAO_opaque& x)
 CORBA::ValueFactory_ptr
 CORBA_ORB::register_value_factory (
                             const char *repository_id,
-                            CORBA::ValueFactory_ptr factory,
-                            CORBA_Environment &ACE_TRY_ENV)
+                            CORBA::ValueFactory_ptr factory
+                            TAO_ENV_ARG_DECL)
 {
 // %! guard, and ACE_Null_Mutex in the map
 // do _add_ref here not in map->rebind
@@ -1887,16 +1896,16 @@ CORBA_ORB::register_value_factory (
 }
 
 void
-CORBA_ORB::unregister_value_factory (const char * /* repository_id */,
-                                     CORBA_Environment &)
+CORBA_ORB::unregister_value_factory (const char * /* repository_id */
+                                     TAO_ENV_ARG_DECL_NOT_USED)
 {
   ACE_ERROR((LM_ERROR, ACE_TEXT ("(%N:%l) function not implemented\n")));
   // %! TODO
 }
 
 CORBA::ValueFactory_ptr
-CORBA_ORB::lookup_value_factory (const char *repository_id,
-                                 CORBA_Environment &)
+CORBA_ORB::lookup_value_factory (const char *repository_id
+                                 TAO_ENV_ARG_DECL_NOT_USED)
 {
 // %! guard
 // do _add_ref here not in map->find