Merged corba-env-clean branch.

14 files changed, 303 insertions, 310 deletions

diff --git a/TAO/performance-tests/Cubit/TAO/DII_Cubit/client.cpp b/TAO/performance-tests/Cubit/TAO/DII_Cubit/client.cpp
index 8273d5089ca..fdf0a8886fa 100644
--- a/TAO/performance-tests/Cubit/TAO/DII_Cubit/client.cpp
+++ b/TAO/performance-tests/Cubit/TAO/DII_Cubit/client.cpp
@@ -200,8 +200,8 @@ DII_Cubit_Client::init (int argc, char **argv)
       // Initialize the ORB.
       this->orb_var_ = CORBA::ORB_init (this->argc_,
                                         this->argv_,
-                                        "internet",
-                                        ACE_TRY_ENV);
+                                        "internet"
+                                        TAO_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       // Parse command line and verify parameters.
@@ -213,13 +213,13 @@ DII_Cubit_Client::init (int argc, char **argv)
 
       // Get a factory object reference from the factory IOR.
       this->factory_var_ =
-        this->orb_var_->string_to_object (this->factory_IOR_,
-                                          ACE_TRY_ENV);
+        this->orb_var_->string_to_object (this->factory_IOR_
+                                          TAO_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       // Get a Cubit object with a DII request on the Cubit factory.
-      CORBA::Request_var mc_req (this->factory_var_->_request ("make_cubit",
-                                                               ACE_TRY_ENV));
+      CORBA::Request_var mc_req (this->factory_var_->_request ("make_cubit"
+                                                               TAO_ENV_ARG_PARAMETER));
 
       ACE_TRY_CHECK;
 
@@ -233,7 +233,7 @@ DII_Cubit_Client::init (int argc, char **argv)
 
       // Invoke the <make_cubit> operation to ask the Cubit factory
       // for a Cubit object.
-      mc_req->invoke (ACE_TRY_ENV);
+      mc_req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       // Extract the returned object reference from the request.
@@ -387,8 +387,8 @@ DII_Cubit_Client::cube_short_dii (void)
   ACE_TRY_NEW_ENV
     {
       // Create the request ...
-      CORBA::Request_var req (this->obj_var_->_request ("cube_short",
-                                                        ACE_TRY_ENV));
+      CORBA::Request_var req (this->obj_var_->_request ("cube_short"
+                                                        TAO_ENV_ARG_PARAMETER));
 
       ACE_TRY_CHECK;
 
@@ -402,7 +402,7 @@ DII_Cubit_Client::cube_short_dii (void)
 
       this->call_count_++;
 
-      req->invoke (ACE_TRY_ENV);
+      req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       req->return_value () >>= ret_short;
@@ -431,8 +431,8 @@ DII_Cubit_Client::cube_long_dii (void)
   ACE_TRY_NEW_ENV
     {
       // Create the request ...
-      CORBA::Request_var req (this->obj_var_->_request ("cube_long",
-                                                        ACE_TRY_ENV));
+      CORBA::Request_var req (this->obj_var_->_request ("cube_long"
+                                                        TAO_ENV_ARG_PARAMETER));
 
       ACE_TRY_CHECK;
 
@@ -446,7 +446,7 @@ DII_Cubit_Client::cube_long_dii (void)
 
       this->call_count_++;
 
-      req->invoke (ACE_TRY_ENV);
+      req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER);
 
       ACE_TRY_CHECK;
 
@@ -476,8 +476,8 @@ DII_Cubit_Client::cube_octet_dii (void)
   ACE_TRY_NEW_ENV
     {
       // Create the request ...
-      CORBA::Request_var req (this->obj_var_->_request ("cube_octet",
-                                                        ACE_TRY_ENV));
+      CORBA::Request_var req (this->obj_var_->_request ("cube_octet"
+                                                        TAO_ENV_ARG_PARAMETER));
 
       ACE_TRY_CHECK;
 
@@ -493,7 +493,7 @@ DII_Cubit_Client::cube_octet_dii (void)
       // Invoke, check for an exception and verify the result.
       this->call_count_++;
 
-      req->invoke (ACE_TRY_ENV);
+      req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER);
 
       ACE_TRY_CHECK;
 
@@ -524,8 +524,8 @@ DII_Cubit_Client::cube_union_dii (void)
   ACE_TRY_NEW_ENV
     {
       // Create the request ...
-      CORBA::Request_var req (this->obj_var_->_request ("cube_union",
-                                                        ACE_TRY_ENV));
+      CORBA::Request_var req (this->obj_var_->_request ("cube_union"
+                                                        TAO_ENV_ARG_PARAMETER));
 
       ACE_TRY_CHECK;
 
@@ -545,7 +545,7 @@ DII_Cubit_Client::cube_union_dii (void)
 
       this->call_count_++;
 
-      req->invoke (ACE_TRY_ENV);
+      req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER);
 
       ACE_TRY_CHECK;
 
@@ -579,8 +579,8 @@ DII_Cubit_Client::cube_struct_dii (void)
   ACE_TRY_NEW_ENV
     {
       // Create the request ...
-      CORBA::Request_var req (this->obj_var_->_request ("cube_struct",
-                                                        ACE_TRY_ENV));
+      CORBA::Request_var req (this->obj_var_->_request ("cube_struct"
+                                                        TAO_ENV_ARG_PARAMETER));
 
       ACE_TRY_CHECK;
 
@@ -599,7 +599,7 @@ DII_Cubit_Client::cube_struct_dii (void)
 
       this->call_count_++;
 
-      req->invoke (ACE_TRY_ENV);
+      req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER);
 
       ACE_TRY_CHECK;
 
@@ -631,8 +631,8 @@ DII_Cubit_Client::cube_octet_seq_dii (int length)
   ACE_TRY_NEW_ENV
     {
       // Create the request ...
-      CORBA::Request_var req (this->obj_var_->_request ("cube_octet_sequence",
-                                                         ACE_TRY_ENV));
+      CORBA::Request_var req (this->obj_var_->_request ("cube_octet_sequence"
+                                                         TAO_ENV_ARG_PARAMETER));
 
       ACE_TRY_CHECK;
 
@@ -652,7 +652,7 @@ DII_Cubit_Client::cube_octet_seq_dii (int length)
 
       this->call_count_++;
 
-      req->invoke (ACE_TRY_ENV);
+      req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER);
 
       ACE_TRY_CHECK;
 
@@ -692,8 +692,8 @@ DII_Cubit_Client::cube_long_seq_dii (int length)
   ACE_TRY_NEW_ENV
     {
       // Create the request ...
-      CORBA::Request_var req (this->obj_var_->_request ("cube_long_sequence",
-                                                        ACE_TRY_ENV));
+      CORBA::Request_var req (this->obj_var_->_request ("cube_long_sequence"
+                                                        TAO_ENV_ARG_PARAMETER));
 
       ACE_TRY_CHECK;
 
@@ -714,7 +714,7 @@ DII_Cubit_Client::cube_long_seq_dii (int length)
 
       this->call_count_++;
 
-      req->invoke (ACE_TRY_ENV);
+      req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER);
 
       ACE_TRY_CHECK;
 
@@ -821,13 +821,13 @@ DII_Cubit_Client::run (void)
       // Shut down server via a DII request.
       if (this->shutdown_)
         {
-          CORBA::Request_var req (this->obj_var_->_request ("shutdown",
-                                                            ACE_TRY_ENV));
+          CORBA::Request_var req (this->obj_var_->_request ("shutdown"
+                                                            TAO_ENV_ARG_PARAMETER));
 
           ACE_TRY_CHECK;
 
           // Cubit::shutdown () is a oneway operation.
-          req->send_oneway (ACE_TRY_ENV);
+          req->send_oneway (TAO_ENV_SINGLE_ARG_PARAMETER);
 
           ACE_TRY_CHECK;
 
diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.cpp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.cpp
index aa872d04ec0..90854fdd211 100644
--- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.cpp
+++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.cpp
@@ -382,7 +382,7 @@ Cubit_Client::check_enabled (unsigned int mask) const
 // Exercise the union.  Cube a union.
 
 void
-Cubit_Client::cube_union (CORBA::Environment &ACE_TRY_ENV)
+Cubit_Client::cube_union (TAO_ENV_SINGLE_ARG_DECL)
 {
   ACE_TRY
     {
@@ -397,8 +397,8 @@ Cubit_Client::cube_union (CORBA::Environment &ACE_TRY_ENV)
       {
         ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_UNION_START);
 
-        r = this->cubit_->cube_union (u,
-                                      ACE_TRY_ENV);
+        r = this->cubit_->cube_union (u
+                                      TAO_ENV_ARG_PARAMETER);
       }
 
       ACE_TRY_CHECK;
@@ -425,8 +425,8 @@ Cubit_Client::cube_union (CORBA::Environment &ACE_TRY_ENV)
       {
         ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_UNION_START);
 
-        r = this->cubit_->cube_union (u,
-                                      ACE_TRY_ENV);
+        r = this->cubit_->cube_union (u
+                                      TAO_ENV_ARG_PARAMETER);
       }
 
       ACE_TRY_CHECK;
@@ -458,8 +458,8 @@ Cubit_Client::cube_union (CORBA::Environment &ACE_TRY_ENV)
 // Cube a short.
 
 void
-Cubit_Client::cube_short (int i,
-                          CORBA::Environment &ACE_TRY_ENV)
+Cubit_Client::cube_short (int i
+                          TAO_ENV_ARG_DECL)
 {
   ACE_TRY
     {
@@ -470,8 +470,8 @@ Cubit_Client::cube_short (int i,
       {
         ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_SHORT_START);
 
-        ret_short = cubit_->cube_short (arg_short,
-                                        ACE_TRY_ENV);
+        ret_short = cubit_->cube_short (arg_short
+                                        TAO_ENV_ARG_PARAMETER);
       }
 
       ACE_TRY_CHECK;
@@ -509,13 +509,13 @@ Cubit_Client::cube_short (int i,
 // Oneway test.
 
 void
-Cubit_Client::cube_oneway (int,
-                           CORBA::Environment &ACE_TRY_ENV)
+Cubit_Client::cube_oneway (int
+                           TAO_ENV_ARG_DECL)
 {
   ACE_TRY
     {
       ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_ONEWAY_START);
-      this->cubit_->cube_oneway (ACE_TRY_ENV);
+      this->cubit_->cube_oneway (TAO_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
       this->call_count_++;
     }
@@ -530,13 +530,13 @@ Cubit_Client::cube_oneway (int,
 }
 
 void
-Cubit_Client::cube_void (int,
-                         CORBA::Environment &ACE_TRY_ENV)
+Cubit_Client::cube_void (int
+                         TAO_ENV_ARG_DECL)
 {
   ACE_TRY
     {
       ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_VOID_START);
-      this->cubit_->cube_void (ACE_TRY_ENV);
+      this->cubit_->cube_void (TAO_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
       this->call_count_++;
     }
@@ -553,8 +553,8 @@ Cubit_Client::cube_void (int,
 // Cube an octet
 
 void
-Cubit_Client::cube_octet (int i,
-                          CORBA::Environment &ACE_TRY_ENV)
+Cubit_Client::cube_octet (int i
+                          TAO_ENV_ARG_DECL)
 {
   ACE_TRY
     {
@@ -565,8 +565,8 @@ Cubit_Client::cube_octet (int i,
       {
         ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_OCTET_START);
 
-        ret_octet = this->cubit_->cube_octet (arg_octet,
-                                              ACE_TRY_ENV);
+        ret_octet = this->cubit_->cube_octet (arg_octet
+                                              TAO_ENV_ARG_PARAMETER);
       }
 
       ACE_TRY_CHECK;
@@ -605,8 +605,8 @@ Cubit_Client::cube_octet (int i,
 // calculate the cube from a long
 
 void
-Cubit_Client::cube_long (int i,
-                         CORBA::Environment &ACE_TRY_ENV)
+Cubit_Client::cube_long (int i
+                         TAO_ENV_ARG_DECL)
 {
   ACE_TRY
     {
@@ -617,8 +617,8 @@ Cubit_Client::cube_long (int i,
       {
         ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_LONG_START);
 
-        ret_long = this->cubit_->cube_long (arg_long,
-                                            ACE_TRY_ENV);
+        ret_long = this->cubit_->cube_long (arg_long
+                                            TAO_ENV_ARG_PARAMETER);
       }
 
       ACE_TRY_CHECK;
@@ -660,8 +660,8 @@ Cubit_Client::cube_long (int i,
 // Cube the numbers in a struct
 
 void
-Cubit_Client::cube_struct (int i,
-                           CORBA::Environment &ACE_TRY_ENV)
+Cubit_Client::cube_struct (int i
+                           TAO_ENV_ARG_DECL)
 {
   ACE_TRY
     {
@@ -678,8 +678,8 @@ Cubit_Client::cube_struct (int i,
       {
         ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_STRUCT_START);
 
-        ret_struct = this->cubit_->cube_struct (arg_struct,
-                                                ACE_TRY_ENV);
+        ret_struct = this->cubit_->cube_struct (arg_struct
+                                                TAO_ENV_ARG_PARAMETER);
       }
 
       ACE_TRY_CHECK;
@@ -717,8 +717,8 @@ Cubit_Client::cube_struct (int i,
 
 void
 Cubit_Client::cube_long_sequence (int,
-                                  int l,
-                                  CORBA::Environment &ACE_TRY_ENV)
+                                  int l
+                                  TAO_ENV_ARG_DECL)
 {
   ACE_TRY
     {
@@ -745,8 +745,8 @@ Cubit_Client::cube_long_sequence (int,
         ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_LONG_SEQUENCE_START);
 
         this->cubit_->cube_long_sequence (input,
-                                          vout,
-                                          ACE_TRY_ENV);
+                                          vout
+                                          TAO_ENV_ARG_PARAMETER);
       }
 
       ACE_TRY_CHECK;
@@ -790,8 +790,8 @@ Cubit_Client::cube_long_sequence (int,
 
 void
 Cubit_Client::cube_octet_sequence (int,
-                                   int l,
-                                   CORBA::Environment &ACE_TRY_ENV)
+                                   int l
+                                   TAO_ENV_ARG_DECL)
 {
   ACE_TRY
     {
@@ -819,8 +819,8 @@ Cubit_Client::cube_octet_sequence (int,
         ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_OCTET_SEQUENCE_START);
 
         this->cubit_->cube_octet_sequence (input,
-                                           vout,
-                                           ACE_TRY_ENV);
+                                           vout
+                                           TAO_ENV_ARG_PARAMETER);
       }
 
       ACE_TRY_CHECK;
@@ -865,8 +865,8 @@ Cubit_Client::cube_octet_sequence (int,
 
 void
 Cubit_Client::cube_many_sequence (int,
-                                  int l,
-                                  CORBA::Environment &ACE_TRY_ENV)
+                                  int l
+                                  TAO_ENV_ARG_DECL)
 {
   ACE_TRY
     {
@@ -901,8 +901,8 @@ Cubit_Client::cube_many_sequence (int,
         ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_MANY_SEQUENCE_START);
 
         this->cubit_->cube_many_sequence (input,
-                                          vout,
-                                          ACE_TRY_ENV);
+                                          vout
+                                          TAO_ENV_ARG_PARAMETER);
       }
 
       ACE_TRY_CHECK;
@@ -950,8 +950,8 @@ Cubit_Client::cube_many_sequence (int,
 void
 Cubit_Client::cube_rti_data (int,
                              int numUpdates,
-                             int numAttrs,
-                             CORBA::Environment &ACE_TRY_ENV)
+                             int numAttrs
+                             TAO_ENV_ARG_DECL)
 {
   ACE_TRY
     {
@@ -1021,8 +1021,8 @@ Cubit_Client::cube_rti_data (int,
         ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_RTI_DATA_START);
 
         this->cubit_->cube_rti_data (input,
-                                     vout,
-                                     ACE_TRY_ENV);
+                                     vout
+                                     TAO_ENV_ARG_PARAMETER);
       }
 
       ACE_TRY_CHECK;
@@ -1053,8 +1053,8 @@ Cubit_Client::cube_rti_data (int,
 // calculate the cube from long contained in an any
 
 void
-Cubit_Client::cube_any (int i,
-                        CORBA::Environment &ACE_TRY_ENV)
+Cubit_Client::cube_any (int i
+                        TAO_ENV_ARG_DECL)
 {
   ACE_TRY
     {
@@ -1068,8 +1068,8 @@ Cubit_Client::cube_any (int i,
       arg_any <<= arg_long;
       {
         ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_ANY_START);
-        ret_any = this->cubit_->cube_any (arg_any,
-                                          ACE_TRY_ENV);
+        ret_any = this->cubit_->cube_any (arg_any
+                                          TAO_ENV_ARG_PARAMETER);
       }
       ACE_TRY_CHECK;
 
@@ -1113,8 +1113,8 @@ Cubit_Client::cube_any (int i,
 // Cube the numbers in a struct
 
 void
-Cubit_Client::cube_any_struct (int i,
-                               CORBA::Environment &ACE_TRY_ENV)
+Cubit_Client::cube_any_struct (int i
+                               TAO_ENV_ARG_DECL)
 {
   ACE_TRY
     {
@@ -1133,8 +1133,8 @@ Cubit_Client::cube_any_struct (int i,
       arg_any <<= arg_struct;
       {
         ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_ANY_STRUCT_START);
-        ret_any = this->cubit_->cube_any_struct (arg_any,
-                                                 ACE_TRY_ENV);
+        ret_any = this->cubit_->cube_any_struct (arg_any
+                                                 TAO_ENV_ARG_PARAMETER);
       }
       ACE_TRY_CHECK;
 
@@ -1246,7 +1246,7 @@ Cubit_Client::run ()
 
   // Show the results one type at a time.
 
-  ACE_DECLARE_NEW_CORBA_ENV;
+  TAO_ENV_DECLARE_NEW_ENV;
   ACE_TRY
     {
       // VOID
@@ -1258,8 +1258,8 @@ Cubit_Client::run ()
 
           for (i = 0; i < this->loop_count_; ++i)
             {
-              this->cube_void (i,
-                               ACE_TRY_ENV);
+              this->cube_void (i
+                               TAO_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1279,8 +1279,8 @@ Cubit_Client::run ()
 
           for (i = 0; i < this->loop_count_; ++i)
             {
-              this->cube_short (i,
-                                ACE_TRY_ENV);
+              this->cube_short (i
+                                TAO_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1300,8 +1300,8 @@ Cubit_Client::run ()
 
           for (i = 0; i < this->loop_count_; ++i)
             {
-              this->cube_octet (i,
-                                ACE_TRY_ENV);
+              this->cube_octet (i
+                                TAO_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1321,8 +1321,8 @@ Cubit_Client::run ()
 
           for (i = 0; i < this->loop_count_; ++i)
             {
-              this->cube_long (i,
-                               ACE_TRY_ENV);
+              this->cube_long (i
+                               TAO_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1341,8 +1341,8 @@ Cubit_Client::run ()
 
           for (i = 0; i < this->loop_count_; ++i)
             {
-              this->cube_struct (i,
-                                 ACE_TRY_ENV);
+              this->cube_struct (i
+                                 TAO_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1362,7 +1362,7 @@ Cubit_Client::run ()
 
           for (i = 0; i < this->loop_count_; ++i)
             {
-              this->cube_union (ACE_TRY_ENV);
+              this->cube_union (TAO_ENV_SINGLE_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1383,8 +1383,8 @@ Cubit_Client::run ()
           for (i = 0; i < this->loop_count_; ++i)
             {
               this->cube_long_sequence (this->loop_count_,
-                                        4,
-                                        ACE_TRY_ENV);
+                                        4
+                                        TAO_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1405,8 +1405,8 @@ Cubit_Client::run ()
           for (i = 0; i < this->loop_count_; ++i)
             {
               this->cube_long_sequence (this->loop_count_,
-                                        1024,
-                                        ACE_TRY_ENV);
+                                        1024
+                                        TAO_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1432,8 +1432,8 @@ Cubit_Client::run ()
               for (i = 0; i < this->loop_count_; ++i)
                 {
                   this->cube_octet_sequence (this->loop_count_,
-                                             bytes_in_octet_sequence_,
-                                             ACE_TRY_ENV);
+                                             bytes_in_octet_sequence_
+                                             TAO_ENV_ARG_PARAMETER);
                   ACE_TRY_CHECK;
                 }
             }
@@ -1442,8 +1442,8 @@ Cubit_Client::run ()
               for (i = 0; i < this->loop_count_; ++i)
                 {
                   this->cube_octet_sequence (this->loop_count_,
-                                             16,
-                                             ACE_TRY_ENV);
+                                             16
+                                             TAO_ENV_ARG_PARAMETER);
                   ACE_TRY_CHECK;
                 }
             }
@@ -1465,8 +1465,8 @@ Cubit_Client::run ()
           for (i = 0; i < this->loop_count_; ++i)
             {
               this->cube_octet_sequence (this->loop_count_,
-                                         4096,
-                                         ACE_TRY_ENV);
+                                         4096
+                                         TAO_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1487,8 +1487,8 @@ Cubit_Client::run ()
           for (i = 0; i < this->loop_count_; ++i)
             {
               this->cube_many_sequence (this->loop_count_,
-                                        4,
-                                        ACE_TRY_ENV);
+                                        4
+                                        TAO_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1509,8 +1509,8 @@ Cubit_Client::run ()
           for (i = 0; i < this->loop_count_; ++i)
             {
               this->cube_many_sequence (this->loop_count_,
-                                        1024,
-                                        ACE_TRY_ENV);
+                                        1024
+                                        TAO_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1530,16 +1530,16 @@ Cubit_Client::run ()
 
           for (i = 0; i < this->loop_count_; ++i)
             {
-              this->cube_short (i,
-                                ACE_TRY_ENV);
+              this->cube_short (i
+                                TAO_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
 
-              this->cube_octet (i,
-                                ACE_TRY_ENV);
+              this->cube_octet (i
+                                TAO_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
 
-              this->cube_long (i,
-                               ACE_TRY_ENV);
+              this->cube_long (i
+                               TAO_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1560,8 +1560,8 @@ Cubit_Client::run ()
             {
               this->cube_rti_data (this->loop_count_,
                                    2,
-                                   5,
-                                   ACE_TRY_ENV);
+                                   5
+                                   TAO_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1581,8 +1581,8 @@ Cubit_Client::run ()
 
           for (i = 0; i < this->loop_count_; ++i)
             {
-              this->cube_oneway (i,
-                                 ACE_TRY_ENV);
+              this->cube_oneway (i
+                                 TAO_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1602,8 +1602,8 @@ Cubit_Client::run ()
 
           for (i = 0; i < this->loop_count_; ++i)
             {
-              this->cube_any (i,
-                              ACE_TRY_ENV);
+              this->cube_any (i
+                              TAO_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1622,8 +1622,8 @@ Cubit_Client::run ()
 
           for (i = 0; i < this->loop_count_; ++i)
             {
-              this->cube_any_struct (i,
-                                     ACE_TRY_ENV);
+              this->cube_any_struct (i
+                                     TAO_ENV_ARG_PARAMETER);
 
               ACE_TRY_CHECK;
             }
@@ -1635,8 +1635,8 @@ Cubit_Client::run ()
                              elapsed_time);
         }
 
-      this->shutdown_server (this->shutdown_,
-                             ACE_TRY_ENV);
+      this->shutdown_server (this->shutdown_
+                             TAO_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -1650,8 +1650,8 @@ Cubit_Client::run ()
 }
 
 int
-Cubit_Client::shutdown_server (int do_shutdown,
-                               CORBA::Environment &ACE_TRY_ENV)
+Cubit_Client::shutdown_server (int do_shutdown
+                               TAO_ENV_ARG_DECL)
 {
   if (do_shutdown)
     {
@@ -1660,7 +1660,7 @@ Cubit_Client::shutdown_server (int do_shutdown,
 
       ACE_TRY_EX(NOT_COLLOCATED)
         {
-          this->cubit_->shutdown (ACE_TRY_ENV);
+          this->cubit_->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK_EX (NOT_COLLOCATED);
         }
       ACE_CATCHANY
@@ -1713,8 +1713,8 @@ Cubit_Client::init (int argc, char **argv)
       // Retrieve the ORB.
       this->orb_ = CORBA::ORB_init (this->argc_,
                                     this->argv_,
-                                    "internet",
-                                    ACE_TRY_ENV);
+                                    "internet"
+                                    TAO_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       // Parse command line and verify parameters.
@@ -1743,13 +1743,13 @@ Cubit_Client::init (int argc, char **argv)
         }
 
       CORBA::Object_var factory_object =
-        this->orb_->string_to_object (this->cubit_factory_key_,
-                                      ACE_TRY_ENV);
+        this->orb_->string_to_object (this->cubit_factory_key_
+                                      TAO_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       this->factory_ =
-        Cubit_Factory::_narrow (factory_object.in(),
-                                ACE_TRY_ENV);
+        Cubit_Factory::_narrow (factory_object.in()
+                                TAO_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (this->factory_.in ()))
@@ -1765,7 +1765,7 @@ Cubit_Client::init (int argc, char **argv)
 
       // Now retrieve the Cubit obj ref corresponding to the key.
       this->cubit_ =
-        this->factory_->make_cubit (ACE_TRY_ENV);
+        this->factory_->make_cubit (TAO_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (this->cubit_.in ()))
diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.h b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.h
index 5899ad7c74d..1915358559c 100644
--- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.h
+++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.h
@@ -82,59 +82,59 @@ private:
                     ACE_Profile_Timer::ACE_Elapsed_Time &elapsed_time);
   // Prints the time stats.
 
-  void cube_union (CORBA::Environment &ACE_TRY_ENV);
+  void cube_union (TAO_ENV_SINGLE_ARG_DECL);
   // Exercise the union.  Cube a union.
 
-  void cube_struct (int i,
-                    CORBA::Environment &ACE_TRY_ENV);
+  void cube_struct (int i
+                    TAO_ENV_ARG_DECL);
   // calculate the cube from a struct.
 
-  void cube_long (int i,
-                  CORBA::Environment &ACE_TRY_ENV);
+  void cube_long (int i
+                  TAO_ENV_ARG_DECL);
   // calculate the cube from a long.
 
-  void cube_oneway (int i,
-                    CORBA::Environment &ACE_TRY_ENV);
+  void cube_oneway (int i
+                    TAO_ENV_ARG_DECL);
   // Oneway operation test.
 
-  void cube_void (int i,
-                  CORBA::Environment &ACE_TRY_ENV);
+  void cube_void (int i
+                  TAO_ENV_ARG_DECL);
   // Twoway operation test.
 
-  void cube_octet (int i,
-                   CORBA::Environment &ACE_TRY_ENV);
+  void cube_octet (int i
+                   TAO_ENV_ARG_DECL);
   // Cube an octet.
 
-  void cube_short (int i,
-                   CORBA::Environment &ACE_TRY_ENV);
+  void cube_short (int i
+                   TAO_ENV_ARG_DECL);
   // Cube a short.
 
-  void cube_long_sequence (int i, int l,
-                           CORBA::Environment &ACE_TRY_ENV);
+  void cube_long_sequence (int i, int l
+                           TAO_ENV_ARG_DECL);
   // Cube a sequence <l> is the length of the sequence.
 
-  void cube_octet_sequence (int i, int l,
-                            CORBA::Environment &ACE_TRY_ENV);
+  void cube_octet_sequence (int i, int l
+                            TAO_ENV_ARG_DECL);
   // Cube a sequence of octets, <l> is the length of the sequence.
 
-  void cube_many_sequence (int i, int l,
-                           CORBA::Environment &ACE_TRY_ENV);
+  void cube_many_sequence (int i, int l
+                           TAO_ENV_ARG_DECL);
   // Cube a sequence of manys, <l> is the length of the sequence.
 
-  void cube_rti_data (int i, int numUpdates, int numAttrs,
-                      CORBA::Environment &ACE_TRY_ENV);
+  void cube_rti_data (int i, int numUpdates, int numAttrs
+                      TAO_ENV_ARG_DECL);
   // Cube a sequence <l> is the length of the sequence.
 
-  void cube_any_struct (int i,
-                    CORBA::Environment &ACE_TRY_ENV);
+  void cube_any_struct (int i
+                    TAO_ENV_ARG_DECL);
   // calculate the cube from a struct in an any.
 
-  void cube_any (int i,
-                 CORBA::Environment &ACE_TRY_ENV);
+  void cube_any (int i
+                 TAO_ENV_ARG_DECL);
   // calculate the cube from a long in an any.
 
-  int shutdown_server (int do_shutdown,
-                       CORBA::Environment &ACE_TRY_ENV);
+  int shutdown_server (int do_shutdown
+                       TAO_ENV_ARG_DECL);
   // Invoke the method with <do_shutdown> != 0 to shutdown the server.
 
   int argc_;
diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.cpp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.cpp
index f54292b49bb..313495d228b 100644
--- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.cpp
+++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.cpp
@@ -55,15 +55,15 @@ Cubit_Server::parse_args (void)
 
 int
 Cubit_Server::init (int argc,
-                    char** argv,
-                    CORBA::Environment& ACE_TRY_ENV)
+                    char** argv
+                    TAO_ENV_ARG_DECL_NOT_USED TAO_ENV_SINGLE_ARG_PARAMETER)
 {
   // Call the init of <TAO_ORB_Manager> to initialize the ORB and
   // create a child POA under the root POA.
   if (this->orb_manager_.init_child_poa (argc,
                                          argv,
-                                         "child_poa",
-                                         ACE_TRY_ENV) == -1)
+                                         "child_poa"
+                                         TAO_ENV_ARG_PARAMETER) == -1)
     ACE_ERROR_RETURN ((LM_ERROR,
                        "%p\n",
                        "init_child_poa"),
@@ -88,8 +88,8 @@ Cubit_Server::init (int argc,
 
   this->factory_id_ =
     this->orb_manager_.activate_under_child_poa ("factory",
-                                                 this->factory_impl_,
-                                                 ACE_TRY_ENV);
+                                                 this->factory_impl_
+                                                 TAO_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (-1);
 
   ACE_DEBUG ((LM_DEBUG,
@@ -108,9 +108,9 @@ Cubit_Server::init (int argc,
 }
 
 int
-Cubit_Server::run (CORBA::Environment& env)
+Cubit_Server::run (TAO_ENV_SINGLE_ARG_DECL)
 {
-  if (this->orb_manager_.run (env) == -1)
+  if (this->orb_manager_.run (TAO_ENV_SINGLE_ARG_PARAMETER) == -1)
     ACE_ERROR_RETURN ((LM_ERROR,
                        "Cubit_Server::run"),
                       -1);
diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.h b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.h
index 633b4424037..d31269dd6ee 100644
--- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.h
+++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.h
@@ -51,11 +51,11 @@ public:
   // Destructor
 
   int init (int argc,
-            char **argv,
-            CORBA::Environment& env);
+            char **argv
+            TAO_ENV_ARG_DECL);
   // Initialize the Cubit_Server state - parsing arguments and ...
 
-  int run (CORBA::Environment& env);
+  int run (TAO_ENV_SINGLE_ARG_DECL);
   // Run the orb
 
 private:
diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.cpp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.cpp
index 73897ae501b..6eca9eb5f98 100644
--- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.cpp
+++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.cpp
@@ -126,10 +126,10 @@ Cubit_Factory_i::~Cubit_Factory_i (void)
 }
 
 Cubit_ptr
-Cubit_Factory_i::make_cubit (CORBA::Environment &env)
+Cubit_Factory_i::make_cubit (TAO_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
-  return my_cubit_._this (env);
+  return my_cubit_._this (TAO_ENV_SINGLE_ARG_PARAMETER);
 }
 
 void
@@ -152,7 +152,7 @@ Cubit_i::~Cubit_i (void)
 }
 
 PortableServer::POA_ptr
-Cubit_i::_default_POA (CORBA::Environment &)
+Cubit_i::_default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
 {
   return PortableServer::POA::_duplicate (this->poa_.in ());
 }
@@ -164,14 +164,14 @@ Cubit_i::set_default_poa (PortableServer::POA_ptr poa)
 }
 
 void
-Cubit_i::cube_oneway (CORBA::Environment &)
+Cubit_i::cube_oneway (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_ONEWAY_START);
 }
 
 void
-Cubit_i::cube_void (CORBA::Environment &)
+Cubit_i::cube_void (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_VOID_START);
@@ -180,54 +180,50 @@ Cubit_i::cube_void (CORBA::Environment &)
 // Cube an octet
 
 CORBA::Octet
-Cubit_i::cube_octet (CORBA::Octet o,
-                     CORBA::Environment &env)
+Cubit_i::cube_octet (CORBA::Octet o
+                     TAO_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_OCTET_START);
 
-  ACE_UNUSED_ARG (env);
   return o * o * o;
 }
 
 // Cube a short.
 
 CORBA::Short
-Cubit_i::cube_short (CORBA::Short s,
-                     CORBA::Environment &env)
+Cubit_i::cube_short (CORBA::Short s
+                     TAO_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_SHORT_START);
 
-  ACE_UNUSED_ARG (env);
   return s * s * s;
 }
 
 // Cube a long
 
 CORBA::Long
-Cubit_i::cube_long (CORBA::Long l,
-                    CORBA::Environment &env)
+Cubit_i::cube_long (CORBA::Long l
+                    TAO_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_LONG_START);
 
-  ACE_UNUSED_ARG (env);
   return l * l * l;
 }
 
 // Cube a struct
 
 Cubit::Many
-Cubit_i::cube_struct (const Cubit::Many &values,
-                      CORBA::Environment &env)
+Cubit_i::cube_struct (const Cubit::Many &values
+                      TAO_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_STRUCT_START);
 
   Cubit::Many temp;
 
-  ACE_UNUSED_ARG (env);
   temp.o = values.o * values.o * values.o;
   temp.s = values.s * values.s * values.s;
   temp.l = values.l * values.l * values.l;
@@ -238,15 +234,14 @@ Cubit_i::cube_struct (const Cubit::Many &values,
 // Cube a union
 
 Cubit::oneof
-Cubit_i::cube_union (const Cubit::oneof &values,
-                     CORBA::Environment &env)
+Cubit_i::cube_union (const Cubit::oneof &values
+                     TAO_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_UNION_START);
 
   Cubit::oneof temp;
 
-  ACE_UNUSED_ARG (env);
   switch (values._d ())
     {
     case Cubit::e_0th:
@@ -273,8 +268,8 @@ Cubit_i::cube_union (const Cubit::oneof &values,
 // Cube a sequence
 void
 Cubit_i::cube_long_sequence (const Cubit::long_seq &input,
-                             Cubit::long_seq_out output,
-                             CORBA::Environment &)
+                             Cubit::long_seq_out output
+                             TAO_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_LONG_SEQUENCE_START);
@@ -300,8 +295,8 @@ Cubit_i::cube_long_sequence (const Cubit::long_seq &input,
 // Cube an octet sequence
 void
 Cubit_i::cube_octet_sequence (const Cubit::octet_seq &input,
-                              Cubit::octet_seq_out output,
-                              CORBA::Environment &)
+                              Cubit::octet_seq_out output
+                              TAO_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_OCTET_SEQUENCE_START);
@@ -341,8 +336,8 @@ Cubit_i::cube_octet_sequence (const Cubit::octet_seq &input,
 
 void
 Cubit_i::cube_many_sequence (const Cubit::many_seq & input,
-                             Cubit::many_seq_out output,
-                             CORBA::Environment &)
+                             Cubit::many_seq_out output
+                             TAO_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_MANY_SEQUENCE_START);
@@ -375,8 +370,8 @@ Cubit_i::cube_many_sequence (const Cubit::many_seq & input,
 
 void
 Cubit_i::cube_rti_data (const Cubit::RtiPacket &input,
-                        Cubit::RtiPacket_out output,
-                        CORBA::Environment &)
+                        Cubit::RtiPacket_out output
+                        TAO_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_LONG_SEQUENCE_START);
@@ -407,13 +402,12 @@ Cubit_i::cube_rti_data (const Cubit::RtiPacket &input,
 // Cube a long contained in an any
 
 CORBA::Any *
-Cubit_i::cube_any (const CORBA::Any & any,
-                   CORBA::Environment &env)
+Cubit_i::cube_any (const CORBA::Any & any
+                   TAO_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_ANY_START);
 
-  ACE_UNUSED_ARG (env);
   CORBA::Long l;
   any >>= l;
   l = l * l * l;
@@ -425,14 +419,13 @@ Cubit_i::cube_any (const CORBA::Any & any,
 // Cube a struct contained in an any
 
 CORBA::Any *
-Cubit_i::cube_any_struct (const CORBA::Any & any,
-                          CORBA::Environment &env)
+Cubit_i::cube_any_struct (const CORBA::Any & any
+                          TAO_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_ANY_STRUCT_START);
   Cubit::Many * arg_struct;
   Cubit::Many ret_struct;
-  ACE_UNUSED_ARG (env);
   any >>= arg_struct;
 
   ret_struct.o = arg_struct->o * arg_struct->o * arg_struct->o;
@@ -446,7 +439,7 @@ Cubit_i::cube_any_struct (const CORBA::Any & any,
 
 // Shutdown.
 
-void Cubit_i::shutdown (CORBA::Environment &)
+void Cubit_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_DEBUG ((LM_DEBUG,
diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.h b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.h
index 06245519b80..454be029601 100644
--- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.h
+++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.h
@@ -37,77 +37,77 @@ public:
   ~Cubit_i (void);
   // Destructor
 
-  virtual PortableServer::POA_ptr _default_POA (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ());
+  virtual PortableServer::POA_ptr _default_POA (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
   // Returns the default POA for this servant.
 
-  virtual void cube_oneway (CORBA::Environment &env)
+  virtual void cube_oneway (TAO_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Test a oneway call.
 
-  virtual void cube_void (CORBA::Environment &env)
+  virtual void cube_void (TAO_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Test a twoway call.
 
-  virtual CORBA::Octet cube_octet (CORBA::Octet o,
-                                   CORBA::Environment &env)
+  virtual CORBA::Octet cube_octet (CORBA::Octet o
+                                   TAO_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Cube an octet
 
-  virtual CORBA::Short cube_short (CORBA::Short s,
-                                   CORBA::Environment &env)
+  virtual CORBA::Short cube_short (CORBA::Short s
+                                   TAO_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Cube a short
 
-  virtual CORBA::Long cube_long (CORBA::Long l,
-                                 CORBA::Environment &env)
+  virtual CORBA::Long cube_long (CORBA::Long l
+                                 TAO_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Cube a long
 
-  virtual Cubit::Many cube_struct (const Cubit::Many &values,
-                                   CORBA::Environment &env)
+  virtual Cubit::Many cube_struct (const Cubit::Many &values
+                                   TAO_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Cube a struct.
 
-  virtual Cubit::oneof cube_union (const Cubit::oneof &values,
-                                   CORBA::Environment &env)
+  virtual Cubit::oneof cube_union (const Cubit::oneof &values
+                                   TAO_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Cube a union.
 
   virtual void cube_long_sequence (const Cubit::long_seq &input,
-                                   Cubit::long_seq_out output,
-                                   CORBA::Environment &env)
+                                   Cubit::long_seq_out output
+                                   TAO_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Cube a sequence.
 
   virtual void cube_octet_sequence (const Cubit::octet_seq &input,
-                                    Cubit::octet_seq_out output,
-                                    CORBA::Environment &_env)
+                                    Cubit::octet_seq_out output
+                                    TAO_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Cube an octet sequence.
 
   virtual void cube_many_sequence (const Cubit::many_seq & input,
-                                   Cubit::many_seq_out output,
-                                   CORBA::Environment &_tao_environment)
+                                   Cubit::many_seq_out output
+                                   TAO_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Cube an Many sequence.
 
   virtual void cube_rti_data (const Cubit::RtiPacket &input,
-                              Cubit::RtiPacket_out output,
-                              CORBA::Environment &env)
+                              Cubit::RtiPacket_out output
+                              TAO_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Cube a sequence.
 
-  virtual CORBA::Any * cube_any (const CORBA::Any & any,
-                                CORBA::Environment &env)
+  virtual CORBA::Any * cube_any (const CORBA::Any & any
+                                TAO_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Cube a long in an any
 
-  virtual CORBA::Any * cube_any_struct (const CORBA::Any & any,
-                                       CORBA::Environment &env)
+  virtual CORBA::Any * cube_any_struct (const CORBA::Any & any
+                                       TAO_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Cube a struct in an any
 
-  virtual void shutdown (CORBA::Environment &env)
+  virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Shutdown routine.
 
@@ -135,7 +135,7 @@ public:
   ~Cubit_Factory_i (void);
   // Destructor.
 
-  virtual Cubit_ptr make_cubit (CORBA::Environment &env)
+  virtual Cubit_ptr make_cubit (TAO_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Make a cubit object.
 
diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/collocation_test.cpp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/collocation_test.cpp
index ece59a9223c..bd4b767c5a4 100644
--- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/collocation_test.cpp
+++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/collocation_test.cpp
@@ -43,15 +43,15 @@ svr_worker (void *arg)
   ACE_TRY_NEW_ENV
     {
       int result = cubit_server.init (args.argc (),
-                                      args.argv (),
-                                      ACE_TRY_ENV);
+                                      args.argv ()
+                                      TAO_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (result == -1)
         return (void *) 1;
 
       barrier->server_init_.wait ();
-      cubit_server.run (ACE_TRY_ENV);
+      cubit_server.run (TAO_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       barrier->client_fini_.wait ();
diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/server.cpp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/server.cpp
index 9279da7ee3a..af690c0ace4 100644
--- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/server.cpp
+++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/server.cpp
@@ -46,13 +46,13 @@ main (int argc, char *argv[])
               "\n\tIDL_Cubit: server\n\n"));
   ACE_TRY_NEW_ENV
     {
-      int ret = cubit_server.init (argc, argv, ACE_TRY_ENV);
+      int ret = cubit_server.init (argc, argv TAO_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (ret == -1)
         return -1;
 
-      cubit_server.run (ACE_TRY_ENV);
+      cubit_server.run (TAO_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       ACE_OS::sleep (5);
diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/Cubit_Task.cpp b/TAO/performance-tests/Cubit/TAO/MT_Cubit/Cubit_Task.cpp
index 8b5ea0b0310..1105a5a099c 100644
--- a/TAO/performance-tests/Cubit/TAO/MT_Cubit/Cubit_Task.cpp
+++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/Cubit_Task.cpp
@@ -64,14 +64,14 @@ Cubit_Task::svc (void)
                        "Create Servants failed.\n"),
                       -1);
 
-  ACE_DECLARE_NEW_CORBA_ENV;
+  TAO_ENV_DECLARE_NEW_ENV;
   ACE_TRY
     {
       GLOBALS::instance ()->barrier_->wait ();
 
       // Handle requests for this object until we're killed, or one of
       // the methods asks us to exit.
-      int r = this->orb_manager_.run (ACE_TRY_ENV);
+      int r = this->orb_manager_.run (TAO_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (r == -1)
@@ -84,7 +84,7 @@ Cubit_Task::svc (void)
       CORBA::ORB_var orb =
         this->orb_manager_.orb ();
 
-      orb->destroy (ACE_TRY_ENV);
+      orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -105,7 +105,7 @@ Cubit_Task::svc (void)
 int
 Cubit_Task::initialize_orb (void)
 {
-  ACE_DECLARE_NEW_CORBA_ENV;
+  TAO_ENV_DECLARE_NEW_ENV;
   ACE_TRY
     {
       ACE_ARGV args (this->orbargs_);
@@ -121,8 +121,8 @@ Cubit_Task::initialize_orb (void)
       int r = this->orb_manager_.init_child_poa (argc,
                                                  argv,
                                                  "persistent_poa",
-                                                 orb_name,
-                                                 ACE_TRY_ENV);
+                                                 orb_name
+                                                 TAO_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
       if (r == -1)
         return -1;
@@ -166,23 +166,23 @@ Cubit_Task::get_servant_ior (u_int index)
 int
 Cubit_Task::create_servants (void)
 {
-  ACE_DECLARE_NEW_CORBA_ENV;
+  TAO_ENV_DECLARE_NEW_ENV;
   ACE_TRY
     {
       CORBA::Object_var obj =
-        this->orb_->resolve_initial_references ("RootPOA",
-                                                ACE_TRY_ENV);
+        this->orb_->resolve_initial_references ("RootPOA"
+                                                TAO_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       PortableServer::POA_var poa =
-        PortableServer::POA::_narrow (obj.in (), ACE_TRY_ENV);
+        PortableServer::POA::_narrow (obj.in () TAO_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       PortableServer::POAManager_var manager =
-        poa->the_POAManager(ACE_TRY_ENV);
+        poa->the_POAManager(TAO_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
-      manager->activate(ACE_TRY_ENV);
+      manager->activate(TAO_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       // Create the array of cubit implementations.
@@ -232,13 +232,13 @@ Cubit_Task::create_servants (void)
           // some client.  Then release the object.
 
           Cubit_var cubit =
-            this->servants_[i]->_this (ACE_TRY_ENV);
+            this->servants_[i]->_this (TAO_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
 
           CORBA::String_var str =
-            this->orb_->object_to_string (cubit.in (),
-                                          ACE_TRY_ENV);
+            this->orb_->object_to_string (cubit.in ()
+                                          TAO_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           this->servants_iors_[i] =
diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.cpp b/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.cpp
index 770718a9684..8235905755c 100644
--- a/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.cpp
+++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.cpp
@@ -553,7 +553,7 @@ Client::find_frequency (void)
 }
 
 CORBA::ORB_ptr
-Client::init_orb (CORBA::Environment &ACE_TRY_ENV)
+Client::init_orb (TAO_ENV_SINGLE_ARG_DECL)
 {
   ACE_DEBUG ((LM_DEBUG,
               "I'm thread %t\n"));
@@ -582,8 +582,8 @@ Client::init_orb (CORBA::Environment &ACE_TRY_ENV)
   ACE_OS::sprintf (orbid, "orb:%d", this->id_);
   CORBA::ORB_var orb = CORBA::ORB_init (argc,
                                         argv,
-                                        orbid,
-                                        ACE_TRY_ENV);
+                                        orbid
+                                        TAO_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (CORBA::ORB::_nil ());
 
   if (this->id_ == 0)
@@ -613,7 +613,7 @@ Client::init_orb (CORBA::Environment &ACE_TRY_ENV)
 }
 
 int
-Client::get_cubit (CORBA::ORB_ptr orb, CORBA::Environment &ACE_TRY_ENV)
+Client::get_cubit (CORBA::ORB_ptr orb TAO_ENV_ARG_DECL)
 {
   char *my_ior =
     this->ts_->use_utilization_test_ == 1
@@ -632,8 +632,8 @@ Client::get_cubit (CORBA::ORB_ptr orb, CORBA::Environment &ACE_TRY_ENV)
                       -1);
 
   CORBA::Object_var objref =
-    orb->string_to_object (my_ior,
-                           ACE_TRY_ENV);
+    orb->string_to_object (my_ior
+                           TAO_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (-1);
 
   if (CORBA::is_nil (objref.in ()))
@@ -643,8 +643,8 @@ Client::get_cubit (CORBA::ORB_ptr orb, CORBA::Environment &ACE_TRY_ENV)
 
   // Narrow the CORBA::Object reference to the stub object,
   // checking the type along the way using _is_a.
-  this->cubit_ = Cubit::_narrow (objref.in (),
-                                 ACE_TRY_ENV);
+  this->cubit_ = Cubit::_narrow (objref.in ()
+                                 TAO_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (-1);
 
   if (CORBA::is_nil (this->cubit_))
@@ -656,8 +656,8 @@ Client::get_cubit (CORBA::ORB_ptr orb, CORBA::Environment &ACE_TRY_ENV)
               "(%t) Binding succeeded\n"));
 
   CORBA::String_var str =
-    orb->object_to_string (this->cubit_,
-                           ACE_TRY_ENV);
+    orb->object_to_string (this->cubit_
+                           TAO_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (-1);
 
   ACE_DEBUG ((LM_DEBUG,
@@ -670,18 +670,18 @@ Client::get_cubit (CORBA::ORB_ptr orb, CORBA::Environment &ACE_TRY_ENV)
 int
 Client::svc (void)
 {
-  ACE_DECLARE_NEW_CORBA_ENV;
+  TAO_ENV_DECLARE_NEW_ENV;
   ACE_TRY
     {
       // Initialize the ORB.
-      CORBA::ORB_var orb = this->init_orb (ACE_TRY_ENV);
+      CORBA::ORB_var orb = this->init_orb (TAO_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       // Find the frequency of CORBA requests based on thread id.
       this->find_frequency ();
 
       // Get the cubit object from the file.
-      int r = this->get_cubit (orb.in (), ACE_TRY_ENV);
+      int r = this->get_cubit (orb.in () TAO_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
       if (r != 0)
         return r;
@@ -716,14 +716,14 @@ Client::svc (void)
         {
           ACE_DEBUG ((LM_DEBUG,
                       "(%t) CALLING SHUTDOWN() ON THE SERVANT\n"));
-          this->cubit_->shutdown (ACE_TRY_ENV);
+          this->cubit_->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK;
         }
 
       CORBA::release (this->cubit_);
       this->cubit_ = 0;
 
-      orb->destroy (ACE_TRY_ENV);
+      orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -746,7 +746,7 @@ Client::svc (void)
 int
 Client::cube_octet (void)
 {
-  ACE_DECLARE_NEW_CORBA_ENV;
+  TAO_ENV_DECLARE_NEW_ENV;
   ACE_TRY
     {
       this->call_count_++;
@@ -757,11 +757,11 @@ Client::cube_octet (void)
       START_QUANTIFY;
 
       if (this->ts_->use_utilization_test_ == 1 && this->ts_->remote_invocations_ == 0)
-        ret_octet = this->cubit_impl_.cube_octet (arg_octet,
-                                                  ACE_TRY_ENV);
+        ret_octet = this->cubit_impl_.cube_octet (arg_octet
+                                                  TAO_ENV_ARG_PARAMETER);
       else
-        ret_octet = this->cubit_->cube_octet (arg_octet,
-                                              ACE_TRY_ENV);
+        ret_octet = this->cubit_->cube_octet (arg_octet
+                                              TAO_ENV_ARG_PARAMETER);
 
       STOP_QUANTIFY;
       ACE_TRY_CHECK;
@@ -792,7 +792,7 @@ Client::cube_octet (void)
 int
 Client::cube_short (void)
 {
-  ACE_DECLARE_NEW_CORBA_ENV;
+  TAO_ENV_DECLARE_NEW_ENV;
   ACE_TRY
     {
       this->call_count_++;
@@ -801,8 +801,8 @@ Client::cube_short (void)
       CORBA::Short ret_short;
 
       START_QUANTIFY;
-      ret_short = this->cubit_->cube_short (arg_short,
-                                            ACE_TRY_ENV);
+      ret_short = this->cubit_->cube_short (arg_short
+                                            TAO_ENV_ARG_PARAMETER);
       STOP_QUANTIFY;
       ACE_TRY_CHECK;
       arg_short = arg_short * arg_short * arg_short;
@@ -829,7 +829,7 @@ Client::cube_short (void)
 int
 Client::cube_long (void)
 {
-  ACE_DECLARE_NEW_CORBA_ENV;
+  TAO_ENV_DECLARE_NEW_ENV;
   ACE_TRY
     {
       this->call_count_++;
@@ -838,8 +838,8 @@ Client::cube_long (void)
       CORBA::Long ret_long;
 
       START_QUANTIFY;
-      ret_long = this->cubit_->cube_long (arg_long,
-                                          ACE_TRY_ENV);
+      ret_long = this->cubit_->cube_long (arg_long
+                                          TAO_ENV_ARG_PARAMETER);
       STOP_QUANTIFY;
       ACE_TRY_CHECK;
 
@@ -866,7 +866,7 @@ Client::cube_long (void)
 int
 Client::cube_struct (void)
 {
-  ACE_DECLARE_NEW_CORBA_ENV;
+  TAO_ENV_DECLARE_NEW_ENV;
   ACE_TRY
     {
       Cubit::Many arg_struct;
@@ -879,8 +879,8 @@ Client::cube_struct (void)
       arg_struct.o = func (this->num_);
 
       START_QUANTIFY;
-      ret_struct = this->cubit_->cube_struct (arg_struct,
-                                              ACE_TRY_ENV);
+      ret_struct = this->cubit_->cube_struct (arg_struct
+                                              TAO_ENV_ARG_PARAMETER);
       STOP_QUANTIFY;
       ACE_TRY_CHECK;
 
@@ -940,12 +940,12 @@ Client::make_request (void)
     }
   else
     {
-      ACE_DECLARE_NEW_CORBA_ENV;
+      TAO_ENV_DECLARE_NEW_ENV;
       ACE_TRY
         {
           this->call_count_++;
           START_QUANTIFY;
-          this->cubit_->noop (ACE_TRY_ENV);
+          this->cubit_->noop (TAO_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK;
           STOP_QUANTIFY;
         }
diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.h b/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.h
index 4472daab77c..554ad87b619 100644
--- a/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.h
+++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.h
@@ -279,14 +279,14 @@ public:
   // cubed.
 
 private:
-  CORBA::ORB_ptr init_orb (CORBA::Environment &ACE_TRY_ENV);
+  CORBA::ORB_ptr init_orb (TAO_ENV_SINGLE_ARG_DECL);
   // initialize the ORB.
 
   void read_ior (void);
   // reads the cubit ior from a file.
 
-  int get_cubit (CORBA::ORB_ptr orb,
-                 CORBA::Environment &ACE_TRY_ENV);
+  int get_cubit (CORBA::ORB_ptr orb
+                 TAO_ENV_ARG_DECL);
   // gets the cubit object.
 
   int run_tests (void);
diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.cpp b/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.cpp
index f27c6c029f9..8de8568c427 100644
--- a/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.cpp
+++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.cpp
@@ -18,32 +18,32 @@ Cubit_i::~Cubit_i (void)
 }
 
 CORBA::Octet
-Cubit_i::cube_octet (CORBA::Octet o,
-                     CORBA::Environment &)
+Cubit_i::cube_octet (CORBA::Octet o
+                     TAO_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   return (CORBA::Octet) (o * o * o);
 }
 
 CORBA::Short
-Cubit_i::cube_short (CORBA::Short s,
-                     CORBA::Environment &)
+Cubit_i::cube_short (CORBA::Short s
+                     TAO_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   return (CORBA::Short) (s * s * s);
 }
 
 CORBA::Long
-Cubit_i::cube_long (CORBA::Long l,
-                    CORBA::Environment &)
+Cubit_i::cube_long (CORBA::Long l
+                    TAO_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   return (CORBA::Long) (l * l * l);
 }
 
 Cubit::Many
-Cubit_i::cube_struct (const Cubit::Many &values,
-                      CORBA::Environment &)
+Cubit_i::cube_struct (const Cubit::Many &values
+                      TAO_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   Cubit::Many out_values;
@@ -56,13 +56,13 @@ Cubit_i::cube_struct (const Cubit::Many &values,
 }
 
 void
-Cubit_i::noop (CORBA::Environment &)
+Cubit_i::noop (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   // does nothing.
 }
 
-void Cubit_i::shutdown (CORBA::Environment &)
+void Cubit_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_DEBUG ((LM_DEBUG,
@@ -71,7 +71,7 @@ void Cubit_i::shutdown (CORBA::Environment &)
 }
 
 PortableServer::POA_ptr
-Cubit_i::_default_POA (CORBA::Environment &)
+Cubit_i::_default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
 {
   return PortableServer::POA::_duplicate (this->poa_.in ());
 }
diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.h b/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.h
index 1c8f2cad34d..bc65208821d 100644
--- a/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.h
+++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.h
@@ -29,30 +29,30 @@ public:
            PortableServer::POA_ptr poa);
   ~Cubit_i (void);
 
-  virtual CORBA::Octet cube_octet (CORBA::Octet o,
-                                   CORBA::Environment &env)
+  virtual CORBA::Octet cube_octet (CORBA::Octet o
+                                   TAO_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  virtual CORBA::Short cube_short (CORBA::Short s,
-                                   CORBA::Environment &env)
+  virtual CORBA::Short cube_short (CORBA::Short s
+                                   TAO_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  virtual CORBA::Long cube_long (CORBA::Long l,
-                                 CORBA::Environment &env)
+  virtual CORBA::Long cube_long (CORBA::Long l
+                                 TAO_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  virtual Cubit::Many cube_struct (const Cubit::Many &values,
-                                   CORBA::Environment &env)
+  virtual Cubit::Many cube_struct (const Cubit::Many &values
+                                   TAO_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  virtual void noop (CORBA::Environment &env)
+  virtual void noop (TAO_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  virtual void shutdown (CORBA::Environment &env)
+  virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
   virtual PortableServer::POA_ptr
-      _default_POA (CORBA::Environment &ACE_TRY_ENV);
+      _default_POA (TAO_ENV_SINGLE_ARG_DECL);
   // The default POA
 
 protected: