Merged corba-env-clean branch.

1 files changed, 158 insertions, 158 deletions

diff --git a/TAO/orbsvcs/orbsvcs/Trader/Trader_Interfaces.cpp b/TAO/orbsvcs/orbsvcs/Trader/Trader_Interfaces.cpp
index 8ec8825635b..9904d27b106 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Trader_Interfaces.cpp
+++ b/TAO/orbsvcs/orbsvcs/Trader/Trader_Interfaces.cpp
@@ -45,8 +45,8 @@ query (const char *type,
        CORBA::ULong how_many,
        CosTrading::OfferSeq_out returned_offers,
        CosTrading::OfferIterator_out returned_offer_iterator,
-       CosTrading::PolicyNameSeq_out returned_limits_applied,
-       CORBA::Environment& ACE_TRY_ENV)
+       CosTrading::PolicyNameSeq_out returned_limits_applied
+       TAO_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException,
                    CosTrading::IllegalServiceType,
                    CosTrading::UnknownServiceType,
@@ -60,13 +60,13 @@ query (const char *type,
                    CosTrading::DuplicatePolicyName))
 {
   // Instantiate a class to help interpret query policies.
-  TAO_Policies policies (this->trader_, in_policies, ACE_TRY_ENV);
+  TAO_Policies policies (this->trader_, in_policies TAO_ENV_ARG_PARAMETER);
   ACE_CHECK;
 
   // If a federated query returns to us, ignore it to prevent
   // redundant results and infinite loops.
   CosTrading::Admin::OctetSeq* request_id = 0;
-  int check = this->seen_request_id (policies, request_id, ACE_TRY_ENV);
+  int check = this->seen_request_id (policies, request_id TAO_ENV_ARG_PARAMETER);
   ACE_CHECK;
 
   if (check)
@@ -84,7 +84,7 @@ query (const char *type,
   // If the importer has specified a starting trader, foward the
   // query.
   CosTrading::TraderName* trader_name =
-    policies.starting_trader (ACE_TRY_ENV);
+    policies.starting_trader (TAO_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK;
 
   if (! CORBA::is_nil (link_if) && trader_name != 0)
@@ -101,8 +101,8 @@ query (const char *type,
                            how_many,
                            returned_offers,
                            returned_offer_iterator,
-                           returned_limits_applied,
-                           ACE_TRY_ENV);
+                           returned_limits_applied
+                           TAO_ENV_ARG_PARAMETER);
       ACE_CHECK;
       return;
     }
@@ -113,7 +113,7 @@ query (const char *type,
   CosTradingRepos::ServiceTypeRepository_ptr rep =
     support_attrs.service_type_repos ();
   CosTradingRepos::ServiceTypeRepository::TypeStruct_var type_struct =
-    rep->fully_describe_type (type, ACE_TRY_ENV);
+    rep->fully_describe_type (type TAO_ENV_ARG_PARAMETER);
   ACE_CHECK;
 
   // @@ Should throw a NO_MEMORY exception here...
@@ -133,17 +133,17 @@ query (const char *type,
   // meets those constraints.  TAO_Preference_Interpreter -- parses
   // the preference string and orders offers according to those
   // constraints.
-  TAO_Offer_Filter offer_filter (policies,
-                                 ACE_TRY_ENV);
+  TAO_Offer_Filter offer_filter (policies
+                                 TAO_ENV_ARG_PARAMETER);
   ACE_CHECK;
   TAO_Trader_Constraint_Validator validator (type_struct.in ());
   TAO_Constraint_Interpreter constr_inter (validator,
-                                           constraint,
-                                           ACE_TRY_ENV);
+                                           constraint
+                                           TAO_ENV_ARG_PARAMETER);
   ACE_CHECK;
   TAO_Preference_Interpreter pref_inter (validator,
-                                         preferences,
-                                         ACE_TRY_ENV);
+                                         preferences
+                                         TAO_ENV_ARG_PARAMETER);
   ACE_CHECK;
 
   // Try to find the map of offers of desired service type.
@@ -154,7 +154,7 @@ query (const char *type,
                          pref_inter,
                          offer_filter);
 
-  CORBA::Boolean result = policies.exact_type_match (ACE_TRY_ENV);
+  CORBA::Boolean result = policies.exact_type_match (TAO_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK;
 
   if (!result)
@@ -171,8 +171,8 @@ query (const char *type,
                                  rep,
                                  constr_inter,
                                  pref_inter,
-                                 offer_filter,
-                                 ACE_TRY_ENV);
+                                 offer_filter
+                                 TAO_ENV_ARG_PARAMETER);
       ACE_CHECK;
     }
 
@@ -187,8 +187,8 @@ query (const char *type,
                             policies,
                             pref_inter,
                             *returned_offers.ptr (),
-                            returned_offer_iterator,
-                            ACE_TRY_ENV);
+                            returned_offer_iterator
+                            TAO_ENV_ARG_PARAMETER);
   ACE_CHECK;
 
   // The following steps are only appropriate for a linked trader.
@@ -200,8 +200,8 @@ query (const char *type,
       CORBA::Boolean should_follow =
         this->retrieve_links (policies,
                               offers_returned,
-                              CosTrading::LinkNameSeq_out (links.out ()),
-                              ACE_TRY_ENV);
+                              CosTrading::LinkNameSeq_out (links.out ())
+                              TAO_ENV_ARG_PARAMETER);
       ACE_CHECK;
 
       if (should_follow && links->length () != 0)
@@ -218,8 +218,8 @@ query (const char *type,
                                  how_many,
                                  *returned_offers.ptr (),
                                  returned_offer_iterator.ptr (),
-                                 *returned_limits_applied.ptr (),
-                                 ACE_TRY_ENV);
+                                 *returned_limits_applied.ptr ()
+                                 TAO_ENV_ARG_PARAMETER);
           ACE_CHECK;
         }
     }
@@ -286,8 +286,8 @@ lookup_all_subtypes (const char* type,
                      CosTradingRepos::ServiceTypeRepository_ptr rep,
                      TAO_Constraint_Interpreter& constr_inter,
                      TAO_Preference_Interpreter& pref_inter,
-                     TAO_Offer_Filter& offer_filter,
-                     CORBA::Environment& ACE_TRY_ENV)
+                     TAO_Offer_Filter& offer_filter
+                     TAO_ENV_ARG_DECL)
 {
   // BEGIN SPEC
   // The trader may return a service offer of a subtype of the "type"
@@ -308,7 +308,7 @@ lookup_all_subtypes (const char* type,
   // types with lower incarnation numbers.
   sst.incarnation (inc_num);
 
-  all_types = rep->list_types (sst, ACE_TRY_ENV);
+  all_types = rep->list_types (sst TAO_ENV_ARG_PARAMETER);
   ACE_CHECK;
 
   // Scan all types inserted after the super types. If the transitive
@@ -321,8 +321,8 @@ lookup_all_subtypes (const char* type,
        i++)
     {
       // Obtain a description of the prospective type.
-      type_struct = rep->fully_describe_type (all_types[i],
-                                              ACE_TRY_ENV);
+      type_struct = rep->fully_describe_type (all_types[i]
+                                              TAO_ENV_ARG_PARAMETER);
       ACE_CHECK;
 
       CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq&
@@ -356,8 +356,8 @@ fill_receptacles (const char* /* type */,
                   TAO_Policies& policies,
                   TAO_Preference_Interpreter& pref_inter,
                   CosTrading::OfferSeq& offers,
-                  CosTrading::OfferIterator_ptr& offer_itr,
-                  CORBA::Environment& ACE_TRY_ENV)
+                  CosTrading::OfferIterator_ptr& offer_itr
+                  TAO_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CosTrading::IllegalPropertyName,
                   CosTrading::DuplicatePropertyName))
 {
@@ -372,13 +372,13 @@ fill_receptacles (const char* /* type */,
   // "offer_itr" will be nil.
   // END SPEC
 
-  TAO_Property_Filter prop_filter (desired_props, ACE_TRY_ENV);
+  TAO_Property_Filter prop_filter (desired_props TAO_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
   // RETURNING: Calculate how many offers go into the sequence
   //  Calculate how many go into the iterator
 
-  CORBA::ULong return_card = policies.return_card (ACE_TRY_ENV);
+  CORBA::ULong return_card = policies.return_card (TAO_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
   CORBA::ULong i = 0;
@@ -423,9 +423,9 @@ fill_receptacles (const char* /* type */,
         this->create_offer_iterator (prop_filter);
 
       // Register it with the POA.
-      offer_itr = oi->_this (ACE_TRY_ENV);
+      offer_itr = oi->_this (TAO_ENV_SINGLE_ARG_PARAMETER);
       // @@ Seth, ACE_CHECK_RETURN (what?);
-      oi->_remove_ref (ACE_TRY_ENV);
+      oi->_remove_ref (TAO_ENV_SINGLE_ARG_PARAMETER);
       ACE_CHECK_RETURN (total_offers - offers_in_iterator);
 
       // Add to the iterator
@@ -492,13 +492,13 @@ CORBA::Boolean
 TAO_Lookup<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
 retrieve_links (TAO_Policies& policies,
                 CORBA::ULong offers_returned,
-                CosTrading::LinkNameSeq_out links,
-                CORBA::Environment& ACE_TRY_ENV)
+                CosTrading::LinkNameSeq_out links
+                TAO_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException,
                    CosTrading::Lookup::PolicyTypeMismatch))
 {
   CORBA::Boolean should_follow = 0;
-  CosTrading::FollowOption follow_rule = policies.link_follow_rule (ACE_TRY_ENV);
+  CosTrading::FollowOption follow_rule = policies.link_follow_rule (TAO_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (should_follow);
 
   // Determine whether or not a federated query is warranted. A query
@@ -507,7 +507,7 @@ retrieve_links (TAO_Policies& policies,
   if ((follow_rule == CosTrading::always ||
        (follow_rule == CosTrading::if_no_local && offers_returned == 0)))
     {
-      CORBA::ULong hc = policies.hop_count (ACE_TRY_ENV);
+      CORBA::ULong hc = policies.hop_count (TAO_ENV_SINGLE_ARG_PARAMETER);
       ACE_CHECK_RETURN (0);
 
       if (hc > 0)
@@ -521,7 +521,7 @@ retrieve_links (TAO_Policies& policies,
       CosTrading::Link_ptr link_if =
         this->trader_.trading_components ().link_if ();
 
-      links = link_if->list_links (ACE_TRY_ENV);
+      links = link_if->list_links (TAO_ENV_SINGLE_ARG_PARAMETER);
       ACE_CHECK_RETURN (0);
 
       // Determine which of the links registered with the Link
@@ -533,12 +533,12 @@ retrieve_links (TAO_Policies& policies,
         {
           // Grab the link information.
           CosTrading::Link::LinkInfo_var
-            link_info (link_if->describe_link (links[i], ACE_TRY_ENV));
+            link_info (link_if->describe_link (links[i] TAO_ENV_ARG_PARAMETER));
           ACE_CHECK_RETURN (should_follow);
 
           // Compute the link follow rule.
           CosTrading::FollowOption link_rule =
-            policies.link_follow_rule (link_info.in (), ACE_TRY_ENV);
+            policies.link_follow_rule (link_info.in () TAO_ENV_ARG_PARAMETER);
           ACE_CHECK_RETURN (should_follow);
 
           // Determine if the link follow rule applies.
@@ -574,8 +574,8 @@ federated_query (const CosTrading::LinkNameSeq& links,
                  CORBA::ULong how_many,
                  CosTrading::OfferSeq& offers,
                  CosTrading::OfferIterator_ptr& offer_iter,
-                 CosTrading::PolicyNameSeq& limits,
-                 CORBA::Environment& ACE_TRY_ENV)
+                 CosTrading::PolicyNameSeq& limits
+                 TAO_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException,
                    CosTrading::IllegalServiceType,
                    CosTrading::UnknownServiceType,
@@ -624,13 +624,13 @@ federated_query (const CosTrading::LinkNameSeq& links,
         {
           // Obtain information about the link we're traversing.
           CosTrading::Link::LinkInfo_var link_info =
-            link_interface->describe_link (links[i], ACE_TRY_ENV);
+            link_interface->describe_link (links[i] TAO_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           // Set the link follow policy for the query over the link.
           policies.copy_in_follow_option (policies_to_pass,
-                                          link_info.in (),
-                                          ACE_TRY_ENV);
+                                          link_info.in ()
+                                          TAO_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           CosTrading::Lookup_var remote_lookup =
@@ -645,8 +645,8 @@ federated_query (const CosTrading::LinkNameSeq& links,
                                 how_many - offers.length (),
                                 CosTrading::OfferSeq_out (out_offers),
                                 CosTrading::OfferIterator_out (out_offer_iter),
-                                CosTrading::PolicyNameSeq_out (out_limits),
-                                ACE_TRY_ENV);
+                                CosTrading::PolicyNameSeq_out (out_limits)
+                                TAO_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           CORBA::ULong j = 0;
@@ -687,10 +687,10 @@ federated_query (const CosTrading::LinkNameSeq& links,
   this->order_merged_sequence (pref_inter, offers);
 
   // Return the collection of offer iterators.
-  offer_iter = offer_iter_collection->_this (ACE_TRY_ENV);
+  offer_iter = offer_iter_collection->_this (TAO_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK;
 
-  offer_iter_collection->_remove_ref (ACE_TRY_ENV);
+  offer_iter_collection->_remove_ref (TAO_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK;
 }
 
@@ -743,8 +743,8 @@ forward_query (const char* next_hop,
                CORBA::ULong how_many,
                CosTrading::OfferSeq_out offers,
                CosTrading::OfferIterator_out offer_itr,
-               CosTrading::PolicyNameSeq_out limits_applied,
-               CORBA::Environment& ACE_TRY_ENV)
+               CosTrading::PolicyNameSeq_out limits_applied
+               TAO_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException,
                    CosTrading::IllegalServiceType,
                    CosTrading::UnknownServiceType,
@@ -764,17 +764,17 @@ forward_query (const char* next_hop,
   ACE_TRY
     {
       CosTrading::Link::LinkInfo_var link_info =
-        link_interface->describe_link (next_hop, ACE_TRY_ENV);
+        link_interface->describe_link (next_hop TAO_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CosTrading::Lookup_var remote_lookup =
         CosTrading::Lookup::_duplicate (link_info->target.in ());
 
-      CORBA::Object_var us = this->_this (ACE_TRY_ENV);
+      CORBA::Object_var us = this->_this (TAO_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::Boolean self_loop =
-        remote_lookup->_is_equivalent (us.in (), ACE_TRY_ENV);
+        remote_lookup->_is_equivalent (us.in () TAO_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (! self_loop)
@@ -788,8 +788,8 @@ forward_query (const char* next_hop,
                                 how_many,
                                 offers,
                                 offer_itr,
-                                limits_applied,
-                                ACE_TRY_ENV);
+                                limits_applied
+                                TAO_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
         }
       else
@@ -802,8 +802,8 @@ forward_query (const char* next_hop,
                        how_many,
                        offers,
                        offer_itr,
-                       limits_applied,
-                       ACE_TRY_ENV);
+                       limits_applied
+                       TAO_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
         }
     }
@@ -822,21 +822,21 @@ template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CORBA::Boolean
 TAO_Lookup<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
 seen_request_id (TAO_Policies& policies,
-                 CosTrading::Admin::OctetSeq*& seq,
-                 CORBA::Environment& ACE_TRY_ENV)
+                 CosTrading::Admin::OctetSeq*& seq
+                 TAO_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException,
                    CosTrading::Lookup::PolicyTypeMismatch))
 {
   CORBA::Boolean return_value = 0;
 
-  seq = policies.request_id (ACE_TRY_ENV);
+  seq = policies.request_id (TAO_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (1);
 
   if (seq == 0)
     {
       CosTrading::Admin_ptr admin_if =
         this->trader_.trading_components ().admin_if ();
-      seq = admin_if->request_id_stem (ACE_TRY_ENV);
+      seq = admin_if->request_id_stem (TAO_ENV_SINGLE_ARG_PARAMETER);
       ACE_CHECK_RETURN (1);
     }
   else
@@ -898,8 +898,8 @@ CosTrading::OfferId
 TAO_Register<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
 _cxx_export (CORBA::Object_ptr reference,
              const char *type,
-             const CosTrading::PropertySeq &properties,
-             CORBA::Environment& ACE_TRY_ENV)
+             const CosTrading::PropertySeq &properties
+             TAO_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException,
                   CosTrading::Register::InvalidObjectRef,
                   CosTrading::IllegalServiceType,
@@ -927,7 +927,7 @@ _cxx_export (CORBA::Object_ptr reference,
   // Yank our friend, the type struct, and confirm that the given
   // properties match the type definition.
   CosTradingRepos::ServiceTypeRepository::TypeStruct_var type_struct =
-    rep->fully_describe_type (type, ACE_TRY_ENV);
+    rep->fully_describe_type (type TAO_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
   // Oops the type is masked, we shouldn't let exporters know the type
@@ -937,7 +937,7 @@ _cxx_export (CORBA::Object_ptr reference,
 
   // TAO-specific way to determine if an object is derived from or is
   // an interface type.
-  int check = (! reference->_is_a (type_struct->if_name, ACE_TRY_ENV));
+  int check = (! reference->_is_a (type_struct->if_name TAO_ENV_ARG_PARAMETER));
   ACE_CHECK_RETURN (0);
   if (check)
     ACE_THROW_RETURN (CosTrading::Register::
@@ -945,7 +945,7 @@ _cxx_export (CORBA::Object_ptr reference,
 
   // Validate that the properties defined for this offer are correct
   // to their types and strength.
-  this->validate_properties (type, type_struct.ptr (), properties, ACE_TRY_ENV);
+  this->validate_properties (type, type_struct.ptr (), properties TAO_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
   // CORBA::ULong plength = properties.length ();
@@ -975,8 +975,8 @@ _cxx_export (CORBA::Object_ptr reference,
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 void
 TAO_Register<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
-withdraw (const char *id,
-          CORBA::Environment& ACE_TRY_ENV)
+withdraw (const char *id
+          TAO_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException,
                    CosTrading::IllegalOfferId,
                    CosTrading::UnknownOfferId,
@@ -984,14 +984,14 @@ withdraw (const char *id,
 {
   // Get service type map.
   TAO_Offer_Database<MAP_LOCK_TYPE> &offer_database = this->trader_.offer_database ();
-  offer_database.remove_offer ((CosTrading::OfferId) id, ACE_TRY_ENV);
+  offer_database.remove_offer ((CosTrading::OfferId) id TAO_ENV_ARG_PARAMETER);
 }
 
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CosTrading::Register::OfferInfo *
 TAO_Register<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
-describe (const char *id,
-          CORBA::Environment& ACE_TRY_ENV)
+describe (const char *id
+          TAO_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException,
                   CosTrading::IllegalOfferId,
                   CosTrading::UnknownOfferId,
@@ -1003,7 +1003,7 @@ describe (const char *id,
 
   // Perform a lookup to find the offer.
   CosTrading::Offer* offer =
-    offer_database.lookup_offer ((CosTrading::OfferId) id, type, ACE_TRY_ENV);
+    offer_database.lookup_offer ((CosTrading::OfferId) id, type TAO_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (0);
 
   CosTrading::Register::OfferInfo *offer_info = 0;
@@ -1026,8 +1026,8 @@ void
 TAO_Register<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
 modify (const char *id,
         const CosTrading::PropertyNameSeq& del_list,
-        const CosTrading::PropertySeq& modify_list,
-        CORBA::Environment& ACE_TRY_ENV)
+        const CosTrading::PropertySeq& modify_list
+        TAO_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException,
                   CosTrading::NotImplemented,
                   CosTrading::IllegalOfferId,
@@ -1043,7 +1043,7 @@ modify (const char *id,
 {
   // Throw an exception if the trader is not configured
   // to support properties modification.
-  int check =  (! this->supports_modifiable_properties (ACE_TRY_ENV));
+  int check =  (! this->supports_modifiable_properties (TAO_ENV_SINGLE_ARG_PARAMETER));
   ACE_CHECK;
 
   if (check)
@@ -1057,22 +1057,22 @@ modify (const char *id,
   TAO_Offer_Database<MAP_LOCK_TYPE> &offer_database = this->trader_.offer_database ();
 
   CosTrading::Offer* offer = offer_database.
-    lookup_offer (ACE_const_cast (CosTrading::OfferId, id), type, ACE_TRY_ENV);
+    lookup_offer (ACE_const_cast (CosTrading::OfferId, id), type TAO_ENV_ARG_PARAMETER);
   ACE_CHECK;
 
   if (offer != 0)
     {
       // Yank our friend, the type struct.
       CosTradingRepos::ServiceTypeRepository::TypeStruct_var type_struct =
-        rep->fully_describe_type (type, ACE_TRY_ENV);
+        rep->fully_describe_type (type TAO_ENV_ARG_PARAMETER);
       ACE_CHECK;
       TAO_Offer_Modifier offer_mod (type, type_struct.in (), offer);
 
       // Delete, add, and change properties of the offer.
-      offer_mod.delete_properties (del_list, ACE_TRY_ENV);
+      offer_mod.delete_properties (del_list TAO_ENV_ARG_PARAMETER);
       ACE_CHECK;
 
-      offer_mod.merge_properties (modify_list, ACE_TRY_ENV);
+      offer_mod.merge_properties (modify_list TAO_ENV_ARG_PARAMETER);
       ACE_CHECK;
 
       // Alter our reference to the offer. We do this last, since the
@@ -1086,8 +1086,8 @@ template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 void
 TAO_Register<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
 withdraw_using_constraint (const char *type,
-                           const char *constr,
-                           CORBA::Environment& ACE_TRY_ENV)
+                           const char *constr
+                           TAO_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException,
                    CosTrading::IllegalServiceType,
                    CosTrading::UnknownServiceType,
@@ -1104,7 +1104,7 @@ withdraw_using_constraint (const char *type,
 
   // Retrieve the type struct
   CosTradingRepos::ServiceTypeRepository::TypeStruct_var type_struct =
-    rep->fully_describe_type (type, ACE_TRY_ENV);
+    rep->fully_describe_type (type TAO_ENV_ARG_PARAMETER);
   ACE_CHECK;
 
   // Try to find the map of offers of desired service type.
@@ -1123,7 +1123,7 @@ withdraw_using_constraint (const char *type,
 #endif /* _MSC_VER */
 
     TAO_Trader_Constraint_Validator validator (type_struct.in ());
-    TAO_Constraint_Interpreter constr_inter (validator, constr, ACE_TRY_ENV);
+    TAO_Constraint_Interpreter constr_inter (validator, constr TAO_ENV_ARG_PARAMETER);
     ACE_CHECK;
 
     while (offer_iter.has_more_offers ())
@@ -1146,7 +1146,7 @@ withdraw_using_constraint (const char *type,
           char* offer_id = 0;
 
           ids.dequeue_head (offer_id);
-          offer_database.remove_offer (offer_id, ACE_TRY_ENV);
+          offer_database.remove_offer (offer_id TAO_ENV_ARG_PARAMETER);
           ACE_CHECK;
           CORBA::string_free (offer_id);
         }
@@ -1158,8 +1158,8 @@ withdraw_using_constraint (const char *type,
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CosTrading::Register_ptr
 TAO_Register<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
-resolve (const CosTrading::TraderName &name,
-         CORBA::Environment& ACE_TRY_ENV)
+resolve (const CosTrading::TraderName &name
+         TAO_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException,
                   CosTrading::Register::IllegalTraderName,
                   CosTrading::Register::UnknownTraderName,
@@ -1184,11 +1184,11 @@ resolve (const CosTrading::TraderName &name,
   ACE_TRY
     {
       // Ensure that the link to the next trader exists.
-      link_info = link_if->describe_link (name[0], ACE_TRY_ENV);
+      link_info = link_if->describe_link (name[0] TAO_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       remote_reg =
-        CosTrading::Register::_narrow (link_info->target_reg.in (), ACE_TRY_ENV);
+        CosTrading::Register::_narrow (link_info->target_reg.in () TAO_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -1212,7 +1212,7 @@ resolve (const CosTrading::TraderName &name,
       for (int i = trader_name.length () - 1; i >= 0; i--)
         trader_name[i] = name[i + 1];
 
-      return_value = remote_reg->resolve (trader_name, ACE_TRY_ENV);
+      return_value = remote_reg->resolve (trader_name TAO_ENV_ARG_PARAMETER);
       ACE_CHECK_RETURN (CosTrading::Register::_nil ());
     }
 
@@ -1224,8 +1224,8 @@ void
 TAO_Register<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
 validate_properties (const char* type,
                      const CosTradingRepos::ServiceTypeRepository::TypeStruct* type_struct,
-                     const CosTrading::PropertySeq& properties,
-                     CORBA::Environment& ACE_TRY_ENV)
+                     const CosTrading::PropertySeq& properties
+                     TAO_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CosTrading::IllegalPropertyName,
                   CosTrading::PropertyTypeMismatch,
                   CosTrading::ReadonlyDynamicProperty,
@@ -1235,7 +1235,7 @@ validate_properties (const char* type,
   CORBA::ULong length = properties.length ();
   const CosTradingRepos::ServiceTypeRepository::PropStructSeq&
     prop_types = type_struct->props;
-  TAO_Property_Evaluator_By_Name prop_eval (properties, ACE_TRY_ENV);
+  TAO_Property_Evaluator_By_Name prop_eval (properties TAO_ENV_ARG_PARAMETER);
   ACE_CHECK;
 
   // Perform property validation
@@ -1260,8 +1260,8 @@ validate_properties (const char* type,
       else
         {
           int check =
-            (! prop_type->equal (prop_struct.value_type.in (),
-                                 ACE_TRY_ENV));
+            (! prop_type->equal (prop_struct.value_type.in ()
+                                 TAO_ENV_ARG_PARAMETER));
           ACE_CHECK;
           if (check)
             {
@@ -1343,7 +1343,7 @@ TAO_Admin<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::~TAO_Admin (void)
 
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CosTrading::Admin::OctetSeq *
-TAO_Admin<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::request_id_stem (CORBA::Environment&)
+TAO_Admin<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::request_id_stem (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_GUARD_RETURN (TRADER_LOCK_TYPE, trader_mon, this->lock_, 0);
@@ -1365,8 +1365,8 @@ TAO_Admin<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::request_id_stem (CORBA::Environment&)
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CORBA::ULong
 TAO_Admin<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
-set_def_search_card (CORBA::ULong value,
-                     CORBA::Environment& )
+set_def_search_card (CORBA::ULong value
+                     TAO_ENV_ARG_DECL_NOT_USED )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   CORBA::ULong return_value =
@@ -1379,8 +1379,8 @@ set_def_search_card (CORBA::ULong value,
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CORBA::ULong
 TAO_Admin<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
-set_max_search_card (CORBA::ULong value,
-                     CORBA::Environment& )
+set_max_search_card (CORBA::ULong value
+                     TAO_ENV_ARG_DECL_NOT_USED )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   CORBA::ULong return_value =
@@ -1393,8 +1393,8 @@ set_max_search_card (CORBA::ULong value,
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CORBA::ULong
 TAO_Admin<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
-set_def_match_card (CORBA::ULong value,
-                    CORBA::Environment& )
+set_def_match_card (CORBA::ULong value
+                    TAO_ENV_ARG_DECL_NOT_USED )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   CORBA::ULong return_value =
@@ -1407,8 +1407,8 @@ set_def_match_card (CORBA::ULong value,
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CORBA::ULong
 TAO_Admin<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
-set_max_match_card (CORBA::ULong value,
-                    CORBA::Environment& )
+set_max_match_card (CORBA::ULong value
+                    TAO_ENV_ARG_DECL_NOT_USED )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   CORBA::ULong return_value =
@@ -1421,8 +1421,8 @@ set_max_match_card (CORBA::ULong value,
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CORBA::ULong
 TAO_Admin<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
-set_def_return_card (CORBA::ULong value,
-                     CORBA::Environment& )
+set_def_return_card (CORBA::ULong value
+                     TAO_ENV_ARG_DECL_NOT_USED )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   CORBA::ULong return_value =
@@ -1435,8 +1435,8 @@ set_def_return_card (CORBA::ULong value,
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CORBA::ULong
 TAO_Admin<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
-set_max_return_card (CORBA::ULong value,
-                     CORBA::Environment& )
+set_max_return_card (CORBA::ULong value
+                     TAO_ENV_ARG_DECL_NOT_USED )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   CORBA::ULong return_value =
@@ -1449,8 +1449,8 @@ set_max_return_card (CORBA::ULong value,
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CORBA::ULong
 TAO_Admin<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
-set_max_list (CORBA::ULong value,
-              CORBA::Environment& )
+set_max_list (CORBA::ULong value
+              TAO_ENV_ARG_DECL_NOT_USED )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   CORBA::ULong return_value =
@@ -1463,8 +1463,8 @@ set_max_list (CORBA::ULong value,
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CORBA::Boolean
 TAO_Admin<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
-set_supports_modifiable_properties (CORBA::Boolean value,
-                                    CORBA::Environment& )
+set_supports_modifiable_properties (CORBA::Boolean value
+                                    TAO_ENV_ARG_DECL_NOT_USED )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   CORBA::Boolean return_value =
@@ -1477,8 +1477,8 @@ set_supports_modifiable_properties (CORBA::Boolean value,
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CORBA::Boolean
 TAO_Admin<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
-set_supports_dynamic_properties (CORBA::Boolean value,
-                                 CORBA::Environment& )
+set_supports_dynamic_properties (CORBA::Boolean value
+                                 TAO_ENV_ARG_DECL_NOT_USED )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   CORBA::Boolean return_value =
@@ -1491,8 +1491,8 @@ set_supports_dynamic_properties (CORBA::Boolean value,
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CORBA::Boolean
 TAO_Admin<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
-set_supports_proxy_offers (CORBA::Boolean value,
-                           CORBA::Environment& )
+set_supports_proxy_offers (CORBA::Boolean value
+                           TAO_ENV_ARG_DECL_NOT_USED )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   CORBA::Boolean return_value =
@@ -1505,8 +1505,8 @@ set_supports_proxy_offers (CORBA::Boolean value,
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CORBA::ULong
 TAO_Admin<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
-set_def_hop_count (CORBA::ULong value,
-                   CORBA::Environment& )
+set_def_hop_count (CORBA::ULong value
+                   TAO_ENV_ARG_DECL_NOT_USED )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   CORBA::ULong return_value =
@@ -1519,8 +1519,8 @@ set_def_hop_count (CORBA::ULong value,
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CORBA::ULong
 TAO_Admin<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
-set_max_hop_count (CORBA::ULong value,
-                   CORBA::Environment& )
+set_max_hop_count (CORBA::ULong value
+                   TAO_ENV_ARG_DECL_NOT_USED )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   CORBA::ULong return_value =
@@ -1533,8 +1533,8 @@ set_max_hop_count (CORBA::ULong value,
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CosTrading::FollowOption
 TAO_Admin<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
-set_def_follow_policy (CosTrading::FollowOption policy,
-                       CORBA::Environment& )
+set_def_follow_policy (CosTrading::FollowOption policy
+                       TAO_ENV_ARG_DECL_NOT_USED )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   CosTrading::FollowOption return_value =
@@ -1547,8 +1547,8 @@ set_def_follow_policy (CosTrading::FollowOption policy,
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CosTrading::FollowOption
 TAO_Admin<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
-set_max_follow_policy (CosTrading::FollowOption policy,
-                       CORBA::Environment& )
+set_max_follow_policy (CosTrading::FollowOption policy
+                       TAO_ENV_ARG_DECL_NOT_USED )
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   CosTrading::FollowOption return_value =
@@ -1561,8 +1561,8 @@ set_max_follow_policy (CosTrading::FollowOption policy,
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CosTrading::FollowOption
 TAO_Admin<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
-set_max_link_follow_policy (CosTrading::FollowOption policy,
-                            CORBA::Environment&)
+set_max_link_follow_policy (CosTrading::FollowOption policy
+                            TAO_ENV_ARG_DECL_NOT_USED)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   CosTrading::FollowOption return_value =
@@ -1575,8 +1575,8 @@ set_max_link_follow_policy (CosTrading::FollowOption policy,
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CosTrading::TypeRepository_ptr
 TAO_Admin<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
-set_type_repos (CosTrading::TypeRepository_ptr repository,
-                CORBA::Environment&)
+set_type_repos (CosTrading::TypeRepository_ptr repository
+                TAO_ENV_ARG_DECL_NOT_USED)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   CosTrading::TypeRepository_ptr return_value =
@@ -1589,8 +1589,8 @@ set_type_repos (CosTrading::TypeRepository_ptr repository,
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CosTrading::Admin::OctetSeq*
 TAO_Admin<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
-set_request_id_stem (const CosTrading::Admin::OctetSeq& stem,
-                       CORBA::Environment&)
+set_request_id_stem (const CosTrading::Admin::OctetSeq& stem
+                       TAO_ENV_ARG_DECL_NOT_USED)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_GUARD_RETURN (TRADER_LOCK_TYPE, trader_mon, this->lock_,
@@ -1604,8 +1604,8 @@ void
 TAO_Admin<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
 list_offers (CORBA::ULong how_many,
              CosTrading::OfferIdSeq_out ids,
-             CosTrading::OfferIdIterator_out id_itr,
-             CORBA::Environment& ACE_TRY_ENV)
+             CosTrading::OfferIdIterator_out id_itr
+             TAO_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException, CosTrading::NotImplemented))
 {
   // This method only applies when the register interface is implemented
@@ -1618,14 +1618,14 @@ list_offers (CORBA::ULong how_many,
   id_itr = CosTrading::OfferIdIterator::_nil ();
   if (how_many > 0)
     {
-      int check = offer_id_iter->next_n (how_many, ids, ACE_TRY_ENV);
+      int check = offer_id_iter->next_n (how_many, ids TAO_ENV_ARG_PARAMETER);
       ACE_CHECK;
 
       if (check == 1)
         {
-          id_itr = offer_id_iter->_this (ACE_TRY_ENV);
+          id_itr = offer_id_iter->_this (TAO_ENV_SINGLE_ARG_PARAMETER);
           ACE_CHECK;
-          offer_id_iter->_remove_ref (ACE_TRY_ENV);
+          offer_id_iter->_remove_ref (TAO_ENV_SINGLE_ARG_PARAMETER);
           ACE_CHECK;
         }
       else
@@ -1640,8 +1640,8 @@ void
 TAO_Admin<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
 list_proxies (CORBA::ULong,
               CosTrading::OfferIdSeq_out,
-              CosTrading::OfferIdIterator_out,
-              CORBA::Environment& ACE_TRY_ENV)
+              CosTrading::OfferIdIterator_out
+              TAO_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException,
                   CosTrading::NotImplemented))
 {
@@ -1668,8 +1668,8 @@ TAO_Link<TRADER_LOCK_TYPE, MAP_LOCK_TYPE>::
 add_link (const char *name,
           CosTrading::Lookup_ptr target,
           CosTrading::FollowOption def_pass_on_follow_rule,
-          CosTrading::FollowOption limiting_follow_rule,
-          CORBA::Environment& ACE_TRY_ENV)
+          CosTrading::FollowOption limiting_follow_rule
+          TAO_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException,
                   CosTrading::Link::IllegalLinkName,
                   CosTrading::Link::DuplicateLinkName,
@@ -1699,7 +1699,7 @@ add_link (const char *name,
   // Ensure that the limiting link behavior for this link doesn't
   // exceed the maximum allowed for a link.
   CosTrading::FollowOption follow_policy =
-    this->max_link_follow_policy (ACE_TRY_ENV);
+    this->max_link_follow_policy (TAO_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK;
   if (limiting_follow_rule < follow_policy)
     ACE_THROW (CosTrading::Link::LimitingFollowTooPermissive
@@ -1721,8 +1721,8 @@ add_link (const char *name,
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 void
 TAO_Link<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
-remove_link (const char *name,
-             CORBA::Environment& ACE_TRY_ENV)
+remove_link (const char *name
+             TAO_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException,
                   CosTrading::Link::IllegalLinkName,
                   CosTrading::Link::UnknownLinkName))
@@ -1742,8 +1742,8 @@ remove_link (const char *name,
 
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CosTrading::Link::LinkInfo *
-TAO_Link<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::describe_link (const char *name,
-                                               CORBA::Environment& ACE_TRY_ENV)
+TAO_Link<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::describe_link (const char *name
+                                               TAO_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException,
                    CosTrading::Link::IllegalLinkName,
                    CosTrading::Link::UnknownLinkName))
@@ -1777,7 +1777,7 @@ TAO_Link<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::describe_link (const char *name,
   // This avoids the nested upcall that would occur were we to invoke
   // this method in the add_link method.
 
-  new_link_info->target_reg = old_link_info.target->register_if (ACE_TRY_ENV);
+  new_link_info->target_reg = old_link_info.target->register_if (TAO_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (new_link_info);
 
   // return the link information for this link name.
@@ -1786,7 +1786,7 @@ TAO_Link<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::describe_link (const char *name,
 
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CosTrading::LinkNameSeq*
-TAO_Link<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::list_links (CORBA::Environment&)
+TAO_Link<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::list_links (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   // Allocate space for the link names.
@@ -1809,8 +1809,8 @@ void
 TAO_Link<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
 modify_link (const char *name,
              CosTrading::FollowOption def_pass_on_follow_rule,
-             CosTrading::FollowOption limiting_follow_rule,
-             CORBA::Environment& ACE_TRY_ENV)
+             CosTrading::FollowOption limiting_follow_rule
+             TAO_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CosTrading::Link::IllegalLinkName,
                    CosTrading::Link::UnknownLinkName,
                    CosTrading::Link::DefaultFollowTooPermissive,
@@ -1835,7 +1835,7 @@ modify_link (const char *name,
   // Ensure that the limiting link behavior for this link doesn't
   // exceed the maximum allowed for a link.
   CosTrading::FollowOption follow_policy =
-    this->max_link_follow_policy (ACE_TRY_ENV);
+    this->max_link_follow_policy (TAO_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK;
 
   if (limiting_follow_rule < follow_policy)
@@ -1870,8 +1870,8 @@ export_proxy (CosTrading::Lookup_ptr,
               const CosTrading::PropertySeq&,
               CORBA::Boolean,
               const char *,
-              const CosTrading::PolicySeq&,
-              CORBA::Environment& ACE_TRY_ENV)
+              const CosTrading::PolicySeq&
+              TAO_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException,
                   CosTrading::IllegalServiceType,
                   CosTrading::UnknownServiceType,
@@ -1890,8 +1890,8 @@ export_proxy (CosTrading::Lookup_ptr,
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 void
 TAO_Proxy<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
-withdraw_proxy (const char *,
-                CORBA::Environment& ACE_TRY_ENV)
+withdraw_proxy (const char *
+                TAO_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException,
                   CosTrading::IllegalOfferId,
                   CosTrading::UnknownOfferId,
@@ -1903,8 +1903,8 @@ withdraw_proxy (const char *,
 template <class TRADER_LOCK_TYPE, class MAP_LOCK_TYPE>
 CosTrading::Proxy::ProxyInfo *
 TAO_Proxy<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
-describe_proxy (const char *,
-                CORBA::Environment& ACE_TRY_ENV)
+describe_proxy (const char *
+                TAO_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException,
                   CosTrading::IllegalOfferId,
                   CosTrading::UnknownOfferId,
@@ -1918,8 +1918,8 @@ void
 TAO_Proxy<TRADER_LOCK_TYPE,MAP_LOCK_TYPE>::
 list_proxies (CORBA::ULong,
                 CosTrading::OfferIdSeq*&,
-                CosTrading::OfferIdIterator_ptr&,
-                CORBA::Environment& ACE_TRY_ENV)
+                CosTrading::OfferIdIterator_ptr&
+                TAO_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException,
                    CosTrading::NotImplemented))
 {