diff options
| author | Ossama Othman <ossama-othman@users.noreply.github.com> | 2001-12-08 21:59:30 +0000 |
|---|---|---|
| committer | Ossama Othman <ossama-othman@users.noreply.github.com> | 2001-12-08 21:59:30 +0000 |
| commit | 63165b00e2d667e39e15cf084128d94a563d484e (patch) | |
| tree | 6939cf1ed0a80ce8a3224d33f3d23c0e1b9a517f /TAO/tests | |
| parent | 6579bccb3a3f22f882ef908ad5f7e1a65b00b133 (diff) | |
| download | ATCD-63165b00e2d667e39e15cf084128d94a563d484e.tar.gz | |
Merged corba-env-clean branch.
Diffstat (limited to 'TAO/tests')
528 files changed, 6720 insertions, 6829 deletions
diff --git a/TAO/tests/AMI/ami_test_i.cpp b/TAO/tests/AMI/ami_test_i.cpp index b6fdee8113d..3745bc069ea 100644 --- a/TAO/tests/AMI/ami_test_i.cpp +++ b/TAO/tests/AMI/ami_test_i.cpp @@ -32,8 +32,8 @@ AMI_Test_i::AMI_Test_i (CORBA::ORB_ptr orb) CORBA::Long AMI_Test_i::foo (CORBA::Long_out out_l, CORBA::Long in_l, - const char* in_str, - CORBA::Environment &ACE_TRY_ENV) + const char* in_str + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, A::DidTheRightThing)) { @@ -58,7 +58,7 @@ AMI_Test_i::foo (CORBA::Long_out out_l, void -AMI_Test_i::shutdown (CORBA::Environment &) +AMI_Test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->orb_->shutdown (0); @@ -66,7 +66,7 @@ AMI_Test_i::shutdown (CORBA::Environment &) CORBA::Long -AMI_Test_i::yadda (CORBA::Environment &) +AMI_Test_i::yadda (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -76,8 +76,8 @@ AMI_Test_i::yadda (CORBA::Environment &) void -AMI_Test_i::yadda (CORBA::Long yadda, - CORBA::Environment &) +AMI_Test_i::yadda (CORBA::Long yadda + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, diff --git a/TAO/tests/AMI/ami_test_i.h b/TAO/tests/AMI/ami_test_i.h index fb235968a52..8e877174b25 100644 --- a/TAO/tests/AMI/ami_test_i.h +++ b/TAO/tests/AMI/ami_test_i.h @@ -37,19 +37,19 @@ public: // The AMI_Test methods. CORBA::Long foo (CORBA::Long_out out_l, CORBA::Long in_l, - const char* in_str, - CORBA::Environment &ACE_TRY_ENV) + const char* in_str + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, A::DidTheRightThing)); - - void shutdown (CORBA::Environment&) + + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - CORBA::Long yadda (CORBA::Environment &ACE_TRY_ENV) + CORBA::Long yadda (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - void yadda (CORBA::Long yadda, - CORBA::Environment &ACE_TRY_ENV) + void yadda (CORBA::Long yadda + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/AMI/client.cpp b/TAO/tests/AMI/client.cpp index 08ded59bd64..5ce889f4cfb 100644 --- a/TAO/tests/AMI/client.cpp +++ b/TAO/tests/AMI/client.cpp @@ -9,7 +9,7 @@ // server.cpp // // = DESCRIPTION -// A client, which uses the AMI callback model. +// A client which uses the AMI callback model. // // = AUTHOR // Alexander Babu Arulanthu <alex@cs.wustl.edu>, @@ -99,8 +99,8 @@ public: Handler (void) {}; void foo (CORBA::Long result, - CORBA::Long out_l, - CORBA::Environment&) + CORBA::Long out_l + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { if (debug) @@ -114,8 +114,8 @@ public: number_of_replies--; }; - void foo_excep (A::AMI_AMI_TestExceptionHolder * excep_holder, - CORBA::Environment &ACE_TRY_ENV) + void foo_excep (A::AMI_AMI_TestExceptionHolder * excep_holder + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { @@ -123,20 +123,20 @@ public: "Callback method <foo_excep> called: \n")); ACE_TRY { - excep_holder->raise_foo (ACE_TRY_ENV); + excep_holder->raise_foo (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY { ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Catched exception:"); + "Caught exception:"); } ACE_ENDTRY; ACE_CHECK; }; - void get_yadda (CORBA::Long result, - CORBA::Environment &) + void get_yadda (CORBA::Long result + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -144,23 +144,23 @@ public: result)); }; - void get_yadda_excep (A::AMI_AMI_TestExceptionHolder *, - CORBA::Environment &) + void get_yadda_excep (A::AMI_AMI_TestExceptionHolder * + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "Callback method <get_yadda_excep> called: \n")); }; - void set_yadda (CORBA::Environment &) + void set_yadda (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "Callback method <set_yadda> called: \n")); }; - void set_yadda_excep (A::AMI_AMI_TestExceptionHolder *, - CORBA::Environment &) + void set_yadda_excep (A::AMI_AMI_TestExceptionHolder * + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -175,22 +175,22 @@ Handler handler; int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; A::AMI_Test_var server = - A::AMI_Test::_narrow (object.in (), ACE_TRY_ENV); + A::AMI_Test::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -204,7 +204,7 @@ main (int argc, char *argv[]) // Activate POA to handle the call back. CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -213,16 +213,16 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - + // Let the client perform the test in a separate thread Client client (server.in (), niterations); @@ -248,12 +248,12 @@ main (int argc, char *argv[]) while (number_of_replies > 0) { CORBA::Boolean pending = - orb->work_pending(ACE_TRY_ENV); + orb->work_pending(TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (pending) { - orb->perform_work(ACE_TRY_ENV); + orb->perform_work(TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } @@ -273,17 +273,17 @@ main (int argc, char *argv[]) //client.ami_test_var_->shutdown (); root_poa->destroy (1, // ethernalize objects - 0, // wait for completion - ACE_TRY_ENV); + 0 // wait for completion + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY { ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Catched exception:"); + "Caught exception:"); return 1; } ACE_ENDTRY; @@ -298,7 +298,7 @@ Client::Client (A::AMI_Test_ptr server, : ami_test_var_ (A::AMI_Test::_duplicate (server)), niterations_ (niterations) { - the_handler_var_ = handler._this (/* ACE_TRY_ENV */); + the_handler_var_ = handler._this (/* TAO_ENV_SINGLE_ARG_PARAMETER */); } int @@ -312,8 +312,8 @@ Client::svc (void) { ami_test_var_->sendc_foo (the_handler_var_.in (), number, - "Let's talk AMI.", - ACE_TRY_ENV); + "Let's talk AMI." + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } if (debug) diff --git a/TAO/tests/AMI/server.cpp b/TAO/tests/AMI/server.cpp index 9393656e85a..a5916a29a99 100644 --- a/TAO/tests/AMI/server.cpp +++ b/TAO/tests/AMI/server.cpp @@ -56,15 +56,15 @@ parse_args (int argc, char *argv[]) int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -73,11 +73,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -86,11 +86,11 @@ main (int argc, char *argv[]) AMI_Test_i ami_test_i (orb.in ()); A::AMI_Test_var ami_test_var = - ami_test_i._this (ACE_TRY_ENV); + ami_test_i._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (ami_test_var.in (), ACE_TRY_ENV); + orb->object_to_string (ami_test_var.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); @@ -108,18 +108,18 @@ main (int argc, char *argv[]) ACE_OS::fclose (output_file); } - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; root_poa->destroy (1, // ethernalize objects - 0, // wait for completion - ACE_TRY_ENV); + 0 // wait for completion + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); @@ -127,7 +127,7 @@ main (int argc, char *argv[]) ACE_CATCHANY { ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Catched exception:"); + "Caught exception:"); return 1; } ACE_ENDTRY; diff --git a/TAO/tests/AMI/simple_client.cpp b/TAO/tests/AMI/simple_client.cpp index 77c14b0e919..7cd8199157f 100644 --- a/TAO/tests/AMI/simple_client.cpp +++ b/TAO/tests/AMI/simple_client.cpp @@ -9,7 +9,7 @@ // simple_client.cpp // // = DESCRIPTION -// A very simple client, which uses the AMI callback model. +// A very simple client which uses the AMI callback model. // // = AUTHOR // Alexander Babu Arulanthu <alex@cs.wustl.edu>, @@ -82,8 +82,8 @@ public: // Destructor. void foo (CORBA::Long ami_return_val, - CORBA::Long out_l, - CORBA::Environment &) + CORBA::Long out_l + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { if (debug) @@ -95,24 +95,24 @@ public: } }; - void foo_excep (A::AMI_AMI_TestExceptionHolder * excep_holder, - CORBA::Environment &ACE_TRY_ENV) + void foo_excep (A::AMI_AMI_TestExceptionHolder * excep_holder + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "Callback method <foo_excep> called: \n" - "Testing proper exception handling ...\n")); + "Testing proper exception handling ...\n")); ACE_TRY { - excep_holder->raise_foo (ACE_TRY_ENV); + excep_holder->raise_foo (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (A::DidTheRightThing, ex) { ACE_DEBUG ((LM_DEBUG, "... exception received successfully\n")); - } + } ACE_CATCHANY { ACE_DEBUG ((LM_DEBUG, @@ -123,8 +123,8 @@ public: }; - void get_yadda (CORBA::Long result, - CORBA::Environment &) + void get_yadda (CORBA::Long result + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -132,23 +132,23 @@ public: result)); }; - void get_yadda_excep (A::AMI_AMI_TestExceptionHolder *, - CORBA::Environment &) + void get_yadda_excep (A::AMI_AMI_TestExceptionHolder * + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "Callback method <get_yadda_excep> called: \n")); }; - void set_yadda (CORBA::Environment &) + void set_yadda (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "Callback method <set_yadda> called: \n")); }; - void set_yadda_excep (A::AMI_AMI_TestExceptionHolder *, - CORBA::Environment &) + void set_yadda_excep (A::AMI_AMI_TestExceptionHolder * + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -161,38 +161,38 @@ int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var object_var = - orb->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var poa_var = - PortableServer::POA::_narrow (object_var.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (object_var.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager_var = - poa_var->the_POAManager (ACE_TRY_ENV); + poa_var->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager_var->activate (ACE_TRY_ENV); + poa_manager_var->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; // We reuse the object_var smart pointer! - object_var = orb->string_to_object (ior, ACE_TRY_ENV); + object_var = orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; A::AMI_Test_var ami_test_var = - A::AMI_Test::_narrow (object_var.in (), ACE_TRY_ENV); + A::AMI_Test::_narrow (object_var.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (ami_test_var.in ())) @@ -206,7 +206,7 @@ main (int argc, char *argv[]) // Instantiate the ReplyHandler and register that with the POA. Handler handler; A::AMI_AMI_TestHandler_var the_handler_var = - handler._this (ACE_TRY_ENV); + handler._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Try out sending asynchronous messages without a reply handler @@ -214,8 +214,8 @@ main (int argc, char *argv[]) ami_test_var->sendc_foo (A::AMI_AMI_TestHandler::_nil (), 0, - "", - ACE_TRY_ENV); + "" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; @@ -226,8 +226,8 @@ main (int argc, char *argv[]) ami_test_var->sendc_foo (the_handler_var.in (), 0, - "Let's talk AMI.", - ACE_TRY_ENV); + "Let's talk AMI." + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Long l = 931247; @@ -240,23 +240,23 @@ main (int argc, char *argv[]) ami_test_var->sendc_foo (the_handler_var.in (), l, - "Let's talk AMI.", - ACE_TRY_ENV); + "Let's talk AMI." + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } // Begin test of attributes - ami_test_var->sendc_get_yadda (the_handler_var.in (), - ACE_TRY_ENV); + ami_test_var->sendc_get_yadda (the_handler_var.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ami_test_var->sendc_set_yadda (the_handler_var.in (), - 4711, - ACE_TRY_ENV); + 4711 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - ami_test_var->sendc_get_yadda (the_handler_var.in (), - ACE_TRY_ENV); + ami_test_var->sendc_get_yadda (the_handler_var.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // End test of attributes @@ -280,8 +280,8 @@ main (int argc, char *argv[]) CORBA::Long number = ami_test_var->foo (l, l, - "Let's talk SMI.", - ACE_TRY_ENV); + "Let's talk SMI." + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (debug) @@ -293,22 +293,22 @@ main (int argc, char *argv[]) if (shutdown_flag) { - ami_test_var->shutdown (ACE_TRY_ENV); + ami_test_var->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } poa_var->destroy (1, // ethernalize objects - 0, // wait for completion - ACE_TRY_ENV); + 0 // wait for completion + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY { ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Catched exception:"); + "Caught exception:"); return 1; } ACE_ENDTRY; diff --git a/TAO/tests/AMI_Buffering/AMI_Buffering.cpp b/TAO/tests/AMI_Buffering/AMI_Buffering.cpp index 79a75408078..9d7ab0a4455 100644 --- a/TAO/tests/AMI_Buffering/AMI_Buffering.cpp +++ b/TAO/tests/AMI_Buffering/AMI_Buffering.cpp @@ -13,29 +13,29 @@ AMI_Buffering::AMI_Buffering (CORBA::ORB_ptr orb, } void -AMI_Buffering::receive_data (const Test::Payload &the_payload, - CORBA::Environment &ACE_TRY_ENV) +AMI_Buffering::receive_data (const Test::Payload &the_payload + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->admin_->request_received (the_payload.length (), ACE_TRY_ENV); + this->admin_->request_received (the_payload.length () TAO_ENV_ARG_PARAMETER); } void -AMI_Buffering::flush (CORBA::Environment &) +AMI_Buffering::flush (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { } void -AMI_Buffering::sync (CORBA::Environment &ACE_TRY_ENV) +AMI_Buffering::sync (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->admin_->flush (ACE_TRY_ENV); + this->admin_->flush (TAO_ENV_SINGLE_ARG_PARAMETER); } void -AMI_Buffering::shutdown (CORBA::Environment &ACE_TRY_ENV) +AMI_Buffering::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/AMI_Buffering/AMI_Buffering.h b/TAO/tests/AMI_Buffering/AMI_Buffering.h index d3f672a97ba..52614d58731 100644 --- a/TAO/tests/AMI_Buffering/AMI_Buffering.h +++ b/TAO/tests/AMI_Buffering/AMI_Buffering.h @@ -26,17 +26,17 @@ public: Test::AMI_Buffering_Admin_ptr admin); // = The skeleton methods - virtual void receive_data (const Test::Payload &the_payload, - CORBA::Environment &ACE_TRY_ENV) + virtual void receive_data (const Test::Payload &the_payload + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void flush (CORBA::Environment &ACE_TRY_ENV) + virtual void flush (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void sync (CORBA::Environment &ACE_TRY_ENV) + virtual void sync (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/AMI_Buffering/AMI_Buffering_Admin.cpp b/TAO/tests/AMI_Buffering/AMI_Buffering_Admin.cpp index b5350db820e..9f258445acd 100644 --- a/TAO/tests/AMI_Buffering/AMI_Buffering_Admin.cpp +++ b/TAO/tests/AMI_Buffering/AMI_Buffering_Admin.cpp @@ -13,22 +13,22 @@ AMI_Buffering_Admin::AMI_Buffering_Admin (CORBA::ORB_ptr orb) } CORBA::ULong -AMI_Buffering_Admin::request_count (CORBA::Environment &) +AMI_Buffering_Admin::request_count (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return this->request_count_; } CORBA::ULong -AMI_Buffering_Admin::bytes_received_count (CORBA::Environment &) +AMI_Buffering_Admin::bytes_received_count (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return this->bytes_received_count_; } void -AMI_Buffering_Admin::request_received (CORBA::ULong payload_length, - CORBA::Environment &) +AMI_Buffering_Admin::request_received (CORBA::ULong payload_length + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->request_count_++; @@ -36,14 +36,14 @@ AMI_Buffering_Admin::request_received (CORBA::ULong payload_length, } void -AMI_Buffering_Admin::flush (CORBA::Environment &) +AMI_Buffering_Admin::flush (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { } void -AMI_Buffering_Admin::shutdown (CORBA::Environment &ACE_TRY_ENV) +AMI_Buffering_Admin::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/AMI_Buffering/AMI_Buffering_Admin.h b/TAO/tests/AMI_Buffering/AMI_Buffering_Admin.h index 23915510b1d..f3f3d305fbc 100644 --- a/TAO/tests/AMI_Buffering/AMI_Buffering_Admin.h +++ b/TAO/tests/AMI_Buffering/AMI_Buffering_Admin.h @@ -25,20 +25,20 @@ public: AMI_Buffering_Admin (CORBA::ORB_ptr orb); // = The skeleton methods - virtual CORBA::ULong request_count (CORBA::Environment &ACE_TRY_ENV) + virtual CORBA::ULong request_count (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual CORBA::ULong bytes_received_count (CORBA::Environment &ACE_TRY_ENV) + virtual CORBA::ULong bytes_received_count (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void request_received (CORBA::ULong payload_length, - CORBA::Environment &ACE_TRY_ENV) + virtual void request_received (CORBA::ULong payload_length + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void flush (CORBA::Environment &ACE_TRY_ENV) + virtual void flush (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/AMI_Buffering/Client_Task.cpp b/TAO/tests/AMI_Buffering/Client_Task.cpp index 3c74d4aa262..e515a0b11a4 100644 --- a/TAO/tests/AMI_Buffering/Client_Task.cpp +++ b/TAO/tests/AMI_Buffering/Client_Task.cpp @@ -23,14 +23,14 @@ int Client_Task::svc (void) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) Starting client task\n")); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { while (1) { // run the even loop for 1 second... ACE_Time_Value tv (1, 0); - this->orb_->run (tv, ACE_TRY_ENV); + this->orb_->run (tv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->mutex_, -1); diff --git a/TAO/tests/AMI_Buffering/Reply_Handler.cpp b/TAO/tests/AMI_Buffering/Reply_Handler.cpp index e82471f58be..c07882c69ce 100644 --- a/TAO/tests/AMI_Buffering/Reply_Handler.cpp +++ b/TAO/tests/AMI_Buffering/Reply_Handler.cpp @@ -10,19 +10,19 @@ Reply_Handler::Reply_Handler (void) } void -Reply_Handler::receive_data (CORBA::Environment &) +Reply_Handler::receive_data (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { } void -Reply_Handler::receive_data_excep (Test::AMI_AMI_BufferingExceptionHolder *holder, - CORBA::Environment &ACE_TRY_ENV) +Reply_Handler::receive_data_excep (Test::AMI_AMI_BufferingExceptionHolder *holder + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_TRY { - holder->raise_receive_data (ACE_TRY_ENV); + holder->raise_receive_data (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -34,19 +34,19 @@ Reply_Handler::receive_data_excep (Test::AMI_AMI_BufferingExceptionHolder *holde } void -Reply_Handler::sync (CORBA::Environment &) +Reply_Handler::sync (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { } void -Reply_Handler::sync_excep (Test::AMI_AMI_BufferingExceptionHolder *holder, - CORBA::Environment &ACE_TRY_ENV) +Reply_Handler::sync_excep (Test::AMI_AMI_BufferingExceptionHolder *holder + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_TRY { - holder->raise_sync (ACE_TRY_ENV); + holder->raise_sync (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -58,19 +58,19 @@ Reply_Handler::sync_excep (Test::AMI_AMI_BufferingExceptionHolder *holder, } void -Reply_Handler::shutdown (CORBA::Environment &) +Reply_Handler::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { } void -Reply_Handler::shutdown_excep (Test::AMI_AMI_BufferingExceptionHolder *holder, - CORBA::Environment &ACE_TRY_ENV) +Reply_Handler::shutdown_excep (Test::AMI_AMI_BufferingExceptionHolder *holder + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_TRY { - holder->raise_shutdown (ACE_TRY_ENV); + holder->raise_shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/AMI_Buffering/Reply_Handler.h b/TAO/tests/AMI_Buffering/Reply_Handler.h index ee0d2665340..fe3b6df4fab 100644 --- a/TAO/tests/AMI_Buffering/Reply_Handler.h +++ b/TAO/tests/AMI_Buffering/Reply_Handler.h @@ -25,22 +25,22 @@ public: Reply_Handler (void); // = The skeleton methods - virtual void receive_data (CORBA::Environment &ACE_TRY_ENV) + virtual void receive_data (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void receive_data_excep (Test::AMI_AMI_BufferingExceptionHolder *holder, - CORBA::Environment &ACE_TRY_ENV) + virtual void receive_data_excep (Test::AMI_AMI_BufferingExceptionHolder *holder + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void sync (CORBA::Environment &ACE_TRY_ENV) + virtual void sync (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void sync_excep (Test::AMI_AMI_BufferingExceptionHolder *holder, - CORBA::Environment &ACE_TRY_ENV) + virtual void sync_excep (Test::AMI_AMI_BufferingExceptionHolder *holder + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown_excep (Test::AMI_AMI_BufferingExceptionHolder *holder, - CORBA::Environment &ACE_TRY_ENV) + virtual void shutdown_excep (Test::AMI_AMI_BufferingExceptionHolder *holder + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); }; diff --git a/TAO/tests/AMI_Buffering/admin.cpp b/TAO/tests/AMI_Buffering/admin.cpp index 8f6e82d3b48..e9dc9dfbe62 100644 --- a/TAO/tests/AMI_Buffering/admin.cpp +++ b/TAO/tests/AMI_Buffering/admin.cpp @@ -17,14 +17,14 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -39,15 +39,15 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (root_poa.in ())) @@ -56,7 +56,7 @@ main (int argc, char *argv[]) 1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -69,11 +69,11 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var owner_transfer(AMI_buffering_admin_impl); Test::AMI_Buffering_Admin_var AMI_buffering_admin = - AMI_buffering_admin_impl->_this (ACE_TRY_ENV); + AMI_buffering_admin_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (AMI_buffering_admin.in (), ACE_TRY_ENV); + orb->object_to_string (AMI_buffering_admin.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -86,18 +86,18 @@ main (int argc, char *argv[]) ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "(%P|%t) admin - event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/AMI_Buffering/client.cpp b/TAO/tests/AMI_Buffering/client.cpp index f7d910eabf8..cc3efc9f4ab 100644 --- a/TAO/tests/AMI_Buffering/client.cpp +++ b/TAO/tests/AMI_Buffering/client.cpp @@ -88,25 +88,25 @@ parse_args (int argc, char *argv[]) int run_message_count (CORBA::ORB_ptr orb, Test::AMI_Buffering_ptr ami_buffering, - Test::AMI_Buffering_Admin_ptr ami_buffering_admin, - CORBA::Environment &ACE_TRY_ENV); + Test::AMI_Buffering_Admin_ptr ami_buffering_admin + TAO_ENV_ARG_DECL); int run_timeout (CORBA::ORB_ptr orb, Test::AMI_Buffering_ptr ami_buffering, - Test::AMI_Buffering_Admin_ptr ami_buffering_admin, - CORBA::Environment &ACE_TRY_ENV); + Test::AMI_Buffering_Admin_ptr ami_buffering_admin + TAO_ENV_ARG_DECL); int run_timeout_reactive (CORBA::ORB_ptr orb, Test::AMI_Buffering_ptr oneway_buffering, - Test::AMI_Buffering_Admin_ptr oneway_buffering_admin, - CORBA::Environment &ACE_TRY_ENV); + Test::AMI_Buffering_Admin_ptr oneway_buffering_admin + TAO_ENV_ARG_DECL); int run_buffer_size (CORBA::ORB_ptr orb, Test::AMI_Buffering_ptr ami_buffering, - Test::AMI_Buffering_Admin_ptr ami_buffering_admin, - CORBA::Environment &ACE_TRY_ENV); + Test::AMI_Buffering_Admin_ptr ami_buffering_admin + TAO_ENV_ARG_DECL); int main (int argc, char *argv[]) @@ -115,15 +115,15 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (root_poa.in ())) @@ -132,21 +132,21 @@ main (int argc, char *argv[]) 1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = - orb->string_to_object(server_ior, ACE_TRY_ENV); + orb->string_to_object(server_ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::AMI_Buffering_var ami_buffering = - Test::AMI_Buffering::_narrow(tmp.in (), ACE_TRY_ENV); + Test::AMI_Buffering::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (ami_buffering.in ())) @@ -158,11 +158,11 @@ main (int argc, char *argv[]) } tmp = - orb->string_to_object(admin_ior, ACE_TRY_ENV); + orb->string_to_object(admin_ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::AMI_Buffering_Admin_var ami_buffering_admin = - Test::AMI_Buffering_Admin::_narrow(tmp.in (), ACE_TRY_ENV); + Test::AMI_Buffering_Admin::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (ami_buffering_admin.in ())) @@ -186,8 +186,8 @@ main (int argc, char *argv[]) test_failed = run_message_count (orb.in (), ami_buffering.in (), - ami_buffering_admin.in (), - ACE_TRY_ENV); + ami_buffering_admin.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } else if (run_timeout_test) @@ -197,8 +197,8 @@ main (int argc, char *argv[]) test_failed = run_timeout (orb.in (), ami_buffering.in (), - ami_buffering_admin.in (), - ACE_TRY_ENV); + ami_buffering_admin.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } else if (run_timeout_reactive_test) @@ -208,8 +208,8 @@ main (int argc, char *argv[]) test_failed = run_timeout_reactive (orb.in (), ami_buffering.in (), - ami_buffering_admin.in (), - ACE_TRY_ENV); + ami_buffering_admin.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } else if (run_buffer_size_test) @@ -219,8 +219,8 @@ main (int argc, char *argv[]) test_failed = run_buffer_size (orb.in (), ami_buffering.in (), - ami_buffering_admin.in (), - ACE_TRY_ENV); + ami_buffering_admin.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } else @@ -233,16 +233,16 @@ main (int argc, char *argv[]) client_task.thr_mgr ()->wait (); - ami_buffering->shutdown (ACE_TRY_ENV); + ami_buffering->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - ami_buffering_admin->shutdown (ACE_TRY_ENV); + ami_buffering_admin->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -260,15 +260,15 @@ int configure_policies (CORBA::ORB_ptr orb, const TAO::BufferingConstraint &buffering_constraint, Test::AMI_Buffering_ptr ami_buffering, - Test::AMI_Buffering_out flusher, - CORBA::Environment &ACE_TRY_ENV) + Test::AMI_Buffering_out flusher + TAO_ENV_ARG_DECL) { CORBA::Object_var object = - orb->resolve_initial_references ("PolicyCurrent", ACE_TRY_ENV); + orb->resolve_initial_references ("PolicyCurrent" TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::PolicyCurrent_var policy_current = - CORBA::PolicyCurrent::_narrow (object.in (), ACE_TRY_ENV); + CORBA::PolicyCurrent::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (CORBA::is_nil (policy_current.in ())) @@ -285,22 +285,22 @@ configure_policies (CORBA::ORB_ptr orb, CORBA::PolicyList policies (2); policies.length (2); policies[0] = orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE, - scope_as_any, - ACE_TRY_ENV); + scope_as_any + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); policies[1] = orb->create_policy (TAO::BUFFERING_CONSTRAINT_POLICY_TYPE, - buffering_as_any, - ACE_TRY_ENV); + buffering_as_any + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); - policy_current->set_policy_overrides (policies, CORBA::ADD_OVERRIDE, - ACE_TRY_ENV); + policy_current->set_policy_overrides (policies, CORBA::ADD_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); - policies[0]->destroy (ACE_TRY_ENV); + policies[0]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); - policies[1]->destroy (ACE_TRY_ENV); + policies[1]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); TAO::BufferingConstraint flush_constraint; @@ -313,21 +313,21 @@ configure_policies (CORBA::ORB_ptr orb, policies.length (1); policies[0] = orb->create_policy (TAO::BUFFERING_CONSTRAINT_POLICY_TYPE, - buffering_as_any, - ACE_TRY_ENV); + buffering_as_any + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); object = ami_buffering->_set_policy_overrides (policies, - CORBA::ADD_OVERRIDE, - ACE_TRY_ENV); + CORBA::ADD_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); - policies[0]->destroy (ACE_TRY_ENV); + policies[0]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); flusher = - Test::AMI_Buffering::_narrow (object.in (), ACE_TRY_ENV); + Test::AMI_Buffering::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); return 0; @@ -335,18 +335,18 @@ configure_policies (CORBA::ORB_ptr orb, void sync_server (CORBA::ORB_ptr orb, - Test::AMI_Buffering_ptr flusher, - CORBA::Environment &ACE_TRY_ENV) + Test::AMI_Buffering_ptr flusher + TAO_ENV_ARG_DECL) { // Get back in sync with the server... - flusher->flush (ACE_TRY_ENV); + flusher->flush (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; - flusher->sync (ACE_TRY_ENV); + flusher->sync (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; // Drain responses from the queue ACE_Time_Value tv (0, 100000); - orb->run (tv, ACE_TRY_ENV); + orb->run (tv TAO_ENV_ARG_PARAMETER); ACE_CHECK; } @@ -355,18 +355,18 @@ run_liveness_test (CORBA::ORB_ptr orb, Test::AMI_AMI_BufferingHandler_ptr reply_handler, Test::AMI_Buffering_ptr ami_buffering, Test::AMI_Buffering_ptr flusher, - Test::AMI_Buffering_Admin_ptr ami_buffering_admin, - CORBA::Environment &ACE_TRY_ENV) + Test::AMI_Buffering_Admin_ptr ami_buffering_admin + TAO_ENV_ARG_DECL) { ACE_DEBUG ((LM_DEBUG, ".... checking for liveness\n")); int test_failed = 0; // Get back in sync with the server... - sync_server (orb, flusher, ACE_TRY_ENV); + sync_server (orb, flusher TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::ULong send_count = - ami_buffering_admin->request_count (ACE_TRY_ENV); + ami_buffering_admin->request_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); int liveness_test_iterations = int(send_count); @@ -380,13 +380,13 @@ run_liveness_test (CORBA::ORB_ptr orb, for (int i = 0; i != liveness_test_iterations; ++i) { ami_buffering->sendc_receive_data (reply_handler, - payload, - ACE_TRY_ENV); + payload + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); send_count++; CORBA::ULong receive_count = - ami_buffering_admin->request_count (ACE_TRY_ENV); + ami_buffering_admin->request_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Once the system has sent enough messages we don't @@ -404,13 +404,13 @@ run_liveness_test (CORBA::ORB_ptr orb, "expected %u\n", i, receive_count, expected)); - sync_server (orb, flusher, ACE_TRY_ENV); + sync_server (orb, flusher TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); } if (depth++ == LIVENESS_MAX_DEPTH) { - sync_server (orb, flusher, ACE_TRY_ENV); + sync_server (orb, flusher TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); depth = 0; @@ -423,8 +423,8 @@ run_liveness_test (CORBA::ORB_ptr orb, int run_message_count (CORBA::ORB_ptr orb, Test::AMI_Buffering_ptr ami_buffering, - Test::AMI_Buffering_Admin_ptr ami_buffering_admin, - CORBA::Environment &ACE_TRY_ENV) + Test::AMI_Buffering_Admin_ptr ami_buffering_admin + TAO_ENV_ARG_DECL) { TAO::BufferingConstraint buffering_constraint; buffering_constraint.mode = TAO::BUFFER_MESSAGE_COUNT; @@ -435,8 +435,8 @@ run_message_count (CORBA::ORB_ptr orb, Test::AMI_Buffering_var flusher; int test_failed = configure_policies (orb, buffering_constraint, - ami_buffering, flusher.out (), - ACE_TRY_ENV); + ami_buffering, flusher.out () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (test_failed != 0) @@ -454,17 +454,17 @@ run_message_count (CORBA::ORB_ptr orb, PortableServer::ServantBase_var owner_transfer(reply_handler_impl); Test::AMI_AMI_BufferingHandler_var reply_handler = - reply_handler_impl->_this (ACE_TRY_ENV); + reply_handler_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::ULong send_count = 0; for (int i = 0; i != iterations; ++i) { - sync_server (orb, flusher.in (), ACE_TRY_ENV); + sync_server (orb, flusher.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::ULong initial_receive_count = - ami_buffering_admin->request_count (ACE_TRY_ENV); + ami_buffering_admin->request_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (initial_receive_count != send_count) @@ -478,13 +478,13 @@ run_message_count (CORBA::ORB_ptr orb, while (1) { ami_buffering->sendc_receive_data (reply_handler.in (), - payload, - ACE_TRY_ENV); + payload + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); send_count++; CORBA::ULong receive_count = - ami_buffering_admin->request_count (ACE_TRY_ENV); + ami_buffering_admin->request_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::ULong iteration_count = @@ -523,8 +523,8 @@ run_message_count (CORBA::ORB_ptr orb, reply_handler.in (), ami_buffering, flusher.in (), - ami_buffering_admin, - ACE_TRY_ENV); + ami_buffering_admin + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (liveness_test_failed) @@ -536,8 +536,8 @@ run_message_count (CORBA::ORB_ptr orb, int run_timeout (CORBA::ORB_ptr orb, Test::AMI_Buffering_ptr ami_buffering, - Test::AMI_Buffering_Admin_ptr ami_buffering_admin, - CORBA::Environment &ACE_TRY_ENV) + Test::AMI_Buffering_Admin_ptr ami_buffering_admin + TAO_ENV_ARG_DECL) { TAO::BufferingConstraint buffering_constraint; buffering_constraint.mode = TAO::BUFFER_TIMEOUT; @@ -548,8 +548,8 @@ run_timeout (CORBA::ORB_ptr orb, Test::AMI_Buffering_var flusher; int test_failed = configure_policies (orb, buffering_constraint, - ami_buffering, flusher.out (), - ACE_TRY_ENV); + ami_buffering, flusher.out () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (test_failed != 0) @@ -567,17 +567,17 @@ run_timeout (CORBA::ORB_ptr orb, PortableServer::ServantBase_var owner_transfer(reply_handler_impl); Test::AMI_AMI_BufferingHandler_var reply_handler = - reply_handler_impl->_this (ACE_TRY_ENV); + reply_handler_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::ULong send_count = 0; for (int i = 0; i != iterations; ++i) { - sync_server (orb, flusher.in (), ACE_TRY_ENV); + sync_server (orb, flusher.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::ULong initial_receive_count = - ami_buffering_admin->request_count (ACE_TRY_ENV); + ami_buffering_admin->request_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (initial_receive_count != send_count) @@ -592,13 +592,13 @@ run_timeout (CORBA::ORB_ptr orb, while (1) { ami_buffering->sendc_receive_data (reply_handler.in (), - payload, - ACE_TRY_ENV); + payload + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); send_count++; CORBA::ULong receive_count = - ami_buffering_admin->request_count (ACE_TRY_ENV); + ami_buffering_admin->request_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_Time_Value elapsed = ACE_OS::gettimeofday () - start; @@ -637,8 +637,8 @@ run_timeout (CORBA::ORB_ptr orb, reply_handler.in (), ami_buffering, flusher.in (), - ami_buffering_admin, - ACE_TRY_ENV); + ami_buffering_admin + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (liveness_test_failed) @@ -650,8 +650,8 @@ run_timeout (CORBA::ORB_ptr orb, int run_timeout_reactive (CORBA::ORB_ptr orb, Test::AMI_Buffering_ptr ami_buffering, - Test::AMI_Buffering_Admin_ptr ami_buffering_admin, - CORBA::Environment &ACE_TRY_ENV) + Test::AMI_Buffering_Admin_ptr ami_buffering_admin + TAO_ENV_ARG_DECL) { TAO::BufferingConstraint buffering_constraint; buffering_constraint.mode = TAO::BUFFER_TIMEOUT; @@ -662,8 +662,8 @@ run_timeout_reactive (CORBA::ORB_ptr orb, Test::AMI_Buffering_var flusher; int test_failed = configure_policies (orb, buffering_constraint, - ami_buffering, flusher.out (), - ACE_TRY_ENV); + ami_buffering, flusher.out () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (test_failed != 0) @@ -681,17 +681,17 @@ run_timeout_reactive (CORBA::ORB_ptr orb, PortableServer::ServantBase_var owner_transfer(reply_handler_impl); Test::AMI_AMI_BufferingHandler_var reply_handler = - reply_handler_impl->_this (ACE_TRY_ENV); + reply_handler_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::ULong send_count = 0; for (int i = 0; i != iterations; ++i) { - sync_server (orb, flusher.in (), ACE_TRY_ENV); + sync_server (orb, flusher.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::ULong initial_receive_count = - ami_buffering_admin->request_count (ACE_TRY_ENV); + ami_buffering_admin->request_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (initial_receive_count != send_count) @@ -706,19 +706,19 @@ run_timeout_reactive (CORBA::ORB_ptr orb, for (int j = 0; j != 20; ++j) { ami_buffering->sendc_receive_data (reply_handler.in (), - payload, - ACE_TRY_ENV); + payload + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); send_count++; } while (1) { CORBA::ULong receive_count = - ami_buffering_admin->request_count (ACE_TRY_ENV); + ami_buffering_admin->request_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_Time_Value sleep (0, 10000); - orb->run (sleep, ACE_TRY_ENV); + orb->run (sleep TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_Time_Value elapsed = ACE_OS::gettimeofday () - start; @@ -758,8 +758,8 @@ run_timeout_reactive (CORBA::ORB_ptr orb, reply_handler.in (), ami_buffering, flusher.in (), - ami_buffering_admin, - ACE_TRY_ENV); + ami_buffering_admin + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (liveness_test_failed) @@ -773,8 +773,8 @@ run_timeout_reactive (CORBA::ORB_ptr orb, int run_buffer_size (CORBA::ORB_ptr orb, Test::AMI_Buffering_ptr ami_buffering, - Test::AMI_Buffering_Admin_ptr ami_buffering_admin, - CORBA::Environment &ACE_TRY_ENV) + Test::AMI_Buffering_Admin_ptr ami_buffering_admin + TAO_ENV_ARG_DECL) { TAO::BufferingConstraint buffering_constraint; buffering_constraint.mode = TAO::BUFFER_MESSAGE_BYTES; @@ -785,8 +785,8 @@ run_buffer_size (CORBA::ORB_ptr orb, Test::AMI_Buffering_var flusher; int test_failed = configure_policies (orb, buffering_constraint, - ami_buffering, flusher.out (), - ACE_TRY_ENV); + ami_buffering, flusher.out () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (test_failed != 0) @@ -802,17 +802,17 @@ run_buffer_size (CORBA::ORB_ptr orb, PortableServer::ServantBase_var owner_transfer(reply_handler_impl); Test::AMI_AMI_BufferingHandler_var reply_handler = - reply_handler_impl->_this (ACE_TRY_ENV); + reply_handler_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::ULong bytes_sent = 0; for (int i = 0; i != iterations; ++i) { - sync_server (orb, flusher.in (), ACE_TRY_ENV); + sync_server (orb, flusher.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::ULong initial_bytes_received = - ami_buffering_admin->bytes_received_count (ACE_TRY_ENV); + ami_buffering_admin->bytes_received_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (initial_bytes_received != bytes_sent) @@ -826,13 +826,13 @@ run_buffer_size (CORBA::ORB_ptr orb, while (1) { ami_buffering->sendc_receive_data (reply_handler.in (), - payload, - ACE_TRY_ENV); + payload + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); bytes_sent += PAYLOAD_LENGTH; CORBA::ULong bytes_received = - ami_buffering_admin->bytes_received_count (ACE_TRY_ENV); + ami_buffering_admin->bytes_received_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::ULong payload_delta = @@ -876,8 +876,8 @@ run_buffer_size (CORBA::ORB_ptr orb, reply_handler.in (), ami_buffering, flusher.in (), - ami_buffering_admin, - ACE_TRY_ENV); + ami_buffering_admin + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (liveness_test_failed) diff --git a/TAO/tests/AMI_Buffering/server.cpp b/TAO/tests/AMI_Buffering/server.cpp index 17d74cb83b5..5403607d06d 100644 --- a/TAO/tests/AMI_Buffering/server.cpp +++ b/TAO/tests/AMI_Buffering/server.cpp @@ -18,19 +18,19 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case 'k': - ior = get_opts.optarg; - break; + ior = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile> " - "-k <ior> " + "-o <iorfile> " + "-k <ior> " "\n", argv [0]), -1); @@ -45,15 +45,15 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (root_poa.in ())) @@ -62,18 +62,18 @@ main (int argc, char *argv[]) 1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = - orb->string_to_object(ior, ACE_TRY_ENV); + orb->string_to_object(ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::AMI_Buffering_Admin_var admin = - Test::AMI_Buffering_Admin::_narrow(tmp.in (), ACE_TRY_ENV); + Test::AMI_Buffering_Admin::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (admin.in ())) @@ -92,11 +92,11 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var owner_transfer(AMI_buffering_impl); Test::AMI_Buffering_var AMI_buffering = - AMI_buffering_impl->_this (ACE_TRY_ENV); + AMI_buffering_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (AMI_buffering.in (), ACE_TRY_ENV); + orb->object_to_string (AMI_buffering.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -109,18 +109,18 @@ main (int argc, char *argv[]) ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/AMI_Timeouts/client.cpp b/TAO/tests/AMI_Timeouts/client.cpp index 4bdbefc4816..00c680e2009 100644 --- a/TAO/tests/AMI_Timeouts/client.cpp +++ b/TAO/tests/AMI_Timeouts/client.cpp @@ -65,22 +65,22 @@ parse_args (int argc, char *argv[]) int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; TimeoutObj_var timeout_var = - TimeoutObj::_narrow (object.in (), ACE_TRY_ENV); + TimeoutObj::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (timeout_var.in ())) @@ -94,7 +94,7 @@ main (int argc, char *argv[]) // Activate POA to handle the call back. CORBA::Object_var poa_object = - orb->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -103,21 +103,21 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Instantiate reply handler TimeoutHandler_i timeoutHandler_i; AMI_TimeoutObjHandler_var timeoutHandler_var = - timeoutHandler_i._this (ACE_TRY_ENV); + timeoutHandler_i._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Instantiate client @@ -130,19 +130,19 @@ main (int argc, char *argv[]) client.activate (); // ORB loop. - orb->run (ACE_TRY_ENV); // Fetch responses + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); // Fetch responses ACE_TRY_CHECK; root_poa->destroy (1, // ethernalize objects - 0, // wait for completion - ACE_TRY_ENV); + 0 // wait for completion + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Wait for all the threads to finish before destroying the // ORB. (void) client.thr_mgr ()->wait (); - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "ORB finished\n")); diff --git a/TAO/tests/AMI_Timeouts/server.cpp b/TAO/tests/AMI_Timeouts/server.cpp index 079b039edd2..c5185d188f0 100644 --- a/TAO/tests/AMI_Timeouts/server.cpp +++ b/TAO/tests/AMI_Timeouts/server.cpp @@ -56,15 +56,15 @@ parse_args (int argc, char *argv[]) int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -73,11 +73,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -86,11 +86,11 @@ main (int argc, char *argv[]) Timeout_i timeout_i (orb.in ()); TimeoutObj_var timeout_var = - timeout_i._this (ACE_TRY_ENV); + timeout_i._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (timeout_var.in (), ACE_TRY_ENV); + orb->object_to_string (timeout_var.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); @@ -108,14 +108,14 @@ main (int argc, char *argv[]) ACE_OS::fclose (output_file); } - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Instantiate reply handler TimeoutHandler_i timeoutHandler_i; AMI_TimeoutObjHandler_var timeoutHandler_var = - timeoutHandler_i._this (ACE_TRY_ENV); + timeoutHandler_i._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Instantiate client @@ -128,18 +128,18 @@ main (int argc, char *argv[]) client->activate (); */ - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); root_poa->destroy (1, // ethernalize objects - 0, // wait for completion - ACE_TRY_ENV); + 0 // wait for completion + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; //delete client; diff --git a/TAO/tests/AMI_Timeouts/timeout_client.cpp b/TAO/tests/AMI_Timeouts/timeout_client.cpp index a21066e3ae9..a8b55d47f0b 100644 --- a/TAO/tests/AMI_Timeouts/timeout_client.cpp +++ b/TAO/tests/AMI_Timeouts/timeout_client.cpp @@ -44,7 +44,7 @@ TimeoutClient::svc () { this->initialize (); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { @@ -61,14 +61,14 @@ TimeoutClient::svc () this->none_test (); // shut down remote ORB - timeoutObject_->shutdown (ACE_TRY_ENV); + timeoutObject_->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_Time_Value tv (0, 20); // wait for the ORB to deliver the shutdonw ACE_OS::sleep (tv); // shut down local ORB - orb_->shutdown (0, ACE_TRY_ENV); + orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -87,16 +87,16 @@ TimeoutClient::svc () int TimeoutClient::initialize () { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { CORBA::Object_var object = - orb_->resolve_initial_references ("ORBPolicyManager", - ACE_TRY_ENV); + orb_->resolve_initial_references ("ORBPolicyManager" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; policy_manager_ = - CORBA::PolicyManager::_narrow (object.in (), ACE_TRY_ENV); + CORBA::PolicyManager::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -131,7 +131,7 @@ TimeoutClient::send (CORBA::Boolean async, CORBA::PolicyList policy_list (1); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY_EX (normal) { if (local_timeout != 0) @@ -144,21 +144,21 @@ TimeoutClient::send (CORBA::Boolean async, policy_list.length (1); policy_list[0] = orb_->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE, - any_orb, - ACE_TRY_ENV); + any_orb + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK_EX (normal); policy_manager_->set_policy_overrides (policy_list, - CORBA::SET_OVERRIDE, - ACE_TRY_ENV); + CORBA::SET_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK_EX (normal); } else { policy_list.length (0); policy_manager_->set_policy_overrides (policy_list, - CORBA::SET_OVERRIDE, - ACE_TRY_ENV); + CORBA::SET_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK_EX (normal); } @@ -169,13 +169,13 @@ TimeoutClient::send (CORBA::Boolean async, if (async) { timeoutObject_->sendc_sendTimeToWait (replyHandlerObject_.in (), - remote_sleep, - ACE_TRY_ENV); + remote_sleep + TAO_ENV_ARG_PARAMETER); } else // synch { - timeoutObject_->sendTimeToWait (remote_sleep, - ACE_TRY_ENV); + timeoutObject_->sendTimeToWait (remote_sleep + TAO_ENV_ARG_PARAMETER); } ACE_TRY_CHECK_EX (normal); } @@ -196,7 +196,7 @@ TimeoutClient::send (CORBA::Boolean async, { if (local_timeout != 0) { - policy_list[0]->destroy (ACE_TRY_ENV); + policy_list[0]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK_EX (cleanup); } } diff --git a/TAO/tests/AMI_Timeouts/timeout_i.cpp b/TAO/tests/AMI_Timeouts/timeout_i.cpp index 0d7e432d147..45727ec7e6f 100644 --- a/TAO/tests/AMI_Timeouts/timeout_i.cpp +++ b/TAO/tests/AMI_Timeouts/timeout_i.cpp @@ -29,8 +29,8 @@ Timeout_i::~Timeout_i () } void -Timeout_i::sendTimeToWait (CORBA::Long msec, - CORBA::Environment &) +Timeout_i::sendTimeToWait (CORBA::Long msec + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { //ACE_DEBUG ((LM_DEBUG, @@ -48,7 +48,7 @@ Timeout_i::sendTimeToWait (CORBA::Long msec, } void -Timeout_i::shutdown (CORBA::Environment &) +Timeout_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { orb_->shutdown (); @@ -72,7 +72,7 @@ TimeoutHandler_i::~TimeoutHandler_i () } void -TimeoutHandler_i::sendTimeToWait (CORBA::Environment &) +TimeoutHandler_i::sendTimeToWait (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -82,15 +82,15 @@ TimeoutHandler_i::sendTimeToWait (CORBA::Environment &) } void -TimeoutHandler_i::sendTimeToWait_excep (AMI_TimeoutObjExceptionHolder *excep_holder, - CORBA::Environment &ACE_TRY_ENV) +TimeoutHandler_i::sendTimeToWait_excep (AMI_TimeoutObjExceptionHolder *excep_holder + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { timer_.stop (); ACE_TRY { - excep_holder->raise_sendTimeToWait (ACE_TRY_ENV); + excep_holder->raise_sendTimeToWait (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (CORBA::TIMEOUT, timeout) diff --git a/TAO/tests/AMI_Timeouts/timeout_i.h b/TAO/tests/AMI_Timeouts/timeout_i.h index 65fe528ca2a..0b2742dac01 100644 --- a/TAO/tests/AMI_Timeouts/timeout_i.h +++ b/TAO/tests/AMI_Timeouts/timeout_i.h @@ -32,11 +32,11 @@ public: ~Timeout_i (); - virtual void sendTimeToWait (CORBA::Long msec, - CORBA::Environment &ACE_TRY_ENV) + virtual void sendTimeToWait (CORBA::Long msec + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: @@ -52,12 +52,12 @@ public: ~TimeoutHandler_i (); - virtual void sendTimeToWait (CORBA::Environment &ACE_TRY_ENV) + virtual void sendTimeToWait (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual void sendTimeToWait_excep ( - AMI_TimeoutObjExceptionHolder * excep_holder, - CORBA::Environment &ACE_TRY_ENV) + AMI_TimeoutObjExceptionHolder * excep_holder + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); void reset_reply_counter (); diff --git a/TAO/tests/BiDirectional/client.cpp b/TAO/tests/BiDirectional/client.cpp index 84c252190bc..cdc63d41f5e 100644 --- a/TAO/tests/BiDirectional/client.cpp +++ b/TAO/tests/BiDirectional/client.cpp @@ -44,11 +44,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -57,11 +57,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Policies for the childPOA to be created. @@ -72,8 +72,8 @@ main (int argc, char *argv[]) pol <<= BiDirPolicy::BOTH; policies[0] = orb->create_policy (BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE, - pol, - ACE_TRY_ENV); + pol + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Create POA as child of RootPOA with the above policies. This POA @@ -82,8 +82,8 @@ main (int argc, char *argv[]) PortableServer::POA_var child_poa = root_poa->create_POA ("childPOA", poa_manager.in (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Creation of childPOA is over. Destroy the Policy objects. @@ -91,22 +91,22 @@ main (int argc, char *argv[]) i < policies.length (); ++i) { - policies[i]->destroy (ACE_TRY_ENV); + policies[i]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Simple_Server_var server = - Simple_Server::_narrow (object.in (), ACE_TRY_ENV); + Simple_Server::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -121,17 +121,17 @@ main (int argc, char *argv[]) Callback_i callback_impl (orb.in ()); Callback_var callback = - callback_impl._this (ACE_TRY_ENV); + callback_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Send the calback object to the server - server->callback_object (callback.in (), - ACE_TRY_ENV); + server->callback_object (callback.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // A method to kickstart callbacks from the server CORBA::Long r = - server->test_method (1, ACE_TRY_ENV); + server->test_method (1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (r != 0) @@ -141,17 +141,17 @@ main (int argc, char *argv[]) r)); } - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY { ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Catched exception:"); + "Caught exception:"); return 1; } ACE_ENDTRY; diff --git a/TAO/tests/BiDirectional/server.cpp b/TAO/tests/BiDirectional/server.cpp index 0999d896458..17934fa1b42 100644 --- a/TAO/tests/BiDirectional/server.cpp +++ b/TAO/tests/BiDirectional/server.cpp @@ -44,11 +44,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -57,11 +57,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Policies for the childPOA to be created. @@ -72,8 +72,8 @@ main (int argc, char *argv[]) pol <<= BiDirPolicy::BOTH; policies[0] = orb->create_policy (BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE, - pol, - ACE_TRY_ENV); + pol + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Create POA as child of RootPOA with the above policies. This POA @@ -82,8 +82,8 @@ main (int argc, char *argv[]) PortableServer::POA_var child_poa = root_poa->create_POA ("childPOA", poa_manager.in (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Creation of childPOA is over. Destroy the Policy objects. @@ -91,11 +91,11 @@ main (int argc, char *argv[]) i < policies.length (); ++i) { - policies[i]->destroy (ACE_TRY_ENV); + policies[i]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -108,17 +108,17 @@ main (int argc, char *argv[]) PortableServer::string_to_ObjectId ("simple_server"); child_poa->activate_object_with_id (id.in (), - &server_impl, - ACE_TRY_ENV); + &server_impl + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var obj = - child_poa->id_to_reference (id.in (), - ACE_TRY_ENV); + child_poa->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (obj.in (), ACE_TRY_ENV); + orb->object_to_string (obj.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); @@ -141,27 +141,27 @@ main (int argc, char *argv[]) { // Please see the README file on why this is being done CORBA::Boolean pending = - orb->work_pending(ACE_TRY_ENV); + orb->work_pending(TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (pending) { - orb->perform_work(ACE_TRY_ENV); + orb->perform_work(TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } - retval = server_impl.call_client (ACE_TRY_ENV); + retval = server_impl.call_client (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY { ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Catched exception:"); + "Caught exception:"); return 1; } ACE_ENDTRY; diff --git a/TAO/tests/BiDirectional/test_i.cpp b/TAO/tests/BiDirectional/test_i.cpp index 09776957239..e0afb927c2c 100644 --- a/TAO/tests/BiDirectional/test_i.cpp +++ b/TAO/tests/BiDirectional/test_i.cpp @@ -14,15 +14,15 @@ ACE_RCSID(BiDirectional, test_i, "$Id$") void -Callback_i::shutdown (CORBA::Environment &ACE_TRY_ENV) +Callback_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "Performing clean shutdown\n")); - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } void -Callback_i::callback_method (CORBA::Environment & /*ACE_TRY_ENV*/) +Callback_i::callback_method (TAO_ENV_SINGLE_ARG_DECL_NOT_USED /*TAO_ENV_SINGLE_ARG_PARAMETER*/) ACE_THROW_SPEC ((CORBA::SystemException)) { if (TAO_debug_level > 0) @@ -33,8 +33,8 @@ Callback_i::callback_method (CORBA::Environment & /*ACE_TRY_ENV*/) // **************************************************************** CORBA::Long -Simple_Server_i::test_method (CORBA::Boolean do_callback, - CORBA::Environment& ) +Simple_Server_i::test_method (CORBA::Boolean do_callback + TAO_ENV_ARG_DECL_NOT_USED ) ACE_THROW_SPEC ((CORBA::SystemException)) { if (do_callback) @@ -46,8 +46,8 @@ Simple_Server_i::test_method (CORBA::Boolean do_callback, } void -Simple_Server_i::callback_object (Callback_ptr callback, - CORBA::Environment& ) +Simple_Server_i::callback_object (Callback_ptr callback + TAO_ENV_ARG_DECL_NOT_USED ) ACE_THROW_SPEC ((CORBA::SystemException)) { // Store the callback object @@ -55,13 +55,13 @@ Simple_Server_i::callback_object (Callback_ptr callback, } int -Simple_Server_i::call_client (CORBA::Environment &ACE_TRY_ENV) +Simple_Server_i::call_client (TAO_ENV_SINGLE_ARG_DECL) { if (this->flag_) { for (int times = 0; times < this->no_iterations_; ++times) { - this->callback_->callback_method (ACE_TRY_ENV); + this->callback_->callback_method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (0); if (this->orb_->orb_core ()->lane_resources ().transport_cache ().current_size () > 1) @@ -73,7 +73,7 @@ Simple_Server_i::call_client (CORBA::Environment &ACE_TRY_ENV) } } - this->callback_->shutdown (ACE_TRY_ENV); + this->callback_->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (0); this->flag_ = 0; @@ -85,8 +85,8 @@ Simple_Server_i::call_client (CORBA::Environment &ACE_TRY_ENV) void -Simple_Server_i::shutdown (CORBA::Environment& ACE_TRY_ENV) +Simple_Server_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/BiDirectional/test_i.h b/TAO/tests/BiDirectional/test_i.h index 3ae9010bbcd..6dbdd7c79a5 100644 --- a/TAO/tests/BiDirectional/test_i.h +++ b/TAO/tests/BiDirectional/test_i.h @@ -31,11 +31,11 @@ public: Callback_i (CORBA::ORB_ptr orb); // ctor - void shutdown (CORBA::Environment &ACE_TRY_ENV) + void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // Safe way to shutdown - void callback_method (CORBA::Environment &ACE_TRY_ENV) + void callback_method (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // The callback method @@ -58,18 +58,18 @@ public: // ctor // = The Simple_Server methods. - CORBA::Long test_method (CORBA::Boolean do_callback, - CORBA::Environment&) + CORBA::Long test_method (CORBA::Boolean do_callback + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void callback_object (Callback_ptr callback, - CORBA::Environment&) + void callback_object (Callback_ptr callback + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - int call_client (CORBA::Environment&); + int call_client (TAO_ENV_SINGLE_ARG_DECL_NOT_USED); private: CORBA::ORB_var orb_; diff --git a/TAO/tests/BiDirectional_NestedUpcall/client.cpp b/TAO/tests/BiDirectional_NestedUpcall/client.cpp index 4bf70bbfd06..2fed8b8707f 100644 --- a/TAO/tests/BiDirectional_NestedUpcall/client.cpp +++ b/TAO/tests/BiDirectional_NestedUpcall/client.cpp @@ -45,11 +45,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -58,11 +58,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Policies for the childPOA to be created. @@ -73,8 +73,8 @@ main (int argc, char *argv[]) pol <<= BiDirPolicy::BOTH; policies[0] = orb->create_policy (BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE, - pol, - ACE_TRY_ENV); + pol + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Create POA as child of RootPOA with the above policies. This POA @@ -83,8 +83,8 @@ main (int argc, char *argv[]) PortableServer::POA_var child_poa = root_poa->create_POA ("childPOA", poa_manager.in (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Creation of childPOA is over. Destroy the Policy objects. @@ -92,22 +92,22 @@ main (int argc, char *argv[]) i < policies.length (); ++i) { - policies[i]->destroy (ACE_TRY_ENV); + policies[i]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Simple_Server_var server = - Simple_Server::_narrow (object.in (), ACE_TRY_ENV); + Simple_Server::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -120,24 +120,24 @@ main (int argc, char *argv[]) Callback_i *callback_impl = 0; ACE_NEW_THROW_EX (callback_impl, - Callback_i (orb.in ()), - CORBA::NO_MEMORY ()); - + Callback_i (orb.in ()), + CORBA::NO_MEMORY ()); + PortableServer::ServantBase_var owner_transfer(callback_impl); - + Callback_var callback = - callback_impl->_this (ACE_TRY_ENV); + callback_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - + // Send the calback object to the server - server->callback_object (callback.in (), - ACE_TRY_ENV); + server->callback_object (callback.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Call the client that will make remote calls CORBA::Long r = - server->test_method (1, ACE_TRY_ENV); + server->test_method (1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (r != 0) @@ -148,17 +148,17 @@ main (int argc, char *argv[]) } // Shtdown the server - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY { ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Catched exception:"); + "Caught exception:"); return 1; } ACE_ENDTRY; diff --git a/TAO/tests/BiDirectional_NestedUpcall/server.cpp b/TAO/tests/BiDirectional_NestedUpcall/server.cpp index 6556f3526ad..9b7753566de 100644 --- a/TAO/tests/BiDirectional_NestedUpcall/server.cpp +++ b/TAO/tests/BiDirectional_NestedUpcall/server.cpp @@ -44,11 +44,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -57,11 +57,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Policies for the childPOA to be created. @@ -72,8 +72,8 @@ main (int argc, char *argv[]) pol <<= BiDirPolicy::BOTH; policies[0] = orb->create_policy (BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE, - pol, - ACE_TRY_ENV); + pol + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Create POA as child of RootPOA with the above policies. This POA @@ -82,8 +82,8 @@ main (int argc, char *argv[]) PortableServer::POA_var child_poa = root_poa->create_POA ("childPOA", poa_manager.in (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Creation of childPOA is over. Destroy the Policy objects. @@ -91,39 +91,39 @@ main (int argc, char *argv[]) i < policies.length (); ++i) { - policies[i]->destroy (ACE_TRY_ENV); + policies[i]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; - + Simple_Server_i *server_impl = 0; - + ACE_NEW_THROW_EX (server_impl, - Simple_Server_i (orb.in (), - no_iterations), - CORBA::NO_MEMORY ()); + Simple_Server_i (orb.in (), + no_iterations), + CORBA::NO_MEMORY ()); PortableServer::ServantBase_var owner_transfer (server_impl); PortableServer::ObjectId_var id = PortableServer::string_to_ObjectId ("simple_server"); child_poa->activate_object_with_id (id.in (), - server_impl, - ACE_TRY_ENV); + server_impl + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var obj = - child_poa->id_to_reference (id.in (), - ACE_TRY_ENV); + child_poa->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (obj.in (), ACE_TRY_ENV); + orb->object_to_string (obj.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); @@ -142,18 +142,18 @@ main (int argc, char *argv[]) } // Run the event loop - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY { ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Catched exception:"); + "Caught exception:"); return 1; } ACE_ENDTRY; diff --git a/TAO/tests/BiDirectional_NestedUpcall/test_i.cpp b/TAO/tests/BiDirectional_NestedUpcall/test_i.cpp index f7476d946df..04289ca3616 100644 --- a/TAO/tests/BiDirectional_NestedUpcall/test_i.cpp +++ b/TAO/tests/BiDirectional_NestedUpcall/test_i.cpp @@ -13,15 +13,15 @@ ACE_RCSID(BiDirectional_NestedUpcall, test_i, "$Id$") void -Callback_i::shutdown (CORBA::Environment &ACE_TRY_ENV) +Callback_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "Performing clean shutdown\n")); - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } void -Callback_i::callback_method (CORBA::Environment & /*ACE_TRY_ENV*/) +Callback_i::callback_method (TAO_ENV_SINGLE_ARG_DECL_NOT_USED /*TAO_ENV_SINGLE_ARG_PARAMETER*/) ACE_THROW_SPEC ((CORBA::SystemException)) { if (TAO_debug_level > 0) @@ -32,8 +32,8 @@ Callback_i::callback_method (CORBA::Environment & /*ACE_TRY_ENV*/) // **************************************************************** CORBA::Long -Simple_Server_i::test_method (CORBA::Boolean do_callback, - CORBA::Environment &ACE_TRY_ENV) +Simple_Server_i::test_method (CORBA::Boolean do_callback + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { if (do_callback) @@ -46,7 +46,7 @@ Simple_Server_i::test_method (CORBA::Boolean do_callback, times < this->no_iterations_; ++times) { - this->callback_->callback_method (ACE_TRY_ENV); + this->callback_->callback_method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (0); if (this->orb_->orb_core ()->lane_resources ().transport_cache ().current_size () > 1) @@ -63,8 +63,8 @@ Simple_Server_i::test_method (CORBA::Boolean do_callback, } void -Simple_Server_i::callback_object (Callback_ptr callback, - CORBA::Environment& ) +Simple_Server_i::callback_object (Callback_ptr callback + TAO_ENV_ARG_DECL_NOT_USED ) ACE_THROW_SPEC ((CORBA::SystemException)) { // Store the callback object @@ -73,8 +73,8 @@ Simple_Server_i::callback_object (Callback_ptr callback, void -Simple_Server_i::shutdown (CORBA::Environment& ACE_TRY_ENV) +Simple_Server_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/BiDirectional_NestedUpcall/test_i.h b/TAO/tests/BiDirectional_NestedUpcall/test_i.h index 404dc8ef610..f8424b7272f 100644 --- a/TAO/tests/BiDirectional_NestedUpcall/test_i.h +++ b/TAO/tests/BiDirectional_NestedUpcall/test_i.h @@ -19,7 +19,7 @@ #include "testS.h" class Callback_i : public virtual POA_Callback, - public virtual PortableServer::RefCountServantBase + public virtual PortableServer::RefCountServantBase { // = TITLE // A callback object to the "client" @@ -32,11 +32,11 @@ public: Callback_i (CORBA::ORB_ptr orb); // ctor - void shutdown (CORBA::Environment &ACE_TRY_ENV) + void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // Safe way to shutdown - void callback_method (CORBA::Environment &ACE_TRY_ENV) + void callback_method (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // The callback method @@ -46,7 +46,7 @@ private: }; class Simple_Server_i : public virtual POA_Simple_Server, - public virtual PortableServer::RefCountServantBase + public virtual PortableServer::RefCountServantBase { // = TITLE // Simpler Server implementation @@ -59,15 +59,15 @@ public: // ctor // = The Simple_Server methods. - CORBA::Long test_method (CORBA::Boolean do_callback, - CORBA::Environment&) + CORBA::Long test_method (CORBA::Boolean do_callback + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void callback_object (Callback_ptr callback, - CORBA::Environment&) + void callback_object (Callback_ptr callback + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Big_Oneways/Coordinator.cpp b/TAO/tests/Big_Oneways/Coordinator.cpp index 52fa351d814..60a43593f69 100644 --- a/TAO/tests/Big_Oneways/Coordinator.cpp +++ b/TAO/tests/Big_Oneways/Coordinator.cpp @@ -29,8 +29,8 @@ Coordinator::create_session_list (Test::Session_Control_ptr session_control, CORBA::ULong payload_size, CORBA::ULong thread_count, CORBA::ULong message_count, - Test::Session_List &session_list, - CORBA::Environment &ACE_TRY_ENV) + Test::Session_List &session_list + TAO_ENV_ARG_DECL) { session_list.length (this->peer_count_); CORBA::ULong count = 0; @@ -43,14 +43,14 @@ Coordinator::create_session_list (Test::Session_Control_ptr session_control, payload_size, thread_count, message_count, - this->peer_count_, - ACE_TRY_ENV); + this->peer_count_ + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } } void -Coordinator::shutdown_all_peers (CORBA::Environment &ACE_TRY_ENV) +Coordinator::shutdown_all_peers (TAO_ENV_SINGLE_ARG_DECL) { for (Test::Peer_var *i = this->peers_; i != this->peers_ + this->peer_count_; @@ -58,7 +58,7 @@ Coordinator::shutdown_all_peers (CORBA::Environment &ACE_TRY_ENV) { ACE_TRY { - (*i)->shutdown (ACE_TRY_ENV); + (*i)->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -71,8 +71,8 @@ Coordinator::shutdown_all_peers (CORBA::Environment &ACE_TRY_ENV) } void -Coordinator::add_peer (Test::Peer_ptr peer, - CORBA::Environment &) +Coordinator::add_peer (Test::Peer_ptr peer + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { if (this->peer_count_ >= this->peer_max_) diff --git a/TAO/tests/Big_Oneways/Coordinator.h b/TAO/tests/Big_Oneways/Coordinator.h index e754658f952..48f5180eb78 100644 --- a/TAO/tests/Big_Oneways/Coordinator.h +++ b/TAO/tests/Big_Oneways/Coordinator.h @@ -35,15 +35,15 @@ public: CORBA::ULong payload_size, CORBA::ULong thread_count, CORBA::ULong message_count, - Test::Session_List &session_list, - CORBA::Environment &ACE_TRY_ENV); + Test::Session_List &session_list + TAO_ENV_ARG_DECL); /// Shutdown all the peers - void shutdown_all_peers (CORBA::Environment &ACE_TRY_ENV); + void shutdown_all_peers (TAO_ENV_SINGLE_ARG_DECL); // = The skeleton methods - virtual void add_peer (Test::Peer_ptr peer, - CORBA::Environment &ACE_TRY_ENV) + virtual void add_peer (Test::Peer_ptr peer + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Big_Oneways/Peer.cpp b/TAO/tests/Big_Oneways/Peer.cpp index e5cf894acba..c4bd8a20639 100644 --- a/TAO/tests/Big_Oneways/Peer.cpp +++ b/TAO/tests/Big_Oneways/Peer.cpp @@ -20,8 +20,8 @@ Peer::create_session (Test::Session_Control_ptr control, CORBA::ULong payload_size, CORBA::ULong thread_count, CORBA::ULong message_count, - CORBA::ULong peer_count, - CORBA::Environment &ACE_TRY_ENV) + CORBA::ULong peer_count + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { Session *session_impl; @@ -35,11 +35,11 @@ Peer::create_session (Test::Session_Control_ptr control, ACE_CHECK_RETURN (Test::Session::_nil ()); PortableServer::ServantBase_var transfer_ownership (session_impl); - return session_impl->_this (ACE_TRY_ENV); + return session_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); } void -Peer::shutdown (CORBA::Environment &ACE_TRY_ENV) +Peer::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -47,5 +47,5 @@ Peer::shutdown (CORBA::Environment &ACE_TRY_ENV) ACE_DEBUG ((LM_DEBUG, "(%P|%t) Peer::shutdown, shutting down ORB\n")); - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/Big_Oneways/Peer.h b/TAO/tests/Big_Oneways/Peer.h index ed34b0eb6fa..41ab681be6f 100644 --- a/TAO/tests/Big_Oneways/Peer.h +++ b/TAO/tests/Big_Oneways/Peer.h @@ -32,10 +32,10 @@ public: CORBA::ULong payload_size, CORBA::ULong thread_count, CORBA::ULong message_count, - CORBA::ULong peer_count, - CORBA::Environment &ACE_TRY_ENV) + CORBA::ULong peer_count + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Big_Oneways/Session.cpp b/TAO/tests/Big_Oneways/Session.cpp index ea0c7b62789..dc1ed674ba4 100644 --- a/TAO/tests/Big_Oneways/Session.cpp +++ b/TAO/tests/Big_Oneways/Session.cpp @@ -36,7 +36,7 @@ Session::svc (void) /// thread PortableServer::ServantBase_var auto_decrement (this); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { @@ -53,7 +53,7 @@ Session::svc (void) CORBA::ULong session_count = this->other_sessions_.length (); - this->validate_connections (ACE_TRY_ENV); + this->validate_connections (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; for (CORBA::ULong i = 0; i != this->message_count_; ++i) @@ -69,8 +69,8 @@ Session::svc (void) #endif /* 0 */ for (CORBA::ULong j = 0; j != session_count; ++j) { - this->other_sessions_[j]->receive_payload (payload, - ACE_TRY_ENV); + this->other_sessions_[j]->receive_payload (payload + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } } @@ -83,7 +83,7 @@ Session::svc (void) return 0; } } - this->terminate (1, ACE_TRY_ENV); + this->terminate (1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -97,7 +97,7 @@ Session::svc (void) } void -Session::validate_connections (CORBA::Environment &ACE_TRY_ENV) +Session::validate_connections (TAO_ENV_SINGLE_ARG_DECL) { CORBA::ULong session_count = this->other_sessions_.length (); @@ -107,7 +107,7 @@ Session::validate_connections (CORBA::Environment &ACE_TRY_ENV) { ACE_TRY { - this->other_sessions_[j]->ping (ACE_TRY_ENV); + this->other_sessions_[j]->ping (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY {} ACE_ENDTRY; @@ -116,8 +116,8 @@ Session::validate_connections (CORBA::Environment &ACE_TRY_ENV) } void -Session::start (const Test::Session_List &other_sessions, - CORBA::Environment &ACE_TRY_ENV) +Session::start (const Test::Session_List &other_sessions + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, Test::Already_Running, Test::No_Peers)) @@ -138,12 +138,12 @@ Session::start (const Test::Session_List &other_sessions, // access to this object.... ACE_TRY { - this->_add_ref (ACE_TRY_ENV); + this->_add_ref (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (this->task_.activate ( THR_NEW_LWP | THR_JOINABLE, 1, 1) == -1) { - this->_remove_ref (ACE_TRY_ENV); + this->_remove_ref (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } else @@ -170,17 +170,17 @@ Session::start (const Test::Session_List &other_sessions, } /// None of the threads are running, this session is useless at /// this point, report the problem and destroy the local objects - this->terminate (0, ACE_TRY_ENV); + this->terminate (0 TAO_ENV_ARG_PARAMETER); } void -Session::ping (CORBA::Environment &) ACE_THROW_SPEC ((CORBA::SystemException)) +Session::ping (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { } void -Session::receive_payload (const Test::Payload &the_payload, - CORBA::Environment &ACE_TRY_ENV) +Session::receive_payload (const Test::Payload &the_payload + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { if (the_payload.length () != this->payload_size_) @@ -217,23 +217,23 @@ Session::receive_payload (const Test::Payload &the_payload, if (this->more_work ()) return; } - this->terminate (1, ACE_TRY_ENV); + this->terminate (1 TAO_ENV_ARG_PARAMETER); } void -Session::destroy (CORBA::Environment &ACE_TRY_ENV) +Session::destroy (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { // Make sure local resources are released PortableServer::POA_var poa = - this->_default_POA (ACE_TRY_ENV); + this->_default_POA (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; PortableServer::ObjectId_var oid = - poa->servant_to_id (this, ACE_TRY_ENV); + poa->servant_to_id (this TAO_ENV_ARG_PARAMETER); ACE_CHECK; - poa->deactivate_object (oid.in (), ACE_TRY_ENV); + poa->deactivate_object (oid.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK; } @@ -249,15 +249,15 @@ Session::more_work (void) const } void -Session::terminate (CORBA::Boolean success, - CORBA::Environment &ACE_TRY_ENV) +Session::terminate (CORBA::Boolean success + TAO_ENV_ARG_DECL) ACE_THROW_SPEC (()) { // Make sure that global resources are released ACE_TRY_EX(GLOBAL) { - this->control_->session_finished (success, - ACE_TRY_ENV); + this->control_->session_finished (success + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK_EX(GLOBAL); } ACE_CATCHANY diff --git a/TAO/tests/Big_Oneways/Session.h b/TAO/tests/Big_Oneways/Session.h index 021da78a550..62dcd896fa5 100644 --- a/TAO/tests/Big_Oneways/Session.h +++ b/TAO/tests/Big_Oneways/Session.h @@ -36,27 +36,27 @@ public: int svc (void); // = The skeleton methods - virtual void start (const Test::Session_List &other_sessions, - CORBA::Environment &ACE_TRY_ENV) + virtual void start (const Test::Session_List &other_sessions + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, Test::Already_Running, Test::No_Peers)); - virtual void ping (CORBA::Environment &) + virtual void ping (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void receive_payload (const Test::Payload &the_payload, - CORBA::Environment &ACE_TRY_ENV) + virtual void receive_payload (const Test::Payload &the_payload + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void destroy (CORBA::Environment &ACE_TRY_ENV) + virtual void destroy (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: /// Helper function used to report any problems and destroy local /// resources - void terminate (CORBA::Boolean success, - CORBA::Environment &ACE_TRY_ENV) + void terminate (CORBA::Boolean success + TAO_ENV_ARG_DECL) ACE_THROW_SPEC (()); /// Return 1 if all the work in this session has been completed @@ -64,7 +64,7 @@ private: /// Make sure that all threads have connections avaiable to the /// other sessions. - void validate_connections (CORBA::Environment &ACE_TRY_ENV); + void validate_connections (TAO_ENV_SINGLE_ARG_DECL); private: /// Synchronize the internal state diff --git a/TAO/tests/Big_Oneways/Session_Control.cpp b/TAO/tests/Big_Oneways/Session_Control.cpp index f0f5c3bd4b4..62a77e985b3 100644 --- a/TAO/tests/Big_Oneways/Session_Control.cpp +++ b/TAO/tests/Big_Oneways/Session_Control.cpp @@ -41,8 +41,8 @@ Session_Control::~Session_Control (void) } void -Session_Control::session_finished (CORBA::Boolean success, - CORBA::Environment &ACE_TRY_ENV) +Session_Control::session_finished (CORBA::Boolean success + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_GUARD (ACE_SYNCH_MUTEX, ace_mon, this->mutex_); @@ -63,12 +63,12 @@ Session_Control::session_finished (CORBA::Boolean success, if (session_count_ == 0) { PortableServer::POA_var poa = - this->_default_POA (ACE_TRY_ENV); + this->_default_POA (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; PortableServer::ObjectId_var oid = - poa->servant_to_id (this, ACE_TRY_ENV); + poa->servant_to_id (this TAO_ENV_ARG_PARAMETER); ACE_CHECK; - poa->deactivate_object (oid.in (), ACE_TRY_ENV); + poa->deactivate_object (oid.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK; } diff --git a/TAO/tests/Big_Oneways/Session_Control.h b/TAO/tests/Big_Oneways/Session_Control.h index 09c19dbaaba..3f3dfcab3f9 100644 --- a/TAO/tests/Big_Oneways/Session_Control.h +++ b/TAO/tests/Big_Oneways/Session_Control.h @@ -34,8 +34,8 @@ public: int all_sessions_finished (void) const; // = The skeleton methods - virtual void session_finished (CORBA::Boolean success, - CORBA::Environment &ACE_TRY_ENV) + virtual void session_finished (CORBA::Boolean success + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Big_Oneways/client.cpp b/TAO/tests/Big_Oneways/client.cpp index 20c6f6900df..2bf4fc0ca25 100644 --- a/TAO/tests/Big_Oneways/client.cpp +++ b/TAO/tests/Big_Oneways/client.cpp @@ -40,15 +40,15 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -57,18 +57,18 @@ main (int argc, char *argv[]) 1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = - orb->string_to_object(ior, ACE_TRY_ENV); + orb->string_to_object(ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Coordinator_var coordinator = - Test::Coordinator::_narrow(tmp.in (), ACE_TRY_ENV); + Test::Coordinator::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (coordinator.in ())) @@ -86,24 +86,24 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var peer_owner_transfer(peer_impl); Test::Peer_var peer = - peer_impl->_this (ACE_TRY_ENV); + peer_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - coordinator->add_peer (peer.in (), ACE_TRY_ENV); + coordinator->add_peer (peer.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Wait for all the threads. ACE_Thread_Manager::instance ()->wait (); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Big_Oneways/server.cpp b/TAO/tests/Big_Oneways/server.cpp index 9de3f84deba..0287285b12b 100644 --- a/TAO/tests/Big_Oneways/server.cpp +++ b/TAO/tests/Big_Oneways/server.cpp @@ -64,15 +64,15 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -81,7 +81,7 @@ main (int argc, char *argv[]) 1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -94,11 +94,11 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var coordinator_owner_transfer(coordinator_impl); Test::Coordinator_var coordinator = - coordinator_impl->_this (ACE_TRY_ENV); + coordinator_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (coordinator.in (), ACE_TRY_ENV); + orb->object_to_string (coordinator.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -111,7 +111,7 @@ main (int argc, char *argv[]) ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Waiting for peers . . . ")); @@ -120,7 +120,7 @@ main (int argc, char *argv[]) ++i) { ACE_Time_Value tv (1, 0); - orb->run (tv, ACE_TRY_ENV); + orb->run (tv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_DEBUG ((LM_DEBUG, "done.\n")); @@ -139,7 +139,7 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var session_control_owner_transfer(session_control_impl); Test::Session_Control_var session_control = - session_control_impl->_this (ACE_TRY_ENV); + session_control_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Test::Session_List session_list; @@ -147,8 +147,8 @@ main (int argc, char *argv[]) payload_size, thread_count, message_count, - session_list, - ACE_TRY_ENV); + session_list + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_ASSERT (session_list.length () == peer_count); @@ -168,8 +168,8 @@ main (int argc, char *argv[]) Test::Session::_duplicate (session_list[k]); } - session_list[j]->start (other_sessions, - ACE_TRY_ENV); + session_list[j]->start (other_sessions + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -180,7 +180,7 @@ main (int argc, char *argv[]) ++k) { ACE_Time_Value tv (1, 0); - orb->run (tv, ACE_TRY_ENV); + orb->run (tv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -195,18 +195,18 @@ main (int argc, char *argv[]) for (j = 0; j != peer_count; ++j) { - session_list[j]->destroy (ACE_TRY_ENV); + session_list[j]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } - coordinator_impl->shutdown_all_peers (ACE_TRY_ENV); + coordinator_impl->shutdown_all_peers (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Big_Reply/Big_Reply_i.cpp b/TAO/tests/Big_Reply/Big_Reply_i.cpp index 7c3dc79fc88..58960000cef 100644 --- a/TAO/tests/Big_Reply/Big_Reply_i.cpp +++ b/TAO/tests/Big_Reply/Big_Reply_i.cpp @@ -14,7 +14,7 @@ Big_Reply_i::~Big_Reply_i (void) } Test::Octet_Seq * -Big_Reply_i::get_big_reply (CORBA::Environment & /*ACE_TRY_ENV*/) +Big_Reply_i::get_big_reply (TAO_ENV_SINGLE_ARG_DECL_NOT_USED /*TAO_ENV_SINGLE_ARG_PARAMETER*/) ACE_THROW_SPEC ((CORBA::SystemException)) { Test::Octet_Seq_var reply_mesg = @@ -26,13 +26,13 @@ Big_Reply_i::get_big_reply (CORBA::Environment & /*ACE_TRY_ENV*/) } void -Big_Reply_i::ping (CORBA::Environment & /*ACE_TRY_ENV*/) +Big_Reply_i::ping (TAO_ENV_SINGLE_ARG_DECL_NOT_USED /*TAO_ENV_SINGLE_ARG_PARAMETER*/) ACE_THROW_SPEC ((CORBA::SystemException)) { } void -Big_Reply_i::shutdown (CORBA::Environment & /*ACE_TRY_ENV*/) +Big_Reply_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED /*TAO_ENV_SINGLE_ARG_PARAMETER*/) ACE_THROW_SPEC ((CORBA::SystemException)) { this->orb_->shutdown (); diff --git a/TAO/tests/Big_Reply/Big_Reply_i.h b/TAO/tests/Big_Reply/Big_Reply_i.h index 008646681a3..ab73819e6e3 100644 --- a/TAO/tests/Big_Reply/Big_Reply_i.h +++ b/TAO/tests/Big_Reply/Big_Reply_i.h @@ -40,13 +40,13 @@ public: virtual ~Big_Reply_i (void); // = The skeleton methods - virtual Test::Octet_Seq *get_big_reply (CORBA::Environment &ACE_TRY_ENV) + virtual Test::Octet_Seq *get_big_reply (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void ping (CORBA::Environment &ACE_TRY_ENV) + virtual void ping (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Big_Reply/Client_Task.cpp b/TAO/tests/Big_Reply/Client_Task.cpp index cb6bb290542..ff78b52259f 100644 --- a/TAO/tests/Big_Reply/Client_Task.cpp +++ b/TAO/tests/Big_Reply/Client_Task.cpp @@ -31,7 +31,7 @@ Client_Task::svc (void) { for (int i = 0; i != this->event_count_; ++i) { - this->reply_gen_->get_big_reply (ACE_TRY_ENV); + this->reply_gen_->get_big_reply (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } @@ -63,7 +63,7 @@ Client_Task::validate_connection (void) ACE_TRY { - this->reply_gen_->ping (ACE_TRY_ENV); + this->reply_gen_->ping (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY {} diff --git a/TAO/tests/Big_Reply/client.cpp b/TAO/tests/Big_Reply/client.cpp index 69777719ff9..c4b67da432f 100644 --- a/TAO/tests/Big_Reply/client.cpp +++ b/TAO/tests/Big_Reply/client.cpp @@ -38,18 +38,18 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = - orb->string_to_object(ior, ACE_TRY_ENV); + orb->string_to_object(ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Big_Reply_var reply_gen = - Test::Big_Reply::_narrow(tmp.in (), ACE_TRY_ENV); + Test::Big_Reply::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (reply_gen.in ())) @@ -73,7 +73,7 @@ main (int argc, char *argv[]) ACE_DEBUG ((LM_DEBUG, "Got all the replies...\n")); - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Big_Reply/server.cpp b/TAO/tests/Big_Reply/server.cpp index 2fa6ba4ea5a..71ac4df2afb 100644 --- a/TAO/tests/Big_Reply/server.cpp +++ b/TAO/tests/Big_Reply/server.cpp @@ -43,11 +43,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -56,11 +56,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; @@ -78,12 +78,12 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var big_reply_owner_transfer(big_reply_gen); Test::Big_Reply_var big_reply = - big_reply_gen->_this (ACE_TRY_ENV); + big_reply_gen->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (big_reply.in (), - ACE_TRY_ENV); + orb->object_to_string (big_reply.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -96,19 +96,19 @@ main (int argc, char *argv[]) ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; orb->run (); ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY { ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Catched exception:"); + "Caught exception:"); return 1; } ACE_ENDTRY; diff --git a/TAO/tests/Big_Request_Muxing/Client_Task.cpp b/TAO/tests/Big_Request_Muxing/Client_Task.cpp index 0ce80749e44..399aa4e0e41 100644 --- a/TAO/tests/Big_Request_Muxing/Client_Task.cpp +++ b/TAO/tests/Big_Request_Muxing/Client_Task.cpp @@ -30,18 +30,18 @@ Client_Task::svc (void) for (CORBA::ULong j = 0; j != payload.length (); ++j) payload[j] = (j % 256); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { - this->validate_connection (ACE_TRY_ENV); + this->validate_connection (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var object = - this->orb_->resolve_initial_references ("PolicyCurrent", - ACE_TRY_ENV); + this->orb_->resolve_initial_references ("PolicyCurrent" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyCurrent_var policy_current = - CORBA::PolicyCurrent::_narrow (object.in (), ACE_TRY_ENV); + CORBA::PolicyCurrent::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Any scope_as_any; @@ -52,18 +52,18 @@ Client_Task::svc (void) policy_list.length (1); policy_list[0] = this->orb_->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE, - scope_as_any, - ACE_TRY_ENV); + scope_as_any + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; policy_current->set_policy_overrides (policy_list, - CORBA::ADD_OVERRIDE, - ACE_TRY_ENV); + CORBA::ADD_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; for (int i = 0; i != this->event_count_; ++i) { - this->payload_receiver_->more_data (payload, ACE_TRY_ENV); + this->payload_receiver_->more_data (payload TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } } @@ -76,13 +76,13 @@ Client_Task::svc (void) } void -Client_Task::validate_connection (CORBA::Environment &ACE_TRY_ENV) +Client_Task::validate_connection (TAO_ENV_SINGLE_ARG_DECL) { ACE_TRY { for (int i = 0; i != 100; ++i) { - (void) this->payload_receiver_->get_message_count (ACE_TRY_ENV); + (void) this->payload_receiver_->get_message_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/tests/Big_Request_Muxing/Client_Task.h b/TAO/tests/Big_Request_Muxing/Client_Task.h index 25fb8267a53..a543a408097 100644 --- a/TAO/tests/Big_Request_Muxing/Client_Task.h +++ b/TAO/tests/Big_Request_Muxing/Client_Task.h @@ -32,7 +32,7 @@ public: private: /// Make sure that all threads have connections available to /// workaround bug 189 - void validate_connection (CORBA::Environment &ACE_TRY_ENV); + void validate_connection (TAO_ENV_SINGLE_ARG_DECL); private: /// Reference to the test interface diff --git a/TAO/tests/Big_Request_Muxing/Payload_Receiver.cpp b/TAO/tests/Big_Request_Muxing/Payload_Receiver.cpp index a4179b53960..86d6c47f73d 100644 --- a/TAO/tests/Big_Request_Muxing/Payload_Receiver.cpp +++ b/TAO/tests/Big_Request_Muxing/Payload_Receiver.cpp @@ -12,8 +12,8 @@ Payload_Receiver::Payload_Receiver (void) } void -Payload_Receiver::more_data (const Test::Payload &payload, - CORBA::Environment &) +Payload_Receiver::more_data (const Test::Payload &payload + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->message_count_++; @@ -21,7 +21,7 @@ Payload_Receiver::more_data (const Test::Payload &payload, } CORBA::Long -Payload_Receiver::get_message_count (CORBA::Environment &) +Payload_Receiver::get_message_count (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return this->message_count_; diff --git a/TAO/tests/Big_Request_Muxing/Payload_Receiver.h b/TAO/tests/Big_Request_Muxing/Payload_Receiver.h index 73787c62451..4675c2e2b30 100644 --- a/TAO/tests/Big_Request_Muxing/Payload_Receiver.h +++ b/TAO/tests/Big_Request_Muxing/Payload_Receiver.h @@ -28,10 +28,10 @@ public: Payload_Receiver (void); // = The skeleton methods - virtual void more_data (const Test::Payload &payload, - CORBA::Environment &ACE_TRY_ENV) + virtual void more_data (const Test::Payload &payload + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual CORBA::Long get_message_count (CORBA::Environment &ACE_TRY_ENV) + virtual CORBA::Long get_message_count (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Big_Request_Muxing/client.cpp b/TAO/tests/Big_Request_Muxing/client.cpp index d6c0682c6eb..47e29b9544d 100644 --- a/TAO/tests/Big_Request_Muxing/client.cpp +++ b/TAO/tests/Big_Request_Muxing/client.cpp @@ -18,13 +18,13 @@ parse_args (int argc, char *argv[]) switch (c) { case 'k': - ior = get_opts.optarg; - break; + ior = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-k <ior>" + "-k <ior>" "\n", argv [0]), -1); @@ -39,18 +39,18 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = - orb->string_to_object(ior, ACE_TRY_ENV); + orb->string_to_object(ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Payload_Receiver_var payload_receiver = - Test::Payload_Receiver::_narrow(tmp.in (), ACE_TRY_ENV); + Test::Payload_Receiver::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (payload_receiver.in ())) @@ -96,20 +96,20 @@ main (int argc, char *argv[]) } ACE_Time_Value tv (120, 0); - orb->run (tv, ACE_TRY_ENV); + orb->run (tv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_Thread_Manager::instance ()->wait (); ACE_DEBUG ((LM_DEBUG, "(%P) Threads finished\n")); CORBA::Long count = - payload_receiver->get_message_count (ACE_TRY_ENV); + payload_receiver->get_message_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "(%P) - Payload_Receiver got %d messages\n", count)); - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Big_Request_Muxing/server.cpp b/TAO/tests/Big_Request_Muxing/server.cpp index fb64629eb8d..bda9db4e71d 100644 --- a/TAO/tests/Big_Request_Muxing/server.cpp +++ b/TAO/tests/Big_Request_Muxing/server.cpp @@ -17,13 +17,13 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -38,11 +38,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -51,11 +51,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -68,11 +68,11 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var receiver_owner_transfer(payload_receiver_impl); Test::Payload_Receiver_var payload_receiver = - payload_receiver_impl->_this (ACE_TRY_ENV); + payload_receiver_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (payload_receiver.in (), ACE_TRY_ENV); + orb->object_to_string (payload_receiver.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -81,23 +81,23 @@ main (int argc, char *argv[]) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_output_file), - 1); + 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_Time_Value tv (240, 0); - orb->run (tv, ACE_TRY_ENV); + orb->run (tv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Now terminating test\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Big_Twoways/Coordinator.cpp b/TAO/tests/Big_Twoways/Coordinator.cpp index 52fa351d814..60a43593f69 100644 --- a/TAO/tests/Big_Twoways/Coordinator.cpp +++ b/TAO/tests/Big_Twoways/Coordinator.cpp @@ -29,8 +29,8 @@ Coordinator::create_session_list (Test::Session_Control_ptr session_control, CORBA::ULong payload_size, CORBA::ULong thread_count, CORBA::ULong message_count, - Test::Session_List &session_list, - CORBA::Environment &ACE_TRY_ENV) + Test::Session_List &session_list + TAO_ENV_ARG_DECL) { session_list.length (this->peer_count_); CORBA::ULong count = 0; @@ -43,14 +43,14 @@ Coordinator::create_session_list (Test::Session_Control_ptr session_control, payload_size, thread_count, message_count, - this->peer_count_, - ACE_TRY_ENV); + this->peer_count_ + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } } void -Coordinator::shutdown_all_peers (CORBA::Environment &ACE_TRY_ENV) +Coordinator::shutdown_all_peers (TAO_ENV_SINGLE_ARG_DECL) { for (Test::Peer_var *i = this->peers_; i != this->peers_ + this->peer_count_; @@ -58,7 +58,7 @@ Coordinator::shutdown_all_peers (CORBA::Environment &ACE_TRY_ENV) { ACE_TRY { - (*i)->shutdown (ACE_TRY_ENV); + (*i)->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -71,8 +71,8 @@ Coordinator::shutdown_all_peers (CORBA::Environment &ACE_TRY_ENV) } void -Coordinator::add_peer (Test::Peer_ptr peer, - CORBA::Environment &) +Coordinator::add_peer (Test::Peer_ptr peer + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { if (this->peer_count_ >= this->peer_max_) diff --git a/TAO/tests/Big_Twoways/Coordinator.h b/TAO/tests/Big_Twoways/Coordinator.h index e754658f952..48f5180eb78 100644 --- a/TAO/tests/Big_Twoways/Coordinator.h +++ b/TAO/tests/Big_Twoways/Coordinator.h @@ -35,15 +35,15 @@ public: CORBA::ULong payload_size, CORBA::ULong thread_count, CORBA::ULong message_count, - Test::Session_List &session_list, - CORBA::Environment &ACE_TRY_ENV); + Test::Session_List &session_list + TAO_ENV_ARG_DECL); /// Shutdown all the peers - void shutdown_all_peers (CORBA::Environment &ACE_TRY_ENV); + void shutdown_all_peers (TAO_ENV_SINGLE_ARG_DECL); // = The skeleton methods - virtual void add_peer (Test::Peer_ptr peer, - CORBA::Environment &ACE_TRY_ENV) + virtual void add_peer (Test::Peer_ptr peer + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Big_Twoways/Peer.cpp b/TAO/tests/Big_Twoways/Peer.cpp index e5cf894acba..c4bd8a20639 100644 --- a/TAO/tests/Big_Twoways/Peer.cpp +++ b/TAO/tests/Big_Twoways/Peer.cpp @@ -20,8 +20,8 @@ Peer::create_session (Test::Session_Control_ptr control, CORBA::ULong payload_size, CORBA::ULong thread_count, CORBA::ULong message_count, - CORBA::ULong peer_count, - CORBA::Environment &ACE_TRY_ENV) + CORBA::ULong peer_count + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { Session *session_impl; @@ -35,11 +35,11 @@ Peer::create_session (Test::Session_Control_ptr control, ACE_CHECK_RETURN (Test::Session::_nil ()); PortableServer::ServantBase_var transfer_ownership (session_impl); - return session_impl->_this (ACE_TRY_ENV); + return session_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); } void -Peer::shutdown (CORBA::Environment &ACE_TRY_ENV) +Peer::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -47,5 +47,5 @@ Peer::shutdown (CORBA::Environment &ACE_TRY_ENV) ACE_DEBUG ((LM_DEBUG, "(%P|%t) Peer::shutdown, shutting down ORB\n")); - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/Big_Twoways/Peer.h b/TAO/tests/Big_Twoways/Peer.h index ed34b0eb6fa..41ab681be6f 100644 --- a/TAO/tests/Big_Twoways/Peer.h +++ b/TAO/tests/Big_Twoways/Peer.h @@ -32,10 +32,10 @@ public: CORBA::ULong payload_size, CORBA::ULong thread_count, CORBA::ULong message_count, - CORBA::ULong peer_count, - CORBA::Environment &ACE_TRY_ENV) + CORBA::ULong peer_count + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Big_Twoways/Session.cpp b/TAO/tests/Big_Twoways/Session.cpp index 2e176ce61f1..efe3afe001f 100644 --- a/TAO/tests/Big_Twoways/Session.cpp +++ b/TAO/tests/Big_Twoways/Session.cpp @@ -36,7 +36,7 @@ Session::svc (void) /// thread PortableServer::ServantBase_var auto_decrement (this); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { @@ -62,8 +62,8 @@ Session::svc (void) for (CORBA::ULong j = 0; j != session_count; ++j) { Test::Payload_var received = - this->other_sessions_[j]->echo_payload (payload, - ACE_TRY_ENV); + this->other_sessions_[j]->echo_payload (payload + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } } @@ -76,7 +76,7 @@ Session::svc (void) return 0; } } - this->terminate (1, ACE_TRY_ENV); + this->terminate (1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -90,8 +90,8 @@ Session::svc (void) } void -Session::start (const Test::Session_List &other_sessions, - CORBA::Environment &ACE_TRY_ENV) +Session::start (const Test::Session_List &other_sessions + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, Test::Already_Running, Test::No_Peers)) @@ -112,12 +112,12 @@ Session::start (const Test::Session_List &other_sessions, // access to this object.... ACE_TRY { - this->_add_ref (ACE_TRY_ENV); + this->_add_ref (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (this->task_.activate ( THR_NEW_LWP | THR_JOINABLE, 1, 1) == -1) { - this->_remove_ref (ACE_TRY_ENV); + this->_remove_ref (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } else @@ -144,12 +144,12 @@ Session::start (const Test::Session_List &other_sessions, } /// None of the threads are running, this session is useless at /// this point, report the problem and destroy the local objects - this->terminate (0, ACE_TRY_ENV); + this->terminate (0 TAO_ENV_ARG_PARAMETER); } Test::Payload * -Session::echo_payload (const Test::Payload &the_payload, - CORBA::Environment &ACE_TRY_ENV) +Session::echo_payload (const Test::Payload &the_payload + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { if (the_payload.length () != this->payload_size_) @@ -188,7 +188,7 @@ Session::echo_payload (const Test::Payload &the_payload, if (this->more_work ()) return retval._retn (); } - this->terminate (1, ACE_TRY_ENV); + this->terminate (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (0); return retval._retn (); @@ -196,18 +196,18 @@ Session::echo_payload (const Test::Payload &the_payload, void -Session::destroy (CORBA::Environment &ACE_TRY_ENV) +Session::destroy (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { // Make sure local resources are released PortableServer::POA_var poa = - this->_default_POA (ACE_TRY_ENV); + this->_default_POA (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; PortableServer::ObjectId_var oid = - poa->servant_to_id (this, ACE_TRY_ENV); + poa->servant_to_id (this TAO_ENV_ARG_PARAMETER); ACE_CHECK; - poa->deactivate_object (oid.in (), ACE_TRY_ENV); + poa->deactivate_object (oid.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK; } @@ -223,15 +223,15 @@ Session::more_work (void) const } void -Session::terminate (CORBA::Boolean success, - CORBA::Environment &ACE_TRY_ENV) +Session::terminate (CORBA::Boolean success + TAO_ENV_ARG_DECL) ACE_THROW_SPEC (()) { // Make sure that global resources are released ACE_TRY_EX(GLOBAL) { - this->control_->session_finished (success, - ACE_TRY_ENV); + this->control_->session_finished (success + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK_EX(GLOBAL); } ACE_CATCHANY diff --git a/TAO/tests/Big_Twoways/Session.h b/TAO/tests/Big_Twoways/Session.h index 6f02a52f802..112165a85b2 100644 --- a/TAO/tests/Big_Twoways/Session.h +++ b/TAO/tests/Big_Twoways/Session.h @@ -36,24 +36,24 @@ public: int svc (void); // = The skeleton methods - virtual void start (const Test::Session_List &other_sessions, - CORBA::Environment &ACE_TRY_ENV) + virtual void start (const Test::Session_List &other_sessions + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, Test::Already_Running, Test::No_Peers)); - virtual Test::Payload* echo_payload (const Test::Payload &the_payload, - CORBA::Environment &ACE_TRY_ENV) + virtual Test::Payload* echo_payload (const Test::Payload &the_payload + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void destroy (CORBA::Environment &ACE_TRY_ENV) + virtual void destroy (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: /// Helper function used to report any problems and destroy local /// resources - void terminate (CORBA::Boolean success, - CORBA::Environment &ACE_TRY_ENV) + void terminate (CORBA::Boolean success + TAO_ENV_ARG_DECL) ACE_THROW_SPEC (()); /// Return 1 if all the work in this session has been completed diff --git a/TAO/tests/Big_Twoways/Session_Control.cpp b/TAO/tests/Big_Twoways/Session_Control.cpp index f0f5c3bd4b4..62a77e985b3 100644 --- a/TAO/tests/Big_Twoways/Session_Control.cpp +++ b/TAO/tests/Big_Twoways/Session_Control.cpp @@ -41,8 +41,8 @@ Session_Control::~Session_Control (void) } void -Session_Control::session_finished (CORBA::Boolean success, - CORBA::Environment &ACE_TRY_ENV) +Session_Control::session_finished (CORBA::Boolean success + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_GUARD (ACE_SYNCH_MUTEX, ace_mon, this->mutex_); @@ -63,12 +63,12 @@ Session_Control::session_finished (CORBA::Boolean success, if (session_count_ == 0) { PortableServer::POA_var poa = - this->_default_POA (ACE_TRY_ENV); + this->_default_POA (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; PortableServer::ObjectId_var oid = - poa->servant_to_id (this, ACE_TRY_ENV); + poa->servant_to_id (this TAO_ENV_ARG_PARAMETER); ACE_CHECK; - poa->deactivate_object (oid.in (), ACE_TRY_ENV); + poa->deactivate_object (oid.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK; } diff --git a/TAO/tests/Big_Twoways/Session_Control.h b/TAO/tests/Big_Twoways/Session_Control.h index 09c19dbaaba..3f3dfcab3f9 100644 --- a/TAO/tests/Big_Twoways/Session_Control.h +++ b/TAO/tests/Big_Twoways/Session_Control.h @@ -34,8 +34,8 @@ public: int all_sessions_finished (void) const; // = The skeleton methods - virtual void session_finished (CORBA::Boolean success, - CORBA::Environment &ACE_TRY_ENV) + virtual void session_finished (CORBA::Boolean success + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Big_Twoways/client.cpp b/TAO/tests/Big_Twoways/client.cpp index 20c6f6900df..2bf4fc0ca25 100644 --- a/TAO/tests/Big_Twoways/client.cpp +++ b/TAO/tests/Big_Twoways/client.cpp @@ -40,15 +40,15 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -57,18 +57,18 @@ main (int argc, char *argv[]) 1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = - orb->string_to_object(ior, ACE_TRY_ENV); + orb->string_to_object(ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Coordinator_var coordinator = - Test::Coordinator::_narrow(tmp.in (), ACE_TRY_ENV); + Test::Coordinator::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (coordinator.in ())) @@ -86,24 +86,24 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var peer_owner_transfer(peer_impl); Test::Peer_var peer = - peer_impl->_this (ACE_TRY_ENV); + peer_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - coordinator->add_peer (peer.in (), ACE_TRY_ENV); + coordinator->add_peer (peer.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Wait for all the threads. ACE_Thread_Manager::instance ()->wait (); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Big_Twoways/server.cpp b/TAO/tests/Big_Twoways/server.cpp index 4a1b4d08252..daba45ad5cc 100644 --- a/TAO/tests/Big_Twoways/server.cpp +++ b/TAO/tests/Big_Twoways/server.cpp @@ -64,15 +64,15 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -81,7 +81,7 @@ main (int argc, char *argv[]) 1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -94,11 +94,11 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var coordinator_owner_transfer(coordinator_impl); Test::Coordinator_var coordinator = - coordinator_impl->_this (ACE_TRY_ENV); + coordinator_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (coordinator.in (), ACE_TRY_ENV); + orb->object_to_string (coordinator.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -111,7 +111,7 @@ main (int argc, char *argv[]) ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Waiting for peers . . . ")); @@ -120,7 +120,7 @@ main (int argc, char *argv[]) ++i) { ACE_Time_Value tv (1, 0); - orb->run (tv, ACE_TRY_ENV); + orb->run (tv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_DEBUG ((LM_DEBUG, "done.\n")); @@ -139,7 +139,7 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var session_control_owner_transfer(session_control_impl); Test::Session_Control_var session_control = - session_control_impl->_this (ACE_TRY_ENV); + session_control_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Test::Session_List session_list; @@ -147,8 +147,8 @@ main (int argc, char *argv[]) payload_size, thread_count, message_count, - session_list, - ACE_TRY_ENV); + session_list + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_ASSERT (session_list.length () == peer_count); @@ -168,8 +168,8 @@ main (int argc, char *argv[]) Test::Session::_duplicate (session_list[k]); } - session_list[j]->start (other_sessions, - ACE_TRY_ENV); + session_list[j]->start (other_sessions + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -180,7 +180,7 @@ main (int argc, char *argv[]) ++k) { ACE_Time_Value tv (1, 0); - orb->run (tv, ACE_TRY_ENV); + orb->run (tv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -195,18 +195,18 @@ main (int argc, char *argv[]) for (j = 0; j != peer_count; ++j) { - session_list[j]->destroy (ACE_TRY_ENV); + session_list[j]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } - coordinator_impl->shutdown_all_peers (ACE_TRY_ENV); + coordinator_impl->shutdown_all_peers (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Blocking_Sync_None/Blocking_Sync_None.cpp b/TAO/tests/Blocking_Sync_None/Blocking_Sync_None.cpp index 6c856fe1cab..80af10cfde4 100644 --- a/TAO/tests/Blocking_Sync_None/Blocking_Sync_None.cpp +++ b/TAO/tests/Blocking_Sync_None/Blocking_Sync_None.cpp @@ -12,8 +12,8 @@ Blocking_Sync_None::Blocking_Sync_None (CORBA::ORB_ptr orb) void Blocking_Sync_None::slow_operation (const Test::Payload &, - CORBA::ULong sleep_microseconds, - CORBA::Environment &) + CORBA::ULong sleep_microseconds + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_Time_Value sleep_time (0, sleep_microseconds); @@ -21,8 +21,8 @@ Blocking_Sync_None::slow_operation (const Test::Payload &, } void -Blocking_Sync_None::shutdown (CORBA::Environment &ACE_TRY_ENV) +Blocking_Sync_None::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/Blocking_Sync_None/Blocking_Sync_None.h b/TAO/tests/Blocking_Sync_None/Blocking_Sync_None.h index a7ac6065f56..8e970e76ee4 100644 --- a/TAO/tests/Blocking_Sync_None/Blocking_Sync_None.h +++ b/TAO/tests/Blocking_Sync_None/Blocking_Sync_None.h @@ -26,11 +26,11 @@ public: // = The skeleton methods virtual void slow_operation (const Test::Payload &the_payload, - CORBA::ULong sleep_microseconds, - CORBA::Environment &ACE_TRY_ENV) + CORBA::ULong sleep_microseconds + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Blocking_Sync_None/client.cpp b/TAO/tests/Blocking_Sync_None/client.cpp index 72ac3fcc768..0a10da916d4 100644 --- a/TAO/tests/Blocking_Sync_None/client.cpp +++ b/TAO/tests/Blocking_Sync_None/client.cpp @@ -19,19 +19,19 @@ parse_args (int argc, char *argv[]) switch (c) { case 'k': - ior = get_opts.optarg; - break; + ior = get_opts.optarg; + break; case 'i': - iterations = ACE_OS::atoi (get_opts.optarg); - break; + iterations = ACE_OS::atoi (get_opts.optarg); + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-k <ior> " - "-i <iterations> " + "-k <ior> " + "-i <iterations> " "\n", argv [0]), -1); @@ -46,18 +46,18 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = - orb->string_to_object(ior, ACE_TRY_ENV); + orb->string_to_object(ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Blocking_Sync_None_var blocking_sync_none = - Test::Blocking_Sync_None::_narrow(tmp.in (), ACE_TRY_ENV); + Test::Blocking_Sync_None::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (blocking_sync_none.in ())) @@ -67,11 +67,11 @@ main (int argc, char *argv[]) 1); CORBA::Object_var object = - orb->resolve_initial_references ("PolicyCurrent", ACE_TRY_ENV); + orb->resolve_initial_references ("PolicyCurrent" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyCurrent_var policy_current = - CORBA::PolicyCurrent::_narrow (object.in (), ACE_TRY_ENV); + CORBA::PolicyCurrent::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (policy_current.in ())) @@ -85,15 +85,15 @@ main (int argc, char *argv[]) CORBA::PolicyList policies(1); policies.length (1); policies[0] = orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE, - scope_as_any, - ACE_TRY_ENV); + scope_as_any + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - policy_current->set_policy_overrides (policies, CORBA::ADD_OVERRIDE, - ACE_TRY_ENV); + policy_current->set_policy_overrides (policies, CORBA::ADD_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - policies[0]->destroy (ACE_TRY_ENV); + policies[0]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; const int payload_length = 65536; @@ -110,8 +110,8 @@ main (int argc, char *argv[]) ACE_Time_Value start = ACE_OS::gettimeofday (); blocking_sync_none->slow_operation (payload, - sleep_microseconds, - ACE_TRY_ENV); + sleep_microseconds + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_Time_Value elapsed = ACE_OS::gettimeofday (); @@ -123,10 +123,10 @@ main (int argc, char *argv[]) } } - blocking_sync_none->shutdown (ACE_TRY_ENV); + blocking_sync_none->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (blocked_calls > iterations / 20) diff --git a/TAO/tests/Blocking_Sync_None/server.cpp b/TAO/tests/Blocking_Sync_None/server.cpp index cd20f410a85..87bed6de345 100644 --- a/TAO/tests/Blocking_Sync_None/server.cpp +++ b/TAO/tests/Blocking_Sync_None/server.cpp @@ -17,14 +17,14 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -39,15 +39,15 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (root_poa.in ())) @@ -56,7 +56,7 @@ main (int argc, char *argv[]) 1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -69,11 +69,11 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var owner_transfer(blocking_sync_none_impl); Test::Blocking_Sync_None_var blocking_sync_none = - blocking_sync_none_impl->_this (ACE_TRY_ENV); + blocking_sync_none_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (blocking_sync_none.in (), ACE_TRY_ENV); + orb->object_to_string (blocking_sync_none.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -82,22 +82,22 @@ main (int argc, char *argv[]) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_output_file), - 1); + 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/CDR/basic_types.cpp b/TAO/tests/CDR/basic_types.cpp index b7b23188e72..6933e23c293 100644 --- a/TAO/tests/CDR/basic_types.cpp +++ b/TAO/tests/CDR/basic_types.cpp @@ -61,8 +61,6 @@ test_put (TAO_OutputCDR &cdr, CDR_Test_Types &test_types) { for (int i = 0; i < n; ++i) { - CORBA::Environment env; - if (cdr.write_octet (test_types.o) == 0) ACE_ERROR_RETURN ((LM_ERROR, "write_octet[%d] failed\n", @@ -113,8 +111,6 @@ test_get (TAO_InputCDR &cdr, const CDR_Test_Types &test_types) CORBA::Long xl; CORBA::Any any; - CORBA::Environment env; - for (int i = 0; i < n; ++i) { if (cdr.read_octet (xo) == 0) @@ -216,8 +212,8 @@ main (int argc, char *argv[]) { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_Get_Opt get_opt (argc, argv, "dn:l:"); diff --git a/TAO/tests/CDR/tc.cpp b/TAO/tests/CDR/tc.cpp index 65b66e0ba66..c82887f6eae 100644 --- a/TAO/tests/CDR/tc.cpp +++ b/TAO/tests/CDR/tc.cpp @@ -32,8 +32,8 @@ main (int argc, char *argv[]) { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; static const CORBA::TypeCode_ptr tcs[]= @@ -104,7 +104,7 @@ main (int argc, char *argv[]) { CORBA::TypeCode_ptr tc = *i; - CORBA::TCKind k = tc->kind (ACE_TRY_ENV); + CORBA::TCKind k = tc->kind (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; switch (k) @@ -116,10 +116,10 @@ main (int argc, char *argv[]) case CORBA::tk_alias: case CORBA::tk_except: { - const char *id = tc->id (ACE_TRY_ENV); + const char *id = tc->id (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - const char *name = tc->name (ACE_TRY_ENV); + const char *name = tc->name (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::ULong length = 0; diff --git a/TAO/tests/Cache_Growth_Test/Hello.cpp b/TAO/tests/Cache_Growth_Test/Hello.cpp index 038663b416a..c1cb89ae728 100644 --- a/TAO/tests/Cache_Growth_Test/Hello.cpp +++ b/TAO/tests/Cache_Growth_Test/Hello.cpp @@ -14,7 +14,7 @@ Hello::Hello (CORBA::ORB_ptr orb) } char * -Hello::get_string (CORBA::Environment &) +Hello::get_string (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { if (this->orb_->orb_core ()->lane_resources ().transport_cache ().current_size () > 1) @@ -27,8 +27,8 @@ Hello::get_string (CORBA::Environment &) } void -Hello::shutdown (CORBA::Environment &ACE_TRY_ENV) +Hello::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/Cache_Growth_Test/Hello.h b/TAO/tests/Cache_Growth_Test/Hello.h index 5fa393ab4b7..2222cb5236d 100644 --- a/TAO/tests/Cache_Growth_Test/Hello.h +++ b/TAO/tests/Cache_Growth_Test/Hello.h @@ -25,10 +25,10 @@ public: Hello (CORBA::ORB_ptr orb); // = The skeleton methods - virtual char * get_string (CORBA::Environment &ACE_TRY_ENV) + virtual char * get_string (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Cache_Growth_Test/client.cpp b/TAO/tests/Cache_Growth_Test/client.cpp index 5b5a1609a68..cfa57e4609b 100644 --- a/TAO/tests/Cache_Growth_Test/client.cpp +++ b/TAO/tests/Cache_Growth_Test/client.cpp @@ -45,18 +45,18 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = - orb->string_to_object(ior, ACE_TRY_ENV); + orb->string_to_object(ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Hello_var hello = - Test::Hello::_narrow(tmp.in (), ACE_TRY_ENV); + Test::Hello::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (hello.in ())) @@ -68,7 +68,7 @@ main (int argc, char *argv[]) } CORBA::String_var the_string = - hello->get_string (ACE_TRY_ENV); + hello->get_string (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "(%P|%t) - string returned <%s>\n", @@ -76,11 +76,11 @@ main (int argc, char *argv[]) if (do_shutdown) { - hello->shutdown (ACE_TRY_ENV); + hello->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Cache_Growth_Test/server.cpp b/TAO/tests/Cache_Growth_Test/server.cpp index 339a0d5ab71..37e44cc4c33 100644 --- a/TAO/tests/Cache_Growth_Test/server.cpp +++ b/TAO/tests/Cache_Growth_Test/server.cpp @@ -17,14 +17,14 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -39,15 +39,15 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (root_poa.in ())) @@ -56,7 +56,7 @@ main (int argc, char *argv[]) 1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -69,11 +69,11 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var owner_transfer(hello_impl); Test::Hello_var hello = - hello_impl->_this (ACE_TRY_ENV); + hello_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (hello.in (), ACE_TRY_ENV); + orb->object_to_string (hello.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -82,22 +82,22 @@ main (int argc, char *argv[]) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_output_file), - 1); + 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Client_Leaks/Client_Task.cpp b/TAO/tests/Client_Leaks/Client_Task.cpp index bc057b1d6c6..2e7d2ebc5c8 100644 --- a/TAO/tests/Client_Leaks/Client_Task.cpp +++ b/TAO/tests/Client_Leaks/Client_Task.cpp @@ -30,12 +30,12 @@ Client_Task::svc (void) ACE_TRY { - this->validate_connection (ACE_TRY_ENV); + this->validate_connection (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; for (int i = 0; i != this->iterations_; ++i) { - int retval = this->one_iteration (ACE_TRY_ENV); + int retval = this->one_iteration (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (retval != 0) @@ -65,13 +65,13 @@ Client_Task::svc (void) } void -Client_Task::validate_connection (CORBA::Environment &ACE_TRY_ENV) +Client_Task::validate_connection (TAO_ENV_SINGLE_ARG_DECL) { ACE_TRY { for (int i = 0; i != 100; ++i) { - (void) this->process_factory_->noop (ACE_TRY_ENV); + (void) this->process_factory_->noop (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } @@ -84,18 +84,18 @@ Client_Task::validate_connection (CORBA::Environment &ACE_TRY_ENV) } int -Client_Task::one_iteration (CORBA::Environment &ACE_TRY_ENV) +Client_Task::one_iteration (TAO_ENV_SINGLE_ARG_DECL) { ACE_TRY { Test::Process_var process = - this->process_factory_->create_new_process (ACE_TRY_ENV); + this->process_factory_->create_new_process (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - (void) process->get_process_id (ACE_TRY_ENV); + (void) process->get_process_id (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - process->shutdown (ACE_TRY_ENV); + process->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; return 1; diff --git a/TAO/tests/Client_Leaks/Client_Task.h b/TAO/tests/Client_Leaks/Client_Task.h index 0b47599a18d..bf1cdcbe900 100644 --- a/TAO/tests/Client_Leaks/Client_Task.h +++ b/TAO/tests/Client_Leaks/Client_Task.h @@ -29,10 +29,10 @@ public: private: /// Run one iteration of the test - int one_iteration (CORBA::Environment &ACE_TRY_ENV); + int one_iteration (TAO_ENV_SINGLE_ARG_DECL); /// Make sure that the thread has a connection available - void validate_connection (CORBA::Environment &ACE_TRY_ENV); + void validate_connection (TAO_ENV_SINGLE_ARG_DECL); private: /// Reference to the test interface diff --git a/TAO/tests/Client_Leaks/Process.cpp b/TAO/tests/Client_Leaks/Process.cpp index 89de1eb0279..f7135b2fab6 100644 --- a/TAO/tests/Client_Leaks/Process.cpp +++ b/TAO/tests/Client_Leaks/Process.cpp @@ -11,16 +11,16 @@ Process::Process (CORBA::ORB_ptr orb) } CORBA::Long -Process::get_process_id (CORBA::Environment &) +Process::get_process_id (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return ACE_OS::getpid (); } void -Process::shutdown (CORBA::Environment &ACE_TRY_ENV) +Process::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); ACE_CHECK; } diff --git a/TAO/tests/Client_Leaks/Process.h b/TAO/tests/Client_Leaks/Process.h index 6185df21a29..e2c74fcf62a 100644 --- a/TAO/tests/Client_Leaks/Process.h +++ b/TAO/tests/Client_Leaks/Process.h @@ -25,10 +25,10 @@ public: Process (CORBA::ORB_ptr orb); // = The skeleton methods - virtual CORBA::Long get_process_id (CORBA::Environment &ACE_TRY_ENV) + virtual CORBA::Long get_process_id (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Client_Leaks/Process_Factory.cpp b/TAO/tests/Client_Leaks/Process_Factory.cpp index cc58bd7ee74..48bfb96e6d7 100644 --- a/TAO/tests/Client_Leaks/Process_Factory.cpp +++ b/TAO/tests/Client_Leaks/Process_Factory.cpp @@ -20,7 +20,7 @@ Process_Factory::shutdown_received (void) } Test::Process_ptr -Process_Factory::create_new_process (CORBA::Environment &ACE_TRY_ENV) +Process_Factory::create_new_process (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException,Test::Spawn_Failed)) { Startup_Callback *startup_callback_impl; @@ -32,11 +32,11 @@ Process_Factory::create_new_process (CORBA::Environment &ACE_TRY_ENV) PortableServer::ServantBase_var owner_transfer(startup_callback_impl); Test::Startup_Callback_var startup_callback = - startup_callback_impl->_this (ACE_TRY_ENV); + startup_callback_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (Test::Process::_nil ()); CORBA::String_var ior = - this->orb_->object_to_string (startup_callback.in (), ACE_TRY_ENV); + this->orb_->object_to_string (startup_callback.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (Test::Process::_nil ()); const char* argv[3] = { @@ -68,7 +68,7 @@ Process_Factory::create_new_process (CORBA::Environment &ACE_TRY_ENV) for (int i = 0; i != 500 && !process_has_started; ++i) { ACE_Time_Value interval (0, 10000); - this->orb_->perform_work (interval, ACE_TRY_ENV); + this->orb_->perform_work (interval TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (Test::Process::_nil ()); process_has_started = @@ -78,12 +78,12 @@ Process_Factory::create_new_process (CORBA::Environment &ACE_TRY_ENV) ACE_TRY { PortableServer::POA_var poa = - startup_callback_impl->_default_POA (ACE_TRY_ENV); + startup_callback_impl->_default_POA (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::ObjectId_var id = - poa->servant_to_id (startup_callback_impl, ACE_TRY_ENV); + poa->servant_to_id (startup_callback_impl TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - poa->deactivate_object (id.in (), ACE_TRY_ENV); + poa->deactivate_object (id.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -104,15 +104,15 @@ Process_Factory::create_new_process (CORBA::Environment &ACE_TRY_ENV) } void -Process_Factory::noop (CORBA::Environment &) +Process_Factory::noop (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { } void -Process_Factory::shutdown (CORBA::Environment &ACE_TRY_ENV) +Process_Factory::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { this->shutdown_received_ = 1; - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/Client_Leaks/Process_Factory.h b/TAO/tests/Client_Leaks/Process_Factory.h index 728ebb0d8f2..dffc1f930b0 100644 --- a/TAO/tests/Client_Leaks/Process_Factory.h +++ b/TAO/tests/Client_Leaks/Process_Factory.h @@ -28,13 +28,13 @@ public: int shutdown_received (void); // = The skeleton methods - virtual Test::Process_ptr create_new_process (CORBA::Environment &ACE_TRY_ENV) + virtual Test::Process_ptr create_new_process (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException,Test::Spawn_Failed)); - virtual void noop (CORBA::Environment &ACE_TRY_ENV) + virtual void noop (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Client_Leaks/Server_Task.cpp b/TAO/tests/Client_Leaks/Server_Task.cpp index 9c8eaa266ad..21935bbec89 100644 --- a/TAO/tests/Client_Leaks/Server_Task.cpp +++ b/TAO/tests/Client_Leaks/Server_Task.cpp @@ -22,7 +22,7 @@ Server_Task::svc (void) { // run the test for at most 120 seconds... // ACE_Time_Value tv (120, 0); - this->orb_->run ( /* tv, */ ACE_TRY_ENV); + this->orb_->run ( /* tv, */ TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Client_Leaks/Startup_Callback.cpp b/TAO/tests/Client_Leaks/Startup_Callback.cpp index 5b82a0586aa..6c55a96b5a0 100644 --- a/TAO/tests/Client_Leaks/Startup_Callback.cpp +++ b/TAO/tests/Client_Leaks/Startup_Callback.cpp @@ -22,8 +22,8 @@ Startup_Callback::process_has_started (Test::Process_out the_process) } void -Startup_Callback::started (Test::Process_ptr process, - CORBA::Environment &) +Startup_Callback::started (Test::Process_ptr process + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->mutex_); diff --git a/TAO/tests/Client_Leaks/Startup_Callback.h b/TAO/tests/Client_Leaks/Startup_Callback.h index 51a83a8c39b..e5b6c619ef4 100644 --- a/TAO/tests/Client_Leaks/Startup_Callback.h +++ b/TAO/tests/Client_Leaks/Startup_Callback.h @@ -32,8 +32,8 @@ public: int process_has_started (Test::Process_out the_process); // = The skeleton methods - virtual void started (Test::Process_ptr the_process, - CORBA::Environment &ACE_TRY_ENV) + virtual void started (Test::Process_ptr the_process + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Client_Leaks/child.cpp b/TAO/tests/Client_Leaks/child.cpp index b0205868b58..b2d66aae41a 100644 --- a/TAO/tests/Client_Leaks/child.cpp +++ b/TAO/tests/Client_Leaks/child.cpp @@ -11,14 +11,14 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (argc < 2) { // Paranoia, we should have an auto_ptr-like gadget for // this. - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_ERROR_RETURN ((LM_ERROR, @@ -27,10 +27,10 @@ main (int argc, char *argv[]) } CORBA::Object_var object = - orb->string_to_object (argv[1], ACE_TRY_ENV); + orb->string_to_object (argv[1] TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Startup_Callback_var startup_callback = - Test::Startup_Callback::_narrow (object.in (), ACE_TRY_ENV); + Test::Startup_Callback::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (startup_callback.in ())) { @@ -40,11 +40,11 @@ main (int argc, char *argv[]) } CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (root_poa.in ())) @@ -53,7 +53,7 @@ main (int argc, char *argv[]) 1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Process *process_impl; @@ -63,23 +63,23 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var owner_transfer(process_impl); Test::Process_var process = - process_impl->_this (ACE_TRY_ENV); + process_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - startup_callback->started (process.in (), ACE_TRY_ENV); + startup_callback->started (process.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_Time_Value tv (50, 0); - orb->run (tv, ACE_TRY_ENV); + orb->run (tv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Client_Leaks/client.cpp b/TAO/tests/Client_Leaks/client.cpp index cd4765cd026..9366170a104 100644 --- a/TAO/tests/Client_Leaks/client.cpp +++ b/TAO/tests/Client_Leaks/client.cpp @@ -19,24 +19,24 @@ parse_args (int argc, char *argv[]) switch (c) { case 'k': - ior = get_opts.optarg; - break; + ior = get_opts.optarg; + break; case 'i': - iterations = ACE_OS::atoi (get_opts.optarg); - break; + iterations = ACE_OS::atoi (get_opts.optarg); + break; case 'n': - threads = ACE_OS::atoi (get_opts.optarg); - break; + threads = ACE_OS::atoi (get_opts.optarg); + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-k <ior> " - "-i <iterations> " - "-i <threads> " + "-k <ior> " + "-i <iterations> " + "-i <threads> " "\n", argv [0]), -1); @@ -51,18 +51,18 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = - orb->string_to_object(ior, ACE_TRY_ENV); + orb->string_to_object(ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Process_Factory_var process_factory = - Test::Process_Factory::_narrow(tmp.in (), ACE_TRY_ENV); + Test::Process_Factory::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (process_factory.in ())) @@ -83,10 +83,10 @@ main (int argc, char *argv[]) } ACE_Thread_Manager::instance ()->wait (); - process_factory->shutdown (ACE_TRY_ENV); + process_factory->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Only pass the test if 90% of the calls worked diff --git a/TAO/tests/Client_Leaks/server.cpp b/TAO/tests/Client_Leaks/server.cpp index f6e61ccf181..185626ebe56 100644 --- a/TAO/tests/Client_Leaks/server.cpp +++ b/TAO/tests/Client_Leaks/server.cpp @@ -18,13 +18,13 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -39,15 +39,15 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (root_poa.in ())) @@ -56,7 +56,7 @@ main (int argc, char *argv[]) 1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -69,11 +69,11 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var owner_transfer(process_factory_impl); Test::Process_Factory_var process = - process_factory_impl->_this (ACE_TRY_ENV); + process_factory_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (process.in (), ACE_TRY_ENV); + orb->object_to_string (process.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -82,11 +82,11 @@ main (int argc, char *argv[]) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_output_file), - 1); + 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Server_Task server_task (orb.in (), @@ -101,10 +101,10 @@ main (int argc, char *argv[]) ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Codec/client.cpp b/TAO/tests/Codec/client.cpp index d70e9172f54..29062b2a642 100644 --- a/TAO/tests/Codec/client.cpp +++ b/TAO/tests/Codec/client.cpp @@ -39,21 +39,21 @@ verify_data (Foo::Bar *original, Foo::Bar *extracted) int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "my_orb", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "my_orb" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Obtain a reference to the CodecFactory. CORBA::Object_var obj = - orb->resolve_initial_references ("CodecFactory", - ACE_TRY_ENV); + orb->resolve_initial_references ("CodecFactory" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; IOP::CodecFactory_var codec_factory = - IOP::CodecFactory::_narrow (obj.in (), ACE_TRY_ENV); + IOP::CodecFactory::_narrow (obj.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // ---------------------------------------------------------- @@ -67,7 +67,7 @@ main (int argc, char *argv[]) // Obtain the CDR encapsulation Codec. IOP::Codec_var codec = - codec_factory->create_codec (encoding, ACE_TRY_ENV); + codec_factory->create_codec (encoding TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // ---------------------------------------------------------- @@ -101,11 +101,11 @@ main (int argc, char *argv[]) // Start out with the encode() method, i.e. the one that // includes the TypeCode in the CDR encapsulation. - encoded_data = codec->encode (data, ACE_TRY_ENV); + encoded_data = codec->encode (data TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Extract the data from the octet sequence. - decoded_data = codec->decode (encoded_data.in (), ACE_TRY_ENV); + decoded_data = codec->decode (encoded_data.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; decoded_data.in() >>= extracted_value; @@ -127,13 +127,13 @@ main (int argc, char *argv[]) // Now use the encode_value() method, i.e. the one that does // *not* include the TypeCode in the CDR encapsulation. - encoded_data = codec->encode_value (data, ACE_TRY_ENV); + encoded_data = codec->encode_value (data TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Extract the data from the octet sequence. decoded_data = codec->decode_value (encoded_data.in (), - Foo::_tc_Bar, - ACE_TRY_ENV); + Foo::_tc_Bar + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; decoded_data.in() >>= extracted_value; diff --git a/TAO/tests/Collocation/Collocation.cpp b/TAO/tests/Collocation/Collocation.cpp index d27105582f2..d0e720b64a0 100644 --- a/TAO/tests/Collocation/Collocation.cpp +++ b/TAO/tests/Collocation/Collocation.cpp @@ -13,13 +13,13 @@ int main (int argc, char *argv[]) { Collocation_Test coll_test; - coll_test.init (argc, argv, ACE_TRY_ENV); + coll_test.init (argc, argv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - coll_test.run (ACE_TRY_ENV); + coll_test.run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - coll_test.shutdown (ACE_TRY_ENV); + coll_test.shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Collocation/Collocation_Tester.cpp b/TAO/tests/Collocation/Collocation_Tester.cpp index 7dba0e02c44..c179cc0c9dd 100644 --- a/TAO/tests/Collocation/Collocation_Tester.cpp +++ b/TAO/tests/Collocation/Collocation_Tester.cpp @@ -21,19 +21,19 @@ Collocation_Test::Collocation_Test (void) } void -Collocation_Test::shutdown (CORBA::Environment &ACE_TRY_ENV) +Collocation_Test::shutdown (TAO_ENV_SINGLE_ARG_DECL) { - this->root_poa_->destroy (1, 1, ACE_TRY_ENV); + this->root_poa_->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; - this->orb_->destroy (ACE_TRY_ENV); + this->orb_->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; } int -Collocation_Test::init (int argc, char *argv[], CORBA::Environment &ACE_TRY_ENV) +Collocation_Test::init (int argc, char *argv[] TAO_ENV_ARG_DECL) { // Initialize the ORB. - this->orb_ = CORBA::ORB_init (argc, argv, 0, ACE_TRY_ENV); + this->orb_ = CORBA::ORB_init (argc, argv, 0 TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); int result = this->parse_args (argc, argv); @@ -42,52 +42,52 @@ Collocation_Test::init (int argc, char *argv[], CORBA::Environment &ACE_TRY_ENV) // Get an Object reference to RootPOA. CORBA::Object_var obj = - this->orb_->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + this->orb_->resolve_initial_references ("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Narrow the Object reference to a POA reference this->root_poa_ = - PortableServer::POA::_narrow (obj.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (obj.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Get the POAManager of RootPOA this->poa_manager_ = - this->root_poa_->the_POAManager (ACE_TRY_ENV); + this->root_poa_->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Activate the diamond servant and its base classes under RootPOA. PortableServer::ObjectId_var id = - this->root_poa_->activate_object (&this->top_servant_, - ACE_TRY_ENV); + this->root_poa_->activate_object (&this->top_servant_ + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // // We only care about the most derived class here. -// this->diamond_obj_ = this->diamond_servant_._this (ACE_TRY_ENV); +// this->diamond_obj_ = this->diamond_servant_._this (TAO_ENV_SINGLE_ARG_PARAMETER); // ACE_CHECK_RETURN (-1); id = - this->root_poa_->activate_object (&this->diamond_servant_, - ACE_TRY_ENV); + this->root_poa_->activate_object (&this->diamond_servant_ + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // We only care about the most derived class here. - this->diamond_obj_ = this->root_poa_->id_to_reference (id.in (), - ACE_TRY_ENV); + this->diamond_obj_ = this->root_poa_->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); id = - this->root_poa_->activate_object (&this->left_servant_, - ACE_TRY_ENV); + this->root_poa_->activate_object (&this->left_servant_ + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); id = - this->root_poa_->activate_object (&this->right_servant_, - ACE_TRY_ENV); + this->root_poa_->activate_object (&this->right_servant_ + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::String_var str = - this->orb_->object_to_string (this->diamond_obj_.in (), - ACE_TRY_ENV); + this->orb_->object_to_string (this->diamond_obj_.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, "Diamond Servant activated:\n %s\n", @@ -106,37 +106,37 @@ Collocation_Test::parse_args (int /*argc*/, } int -Collocation_Test::test_narrow (CORBA::Environment &ACE_TRY_ENV) +Collocation_Test::test_narrow (TAO_ENV_SINGLE_ARG_DECL) { Diamond::Top_var top = - Diamond::Top::_narrow (this->diamond_obj_.in (), ACE_TRY_ENV); + Diamond::Top::_narrow (this->diamond_obj_.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); Diamond::Left_var left = - Diamond::Left::_narrow (this->diamond_obj_.in (), ACE_TRY_ENV); + Diamond::Left::_narrow (this->diamond_obj_.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); Diamond::Right_var right = - Diamond::Right::_narrow (this->diamond_obj_.in (), ACE_TRY_ENV); + Diamond::Right::_narrow (this->diamond_obj_.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); Diamond::Buttom_var buttom = - Diamond::Buttom::_narrow (this->diamond_obj_.in (), ACE_TRY_ENV); + Diamond::Buttom::_narrow (this->diamond_obj_.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); - CORBA::String_var str = top->shape (ACE_TRY_ENV); + CORBA::String_var str = top->shape (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, "Calling top->shape: %s\n", str.in ())); - str = left->shape (ACE_TRY_ENV); + str = left->shape (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, "Calling left->shape: %s\n", str.in ())); - str = right->shape (ACE_TRY_ENV); + str = right->shape (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, "Calling right->shape: %s\n", str.in ())); - str = buttom->shape (ACE_TRY_ENV); + str = buttom->shape (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, "Calling buttom->shape: %s\n", str.in ())); @@ -144,12 +144,12 @@ Collocation_Test::test_narrow (CORBA::Environment &ACE_TRY_ENV) } int -Collocation_Test::run (CORBA::Environment &ACE_TRY_ENV) +Collocation_Test::run (TAO_ENV_SINGLE_ARG_DECL) { - this->poa_manager_->activate (ACE_TRY_ENV); + this->poa_manager_->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); - this->test_narrow (ACE_TRY_ENV); + this->test_narrow (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); return 0; diff --git a/TAO/tests/Collocation/Collocation_Tester.h b/TAO/tests/Collocation/Collocation_Tester.h index 584710a098a..ee51d2fa1f0 100644 --- a/TAO/tests/Collocation/Collocation_Tester.h +++ b/TAO/tests/Collocation/Collocation_Tester.h @@ -29,19 +29,19 @@ class Collocation_Test public: Collocation_Test (void); - void shutdown (CORBA::Environment &ACE_TRY_ENV); + void shutdown (TAO_ENV_SINGLE_ARG_DECL); - int init (int argc, char *argv[], CORBA::Environment &); + int init (int argc, char *argv[] TAO_ENV_ARG_DECL_NOT_USED); // Initializing the Collocation_Test object. int parse_args (int argc, char *argv[]); // Parse the test specific arguments. - int test_narrow (CORBA::Environment &); + int test_narrow (TAO_ENV_SINGLE_ARG_DECL_NOT_USED); // This test narrow an object reference to its base class and see // if it works correctly. - int run (CORBA::Environment &); + int run (TAO_ENV_SINGLE_ARG_DECL_NOT_USED); // Run the test. private: diff --git a/TAO/tests/Collocation/Diamond_i.cpp b/TAO/tests/Collocation/Diamond_i.cpp index 204f22da198..149c2aed27b 100644 --- a/TAO/tests/Collocation/Diamond_i.cpp +++ b/TAO/tests/Collocation/Diamond_i.cpp @@ -13,7 +13,7 @@ Top_i::~Top_i () } char * -Top_i::shape (CORBA::Environment &) +Top_i::shape (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC (( CORBA::SystemException )) @@ -32,7 +32,7 @@ Left_i::~Left_i () } char * -Left_i::shape (CORBA::Environment &) +Left_i::shape (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC (( CORBA::SystemException )) @@ -41,7 +41,7 @@ Left_i::shape (CORBA::Environment &) } char * -Left_i::color (CORBA::Environment &) +Left_i::color (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC (( CORBA::SystemException )) @@ -60,7 +60,7 @@ Right_i::~Right_i () } char * -Right_i::shape (CORBA::Environment &) +Right_i::shape (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC (( CORBA::SystemException )) @@ -69,7 +69,7 @@ Right_i::shape (CORBA::Environment &) } char * -Right_i::color (CORBA::Environment &) +Right_i::color (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC (( CORBA::SystemException )) @@ -79,7 +79,7 @@ Right_i::color (CORBA::Environment &) } CORBA::Long -Right_i::width (CORBA::Environment &) +Right_i::width (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC (( CORBA::SystemException )) @@ -98,7 +98,7 @@ Buttom_i::~Buttom_i () } char * -Buttom_i::shape (CORBA::Environment &) +Buttom_i::shape (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC (( CORBA::SystemException )) @@ -107,7 +107,7 @@ Buttom_i::shape (CORBA::Environment &) } char * -Buttom_i::color (CORBA::Environment &) +Buttom_i::color (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC (( CORBA::SystemException )) @@ -116,7 +116,7 @@ Buttom_i::color (CORBA::Environment &) } CORBA::Long -Buttom_i::width (CORBA::Environment &) +Buttom_i::width (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC (( CORBA::SystemException )) @@ -125,7 +125,7 @@ Buttom_i::width (CORBA::Environment &) } char * -Buttom_i::name (CORBA::Environment &) +Buttom_i::name (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC (( CORBA::SystemException )) diff --git a/TAO/tests/Collocation/Diamond_i.h b/TAO/tests/Collocation/Diamond_i.h index 6aaecc464f3..4d3ba4293b5 100644 --- a/TAO/tests/Collocation/Diamond_i.h +++ b/TAO/tests/Collocation/Diamond_i.h @@ -17,7 +17,7 @@ public: ~Top_i (void); // Ctor and dtor. - virtual char * shape (CORBA::Environment &) + virtual char * shape (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); // Return the shape of this object (interface.) }; @@ -29,11 +29,11 @@ public: ~Left_i (void); // Ctor, dtor. - virtual char * shape (CORBA::Environment &) + virtual char * shape (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); // Return the shape of this object (interface.) - virtual char * color (CORBA::Environment &) + virtual char * color (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); // Return the color of this object (interface.) }; @@ -45,15 +45,15 @@ public: ~Right_i (void); // Ctor, dtor. - virtual char * shape (CORBA::Environment &) + virtual char * shape (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); // Return the shape of this object (interface.) - virtual char * color (CORBA::Environment &) + virtual char * color (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); // Return the color of this object (interface.) - virtual CORBA::Long width (CORBA::Environment &) + virtual CORBA::Long width (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); // Return the width of the stuff. }; @@ -65,19 +65,19 @@ public: ~Buttom_i (void); // Ctor, dtor. - virtual char * shape (CORBA::Environment &) + virtual char * shape (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); // Return the shape of this object (interface.) - virtual char * color (CORBA::Environment &) + virtual char * color (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); // Return the color of this object (interface.) - virtual CORBA::Long width (CORBA::Environment &) + virtual CORBA::Long width (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); // Return the width of the stuff. - virtual char * name (CORBA::Environment &) + virtual char * name (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); // Return the name of the object. }; diff --git a/TAO/tests/Connection_Purging/client.cpp b/TAO/tests/Connection_Purging/client.cpp index 81bfb90f63e..b253b9f4dbc 100644 --- a/TAO/tests/Connection_Purging/client.cpp +++ b/TAO/tests/Connection_Purging/client.cpp @@ -38,7 +38,7 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -58,11 +58,11 @@ main (int argc, char *argv[]) { iorfile = "file://" + iorfile; CORBA::Object_var tmp = - orb->string_to_object(iorfile.c_str (), ACE_TRY_ENV); + orb->string_to_object(iorfile.c_str () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; test_var test = - test::_narrow(tmp.in (), ACE_TRY_ENV); + test::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (test.in ())) @@ -73,14 +73,14 @@ main (int argc, char *argv[]) 1); } - test->send_stuff ("Some stuff to send", ACE_TRY_ENV); + test->send_stuff ("Some stuff to send" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK // Test for LFU strategy. The transport to any other // server should be removed before the first one. if (i == 0) { - test->send_stuff ("Some stuff to send", ACE_TRY_ENV); + test->send_stuff ("Some stuff to send" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK holder = test; @@ -91,7 +91,7 @@ main (int argc, char *argv[]) // removed. if (!CORBA::is_nil(holder.in ())) { - holder->send_stuff ("Some stuff to send", ACE_TRY_ENV); + holder->send_stuff ("Some stuff to send" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK } } @@ -102,10 +102,10 @@ main (int argc, char *argv[]) } } - orb->shutdown (1, ACE_TRY_ENV); + orb->shutdown (1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Connection_Purging/server.cpp b/TAO/tests/Connection_Purging/server.cpp index 9b66cb607e1..d8972b2362a 100644 --- a/TAO/tests/Connection_Purging/server.cpp +++ b/TAO/tests/Connection_Purging/server.cpp @@ -38,15 +38,15 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (root_poa.in ())) @@ -55,7 +55,7 @@ main (int argc, char *argv[]) 1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -68,11 +68,11 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var owner_transfer(test_impl); test_var test = - test_impl->_this (ACE_TRY_ENV); + test_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (test.in (), ACE_TRY_ENV); + orb->object_to_string (test.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -85,19 +85,19 @@ main (int argc, char *argv[]) ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); delete test_impl; - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Connection_Purging/test_i.cpp b/TAO/tests/Connection_Purging/test_i.cpp index ad27e9ee1b1..9f69f9e1ec0 100644 --- a/TAO/tests/Connection_Purging/test_i.cpp +++ b/TAO/tests/Connection_Purging/test_i.cpp @@ -4,8 +4,8 @@ #include "test_i.h" void -test_i::send_stuff (const char* string, - CORBA::Environment &) +test_i::send_stuff (const char* string + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "TAO (%P|%t) - %s\n", string)); diff --git a/TAO/tests/Connection_Purging/test_i.h b/TAO/tests/Connection_Purging/test_i.h index 40c180558ac..b862bd1e806 100644 --- a/TAO/tests/Connection_Purging/test_i.h +++ b/TAO/tests/Connection_Purging/test_i.h @@ -22,8 +22,8 @@ class test_i { public: // = The skeleton methods - virtual void send_stuff (const char* string, - CORBA::Environment &ACE_TRY_ENV) + virtual void send_stuff (const char* string + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Crash_On_Write/Oneway_Receiver.cpp b/TAO/tests/Crash_On_Write/Oneway_Receiver.cpp index a1ad06f81ff..db977d4d71c 100644 --- a/TAO/tests/Crash_On_Write/Oneway_Receiver.cpp +++ b/TAO/tests/Crash_On_Write/Oneway_Receiver.cpp @@ -10,7 +10,7 @@ Oneway_Receiver::Oneway_Receiver (void) } void -Oneway_Receiver::receive_oneway (CORBA::Environment &) +Oneway_Receiver::receive_oneway (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { } diff --git a/TAO/tests/Crash_On_Write/Oneway_Receiver.h b/TAO/tests/Crash_On_Write/Oneway_Receiver.h index b5865bc1d98..69eeebf4920 100644 --- a/TAO/tests/Crash_On_Write/Oneway_Receiver.h +++ b/TAO/tests/Crash_On_Write/Oneway_Receiver.h @@ -25,7 +25,7 @@ public: Oneway_Receiver (void); // = The skeleton methods - virtual void receive_oneway (CORBA::Environment &ACE_TRY_ENV) + virtual void receive_oneway (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); }; diff --git a/TAO/tests/Crash_On_Write/client.cpp b/TAO/tests/Crash_On_Write/client.cpp index 6db05eed05e..b689510cd8a 100644 --- a/TAO/tests/Crash_On_Write/client.cpp +++ b/TAO/tests/Crash_On_Write/client.cpp @@ -18,18 +18,18 @@ parse_args (int argc, char *argv[]) switch (c) { case 'k': - ior = get_opts.optarg; - break; + ior = get_opts.optarg; + break; case 'i': - iterations = ACE_OS::atoi (get_opts.optarg); - break; + iterations = ACE_OS::atoi (get_opts.optarg); + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-k <ior> " + "-k <ior> " "-i iterations " "\n", argv [0]), @@ -40,12 +40,12 @@ parse_args (int argc, char *argv[]) } int -single_iteration (Test::Oneway_Receiver_ptr oneway_receiver, - CORBA::Environment &ACE_TRY_ENV) +single_iteration (Test::Oneway_Receiver_ptr oneway_receiver + TAO_ENV_ARG_DECL) { ACE_TRY { - oneway_receiver->receive_oneway (ACE_TRY_ENV); + oneway_receiver->receive_oneway (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_Time_Value tv (0, 40000); ACE_OS::sleep (tv); @@ -64,18 +64,18 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = - orb->string_to_object(ior, ACE_TRY_ENV); + orb->string_to_object(ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Oneway_Receiver_var oneway_receiver = - Test::Oneway_Receiver::_narrow(tmp.in (), ACE_TRY_ENV); + Test::Oneway_Receiver::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (oneway_receiver.in ())) @@ -90,8 +90,8 @@ main (int argc, char *argv[]) int exception_count = 0; for (int i = 0; i != iterations; ++i) { - int result = single_iteration (oneway_receiver.in (), - ACE_TRY_ENV); + int result = single_iteration (oneway_receiver.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result) exception_count++; @@ -108,7 +108,7 @@ main (int argc, char *argv[]) if (normal_count == 0) ACE_ERROR ((LM_ERROR, "ERROR: no request was succesful\n")); - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Crash_On_Write/server.cpp b/TAO/tests/Crash_On_Write/server.cpp index c6ccb281636..6fae627ce65 100644 --- a/TAO/tests/Crash_On_Write/server.cpp +++ b/TAO/tests/Crash_On_Write/server.cpp @@ -18,14 +18,14 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -40,15 +40,15 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (root_poa.in ())) @@ -57,7 +57,7 @@ main (int argc, char *argv[]) 1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -70,11 +70,11 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var owner_transfer(oneway_receiver_impl); Test::Oneway_Receiver_var oneway_receiver = - oneway_receiver_impl->_this (ACE_TRY_ENV); + oneway_receiver_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (oneway_receiver.in (), ACE_TRY_ENV); + orb->object_to_string (oneway_receiver.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -87,7 +87,7 @@ main (int argc, char *argv[]) ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Create a separate thread to crash the server. @@ -99,16 +99,16 @@ main (int argc, char *argv[]) return 1; } - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; /*NOTREACHED*/ ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Crashed_Callback/Crashed_Callback.cpp b/TAO/tests/Crashed_Callback/Crashed_Callback.cpp index 637c20c582f..1c716d5ac16 100644 --- a/TAO/tests/Crashed_Callback/Crashed_Callback.cpp +++ b/TAO/tests/Crashed_Callback/Crashed_Callback.cpp @@ -10,14 +10,14 @@ Crashed_Callback::Crashed_Callback (void) } CORBA::Boolean -Crashed_Callback::are_you_there (CORBA::Environment &) +Crashed_Callback::are_you_there (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return 1; } void -Crashed_Callback::crash_now_please (CORBA::Environment &) +Crashed_Callback::crash_now_please (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -33,7 +33,7 @@ Crashed_Callback::crash_now_please (CORBA::Environment &) } void -Crashed_Callback::test_oneway (CORBA::Environment &) +Crashed_Callback::test_oneway (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { } diff --git a/TAO/tests/Crashed_Callback/Crashed_Callback.h b/TAO/tests/Crashed_Callback/Crashed_Callback.h index 8485d3c0c82..cc1b316356b 100644 --- a/TAO/tests/Crashed_Callback/Crashed_Callback.h +++ b/TAO/tests/Crashed_Callback/Crashed_Callback.h @@ -25,13 +25,13 @@ public: Crashed_Callback (void); // = The skeleton methods - virtual CORBA::Boolean are_you_there (CORBA::Environment &ACE_TRY_ENV) + virtual CORBA::Boolean are_you_there (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void crash_now_please (CORBA::Environment &ACE_TRY_ENV) + virtual void crash_now_please (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void test_oneway (CORBA::Environment &ACE_TRY_ENV) + virtual void test_oneway (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); }; diff --git a/TAO/tests/Crashed_Callback/Service.cpp b/TAO/tests/Crashed_Callback/Service.cpp index 3cfc1a048c4..69f2817c3ff 100644 --- a/TAO/tests/Crashed_Callback/Service.cpp +++ b/TAO/tests/Crashed_Callback/Service.cpp @@ -21,29 +21,29 @@ Service::dump_results (void) } void -Service::run_test (Test::Crashed_Callback_ptr callback, - CORBA::Environment &ACE_TRY_ENV) +Service::run_test (Test::Crashed_Callback_ptr callback + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { int pre_crash_exceptions = - this->call_are_you_there (callback, ACE_TRY_ENV); + this->call_are_you_there (callback TAO_ENV_ARG_PARAMETER); ACE_CHECK; pre_crash_exceptions += - this->call_test_oneway (callback, ACE_TRY_ENV); + this->call_test_oneway (callback TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_TRY { ACE_DEBUG ((LM_DEBUG, "(%P|%t) - Service, calling crash_now_please\n")); - callback->crash_now_please (ACE_TRY_ENV); + callback->crash_now_please (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY {} ACE_ENDTRY; int pos_crash_exceptions = - this->call_test_oneway (callback, ACE_TRY_ENV); + this->call_test_oneway (callback TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (pre_crash_exceptions != 0) @@ -69,8 +69,8 @@ Service::run_test (Test::Crashed_Callback_ptr callback, } int -Service::call_are_you_there (Test::Crashed_Callback_ptr callback, - CORBA::Environment &ACE_TRY_ENV) +Service::call_are_you_there (Test::Crashed_Callback_ptr callback + TAO_ENV_ARG_DECL) ACE_THROW_SPEC (()) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) - Service, calling are_you_there\n")); @@ -81,7 +81,7 @@ Service::call_are_you_there (Test::Crashed_Callback_ptr callback, { ACE_TRY { - (void) callback->are_you_there (ACE_TRY_ENV); + (void) callback->are_you_there (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -94,8 +94,8 @@ Service::call_are_you_there (Test::Crashed_Callback_ptr callback, } int -Service::call_test_oneway (Test::Crashed_Callback_ptr callback, - CORBA::Environment &ACE_TRY_ENV) +Service::call_test_oneway (Test::Crashed_Callback_ptr callback + TAO_ENV_ARG_DECL) ACE_THROW_SPEC (()) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) - Service, calling test_oneway\n")); @@ -106,7 +106,7 @@ Service::call_test_oneway (Test::Crashed_Callback_ptr callback, { ACE_TRY { - (void) callback->test_oneway (ACE_TRY_ENV); + (void) callback->test_oneway (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Crashed_Callback/Service.h b/TAO/tests/Crashed_Callback/Service.h index de738cf134f..8427d6d80fe 100644 --- a/TAO/tests/Crashed_Callback/Service.h +++ b/TAO/tests/Crashed_Callback/Service.h @@ -31,8 +31,8 @@ public: void dump_results (void); // = The skeleton methods - virtual void run_test (Test::Crashed_Callback_ptr callback, - CORBA::Environment &ACE_TRY_ENV) + virtual void run_test (Test::Crashed_Callback_ptr callback + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: @@ -40,16 +40,16 @@ private: /** * @return Number of exceptions raised */ - int call_are_you_there (Test::Crashed_Callback_ptr callback, - CORBA::Environment &ACE_TRY_ENV) + int call_are_you_there (Test::Crashed_Callback_ptr callback + TAO_ENV_ARG_DECL) ACE_THROW_SPEC (()); /// Call the test_oneway method mutiple times. /** * @return Number of exceptions raised */ - int call_test_oneway (Test::Crashed_Callback_ptr callback, - CORBA::Environment &ACE_TRY_ENV) + int call_test_oneway (Test::Crashed_Callback_ptr callback + TAO_ENV_ARG_DECL) ACE_THROW_SPEC (()); private: diff --git a/TAO/tests/Crashed_Callback/client.cpp b/TAO/tests/Crashed_Callback/client.cpp index 8585107b75c..7f81e47e831 100644 --- a/TAO/tests/Crashed_Callback/client.cpp +++ b/TAO/tests/Crashed_Callback/client.cpp @@ -19,13 +19,13 @@ parse_args (int argc, char *argv[]) switch (c) { case 'k': - ior = get_opts.optarg; - break; + ior = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-k <ior>" + "-k <ior>" "\n", argv [0]), -1); @@ -40,15 +40,15 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (root_poa.in ())) @@ -57,18 +57,18 @@ main (int argc, char *argv[]) 1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Make all oneways "reliable." { CORBA::Object_var manager_object = - orb->resolve_initial_references("ORBPolicyManager", - ACE_TRY_ENV); + orb->resolve_initial_references("ORBPolicyManager" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyManager_var policy_manager = - CORBA::PolicyManager::_narrow(manager_object.in(), - ACE_TRY_ENV); + CORBA::PolicyManager::_narrow(manager_object.in() + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (policy_manager.in ())) @@ -80,16 +80,16 @@ main (int argc, char *argv[]) CORBA::PolicyList policies(1); policies.length(1); policies[0] = orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE, - policy_value, - ACE_TRY_ENV); + policy_value + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; policy_manager->set_policy_overrides (policies, - CORBA::ADD_OVERRIDE, - ACE_TRY_ENV); + CORBA::ADD_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - policies[0]->destroy (ACE_TRY_ENV); + policies[0]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -97,11 +97,11 @@ main (int argc, char *argv[]) return 1; CORBA::Object_var tmp = - orb->string_to_object(ior, ACE_TRY_ENV); + orb->string_to_object(ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Service_var service = - Test::Service::_narrow(tmp.in (), ACE_TRY_ENV); + Test::Service::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (service.in ())) @@ -119,22 +119,22 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var owner_transfer(crashed_callback_impl); Test::Crashed_Callback_var crashed_callback = - crashed_callback_impl->_this (ACE_TRY_ENV); + crashed_callback_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - service->run_test (crashed_callback.in (), ACE_TRY_ENV); + service->run_test (crashed_callback.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Crashed_Callback/server.cpp b/TAO/tests/Crashed_Callback/server.cpp index 90650f28024..e0e2e637d72 100644 --- a/TAO/tests/Crashed_Callback/server.cpp +++ b/TAO/tests/Crashed_Callback/server.cpp @@ -19,13 +19,13 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -40,15 +40,15 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (root_poa.in ())) @@ -57,18 +57,18 @@ main (int argc, char *argv[]) 1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Make all oneways "reliable." { CORBA::Object_var manager_object = - orb->resolve_initial_references("ORBPolicyManager", - ACE_TRY_ENV); + orb->resolve_initial_references("ORBPolicyManager" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyManager_var policy_manager = - CORBA::PolicyManager::_narrow(manager_object.in(), - ACE_TRY_ENV); + CORBA::PolicyManager::_narrow(manager_object.in() + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (policy_manager.in ())) @@ -80,16 +80,16 @@ main (int argc, char *argv[]) CORBA::PolicyList policies(1); policies.length(1); policies[0] = orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE, - policy_value, - ACE_TRY_ENV); + policy_value + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; policy_manager->set_policy_overrides (policies, - CORBA::ADD_OVERRIDE, - ACE_TRY_ENV); + CORBA::ADD_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - policies[0]->destroy (ACE_TRY_ENV); + policies[0]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -103,11 +103,11 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var owner_transfer(service_impl); Test::Service_var service = - service_impl->_this (ACE_TRY_ENV); + service_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (service.in (), ACE_TRY_ENV); + orb->object_to_string (service.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -116,25 +116,25 @@ main (int argc, char *argv[]) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_output_file), - 1); + 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_Time_Value tv (50, 0); - orb->run (tv, ACE_TRY_ENV); + orb->run (tv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Event loop finished\n")); service_impl->dump_results (); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/DLL_ORB/Test_Client_Module.cpp b/TAO/tests/DLL_ORB/Test_Client_Module.cpp index 34d22d0a5e4..cdc2bf8fa0d 100644 --- a/TAO/tests/DLL_ORB/Test_Client_Module.cpp +++ b/TAO/tests/DLL_ORB/Test_Client_Module.cpp @@ -63,7 +63,7 @@ Test_Client_Module::init (int argc, ACE_TCHAR *argv[]) // ----------------------------------------------------------------- // Boilerplate CORBA/TAO client-side ORB initialization code. // ----------------------------------------------------------------- - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { // Prepend a "dummy" program name argument to the Service @@ -87,8 +87,8 @@ Test_Client_Module::init (int argc, ACE_TCHAR *argv[]) // Initialize the ORB. this->orb_ = CORBA::ORB_init (new_argc, new_argv.get_buffer (), - "", - ACE_TRY_ENV); + "" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (this->orb_.in ())) @@ -98,11 +98,11 @@ Test_Client_Module::init (int argc, ACE_TCHAR *argv[]) return 1; CORBA::Object_var obj = - this->orb_->string_to_object (ior, ACE_TRY_ENV); + this->orb_->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; this->test_ = - Test::_narrow (obj.in (), ACE_TRY_ENV); + Test::_narrow (obj.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (this->test_.in ())) @@ -139,13 +139,13 @@ Test_Client_Module::init (int argc, ACE_TCHAR *argv[]) int Test_Client_Module::fini (void) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { // Make sure the ORB is destroyed. if (!CORBA::is_nil (this->orb_.in ())) { - this->orb_->destroy (ACE_TRY_ENV); + this->orb_->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } @@ -184,15 +184,15 @@ Test_Client_Module::fini (void) int Test_Client_Module::svc (void) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { // Invoke an operation on the Test object. - this->test_->invoke_me (ACE_TRY_ENV); + this->test_->invoke_me (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; /// Shutdown the remote ORB. - this->test_->shutdown (ACE_TRY_ENV); + this->test_->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/DLL_ORB/Test_Server_Module.cpp b/TAO/tests/DLL_ORB/Test_Server_Module.cpp index 58166838b78..5f47b6cb1ce 100644 --- a/TAO/tests/DLL_ORB/Test_Server_Module.cpp +++ b/TAO/tests/DLL_ORB/Test_Server_Module.cpp @@ -63,7 +63,7 @@ Test_Server_Module::init (int argc, ACE_TCHAR *argv[]) // ----------------------------------------------------------------- // Boilerplate CORBA/TAO server-side ORB initialization code. // ----------------------------------------------------------------- - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { // Add one to the new argc since "dummy" is being added to the @@ -87,15 +87,15 @@ Test_Server_Module::init (int argc, ACE_TCHAR *argv[]) // Initialize the ORB. this->orb_ = CORBA::ORB_init (new_argc, new_argv.get_buffer (), - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (this->orb_.in ())) return -1; CORBA::Object_var poa_object = - this->orb_->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + this->orb_->resolve_initial_references ("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -104,23 +104,23 @@ Test_Server_Module::init (int argc, ACE_TCHAR *argv[]) 1); this->poa_ = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - this->poa_manager_ = this->poa_->the_POAManager (ACE_TRY_ENV); + this->poa_manager_ = this->poa_->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - this->poa_manager_->activate (ACE_TRY_ENV); + this->poa_manager_->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (::parse_args (new_argc, new_argv.get_buffer ()) != 0) return -1; - CORBA::Object_var obj = this->servant_._this (ACE_TRY_ENV); + CORBA::Object_var obj = this->servant_._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - this->orb_->object_to_string (obj.in (), ACE_TRY_ENV); + this->orb_->object_to_string (obj.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -165,13 +165,13 @@ Test_Server_Module::init (int argc, ACE_TCHAR *argv[]) int Test_Server_Module::fini (void) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { // Make sure the ORB is destroyed. if (!CORBA::is_nil (this->orb_.in ())) { - this->orb_->destroy (ACE_TRY_ENV); + this->orb_->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } @@ -201,11 +201,11 @@ Test_Server_Module::fini (void) int Test_Server_Module::svc (void) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { // Run the ORB event loop in its own thread. - this->orb_->run (ACE_TRY_ENV); + this->orb_->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/DLL_ORB/Test_i.cpp b/TAO/tests/DLL_ORB/Test_i.cpp index a385bba01e1..f5ee66fd980 100644 --- a/TAO/tests/DLL_ORB/Test_i.cpp +++ b/TAO/tests/DLL_ORB/Test_i.cpp @@ -12,7 +12,7 @@ Test_i::Test_i (void) } void -Test_i::invoke_me (CORBA::Environment & /* ACE_TRY_ENV */) +Test_i::invoke_me (TAO_ENV_SINGLE_ARG_DECL_NOT_USED /* TAO_ENV_SINGLE_ARG_PARAMETER */) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_INFO, @@ -20,14 +20,14 @@ Test_i::invoke_me (CORBA::Environment & /* ACE_TRY_ENV */) } void -Test_i::shutdown (CORBA::Environment &ACE_TRY_ENV) +Test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_INFO, "Server is shutting down.\n")); if (!CORBA::is_nil (this->orb_.in ())) - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } void diff --git a/TAO/tests/DLL_ORB/Test_i.h b/TAO/tests/DLL_ORB/Test_i.h index e4e3d04a920..b0f6ddb293a 100644 --- a/TAO/tests/DLL_ORB/Test_i.h +++ b/TAO/tests/DLL_ORB/Test_i.h @@ -34,13 +34,11 @@ public: /// Simple two-way operation used to excercise the ORB transport /// internals. - virtual void invoke_me (CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + virtual void invoke_me (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); /// Shutdown the ORB. - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); /// Set the ORB to be shutdown by the shutdown() method in this diff --git a/TAO/tests/DSI_Gateway/client.cpp b/TAO/tests/DSI_Gateway/client.cpp index 34b2d1be516..b90a0724f11 100644 --- a/TAO/tests/DSI_Gateway/client.cpp +++ b/TAO/tests/DSI_Gateway/client.cpp @@ -66,7 +66,7 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -75,11 +75,11 @@ main (int argc, char *argv[]) } CORBA::Object_var object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Simple_Server_var server = - Simple_Server::_narrow (object.in (), ACE_TRY_ENV); + Simple_Server::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -95,12 +95,12 @@ main (int argc, char *argv[]) if (test_user_exception == 1) { - server->raise_user_exception (ACE_TRY_ENV); + server->raise_user_exception (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } else if (test_system_exception == 1) { - server->raise_system_exception (ACE_TRY_ENV); + server->raise_system_exception (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } else @@ -116,8 +116,8 @@ main (int argc, char *argv[]) server->test_method (i, the_in_structure, the_out_structure.out (), - name.inout (), - ACE_TRY_ENV); + name.inout () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (TAO_debug_level > 0) @@ -145,7 +145,7 @@ main (int argc, char *argv[]) if (do_shutdown) { - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/tests/DSI_Gateway/gateway.cpp b/TAO/tests/DSI_Gateway/gateway.cpp index 8c639fcc85b..2dbe2dad28d 100644 --- a/TAO/tests/DSI_Gateway/gateway.cpp +++ b/TAO/tests/DSI_Gateway/gateway.cpp @@ -33,8 +33,8 @@ parse_args (int argc, char *argv[]) break; case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: @@ -43,7 +43,7 @@ parse_args (int argc, char *argv[]) "-x " "-k <ior> " "-i <niterations> " - "-o <iorfile> " + "-o <iorfile> " "\n", argv [0]), -1); @@ -59,11 +59,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -74,14 +74,14 @@ main (int argc, char *argv[]) } PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -90,46 +90,46 @@ main (int argc, char *argv[]) } CORBA::Object_var object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; DSI_Simple_Server server_impl (orb.in (), object.in (), root_poa.in ()); PortableServer::ObjectId_var oid = - root_poa->activate_object (&server_impl, - ACE_TRY_ENV); + root_poa->activate_object (&server_impl + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var server = - root_poa->id_to_reference (oid.in (), - ACE_TRY_ENV); + root_poa->id_to_reference (oid.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); // If the ior_output_file exists, output the ior to it if (ior_output_file != 0) - { - FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); + { + FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); - if (output_file == 0) + if (output_file == 0) { - ACE_ERROR_RETURN ((LM_ERROR, - "Cannot open output file for writing IOR: %s", - ior_output_file), - 1); + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot open output file for writing IOR: %s", + ior_output_file), + 1); } - ACE_OS::fprintf (output_file, "%s", ior.in ()); - ACE_OS::fclose (output_file); - } + ACE_OS::fprintf (output_file, "%s", ior.in ()); + ACE_OS::fclose (output_file); + } - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); diff --git a/TAO/tests/DSI_Gateway/server.cpp b/TAO/tests/DSI_Gateway/server.cpp index 72819309c96..7bc94dda05f 100644 --- a/TAO/tests/DSI_Gateway/server.cpp +++ b/TAO/tests/DSI_Gateway/server.cpp @@ -20,18 +20,18 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case 'n': - nthreads = ACE_OS::atoi (get_opts.optarg); - break; + nthreads = ACE_OS::atoi (get_opts.optarg); + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -46,11 +46,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -61,11 +61,11 @@ main (int argc, char *argv[]) } PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -76,36 +76,36 @@ main (int argc, char *argv[]) Simple_Server_i server_impl (orb.in ()); Simple_Server_var server = - server_impl._this (ACE_TRY_ENV); + server_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); // If the ior_output_file exists, output the ior to it if (ior_output_file != 0) - { - FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); + { + FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); - if (output_file == 0) + if (output_file == 0) { - ACE_ERROR_RETURN ((LM_ERROR, - "Cannot open output file for writing IOR: %s", - ior_output_file), - 1); + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot open output file for writing IOR: %s", + ior_output_file), + 1); } - ACE_OS::fprintf (output_file, "%s", ior.in ()); - ACE_OS::fclose (output_file); - } + ACE_OS::fprintf (output_file, "%s", ior.in ()); + ACE_OS::fclose (output_file); + } - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); diff --git a/TAO/tests/DSI_Gateway/test_dsi.cpp b/TAO/tests/DSI_Gateway/test_dsi.cpp index 4a96384e624..a278997774d 100644 --- a/TAO/tests/DSI_Gateway/test_dsi.cpp +++ b/TAO/tests/DSI_Gateway/test_dsi.cpp @@ -11,21 +11,21 @@ ACE_RCSID(DSI_Gateway, test_dsi, "$Id$") void -DSI_Simple_Server::invoke (CORBA::ServerRequest_ptr request, - CORBA::Environment &ACE_TRY_ENV) +DSI_Simple_Server::invoke (CORBA::ServerRequest_ptr request + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { if (ACE_OS::strcmp ("shutdown", request->operation ()) == 0) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); ACE_CHECK; } CORBA::NVList_ptr list; - this->orb_->create_list (0, list, ACE_TRY_ENV); + this->orb_->create_list (0, list TAO_ENV_ARG_PARAMETER); ACE_CHECK; - request->arguments (list, ACE_TRY_ENV); + request->arguments (list TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::Request_var target_request; @@ -37,8 +37,8 @@ DSI_Simple_Server::invoke (CORBA::ServerRequest_ptr request, 0, // exception_list, 0, // context_list, target_request.inout (), - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_CHECK; target_request->_tao_lazy_evaluation (1); @@ -49,7 +49,7 @@ DSI_Simple_Server::invoke (CORBA::ServerRequest_ptr request, ACE_TRY { // Updates the byte order state, if necessary. - target_request->invoke (ACE_TRY_ENV); + target_request->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (CORBA::UNKNOWN, ex) @@ -71,15 +71,15 @@ DSI_Simple_Server::invoke (CORBA::ServerRequest_ptr request, CORBA::RepositoryId DSI_Simple_Server::_primary_interface (const PortableServer::ObjectId &, - PortableServer::POA_ptr, - CORBA::Environment &) + PortableServer::POA_ptr + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC (()) { return CORBA::string_dup ("IDL:Simple_Server:1.0"); } PortableServer::POA_ptr -DSI_Simple_Server::_default_POA (CORBA::Environment &) +DSI_Simple_Server::_default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) { return PortableServer::POA::_duplicate (this->poa_.in ()); } diff --git a/TAO/tests/DSI_Gateway/test_dsi.h b/TAO/tests/DSI_Gateway/test_dsi.h index eb219d03547..77333ed445d 100644 --- a/TAO/tests/DSI_Gateway/test_dsi.h +++ b/TAO/tests/DSI_Gateway/test_dsi.h @@ -35,19 +35,19 @@ public: // ctor // = The DynamicImplementation methods. - virtual void invoke (CORBA::ServerRequest_ptr request, - CORBA::Environment &env) + virtual void invoke (CORBA::ServerRequest_ptr request + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual CORBA::RepositoryId _primary_interface ( const PortableServer::ObjectId &oid, - PortableServer::POA_ptr poa, - CORBA::Environment &ACE_TRY_ENV + PortableServer::POA_ptr poa + TAO_ENV_ARG_DECL ) ACE_THROW_SPEC (()); virtual PortableServer::POA_ptr _default_POA ( - CORBA::Environment &ACE_TRY_ENV + TAO_ENV_SINGLE_ARG_DECL ); private: diff --git a/TAO/tests/DSI_Gateway/test_i.cpp b/TAO/tests/DSI_Gateway/test_i.cpp index 50876045e12..6813e9f6af5 100644 --- a/TAO/tests/DSI_Gateway/test_i.cpp +++ b/TAO/tests/DSI_Gateway/test_i.cpp @@ -13,8 +13,8 @@ CORBA::Long Simple_Server_i::test_method (CORBA::Long x, const Structure& the_in_structure, Structure_out the_out_structure, - char *&name, - CORBA::Environment&) + char *&name + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { Structure *tmp; @@ -39,7 +39,7 @@ Simple_Server_i::test_method (CORBA::Long x, } void -Simple_Server_i::raise_user_exception (CORBA::Environment &ACE_TRY_ENV) +Simple_Server_i::raise_user_exception (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, test_exception)) { @@ -49,15 +49,15 @@ Simple_Server_i::raise_user_exception (CORBA::Environment &ACE_TRY_ENV) } void -Simple_Server_i::raise_system_exception (CORBA::Environment &ACE_TRY_ENV) +Simple_Server_i::raise_system_exception (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_THROW (CORBA::NO_PERMISSION ()); } void -Simple_Server_i::shutdown (CORBA::Environment& ACE_TRY_ENV) +Simple_Server_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/DSI_Gateway/test_i.h b/TAO/tests/DSI_Gateway/test_i.h index a115367cc34..6f960b77359 100644 --- a/TAO/tests/DSI_Gateway/test_i.h +++ b/TAO/tests/DSI_Gateway/test_i.h @@ -34,18 +34,18 @@ public: CORBA::Long test_method (CORBA::Long x, const Structure& the_in_structure, Structure_out the_out_structure, - char *&name, - CORBA::Environment &) + char *&name + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void raise_user_exception (CORBA::Environment &) + void raise_user_exception (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException, test_exception)); - void raise_system_exception (CORBA::Environment &) + void raise_system_exception (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment &) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/DynAny_Test/data.cpp b/TAO/tests/DynAny_Test/data.cpp index 89a008bf0b0..9582037ebd3 100644 --- a/TAO/tests/DynAny_Test/data.cpp +++ b/TAO/tests/DynAny_Test/data.cpp @@ -39,7 +39,7 @@ Data::Data (CORBA::ORB_var orb) m_any1 (CORBA::_tc_long), orb_ (orb) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { @@ -62,8 +62,8 @@ Data::Data (CORBA::ORB_var orb) // Getting the RootPOA so we can generate object references. 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; @@ -75,28 +75,28 @@ Data::Data (CORBA::ORB_var orb) // Get the POA_var object from Object_var. PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (obj.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Generate values for the member variables. this->m_objref1 = - root_poa->create_reference ("foo", - ACE_TRY_ENV); + root_poa->create_reference ("foo" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; this->m_objref2 = - root_poa->create_reference ("foo", - ACE_TRY_ENV); + root_poa->create_reference ("foo" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Clean up after the POA root_poa->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } diff --git a/TAO/tests/DynAny_Test/driver.cpp b/TAO/tests/DynAny_Test/driver.cpp index ffe04da689a..2cbc2873eac 100644 --- a/TAO/tests/DynAny_Test/driver.cpp +++ b/TAO/tests/DynAny_Test/driver.cpp @@ -60,7 +60,7 @@ Driver::~Driver (void) if (this->orb_.in () != 0) { this->orb_->shutdown (); - this->orb_->destroy (); + this->orb_->destroy (); } } @@ -73,8 +73,8 @@ Driver::init (int argc, char* argv[]) // Retrieve the underlying ORB this->orb_ = CORBA::ORB_init (argc, argv, - "local", - ACE_TRY_ENV); + "local" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; diff --git a/TAO/tests/DynAny_Test/test_dynany.cpp b/TAO/tests/DynAny_Test/test_dynany.cpp index 875bca9c851..c18f79d4569 100644 --- a/TAO/tests/DynAny_Test/test_dynany.cpp +++ b/TAO/tests/DynAny_Test/test_dynany.cpp @@ -54,13 +54,13 @@ Test_DynAny::run_test (void) "testing: constructor(Any)/insert/get\n")); CORBA::Object_var factory_obj = - this->orb_->resolve_initial_references ("DynAnyFactory", - ACE_TRY_ENV); + this->orb_->resolve_initial_references ("DynAnyFactory" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; DynamicAny::DynAnyFactory_var dynany_factory = - DynamicAny::DynAnyFactory::_narrow (factory_obj.in (), - ACE_TRY_ENV); + DynamicAny::DynAnyFactory::_narrow (factory_obj.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (dynany_factory.in ())) @@ -72,13 +72,13 @@ Test_DynAny::run_test (void) CORBA::Any in1 (CORBA::_tc_double); DynamicAny::DynAny_var fa1 = - dynany_factory->create_dyn_any (in1, ACE_TRY_ENV); + dynany_factory->create_dyn_any (in1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - fa1->insert_double (data.m_double1, - ACE_TRY_ENV); + fa1->insert_double (data.m_double1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::Double d_out = fa1->get_double (ACE_TRY_ENV); + CORBA::Double d_out = fa1->get_double (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (d_out == data.m_double1) @@ -96,15 +96,15 @@ Test_DynAny::run_test (void) d_out = data.m_double2; DynamicAny::DynAny_var ftc1 = - dynany_factory->create_dyn_any_from_type_code (CORBA::_tc_double, - ACE_TRY_ENV); + dynany_factory->create_dyn_any_from_type_code (CORBA::_tc_double + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Any in_any1; in_any1 <<= data.m_double1; - ftc1->from_any (in_any1, - ACE_TRY_ENV); + ftc1->from_any (in_any1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::Any_var out_any1 = ftc1->to_any (ACE_TRY_ENV); + CORBA::Any_var out_any1 = ftc1->to_any (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; out_any1 >>= d_out; @@ -118,9 +118,9 @@ Test_DynAny::run_test (void) ++this->error_count_; } - fa1->destroy (ACE_TRY_ENV); + fa1->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - ftc1->destroy (ACE_TRY_ENV); + ftc1->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -132,17 +132,17 @@ Test_DynAny::run_test (void) CORBA_Any in (CORBA::_tc_TypeCode); DynamicAny::DynAny_var fa2 = - dynany_factory->create_dyn_any (in, - ACE_TRY_ENV); + dynany_factory->create_dyn_any (in + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - fa2->insert_typecode (data.m_typecode1, - ACE_TRY_ENV); + fa2->insert_typecode (data.m_typecode1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::TypeCode_var tc_out = fa2->get_typecode (ACE_TRY_ENV); + CORBA::TypeCode_var tc_out = fa2->get_typecode (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - if (tc_out->equal (data.m_typecode1, - ACE_TRY_ENV)) + if (tc_out->equal (data.m_typecode1 + TAO_ENV_ARG_PARAMETER)) { ACE_DEBUG ((LM_DEBUG, "++ OK ++\n")); @@ -158,21 +158,21 @@ Test_DynAny::run_test (void) "testing: constructor(TypeCode)/from_any/to_any\n")); DynamicAny::DynAny_var ftc2 = - dynany_factory->create_dyn_any_from_type_code (CORBA::_tc_TypeCode, - ACE_TRY_ENV); + dynany_factory->create_dyn_any_from_type_code (CORBA::_tc_TypeCode + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Any in_any2; in_any2 <<= data.m_typecode1; - ftc2->from_any (in_any2, - ACE_TRY_ENV); + ftc2->from_any (in_any2 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::Any_var out_any2 = ftc2->to_any (ACE_TRY_ENV); + CORBA::Any_var out_any2 = ftc2->to_any (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::TypeCode_ptr out_tc; out_any2 >>= out_tc; - CORBA::Boolean equal = out_tc->equal (data.m_typecode1, - ACE_TRY_ENV); + CORBA::Boolean equal = out_tc->equal (data.m_typecode1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (equal) @@ -187,9 +187,9 @@ Test_DynAny::run_test (void) ACE_TRY_CHECK; - fa2->destroy (ACE_TRY_ENV); + fa2->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - ftc2->destroy (ACE_TRY_ENV); + ftc2->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/DynAny_Test/test_dynarray.cpp b/TAO/tests/DynAny_Test/test_dynarray.cpp index 1db1cb02c04..ec9fc3c1fbd 100644 --- a/TAO/tests/DynAny_Test/test_dynarray.cpp +++ b/TAO/tests/DynAny_Test/test_dynarray.cpp @@ -57,13 +57,13 @@ Test_DynArray::run_test (void) "testing: constructor(Any)/insert/get/seek/rewind/current_component\n")); CORBA::Object_var factory_obj = - this->orb_->resolve_initial_references ("DynAnyFactory", - ACE_TRY_ENV); + this->orb_->resolve_initial_references ("DynAnyFactory" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; DynamicAny::DynAnyFactory_var dynany_factory = - DynamicAny::DynAnyFactory::_narrow (factory_obj.in (), - ACE_TRY_ENV); + DynamicAny::DynAnyFactory::_narrow (factory_obj.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (dynany_factory.in ())) @@ -76,25 +76,25 @@ Test_DynArray::run_test (void) CORBA::Any in_any1; in_any1 <<= ta; DynamicAny::DynAny_var dp1 = - dynany_factory->create_dyn_any (in_any1, - ACE_TRY_ENV); + dynany_factory->create_dyn_any (in_any1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - DynamicAny::DynArray_var fa1 = DynamicAny::DynArray::_narrow (dp1.in (), - ACE_TRY_ENV); + DynamicAny::DynArray_var fa1 = DynamicAny::DynArray::_narrow (dp1.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - fa1->seek (1, - ACE_TRY_ENV); + fa1->seek (1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - fa1->insert_long (data.m_long1, - ACE_TRY_ENV); + fa1->insert_long (data.m_long1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - fa1->rewind (ACE_TRY_ENV); + fa1->rewind (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Long l_out1 = data.m_long2; - fa1->seek (1, - ACE_TRY_ENV); + fa1->seek (1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - l_out1 = fa1->get_long (ACE_TRY_ENV); + l_out1 = fa1->get_long (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (l_out1 == data.m_long1) @@ -111,13 +111,13 @@ Test_DynArray::run_test (void) "testing: constructor(TypeCode)/from_any/to_any\n")); DynamicAny::DynAny_var ftc1_base = - dynany_factory->create_dyn_any_from_type_code (DynAnyTests::_tc_test_array, - ACE_TRY_ENV); + dynany_factory->create_dyn_any_from_type_code (DynAnyTests::_tc_test_array + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; DynamicAny::DynArray_var ftc1 = - DynamicAny::DynArray::_narrow (ftc1_base.in (), - ACE_TRY_ENV); + DynamicAny::DynArray::_narrow (ftc1_base.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (ftc1.in ())) @@ -130,10 +130,10 @@ Test_DynArray::run_test (void) ta[1] = data.m_long1; CORBA::Any in_any2; in_any2 <<= ta; - ftc1->from_any (in_any2, - ACE_TRY_ENV); + ftc1->from_any (in_any2 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::Any_var out_any1 = ftc1->to_any (ACE_TRY_ENV); + CORBA::Any_var out_any1 = ftc1->to_any (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; DynAnyTests::test_array_forany ta_out; out_any1.in () >>= ta_out; @@ -157,10 +157,10 @@ Test_DynArray::run_test (void) in_any3 <<= data.m_long1; as_in[0] = in_any3; as_in[1] = in_any3; - ftc1->set_elements (as_in, - ACE_TRY_ENV); + ftc1->set_elements (as_in + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - DynamicAny::AnySeq_var as_out = ftc1->get_elements (ACE_TRY_ENV); + DynamicAny::AnySeq_var as_out = ftc1->get_elements (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA_Any out_any2 = as_out[1U]; CORBA::Long l_out2; @@ -176,9 +176,9 @@ Test_DynArray::run_test (void) ++this->error_count_; } - fa1->destroy (ACE_TRY_ENV); + fa1->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - ftc1->destroy (ACE_TRY_ENV); + ftc1->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/DynAny_Test/test_dynenum.cpp b/TAO/tests/DynAny_Test/test_dynenum.cpp index b0b04b65927..1b8b4d77894 100644 --- a/TAO/tests/DynAny_Test/test_dynenum.cpp +++ b/TAO/tests/DynAny_Test/test_dynenum.cpp @@ -49,13 +49,13 @@ Test_DynEnum::run_test (void) "testing: constructor(Any)/set_as_string/get_as_ulong\n")); CORBA::Object_var factory_obj = - this->orb_->resolve_initial_references ("DynAnyFactory", - ACE_TRY_ENV); + this->orb_->resolve_initial_references ("DynAnyFactory" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; DynamicAny::DynAnyFactory_var dynany_factory = - DynamicAny::DynAnyFactory::_narrow (factory_obj.in (), - ACE_TRY_ENV); + DynamicAny::DynAnyFactory::_narrow (factory_obj.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (dynany_factory.in ())) @@ -69,17 +69,17 @@ Test_DynEnum::run_test (void) CORBA_Any in_any1; in_any1 <<= te; DynamicAny::DynAny_var dp1 = - dynany_factory->create_dyn_any (in_any1, - ACE_TRY_ENV); + dynany_factory->create_dyn_any (in_any1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - DynamicAny::DynEnum_var de1 = - DynamicAny::DynEnum::_narrow (dp1.in (), - ACE_TRY_ENV); + DynamicAny::DynEnum_var de1 = + DynamicAny::DynEnum::_narrow (dp1.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - de1->set_as_string ("TE_FIRST", - ACE_TRY_ENV); + de1->set_as_string ("TE_FIRST" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::ULong ul_out1 = de1->get_as_ulong (ACE_TRY_ENV); + CORBA::ULong ul_out1 = de1->get_as_ulong (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (ul_out1 == 1) @@ -95,10 +95,10 @@ Test_DynEnum::run_test (void) ACE_DEBUG ((LM_DEBUG, "testing: set_as_ulong/get_as_string\n")); - de1->set_as_ulong (3, - ACE_TRY_ENV); + de1->set_as_ulong (3 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::String_var s = de1->get_as_string (ACE_TRY_ENV); + CORBA::String_var s = de1->get_as_string (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (ACE_OS::strcmp (s.in (), "TE_THIRD") == 0) @@ -116,13 +116,13 @@ Test_DynEnum::run_test (void) "testing: constructor(TypeCode)/from_any/to_any\n")); DynamicAny::DynAny_var de2_base = - dynany_factory->create_dyn_any_from_type_code (DynAnyTests::_tc_test_enum, - ACE_TRY_ENV); + dynany_factory->create_dyn_any_from_type_code (DynAnyTests::_tc_test_enum + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; DynamicAny::DynEnum_var de2 = - DynamicAny::DynEnum::_narrow (de2_base.in (), - ACE_TRY_ENV); + DynamicAny::DynEnum::_narrow (de2_base.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (de2.in ())) @@ -134,10 +134,10 @@ Test_DynEnum::run_test (void) CORBA_Any in_any2; in_any2 <<= DynAnyTests::TE_THIRD; - de2->from_any (in_any2, - ACE_TRY_ENV); + de2->from_any (in_any2 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA_Any_var out_any1 = de2->to_any (ACE_TRY_ENV); + CORBA_Any_var out_any1 = de2->to_any (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; out_any1.in () >>= te; @@ -151,9 +151,9 @@ Test_DynEnum::run_test (void) ++this->error_count_; } - de1->destroy (ACE_TRY_ENV); + de1->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - de2->destroy (ACE_TRY_ENV); + de2->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/DynAny_Test/test_dynsequence.cpp b/TAO/tests/DynAny_Test/test_dynsequence.cpp index 61c62345a03..36e8ab2b1ce 100644 --- a/TAO/tests/DynAny_Test/test_dynsequence.cpp +++ b/TAO/tests/DynAny_Test/test_dynsequence.cpp @@ -59,13 +59,13 @@ Test_DynSequence::run_test (void) "rewind/current_component\n")); CORBA::Object_var factory_obj = - this->orb_->resolve_initial_references ("DynAnyFactory", - ACE_TRY_ENV); + this->orb_->resolve_initial_references ("DynAnyFactory" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; DynamicAny::DynAnyFactory_var dynany_factory = - DynamicAny::DynAnyFactory::_narrow (factory_obj.in (), - ACE_TRY_ENV); + DynamicAny::DynAnyFactory::_narrow (factory_obj.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (dynany_factory.in ())) @@ -80,25 +80,25 @@ Test_DynSequence::run_test (void) CORBA_Any in_any1; in_any1 <<= ts; DynamicAny::DynAny_var dp1 = - dynany_factory->create_dyn_any (in_any1, - ACE_TRY_ENV); + dynany_factory->create_dyn_any (in_any1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - DynamicAny::DynSequence_var fa1 = - DynamicAny::DynSequence::_narrow (dp1.in (), - ACE_TRY_ENV); + DynamicAny::DynSequence_var fa1 = + DynamicAny::DynSequence::_narrow (dp1.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - fa1->seek (1, - ACE_TRY_ENV); + fa1->seek (1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - fa1->insert_string (data.m_string1, - ACE_TRY_ENV); + fa1->insert_string (data.m_string1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - fa1->rewind (ACE_TRY_ENV); + fa1->rewind (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - fa1->seek (1, - ACE_TRY_ENV); + fa1->seek (1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::String_var out_str1 = fa1->get_string (ACE_TRY_ENV); + CORBA::String_var out_str1 = fa1->get_string (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (!ACE_OS::strcmp (out_str1.in (), data.m_string1)) @@ -116,7 +116,7 @@ Test_DynSequence::run_test (void) "testing: set_elements_as_dyn_any/get_elements_as_dyn_any/equal\n" )); - static const char *values[] = + static const char *values[] = { "zero", "one", @@ -137,17 +137,17 @@ Test_DynSequence::run_test (void) { elem_any <<= CORBA::Any::from_string (values[i], 8); - elements[i] = dynany_factory->create_dyn_any (elem_any, - ACE_TRY_ENV); + elements[i] = dynany_factory->create_dyn_any (elem_any + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } - fa1->set_elements_as_dyn_any (elements.in (), - ACE_TRY_ENV); + fa1->set_elements_as_dyn_any (elements.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - DynamicAny::DynAnySeq_var out_elems = - fa1->get_elements_as_dyn_any (ACE_TRY_ENV); + DynamicAny::DynAnySeq_var out_elems = + fa1->get_elements_as_dyn_any (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (out_elems->length () != 3) @@ -160,12 +160,12 @@ Test_DynSequence::run_test (void) for (i = 0; i < length; ++i) { - out_str = out_elems[i]->get_string (ACE_TRY_ENV); + out_str = out_elems[i]->get_string (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::Boolean equal = - out_elems[i]->equal (elements[i].in (), - ACE_TRY_ENV); + CORBA::Boolean equal = + out_elems[i]->equal (elements[i].in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (!equal) @@ -175,7 +175,7 @@ Test_DynSequence::run_test (void) // To show that calling destroy() on a component does // nothing, as required by the spec. - out_elems[i]->destroy (ACE_TRY_ENV); + out_elems[i]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -190,14 +190,14 @@ Test_DynSequence::run_test (void) DynamicAny::DynAny_var ftc1_base = dynany_factory->create_dyn_any_from_type_code ( - DynAnyTests::_tc_test_seq, - ACE_TRY_ENV + DynAnyTests::_tc_test_seq + TAO_ENV_ARG_PARAMETER ); ACE_TRY_CHECK; DynamicAny::DynSequence_var ftc1 = - DynamicAny::DynSequence::_narrow (ftc1_base.in (), - ACE_TRY_ENV); + DynamicAny::DynSequence::_narrow (ftc1_base.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (ftc1.in ())) @@ -210,10 +210,10 @@ Test_DynSequence::run_test (void) ts[0] = CORBA::string_dup (data.m_string1); CORBA_Any in_any2; in_any2 <<= ts; - ftc1->from_any (in_any2, - ACE_TRY_ENV); + ftc1->from_any (in_any2 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::Any_var out_any1 = ftc1->to_any (ACE_TRY_ENV); + CORBA::Any_var out_any1 = ftc1->to_any (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; DynAnyTests::test_seq *ts_out; out_any1.in () >>= ts_out; @@ -231,7 +231,7 @@ Test_DynSequence::run_test (void) ACE_DEBUG ((LM_DEBUG, "testing: length/set_elements/get_elements\n")); - length = ftc1->get_length (ACE_TRY_ENV); + length = ftc1->get_length (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (length != 2) @@ -239,8 +239,8 @@ Test_DynSequence::run_test (void) ++this->error_count_; } - ftc1->set_length (3, - ACE_TRY_ENV); + ftc1->set_length (3 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; DynamicAny::AnySeq as_in (3); as_in.length (3); @@ -250,10 +250,10 @@ Test_DynSequence::run_test (void) as_in[1] = in_any3; in_any3 <<= CORBA::Any::from_string (data.m_string1, 8); as_in[2] = in_any3; - ftc1->set_elements (as_in, - ACE_TRY_ENV); + ftc1->set_elements (as_in + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - DynamicAny::AnySeq_var as_out = ftc1->get_elements (ACE_TRY_ENV); + DynamicAny::AnySeq_var as_out = ftc1->get_elements (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::ULong index = 2; CORBA_Any out_any2 = as_out[index]; @@ -271,9 +271,9 @@ Test_DynSequence::run_test (void) "++ OK ++\n")); } - fa1->destroy (ACE_TRY_ENV); + fa1->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - ftc1->destroy (ACE_TRY_ENV); + ftc1->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/DynAny_Test/test_dynstruct.cpp b/TAO/tests/DynAny_Test/test_dynstruct.cpp index 25ccd38df43..b72b83e6229 100644 --- a/TAO/tests/DynAny_Test/test_dynstruct.cpp +++ b/TAO/tests/DynAny_Test/test_dynstruct.cpp @@ -57,13 +57,13 @@ Test_DynStruct::run_test (void) "testing: constructor(Any)/insert/get/next/seek/rewind/current_component\n")); CORBA::Object_var factory_obj = - this->orb_->resolve_initial_references ("DynAnyFactory", - ACE_TRY_ENV); + this->orb_->resolve_initial_references ("DynAnyFactory" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; DynamicAny::DynAnyFactory_var dynany_factory = - DynamicAny::DynAnyFactory::_narrow (factory_obj.in (), - ACE_TRY_ENV); + DynamicAny::DynAnyFactory::_narrow (factory_obj.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (dynany_factory.in ())) @@ -76,45 +76,45 @@ Test_DynStruct::run_test (void) CORBA::Any in_any1; in_any1 <<= ts; DynamicAny::DynAny_var dp1 = - dynany_factory->create_dyn_any (in_any1, - ACE_TRY_ENV); + dynany_factory->create_dyn_any (in_any1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; DynamicAny::DynStruct_var fa1 = - DynamicAny::DynStruct::_narrow (dp1.in (), - ACE_TRY_ENV); + DynamicAny::DynStruct::_narrow (dp1.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - fa1->insert_char (data.m_char1, - ACE_TRY_ENV); + fa1->insert_char (data.m_char1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - fa1->next (ACE_TRY_ENV); + fa1->next (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - fa1->insert_long (data.m_long1, - ACE_TRY_ENV); + fa1->insert_long (data.m_long1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - fa1->next (ACE_TRY_ENV); + fa1->next (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - DynamicAny::DynAny_var cc = fa1->current_component (ACE_TRY_ENV); + DynamicAny::DynAny_var cc = fa1->current_component (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - cc->insert_float (data.m_float1, - ACE_TRY_ENV); + cc->insert_float (data.m_float1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - cc->next (ACE_TRY_ENV); + cc->next (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - cc->insert_short (data.m_short1, - ACE_TRY_ENV); + cc->insert_short (data.m_short1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - cc->rewind (ACE_TRY_ENV); + cc->rewind (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // To show that calling destroy() on a component does // nothing, as required by the spec. - cc->destroy (ACE_TRY_ENV); + cc->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - fa1->rewind (ACE_TRY_ENV); + fa1->rewind (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::Char c = fa1->get_char (ACE_TRY_ENV); + CORBA::Char c = fa1->get_char (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (c != data.m_char1) @@ -122,9 +122,9 @@ Test_DynStruct::run_test (void) ++this->error_count_; } - fa1->next (ACE_TRY_ENV); + fa1->next (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::Long l = fa1->get_long (ACE_TRY_ENV); + CORBA::Long l = fa1->get_long (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (l != data.m_long1) @@ -132,16 +132,16 @@ Test_DynStruct::run_test (void) ++this->error_count_; } - fa1->next (ACE_TRY_ENV); + fa1->next (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - cc = fa1->current_component (ACE_TRY_ENV); + cc = fa1->current_component (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - cc->seek (1, - ACE_TRY_ENV); + cc->seek (1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::Short s = cc->get_short (ACE_TRY_ENV); + CORBA::Short s = cc->get_short (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (s != data.m_short1) @@ -159,13 +159,13 @@ Test_DynStruct::run_test (void) "testing: constructor(TypeCode)/from_any/to_any\n")); DynamicAny::DynAny_var ftc1_base = - dynany_factory->create_dyn_any_from_type_code (DynAnyTests::_tc_test_struct, - ACE_TRY_ENV); + dynany_factory->create_dyn_any_from_type_code (DynAnyTests::_tc_test_struct + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; DynamicAny::DynStruct_var ftc1 = - DynamicAny::DynStruct::_narrow (ftc1_base.in (), - ACE_TRY_ENV); + DynamicAny::DynStruct::_narrow (ftc1_base.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (ftc1.in ())) @@ -181,10 +181,10 @@ Test_DynStruct::run_test (void) ts.es.s = data.m_short1; CORBA_Any in_any2; in_any2 <<= ts; - ftc1->from_any (in_any2, - ACE_TRY_ENV); + ftc1->from_any (in_any2 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA_Any_var out_any1 = ftc1->to_any (ACE_TRY_ENV); + CORBA_Any_var out_any1 = ftc1->to_any (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; DynAnyTests::test_struct* ts_out; out_any1.in () >>= ts_out; @@ -202,11 +202,11 @@ Test_DynStruct::run_test (void) ACE_DEBUG ((LM_DEBUG, "testing: current_member_name/current_member_kind\n")); - ftc1->seek (2, - ACE_TRY_ENV); + ftc1->seek (2 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; DynamicAny::FieldName_var fn = - ftc1->current_member_name (ACE_TRY_ENV); + ftc1->current_member_name (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (ACE_OS::strcmp (fn.in (), "es")) @@ -214,7 +214,7 @@ Test_DynStruct::run_test (void) ++this->error_count_; } - CORBA::TCKind tk = ftc1->current_member_kind (ACE_TRY_ENV); + CORBA::TCKind tk = ftc1->current_member_kind (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (tk != CORBA::tk_struct) @@ -231,18 +231,18 @@ Test_DynStruct::run_test (void) ACE_DEBUG ((LM_DEBUG, "testing: get_members/set_members\n")); - DynamicAny::NameValuePairSeq_var nvps = fa1->get_members (ACE_TRY_ENV); + DynamicAny::NameValuePairSeq_var nvps = fa1->get_members (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; DynamicAny::DynAny_var sm_base = dynany_factory->create_dyn_any_from_type_code ( - DynAnyTests::_tc_test_struct, - ACE_TRY_ENV + DynAnyTests::_tc_test_struct + TAO_ENV_ARG_PARAMETER ); ACE_TRY_CHECK; DynamicAny::DynStruct_var sm = - DynamicAny::DynStruct::_narrow (sm_base.in (), - ACE_TRY_ENV); + DynamicAny::DynStruct::_narrow (sm_base.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (sm.in ())) @@ -252,10 +252,10 @@ Test_DynStruct::run_test (void) -1); } - sm->set_members (nvps.in (), - ACE_TRY_ENV); + sm->set_members (nvps.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - DynamicAny::NameValuePairSeq_var gm = sm->get_members (ACE_TRY_ENV); + DynamicAny::NameValuePairSeq_var gm = sm->get_members (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::ULong index = 2; @@ -264,11 +264,11 @@ Test_DynStruct::run_test (void) ++this->error_count_; } - fa1->destroy (ACE_TRY_ENV); + fa1->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - ftc1->destroy (ACE_TRY_ENV); + ftc1->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - sm->destroy (ACE_TRY_ENV); + sm->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/DynAny_Test/test_dynunion.cpp b/TAO/tests/DynAny_Test/test_dynunion.cpp index 9eba7003926..fb4ce42e20f 100644 --- a/TAO/tests/DynAny_Test/test_dynunion.cpp +++ b/TAO/tests/DynAny_Test/test_dynunion.cpp @@ -57,13 +57,13 @@ Test_DynUnion::run_test (void) "testing: constructor(Any)/insert/get\n")); CORBA::Object_var factory_obj = - this->orb_->resolve_initial_references ("DynAnyFactory", - ACE_TRY_ENV); + this->orb_->resolve_initial_references ("DynAnyFactory" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; DynamicAny::DynAnyFactory_var dynany_factory = - DynamicAny::DynAnyFactory::_narrow (factory_obj.in (), - ACE_TRY_ENV); + DynamicAny::DynAnyFactory::_narrow (factory_obj.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (dynany_factory.in ())) @@ -78,20 +78,20 @@ Test_DynUnion::run_test (void) CORBA_Any in_any1; in_any1 <<= tu; DynamicAny::DynAny_var dp1 = - dynany_factory->create_dyn_any (in_any1, - ACE_TRY_ENV); + dynany_factory->create_dyn_any (in_any1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; DynamicAny::DynUnion_var fa1 = - DynamicAny::DynUnion::_narrow (dp1.in (), - ACE_TRY_ENV); + DynamicAny::DynUnion::_narrow (dp1.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - fa1->seek (1, - ACE_TRY_ENV); + fa1->seek (1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - fa1->insert_typecode (data.m_typecode1, - ACE_TRY_ENV); + fa1->insert_typecode (data.m_typecode1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::TypeCode_var s_out1 = fa1->get_typecode (ACE_TRY_ENV); + CORBA::TypeCode_var s_out1 = fa1->get_typecode (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (s_out1.in ()->equal (data.m_typecode1)) @@ -107,16 +107,16 @@ Test_DynUnion::run_test (void) ACE_DEBUG ((LM_DEBUG, "testing: constructor(TypeCode)/from_any/to_any\n")); - CORBA_Any_var out_any1 = fa1->to_any (ACE_TRY_ENV); + CORBA_Any_var out_any1 = fa1->to_any (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; DynamicAny::DynAny_var ftc1_base = - dynany_factory->create_dyn_any_from_type_code (DynAnyTests::_tc_test_union, - ACE_TRY_ENV); + dynany_factory->create_dyn_any_from_type_code (DynAnyTests::_tc_test_union + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; DynamicAny::DynUnion_var ftc1 = - DynamicAny::DynUnion::_narrow (ftc1_base.in (), - ACE_TRY_ENV); + DynamicAny::DynUnion::_narrow (ftc1_base.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (ftc1.in ())) @@ -126,13 +126,13 @@ Test_DynUnion::run_test (void) -1); } - ftc1->from_any (out_any1.in (), - ACE_TRY_ENV); + ftc1->from_any (out_any1.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - ftc1->seek (1, - ACE_TRY_ENV); + ftc1->seek (1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::TypeCode_var s_out2 = ftc1->get_typecode (ACE_TRY_ENV); + CORBA::TypeCode_var s_out2 = ftc1->get_typecode (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (s_out2.in ()->equal (data.m_typecode1)) @@ -148,15 +148,15 @@ Test_DynUnion::run_test (void) ACE_DEBUG ((LM_DEBUG, "testing:discriminator/discriminator_kind\n")); - DynamicAny::DynAny_var dp2 = ftc1->get_discriminator (ACE_TRY_ENV); + DynamicAny::DynAny_var dp2 = ftc1->get_discriminator (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::TypeCode_var tc2 = dp2->type (ACE_TRY_ENV); + CORBA::TypeCode_var tc2 = dp2->type (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::TCKind tc1kind = ftc1->discriminator_kind (ACE_TRY_ENV); + CORBA::TCKind tc1kind = ftc1->discriminator_kind (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::TCKind tc2kind = tc2->kind (ACE_TRY_ENV); + CORBA::TCKind tc2kind = tc2->kind (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (tc2kind == tc1kind) @@ -172,13 +172,13 @@ Test_DynUnion::run_test (void) ACE_DEBUG ((LM_DEBUG, "testing:member/member_kind/member_name\n")); - DynamicAny::DynAny_var dp3 = ftc1->member (ACE_TRY_ENV); + DynamicAny::DynAny_var dp3 = ftc1->member (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::String_var m_nm = ftc1->member_name (ACE_TRY_ENV); + CORBA::String_var m_nm = ftc1->member_name (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::TCKind tk = ftc1->member_kind (ACE_TRY_ENV); + CORBA::TCKind tk = ftc1->member_kind (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::TypeCode_var tc3 = dp3->get_typecode (ACE_TRY_ENV); + CORBA::TypeCode_var tc3 = dp3->get_typecode (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (!ACE_OS::strcmp (m_nm.in (), "tc") @@ -198,17 +198,17 @@ Test_DynUnion::run_test (void) ACE_DEBUG ((LM_DEBUG, "testing: set_to_default_member\n")); - ftc1->set_to_default_member (ACE_TRY_ENV); + ftc1->set_to_default_member (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - ftc1->seek (1, - ACE_TRY_ENV); + ftc1->seek (1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - ftc1->insert_short (data.m_short1, - ACE_TRY_ENV); + ftc1->insert_short (data.m_short1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - DynamicAny::DynAny_var mem = ftc1->member (ACE_TRY_ENV); + DynamicAny::DynAny_var mem = ftc1->member (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::Short out_s = mem->get_short (ACE_TRY_ENV); + CORBA::Short out_s = mem->get_short (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (out_s == data.m_short1) @@ -221,9 +221,9 @@ Test_DynUnion::run_test (void) ++this->error_count_; } - fa1->destroy (ACE_TRY_ENV); + fa1->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - ftc1->destroy (ACE_TRY_ENV); + ftc1->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Explicit_Event_Loop/client.cpp b/TAO/tests/Explicit_Event_Loop/client.cpp index 6537950ca44..984dcbc34c6 100644 --- a/TAO/tests/Explicit_Event_Loop/client.cpp +++ b/TAO/tests/Explicit_Event_Loop/client.cpp @@ -29,18 +29,18 @@ int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; - ACE_TRY + TAO_ENV_DECLARE_NEW_ENV; + ACE_TRY { // Initialize orb - CORBA::ORB_var orb = CORBA::ORB_init (argc, + CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "", - ACE_TRY_ENV); + "" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Check arguments. - if (argc != 2) + if (argc != 2) { ACE_ERROR_RETURN ((LM_ERROR, "Usage: client IOR_string\n"), @@ -48,11 +48,11 @@ main (int argc, char *argv[]) } // Destringify argv[1]. - CORBA::Object_var obj = orb->string_to_object (argv[1], - ACE_TRY_ENV); + CORBA::Object_var obj = orb->string_to_object (argv[1] + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - if (CORBA::is_nil (obj.in ())) + if (CORBA::is_nil (obj.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "Nil Time reference\n"), @@ -60,11 +60,11 @@ main (int argc, char *argv[]) } // Narrow. - Time_var tm = Time::_narrow (obj.in (), - ACE_TRY_ENV); + Time_var tm = Time::_narrow (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - if (CORBA::is_nil (tm.in ())) + if (CORBA::is_nil (tm.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "Argument is not a Time reference\n"), @@ -72,7 +72,7 @@ main (int argc, char *argv[]) } // Get time. - TimeOfDay tod = tm->get_gmt (ACE_TRY_ENV); + TimeOfDay tod = tm->get_gmt (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -85,20 +85,20 @@ main (int argc, char *argv[]) tod.second)); } - ACE_CATCHANY + ACE_CATCHANY { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "client: a CORBA exception occured"); return 1; } - ACE_CATCHALL + ACE_CATCHALL { ACE_ERROR_RETURN ((LM_ERROR, "client: an unknown exception was caught\n"), 1); } - ACE_ENDTRY; - + ACE_ENDTRY; + ACE_CHECK_RETURN (-1); return 0; } diff --git a/TAO/tests/Explicit_Event_Loop/server.cpp b/TAO/tests/Explicit_Event_Loop/server.cpp index eb040211863..b714a1f80ab 100644 --- a/TAO/tests/Explicit_Event_Loop/server.cpp +++ b/TAO/tests/Explicit_Event_Loop/server.cpp @@ -49,7 +49,7 @@ parse_args (int argc, char *argv[]) "\n", argv [0]), -1); - } + } // Indicates sucessful parsing of the command line return 0; } @@ -57,7 +57,7 @@ parse_args (int argc, char *argv[]) TimeOfDay Time_impl:: -get_gmt ( CORBA_Environment &) +get_gmt ( TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { time_t time_now = time (0); @@ -83,14 +83,14 @@ void do_something_else() int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { // Initialize orb CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "", - ACE_TRY_ENV); + "" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -100,32 +100,32 @@ main (int argc, char *argv[]) // Get reference to Root POA. CORBA::Object_var obj - = orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + = 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; // Activate POA manager. PortableServer::POAManager_var mgr - = poa->the_POAManager (ACE_TRY_ENV); + = poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - mgr->activate (ACE_TRY_ENV); + mgr->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Create an object. Time_impl time_servant; // Write its stringified reference to stdout. - Time_var tm = time_servant._this (ACE_TRY_ENV); + Time_var tm = time_servant._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::String_var str = orb->object_to_string (tm.in (), - ACE_TRY_ENV); + CORBA::String_var str = orb->object_to_string (tm.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -147,8 +147,8 @@ main (int argc, char *argv[]) ); } - ACE_OS::fprintf (output_file, - "%s", + ACE_OS::fprintf (output_file, + "%s", str.in ()); ACE_OS::fclose (output_file); } @@ -157,12 +157,12 @@ main (int argc, char *argv[]) while (!done) { CORBA::Boolean pending = - orb->work_pending (ACE_TRY_ENV); + orb->work_pending (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (pending) { - orb->perform_work (ACE_TRY_ENV); + orb->perform_work (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } do_something_else (); @@ -174,7 +174,7 @@ main (int argc, char *argv[]) ACE_CATCHANY { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "server: a CORBA exception occured"); return 1; } diff --git a/TAO/tests/Explicit_Event_Loop/server.h b/TAO/tests/Explicit_Event_Loop/server.h index 2f4705e16a1..86d504ec72b 100644 --- a/TAO/tests/Explicit_Event_Loop/server.h +++ b/TAO/tests/Explicit_Event_Loop/server.h @@ -26,7 +26,7 @@ class Time_impl : public virtual POA_Time { public: - virtual TimeOfDay get_gmt (CORBA::Environment &) + virtual TimeOfDay get_gmt (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); }; diff --git a/TAO/tests/Exposed_Policies/Counter_i.cpp b/TAO/tests/Exposed_Policies/Counter_i.cpp index 216ef07c175..02c51916335 100644 --- a/TAO/tests/Exposed_Policies/Counter_i.cpp +++ b/TAO/tests/Exposed_Policies/Counter_i.cpp @@ -21,30 +21,30 @@ Counter_Servant::~Counter_Servant (void) // Counter Interface Methods Implementation. void -Counter_Servant::increment (CORBA::Environment &/*ACE_TRY_ENV*/) +Counter_Servant::increment (TAO_ENV_SINGLE_ARG_DECL_NOT_USED/*TAO_ENV_SINGLE_ARG_PARAMETER*/) ACE_THROW_SPEC ((CORBA::SystemException)) { ++this->count_; } CORBA::Long -Counter_Servant::get_count (CORBA::Environment &/*ACE_TRY_ENV*/) +Counter_Servant::get_count (TAO_ENV_SINGLE_ARG_DECL_NOT_USED/*TAO_ENV_SINGLE_ARG_PARAMETER*/) ACE_THROW_SPEC ((CORBA::SystemException)) { return this->count_; } void -Counter_Servant::reset (CORBA::Environment &/*ACE_TRY_ENV*/) +Counter_Servant::reset (TAO_ENV_SINGLE_ARG_DECL_NOT_USED/*TAO_ENV_SINGLE_ARG_PARAMETER*/) ACE_THROW_SPEC ((CORBA::SystemException)) { this->count_ = 0; } void -Counter_Servant::shutdown (CORBA::Environment &ACE_TRY_ENV) +Counter_Servant::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->policy_tester_->shutdown (ACE_TRY_ENV); + this->policy_tester_->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } diff --git a/TAO/tests/Exposed_Policies/Counter_i.h b/TAO/tests/Exposed_Policies/Counter_i.h index 888b72dbc09..2ed503217ea 100644 --- a/TAO/tests/Exposed_Policies/Counter_i.h +++ b/TAO/tests/Exposed_Policies/Counter_i.h @@ -35,20 +35,16 @@ public: // = Counter Interface Methods Overloading. - virtual void increment (CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + virtual void increment (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual CORBA::Long get_count (CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + virtual CORBA::Long get_count (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void reset (CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + virtual void reset (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); protected: diff --git a/TAO/tests/Exposed_Policies/Policy_Tester.cpp b/TAO/tests/Exposed_Policies/Policy_Tester.cpp index 841d29cd783..e8beea4ce17 100644 --- a/TAO/tests/Exposed_Policies/Policy_Tester.cpp +++ b/TAO/tests/Exposed_Policies/Policy_Tester.cpp @@ -28,38 +28,38 @@ Policy_Tester::~Policy_Tester (void) } void -Policy_Tester::run (CORBA::Environment &ACE_TRY_ENV) +Policy_Tester::run (TAO_ENV_SINGLE_ARG_DECL) { PortableServer::POAManager_var poa_manager = - this->child_poa_->the_POAManager (ACE_TRY_ENV); + this->child_poa_->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; - this->orb_->run (ACE_TRY_ENV); + this->orb_->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; } int Policy_Tester::init (int argc, - char *argv[], - CORBA::Environment &ACE_TRY_ENV) + char *argv[] + TAO_ENV_ARG_DECL) { // ORB Initialization. this->orb_ = - CORBA::ORB_init (argc, argv, "", - ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Get a reference to the RT-ORB. CORBA::Object_var object = - this->orb_->resolve_initial_references ("RTORB", - ACE_TRY_ENV); + this->orb_->resolve_initial_references ("RTORB" + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); - this->rt_orb_ = RTCORBA::RTORB::_narrow (object.in (), - ACE_TRY_ENV); + this->rt_orb_ = RTCORBA::RTORB::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Here we parse the command line paramether passed @@ -74,13 +74,13 @@ Policy_Tester::init (int argc, if ((arg = arg_shifter.get_the_parameter ("-POAConfigFile"))) { this->rt_poa_properties_ = - RT_Properties::read_from (arg, ACE_TRY_ENV); + RT_Properties::read_from (arg TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); } else if ((arg = arg_shifter.get_the_parameter ("-ObjectConfigFile"))) { this->rt_object_properties_ = - RT_Properties::read_from (arg, ACE_TRY_ENV); + RT_Properties::read_from (arg TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); } else if ((arg = arg_shifter.get_the_parameter ("-BaseObjectIOR"))) @@ -119,7 +119,7 @@ Policy_Tester::init (int argc, } int result = - this->create_objects (ACE_TRY_ENV); + this->create_objects (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (result != 0) @@ -142,7 +142,7 @@ Policy_Tester::check_reference (CORBA::Object_ptr object, int -Policy_Tester::create_objects (CORBA::Environment &ACE_TRY_ENV) +Policy_Tester::create_objects (TAO_ENV_SINGLE_ARG_DECL) { CORBA::PolicyList poa_policy_list; poa_policy_list.length (3); @@ -151,8 +151,8 @@ Policy_Tester::create_objects (CORBA::Environment &ACE_TRY_ENV) RTCORBA::Priority priority = this->rt_poa_properties_->priority (); poa_policy_list[0] = this->rt_orb_->create_priority_model_policy (RTCORBA::SERVER_DECLARED, - priority, - ACE_TRY_ENV); + priority + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Create priority Banded Connection Policy. @@ -160,8 +160,8 @@ Policy_Tester::create_objects (CORBA::Environment &ACE_TRY_ENV) this->rt_poa_properties_->priority_bands (); poa_policy_list[1] = - this->rt_orb_->create_priority_banded_connection_policy (poa_priority_bands, - ACE_TRY_ENV); + this->rt_orb_->create_priority_banded_connection_policy (poa_priority_bands + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Client Protocol Policy. @@ -179,11 +179,11 @@ Policy_Tester::create_objects (CORBA::Environment &ACE_TRY_ENV) this->rt_orb_->create_client_protocol_policy (protocol_list); CORBA::Object_var object = - this->orb_->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + this->orb_->resolve_initial_references ("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); this->poa_ = - PortableServer::POA::_narrow (object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); PortableServer::POAManager_var poa_mgr = @@ -192,19 +192,19 @@ Policy_Tester::create_objects (CORBA::Environment &ACE_TRY_ENV) object = this->poa_->create_POA ("Child_POA", poa_mgr.in (), - poa_policy_list, - ACE_TRY_ENV); + poa_policy_list + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); this->child_poa_ = - RTPortableServer::POA::_narrow (object.in (), ACE_TRY_ENV); + RTPortableServer::POA::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Create a Corba Object reference, using the policies // set at the POA level. object = - this->child_poa_->create_reference ("IDL:Counter:1.0", - ACE_TRY_ENV); + this->child_poa_->create_reference ("IDL:Counter:1.0" + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, @@ -214,7 +214,7 @@ Policy_Tester::create_objects (CORBA::Environment &ACE_TRY_ENV) "Unable to create Object!\n")) return -1; - Counter_var base_object = Counter::_narrow (object.in (), ACE_TRY_ENV); + Counter_var base_object = Counter::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (!check_reference (base_object.in(), @@ -222,7 +222,7 @@ Policy_Tester::create_objects (CORBA::Environment &ACE_TRY_ENV) return -1; CORBA::String_var ior = - this->orb_->object_to_string (base_object.in (), ACE_TRY_ENV); + this->orb_->object_to_string (base_object.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, @@ -247,8 +247,8 @@ Policy_Tester::create_objects (CORBA::Environment &ACE_TRY_ENV) object = this->child_poa_->create_reference_with_priority ("IDL:Counter:1.0", - this->rt_object_properties_->priority (), - ACE_TRY_ENV); + this->rt_object_properties_->priority () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, @@ -258,7 +258,7 @@ Policy_Tester::create_objects (CORBA::Environment &ACE_TRY_ENV) "Unable to create a Counter Object!\n")) return -1; - Counter_var over_object = Counter::_narrow (object.in (), ACE_TRY_ENV); + Counter_var over_object = Counter::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (!check_reference (over_object.in(), @@ -267,7 +267,7 @@ Policy_Tester::create_objects (CORBA::Environment &ACE_TRY_ENV) CORBA::String_var o_ior = - this->orb_->object_to_string (over_object.in (), ACE_TRY_ENV); + this->orb_->object_to_string (over_object.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, @@ -286,8 +286,8 @@ Policy_Tester::create_objects (CORBA::Environment &ACE_TRY_ENV) } void -Policy_Tester::shutdown (CORBA::Environment &ACE_TRY_ENV) +Policy_Tester::shutdown (TAO_ENV_SINGLE_ARG_DECL) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); ACE_CHECK; } diff --git a/TAO/tests/Exposed_Policies/Policy_Tester.h b/TAO/tests/Exposed_Policies/Policy_Tester.h index a2ba26dd7ef..86440cb829e 100644 --- a/TAO/tests/Exposed_Policies/Policy_Tester.h +++ b/TAO/tests/Exposed_Policies/Policy_Tester.h @@ -35,17 +35,17 @@ public: Policy_Tester (void); ~Policy_Tester (void); - void run (CORBA::Environment &ACE_TRY_ENV); + void run (TAO_ENV_SINGLE_ARG_DECL); // Runs the test. int init (int argc, - char *argv[], - CORBA::Environment &ACE_TRY_ENV); + char *argv[] + TAO_ENV_ARG_DECL); - void shutdown (CORBA::Environment &ACE_TRY_ENV); + void shutdown (TAO_ENV_SINGLE_ARG_DECL); private: // Helper method used internally. - int create_objects (CORBA::Environment &ACE_TRY_ENV); + int create_objects (TAO_ENV_SINGLE_ARG_DECL); CORBA::Boolean check_reference (CORBA::Object_ptr object, const char *msg); diff --git a/TAO/tests/Exposed_Policies/Policy_Verifier.cpp b/TAO/tests/Exposed_Policies/Policy_Verifier.cpp index 9ef23562029..8d2329cfa06 100644 --- a/TAO/tests/Exposed_Policies/Policy_Verifier.cpp +++ b/TAO/tests/Exposed_Policies/Policy_Verifier.cpp @@ -18,11 +18,11 @@ Policy_Verifier::~Policy_Verifier (void) void Policy_Verifier::init (int argc, - char *argv[], - CORBA::Environment &ACE_TRY_ENV) + char *argv[] + TAO_ENV_ARG_DECL) { this->orb_ = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_Arg_Shifter arg_shifter (argc, argv); @@ -34,7 +34,7 @@ Policy_Verifier::init (int argc, if ((arg = arg_shifter.get_the_parameter ("-POAConfigFile"))) { this->rt_poa_properties_ = - RT_Properties::read_from (arg, ACE_TRY_ENV); + RT_Properties::read_from (arg TAO_ENV_ARG_PARAMETER); ACE_CHECK; this->priority_bands_ = this->rt_poa_properties_->priority_bands ().length (); @@ -42,7 +42,7 @@ Policy_Verifier::init (int argc, else if ((arg = arg_shifter.get_the_parameter ("-ObjectConfigFile"))) { this->rt_object_properties_ = - RT_Properties::read_from (arg, ACE_TRY_ENV); + RT_Properties::read_from (arg TAO_ENV_ARG_PARAMETER); ACE_CHECK; } else if ((arg = arg_shifter.get_the_parameter ("-BaseObjectIOR"))) @@ -88,27 +88,27 @@ Policy_Verifier::init (int argc, } // Get the Object references. - CORBA::Object_var object = this->orb_->string_to_object (this->base_object_ref_, - ACE_TRY_ENV); + CORBA::Object_var object = this->orb_->string_to_object (this->base_object_ref_ + TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (!Policy_Verifier::check_reference (object.in (), "Invalid IOR file!\n")) return; - this->base_object_ = Counter::_narrow (object.in (), ACE_TRY_ENV); + this->base_object_ = Counter::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (!Policy_Verifier::check_reference (this->base_object_.in (), "Unable to convert the IOR to the proper object reference.\n")) return; - object = this->orb_->string_to_object (this->overridden_object_ref_, ACE_TRY_ENV); + object = this->orb_->string_to_object (this->overridden_object_ref_ TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (!Policy_Verifier::check_reference (object.in (), "Invalid IOR file!\n")) return; - this->overridden_object_ = Counter::_narrow (object.in (), ACE_TRY_ENV); + this->overridden_object_ = Counter::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (!Policy_Verifier::check_reference (this->overridden_object_.in (), @@ -118,30 +118,30 @@ Policy_Verifier::init (int argc, } void -Policy_Verifier::run (CORBA::Environment &ACE_TRY_ENV ) +Policy_Verifier::run (TAO_ENV_SINGLE_ARG_DECL ) { this->verify_reference (this->base_object_.in (), - this->rt_poa_properties_, - ACE_TRY_ENV); + this->rt_poa_properties_ + TAO_ENV_ARG_PARAMETER); ACE_CHECK; this->verify_reference (this->overridden_object_.in (), - this->rt_object_properties_, - ACE_TRY_ENV); + this->rt_object_properties_ + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } void Policy_Verifier::verify_reference (Counter_ptr object, - RT_Properties *rt_properties, - CORBA::Environment &ACE_TRY_ENV) + RT_Properties *rt_properties + TAO_ENV_ARG_DECL) { ACE_TRY { CORBA::Policy_var policy_var = - object->_get_policy (RTCORBA::PRIORITY_MODEL_POLICY_TYPE, - ACE_TRY_ENV); + object->_get_policy (RTCORBA::PRIORITY_MODEL_POLICY_TYPE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (Policy_Verifier::check_reference (policy_var.in (), "Unable to get Priority Policy.\n")) @@ -150,11 +150,11 @@ Policy_Verifier::verify_reference (Counter_ptr object, RTCORBA::PriorityModelPolicy::_narrow (policy_var.in ()); RTCORBA::PriorityModel priority_model = - priority_policy->priority_model (ACE_TRY_ENV); + priority_policy->priority_model (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::Priority priority = - priority_policy->server_priority (ACE_TRY_ENV); + priority_policy->server_priority (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (priority_model == RTCORBA::SERVER_DECLARED) @@ -174,15 +174,15 @@ Policy_Verifier::verify_reference (Counter_ptr object, ACE_TEXT ("Priority Value Mismatch.\n"))); } - policy_var = object->_get_policy (RTCORBA::PRIORITY_BANDED_CONNECTION_POLICY_TYPE, - ACE_TRY_ENV); + policy_var = object->_get_policy (RTCORBA::PRIORITY_BANDED_CONNECTION_POLICY_TYPE + TAO_ENV_ARG_PARAMETER); if (Policy_Verifier::check_reference (policy_var.in (), "Unable to get Priority Banded Policy\n")) { RTCORBA::PriorityBandedConnectionPolicy_var priority_banded_policy = - RTCORBA::PriorityBandedConnectionPolicy::_narrow (policy_var.in (), - ACE_TRY_ENV); + RTCORBA::PriorityBandedConnectionPolicy::_narrow (policy_var.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; @@ -218,17 +218,17 @@ Policy_Verifier::verify_reference (Counter_ptr object, } } } - policy_var = object->_get_policy (RTCORBA::CLIENT_PROTOCOL_POLICY_TYPE, - ACE_TRY_ENV); + policy_var = object->_get_policy (RTCORBA::CLIENT_PROTOCOL_POLICY_TYPE + TAO_ENV_ARG_PARAMETER); if (Policy_Verifier::check_reference (policy_var.in (), "Unable to get Client Protocol Policy\n")) { RTCORBA::ClientProtocolPolicy_var client_protocol_policy = - RTCORBA::ClientProtocolPolicy::_narrow (policy_var.in (), ACE_TRY_ENV); + RTCORBA::ClientProtocolPolicy::_narrow (policy_var.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::ProtocolList_var protocol_list = - client_protocol_policy->protocols (ACE_TRY_ENV); + client_protocol_policy->protocols (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; for (unsigned int i = 0; i < protocol_list->length (); i++) diff --git a/TAO/tests/Exposed_Policies/Policy_Verifier.h b/TAO/tests/Exposed_Policies/Policy_Verifier.h index 830bbdc11f2..d533a32f64a 100644 --- a/TAO/tests/Exposed_Policies/Policy_Verifier.h +++ b/TAO/tests/Exposed_Policies/Policy_Verifier.h @@ -39,19 +39,16 @@ public: ~Policy_Verifier (void); void init (int argc, - char *argv[], - CORBA::Environment &ACE_TRY_ENV - = TAO_default_environment ()); + char *argv[] + TAO_ENV_ARG_DECL_WITH_DEFAULTS); - void run (CORBA::Environment &ACE_TRY_ENV - = TAO_default_environment ()); + void run (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS); private: // -- Helper methods -- void verify_reference (Counter_ptr counter, - RT_Properties *rt_properties, - CORBA::Environment &ACE_TRY_ENV - = TAO_default_environment ()); + RT_Properties *rt_properties + TAO_ENV_ARG_DECL_WITH_DEFAULTS); CORBA::Boolean check_reference (CORBA::Object_ptr object, const char *msg); diff --git a/TAO/tests/Exposed_Policies/RT_Properties.cpp b/TAO/tests/Exposed_Policies/RT_Properties.cpp index 17a9dd6aca3..cff2300b0be 100644 --- a/TAO/tests/Exposed_Policies/RT_Properties.cpp +++ b/TAO/tests/Exposed_Policies/RT_Properties.cpp @@ -16,8 +16,8 @@ RT_Properties::~RT_Properties (void) } RT_Properties * -RT_Properties::read_from (const char *file_name, - CORBA::Environment &ACE_TRY_ENV) +RT_Properties::read_from (const char *file_name + TAO_ENV_ARG_DECL) { FILE *fp = ACE_OS::fopen (file_name, "r"); diff --git a/TAO/tests/Exposed_Policies/RT_Properties.h b/TAO/tests/Exposed_Policies/RT_Properties.h index 2608fc37e7a..310c8c99174 100644 --- a/TAO/tests/Exposed_Policies/RT_Properties.h +++ b/TAO/tests/Exposed_Policies/RT_Properties.h @@ -29,8 +29,8 @@ public: RT_Properties (void); ~RT_Properties (void); - static RT_Properties * read_from (const char *file_name, - CORBA::Environment &ACE_TRY_ENV); + static RT_Properties * read_from (const char *file_name + TAO_ENV_ARG_DECL); // -- Accessor Methods -- void priority (RTCORBA::Priority priority); diff --git a/TAO/tests/Exposed_Policies/client.cpp b/TAO/tests/Exposed_Policies/client.cpp index 30e1205c761..4859498b674 100644 --- a/TAO/tests/Exposed_Policies/client.cpp +++ b/TAO/tests/Exposed_Policies/client.cpp @@ -14,16 +14,16 @@ ACE_RCSID(tao, client, "$Id$") int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { Policy_Verifier policy_verifier; - policy_verifier.init (argc, argv, ACE_TRY_ENV); + policy_verifier.init (argc, argv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - policy_verifier.run (ACE_TRY_ENV); + policy_verifier.run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Exposed_Policies/server.cpp b/TAO/tests/Exposed_Policies/server.cpp index 4087198ca21..2903e49602e 100644 --- a/TAO/tests/Exposed_Policies/server.cpp +++ b/TAO/tests/Exposed_Policies/server.cpp @@ -21,19 +21,19 @@ ACE_RCSID(tao, server, "$Id$") int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { Policy_Tester policy_tester; - int result = policy_tester.init (argc, argv, ACE_TRY_ENV); + int result = policy_tester.init (argc, argv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result != 0) return result; - policy_tester.run (ACE_TRY_ENV); + policy_tester.run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } diff --git a/TAO/tests/FL_Cube/client.cpp b/TAO/tests/FL_Cube/client.cpp index 46acabb859b..1956c605ca5 100644 --- a/TAO/tests/FL_Cube/client.cpp +++ b/TAO/tests/FL_Cube/client.cpp @@ -39,8 +39,8 @@ public: void show (void); // Call show on all the window objects - void parse_args (int argc, char *argv[], - CORBA::Environment &ACE_TRY_ENV); + void parse_args (int argc, char *argv[] + TAO_ENV_ARG_DECL); private: static void x_cb (Fl_Widget *widget, void* cookie); @@ -68,7 +68,7 @@ int main (int argc, char* argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Fl_Window window (300, 100); @@ -81,14 +81,14 @@ int main (int argc, char* argv[]) client.show (); - client.parse_args (argc, argv, ACE_TRY_ENV); + client.parse_args (argc, argv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Fl::run (); } ACE_CATCHANY { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Catched exception:"); + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Caught exception:"); return 1; } ACE_ENDTRY; @@ -149,7 +149,7 @@ Client::x_changed (void) ACE_TRY_NEW_ENV { CORBA::Long x = CORBA::Long (this->x_roller_->value ()); - this->server_->set_x_angle (x, ACE_TRY_ENV); + this->server_->set_x_angle (x TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -165,7 +165,7 @@ Client::y_changed (void) ACE_TRY_NEW_ENV { CORBA::Long y = CORBA::Long (this->y_roller_->value ()); - this->server_->set_y_angle (y, ACE_TRY_ENV); + this->server_->set_y_angle (y TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -176,8 +176,8 @@ Client::y_changed (void) } void -Client::parse_args (int argc, char *argv[], - CORBA::Environment &ACE_TRY_ENV) +Client::parse_args (int argc, char *argv[] + TAO_ENV_ARG_DECL) { const char *ior = "file://test.ior"; @@ -200,11 +200,11 @@ Client::parse_args (int argc, char *argv[], } CORBA::Object_var object = - this->orb_->string_to_object (ior, ACE_TRY_ENV); + this->orb_->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_CHECK; this->server_ = - Simple_Server::_narrow (object.in (), ACE_TRY_ENV); + Simple_Server::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK; } #endif /* ACE_HAS_FL */ diff --git a/TAO/tests/FL_Cube/server.cpp b/TAO/tests/FL_Cube/server.cpp index 561a50778db..f8f466aecd7 100644 --- a/TAO/tests/FL_Cube/server.cpp +++ b/TAO/tests/FL_Cube/server.cpp @@ -31,14 +31,14 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -61,7 +61,7 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -73,7 +73,7 @@ main (int argc, char *argv[]) sw.show (); CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -82,39 +82,39 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Simple_Server_i server_impl (orb.in (), &sw); Simple_Server_var server = - server_impl._this (ACE_TRY_ENV); + server_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); // If the ior_output_file exists, output the ior to it if (ior_output_file != 0) - { - FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); - if (output_file == 0) - ACE_ERROR_RETURN ((LM_ERROR, - "Cannot open output file for writing IOR: %s", - ior_output_file), - 1); - ACE_OS::fprintf (output_file, "%s", ior.in ()); - ACE_OS::fclose (output_file); - } - - poa_manager->activate (ACE_TRY_ENV); + { + FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); + if (output_file == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot open output file for writing IOR: %s", + ior_output_file), + 1); + ACE_OS::fprintf (output_file, "%s", ior.in ()); + ACE_OS::fclose (output_file); + } + + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (Fl::run () == -1) @@ -124,7 +124,7 @@ main (int argc, char *argv[]) ACE_CATCHANY { ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Catched exception:"); + "Caught exception:"); return 1; } ACE_ENDTRY; diff --git a/TAO/tests/FL_Cube/test_i.cpp b/TAO/tests/FL_Cube/test_i.cpp index b6208c01cf9..cac8329a03c 100644 --- a/TAO/tests/FL_Cube/test_i.cpp +++ b/TAO/tests/FL_Cube/test_i.cpp @@ -20,19 +20,19 @@ Simple_Server_i::Simple_Server_i (CORBA::ORB_ptr orb, } void -Simple_Server_i::set_x_angle (CORBA::Long x, CORBA::Environment&) +Simple_Server_i::set_x_angle (CORBA::Long x TAO_ENV_ARG_DECL_NOT_USED) { this->window_->set_x_angle (x); } void -Simple_Server_i::set_y_angle (CORBA::Long y, CORBA::Environment&) +Simple_Server_i::set_y_angle (CORBA::Long y TAO_ENV_ARG_DECL_NOT_USED) { this->window_->set_y_angle (y); } void -Simple_Server_i::shutdown (CORBA::Environment&) +Simple_Server_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) { this->orb_->shutdown (0); } diff --git a/TAO/tests/FL_Cube/test_i.h b/TAO/tests/FL_Cube/test_i.h index 76b105cff79..2ae0ae47de9 100644 --- a/TAO/tests/FL_Cube/test_i.h +++ b/TAO/tests/FL_Cube/test_i.h @@ -64,9 +64,9 @@ public: // ctor // = The Simple_Server methods. - void set_x_angle (CORBA::Long x, CORBA::Environment&); - void set_y_angle (CORBA::Long y, CORBA::Environment&); - void shutdown (CORBA::Environment&); + void set_x_angle (CORBA::Long x TAO_ENV_ARG_DECL_NOT_USED); + void set_y_angle (CORBA::Long y TAO_ENV_ARG_DECL_NOT_USED); + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED); private: CORBA::ORB_var orb_; diff --git a/TAO/tests/Faults/client.cpp b/TAO/tests/Faults/client.cpp index 9a4ee0a775e..f293e7095f8 100644 --- a/TAO/tests/Faults/client.cpp +++ b/TAO/tests/Faults/client.cpp @@ -71,11 +71,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -84,25 +84,25 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Simple_Server_var server = - Simple_Server::_narrow (object.in (), ACE_TRY_ENV); + Simple_Server::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -116,14 +116,14 @@ main (int argc, char *argv[]) Callback_i callback_impl (orb.in ()); Callback_var callback = - callback_impl._this (ACE_TRY_ENV); + callback_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; for (int i = 0; i != niterations; ++i) { CORBA::Long r = - server->test_method (0, 0, callback.in (), - ACE_TRY_ENV); + server->test_method (0, 0, callback.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (r != 0) @@ -138,7 +138,7 @@ main (int argc, char *argv[]) { ACE_TRY_EX(ABORT) { - server->shutdown_now (0, ACE_TRY_ENV); + server->shutdown_now (0 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK_EX(ABORT); } ACE_CATCH (CORBA::COMM_FAILURE, comm_failure) @@ -153,7 +153,7 @@ main (int argc, char *argv[]) { ACE_TRY_EX(CRASH) { - server->shutdown_now (1, ACE_TRY_ENV); + server->shutdown_now (1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK_EX(CRASH); } ACE_CATCH (CORBA::COMM_FAILURE, comm_failure) @@ -166,25 +166,25 @@ main (int argc, char *argv[]) } else if (do_suicide) { - (void) server->test_method (1, 0, callback.in (), - ACE_TRY_ENV); + (void) server->test_method (1, 0, callback.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "ERROR: client should have aborted\n")); } else if (do_self_shutdown) { - (void) server->test_method (1, 1, callback.in (), - ACE_TRY_ENV); + (void) server->test_method (1, 1, callback.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } if (do_shutdown) { - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } diff --git a/TAO/tests/Faults/middle.cpp b/TAO/tests/Faults/middle.cpp index 6f88904ccef..157a5a9fc9b 100644 --- a/TAO/tests/Faults/middle.cpp +++ b/TAO/tests/Faults/middle.cpp @@ -19,8 +19,8 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case 'k': ior = get_opts.optarg; @@ -34,7 +34,7 @@ parse_args (int argc, char *argv[]) default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "-k <ior> " "-i <niterations> " "\n", @@ -51,11 +51,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -64,25 +64,25 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Simple_Server_var server = - Simple_Server::_narrow (object.in (), ACE_TRY_ENV); + Simple_Server::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -97,34 +97,34 @@ main (int argc, char *argv[]) server.in ()); Simple_Server_var middle = - middle_impl._this (ACE_TRY_ENV); + middle_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (middle.in (), ACE_TRY_ENV); + orb->object_to_string (middle.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); // If the ior_output_file exists, output the ior to it if (ior_output_file != 0) - { - FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); - if (output_file == 0) - ACE_ERROR_RETURN ((LM_ERROR, - "Cannot open output file for writing IOR: %s", - ior_output_file), - 1); - ACE_OS::fprintf (output_file, "%s", ior.in ()); - ACE_OS::fclose (output_file); - } - - orb->run (ACE_TRY_ENV); + { + FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); + if (output_file == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot open output file for writing IOR: %s", + ior_output_file), + 1); + ACE_OS::fprintf (output_file, "%s", ior.in ()); + ACE_OS::fclose (output_file); + } + + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } diff --git a/TAO/tests/Faults/ping.cpp b/TAO/tests/Faults/ping.cpp index cc21f45d8cd..3f571087e52 100644 --- a/TAO/tests/Faults/ping.cpp +++ b/TAO/tests/Faults/ping.cpp @@ -39,22 +39,22 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // create child poa with PERSISTENT policy @@ -62,25 +62,25 @@ main (int argc, char *argv[]) CORBA::PolicyList policies; policies.length (2); policies[0] = - root_poa->create_lifespan_policy(PortableServer::PERSISTENT, - ACE_TRY_ENV); + root_poa->create_lifespan_policy(PortableServer::PERSISTENT + TAO_ENV_ARG_PARAMETER); policies[1] = - root_poa->create_implicit_activation_policy(PortableServer::IMPLICIT_ACTIVATION, - ACE_TRY_ENV); + root_poa->create_implicit_activation_policy(PortableServer::IMPLICIT_ACTIVATION + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var persistent_poa = root_poa->create_POA("persistent", poa_manager.in (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - policies[0]->destroy (ACE_TRY_ENV); + policies[0]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - policies[1]->destroy (ACE_TRY_ENV); + policies[1]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -90,11 +90,11 @@ main (int argc, char *argv[]) persistent_poa.in ()); PingObject_var server = - server_impl._this (ACE_TRY_ENV); + server_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); @@ -112,15 +112,15 @@ main (int argc, char *argv[]) ACE_OS::fclose (output_file); } - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); - persistent_poa->destroy (1, 1, ACE_TRY_ENV); + persistent_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Faults/ping_i.cpp b/TAO/tests/Faults/ping_i.cpp index ec8e6b64105..e8129cce447 100644 --- a/TAO/tests/Faults/ping_i.cpp +++ b/TAO/tests/Faults/ping_i.cpp @@ -9,28 +9,28 @@ ACE_RCSID(Faults, test_i, "$Id$") void -PingObject_i::ping (PingObject_ptr callback, - CORBA::Environment &ACE_TRY_ENV) +PingObject_i::ping (PingObject_ptr callback + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - callback->pong (ACE_TRY_ENV); + callback->pong (TAO_ENV_SINGLE_ARG_PARAMETER); } void -PingObject_i::pong (CORBA::Environment &) +PingObject_i::pong (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { } void -PingObject_i::shutdown (CORBA::Environment &ACE_TRY_ENV) +PingObject_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } PortableServer::POA_ptr -PingObject_i::_default_POA (CORBA::Environment &) +PingObject_i::_default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return PortableServer::POA::_duplicate (this->poa_.in ()); diff --git a/TAO/tests/Faults/ping_i.h b/TAO/tests/Faults/ping_i.h index 1e3ef958cf5..76ded91dcbf 100644 --- a/TAO/tests/Faults/ping_i.h +++ b/TAO/tests/Faults/ping_i.h @@ -34,15 +34,15 @@ public: // ctor // = The PingObject interface methods - void ping (PingObject_ptr callback, - CORBA::Environment &ACE_TRY_ENV) + void ping (PingObject_ptr callback + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - void pong (CORBA::Environment &ACE_TRY_ENV) + void pong (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment &ACE_TRY_ENV) + void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - PortableServer::POA_ptr _default_POA (CORBA::Environment &ACE_TRY_ENV) + PortableServer::POA_ptr _default_POA (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Faults/pong.cpp b/TAO/tests/Faults/pong.cpp index 108184cad9e..1066400e786 100644 --- a/TAO/tests/Faults/pong.cpp +++ b/TAO/tests/Faults/pong.cpp @@ -55,8 +55,8 @@ parse_args (int argc, char *argv[]) void run_client (CORBA::ORB_ptr orb, PingObject_ptr server, - PingObject_ptr callback, - CORBA::Environment &ACE_TRY_ENV) + PingObject_ptr callback + TAO_ENV_ARG_DECL) { // Run the client requests in a separate routine to isolate the // exceptions... @@ -68,11 +68,11 @@ run_client (CORBA::ORB_ptr orb, ACE_TRY { reason = "Exception during ping call"; - server->ping (callback, ACE_TRY_ENV); + server->ping (callback TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Run for <period> milliseconds, to receive the reply - orb->run (tv, ACE_TRY_ENV); + orb->run (tv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Terminate the client if: @@ -83,7 +83,7 @@ run_client (CORBA::ORB_ptr orb, { ACE_DEBUG ((LM_DEBUG, "Shutting down server\n")); reason = "Exception during server shutdown"; - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } @@ -115,22 +115,22 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // create child poa with PERSISTENT policy @@ -138,37 +138,37 @@ main (int argc, char *argv[]) CORBA::PolicyList policies; policies.length (2); policies[0] = - root_poa->create_lifespan_policy(PortableServer::PERSISTENT, - ACE_TRY_ENV); + root_poa->create_lifespan_policy(PortableServer::PERSISTENT + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; policies[1] = - root_poa->create_implicit_activation_policy(PortableServer::IMPLICIT_ACTIVATION, - ACE_TRY_ENV); + root_poa->create_implicit_activation_policy(PortableServer::IMPLICIT_ACTIVATION + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var persistent_poa = root_poa->create_POA("persistent", poa_manager.in (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - policies[0]->destroy (ACE_TRY_ENV); + policies[0]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - policies[1]->destroy (ACE_TRY_ENV); + policies[1]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PingObject_var server = - PingObject::_narrow (object.in (), ACE_TRY_ENV); + PingObject::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -183,21 +183,21 @@ main (int argc, char *argv[]) persistent_poa.in ()); PingObject_var callback = - callback_impl._this (ACE_TRY_ENV); + callback_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it run_client (orb.in (), server.in (), - callback.in (), - ACE_TRY_ENV); + callback.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - persistent_poa->destroy (1, 1, ACE_TRY_ENV); + persistent_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Faults/server.cpp b/TAO/tests/Faults/server.cpp index 5dfdad61ba8..1ed8bab1f07 100644 --- a/TAO/tests/Faults/server.cpp +++ b/TAO/tests/Faults/server.cpp @@ -39,11 +39,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -52,14 +52,14 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -76,11 +76,11 @@ main (int argc, char *argv[]) Simple_Server_var server = - server_impl->_this (ACE_TRY_ENV); + server_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); @@ -98,12 +98,12 @@ main (int argc, char *argv[]) ACE_OS::fclose (output_file); } - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Faults/test_i.cpp b/TAO/tests/Faults/test_i.cpp index 67c8cc13dc2..ac290b81b1a 100644 --- a/TAO/tests/Faults/test_i.cpp +++ b/TAO/tests/Faults/test_i.cpp @@ -9,8 +9,8 @@ ACE_RCSID(Failure, test_i, "$Id$") void -Callback_i::shutdown (CORBA::Boolean is_clean, - CORBA::Environment &ACE_TRY_ENV) +Callback_i::shutdown (CORBA::Boolean is_clean + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { if (is_clean == 0) @@ -27,7 +27,7 @@ Callback_i::shutdown (CORBA::Boolean is_clean, return; } ACE_DEBUG ((LM_DEBUG, "Performing clean shutdown\n")); - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } // **************************************************************** @@ -35,15 +35,15 @@ Callback_i::shutdown (CORBA::Boolean is_clean, CORBA::Long Simple_Server_i::test_method (CORBA::Boolean do_callback, CORBA::Boolean is_clean, - Callback_ptr callback, - CORBA::Environment& ACE_TRY_ENV) + Callback_ptr callback + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { if (do_callback) { ACE_DEBUG ((LM_DEBUG, "Callback to shutdown client (%d)\n", is_clean)); - callback->shutdown (is_clean, ACE_TRY_ENV); + callback->shutdown (is_clean TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (0); } ACE_Time_Value tv (0, 20000); @@ -52,8 +52,8 @@ Simple_Server_i::test_method (CORBA::Boolean do_callback, } void -Simple_Server_i::shutdown_now (CORBA::Boolean is_clean, - CORBA::Environment& ACE_TRY_ENV) +Simple_Server_i::shutdown_now (CORBA::Boolean is_clean + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { if (is_clean == 0) @@ -68,14 +68,14 @@ Simple_Server_i::shutdown_now (CORBA::Boolean is_clean, } ACE_DEBUG ((LM_DEBUG, "Performing clean shutdown\n")); - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } void -Simple_Server_i::shutdown (CORBA::Environment& ACE_TRY_ENV) +Simple_Server_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } // **************************************************************** @@ -83,8 +83,8 @@ Simple_Server_i::shutdown (CORBA::Environment& ACE_TRY_ENV) CORBA::Long Middle_i::test_method (CORBA::Boolean do_callback, CORBA::Boolean is_clean, - Callback_ptr callback, - CORBA::Environment& ACE_TRY_ENV) + Callback_ptr callback + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { int i = 0; @@ -92,23 +92,23 @@ Middle_i::test_method (CORBA::Boolean do_callback, { this->server_->test_method (0, 0, - callback, - ACE_TRY_ENV); + callback + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (0); } this->server_->test_method (do_callback, is_clean, - callback, - ACE_TRY_ENV); + callback + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (0); for (; i != 10; ++i) { this->server_->test_method (0, 0, - callback, - ACE_TRY_ENV); + callback + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (0); } @@ -116,20 +116,20 @@ Middle_i::test_method (CORBA::Boolean do_callback, } void -Middle_i::shutdown_now (CORBA::Boolean is_clean, - CORBA::Environment& ACE_TRY_ENV) +Middle_i::shutdown_now (CORBA::Boolean is_clean + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->server_->shutdown_now (is_clean, ACE_TRY_ENV); + this->server_->shutdown_now (is_clean TAO_ENV_ARG_PARAMETER); } void -Middle_i::shutdown (CORBA::Environment& ACE_TRY_ENV) +Middle_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_TRY { - this->server_->shutdown (ACE_TRY_ENV); + this->server_->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -138,5 +138,5 @@ Middle_i::shutdown (CORBA::Environment& ACE_TRY_ENV) } ACE_ENDTRY; - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/Faults/test_i.h b/TAO/tests/Faults/test_i.h index 648e8e4f0f1..87335c1adb3 100644 --- a/TAO/tests/Faults/test_i.h +++ b/TAO/tests/Faults/test_i.h @@ -33,8 +33,8 @@ public: Callback_i (CORBA::ORB_ptr orb); // ctor - void shutdown (CORBA::Boolean is_clean, - CORBA::Environment &ACE_TRY_ENV) + void shutdown (CORBA::Boolean is_clean + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // The callback method @@ -58,15 +58,15 @@ public: // = The Simple_Server methods. CORBA::Long test_method (CORBA::Boolean do_callback, CORBA::Boolean is_clean, - Callback_ptr callback, - CORBA::Environment&) + Callback_ptr callback + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown_now (CORBA::Boolean is_clean, - CORBA::Environment&) + void shutdown_now (CORBA::Boolean is_clean + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: @@ -90,15 +90,15 @@ public: // = The Simple_Server methods. CORBA::Long test_method (CORBA::Boolean do_callback, CORBA::Boolean is_clean, - Callback_ptr callback, - CORBA::Environment&) + Callback_ptr callback + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown_now (CORBA::Boolean is_clean, - CORBA::Environment&) + void shutdown_now (CORBA::Boolean is_clean + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/File_IO/File_i.cpp b/TAO/tests/File_IO/File_i.cpp index a613869e10e..aec7d4a2464 100644 --- a/TAO/tests/File_IO/File_i.cpp +++ b/TAO/tests/File_IO/File_i.cpp @@ -24,9 +24,9 @@ FileImpl::System::System (PortableServer::POA_ptr poa) // Create the Default Descriptor Servant fd_servant_ (poa) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; // set the default servant of the POA - poa->set_servant (&this->fd_servant_, ACE_TRY_ENV); + poa->set_servant (&this->fd_servant_ TAO_ENV_ARG_PARAMETER); ACE_CHECK; } @@ -35,15 +35,15 @@ FileImpl::System::~System (void) } PortableServer::POA_ptr -FileImpl::System::_default_POA (CORBA::Environment &) +FileImpl::System::_default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) { return PortableServer::POA::_duplicate (this->poa_.in ()); } File::Descriptor_ptr FileImpl::System::open (const char *file_name, - CORBA::Long flags, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Long flags + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, File::IOError)) { @@ -72,13 +72,13 @@ FileImpl::System::open (const char *file_name, // from ACE_HANDLE string CORBA::Object_var obj = this->poa_->create_reference_with_id (oid.in (), - "IDL:File/Descriptor:1.0", - ACE_TRY_ENV); + "IDL:File/Descriptor:1.0" + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (File::Descriptor::_nil ()); // Narrow the object reference to a File Descriptor File::Descriptor_var fd = - File::Descriptor::_narrow (obj.in (), ACE_TRY_ENV); + File::Descriptor::_narrow (obj.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (File::Descriptor::_nil ()); @@ -96,26 +96,26 @@ FileImpl::Descriptor::~Descriptor (void) } PortableServer::POA_ptr -FileImpl::Descriptor::_default_POA (CORBA::Environment &) +FileImpl::Descriptor::_default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) { return PortableServer::POA::_duplicate (this->poa_.in ()); } //Extracts the ACE_HANDLE from the passed object reference ACE_HANDLE -FileImpl::Descriptor::fd (CORBA::Environment &ACE_TRY_ENV) +FileImpl::Descriptor::fd (TAO_ENV_SINGLE_ARG_DECL) { // // One way of getting our id. // // Get a reference to myself - File::Descriptor_var me = this->_this (ACE_TRY_ENV); + File::Descriptor_var me = this->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (ACE_INVALID_HANDLE); // Get the ObjectId from the reference PortableServer::ObjectId_var oid1 = - this->poa_->reference_to_id (me.in (), ACE_TRY_ENV); + this->poa_->reference_to_id (me.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (ACE_INVALID_HANDLE); // @@ -123,7 +123,7 @@ FileImpl::Descriptor::fd (CORBA::Environment &ACE_TRY_ENV) // PortableServer::ObjectId_var oid2 = - this->poa_->servant_to_id (this, ACE_TRY_ENV); + this->poa_->servant_to_id (this TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (ACE_INVALID_HANDLE); // @@ -131,23 +131,23 @@ FileImpl::Descriptor::fd (CORBA::Environment &ACE_TRY_ENV) // int argc = 0; - CORBA::ORB_var orb = CORBA::ORB_init (argc, 0, 0, ACE_TRY_ENV); + CORBA::ORB_var orb = CORBA::ORB_init (argc, 0, 0 TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (ACE_INVALID_HANDLE); // Get the POA Current object reference CORBA::Object_var obj = - orb->resolve_initial_references ("POACurrent", - ACE_TRY_ENV); + orb->resolve_initial_references ("POACurrent" + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (ACE_INVALID_HANDLE); // Narrow the object reference to a POA Current reference PortableServer::Current_var poa_current = - PortableServer::Current::_narrow (obj.in (), - ACE_TRY_ENV); + PortableServer::Current::_narrow (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (ACE_INVALID_HANDLE); PortableServer::ObjectId_var oid3 = - poa_current->get_object_id (ACE_TRY_ENV); + poa_current->get_object_id (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (ACE_INVALID_HANDLE); ACE_ASSERT (oid1.in () == oid2.in ()); @@ -162,12 +162,12 @@ FileImpl::Descriptor::fd (CORBA::Environment &ACE_TRY_ENV) } CORBA::Long -FileImpl::Descriptor::write (const File::Descriptor::DataBuffer &buffer, - CORBA::Environment &ACE_TRY_ENV) +FileImpl::Descriptor::write (const File::Descriptor::DataBuffer &buffer + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, File::IOError)) { - ACE_HANDLE file_descriptor = this->fd (ACE_TRY_ENV); + ACE_HANDLE file_descriptor = this->fd (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (0); const CORBA::Octet *data = &buffer[0]; @@ -182,12 +182,12 @@ FileImpl::Descriptor::write (const File::Descriptor::DataBuffer &buffer, } File::Descriptor::DataBuffer * -FileImpl::Descriptor::read (CORBA::Long num_bytes, - CORBA::Environment &ACE_TRY_ENV) +FileImpl::Descriptor::read (CORBA::Long num_bytes + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, File::IOError)) { - ACE_HANDLE file_descriptor = this->fd (ACE_TRY_ENV); + ACE_HANDLE file_descriptor = this->fd (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (0); CORBA::Octet *buffer = File::Descriptor::DataBuffer::allocbuf (num_bytes); @@ -205,12 +205,12 @@ FileImpl::Descriptor::read (CORBA::Long num_bytes, CORBA::ULong FileImpl::Descriptor::lseek (CORBA::ULong offset, - CORBA::Long whence, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Long whence + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, File::IOError)) { - ACE_HANDLE file_descriptor = this->fd (ACE_TRY_ENV); + ACE_HANDLE file_descriptor = this->fd (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (0); CORBA::Long result = (CORBA::Long) ACE_OS::lseek (file_descriptor, @@ -223,11 +223,11 @@ FileImpl::Descriptor::lseek (CORBA::ULong offset, } void -FileImpl::Descriptor::destroy (CORBA::Environment &ACE_TRY_ENV) +FileImpl::Descriptor::destroy (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { // Get the ACE_HANDLE for this object reference - ACE_HANDLE file_descriptor = this->fd (ACE_TRY_ENV); + ACE_HANDLE file_descriptor = this->fd (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; // Close the file corresponding to this object reference. diff --git a/TAO/tests/File_IO/File_i.h b/TAO/tests/File_IO/File_i.h index cee4e41d63e..30c6c6f5e5b 100644 --- a/TAO/tests/File_IO/File_i.h +++ b/TAO/tests/File_IO/File_i.h @@ -34,35 +34,35 @@ public: ~Descriptor (void); // Destructor - PortableServer::POA_ptr _default_POA (CORBA::Environment &env); + PortableServer::POA_ptr _default_POA (TAO_ENV_SINGLE_ARG_DECL); // Returns the default POA of this object - virtual CORBA::Long write (const File::Descriptor::DataBuffer &buffer, - CORBA::Environment &env) + virtual CORBA::Long write (const File::Descriptor::DataBuffer &buffer + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, File::IOError)); // write buffer to File corresponding to this Descriptor - virtual File::Descriptor::DataBuffer *read (CORBA::Long num_bytes, - CORBA::Environment &env) + virtual File::Descriptor::DataBuffer *read (CORBA::Long num_bytes + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, // Reads num_bytes from the file and returns it File::IOError)); virtual CORBA::ULong lseek (CORBA::ULong offset, - CORBA::Long whence, - CORBA::Environment &env) + CORBA::Long whence + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, File::IOError)); // seek to the offset in file from whence - virtual void destroy (CORBA::Environment &env) + virtual void destroy (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // closes the file corresponding to the requested ObjectID private: - ACE_HANDLE fd (CORBA::Environment &env); + ACE_HANDLE fd (TAO_ENV_SINGLE_ARG_DECL); // Extracts the ACE_HANDLE from the objectID PortableServer::POA_var poa_; @@ -80,12 +80,12 @@ public: ~System (void); //Destructor - PortableServer::POA_ptr _default_POA (CORBA::Environment &env); + PortableServer::POA_ptr _default_POA (TAO_ENV_SINGLE_ARG_DECL); //Returns the default POA of this object File::Descriptor_ptr open (const char *file_name, - CORBA::Long flags, - CORBA::Environment &env) + CORBA::Long flags + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, File::IOError)); // Opens a file ,creates a Descriptor reference with the diff --git a/TAO/tests/File_IO/client.cpp b/TAO/tests/File_IO/client.cpp index 78754b993cc..5160344c020 100644 --- a/TAO/tests/File_IO/client.cpp +++ b/TAO/tests/File_IO/client.cpp @@ -75,41 +75,41 @@ parse_args (int argc, char **argv) static void * MTTEST (void *args) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_CString& ior = *(ACE_CString*)args; ACE_TRY { - CORBA::Object_var object = orb->string_to_object (ior.c_str (), - ACE_TRY_ENV); + CORBA::Object_var object = orb->string_to_object (ior.c_str () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Narrow the object reference to a File::System - File::System_var file_system = File::System::_narrow (object.in (), - ACE_TRY_ENV); + File::System_var file_system = File::System::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Creat the file filename i.e "test" File::Descriptor_var fd = file_system->open (filename, - O_RDONLY, - ACE_TRY_ENV); + O_RDONLY + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; for( int i=0; i<loops; ++i) { //seek to the beginning of the file ACE_DEBUG((LM_DEBUG,"Making request number %d\n",i)); - fd->lseek (0, SEEK_SET, ACE_TRY_ENV); + fd->lseek (0, SEEK_SET TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Read back the written message // Twice the size of the socket buffer - File::Descriptor::DataBuffer_var data_received = fd->read (128*1024, - ACE_TRY_ENV); + File::Descriptor::DataBuffer_var data_received = fd->read (128*1024 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } // close the file - fd->destroy (ACE_TRY_ENV); + fd->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -125,12 +125,12 @@ MTTEST (void *args) int main (int argc, char **argv) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { // Initialize the ORB - orb = CORBA::ORB_init (argc, argv, 0, ACE_TRY_ENV); + orb = CORBA::ORB_init (argc, argv, 0 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Parse the command-line arguments to get the IOR diff --git a/TAO/tests/File_IO/server.cpp b/TAO/tests/File_IO/server.cpp index da008488264..87749551f69 100644 --- a/TAO/tests/File_IO/server.cpp +++ b/TAO/tests/File_IO/server.cpp @@ -77,11 +77,11 @@ main (int argc, char *argv[]) ACE_OS::write (handle, "", 1); ACE_OS::close (handle); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { // Initialize the ORB - CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, 0, ACE_TRY_ENV); + CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, 0 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; int result = parse_args (argc, argv); @@ -90,17 +90,17 @@ main (int argc, char *argv[]) // Obtain the RootPOA. CORBA::Object_var obj = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Narrow the object reference to a POA reference PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (obj.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (obj.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyList policies (5); @@ -108,35 +108,35 @@ main (int argc, char *argv[]) // ID Assignment Policy policies[0] = - root_poa->create_id_assignment_policy (PortableServer::USER_ID, ACE_TRY_ENV); + root_poa->create_id_assignment_policy (PortableServer::USER_ID TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Lifespan Policy policies[1] = - root_poa->create_lifespan_policy (PortableServer::PERSISTENT, ACE_TRY_ENV); + root_poa->create_lifespan_policy (PortableServer::PERSISTENT TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Request Processing Policy policies[2] = - root_poa->create_request_processing_policy (PortableServer::USE_DEFAULT_SERVANT, ACE_TRY_ENV); + root_poa->create_request_processing_policy (PortableServer::USE_DEFAULT_SERVANT TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Servant Retention Policy policies[3] = - root_poa->create_servant_retention_policy (PortableServer::RETAIN, ACE_TRY_ENV); + root_poa->create_servant_retention_policy (PortableServer::RETAIN TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Id Uniqueness Policy policies[4] = - root_poa->create_id_uniqueness_policy (PortableServer::MULTIPLE_ID, ACE_TRY_ENV); + root_poa->create_id_uniqueness_policy (PortableServer::MULTIPLE_ID TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_CString name = "firstPOA"; PortableServer::POA_var first_poa = root_poa->create_POA (name.c_str (), poa_manager.in (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; for (CORBA::ULong i = 0; @@ -144,7 +144,7 @@ main (int argc, char *argv[]) ++i) { CORBA::Policy_ptr policy = policies[i]; - policy->destroy (ACE_TRY_ENV); + policy->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -155,17 +155,17 @@ main (int argc, char *argv[]) PortableServer::string_to_ObjectId ("FileSystem"); first_poa->activate_object_with_id (file_system_oid.in (), - &file_system_impl, - ACE_TRY_ENV); + &file_system_impl + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var file_system = - first_poa->id_to_reference (file_system_oid.in (), ACE_TRY_ENV); + first_poa->id_to_reference (file_system_oid.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the IOR for the "FileSystem" object CORBA::String_var file_system_ior = - orb->object_to_string (file_system.in (), ACE_TRY_ENV); + orb->object_to_string (file_system.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG,"%s\n", @@ -182,7 +182,7 @@ main (int argc, char *argv[]) // set the state of the poa_manager to active i.e ready to // process requests - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Worker worker (orb.in ()); @@ -217,12 +217,12 @@ Worker::Worker (CORBA::ORB_ptr orb) int Worker::svc (void) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { // Run the ORB for atmost 75 seconds ACE_Time_Value tv (75, 0); - this->orb_->run (tv, ACE_TRY_ENV); + this->orb_->run (tv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Forwarding/client.cpp b/TAO/tests/Forwarding/client.cpp index d2ecf591d29..74fb63e708f 100644 --- a/TAO/tests/Forwarding/client.cpp +++ b/TAO/tests/Forwarding/client.cpp @@ -52,7 +52,7 @@ public: Worker (CORBA::ORB_ptr orb); // Constructor - virtual void run_test (CORBA::Environment &ACE_TRY_ENV); + virtual void run_test (TAO_ENV_SINGLE_ARG_DECL); // The actual implementation of the test // = The Task_Base methods @@ -69,7 +69,7 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -85,12 +85,12 @@ main (int argc, char *argv[]) ACE_Time_Value tv (5, 0); - orb->run (tv, ACE_TRY_ENV); + orb->run (tv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Now run a test in the main thread, just to confuse matters a // little more. - worker.run_test (ACE_TRY_ENV); + worker.run_test (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; worker.thr_mgr ()->wait (); @@ -98,18 +98,18 @@ main (int argc, char *argv[]) if (do_shutdown) { CORBA::Object_var object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Simple_Server_var server = - Simple_Server::_narrow (object.in (), ACE_TRY_ENV); + Simple_Server::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -135,7 +135,7 @@ Worker::svc (void) { ACE_TRY_NEW_ENV { - this->run_test (ACE_TRY_ENV); + this->run_test (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -149,16 +149,16 @@ Worker::svc (void) } void -Worker::run_test (CORBA::Environment &ACE_TRY_ENV) +Worker::run_test (TAO_ENV_SINGLE_ARG_DECL) { for (int j = 0; j != niterations; ++j) { CORBA::Object_var object = - this->orb_->string_to_object (ior, ACE_TRY_ENV); + this->orb_->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::Boolean is_simple_server = - object->_is_a ("IDL:Simple_Server:1.0", ACE_TRY_ENV); + object->_is_a ("IDL:Simple_Server:1.0" TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (!is_simple_server) ACE_DEBUG ((LM_DEBUG, @@ -166,11 +166,11 @@ Worker::run_test (CORBA::Environment &ACE_TRY_ENV) } CORBA::Object_var object = - this->orb_->string_to_object (ior, ACE_TRY_ENV); + this->orb_->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_CHECK; Simple_Server_var server = - Simple_Server::_narrow (object.in (), ACE_TRY_ENV); + Simple_Server::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (CORBA::is_nil (server.in ())) @@ -184,7 +184,7 @@ Worker::run_test (CORBA::Environment &ACE_TRY_ENV) for (int i = 0; i != niterations; ++i) { CORBA::Boolean r = - server->test_is_a ("IDL:Foo:1.0", ACE_TRY_ENV); + server->test_is_a ("IDL:Foo:1.0" TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (r != 0) diff --git a/TAO/tests/Forwarding/server.cpp b/TAO/tests/Forwarding/server.cpp index acd0a523c8a..c1978fab285 100644 --- a/TAO/tests/Forwarding/server.cpp +++ b/TAO/tests/Forwarding/server.cpp @@ -18,14 +18,14 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -40,15 +40,15 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (root_poa.in ())) ACE_ERROR_RETURN ((LM_ERROR, @@ -56,7 +56,7 @@ main (int argc, char *argv[]) 1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -65,25 +65,25 @@ main (int argc, char *argv[]) Simple_Server_i server_impl (orb.in ()); Simple_Server_var server = - server_impl._this (ACE_TRY_ENV); + server_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var table_object = - orb->resolve_initial_references("IORTable", ACE_TRY_ENV); + orb->resolve_initial_references("IORTable" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; IORTable::Table_var table = - IORTable::Table::_narrow (table_object.in (), ACE_TRY_ENV); + IORTable::Table::_narrow (table_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (table.in ())) ACE_ERROR_RETURN ((LM_ERROR, " (%P|%t) Unable to initialize the IORTable.\n"), 1); - table->bind ("Simple_Server", ior.in (), ACE_TRY_ENV); + table->bind ("Simple_Server", ior.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); @@ -97,10 +97,10 @@ main (int argc, char *argv[]) ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); diff --git a/TAO/tests/Forwarding/test_i.cpp b/TAO/tests/Forwarding/test_i.cpp index b972bb9ff01..ede8a267b1b 100644 --- a/TAO/tests/Forwarding/test_i.cpp +++ b/TAO/tests/Forwarding/test_i.cpp @@ -9,8 +9,8 @@ ACE_RCSID(Forwarding, test_i, "$Id$") CORBA::Boolean -Simple_Server_i::test_is_a (const char * /* type */, - CORBA::Environment&) +Simple_Server_i::test_is_a (const char * /* type */ + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { // ACE_DEBUG ((LM_DEBUG, "(%P|%t) test_is_a %s\n", type)); @@ -18,8 +18,8 @@ Simple_Server_i::test_is_a (const char * /* type */, } void -Simple_Server_i::shutdown (CORBA::Environment& ACE_TRY_ENV) +Simple_Server_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/Forwarding/test_i.h b/TAO/tests/Forwarding/test_i.h index 8627dc3768e..e8ce284c368 100644 --- a/TAO/tests/Forwarding/test_i.h +++ b/TAO/tests/Forwarding/test_i.h @@ -31,10 +31,10 @@ public: // ctor // = The Simple_Server methods. - CORBA::Boolean test_is_a (const char * type, CORBA::Environment&) + CORBA::Boolean test_is_a (const char * type TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Hello/Hello.cpp b/TAO/tests/Hello/Hello.cpp index ed757e48b2a..dc959b7650c 100644 --- a/TAO/tests/Hello/Hello.cpp +++ b/TAO/tests/Hello/Hello.cpp @@ -11,15 +11,15 @@ Hello::Hello (CORBA::ORB_ptr orb) } char * -Hello::get_string (CORBA::Environment &) +Hello::get_string (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return CORBA::string_dup ("Hello there!"); } void -Hello::shutdown (CORBA::Environment &ACE_TRY_ENV) +Hello::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/Hello/Hello.h b/TAO/tests/Hello/Hello.h index 5fa393ab4b7..2222cb5236d 100644 --- a/TAO/tests/Hello/Hello.h +++ b/TAO/tests/Hello/Hello.h @@ -25,10 +25,10 @@ public: Hello (CORBA::ORB_ptr orb); // = The skeleton methods - virtual char * get_string (CORBA::Environment &ACE_TRY_ENV) + virtual char * get_string (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Hello/client.cpp b/TAO/tests/Hello/client.cpp index 1c18d055e45..d2f8b87923b 100644 --- a/TAO/tests/Hello/client.cpp +++ b/TAO/tests/Hello/client.cpp @@ -17,14 +17,14 @@ parse_args (int argc, char *argv[]) switch (c) { case 'k': - ior = get_opts.optarg; - break; + ior = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-k <ior> " + "-k <ior> " "\n", argv [0]), -1); @@ -39,18 +39,18 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = - orb->string_to_object(ior, ACE_TRY_ENV); + orb->string_to_object(ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Hello_var hello = - Test::Hello::_narrow(tmp.in (), ACE_TRY_ENV); + Test::Hello::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (hello.in ())) @@ -62,16 +62,16 @@ main (int argc, char *argv[]) } CORBA::String_var the_string = - hello->get_string (ACE_TRY_ENV); + hello->get_string (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "(%P|%t) - string returned <%s>\n", the_string.in ())); - hello->shutdown (ACE_TRY_ENV); + hello->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Hello/server.cpp b/TAO/tests/Hello/server.cpp index 3b44ddd67e8..9cc27af8ec3 100644 --- a/TAO/tests/Hello/server.cpp +++ b/TAO/tests/Hello/server.cpp @@ -3,7 +3,9 @@ #include "Hello.h" #include "ace/Get_Opt.h" -ACE_RCSID(Hello, server, "$Id$") +ACE_RCSID (Hello, + server, + "$Id$") const char *ior_output_file = "test.ior"; @@ -17,14 +19,14 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -39,15 +41,15 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (root_poa.in ())) @@ -56,7 +58,7 @@ main (int argc, char *argv[]) 1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -69,11 +71,11 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var owner_transfer(hello_impl); Test::Hello_var hello = - hello_impl->_this (ACE_TRY_ENV); + hello_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (hello.in (), ACE_TRY_ENV); + orb->object_to_string (hello.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Output the IOR to the <ior_output_file> @@ -82,22 +84,22 @@ main (int argc, char *argv[]) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_output_file), - 1); + 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/IDL_Test/main.cpp b/TAO/tests/IDL_Test/main.cpp index a5aa746de5a..d46d46e94ef 100644 --- a/TAO/tests/IDL_Test/main.cpp +++ b/TAO/tests/IDL_Test/main.cpp @@ -42,25 +42,25 @@ class aloha_i : public virtual POA_aloha { }; -int +int main (int argc , char *argv[]) { ACE_TRY_NEW_ENV { - CORBA::ORB_var orb = CORBA::ORB_init (argc, - argv, - "", - ACE_TRY_ENV); + CORBA::ORB_var orb = CORBA::ORB_init (argc, + argv, + "" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Test of pragma prefix handling. @@ -71,7 +71,7 @@ main (int argc , char *argv[]) hello_i h; - obj = h._this (ACE_TRY_ENV); + obj = h._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; @@ -86,13 +86,13 @@ main (int argc , char *argv[]) goodbye_i g; - obj = g._this (ACE_TRY_ENV); + obj = g._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (ACE_OS::strcmp (obj->_interface_repository_id (), "IDL:anvil.com/goodbye:1.0")) - { + { ACE_DEBUG ((LM_DEBUG, "pragma prefix error in object 'goodbye'\n")); @@ -101,13 +101,13 @@ main (int argc , char *argv[]) sayonara_i s; - obj = s._this (ACE_TRY_ENV); + obj = s._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (ACE_OS::strcmp (obj->_interface_repository_id (), "IDL:hammer.com/salutation/sayonara:1.0")) - { + { ACE_DEBUG ((LM_DEBUG, "pragma prefix error in object 'sayonara'\n")); @@ -116,13 +116,13 @@ main (int argc , char *argv[]) ciao_i c; - obj = c._this (ACE_TRY_ENV); + obj = c._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (ACE_OS::strcmp (obj->_interface_repository_id (), "IDL:anvil.com/ciao:1.0")) - { + { ACE_DEBUG ((LM_DEBUG, "pragma prefix error in object 'ciao'\n")); @@ -131,13 +131,13 @@ main (int argc , char *argv[]) aloha_i a; - obj = a._this (ACE_TRY_ENV); + obj = a._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (ACE_OS::strcmp (obj->_interface_repository_id (), "IDL:anvil.com/aloha:1.0")) - { + { ACE_DEBUG ((LM_DEBUG, "pragma prefix error in object 'aloha'\n")); @@ -172,13 +172,13 @@ main (int argc , char *argv[]) str)); root_poa->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Unexpected exception in main"); return 1; } diff --git a/TAO/tests/IORManipulation/IORTest.cpp b/TAO/tests/IORManipulation/IORTest.cpp index abdef9c52d0..0e8a36929f6 100644 --- a/TAO/tests/IORManipulation/IORTest.cpp +++ b/TAO/tests/IORManipulation/IORTest.cpp @@ -32,50 +32,50 @@ main (int argc, char *argv[]) ACE_DEBUG ((LM_DEBUG, "---------------------------------------------\n")); ACE_DEBUG ((LM_DEBUG, "Running the IORManipulation Tests.\n")); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { // Retrieve the ORB. CORBA::ORB_var orb_ = CORBA::ORB_init (argc, argv, - "", - ACE_TRY_ENV); + "" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // ********************************************************************** // Get an object reference for the ORBs IORManipulation object! CORBA::Object_var IORM = - orb_->resolve_initial_references ("IORManipulation", - ACE_TRY_ENV); + orb_->resolve_initial_references ("IORManipulation" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; TAO_IOP::TAO_IOR_Manipulation_var iorm = - TAO_IOP::TAO_IOR_Manipulation::_narrow (IORM.in (), - ACE_TRY_ENV); + TAO_IOP::TAO_IOR_Manipulation::_narrow (IORM.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // ********************************************************************** // Create a few fictitious IORs CORBA::Object_var name1 = - orb_->string_to_object ("corbaloc:iiop:macarena.cs.wustl.edu:6060/xyz", - ACE_TRY_ENV); + orb_->string_to_object ("corbaloc:iiop:macarena.cs.wustl.edu:6060/xyz" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var name2 = - orb_->string_to_object ("corbaloc:iiop:tango.cs.wustl.edu:7070/xyz", - ACE_TRY_ENV); + orb_->string_to_object ("corbaloc:iiop:tango.cs.wustl.edu:7070/xyz" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // ********************************************************************** CORBA::String_var name1_ior = - orb_->object_to_string (name1.in (), ACE_TRY_ENV); + orb_->object_to_string (name1.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "\tFirst made up IOR = %s\n", name1_ior.in ())); CORBA::String_var name2_ior = - orb_->object_to_string (name2.in (), ACE_TRY_ENV); + orb_->object_to_string (name2.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "\tSecond made up IOR = %s\n", name2_ior.in ())); @@ -87,21 +87,21 @@ main (int argc, char *argv[]) iors [0] = name1; iors [1] = name2; - CORBA::Object_var merged = iorm->merge_iors (iors, ACE_TRY_ENV); + CORBA::Object_var merged = iorm->merge_iors (iors TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var merged_ior = - orb_->object_to_string (merged.in (), ACE_TRY_ENV); + orb_->object_to_string (merged.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::ULong count1 = iorm->get_profile_count (iors [0], ACE_TRY_ENV); + CORBA::ULong count1 = iorm->get_profile_count (iors [0] TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::ULong count2 = iorm->get_profile_count (iors [1], ACE_TRY_ENV); + CORBA::ULong count2 = iorm->get_profile_count (iors [1] TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::ULong count = iorm->get_profile_count (merged.in (), - ACE_TRY_ENV); + CORBA::ULong count = iorm->get_profile_count (merged.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (count != (count1 + count2)) @@ -116,8 +116,8 @@ main (int argc, char *argv[]) // is_in_ior throws an exception if the intersection of the two // IORs is NULL. CORBA::ULong in_count = iorm->is_in_ior (merged.in (), - name1.in (), - ACE_TRY_ENV); + name1.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (count1 != in_count) @@ -127,8 +127,8 @@ main (int argc, char *argv[]) in_count)); in_count = iorm->is_in_ior (merged.in (), - name2.in (), - ACE_TRY_ENV); + name2.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (count2 != in_count) @@ -142,14 +142,14 @@ main (int argc, char *argv[]) // Verify ability to remove profiles from an IOR // First remove the second IOR from the merged IOR CORBA::Object_var just1 = - iorm->remove_profiles (merged.in (), name2.in (), ACE_TRY_ENV); + iorm->remove_profiles (merged.in (), name2.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var just1_ior = - orb_->object_to_string (just1.in (), ACE_TRY_ENV); + orb_->object_to_string (just1.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - count = iorm->get_profile_count (just1.in (), ACE_TRY_ENV); + count = iorm->get_profile_count (just1.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (count1 != count) @@ -162,7 +162,7 @@ main (int argc, char *argv[]) count, just1_ior.in ())); - in_count = iorm->is_in_ior (just1.in (), name1.in (), ACE_TRY_ENV); + in_count = iorm->is_in_ior (just1.in (), name1.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (count1 != in_count) @@ -175,10 +175,10 @@ main (int argc, char *argv[]) // Now try the add_profiles interface. CORBA::Object_var merged2 = - iorm->add_profiles (just1.in (), name2.in (), ACE_TRY_ENV); + iorm->add_profiles (just1.in (), name2.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - count = iorm->get_profile_count (merged2.in (), ACE_TRY_ENV); + count = iorm->get_profile_count (merged2.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (count != (count1 + count2)) @@ -186,7 +186,7 @@ main (int argc, char *argv[]) "**ERROR: add_profile failed profile count test!\n")); CORBA::String_var merged2_ior = - orb_->object_to_string (merged2.in (), ACE_TRY_ENV); + orb_->object_to_string (merged2.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -196,7 +196,7 @@ main (int argc, char *argv[]) // is_in_ior throws an exception if the intersection of the two // IORs is NULL. - in_count = iorm->is_in_ior (merged2.in (), name1. in (), ACE_TRY_ENV); + in_count = iorm->is_in_ior (merged2.in (), name1. in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (count1 != in_count) @@ -205,7 +205,7 @@ main (int argc, char *argv[]) "count bad (%d)!\n", in_count)); - in_count = iorm->is_in_ior (merged2.in (), name2.in (), ACE_TRY_ENV); + in_count = iorm->is_in_ior (merged2.in (), name2.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (count2 != in_count) @@ -216,14 +216,14 @@ main (int argc, char *argv[]) // ********************************************************************** CORBA::Object_var just2 = - iorm->remove_profiles (merged2.in (), name1.in (), ACE_TRY_ENV); + iorm->remove_profiles (merged2.in (), name1.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var just2_ior = - orb_->object_to_string (just2.in (), ACE_TRY_ENV); + orb_->object_to_string (just2.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - count = iorm->get_profile_count (just2.in (), ACE_TRY_ENV); + count = iorm->get_profile_count (just2.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (count2 != count) @@ -234,7 +234,7 @@ main (int argc, char *argv[]) count, just2_ior.in ())); - in_count = iorm->is_in_ior (just2.in (), name2.in (), ACE_TRY_ENV); + in_count = iorm->is_in_ior (just2.in (), name2.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (count2 != in_count) @@ -247,7 +247,7 @@ main (int argc, char *argv[]) Status = 1; // Finally generate an exception and quit. // This will generate a NotFound exception. - in_count = iorm->is_in_ior (just2.in (), name1.in (), ACE_TRY_ENV); + in_count = iorm->is_in_ior (just2.in (), name1.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } diff --git a/TAO/tests/InterOp-Naming/INS_i.cpp b/TAO/tests/InterOp-Naming/INS_i.cpp index 9e0e07db934..11028ad50b5 100644 --- a/TAO/tests/InterOp-Naming/INS_i.cpp +++ b/TAO/tests/InterOp-Naming/INS_i.cpp @@ -24,11 +24,9 @@ INS_i::orb (CORBA::ORB_ptr o) } char * -INS_i::test_ins (CORBA::Environment &env) +INS_i::test_ins (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC (( CORBA::SystemException )) { - ACE_UNUSED_ARG (env); - ACE_DEBUG ((LM_DEBUG, "Inside Operation\n")); return CORBA::string_dup ("Success"); diff --git a/TAO/tests/InterOp-Naming/INS_i.h b/TAO/tests/InterOp-Naming/INS_i.h index c278b2030f8..6fb278a0c90 100644 --- a/TAO/tests/InterOp-Naming/INS_i.h +++ b/TAO/tests/InterOp-Naming/INS_i.h @@ -33,7 +33,7 @@ public: ~INS_i (void); // Destructor. - char * test_ins (CORBA::Environment &env) + char * test_ins (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC (( CORBA::SystemException )); // test the INS. diff --git a/TAO/tests/InterOp-Naming/INS_test_client.cpp b/TAO/tests/InterOp-Naming/INS_test_client.cpp index e6f9e1a5d1b..3e843c3a1c3 100644 --- a/TAO/tests/InterOp-Naming/INS_test_client.cpp +++ b/TAO/tests/InterOp-Naming/INS_test_client.cpp @@ -8,14 +8,14 @@ main (int argc, char *argv[]) { int i = 0; - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { // Retrieve a reference to the ORB. CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (argc < 2) @@ -33,7 +33,7 @@ main (int argc, char *argv[]) { // List initial services CORBA::ORB::ObjectIdList_var list = - orb->list_initial_services (ACE_TRY_ENV); + orb->list_initial_services (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; size_t length = list->length (); @@ -64,7 +64,7 @@ main (int argc, char *argv[]) } else { - objref = orb->resolve_initial_references (argv[i], ACE_TRY_ENV); + objref = orb->resolve_initial_references (argv[i] TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (objref.in ())) @@ -73,8 +73,8 @@ main (int argc, char *argv[]) "given name.\n"), -1); - INS_var server = INS::_narrow (objref.in (), - ACE_TRY_ENV); + INS_var server = INS::_narrow (objref.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -82,8 +82,8 @@ main (int argc, char *argv[]) argv[i], orb->object_to_string (server.in ()))); - CORBA::String_var test_ins_result = - server->test_ins (ACE_TRY_ENV); + CORBA::String_var test_ins_result = + server->test_ins (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, diff --git a/TAO/tests/InterOp-Naming/INS_test_server.cpp b/TAO/tests/InterOp-Naming/INS_test_server.cpp index 26bd72579b2..a65bffc9c54 100644 --- a/TAO/tests/InterOp-Naming/INS_test_server.cpp +++ b/TAO/tests/InterOp-Naming/INS_test_server.cpp @@ -16,12 +16,12 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { if (server.init (argc, - argv, - ACE_TRY_ENV) == -1) + argv + TAO_ENV_ARG_PARAMETER) == -1) return 1; else { - server.run (ACE_TRY_ENV); + server.run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/tests/InterOp-Naming/Server_i.cpp b/TAO/tests/InterOp-Naming/Server_i.cpp index 5621980ddb2..97b776c45ff 100644 --- a/TAO/tests/InterOp-Naming/Server_i.cpp +++ b/TAO/tests/InterOp-Naming/Server_i.cpp @@ -77,15 +77,15 @@ Server_i::add_IOR_to_table (CORBA::String_var ior) CORBA::Object_var table_object = this->orb_manager_.orb ()->resolve_initial_references ( - "IORTable", - ACE_TRY_ENV); + "IORTable" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; IORTable::Table_var adapter = - IORTable::Table::_narrow (table_object.in (), ACE_TRY_ENV); + IORTable::Table::_narrow (table_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - adapter->bind (this->ins_, ior.in (), ACE_TRY_ENV); + adapter->bind (this->ins_, ior.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (CORBA::SystemException, ex) @@ -100,15 +100,15 @@ Server_i::add_IOR_to_table (CORBA::String_var ior) // Initialize the server. int Server_i::init (int argc, - char *argv[], - CORBA::Environment &ACE_TRY_ENV) + char *argv[] + TAO_ENV_ARG_DECL) { // 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"), @@ -133,8 +133,8 @@ Server_i::init (int argc, { CORBA::String_var str = this->orb_manager_.activate_under_child_poa ("INS_servant", - &this->servant_, - ACE_TRY_ENV); + &this->servant_ + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -167,10 +167,10 @@ Server_i::init (int argc, } int -Server_i::run (CORBA::Environment &env) +Server_i::run (TAO_ENV_SINGLE_ARG_DECL) { // Run the main event loop for the ORB. - if (this->orb_manager_.run (env) == -1) + if (this->orb_manager_.run (TAO_ENV_SINGLE_ARG_PARAMETER) == -1) ACE_ERROR_RETURN ((LM_ERROR, "Server_i::run"), -1); diff --git a/TAO/tests/InterOp-Naming/Server_i.h b/TAO/tests/InterOp-Naming/Server_i.h index 28dd76343ce..d15824c425b 100644 --- a/TAO/tests/InterOp-Naming/Server_i.h +++ b/TAO/tests/InterOp-Naming/Server_i.h @@ -37,14 +37,14 @@ public: // Destructor. int init (int argc, - char *argv[], - CORBA::Environment &env); + char *argv[] + TAO_ENV_ARG_DECL); // Initialize the Server state - parsing arguments and waiting. int add_IOR_to_table (CORBA::String_var ior); // Add an IOR to the ORB-IOR table. - int run (CORBA::Environment &env); + int run (TAO_ENV_SINGLE_ARG_DECL); // Run the orb. protected: diff --git a/TAO/tests/Leader_Followers/client.cpp b/TAO/tests/Leader_Followers/client.cpp index dc53a97fae9..ca19357f5dd 100644 --- a/TAO/tests/Leader_Followers/client.cpp +++ b/TAO/tests/Leader_Followers/client.cpp @@ -109,7 +109,7 @@ public: int svc (void) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { @@ -134,8 +134,8 @@ public: "Client: Invoking server from thread %t for time %d @ %T\n", work_from_this_thread)); - CORBA::ULong result = this->test_->method (work_from_this_thread, - ACE_TRY_ENV); + CORBA::ULong result = this->test_->method (work_from_this_thread + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (work_from_this_thread != result) @@ -185,7 +185,7 @@ public: int svc (void) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { @@ -205,7 +205,7 @@ public: ACE_Time_Value timeout (0, event_loop_timeout_for_this_thread * 1000); - this->orb_->run (timeout, ACE_TRY_ENV); + this->orb_->run (timeout TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Client: Event loop finished for thread %t @ %T\n")); @@ -237,7 +237,7 @@ private: int main (int argc, char **argv) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { @@ -245,8 +245,8 @@ main (int argc, char **argv) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Initialize options based on command-line arguments. @@ -256,12 +256,12 @@ main (int argc, char **argv) // Get an object reference from the argument string. CORBA::Object_var object = - orb->string_to_object (IOR, ACE_TRY_ENV); + orb->string_to_object (IOR TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Try to narrow the object reference to a <server> reference. - test_var server = test::_narrow (object.in (), - ACE_TRY_ENV); + test_var server = test::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Client_Task client_task (server.in ()); @@ -292,7 +292,7 @@ main (int argc, char **argv) // Shutdown server. if (shutdown_server) { - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/tests/Leader_Followers/server.cpp b/TAO/tests/Leader_Followers/server.cpp index 15c7f9ee652..1746658649c 100644 --- a/TAO/tests/Leader_Followers/server.cpp +++ b/TAO/tests/Leader_Followers/server.cpp @@ -54,11 +54,11 @@ public: int svc (void) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { - this->orb_->run (ACE_TRY_ENV); + this->orb_->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -87,25 +87,25 @@ main (int argc, char *argv[]) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "", - ACE_TRY_ENV); + "" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -114,12 +114,12 @@ main (int argc, char *argv[]) test_i servant (orb.in ()); test_var server = - servant._this (ACE_TRY_ENV); + servant._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (server.in (), - ACE_TRY_ENV); + orb->object_to_string (server.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); @@ -146,8 +146,8 @@ main (int argc, char *argv[]) ACE_DEBUG ((LM_DEBUG, "Server: Event loop finished\n")); root_poa->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Leader_Followers/test_i.cpp b/TAO/tests/Leader_Followers/test_i.cpp index c12bcb08073..342ea2ea087 100644 --- a/TAO/tests/Leader_Followers/test_i.cpp +++ b/TAO/tests/Leader_Followers/test_i.cpp @@ -10,16 +10,16 @@ test_i::test_i (CORBA::ORB_ptr orb) } void -test_i::shutdown (CORBA::Environment &ACE_TRY_ENV) +test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, - ACE_TRY_ENV); + this->orb_->shutdown (0 + TAO_ENV_ARG_PARAMETER); } CORBA::ULong -test_i::method (CORBA::ULong work, - CORBA::Environment &) +test_i::method (CORBA::ULong work + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, diff --git a/TAO/tests/Leader_Followers/test_i.h b/TAO/tests/Leader_Followers/test_i.h index 776e7fc86fc..6395ac7eb07 100644 --- a/TAO/tests/Leader_Followers/test_i.h +++ b/TAO/tests/Leader_Followers/test_i.h @@ -25,11 +25,11 @@ public: // ctor. // = The test interface methods. - CORBA::ULong method (CORBA::ULong work, - CORBA::Environment &) + CORBA::ULong method (CORBA::ULong work + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment &) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/LongUpcalls/AMI_Manager.cpp b/TAO/tests/LongUpcalls/AMI_Manager.cpp index b3a92ab9689..712ed680558 100644 --- a/TAO/tests/LongUpcalls/AMI_Manager.cpp +++ b/TAO/tests/LongUpcalls/AMI_Manager.cpp @@ -14,8 +14,8 @@ AMI_Manager::AMI_Manager (CORBA::ORB_ptr orb) void AMI_Manager::start_workers (CORBA::Short worker_count, CORBA::Long milliseconds, - Test::Controller_ptr controller, - CORBA::Environment &) + Test::Controller_ptr controller + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_Thread_Manager thread_manager; @@ -31,10 +31,10 @@ AMI_Manager::start_workers (CORBA::Short worker_count, } void -AMI_Manager::shutdown (CORBA::Environment &ACE_TRY_ENV) +AMI_Manager::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } // **************************************************************** @@ -54,7 +54,7 @@ int Worker::svc (void) { // ACE_DEBUG ((LM_DEBUG, "Worker starts\n")); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { TAO_SYNCH_MUTEX mutex; @@ -69,11 +69,11 @@ Worker::svc (void) -1); PortableServer::ServantBase_var auto_destroy (handler_impl); - handler = handler_impl->_this (ACE_TRY_ENV); + handler = handler_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } - this->controller_->sendc_worker_started (handler.in (), - ACE_TRY_ENV); + this->controller_->sendc_worker_started (handler.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // ACE_DEBUG ((LM_DEBUG, "Worker start reported\n")); @@ -81,8 +81,8 @@ Worker::svc (void) ACE_Time_Value tv (0, 1000 * this->milliseconds_); ACE_OS::sleep (tv); - this->controller_->sendc_worker_finished (handler.in (), - ACE_TRY_ENV); + this->controller_->sendc_worker_finished (handler.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // ACE_DEBUG ((LM_DEBUG, "Worker completion reported\n")); @@ -90,7 +90,7 @@ Worker::svc (void) for (;;) { ACE_Time_Value tv (0, 1000 * this->milliseconds_); - this->orb_->run (tv, ACE_TRY_ENV); + this->orb_->run (tv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, mutex, -1); @@ -117,7 +117,7 @@ Controller_Handler::Controller_Handler (TAO_SYNCH_MUTEX *mutex, } void -Controller_Handler::worker_started (CORBA::Environment &) +Controller_Handler::worker_started (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, *this->mutex_); @@ -126,13 +126,13 @@ Controller_Handler::worker_started (CORBA::Environment &) void Controller_Handler::worker_started_excep - (Test::AMI_ControllerExceptionHolder* h, - CORBA::Environment &ACE_TRY_ENV) + (Test::AMI_ControllerExceptionHolder* h + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_TRY { - h->raise_worker_started (ACE_TRY_ENV); + h->raise_worker_started (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -145,7 +145,7 @@ Controller_Handler::worker_started_excep } void -Controller_Handler::worker_finished (CORBA::Environment &) +Controller_Handler::worker_finished (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, *this->mutex_); @@ -154,13 +154,13 @@ Controller_Handler::worker_finished (CORBA::Environment &) void Controller_Handler::worker_finished_excep - (Test::AMI_ControllerExceptionHolder *h, - CORBA::Environment &ACE_TRY_ENV) + (Test::AMI_ControllerExceptionHolder *h + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_TRY { - h->raise_worker_finished (ACE_TRY_ENV); + h->raise_worker_finished (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/LongUpcalls/AMI_Manager.h b/TAO/tests/LongUpcalls/AMI_Manager.h index f2517bedf7f..84ca8247dd5 100644 --- a/TAO/tests/LongUpcalls/AMI_Manager.h +++ b/TAO/tests/LongUpcalls/AMI_Manager.h @@ -24,10 +24,10 @@ public: // = The skeleton methods virtual void start_workers (CORBA::Short worker_count, CORBA::Long milliseconds, - Test::Controller_ptr controller, - CORBA::Environment &ACE_TRY_ENV) + Test::Controller_ptr controller + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: @@ -70,15 +70,15 @@ public: int *pending_replies); // Constructor - virtual void worker_started (CORBA::Environment &ACE_TRY_ENV) + virtual void worker_started (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void worker_started_excep (Test::AMI_ControllerExceptionHolder*, - CORBA::Environment &ACE_TRY_ENV) + virtual void worker_started_excep (Test::AMI_ControllerExceptionHolder* + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void worker_finished (CORBA::Environment &ACE_TRY_ENV) + virtual void worker_finished (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void worker_finished_excep (Test::AMI_ControllerExceptionHolder*, - CORBA::Environment &ACE_TRY_ENV) + virtual void worker_finished_excep (Test::AMI_ControllerExceptionHolder* + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/LongUpcalls/Controller.cpp b/TAO/tests/LongUpcalls/Controller.cpp index a9bbc43502e..2485ce0489f 100644 --- a/TAO/tests/LongUpcalls/Controller.cpp +++ b/TAO/tests/LongUpcalls/Controller.cpp @@ -24,7 +24,7 @@ Controller::dump_results () } void -Controller::worker_started (CORBA::Environment &) +Controller::worker_started (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->mutex_); @@ -34,7 +34,7 @@ Controller::worker_started (CORBA::Environment &) } void -Controller::worker_finished (CORBA::Environment &) +Controller::worker_finished (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->mutex_); diff --git a/TAO/tests/LongUpcalls/Controller.h b/TAO/tests/LongUpcalls/Controller.h index aaefd878e41..1ab48e7c104 100644 --- a/TAO/tests/LongUpcalls/Controller.h +++ b/TAO/tests/LongUpcalls/Controller.h @@ -24,9 +24,9 @@ public: // Print out the results and any errors // = The skeleton methods - virtual void worker_started (CORBA::Environment &ACE_TRY_ENV) + virtual void worker_started (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void worker_finished (CORBA::Environment &ACE_TRY_ENV) + virtual void worker_finished (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/LongUpcalls/Manager.cpp b/TAO/tests/LongUpcalls/Manager.cpp index c519ceec7a5..b9b9a2d1685 100644 --- a/TAO/tests/LongUpcalls/Manager.cpp +++ b/TAO/tests/LongUpcalls/Manager.cpp @@ -14,8 +14,8 @@ Manager::Manager (CORBA::ORB_ptr orb) void Manager::start_workers (CORBA::Short worker_count, CORBA::Long milliseconds, - Test::Controller_ptr controller, - CORBA::Environment &) + Test::Controller_ptr controller + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_Thread_Manager thread_manager; @@ -30,10 +30,10 @@ Manager::start_workers (CORBA::Short worker_count, } void -Manager::shutdown (CORBA::Environment &ACE_TRY_ENV) +Manager::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } @@ -52,10 +52,10 @@ int Worker::svc (void) { // ACE_DEBUG ((LM_DEBUG, "Worker starts\n")); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { - this->controller_->worker_started (ACE_TRY_ENV); + this->controller_->worker_started (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // ACE_DEBUG ((LM_DEBUG, "Worker start reported\n")); @@ -63,7 +63,7 @@ Worker::svc (void) ACE_Time_Value tv (0, 1000 * this->milliseconds_); ACE_OS::sleep (tv); - this->controller_->worker_finished (ACE_TRY_ENV); + this->controller_->worker_finished (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // ACE_DEBUG ((LM_DEBUG, "Worker completion reported\n")); diff --git a/TAO/tests/LongUpcalls/Manager.h b/TAO/tests/LongUpcalls/Manager.h index cabf27d0b5d..31cf037ced8 100644 --- a/TAO/tests/LongUpcalls/Manager.h +++ b/TAO/tests/LongUpcalls/Manager.h @@ -26,10 +26,10 @@ public: // = The skeleton methods virtual void start_workers (CORBA::Short worker_count, CORBA::Long milliseconds, - Test::Controller_ptr controller, - CORBA::Environment &ACE_TRY_ENV) + Test::Controller_ptr controller + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/LongUpcalls/Manager_Handler.cpp b/TAO/tests/LongUpcalls/Manager_Handler.cpp index f5207ae0fb6..a4ed57650f7 100644 --- a/TAO/tests/LongUpcalls/Manager_Handler.cpp +++ b/TAO/tests/LongUpcalls/Manager_Handler.cpp @@ -14,15 +14,15 @@ Manager_Handler::Manager_Handler (Test::Manager_ptr manager, } void -Manager_Handler::start_workers (CORBA::Environment &ACE_TRY_ENV) +Manager_Handler::start_workers (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_TRY { this->manager_->start_workers (CORBA::Short(10), CORBA::Long(1000), - this->controller_.in (), - ACE_TRY_ENV); + this->controller_.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -34,13 +34,13 @@ Manager_Handler::start_workers (CORBA::Environment &ACE_TRY_ENV) } void -Manager_Handler::start_workers_excep (Test::AMI_ManagerExceptionHolder * holder, - CORBA::Environment &ACE_TRY_ENV) +Manager_Handler::start_workers_excep (Test::AMI_ManagerExceptionHolder * holder + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_TRY { - holder->raise_start_workers (ACE_TRY_ENV); + holder->raise_start_workers (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/LongUpcalls/Manager_Handler.h b/TAO/tests/LongUpcalls/Manager_Handler.h index 94f1e3b3427..bc489e678b1 100644 --- a/TAO/tests/LongUpcalls/Manager_Handler.h +++ b/TAO/tests/LongUpcalls/Manager_Handler.h @@ -25,10 +25,10 @@ public: // Constructor // = The skeleton methods - virtual void start_workers (CORBA::Environment &ACE_TRY_ENV) + virtual void start_workers (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void start_workers_excep (Test::AMI_ManagerExceptionHolder*, - CORBA::Environment &ACE_TRY_ENV) + virtual void start_workers_excep (Test::AMI_ManagerExceptionHolder* + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/LongUpcalls/ami_client.cpp b/TAO/tests/LongUpcalls/ami_client.cpp index 4cb612e5fb8..64d285abdd4 100644 --- a/TAO/tests/LongUpcalls/ami_client.cpp +++ b/TAO/tests/LongUpcalls/ami_client.cpp @@ -18,13 +18,13 @@ parse_args (int argc, char *argv[]) switch (c) { case 'k': - ior = get_opts.optarg; - break; + ior = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-k <ior>" + "-k <ior>" "\n", argv [0]), -1); @@ -39,11 +39,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (object.in ())) @@ -52,11 +52,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -65,14 +65,14 @@ main (int argc, char *argv[]) Controller controller_impl; Test::Controller_var controller = - controller_impl._this (ACE_TRY_ENV); + controller_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - object = orb->string_to_object (ior, ACE_TRY_ENV); + object = orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Manager_var manager = - Test::Manager::_narrow (object.in (), ACE_TRY_ENV); + Test::Manager::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (manager.in ())) @@ -83,33 +83,33 @@ main (int argc, char *argv[]) Manager_Handler handler_impl (manager.in (), controller.in ()); Test::AMI_ManagerHandler_var handler = - handler_impl._this (ACE_TRY_ENV); + handler_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; const CORBA::Short worker_count = 10; manager->sendc_start_workers (handler.in (), worker_count, CORBA::Long (1000), - controller.in (), - ACE_TRY_ENV); + controller.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_Time_Value tv (30, 0); - orb->run (tv, ACE_TRY_ENV); + orb->run (tv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; controller_impl.dump_results (); - manager->shutdown (ACE_TRY_ENV); + manager->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/LongUpcalls/ami_server.cpp b/TAO/tests/LongUpcalls/ami_server.cpp index a05f10333d7..6eeacf2732d 100644 --- a/TAO/tests/LongUpcalls/ami_server.cpp +++ b/TAO/tests/LongUpcalls/ami_server.cpp @@ -17,13 +17,13 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -38,11 +38,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -51,11 +51,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -64,11 +64,11 @@ main (int argc, char *argv[]) AMI_Manager manager_impl (orb.in ()); Test::Manager_var manager = - manager_impl._this (ACE_TRY_ENV); + manager_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (manager.in (), ACE_TRY_ENV); + orb->object_to_string (manager.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -77,22 +77,22 @@ main (int argc, char *argv[]) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_output_file), - 1); + 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/LongUpcalls/blocking_client.cpp b/TAO/tests/LongUpcalls/blocking_client.cpp index 870496069e3..12e9fd95501 100644 --- a/TAO/tests/LongUpcalls/blocking_client.cpp +++ b/TAO/tests/LongUpcalls/blocking_client.cpp @@ -17,13 +17,13 @@ parse_args (int argc, char *argv[]) switch (c) { case 'k': - ior = get_opts.optarg; - break; + ior = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-k <ior>" + "-k <ior>" "\n", argv [0]), -1); @@ -38,11 +38,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (object.in ())) @@ -51,11 +51,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -64,14 +64,14 @@ main (int argc, char *argv[]) Controller controller_impl; Test::Controller_var controller = - controller_impl._this (ACE_TRY_ENV); + controller_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - object = orb->string_to_object (ior, ACE_TRY_ENV); + object = orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Manager_var manager = - Test::Manager::_narrow (object.in (), ACE_TRY_ENV); + Test::Manager::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (manager.in ())) @@ -80,25 +80,25 @@ main (int argc, char *argv[]) 1); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; const CORBA::Short worker_count = 10; manager->start_workers (worker_count, CORBA::Long (1000), - controller.in (), - ACE_TRY_ENV); + controller.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; controller_impl.dump_results (); - manager->shutdown (ACE_TRY_ENV); + manager->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/LongUpcalls/blocking_server.cpp b/TAO/tests/LongUpcalls/blocking_server.cpp index 05af445eb9f..5a58dbfd8f7 100644 --- a/TAO/tests/LongUpcalls/blocking_server.cpp +++ b/TAO/tests/LongUpcalls/blocking_server.cpp @@ -17,13 +17,13 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -38,11 +38,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -51,11 +51,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -64,11 +64,11 @@ main (int argc, char *argv[]) Manager manager_impl (orb.in ()); Test::Manager_var manager = - manager_impl._this (ACE_TRY_ENV); + manager_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (manager.in (), ACE_TRY_ENV); + orb->object_to_string (manager.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -77,22 +77,22 @@ main (int argc, char *argv[]) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_output_file), - 1); + 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/MProfile/client.cpp b/TAO/tests/MProfile/client.cpp index d81e4ace056..e15389d644c 100644 --- a/TAO/tests/MProfile/client.cpp +++ b/TAO/tests/MProfile/client.cpp @@ -48,18 +48,18 @@ parse_args (int argc, char *argv[]) } void -run_test (Simple_Server_ptr server, - CORBA::Environment &ACE_TRY_ENV); +run_test (Simple_Server_ptr server + TAO_ENV_ARG_DECL); int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -67,23 +67,23 @@ main (int argc, char *argv[]) // Primary server CORBA::Object_var object_primary = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; //Secondary server CORBA::Object_var object_secondary = - orb->string_to_object (name, ACE_TRY_ENV); + orb->string_to_object (name TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get an object reference for the ORBs IORManipultion object! CORBA_Object_ptr IORM = orb->resolve_initial_references (TAO_OBJID_IORMANIPULATION, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; TAO_IOP::TAO_IOR_Manipulation_ptr iorm = - TAO_IOP::TAO_IOR_Manipulation::_narrow (IORM, ACE_TRY_ENV); + TAO_IOP::TAO_IOR_Manipulation::_narrow (IORM TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; TAO_IOP::TAO_IOR_Manipulation::IORList iors (2); @@ -91,12 +91,12 @@ main (int argc, char *argv[]) iors [0] = object_primary; iors [1] = object_secondary; - CORBA_Object_var merged = iorm->merge_iors (iors, ACE_TRY_ENV); + CORBA_Object_var merged = iorm->merge_iors (iors TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Combined IOR stuff Simple_Server_var server = - Simple_Server::_narrow (merged.in (), ACE_TRY_ENV); + Simple_Server::_narrow (merged.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -107,7 +107,7 @@ main (int argc, char *argv[]) 1); } - run_test (server.in (), ACE_TRY_ENV); + run_test (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -119,8 +119,8 @@ main (int argc, char *argv[]) return 0; } -void run_test (Simple_Server_ptr server, - CORBA::Environment &ACE_TRY_ENV) +void run_test (Simple_Server_ptr server + TAO_ENV_ARG_DECL) { for (int loop = 0; loop < 10; loop++) { @@ -129,7 +129,7 @@ void run_test (Simple_Server_ptr server, // Make a remote call cout << "Remote call "<<endl; CORBA::Long ret= - server->remote_call (ACE_TRY_ENV); + server->remote_call (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; cout << "The retval is .. " << ret << endl; diff --git a/TAO/tests/MProfile/server.cpp b/TAO/tests/MProfile/server.cpp index 7d91591bccc..0edb0a7bd20 100644 --- a/TAO/tests/MProfile/server.cpp +++ b/TAO/tests/MProfile/server.cpp @@ -17,13 +17,13 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -38,11 +38,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -51,15 +51,15 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the POAManager of the RootPOA. PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -68,35 +68,35 @@ main (int argc, char *argv[]) Simple_Server_i server_impl (orb.in ()); Simple_Server_var server = - server_impl._this (ACE_TRY_ENV); + server_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); // If the ior_output_file exists, output the ior to it if (ior_output_file != 0) - { - FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); - if (output_file == 0) - ACE_ERROR_RETURN ((LM_ERROR, - "Cannot open output file for writing IOR: %s", - ior_output_file), - 1); - ACE_OS::fprintf (output_file, "%s", ior.in ()); - ACE_OS::fclose (output_file); - } - - - orb->run (ACE_TRY_ENV); + { + FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); + if (output_file == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot open output file for writing IOR: %s", + ior_output_file), + 1); + ACE_OS::fprintf (output_file, "%s", ior.in ()); + ACE_OS::fclose (output_file); + } + + + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_OS::sleep (5); diff --git a/TAO/tests/MProfile/test_i.cpp b/TAO/tests/MProfile/test_i.cpp index b8e877722ca..bbf7e7c0709 100644 --- a/TAO/tests/MProfile/test_i.cpp +++ b/TAO/tests/MProfile/test_i.cpp @@ -17,7 +17,7 @@ Simple_Server_i::Simple_Server_i (void) } CORBA::Long -Simple_Server_i::remote_call (CORBA::Environment &) +Simple_Server_i::remote_call (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -28,7 +28,7 @@ Simple_Server_i::remote_call (CORBA::Environment &) void -Simple_Server_i::shutdown (CORBA::Environment&) +Simple_Server_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->orb_->shutdown (0); diff --git a/TAO/tests/MProfile/test_i.h b/TAO/tests/MProfile/test_i.h index f2e2242f70f..f839fd3c6b4 100644 --- a/TAO/tests/MProfile/test_i.h +++ b/TAO/tests/MProfile/test_i.h @@ -34,10 +34,10 @@ public: // ctor // = The Simple_Server methods. - CORBA::Long remote_call (CORBA::Environment &) + CORBA::Long remote_call (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/MProfile_Forwarding/Manager.cpp b/TAO/tests/MProfile_Forwarding/Manager.cpp index 700a76a2070..c7d8400ef38 100644 --- a/TAO/tests/MProfile_Forwarding/Manager.cpp +++ b/TAO/tests/MProfile_Forwarding/Manager.cpp @@ -49,7 +49,7 @@ int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; Manager manager; @@ -57,20 +57,20 @@ main (int argc, { // Initilaize the ORB, POA etc. manager.init (argc, - argv, - ACE_TRY_ENV); + argv + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) == -1) return -1; - manager.activate_servant (ACE_TRY_ENV); + manager.activate_servant (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - manager.make_iors_register (ACE_TRY_ENV); + manager.make_iors_register (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - manager.run (ACE_TRY_ENV); + manager.run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -93,31 +93,31 @@ Manager::Manager (void) int Manager::init (int argc, - char *argv[], - CORBA::Environment &ACE_TRY_ENV) + char *argv[] + TAO_ENV_ARG_DECL) { this->orb_ = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Obtain the RootPOA. CORBA::Object_var obj_var = - this->orb_->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + this->orb_->resolve_initial_references ("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Get the POA_var object from Object_var. PortableServer::POA_var root_poa_var = - PortableServer::POA::_narrow (obj_var.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (obj_var.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Get the POAManager of the RootPOA. PortableServer::POAManager_var poa_manager_var = - root_poa_var->the_POAManager (ACE_TRY_ENV); + root_poa_var->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); - poa_manager_var->activate (ACE_TRY_ENV); + poa_manager_var->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Policies for the childPOA to be created. @@ -127,26 +127,26 @@ Manager::init (int argc, // The next two policies are common to both // Id Assignment Policy policies[0] = - root_poa_var->create_id_assignment_policy (PortableServer::USER_ID, - ACE_TRY_ENV); + root_poa_var->create_id_assignment_policy (PortableServer::USER_ID + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Lifespan policy policies[1] = - root_poa_var->create_lifespan_policy (PortableServer::PERSISTENT, - ACE_TRY_ENV); + root_poa_var->create_lifespan_policy (PortableServer::PERSISTENT + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Tell the POA to use a servant manager policies[2] = - root_poa_var->create_request_processing_policy (PortableServer::USE_SERVANT_MANAGER, - ACE_TRY_ENV); + root_poa_var->create_request_processing_policy (PortableServer::USE_SERVANT_MANAGER + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Servant Retention Policy -> Use a locator policies[3] = - root_poa_var->create_servant_retention_policy (PortableServer::NON_RETAIN, - ACE_TRY_ENV); + root_poa_var->create_servant_retention_policy (PortableServer::NON_RETAIN + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_CString name = "newPOA"; @@ -154,8 +154,8 @@ Manager::init (int argc, new_poa_var_ = root_poa_var->create_POA (name.c_str (), poa_manager_var.in (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Creation of childPOAs is over. Destroy the Policy objects. @@ -164,7 +164,7 @@ Manager::init (int argc, ++i) { CORBA::Policy_ptr policy = policies[i]; - policy->destroy (ACE_TRY_ENV); + policy->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); } @@ -173,7 +173,7 @@ Manager::init (int argc, int -Manager::activate_servant (CORBA::Environment &ACE_TRY_ENV) +Manager::activate_servant (TAO_ENV_SINGLE_ARG_DECL) { ACE_NEW_THROW_EX (this->servant_locator_, @@ -185,8 +185,8 @@ Manager::activate_servant (CORBA::Environment &ACE_TRY_ENV) // Set ServantLocator object as the servant Manager of // secondPOA. - this->new_poa_var_->set_servant_manager (this->servant_locator_, - ACE_TRY_ENV); + this->new_poa_var_->set_servant_manager (this->servant_locator_ + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Try to create a reference with user created ID in new_poa @@ -197,7 +197,7 @@ Manager::activate_servant (CORBA::Environment &ACE_TRY_ENV) this->new_manager_ior_ = new_poa_var_->create_reference_with_id (second_foo_oid_var.in (), - "IDL:Simple_Server:1.0", ACE_TRY_ENV); + "IDL:Simple_Server:1.0" TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); return 0; @@ -205,18 +205,18 @@ Manager::activate_servant (CORBA::Environment &ACE_TRY_ENV) int -Manager::make_iors_register (CORBA::Environment &ACE_TRY_ENV) +Manager::make_iors_register (TAO_ENV_SINGLE_ARG_DECL) { // First server CORBA::Object_var object_primary = - this->orb_->string_to_object (first_ior, - ACE_TRY_ENV); + this->orb_->string_to_object (first_ior + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); //Second server CORBA::Object_var object_secondary = - this->orb_->string_to_object (second_ior, - ACE_TRY_ENV); + this->orb_->string_to_object (second_ior + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (third_ior == 0) @@ -224,19 +224,19 @@ Manager::make_iors_register (CORBA::Environment &ACE_TRY_ENV) "Here is the culprit \n")); // Third Server CORBA::Object_var object_tertiary = - this->orb_->string_to_object (third_ior, - ACE_TRY_ENV); + this->orb_->string_to_object (third_ior + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Get an object reference for the ORBs IORManipultion object! CORBA_Object_ptr IORM = this->orb_->resolve_initial_references (TAO_OBJID_IORMANIPULATION, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); TAO_IOP::TAO_IOR_Manipulation_ptr iorm = - TAO_IOP::TAO_IOR_Manipulation::_narrow (IORM, ACE_TRY_ENV); + TAO_IOP::TAO_IOR_Manipulation::_narrow (IORM TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); @@ -249,7 +249,7 @@ Manager::make_iors_register (CORBA::Environment &ACE_TRY_ENV) // Create a merged set 1; CORBA_Object_var merged_set1 = - iorm->merge_iors (iors, ACE_TRY_ENV); + iorm->merge_iors (iors TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (object_secondary.in () == 0) @@ -268,7 +268,7 @@ Manager::make_iors_register (CORBA::Environment &ACE_TRY_ENV) // Create merged set 2 CORBA_Object_var merged_set2 = - iorm->merge_iors (iors_again, ACE_TRY_ENV); + iorm->merge_iors (iors_again TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::String_var iorref1 = @@ -293,9 +293,9 @@ Manager::make_iors_register (CORBA::Environment &ACE_TRY_ENV) int -Manager::run (CORBA::Environment &ACE_TRY_ENV) +Manager::run (TAO_ENV_SINGLE_ARG_DECL) { - this->orb_->run (ACE_TRY_ENV); + this->orb_->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); return 0; diff --git a/TAO/tests/MProfile_Forwarding/Manager.h b/TAO/tests/MProfile_Forwarding/Manager.h index c83349cf76e..7c61379f133 100644 --- a/TAO/tests/MProfile_Forwarding/Manager.h +++ b/TAO/tests/MProfile_Forwarding/Manager.h @@ -13,20 +13,20 @@ class Manager // Ctor int init (int argc, - char *argv[], - CORBA::Environment & ACE_TRY_ENV); + char *argv[] + TAO_ENV_ARG_DECL); // Initialize the ORB, POA etc. - int init_register_name_service (CORBA::Environment &ACE_TRY_ENV); + int init_register_name_service (TAO_ENV_SINGLE_ARG_DECL); // Initialize the Name service, tegister the combined IOR with it - int activate_servant (CORBA::Environment &ACE_TRY_ENV); + int activate_servant (TAO_ENV_SINGLE_ARG_DECL); // Activate the servant etc. - int make_iors_register (CORBA::Environment &); + int make_iors_register (TAO_ENV_SINGLE_ARG_DECL_NOT_USED); - int run (CORBA::Environment &ACE_TRY_ENV); + int run (TAO_ENV_SINGLE_ARG_DECL); // Run the ORB event loop.. private: CORBA::ORB_var orb_; diff --git a/TAO/tests/MProfile_Forwarding/Servant_Locator.cpp b/TAO/tests/MProfile_Forwarding/Servant_Locator.cpp index 87751adb169..c3b52c4346b 100755 --- a/TAO/tests/MProfile_Forwarding/Servant_Locator.cpp +++ b/TAO/tests/MProfile_Forwarding/Servant_Locator.cpp @@ -46,7 +46,6 @@ Servant_Locator::preinvoke (const PortableServer::ObjectId &oid, ACE_THROW_SPEC ((CORBA::SystemException, PortableServer::ForwardRequest)) { - TAO_ENV_ARG_DEFN; CORBA::String_var s = PortableServer::ObjectId_to_string (oid); @@ -59,8 +58,8 @@ Servant_Locator::preinvoke (const PortableServer::ObjectId &oid, // Combined IOR stuff Simple_Server_var server = - Simple_Server::_narrow (this->objref_.in (), - ACE_TRY_ENV); + Simple_Server::_narrow (this->objref_.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (0); ACE_DEBUG ((LM_DEBUG, diff --git a/TAO/tests/MProfile_Forwarding/client.cpp b/TAO/tests/MProfile_Forwarding/client.cpp index e52320e373b..10c176b81a7 100644 --- a/TAO/tests/MProfile_Forwarding/client.cpp +++ b/TAO/tests/MProfile_Forwarding/client.cpp @@ -34,18 +34,18 @@ parse_args (int argc, char *argv[]) } void -run_test (Simple_Server_ptr server, - CORBA::Environment &ACE_TRY_ENV); +run_test (Simple_Server_ptr server + TAO_ENV_ARG_DECL); int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) == -1) @@ -63,7 +63,7 @@ main (int argc, char *argv[]) } Simple_Server_var server = - Simple_Server::_narrow (objref.in (), ACE_TRY_ENV); + Simple_Server::_narrow (objref.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -73,7 +73,7 @@ main (int argc, char *argv[]) -1); } - run_test (server.in (), ACE_TRY_ENV); + run_test (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -85,8 +85,8 @@ main (int argc, char *argv[]) return 0; } -void run_test (Simple_Server_ptr server, - CORBA::Environment &ACE_TRY_ENV) +void run_test (Simple_Server_ptr server + TAO_ENV_ARG_DECL) { for (int loop = 0; loop < 10; loop++) { @@ -97,7 +97,7 @@ void run_test (Simple_Server_ptr server, ACE_OS::sleep (2); // Make a remote call - server->remote_call (ACE_TRY_ENV); + server->remote_call (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; /*ACE_DEBUG ((LM_DEBUG, @@ -106,7 +106,7 @@ void run_test (Simple_Server_ptr server, ACE_DEBUG ((LM_DEBUG, " hope you did\n")); */ ACE_DEBUG ((LM_DEBUG, "I am going to shutdown \n")); - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_OS::sleep (23); } diff --git a/TAO/tests/MProfile_Forwarding/server.cpp b/TAO/tests/MProfile_Forwarding/server.cpp index 47c475b7dd9..1d88b1a6acf 100755 --- a/TAO/tests/MProfile_Forwarding/server.cpp +++ b/TAO/tests/MProfile_Forwarding/server.cpp @@ -17,13 +17,13 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -38,11 +38,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -51,15 +51,15 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the POAManager of the RootPOA. PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -68,35 +68,35 @@ main (int argc, char *argv[]) Simple_Server_i server_impl (orb.in ()); Simple_Server_var server = - server_impl._this (ACE_TRY_ENV); + server_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); // If the ior_output_file exists, output the ior to it if (ior_output_file != 0) - { - FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); - if (output_file == 0) - ACE_ERROR_RETURN ((LM_ERROR, - "Cannot open output file for writing IOR: %s", - ior_output_file), - 1); - ACE_OS::fprintf (output_file, "%s", ior.in ()); - ACE_OS::fclose (output_file); - } - - - orb->run (ACE_TRY_ENV); + { + FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); + if (output_file == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot open output file for writing IOR: %s", + ior_output_file), + 1); + ACE_OS::fprintf (output_file, "%s", ior.in ()); + ACE_OS::fclose (output_file); + } + + + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_OS::sleep (5); @@ -104,7 +104,7 @@ main (int argc, char *argv[]) ACE_CATCHANY { ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Catched exception:"); + "Caught exception:"); return 1; } ACE_ENDTRY; diff --git a/TAO/tests/MProfile_Forwarding/test_i.cpp b/TAO/tests/MProfile_Forwarding/test_i.cpp index 27ebda35fb2..9866b7fb3a3 100644 --- a/TAO/tests/MProfile_Forwarding/test_i.cpp +++ b/TAO/tests/MProfile_Forwarding/test_i.cpp @@ -15,7 +15,7 @@ Simple_Server_i::Simple_Server_i (void) } void -Simple_Server_i::remote_call (CORBA::Environment &) +Simple_Server_i::remote_call (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -24,7 +24,7 @@ Simple_Server_i::remote_call (CORBA::Environment &) void -Simple_Server_i::shutdown (CORBA::Environment&) +Simple_Server_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->orb_->shutdown (0); diff --git a/TAO/tests/MProfile_Forwarding/test_i.h b/TAO/tests/MProfile_Forwarding/test_i.h index b704fa70ceb..f55d995e411 100644 --- a/TAO/tests/MProfile_Forwarding/test_i.h +++ b/TAO/tests/MProfile_Forwarding/test_i.h @@ -34,10 +34,10 @@ public: // ctor // = The Simple_Server methods. - void remote_call (CORBA::Environment &) + void remote_call (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/MT_Client/client.cpp b/TAO/tests/MT_Client/client.cpp index ee57e2b8900..75dbdd84241 100644 --- a/TAO/tests/MT_Client/client.cpp +++ b/TAO/tests/MT_Client/client.cpp @@ -64,7 +64,7 @@ public: // The thread entry point. private: - void validate_connection (CORBA::Environment &); + void validate_connection (TAO_ENV_SINGLE_ARG_DECL_NOT_USED); // Validate the connection private: @@ -81,18 +81,18 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Simple_Server_var server = - Simple_Server::_narrow (object.in (), ACE_TRY_ENV); + Simple_Server::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -116,11 +116,11 @@ main (int argc, char *argv[]) if (server_shutdown) { - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -144,7 +144,7 @@ Client::Client (Simple_Server_ptr server, } void -Client::validate_connection (CORBA::Environment &ACE_TRY_ENV) +Client::validate_connection (TAO_ENV_SINGLE_ARG_DECL) { // Ping the object 100 times, ignoring all exceptions. // It would be better to use validate_connection() but the test must @@ -153,7 +153,7 @@ Client::validate_connection (CORBA::Environment &ACE_TRY_ENV) { ACE_TRY { - this->server_->test_method (ACE_TRY_ENV); + this->server_->test_method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY {} ACE_ENDTRY; @@ -165,12 +165,12 @@ Client::svc (void) { ACE_TRY_NEW_ENV { - this->validate_connection (ACE_TRY_ENV); + this->validate_connection (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; for (int i = 0; i < this->niterations_; ++i) { - this->server_->test_method (ACE_TRY_ENV); + this->server_->test_method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (TAO_debug_level > 0 && i % 100 == 0) diff --git a/TAO/tests/MT_Client/orb_creation.cpp b/TAO/tests/MT_Client/orb_creation.cpp index d44016f40f1..97b08f0eb11 100644 --- a/TAO/tests/MT_Client/orb_creation.cpp +++ b/TAO/tests/MT_Client/orb_creation.cpp @@ -81,11 +81,11 @@ main (int argc, char *argv[]) return 1; CORBA::Object_var object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Simple_Server_var server = - Simple_Server::_narrow (object.in (), ACE_TRY_ENV); + Simple_Server::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -107,7 +107,7 @@ main (int argc, char *argv[]) ACE_DEBUG ((LM_DEBUG, "threads finished\n")); - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -133,7 +133,7 @@ Client::Client (int niterations, int Client::svc (void) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { for (int i = 0; i < this->niterations_; ++i) @@ -144,15 +144,15 @@ Client::svc (void) CORBA::String_var argv0 = CORBA::string_dup ("dummy_argv"); char* argv[1] = { argv0.inout () }; CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var object = - orb->string_to_object (this->ior_, ACE_TRY_ENV); + orb->string_to_object (this->ior_ TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Simple_Server_var server = - Simple_Server::_narrow (object.in (), ACE_TRY_ENV); + Simple_Server::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -163,7 +163,7 @@ Client::svc (void) 1); } - server->test_method (ACE_TRY_ENV); + server->test_method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (TAO_debug_level > 0 && i % 100 == 0) ACE_DEBUG ((LM_DEBUG, "(%P|%t) iteration = %d\n", i)); diff --git a/TAO/tests/MT_Client/server.cpp b/TAO/tests/MT_Client/server.cpp index 83aed347feb..e7a42f825ce 100644 --- a/TAO/tests/MT_Client/server.cpp +++ b/TAO/tests/MT_Client/server.cpp @@ -17,13 +17,13 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -38,11 +38,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -51,11 +51,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -64,40 +64,40 @@ main (int argc, char *argv[]) Simple_Server_i server_impl (orb.in ()); Simple_Server_var server = - server_impl._this (ACE_TRY_ENV); + server_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); // If the ior_output_file exists, output the ior to it if (ior_output_file != 0) - { - FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); - if (output_file == 0) - ACE_ERROR_RETURN ((LM_ERROR, - "Cannot open output file for writing IOR: %s", - ior_output_file), - 1); - ACE_OS::fprintf (output_file, "%s", ior.in ()); - ACE_OS::fclose (output_file); - } - - poa_manager->activate (ACE_TRY_ENV); + { + FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); + if (output_file == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot open output file for writing IOR: %s", + ior_output_file), + 1); + ACE_OS::fprintf (output_file, "%s", ior.in ()); + ACE_OS::fclose (output_file); + } + + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/MT_Client/test_i.cpp b/TAO/tests/MT_Client/test_i.cpp index 0471f96dd5c..b10c633832d 100644 --- a/TAO/tests/MT_Client/test_i.cpp +++ b/TAO/tests/MT_Client/test_i.cpp @@ -9,14 +9,14 @@ ACE_RCSID(MT_Client, test_i, "$Id$") void -Simple_Server_i::test_method (CORBA::Environment&) +Simple_Server_i::test_method (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { } void -Simple_Server_i::shutdown (CORBA::Environment &ACE_TRY_ENV) +Simple_Server_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/MT_Client/test_i.h b/TAO/tests/MT_Client/test_i.h index 2c6669ef947..295fe73af56 100644 --- a/TAO/tests/MT_Client/test_i.h +++ b/TAO/tests/MT_Client/test_i.h @@ -31,10 +31,10 @@ public: // ctor // = The Simple_Server methods. - void test_method (CORBA::Environment&) + void test_method (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/MT_Server/client.cpp b/TAO/tests/MT_Server/client.cpp index e00aed7b822..8f0642d546b 100644 --- a/TAO/tests/MT_Server/client.cpp +++ b/TAO/tests/MT_Server/client.cpp @@ -51,18 +51,18 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Simple_Server_var server = - Simple_Server::_narrow (object.in (), ACE_TRY_ENV); + Simple_Server::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -76,7 +76,7 @@ main (int argc, char *argv[]) for (int i = 0; i != niterations; ++i) { CORBA::Long r = - server->test_method (i, ACE_TRY_ENV); + server->test_method (i TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (r != i) @@ -89,7 +89,7 @@ main (int argc, char *argv[]) if (do_shutdown) { - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/tests/MT_Server/server.cpp b/TAO/tests/MT_Server/server.cpp index 2230b637515..bfc8e14d63f 100644 --- a/TAO/tests/MT_Server/server.cpp +++ b/TAO/tests/MT_Server/server.cpp @@ -20,18 +20,18 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case 'n': - nthreads = ACE_OS::atoi (get_opts.optarg); - break; + nthreads = ACE_OS::atoi (get_opts.optarg); + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -66,11 +66,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -79,11 +79,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -92,29 +92,29 @@ main (int argc, char *argv[]) Simple_Server_i server_impl (orb.in ()); Simple_Server_var server = - server_impl._this (ACE_TRY_ENV); + server_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); // If the ior_output_file exists, output the ior to it if (ior_output_file != 0) - { - FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); - if (output_file == 0) - ACE_ERROR_RETURN ((LM_ERROR, - "Cannot open output file for writing IOR: %s", - ior_output_file), - 1); - ACE_OS::fprintf (output_file, "%s", ior.in ()); - ACE_OS::fclose (output_file); - } - - poa_manager->activate (ACE_TRY_ENV); + { + FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); + if (output_file == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot open output file for writing IOR: %s", + ior_output_file), + 1); + ACE_OS::fprintf (output_file, "%s", ior.in ()); + ACE_OS::fclose (output_file); + } + + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Worker worker (orb.in ()); @@ -149,10 +149,10 @@ Worker::Worker (CORBA::ORB_ptr orb) int Worker::svc (void) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { - this->orb_->run (ACE_TRY_ENV); + this->orb_->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/MT_Server/test_i.cpp b/TAO/tests/MT_Server/test_i.cpp index c0810d5df9e..cd3bc2abbc3 100644 --- a/TAO/tests/MT_Server/test_i.cpp +++ b/TAO/tests/MT_Server/test_i.cpp @@ -10,7 +10,7 @@ ACE_RCSID(MT_Server, test_i, "$Id$") CORBA::Long -Simple_Server_i::test_method (CORBA::Long x, CORBA::Environment&) +Simple_Server_i::test_method (CORBA::Long x TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { if (TAO_debug_level > 0) @@ -21,8 +21,8 @@ Simple_Server_i::test_method (CORBA::Long x, CORBA::Environment&) } void -Simple_Server_i::shutdown (CORBA::Environment& ACE_TRY_ENV) +Simple_Server_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/MT_Server/test_i.h b/TAO/tests/MT_Server/test_i.h index c49f47c8741..60fdc9a457b 100644 --- a/TAO/tests/MT_Server/test_i.h +++ b/TAO/tests/MT_Server/test_i.h @@ -31,10 +31,10 @@ public: // ctor // = The Simple_Server methods. - CORBA::Long test_method (CORBA::Long x, CORBA::Environment&) + CORBA::Long test_method (CORBA::Long x TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/MT_Timeout/Client_Task.cpp b/TAO/tests/MT_Timeout/Client_Task.cpp index a397c282a55..5bf38b970dd 100644 --- a/TAO/tests/MT_Timeout/Client_Task.cpp +++ b/TAO/tests/MT_Timeout/Client_Task.cpp @@ -46,22 +46,22 @@ Client_Task::too_big_difference_calls (void) const int Client_Task::svc (void) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; int successful_calls = 0; int timed_out_calls = 0; ACE_TRY { - this->validate_connection (ACE_TRY_ENV); + this->validate_connection (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var object = - this->orb_->resolve_initial_references ("PolicyCurrent", - ACE_TRY_ENV); + this->orb_->resolve_initial_references ("PolicyCurrent" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyCurrent_var policy_current = - CORBA::PolicyCurrent::_narrow (object.in (), ACE_TRY_ENV); + CORBA::PolicyCurrent::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; TimeBase::TimeT timeout_period = 10 * this->timeout_; @@ -73,18 +73,18 @@ Client_Task::svc (void) policy_list.length (1); policy_list[0] = this->orb_->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE, - timeout_as_any, - ACE_TRY_ENV); + timeout_as_any + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; policy_current->set_policy_overrides (policy_list, - CORBA::ADD_OVERRIDE, - ACE_TRY_ENV); + CORBA::ADD_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; for (int i = 0; i != this->iterations_; ++i) { - int retval = this->one_iteration (ACE_TRY_ENV); + int retval = this->one_iteration (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (retval == 1) @@ -118,13 +118,13 @@ Client_Task::svc (void) } void -Client_Task::validate_connection (CORBA::Environment &ACE_TRY_ENV) +Client_Task::validate_connection (TAO_ENV_SINGLE_ARG_DECL) { ACE_TRY { for (int i = 0; i != 100; ++i) { - (void) this->sleep_service_->go_to_sleep (0, ACE_TRY_ENV); + (void) this->sleep_service_->go_to_sleep (0 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } } @@ -137,14 +137,14 @@ Client_Task::validate_connection (CORBA::Environment &ACE_TRY_ENV) } int -Client_Task::one_iteration (CORBA::Environment &ACE_TRY_ENV) +Client_Task::one_iteration (TAO_ENV_SINGLE_ARG_DECL) { ACE_TRY { ACE_Time_Value start = ACE_OS::gettimeofday (); - this->sleep_service_->go_to_sleep (this->sleep_time_, - ACE_TRY_ENV); + this->sleep_service_->go_to_sleep (this->sleep_time_ + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_Time_Value end = ACE_OS::gettimeofday (); @@ -179,7 +179,7 @@ Client_Task::one_iteration (CORBA::Environment &ACE_TRY_ENV) // *way* off, this is an error. if (difference > 10) { - this->too_big_difference_++; + this->too_big_difference_++; ACE_ERROR ((LM_ERROR, "(%P|%t) Elapsed time = %d, expected %d\n", elapsed_milliseconds, max_milliseconds)); diff --git a/TAO/tests/MT_Timeout/Client_Task.h b/TAO/tests/MT_Timeout/Client_Task.h index add5700ce85..8b9ef41cc0e 100644 --- a/TAO/tests/MT_Timeout/Client_Task.h +++ b/TAO/tests/MT_Timeout/Client_Task.h @@ -55,10 +55,10 @@ public: private: /// Run one iteration of the test - int one_iteration (CORBA::Environment &ACE_TRY_ENV); + int one_iteration (TAO_ENV_SINGLE_ARG_DECL); /// Make sure that the thread has a connection available - void validate_connection (CORBA::Environment &ACE_TRY_ENV); + void validate_connection (TAO_ENV_SINGLE_ARG_DECL); private: /// A reference to the ORB diff --git a/TAO/tests/MT_Timeout/Server_Task.cpp b/TAO/tests/MT_Timeout/Server_Task.cpp index 4a90de6a0e0..34c76abd7bf 100644 --- a/TAO/tests/MT_Timeout/Server_Task.cpp +++ b/TAO/tests/MT_Timeout/Server_Task.cpp @@ -18,10 +18,10 @@ Server_Task::Server_Task (ACE_Thread_Manager *thr_mgr, int Server_Task::svc (void) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { - this->orb_->run (this->running_time_, ACE_TRY_ENV); + this->orb_->run (this->running_time_ TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/MT_Timeout/Sleep_Service.cpp b/TAO/tests/MT_Timeout/Sleep_Service.cpp index bd0aaa8e853..0650e317c9e 100644 --- a/TAO/tests/MT_Timeout/Sleep_Service.cpp +++ b/TAO/tests/MT_Timeout/Sleep_Service.cpp @@ -11,8 +11,8 @@ Sleep_Service::Sleep_Service (CORBA::ORB_ptr orb) } void -Sleep_Service::go_to_sleep (CORBA::ULong microseconds, - CORBA::Environment &) +Sleep_Service::go_to_sleep (CORBA::ULong microseconds + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { CORBA::ULong secs = microseconds / 1000000; @@ -23,9 +23,9 @@ Sleep_Service::go_to_sleep (CORBA::ULong microseconds, } void -Sleep_Service::shutdown (CORBA::Environment &ACE_TRY_ENV) +Sleep_Service::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "Shutting down the ORB\n")); - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/MT_Timeout/Sleep_Service.h b/TAO/tests/MT_Timeout/Sleep_Service.h index 11d1561cc74..b25ddd7a66d 100644 --- a/TAO/tests/MT_Timeout/Sleep_Service.h +++ b/TAO/tests/MT_Timeout/Sleep_Service.h @@ -25,11 +25,11 @@ public: Sleep_Service (CORBA::ORB_ptr orb); // = The skeleton methods - virtual void go_to_sleep (CORBA::ULong microseconds, - CORBA::Environment &ACE_TRY_ENV) + virtual void go_to_sleep (CORBA::ULong microseconds + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/MT_Timeout/client.cpp b/TAO/tests/MT_Timeout/client.cpp index 4d37ed0605c..ae5308cab04 100644 --- a/TAO/tests/MT_Timeout/client.cpp +++ b/TAO/tests/MT_Timeout/client.cpp @@ -51,18 +51,18 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = - orb->string_to_object(ior, ACE_TRY_ENV); + orb->string_to_object(ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Sleep_Service_var sleep_service = - Test::Sleep_Service::_narrow(tmp.in (), ACE_TRY_ENV); + Test::Sleep_Service::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (sleep_service.in ())) @@ -95,13 +95,13 @@ main (int argc, char *argv[]) ACE_Thread_Manager::instance ()->wait (); // Get back in sync with the server.. - sleep_service->go_to_sleep (0, ACE_TRY_ENV); + sleep_service->go_to_sleep (0 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - sleep_service->shutdown (ACE_TRY_ENV); + sleep_service->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -117,24 +117,24 @@ main (int argc, char *argv[]) // No more than 5 % of the calls are allowed to have a too big // difference if (task0.too_big_difference_calls () > iterations/20 - || task1.too_big_difference_calls () > iterations/20) - { - ACE_DEBUG ((LM_DEBUG, - "ERROR: Too many calls have a too big difference between " - "timeout and elapsed time (task0: %d, task1: %d)\n", - task0.too_big_difference_calls (), - task1.too_big_difference_calls ())); - } + || task1.too_big_difference_calls () > iterations/20) + { + ACE_DEBUG ((LM_DEBUG, + "ERROR: Too many calls have a too big difference between " + "timeout and elapsed time (task0: %d, task1: %d)\n", + task0.too_big_difference_calls (), + task1.too_big_difference_calls ())); + } else if (task0.too_big_difference_calls () != 0 - || task1.too_big_difference_calls () != 0) - { - ACE_DEBUG ((LM_DEBUG, - "Warning: some calls (task0: %d, task1: %d) " - "exceeded their expected elapsed times\n", - task0.too_big_difference_calls (), - task1.too_big_difference_calls ())); - } - + || task1.too_big_difference_calls () != 0) + { + ACE_DEBUG ((LM_DEBUG, + "Warning: some calls (task0: %d, task1: %d) " + "exceeded their expected elapsed times\n", + task0.too_big_difference_calls (), + task1.too_big_difference_calls ())); + } + if (task0.timed_out_calls () == 0) { ACE_ERROR ((LM_ERROR, diff --git a/TAO/tests/MT_Timeout/server.cpp b/TAO/tests/MT_Timeout/server.cpp index efdf1c10f22..91dede3b629 100644 --- a/TAO/tests/MT_Timeout/server.cpp +++ b/TAO/tests/MT_Timeout/server.cpp @@ -39,15 +39,15 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (root_poa.in ())) @@ -56,7 +56,7 @@ main (int argc, char *argv[]) 1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -69,11 +69,11 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var owner_transfer(sleep_service_impl); Test::Sleep_Service_var process = - sleep_service_impl->_this (ACE_TRY_ENV); + sleep_service_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (process.in (), ACE_TRY_ENV); + orb->object_to_string (process.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -86,7 +86,7 @@ main (int argc, char *argv[]) ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Server_Task server_task (ACE_Thread_Manager::instance (), @@ -102,10 +102,10 @@ main (int argc, char *argv[]) ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Multiple/Collocation_Tester.cpp b/TAO/tests/Multiple/Collocation_Tester.cpp index 886e9d81830..0723c2e42f8 100644 --- a/TAO/tests/Multiple/Collocation_Tester.cpp +++ b/TAO/tests/Multiple/Collocation_Tester.cpp @@ -39,7 +39,7 @@ Collocation_Tester::match_answer (const char *actual_answer, } int -Collocation_Tester::test_top (CORBA::Environment &ACE_TRY_ENV) +Collocation_Tester::test_top (TAO_ENV_SINGLE_ARG_DECL) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT("\n------------------------<TOP>-------------------------------\n"))); @@ -58,7 +58,7 @@ Collocation_Tester::test_top (CORBA::Environment &ACE_TRY_ENV) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n\nCalling all method supported by the Interface Top\n\n"))); - CORBA::String_var msg = top->top_quote (ACE_TRY_ENV); + CORBA::String_var msg = top->top_quote (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (0); failure += this->match_answer (Quote::top, msg.in (), "top_quote"); @@ -74,7 +74,7 @@ Collocation_Tester::test_top (CORBA::Environment &ACE_TRY_ENV) } int -Collocation_Tester::test_right (CORBA::Environment &ACE_TRY_ENV) +Collocation_Tester::test_right (TAO_ENV_SINGLE_ARG_DECL) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT("\n------------------------<RIGHT>-------------------------------\n"))); @@ -93,12 +93,12 @@ Collocation_Tester::test_right (CORBA::Environment &ACE_TRY_ENV) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n\nCalling all method supported by the Interface Right\n\n"))); - CORBA::String_var msg = right->top_quote (ACE_TRY_ENV); + CORBA::String_var msg = right->top_quote (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (1); failure += this->match_answer (Quote::top, msg.in (), "top_quote"); - msg = right->right_quote (ACE_TRY_ENV); + msg = right->right_quote (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (1); failure += this->match_answer (Quote::right, msg.in (), "right_quote"); @@ -115,7 +115,7 @@ Collocation_Tester::test_right (CORBA::Environment &ACE_TRY_ENV) int -Collocation_Tester::test_left (CORBA::Environment &ACE_TRY_ENV) +Collocation_Tester::test_left (TAO_ENV_SINGLE_ARG_DECL) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT("\n------------------------<LEFT>-------------------------------\n"))); @@ -135,12 +135,12 @@ Collocation_Tester::test_left (CORBA::Environment &ACE_TRY_ENV) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n\nCalling all method supported by the Interface Left\n\n"))); - CORBA::String_var msg = left->top_quote (ACE_TRY_ENV); + CORBA::String_var msg = left->top_quote (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (1); failure += this->match_answer (Quote::top, msg.in (), "top_quote"); - msg = left->left_quote (ACE_TRY_ENV); + msg = left->left_quote (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN(1); failure += this->match_answer (Quote::left, msg.in (), "left_quote"); @@ -157,7 +157,7 @@ Collocation_Tester::test_left (CORBA::Environment &ACE_TRY_ENV) int -Collocation_Tester::test_bottom (CORBA::Environment &ACE_TRY_ENV) +Collocation_Tester::test_bottom (TAO_ENV_SINGLE_ARG_DECL) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT("\n-----------------------<BOTTOM>-------------------------------\n"))); @@ -177,22 +177,22 @@ Collocation_Tester::test_bottom (CORBA::Environment &ACE_TRY_ENV) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n\nCalling all method supported by the Interface Bottom\n\n"))); - CORBA::String_var msg = bottom->top_quote (ACE_TRY_ENV); + CORBA::String_var msg = bottom->top_quote (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN(1); failure += this->match_answer (Quote::top, msg.in (), "top_quote"); - msg = bottom->left_quote (ACE_TRY_ENV); + msg = bottom->left_quote (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (1); failure += this->match_answer (Quote::left, msg.in (), "left_quote"); - msg = bottom->right_quote (ACE_TRY_ENV); + msg = bottom->right_quote (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN(1); failure += this->match_answer (Quote::right, msg.in (), "right_quote"); - msg = bottom->bottom_quote (ACE_TRY_ENV); + msg = bottom->bottom_quote (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN(1); failure += this->match_answer (Quote::bottom, msg.in (), "bottom_quote"); @@ -208,7 +208,7 @@ Collocation_Tester::test_bottom (CORBA::Environment &ACE_TRY_ENV) } void -Collocation_Tester::shutdown (CORBA::Environment &ACE_TRY_ENV) +Collocation_Tester::shutdown (TAO_ENV_SINGLE_ARG_DECL) { Multiple::Top_var top = Multiple::Top::_narrow (this->object_.in ()); @@ -223,23 +223,23 @@ Collocation_Tester::shutdown (CORBA::Environment &ACE_TRY_ENV) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n\nCalling ShutDown on Top.\n\n"))); - top->shutdown (ACE_TRY_ENV); + top->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; } void -Collocation_Tester::run (CORBA::Environment &ACE_TRY_ENV) +Collocation_Tester::run (TAO_ENV_SINGLE_ARG_DECL) { - int failure_num = this->test_top (ACE_TRY_ENV); + int failure_num = this->test_top (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; - failure_num += this->test_left (ACE_TRY_ENV); + failure_num += this->test_left (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; - failure_num += this->test_right (ACE_TRY_ENV); + failure_num += this->test_right (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; - failure_num += this->test_bottom (ACE_TRY_ENV); + failure_num += this->test_bottom (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (failure_num) @@ -249,5 +249,5 @@ Collocation_Tester::run (CORBA::Environment &ACE_TRY_ENV) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n\nThe Test Completed Successfully. Congratulations! "))); - this->shutdown (ACE_TRY_ENV); + this->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); } diff --git a/TAO/tests/Multiple/Collocation_Tester.h b/TAO/tests/Multiple/Collocation_Tester.h index cfb24b1e39d..766242232bc 100644 --- a/TAO/tests/Multiple/Collocation_Tester.h +++ b/TAO/tests/Multiple/Collocation_Tester.h @@ -39,7 +39,7 @@ public: ~Collocation_Tester (); // -- Command -- - void run (CORBA::Environment &ACE_TRY_ENV); + void run (TAO_ENV_SINGLE_ARG_DECL); // Runs the test. @@ -47,19 +47,19 @@ private: // -- Helper Methods -- - int test_top (CORBA::Environment &ACE_TRY_ENV); + int test_top (TAO_ENV_SINGLE_ARG_DECL); // Tests the method accessible thru the // Top interface. - int test_right (CORBA::Environment &ACE_TRY_ENV); + int test_right (TAO_ENV_SINGLE_ARG_DECL); // Tests the method accessible thru the // Right interface. - int test_left (CORBA::Environment &ACE_TRY_ENV); + int test_left (TAO_ENV_SINGLE_ARG_DECL); // Tests the method accessible thru the // Left interface. - int test_bottom (CORBA::Environment &ACE_TRY_ENV); + int test_bottom (TAO_ENV_SINGLE_ARG_DECL); // Tests the method accessible thru the // Bottom interface. @@ -72,7 +72,7 @@ private: // is no match (actually 1 is returned if there is // no match. - void shutdown (CORBA::Environment &ACE_TRY_ENV); + void shutdown (TAO_ENV_SINGLE_ARG_DECL); private: CORBA::Object_var object_; }; diff --git a/TAO/tests/Multiple/Multiple_Impl.cpp b/TAO/tests/Multiple/Multiple_Impl.cpp index cfd495b7552..d65dfde3c07 100644 --- a/TAO/tests/Multiple/Multiple_Impl.cpp +++ b/TAO/tests/Multiple/Multiple_Impl.cpp @@ -20,38 +20,38 @@ Bottom_Impl::~Bottom_Impl (void) } char * -Bottom_Impl::top_quote (CORBA::Environment & ) +Bottom_Impl::top_quote (TAO_ENV_SINGLE_ARG_DECL_NOT_USED ) ACE_THROW_SPEC ((CORBA::SystemException)) { return CORBA::string_dup(Quote::top); } char * -Bottom_Impl::left_quote (CORBA::Environment & ) +Bottom_Impl::left_quote (TAO_ENV_SINGLE_ARG_DECL_NOT_USED ) ACE_THROW_SPEC ((CORBA::SystemException)) { return CORBA::string_dup(Quote::left); } char * -Bottom_Impl::right_quote (CORBA::Environment & ) +Bottom_Impl::right_quote (TAO_ENV_SINGLE_ARG_DECL_NOT_USED ) ACE_THROW_SPEC ((CORBA::SystemException)) { return CORBA::string_dup(Quote::right); } char * -Bottom_Impl::bottom_quote (CORBA::Environment & ) +Bottom_Impl::bottom_quote (TAO_ENV_SINGLE_ARG_DECL_NOT_USED ) ACE_THROW_SPEC ((CORBA::SystemException)) { return CORBA::string_dup(Quote::bottom); } void -Bottom_Impl::shutdown (CORBA::Environment &ACE_TRY_ENV) +Bottom_Impl::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } /////////////////////////////////////////////////////////// @@ -70,64 +70,64 @@ Delegated_Bottom_Impl::~Delegated_Bottom_Impl (void) } char * -Delegated_Bottom_Impl::top_quote (CORBA::Environment &ACE_TRY_ENV) +Delegated_Bottom_Impl::top_quote (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Delegating the call: <top_quote>\n"))); CORBA::String_var msg = - this->delegate_->top_quote (ACE_TRY_ENV); + this->delegate_->top_quote (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (0); return msg._retn (); } char * -Delegated_Bottom_Impl::left_quote (CORBA::Environment &ACE_TRY_ENV) +Delegated_Bottom_Impl::left_quote (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Delegating the call: <left_quote>\n"))); CORBA::String_var msg = - this->delegate_->left_quote (ACE_TRY_ENV); + this->delegate_->left_quote (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (0); return msg._retn (); } char * -Delegated_Bottom_Impl::right_quote (CORBA::Environment &ACE_TRY_ENV) +Delegated_Bottom_Impl::right_quote (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Delegating the call: <right_quote>\n"))); CORBA::String_var msg = - this->delegate_->right_quote (ACE_TRY_ENV); + this->delegate_->right_quote (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (0); return msg._retn (); } char * -Delegated_Bottom_Impl::bottom_quote (CORBA::Environment &ACE_TRY_ENV) +Delegated_Bottom_Impl::bottom_quote (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Delegating the call: <bottom_quote>\n"))); CORBA::String_var msg = - this->delegate_->bottom_quote (ACE_TRY_ENV); + this->delegate_->bottom_quote (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (0); return msg._retn (); } void -Delegated_Bottom_Impl::shutdown (CORBA::Environment &ACE_TRY_ENV) +Delegated_Bottom_Impl::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Delegating Shut-Down.\n"))); - this->delegate_->shutdown (ACE_TRY_ENV); - //this->orb_->shutdown (0, ACE_TRY_ENV); + this->delegate_->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); + //this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); ACE_CHECK; } diff --git a/TAO/tests/Multiple/Multiple_Impl.h b/TAO/tests/Multiple/Multiple_Impl.h index d66c87ed192..e0a563896bc 100644 --- a/TAO/tests/Multiple/Multiple_Impl.h +++ b/TAO/tests/Multiple/Multiple_Impl.h @@ -40,27 +40,27 @@ public: virtual ~Bottom_Impl (void); // IDL Interface Methods - virtual char * top_quote (CORBA::Environment &ACE_TRY_ENV) + virtual char * top_quote (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC (( CORBA::SystemException )); - virtual char * left_quote (CORBA::Environment &ACE_TRY_ENV) + virtual char * left_quote (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC (( CORBA::SystemException )); - virtual char * right_quote (CORBA::Environment &ACE_TRY_ENV) + virtual char * right_quote (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC (( CORBA::SystemException )); - virtual char * bottom_quote (CORBA::Environment &ACE_TRY_ENV) + virtual char * bottom_quote (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC (( CORBA::SystemException )); - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC (( CORBA::SystemException )); @@ -89,24 +89,24 @@ public: virtual ~Delegated_Bottom_Impl (void); // IDL Interface Methods. - virtual char * top_quote (CORBA::Environment &ACE_TRY_ENV) + virtual char * top_quote (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC (( CORBA::SystemException )); - virtual char * left_quote (CORBA::Environment &ACE_TRY_ENV) + virtual char * left_quote (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC (( CORBA::SystemException )); - virtual char * right_quote (CORBA::Environment &ACE_TRY_ENV) + virtual char * right_quote (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC (( CORBA::SystemException )); - virtual char * bottom_quote (CORBA::Environment &ACE_TRY_ENV) + virtual char * bottom_quote (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC (( CORBA::SystemException )); - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC (( CORBA::SystemException )); diff --git a/TAO/tests/Multiple/client.cpp b/TAO/tests/Multiple/client.cpp index 79e171ef16e..796976b3470 100644 --- a/TAO/tests/Multiple/client.cpp +++ b/TAO/tests/Multiple/client.cpp @@ -6,18 +6,18 @@ ACE_RCSID (tests, client, "$Id$") int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { // ORB Initialization - CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, "TAO", ACE_TRY_ENV); + CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, "TAO" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var object; // Get The IOR from a file - object = orb->string_to_object ("file://s.ior", ACE_TRY_ENV); + object = orb->string_to_object ("file://s.ior" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (object.in ())) @@ -27,7 +27,7 @@ int main (int argc, char *argv[]) } Collocation_Tester tester (object.in ()); - tester.run (ACE_TRY_ENV); + tester.run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Multiple/server.cpp b/TAO/tests/Multiple/server.cpp index 576e662898a..403530d1b21 100644 --- a/TAO/tests/Multiple/server.cpp +++ b/TAO/tests/Multiple/server.cpp @@ -7,24 +7,24 @@ ACE_RCSID (tests, server, "$Id$") int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { // Orb Initialization - CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, "TAO", ACE_TRY_ENV); + CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, "TAO" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var object; - object = orb->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + object = orb->resolve_initial_references ("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - PortableServer::POA_var poa = PortableServer::POA::_narrow(object.in(), ACE_TRY_ENV); + PortableServer::POA_var poa = PortableServer::POA::_narrow(object.in() TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the POAManager - PortableServer::POAManager_var poa_manager = poa->the_POAManager(ACE_TRY_ENV); + PortableServer::POAManager_var poa_manager = poa->the_POAManager(TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Create the servant. @@ -41,7 +41,7 @@ int main (int argc, char *argv[]) // Now we stringfy the object reference. CORBA::String_var ior = - orb->object_to_string (bottom.in (), ACE_TRY_ENV); + orb->object_to_string (bottom.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); @@ -58,7 +58,7 @@ int main (int argc, char *argv[]) ACE_OS::fclose (output_file); // Activate the POAManager - poa_manager->activate(ACE_TRY_ENV); + poa_manager->activate(TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; orb->run(); diff --git a/TAO/tests/Multiple_Inheritance/Multiple_Inheritance_i.h b/TAO/tests/Multiple_Inheritance/Multiple_Inheritance_i.h index f294aa2172b..87e8cbe8611 100644 --- a/TAO/tests/Multiple_Inheritance/Multiple_Inheritance_i.h +++ b/TAO/tests/Multiple_Inheritance/Multiple_Inheritance_i.h @@ -9,22 +9,22 @@ class Multiple_Inheritance_i : public POA_D public: Multiple_Inheritance_i (void); - virtual char* method1 (CORBA::Environment &) + virtual char* method1 (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return CORBA::string_dup ("method1"); } - virtual char* method2 (CORBA::Environment &) + virtual char* method2 (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return CORBA::string_dup ("method2"); } - virtual char* method3 (CORBA::Environment &) + virtual char* method3 (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return CORBA::string_dup ("method3"); } - virtual char* method4 (CORBA::Environment &) + virtual char* method4 (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return CORBA::string_dup ("method4"); diff --git a/TAO/tests/Multiple_Inheritance/client.cpp b/TAO/tests/Multiple_Inheritance/client.cpp index 4618dbcbb18..5f1a4b00dba 100644 --- a/TAO/tests/Multiple_Inheritance/client.cpp +++ b/TAO/tests/Multiple_Inheritance/client.cpp @@ -38,13 +38,13 @@ parse_args (int argc, char **argv) ior = get_opts.optarg; break; case 'f': - ior_input_file = get_opts.optarg; - break; + ior_input_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "\nusage: %s " - "-i <ior_input_file> " + "-i <ior_input_file> " "-k IOR " "\n", argv [0]), @@ -54,13 +54,13 @@ parse_args (int argc, char **argv) if (ior == 0 && ior_input_file == 0) ACE_ERROR_RETURN ((LM_ERROR, "\nPlease specify the IOR or IOR input file" - " for the servant"), - -1); + " for the servant"), + -1); if (ior != 0 && ior_input_file != 0) ACE_ERROR_RETURN ((LM_ERROR, - "\nPlease specify only an IOR or only an IOR" - " input file but not both"), - -1); + "\nPlease specify only an IOR or only an IOR" + " input file but not both"), + -1); // Indicates successful parsing of the command line. return 0; @@ -69,12 +69,12 @@ parse_args (int argc, char **argv) int main (int argc, char **argv) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { // Initialize the ORB - CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, 0, - ACE_TRY_ENV); + CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Parse the command-line arguments to get the IOR @@ -100,62 +100,62 @@ main (int argc, char **argv) ior_buffer.alloc ()-> free (data); ACE_OS::close (input_file); } - + // Get the object reference with the IOR - CORBA::Object_var object = orb->string_to_object (ior, ACE_TRY_ENV); + CORBA::Object_var object = orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var string; // Narrow the object reference - A_var a = A::_narrow (object.in (), ACE_TRY_ENV); + A_var a = A::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Narrow the object reference - B_var b = B::_narrow (a.in (), ACE_TRY_ENV); + B_var b = B::_narrow (a.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Narrow the object reference - C_var c = C::_narrow (a.in (), ACE_TRY_ENV); + C_var c = C::_narrow (a.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Narrow the object reference - D_var d = D::_narrow (c.in (), ACE_TRY_ENV); + D_var d = D::_narrow (c.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - string = a->method1 (ACE_TRY_ENV); + string = a->method1 (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); - string = b->method1 (ACE_TRY_ENV); + string = b->method1 (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); - string = b->method2 (ACE_TRY_ENV); + string = b->method2 (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); - string = c->method1 (ACE_TRY_ENV); + string = c->method1 (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); - string = c->method3 (ACE_TRY_ENV); + string = c->method3 (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); - string = d->method1 (ACE_TRY_ENV); + string = d->method1 (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); - string = d->method2 (ACE_TRY_ENV); + string = d->method2 (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); - string = d->method3 (ACE_TRY_ENV); + string = d->method3 (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); - string = d->method4 (ACE_TRY_ENV); + string = d->method4 (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); } diff --git a/TAO/tests/Multiple_Inheritance/server.cpp b/TAO/tests/Multiple_Inheritance/server.cpp index 43c0343fcb3..42a5d54f11c 100644 --- a/TAO/tests/Multiple_Inheritance/server.cpp +++ b/TAO/tests/Multiple_Inheritance/server.cpp @@ -48,13 +48,13 @@ main (int argc, char **argv) TAO_ORB_Manager orb_manager; ACE_DEBUG ((LM_DEBUG, "\n\tMultiple Inheritance Server\n\n")); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { orb_manager.init_child_poa (argc, argv, - "child_poa", - ACE_TRY_ENV); + "child_poa" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -62,8 +62,8 @@ main (int argc, char **argv) CORBA::String_var ior = orb_manager.activate_under_child_poa ("my_object", - &servant, - ACE_TRY_ENV); + &servant + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", @@ -82,7 +82,7 @@ main (int argc, char **argv) ACE_OS::fclose (output_file); } - orb_manager.run (ACE_TRY_ENV); + orb_manager.run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (CORBA::SystemException, sysex) diff --git a/TAO/tests/Muxing/Client_Task.cpp b/TAO/tests/Muxing/Client_Task.cpp index dccfc7aee2a..52a2ea3a368 100644 --- a/TAO/tests/Muxing/Client_Task.cpp +++ b/TAO/tests/Muxing/Client_Task.cpp @@ -27,12 +27,12 @@ Client_Task::svc (void) for (CORBA::ULong j = 0; j != payload.length (); ++j) payload[j] = (j % 256); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { for (int i = 0; i != this->event_count_; ++i) { - this->receiver_->receive_data (payload, ACE_TRY_ENV); + this->receiver_->receive_data (payload TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/tests/Muxing/Receiver.cpp b/TAO/tests/Muxing/Receiver.cpp index fb342f25dc3..ddeb77de007 100644 --- a/TAO/tests/Muxing/Receiver.cpp +++ b/TAO/tests/Muxing/Receiver.cpp @@ -23,8 +23,8 @@ Receiver::dump_results () } void -Receiver::receive_data (const Test::Payload &payload, - CORBA::Environment &) +Receiver::receive_data (const Test::Payload &payload + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_GUARD (ACE_SYNCH_MUTEX, ace_mon, this->mutex_); @@ -33,7 +33,7 @@ Receiver::receive_data (const Test::Payload &payload, } CORBA::Long -Receiver::get_event_count (CORBA::Environment &) +Receiver::get_event_count (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, 0); diff --git a/TAO/tests/Muxing/Receiver.h b/TAO/tests/Muxing/Receiver.h index a18172927f5..227c4c785a7 100644 --- a/TAO/tests/Muxing/Receiver.h +++ b/TAO/tests/Muxing/Receiver.h @@ -31,10 +31,10 @@ public: void dump_results (void); // = The skeleton methods - virtual void receive_data (const Test::Payload &payload, - CORBA::Environment &ACE_TRY_ENV) + virtual void receive_data (const Test::Payload &payload + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual CORBA::Long get_event_count (CORBA::Environment &ACE_TRY_ENV) + virtual CORBA::Long get_event_count (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Muxing/Server_Task.cpp b/TAO/tests/Muxing/Server_Task.cpp index a011605622d..e23e16908a2 100644 --- a/TAO/tests/Muxing/Server_Task.cpp +++ b/TAO/tests/Muxing/Server_Task.cpp @@ -17,12 +17,12 @@ int Server_Task::svc (void) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) Starting server task\n")); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { // run the test for at most 120 seconds... ACE_Time_Value tv (120, 0); - this->orb_->run (tv, ACE_TRY_ENV); + this->orb_->run (tv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Muxing/client.cpp b/TAO/tests/Muxing/client.cpp index 492dcc1fc77..348025219f9 100644 --- a/TAO/tests/Muxing/client.cpp +++ b/TAO/tests/Muxing/client.cpp @@ -17,13 +17,13 @@ parse_args (int argc, char *argv[]) switch (c) { case 'k': - ior = get_opts.optarg; - break; + ior = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-k <ior>" + "-k <ior>" "\n", argv [0]), -1); @@ -38,18 +38,18 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = - orb->string_to_object(ior, ACE_TRY_ENV); + orb->string_to_object(ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Receiver_var receiver = - Test::Receiver::_narrow(tmp.in (), ACE_TRY_ENV); + Test::Receiver::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (receiver.in ())) @@ -72,13 +72,13 @@ main (int argc, char *argv[]) } ACE_Thread_Manager::instance ()->wait (); - CORBA::Long count = receiver->get_event_count (ACE_TRY_ENV); + CORBA::Long count = receiver->get_event_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "(%P) - Receiver got %d messages\n", count)); - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Muxing/server.cpp b/TAO/tests/Muxing/server.cpp index 602f2aea07c..b0481c089ee 100644 --- a/TAO/tests/Muxing/server.cpp +++ b/TAO/tests/Muxing/server.cpp @@ -18,13 +18,13 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -39,11 +39,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -52,11 +52,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -69,11 +69,11 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var receiver_owner_transfer(receiver_impl); Test::Receiver_var receiver = - receiver_impl->_this (ACE_TRY_ENV); + receiver_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (receiver.in (), ACE_TRY_ENV); + orb->object_to_string (receiver.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -82,11 +82,11 @@ main (int argc, char *argv[]) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_output_file), - 1); + 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Server_Task server_task (orb.in (), @@ -100,10 +100,10 @@ main (int argc, char *argv[]) ACE_DEBUG ((LM_DEBUG, "Now terminating test\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Native_Exceptions/client.cpp b/TAO/tests/Native_Exceptions/client.cpp index 29103ecc612..5cd7c837c6b 100644 --- a/TAO/tests/Native_Exceptions/client.cpp +++ b/TAO/tests/Native_Exceptions/client.cpp @@ -89,7 +89,7 @@ main (int argc, char *argv[]) } catch (CORBA::SystemException &ex) { - ACE_PRINT_EXCEPTION (ex, "Catched exception:"); + ACE_PRINT_EXCEPTION (ex, "Caught exception:"); return 1; } diff --git a/TAO/tests/Native_Exceptions/server.cpp b/TAO/tests/Native_Exceptions/server.cpp index cae2e7d2570..8de43cfbbf1 100644 --- a/TAO/tests/Native_Exceptions/server.cpp +++ b/TAO/tests/Native_Exceptions/server.cpp @@ -84,7 +84,7 @@ main (int argc, char *argv[]) } catch (CORBA::SystemException &ex) { - ACE_PRINT_EXCEPTION (ex, "Catched exception:"); + ACE_PRINT_EXCEPTION (ex, "Caught exception:"); return 1; } diff --git a/TAO/tests/NestedUpcall/MT_Client_Test/MT_Object_i.cpp b/TAO/tests/NestedUpcall/MT_Client_Test/MT_Object_i.cpp index abd189164d2..14d564729cf 100644 --- a/TAO/tests/NestedUpcall/MT_Client_Test/MT_Object_i.cpp +++ b/TAO/tests/NestedUpcall/MT_Client_Test/MT_Object_i.cpp @@ -9,7 +9,7 @@ // MT_Object_i.cpp // // = DESCRIPTION -// This class implements the Object A of the +// This class implements the Object A of the // Nested Upcalls - MT Client test. // // = AUTHORS @@ -37,8 +37,8 @@ MT_Object_i::~MT_Object_i (void) CORBA::Long MT_Object_i::yadda (CORBA::Long hop_count, - MT_Object_ptr partner, - CORBA::Environment &env) + MT_Object_ptr partner + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -48,7 +48,9 @@ MT_Object_i::yadda (CORBA::Long hop_count, if (hop_count < MAX_HOP_COUNT) { if (partner != 0) - return partner->yadda (hop_count + 1, this->_this (env), env) + 1; + return partner->yadda (hop_count + 1, + this->_this (TAO_ENV_SINGLE_ARG_PARAMETER) + TAO_ENV_ARG_PARAMETER) + 1; } return 0; diff --git a/TAO/tests/NestedUpcall/MT_Client_Test/MT_Object_i.h b/TAO/tests/NestedUpcall/MT_Client_Test/MT_Object_i.h index 2421abb2dea..ccfad73f3ab 100644 --- a/TAO/tests/NestedUpcall/MT_Client_Test/MT_Object_i.h +++ b/TAO/tests/NestedUpcall/MT_Client_Test/MT_Object_i.h @@ -36,8 +36,8 @@ public: // Destructor. virtual CORBA::Long yadda (CORBA::Long hop_count, - MT_Object_ptr partner, - CORBA::Environment &_tao_environment) + MT_Object_ptr partner + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); }; diff --git a/TAO/tests/NestedUpcall/MT_Client_Test/client.cpp b/TAO/tests/NestedUpcall/MT_Client_Test/client.cpp index 2ede15e0127..fb2c7d74986 100644 --- a/TAO/tests/NestedUpcall/MT_Client_Test/client.cpp +++ b/TAO/tests/NestedUpcall/MT_Client_Test/client.cpp @@ -146,7 +146,7 @@ MT_Client::parse_args (void) int MT_Client::run (void) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { for (unsigned long i = 0; i < this->iterations_; i++) @@ -159,8 +159,8 @@ MT_Client::run (void) // call the recursive object MT_Object for nested upcalls // testing this->mT_Object_var_->yadda (0, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } } @@ -198,7 +198,7 @@ MT_Client::init (int argc, char **argv, this->client_number_ = client_number; - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { char buf[64]; @@ -207,8 +207,8 @@ MT_Client::init (int argc, char **argv, this->orb_var_ = CORBA::ORB_init (this->argc_, this->argv_, - buf, - ACE_TRY_ENV); + buf + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Parse command line and verify parameters. @@ -222,8 +222,8 @@ MT_Client::init (int argc, char **argv, CORBA::Object_var object_var = - this->orb_var_->string_to_object (this->object_key_, - ACE_TRY_ENV); + this->orb_var_->string_to_object (this->object_key_ + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (object_var.in())) @@ -231,8 +231,8 @@ MT_Client::init (int argc, char **argv, "No proper object has been returned.\n"), -1); - this->mT_Object_var_ = MT_Object::_narrow (object_var.in(), - ACE_TRY_ENV); + this->mT_Object_var_ = MT_Object::_narrow (object_var.in() + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (this->mT_Object_var_.in())) @@ -246,7 +246,7 @@ MT_Client::init (int argc, char **argv, ACE_DEBUG ((LM_DEBUG, "We have a proper reference to the Object.\n")); CORBA::Object_var poa_object = - this->orb_var_->resolve_initial_references("RootPOA", ACE_TRY_ENV); + this->orb_var_->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -255,14 +255,14 @@ MT_Client::init (int argc, char **argv, 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -282,14 +282,14 @@ MT_Client::init (int argc, char **argv, int main (int argc, char **argv) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { TAO_ORB_Manager orb_manager; int r = orb_manager.init (argc, - argv, - ACE_TRY_ENV); + argv + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (r != 0) diff --git a/TAO/tests/NestedUpcall/MT_Client_Test/local_server.cpp b/TAO/tests/NestedUpcall/MT_Client_Test/local_server.cpp index 8c997c45d87..39212cdb3ed 100644 --- a/TAO/tests/NestedUpcall/MT_Client_Test/local_server.cpp +++ b/TAO/tests/NestedUpcall/MT_Client_Test/local_server.cpp @@ -142,15 +142,15 @@ MT_Server::init (int argc, "MT_Server::init: ORB_Manager is nil!\n"), -1); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { // Call the init of TAO_ORB_Manager to create a child POA // under the root POA. this->orb_manager_ptr_->init_child_poa (argc, argv, - "child_poa", - ACE_TRY_ENV); + "child_poa" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; @@ -159,8 +159,8 @@ MT_Server::init (int argc, this->str_ = this->orb_manager_ptr_->activate_under_child_poa ("MT", - &this->mT_Object_i_, - ACE_TRY_ENV); + &this->mT_Object_i_ + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -184,8 +184,8 @@ MT_Server::init (int argc, CORBA::ORB_var orb_var = this->orb_manager_ptr_->orb (); CORBA::Object_var object_var = - orb_var->string_to_object (this->object_key_, - ACE_TRY_ENV); + orb_var->string_to_object (this->object_key_ + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (object_var.in())) @@ -193,8 +193,8 @@ MT_Server::init (int argc, "No proper object has been returned.\n"), -1); - this->mT_Object_var_ = MT_Object::_narrow (object_var.in(), - ACE_TRY_ENV); + this->mT_Object_var_ = MT_Object::_narrow (object_var.in() + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (this->mT_Object_var_.in())) @@ -220,10 +220,10 @@ MT_Server::init (int argc, int MT_Server::run () { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { - int r = this->orb_manager_ptr_->run (ACE_TRY_ENV); + int r = this->orb_manager_ptr_->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (r == -1) @@ -245,12 +245,12 @@ MT_Server::~MT_Server (void) if (this->object_key_ != 0) ACE_OS::free (this->object_key_); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { if (this->orb_manager_ptr_) - this->orb_manager_ptr_->deactivate_under_child_poa (this->str_.in (), - ACE_TRY_ENV); + this->orb_manager_ptr_->deactivate_under_child_poa (this->str_.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -266,7 +266,7 @@ MT_Server::run_ORB_briefly (void) { if (this->iterations_ > 0) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { ACE_DEBUG ((LM_DEBUG, @@ -276,12 +276,12 @@ MT_Server::run_ORB_briefly (void) for (unsigned int i = 0; i < this->iterations_; i++) { MT_Object_var tmp = - this->mT_Object_i_._this (ACE_TRY_ENV); + this->mT_Object_i_._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; this->mT_Object_var_->yadda (0, - tmp.in (), - ACE_TRY_ENV); + tmp.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/tests/NestedUpcall/MT_Client_Test/server.cpp b/TAO/tests/NestedUpcall/MT_Client_Test/server.cpp index 8fd4340af1d..ec7dbe786a5 100644 --- a/TAO/tests/NestedUpcall/MT_Client_Test/server.cpp +++ b/TAO/tests/NestedUpcall/MT_Client_Test/server.cpp @@ -63,15 +63,15 @@ MT_Object_Server::parse_args (void) int MT_Object_Server::init (int argc, - char** argv, - CORBA::Environment& ACE_TRY_ENV) + char** argv + TAO_ENV_ARG_DECL) { // Call the init of TAO_ORB_Manager to create a child POA // under the root POA. this->orb_manager_.init_child_poa (argc, argv, - "child_poa", - ACE_TRY_ENV); + "child_poa" + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); this->argc_ = argc; @@ -82,8 +82,8 @@ MT_Object_Server::init (int argc, CORBA::String_var str; str = this->orb_manager_.activate_under_child_poa ("MT_Object", - &this->mT_Object_i_, - ACE_TRY_ENV); + &this->mT_Object_i_ + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, @@ -104,9 +104,9 @@ MT_Object_Server::init (int argc, int -MT_Object_Server::run (CORBA::Environment& env) +MT_Object_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, "NestedUpCalls_Server::run"), -1); @@ -125,17 +125,17 @@ main (int argc, char *argv[]) ACE_DEBUG ((LM_DEBUG, "\n \t NestedUpCalls.Triangle_Test: Object A Server \n \n")); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { - int r = MT_Object_Server.init (argc,argv,ACE_TRY_ENV); + int r = MT_Object_Server.init (argc,argv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (r == -1) return 1; else { - MT_Object_Server.run (ACE_TRY_ENV); + MT_Object_Server.run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/tests/NestedUpcall/MT_Client_Test/server.h b/TAO/tests/NestedUpcall/MT_Client_Test/server.h index b14807e2454..b8d72823b9e 100644 --- a/TAO/tests/NestedUpcall/MT_Client_Test/server.h +++ b/TAO/tests/NestedUpcall/MT_Client_Test/server.h @@ -48,11 +48,11 @@ public: // Destructor int init (int argc, - char **argv, - CORBA::Environment& env); + char **argv + TAO_ENV_ARG_DECL); // Initialize the NestedUpCalls_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/tests/NestedUpcall/Simple/client.cpp b/TAO/tests/NestedUpcall/Simple/client.cpp index 3330c44b3b0..cf084955ba9 100644 --- a/TAO/tests/NestedUpcall/Simple/client.cpp +++ b/TAO/tests/NestedUpcall/Simple/client.cpp @@ -49,8 +49,8 @@ Client_Task::svc (void) // Now, we can invoke an operation on the remote side. this->server_->start (this->client_.in (), - call_count, - ACE_TRY_ENV); + call_count + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -120,8 +120,8 @@ main (int argc, { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; int result = parse_args (argc, @@ -129,35 +129,35 @@ main (int argc, if (result != 0) return result; - CORBA::Object_var object = orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + CORBA::Object_var object = orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (object.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - object = orb->string_to_object (ior, - ACE_TRY_ENV); + object = orb->string_to_object (ior + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - server_var server = server::_narrow (object.in (), - ACE_TRY_ENV); + server_var server = server::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Create an client object to hand to the other side... client_i client_servant (quiet, server.in ()); - client_var client_object = client_servant._this (ACE_TRY_ENV); + client_var client_object = client_servant._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Client_Task client_tasks (client_object.in (), @@ -167,13 +167,13 @@ main (int argc, if (shutdown_server) { - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } root_poa->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/NestedUpcall/Simple/client_i.cpp b/TAO/tests/NestedUpcall/Simple/client_i.cpp index 58aed897da2..3e1d975fb28 100644 --- a/TAO/tests/NestedUpcall/Simple/client_i.cpp +++ b/TAO/tests/NestedUpcall/Simple/client_i.cpp @@ -10,8 +10,8 @@ client_i::client_i (int quiet, } void -client_i::ping (CORBA::UShort time_to_live, - CORBA::Environment &ACE_TRY_ENV) +client_i::ping (CORBA::UShort time_to_live + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { if (!this->quiet_) @@ -23,8 +23,8 @@ client_i::ping (CORBA::UShort time_to_live, if (time_to_live > 0) { - this->server_->ping (time_to_live, - ACE_TRY_ENV); + this->server_->ping (time_to_live + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } } diff --git a/TAO/tests/NestedUpcall/Simple/client_i.h b/TAO/tests/NestedUpcall/Simple/client_i.h index 03ce86be834..d384e305791 100644 --- a/TAO/tests/NestedUpcall/Simple/client_i.h +++ b/TAO/tests/NestedUpcall/Simple/client_i.h @@ -9,8 +9,8 @@ public: server_ptr s); // Constructor. - void ping (CORBA::UShort time_to_live, - CORBA::Environment &ACE_TRY_ENV) + void ping (CORBA::UShort time_to_live + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/NestedUpcall/Simple/server.cpp b/TAO/tests/NestedUpcall/Simple/server.cpp index 2b9450234cc..d556b0955e6 100644 --- a/TAO/tests/NestedUpcall/Simple/server.cpp +++ b/TAO/tests/NestedUpcall/Simple/server.cpp @@ -33,10 +33,10 @@ Server_Task::Server_Task (CORBA::ORB_ptr orb) int Server_Task::svc (void) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { - this->orb_->run (ACE_TRY_ENV); + this->orb_->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -120,8 +120,8 @@ main (int argc, { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; int result = parse_args (argc, @@ -129,30 +129,30 @@ main (int argc, if (result != 0) return result; - CORBA::Object_var object = orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + CORBA::Object_var object = orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (object.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; server_i server_servant (quiet, orb.in ()); - server_var server_object = server_servant._this (ACE_TRY_ENV); + server_var server_object = server_servant._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - CORBA::String_var ior = orb->object_to_string (server_object.in (), - ACE_TRY_ENV); + CORBA::String_var ior = orb->object_to_string (server_object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; result = write_ior_to_file (ior.in ()); @@ -173,8 +173,8 @@ main (int argc, return result; root_poa->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/NestedUpcall/Simple/server_i.cpp b/TAO/tests/NestedUpcall/Simple/server_i.cpp index 31888a61dc8..9bf81230998 100644 --- a/TAO/tests/NestedUpcall/Simple/server_i.cpp +++ b/TAO/tests/NestedUpcall/Simple/server_i.cpp @@ -11,21 +11,21 @@ server_i::server_i (int quiet, void server_i::start (client_ptr c, - CORBA::UShort time_to_live, - CORBA::Environment &ACE_TRY_ENV) + CORBA::UShort time_to_live + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { this->client_ = client::_duplicate (c); - this->ping (time_to_live, - ACE_TRY_ENV); + this->ping (time_to_live + TAO_ENV_ARG_PARAMETER); ACE_CHECK; return; } void -server_i::ping (CORBA::UShort time_to_live, - CORBA::Environment &ACE_TRY_ENV) +server_i::ping (CORBA::UShort time_to_live + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { if (!this->quiet_) @@ -37,17 +37,17 @@ server_i::ping (CORBA::UShort time_to_live, if (time_to_live > 0) { - this->client_->ping (time_to_live, - ACE_TRY_ENV); + this->client_->ping (time_to_live + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } } void -server_i::shutdown (CORBA::Environment &ACE_TRY_ENV) +server_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, - ACE_TRY_ENV); + this->orb_->shutdown (0 + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } diff --git a/TAO/tests/NestedUpcall/Simple/server_i.h b/TAO/tests/NestedUpcall/Simple/server_i.h index e1bd4802b1e..805606b8a32 100644 --- a/TAO/tests/NestedUpcall/Simple/server_i.h +++ b/TAO/tests/NestedUpcall/Simple/server_i.h @@ -8,16 +8,16 @@ public: server_i (int quiet, CORBA::ORB_ptr orb); - void ping (CORBA::UShort time_to_live, - CORBA::Environment &ACE_TRY_ENV) + void ping (CORBA::UShort time_to_live + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); void start (client_ptr c, - CORBA::UShort time_to_live, - CORBA::Environment &ACE_TRY_ENV) + CORBA::UShort time_to_live + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment &ACE_TRY_ENV) + void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/NestedUpcall/Simple/simple-client.cpp b/TAO/tests/NestedUpcall/Simple/simple-client.cpp index 9bd050ba49c..1ec28af256e 100644 --- a/TAO/tests/NestedUpcall/Simple/simple-client.cpp +++ b/TAO/tests/NestedUpcall/Simple/simple-client.cpp @@ -52,8 +52,8 @@ Client_Task::svc (void) // Now, we can invoke an operation on the remote side. this->server_->start (this->client_.in (), - call_count, - ACE_TRY_ENV); + call_count + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; @@ -129,8 +129,8 @@ main (int argc, { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; int result = parse_args (argc, @@ -138,35 +138,35 @@ main (int argc, if (result != 0) return result; - CORBA::Object_var object = orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + CORBA::Object_var object = orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (object.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - object = orb->string_to_object (ior, - ACE_TRY_ENV); + object = orb->string_to_object (ior + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - server_var server = server::_narrow (object.in (), - ACE_TRY_ENV); + server_var server = server::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Create an client object to hand to the other side... client_i client_servant (quiet, server.in ()); - client_var client_object = client_servant._this (ACE_TRY_ENV); + client_var client_object = client_servant._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Client_Task client_tasks (client_object.in (), @@ -177,13 +177,13 @@ main (int argc, if (shutdown_server) { - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } root_poa->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/NestedUpcall/Triangle_Test/Initiator_i.cpp b/TAO/tests/NestedUpcall/Triangle_Test/Initiator_i.cpp index 7cc49030b6b..67053270013 100644 --- a/TAO/tests/NestedUpcall/Triangle_Test/Initiator_i.cpp +++ b/TAO/tests/NestedUpcall/Triangle_Test/Initiator_i.cpp @@ -36,7 +36,7 @@ Initiator_i::~Initiator_i (void) } void -Initiator_i::foo_object_B (CORBA::Environment &ACE_TRY_ENV) +Initiator_i::foo_object_B (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -44,8 +44,8 @@ Initiator_i::foo_object_B (CORBA::Environment &ACE_TRY_ENV) ACE_TRY { - this->object_B_var_->foo (this->object_A_var_.in (), - ACE_TRY_ENV); + this->object_B_var_->foo (this->object_A_var_.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "(%P|%t) Initiator_i::foo_object_B: Returned from call.\n")); diff --git a/TAO/tests/NestedUpcall/Triangle_Test/Initiator_i.h b/TAO/tests/NestedUpcall/Triangle_Test/Initiator_i.h index cd7cace945f..ab5133bbb28 100644 --- a/TAO/tests/NestedUpcall/Triangle_Test/Initiator_i.h +++ b/TAO/tests/NestedUpcall/Triangle_Test/Initiator_i.h @@ -35,7 +35,7 @@ public: virtual ~Initiator_i (void); // Destructor. - virtual void foo_object_B (CORBA::Environment &env) + virtual void foo_object_B (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/NestedUpcall/Triangle_Test/Object_A_i.cpp b/TAO/tests/NestedUpcall/Triangle_Test/Object_A_i.cpp index bdab9cb12af..ec7adc6c3f4 100644 --- a/TAO/tests/NestedUpcall/Triangle_Test/Object_A_i.cpp +++ b/TAO/tests/NestedUpcall/Triangle_Test/Object_A_i.cpp @@ -38,8 +38,8 @@ Object_A_i::~Object_A_i (void) void -Object_A_i::foo (Initiator_ptr theInitiator_ptr, - CORBA::Environment &ACE_TRY_ENV) +Object_A_i::foo (Initiator_ptr theInitiator_ptr + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -47,7 +47,7 @@ Object_A_i::foo (Initiator_ptr theInitiator_ptr, ACE_TRY { - theInitiator_ptr->foo_object_B (ACE_TRY_ENV); + theInitiator_ptr->foo_object_B (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; while (!this->finish_two_way_call_) @@ -64,7 +64,7 @@ Object_A_i::foo (Initiator_ptr theInitiator_ptr, } void -Object_A_i::finish (CORBA::Environment &) +Object_A_i::finish (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, diff --git a/TAO/tests/NestedUpcall/Triangle_Test/Object_A_i.h b/TAO/tests/NestedUpcall/Triangle_Test/Object_A_i.h index 3c829cca935..6831a81039b 100644 --- a/TAO/tests/NestedUpcall/Triangle_Test/Object_A_i.h +++ b/TAO/tests/NestedUpcall/Triangle_Test/Object_A_i.h @@ -34,11 +34,11 @@ public: virtual ~Object_A_i (void); // Destructor. - virtual void foo (Initiator_ptr theInitiator_ptr, - CORBA::Environment &env) + virtual void foo (Initiator_ptr theInitiator_ptr + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void finish (CORBA::Environment &env) + virtual void finish (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); unsigned long finish_two_way_call_; diff --git a/TAO/tests/NestedUpcall/Triangle_Test/Object_B_i.cpp b/TAO/tests/NestedUpcall/Triangle_Test/Object_B_i.cpp index 49c5912f341..94654d06bd5 100644 --- a/TAO/tests/NestedUpcall/Triangle_Test/Object_B_i.cpp +++ b/TAO/tests/NestedUpcall/Triangle_Test/Object_B_i.cpp @@ -35,8 +35,8 @@ Object_B_i::~Object_B_i (void) void -Object_B_i::foo (Object_A_ptr theObject_A_ptr, - CORBA::Environment &ACE_TRY_ENV) +Object_B_i::foo (Object_A_ptr theObject_A_ptr + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -48,7 +48,7 @@ Object_B_i::foo (Object_A_ptr theObject_A_ptr, ACE_DEBUG ((LM_DEBUG, "(%P|%t) BEGIN Object_B_i::foo: Trying to call Object A\n")); - theObject_A_ptr->finish (ACE_TRY_ENV); + theObject_A_ptr->finish (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Start to wait on this variable, it is set to true diff --git a/TAO/tests/NestedUpcall/Triangle_Test/Object_B_i.h b/TAO/tests/NestedUpcall/Triangle_Test/Object_B_i.h index 9d664fa235d..d4468a9372c 100644 --- a/TAO/tests/NestedUpcall/Triangle_Test/Object_B_i.h +++ b/TAO/tests/NestedUpcall/Triangle_Test/Object_B_i.h @@ -34,8 +34,8 @@ public: virtual ~Object_B_i (void); // Destructor. - virtual void foo(Object_A_ptr theObject_A_ptr, - CORBA::Environment &env) + virtual void foo(Object_A_ptr theObject_A_ptr + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); }; diff --git a/TAO/tests/NestedUpcall/Triangle_Test/initiator.cpp b/TAO/tests/NestedUpcall/Triangle_Test/initiator.cpp index 7db4e889fe6..1f91b27f5ee 100644 --- a/TAO/tests/NestedUpcall/Triangle_Test/initiator.cpp +++ b/TAO/tests/NestedUpcall/Triangle_Test/initiator.cpp @@ -119,15 +119,15 @@ Initiator_Server::parse_args (void) int Initiator_Server::init (int argc, - char** argv, - CORBA::Environment& ACE_TRY_ENV) + char** argv + TAO_ENV_ARG_DECL) { // Call the init of TAO_ORB_Manager to create a child POA // under the root POA. this->orb_manager_.init_child_poa (argc, argv, - "child_poa", - ACE_TRY_ENV); + "child_poa" + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); this->argc_ = argc; @@ -147,12 +147,12 @@ Initiator_Server::init (int argc, // Get Object A CORBA::Object_var object_A_obj_var = - this->orb_manager_.orb()->string_to_object (this->object_A_key_, - ACE_TRY_ENV); + this->orb_manager_.orb()->string_to_object (this->object_A_key_ + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; this->object_A_var_ = - Object_A::_narrow (object_A_obj_var.in(), ACE_TRY_ENV); + Object_A::_narrow (object_A_obj_var.in() TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (this->object_A_var_.in ())) @@ -169,12 +169,12 @@ Initiator_Server::init (int argc, // Get Object B CORBA::Object_var object_B_obj_var = - this->orb_manager_.orb()->string_to_object (this->object_B_key_, - ACE_TRY_ENV); + this->orb_manager_.orb()->string_to_object (this->object_B_key_ + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; this->object_B_var_ = - Object_B::_narrow (object_B_obj_var.in(), ACE_TRY_ENV); + Object_B::_narrow (object_B_obj_var.in() TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (this->object_B_var_.in ())) @@ -188,7 +188,7 @@ Initiator_Server::init (int argc, this->object_A_key_)); ACE_DEBUG ((LM_DEBUG, "Object B received OK\n")); - this->orb_manager_.activate_poa_manager (ACE_TRY_ENV); + this->orb_manager_.activate_poa_manager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (CORBA::SystemException, sysex) @@ -209,8 +209,8 @@ Initiator_Server::init (int argc, -1); this->str_ = - this->orb_manager_.activate (this->initiator_i_ptr_, - ACE_TRY_ENV); + this->orb_manager_.activate (this->initiator_i_ptr_ + TAO_ENV_ARG_PARAMETER); ACE_DEBUG ((LM_DEBUG, "The IOR is: <%s>\n", this->str_.in ())); @@ -221,7 +221,7 @@ Initiator_Server::init (int argc, int -Initiator_Server::run (CORBA::Environment &ACE_TRY_ENV) +Initiator_Server::run (TAO_ENV_SINGLE_ARG_DECL) { ACE_TRY { @@ -230,10 +230,10 @@ Initiator_Server::run (CORBA::Environment &ACE_TRY_ENV) "foo on Object A\n")); Initiator_var initiator = - this->initiator_i_ptr_->_this(ACE_TRY_ENV); + this->initiator_i_ptr_->_this(TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - this->object_A_var_->foo (initiator.in (), ACE_TRY_ENV); + this->object_A_var_->foo (initiator.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Initiator_Server::run: Returned from invoke " @@ -261,11 +261,11 @@ Initiator_Server::~Initiator_Server (void) if (this->object_B_key_ != 0) ACE_OS::free (this->object_B_key_); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { - this->orb_manager_.deactivate (this->str_.in (), - ACE_TRY_ENV); + this->orb_manager_.deactivate (this->str_.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -285,18 +285,18 @@ main (int argc, char *argv[]) ACE_DEBUG ((LM_DEBUG, "\n \t NestedUpCalls.Triangle_Test: Initiator Server \n \n")); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { int retval = - initiator_Server.init (argc, argv, ACE_TRY_ENV); + initiator_Server.init (argc, argv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (retval == -1) return 1; else { - initiator_Server.run (ACE_TRY_ENV); + initiator_Server.run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/tests/NestedUpcall/Triangle_Test/initiator.h b/TAO/tests/NestedUpcall/Triangle_Test/initiator.h index 8d80cc8f1ea..c67ca955c21 100644 --- a/TAO/tests/NestedUpcall/Triangle_Test/initiator.h +++ b/TAO/tests/NestedUpcall/Triangle_Test/initiator.h @@ -51,11 +51,11 @@ public: // read in the IOR's for the two objects A and B int init (int argc, - char **argv, - CORBA::Environment& env); + char **argv + TAO_ENV_ARG_DECL); // Initialize the Initiator_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/tests/NestedUpcall/Triangle_Test/server_A.cpp b/TAO/tests/NestedUpcall/Triangle_Test/server_A.cpp index aac08ecf309..c48d187544d 100644 --- a/TAO/tests/NestedUpcall/Triangle_Test/server_A.cpp +++ b/TAO/tests/NestedUpcall/Triangle_Test/server_A.cpp @@ -63,15 +63,15 @@ Object_A_Server::parse_args (void) int Object_A_Server::init (int argc, - char** argv, - CORBA::Environment& ACE_TRY_ENV) + char** argv + TAO_ENV_ARG_DECL) { // Call the init of TAO_ORB_Manager to create a child POA // under the root POA. this->orb_manager_.init_child_poa (argc, argv, - "child_poa", - ACE_TRY_ENV); + "child_poa" + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); this->argc_ = argc; @@ -82,8 +82,8 @@ Object_A_Server::init (int argc, CORBA::String_var str = this->orb_manager_.activate_under_child_poa ("object_A", - &this->object_A_i_, - ACE_TRY_ENV); + &this->object_A_i_ + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, @@ -104,9 +104,9 @@ Object_A_Server::init (int argc, int -Object_A_Server::run (CORBA::Environment& ACE_TRY_ENV) +Object_A_Server::run (TAO_ENV_SINGLE_ARG_DECL) { - int r = this->orb_manager_.run (ACE_TRY_ENV); + int r = this->orb_manager_.run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (r == -1) @@ -128,18 +128,18 @@ main (int argc, char *argv[]) ACE_DEBUG ((LM_DEBUG, "\n \t NestedUpCalls.Triangle_Test: Object A Server \n \n")); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { int retval = - object_A_Server.init (argc,argv, ACE_TRY_ENV); + object_A_Server.init (argc,argv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (retval == -1) return 1; else { - object_A_Server.run (ACE_TRY_ENV); + object_A_Server.run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/tests/NestedUpcall/Triangle_Test/server_A.h b/TAO/tests/NestedUpcall/Triangle_Test/server_A.h index c7438ef5144..b2722bb822f 100644 --- a/TAO/tests/NestedUpcall/Triangle_Test/server_A.h +++ b/TAO/tests/NestedUpcall/Triangle_Test/server_A.h @@ -48,11 +48,11 @@ public: // Destructor int init (int argc, - char **argv, - CORBA::Environment& env); + char **argv + TAO_ENV_ARG_DECL); // Initialize the NestedUpCalls_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/tests/NestedUpcall/Triangle_Test/server_B.cpp b/TAO/tests/NestedUpcall/Triangle_Test/server_B.cpp index a9d76697392..259f0043db4 100644 --- a/TAO/tests/NestedUpcall/Triangle_Test/server_B.cpp +++ b/TAO/tests/NestedUpcall/Triangle_Test/server_B.cpp @@ -63,15 +63,15 @@ Object_B_Server::parse_args (void) int Object_B_Server::init (int argc, - char** argv, - CORBA::Environment& ACE_TRY_ENV) + char** argv + TAO_ENV_ARG_DECL) { // Call the init of TAO_ORB_Manager to create a child POA // under the root POA. this->orb_manager_.init_child_poa (argc, argv, - "child_poa", - ACE_TRY_ENV); + "child_poa" + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); this->argc_ = argc; @@ -82,8 +82,8 @@ Object_B_Server::init (int argc, CORBA::String_var str = this->orb_manager_.activate_under_child_poa ("object_B", - &this->object_B_i_, - ACE_TRY_ENV); + &this->object_B_i_ + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, @@ -103,9 +103,9 @@ Object_B_Server::init (int argc, int -Object_B_Server::run (CORBA::Environment& env) +Object_B_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, "Object_B_Server::run"), -1); @@ -124,17 +124,17 @@ main (int argc, char *argv[]) ACE_DEBUG ((LM_DEBUG, "\n \t NestedUpCalls.Triangle_Test: Object B Server \n \n")); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { - int retval = object_B_Server.init (argc, argv, ACE_TRY_ENV); + int retval = object_B_Server.init (argc, argv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (retval == -1) return 1; else { - object_B_Server.run (ACE_TRY_ENV); + object_B_Server.run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/tests/NestedUpcall/Triangle_Test/server_B.h b/TAO/tests/NestedUpcall/Triangle_Test/server_B.h index 07ae82c68f9..783eaa652a2 100644 --- a/TAO/tests/NestedUpcall/Triangle_Test/server_B.h +++ b/TAO/tests/NestedUpcall/Triangle_Test/server_B.h @@ -48,11 +48,11 @@ public: // Destructor int init (int argc, - char **argv, - CORBA::Environment& env); + char **argv + TAO_ENV_ARG_DECL); // Initialize the NestedUpCalls_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/tests/Nested_Event_Loop/client.cpp b/TAO/tests/Nested_Event_Loop/client.cpp index 4642532075d..4069909cdcb 100644 --- a/TAO/tests/Nested_Event_Loop/client.cpp +++ b/TAO/tests/Nested_Event_Loop/client.cpp @@ -70,7 +70,7 @@ parse_args (int argc, char **argv) int main (int argc, char **argv) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { @@ -78,8 +78,8 @@ main (int argc, char **argv) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Initialize options based on command-line arguments. @@ -88,49 +88,49 @@ main (int argc, char **argv) return parse_args_result; CORBA::Object_var object = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (object.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Get an object reference from the argument string. - object = orb->string_to_object (IOR, - ACE_TRY_ENV); + object = orb->string_to_object (IOR + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Try to narrow the object reference to a <server> reference. - server_var server_object = server::_narrow (object.in (), - ACE_TRY_ENV); + server_var server_object = server::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; client_i servant (server_object.in ()); servant.loop (event_loop_depth, - event_loop_iterations, - ACE_TRY_ENV); + event_loop_iterations + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Shutdown server. if (shutdown_server) { - server_object->shutdown (ACE_TRY_ENV); + server_object->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } root_poa->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Nested_Event_Loop/server.cpp b/TAO/tests/Nested_Event_Loop/server.cpp index b3617663e24..822c457c159 100644 --- a/TAO/tests/Nested_Event_Loop/server.cpp +++ b/TAO/tests/Nested_Event_Loop/server.cpp @@ -43,22 +43,22 @@ main (int argc, char *argv[]) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "", - ACE_TRY_ENV); + "" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -67,12 +67,12 @@ main (int argc, char *argv[]) server_i servant (orb.in ()); server_var server_object = - servant._this (ACE_TRY_ENV); + servant._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (server_object.in (), - ACE_TRY_ENV); + orb->object_to_string (server_object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); @@ -86,17 +86,17 @@ main (int argc, char *argv[]) ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); root_poa->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Nested_Event_Loop/test_i.cpp b/TAO/tests/Nested_Event_Loop/test_i.cpp index 7e11926ffec..2f1fca6d3e6 100644 --- a/TAO/tests/Nested_Event_Loop/test_i.cpp +++ b/TAO/tests/Nested_Event_Loop/test_i.cpp @@ -12,8 +12,8 @@ server_i::server_i (CORBA::ORB_ptr orb) void server_i::loop (client_ptr remote_partner, CORBA::ULong event_loop_depth, - CORBA::ULong event_loop_iterations, - CORBA::Environment &ACE_TRY_ENV) + CORBA::ULong event_loop_iterations + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -22,28 +22,28 @@ server_i::loop (client_ptr remote_partner, event_loop_iterations)); this->run_no_ops (remote_partner, - event_loop_iterations / 2, - ACE_TRY_ENV); + event_loop_iterations / 2 + TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (--event_loop_depth != 0) { remote_partner->loop (event_loop_depth, - event_loop_iterations, - ACE_TRY_ENV); + event_loop_iterations + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } this->run_no_ops (remote_partner, - event_loop_iterations / 2, - ACE_TRY_ENV); + event_loop_iterations / 2 + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } void server_i::run_no_ops (client_ptr remote_partner, - CORBA::ULong iterations, - CORBA::Environment &ACE_TRY_ENV) + CORBA::ULong iterations + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { while (iterations != 0) @@ -71,13 +71,13 @@ server_i::run_no_ops (client_ptr remote_partner, sizeof_pointer_to_flag); remote_partner->oneway_no_op (act_for_iterations, - act_for_flag, - ACE_TRY_ENV); + act_for_flag + TAO_ENV_ARG_PARAMETER); ACE_CHECK; while (!got_reply) { - this->orb_->perform_work (ACE_TRY_ENV); + this->orb_->perform_work (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; } } @@ -86,8 +86,8 @@ server_i::run_no_ops (client_ptr remote_partner, void server_i::no_op (client_ptr remote_partner, const act &act_for_iterations, - const act &act_for_flag, - CORBA::Environment &ACE_TRY_ENV) + const act &act_for_flag + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { CORBA::ULong *pointer_to_iterations = 0; @@ -110,16 +110,16 @@ server_i::no_op (client_ptr remote_partner, *pointer_to_flag = 1; - remote_partner->twoway_no_op (ACE_TRY_ENV); + remote_partner->twoway_no_op (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; } void -server_i::shutdown (CORBA::Environment &ACE_TRY_ENV) +server_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, - ACE_TRY_ENV); + this->orb_->shutdown (0 + TAO_ENV_ARG_PARAMETER); } client_i::client_i (server_ptr remote_partner) @@ -129,8 +129,8 @@ client_i::client_i (server_ptr remote_partner) void client_i::loop (CORBA::ULong event_loop_depth, - CORBA::ULong event_loop_iterations, - CORBA::Environment &) + CORBA::ULong event_loop_iterations + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -138,18 +138,18 @@ client_i::loop (CORBA::ULong event_loop_depth, event_loop_depth, event_loop_iterations)); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { client_var self = - this->_this (ACE_TRY_ENV); + this->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; this->remote_partner_->loop (self.in (), event_loop_depth, - event_loop_iterations, - ACE_TRY_ENV); + event_loop_iterations + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -162,22 +162,22 @@ client_i::loop (CORBA::ULong event_loop_depth, void client_i::oneway_no_op (const act &act_for_iterations, - const act &act_for_flag, - CORBA::Environment &) + const act &act_for_flag + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { client_var self = - this->_this (ACE_TRY_ENV); + this->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; this->remote_partner_->no_op (self.in (), act_for_iterations, - act_for_flag, - ACE_TRY_ENV); + act_for_flag + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -189,7 +189,7 @@ client_i::oneway_no_op (const act &act_for_iterations, } void -client_i::twoway_no_op (CORBA::Environment &) +client_i::twoway_no_op (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, diff --git a/TAO/tests/Nested_Event_Loop/test_i.h b/TAO/tests/Nested_Event_Loop/test_i.h index bcf3b1188db..6a4f6afef7c 100644 --- a/TAO/tests/Nested_Event_Loop/test_i.h +++ b/TAO/tests/Nested_Event_Loop/test_i.h @@ -9,22 +9,22 @@ public: void loop (client_ptr remote_partner, CORBA::ULong event_loop_depth, - CORBA::ULong event_loop_iterations, - CORBA::Environment &ACE_TRY_ENV) + CORBA::ULong event_loop_iterations + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); void run_no_ops (client_ptr remote_partner, - CORBA::ULong iterations, - CORBA::Environment &ACE_TRY_ENV) + CORBA::ULong iterations + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); void no_op (client_ptr remote_partner, const act &act_for_iterations, - const act &act_for_flag, - CORBA::Environment &) + const act &act_for_flag + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment &ACE_TRY_ENV) + void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: @@ -37,16 +37,16 @@ public: client_i (server_ptr remote_partner); void loop (CORBA::ULong event_loop_depth, - CORBA::ULong event_loop_iterations, - CORBA::Environment &) + CORBA::ULong event_loop_iterations + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); void oneway_no_op (const act &act_for_iterations, - const act &act_for_flag, - CORBA::Environment &) + const act &act_for_flag + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void twoway_no_op (CORBA::Environment &) + void twoway_no_op (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/ORB_destroy/ORB_destroy.cpp b/TAO/tests/ORB_destroy/ORB_destroy.cpp index 83b251c32ca..40cfa51f3b0 100644 --- a/TAO/tests/ORB_destroy/ORB_destroy.cpp +++ b/TAO/tests/ORB_destroy/ORB_destroy.cpp @@ -28,39 +28,39 @@ test_with_regular_poa_manager (int argc, int destroy_orb, int destroy_poa) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, orb_name, ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, orb_name TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var obj = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (obj.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (obj.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (destroy_poa) { - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } if (destroy_orb) { - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } @@ -83,42 +83,42 @@ test_with_funky_poa_manager (int argc, int destroy_poa, int funky_poa_manager) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, orb_name, ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, orb_name TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var obj = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (obj.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (obj.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (funky_poa_manager) { PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } if (destroy_poa) { - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } if (destroy_orb) { - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/tests/ORB_init/ORB_init.cpp b/TAO/tests/ORB_init/ORB_init.cpp index 5dce9d5de6e..77814057eb1 100644 --- a/TAO/tests/ORB_init/ORB_init.cpp +++ b/TAO/tests/ORB_init/ORB_init.cpp @@ -17,7 +17,7 @@ main (int argc, char *argv[]) { CORBA::ORB_var orb; - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { const char orbid[] = "mighty_orb"; @@ -25,7 +25,7 @@ main (int argc, char *argv[]) CORBA::ORB_ptr my_orb = CORBA::ORB::_nil(); { - CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, orbid, ACE_TRY_ENV); + CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, orbid TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; my_orb = orb.in (); @@ -42,7 +42,7 @@ main (int argc, char *argv[]) // used in that scope. // ------------------------------------------------------------- - orb = CORBA::ORB_init (argc, argv, orbid, ACE_TRY_ENV); + orb = CORBA::ORB_init (argc, argv, orbid TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // This isn't portable, but TAO implements an ORB_ptr as a @@ -77,10 +77,10 @@ main (int argc, char *argv[]) // attempt to initialize a new ORB with the same ORBid. // ------------------------------------------------------------- - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb = CORBA::ORB_init (argc, argv, orbid, ACE_TRY_ENV); + orb = CORBA::ORB_init (argc, argv, orbid TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // This isn't portable, but TAO implements an ORB_ptr as a @@ -116,7 +116,7 @@ main (int argc, char *argv[]) // ------------------------------------------------------------- CORBA::Object_var object = - orb->string_to_object (IOR, ACE_TRY_ENV); + orb->string_to_object (IOR TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // ------------------------------------------------------------- @@ -125,11 +125,11 @@ main (int argc, char *argv[]) // clean-up. // ------------------------------------------------------------- CORBA::ORB_var orb2 = - CORBA::ORB_init (argc, argv, "ORB number 2", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "ORB number 2" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::ORB_var orb3 = - CORBA::ORB_init (argc, argv, "ORB number 3", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "ORB number 3" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // ------------------------------------------------------------- @@ -139,11 +139,11 @@ main (int argc, char *argv[]) // ORB itself break when the last ORB is released. // ------------------------------------------------------------- - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var obj = - orb->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If we get here, then something went wrong. A diff --git a/TAO/tests/Object_Loader/Loader.cpp b/TAO/tests/Object_Loader/Loader.cpp index 6937a20cdf1..8c2f2c62553 100644 --- a/TAO/tests/Object_Loader/Loader.cpp +++ b/TAO/tests/Object_Loader/Loader.cpp @@ -16,25 +16,25 @@ Loader::Loader (void) CORBA::Object_ptr Loader::create_object (CORBA::ORB_ptr orb, int, - char * [], - CORBA::Environment &ACE_TRY_ENV) + char * [] + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_TRY { CORBA::Object_var obj = - orb->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + 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 mgr = - poa->the_POAManager (ACE_TRY_ENV); + poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - mgr->activate (ACE_TRY_ENV); + mgr->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Test_i *test; @@ -42,7 +42,7 @@ Loader::create_object (CORBA::ORB_ptr orb, CORBA::Object::_nil ()); PortableServer::ServantBase_var tmp = test; - obj = test->_this (ACE_TRY_ENV); + obj = test->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; return obj._retn (); diff --git a/TAO/tests/Object_Loader/Loader.h b/TAO/tests/Object_Loader/Loader.h index f6675712f20..7dbcbed351d 100644 --- a/TAO/tests/Object_Loader/Loader.h +++ b/TAO/tests/Object_Loader/Loader.h @@ -32,8 +32,8 @@ public: virtual CORBA::Object_ptr create_object (CORBA::ORB_ptr orb, int argc, - char *argv [], - CORBA::Environment &) + char *argv [] + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); // Create a new instance }; diff --git a/TAO/tests/Object_Loader/Test_i.cpp b/TAO/tests/Object_Loader/Test_i.cpp index 5f4ed5a86e1..2bdf3980984 100644 --- a/TAO/tests/Object_Loader/Test_i.cpp +++ b/TAO/tests/Object_Loader/Test_i.cpp @@ -18,28 +18,28 @@ Test_i::Test_i (PortableServer::POA_ptr poa) } CORBA::Long -Test_i::instance_count (CORBA::Environment &) +Test_i::instance_count (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return Test_i::instance_count_; } void -Test_i::destroy (CORBA::Environment &ACE_TRY_ENV) +Test_i::destroy (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { PortableServer::POA_var poa = - this->_default_POA (ACE_TRY_ENV); + this->_default_POA (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; PortableServer::ObjectId_var oid = - poa->servant_to_id (this, ACE_TRY_ENV); + poa->servant_to_id (this TAO_ENV_ARG_PARAMETER); ACE_CHECK; - poa->deactivate_object (oid.in (), ACE_TRY_ENV); + poa->deactivate_object (oid.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK; } PortableServer::POA_ptr -Test_i::_default_POA (CORBA::Environment &) +Test_i::_default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return PortableServer::POA::_duplicate (this->poa_.in ()); diff --git a/TAO/tests/Object_Loader/Test_i.h b/TAO/tests/Object_Loader/Test_i.h index 06ecfd828b7..4c9a9ad70d3 100644 --- a/TAO/tests/Object_Loader/Test_i.h +++ b/TAO/tests/Object_Loader/Test_i.h @@ -37,13 +37,13 @@ public: Test_i (PortableServer::POA_ptr poa); // ctor - CORBA::Long instance_count (CORBA::Environment &) + CORBA::Long instance_count (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void destroy (CORBA::Environment &) + void destroy (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - PortableServer::POA_ptr _default_POA (CORBA::Environment &) + PortableServer::POA_ptr _default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Object_Loader/driver.cpp b/TAO/tests/Object_Loader/driver.cpp index b16afaa9f27..5cf0f232ce8 100644 --- a/TAO/tests/Object_Loader/driver.cpp +++ b/TAO/tests/Object_Loader/driver.cpp @@ -22,20 +22,20 @@ main (int, char *[]) int argc = 0; CORBA::ORB_var orb = - CORBA::ORB_init (argc, 0, buf, ACE_TRY_ENV); + CORBA::ORB_init (argc, 0, buf TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var object = - orb->string_to_object ("DLL:Test_Object", - ACE_TRY_ENV); + orb->string_to_object ("DLL:Test_Object" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test_var test = - Test::_narrow (object.in (), ACE_TRY_ENV); + Test::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Long count = - test->instance_count (ACE_TRY_ENV); + test->instance_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (count != norbs*i + j + 1) @@ -45,7 +45,7 @@ main (int, char *[]) "(%d != %d)\n", count, norbs * i + j + 1)); } - test->destroy (ACE_TRY_ENV); + test->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } @@ -57,22 +57,22 @@ main (int, char *[]) int argc = 0; CORBA::ORB_var orb = - CORBA::ORB_init (argc, 0, buf, ACE_TRY_ENV); + CORBA::ORB_init (argc, 0, buf TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var obj = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + 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; - poa->destroy (1, 1, ACE_TRY_ENV); + poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/tests/OctetSeq/OctetSeq.cpp b/TAO/tests/OctetSeq/OctetSeq.cpp index 51768cfc050..4aa340c639e 100644 --- a/TAO/tests/OctetSeq/OctetSeq.cpp +++ b/TAO/tests/OctetSeq/OctetSeq.cpp @@ -161,13 +161,13 @@ run (char* buf, size_t bufsize, int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; int n = 64; diff --git a/TAO/tests/OctetSeq/client.cpp b/TAO/tests/OctetSeq/client.cpp index ed806604edd..881ee8b3a7a 100644 --- a/TAO/tests/OctetSeq/client.cpp +++ b/TAO/tests/OctetSeq/client.cpp @@ -57,18 +57,18 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Database_var server = - Test::Database::_narrow (object.in (), ACE_TRY_ENV); + Test::Database::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -112,8 +112,8 @@ main (int argc, char *argv[]) server->set (Test::Index (j), elements[j], token, - returned_token, - ACE_TRY_ENV); + returned_token + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (token != returned_token) @@ -127,7 +127,7 @@ main (int argc, char *argv[]) } CORBA::ULong crc_remote = - server->get_crc (idx, ACE_TRY_ENV); + server->get_crc (idx TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::ULong crc_local = @@ -149,16 +149,16 @@ main (int argc, char *argv[]) } - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY { ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Catched exception:"); + "Caught exception:"); return 1; } ACE_ENDTRY; diff --git a/TAO/tests/OctetSeq/server.cpp b/TAO/tests/OctetSeq/server.cpp index 3c6009fb55c..cfad7fffd81 100644 --- a/TAO/tests/OctetSeq/server.cpp +++ b/TAO/tests/OctetSeq/server.cpp @@ -38,11 +38,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -51,11 +51,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -66,11 +66,11 @@ main (int argc, char *argv[]) 128); // @@ TODO Test::Database_var server = - server_impl._this (ACE_TRY_ENV); + server_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); @@ -88,25 +88,25 @@ main (int argc, char *argv[]) ACE_OS::fclose (output_file); } - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY { ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Catched exception:"); + "Caught exception:"); return 1; } ACE_ENDTRY; diff --git a/TAO/tests/OctetSeq/test_i.cpp b/TAO/tests/OctetSeq/test_i.cpp index 64dd349d241..29614b938e3 100644 --- a/TAO/tests/OctetSeq/test_i.cpp +++ b/TAO/tests/OctetSeq/test_i.cpp @@ -17,8 +17,8 @@ void Database_i::set (Test::Index i, const Test::OctetSeq& seq, CORBA::Double verification_token, - CORBA::Double_out returned_token, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Double_out returned_token + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((Test::OutOfRange)) { if (i >= this->max_range_) @@ -44,8 +44,8 @@ Database_i::set (Test::Index i, } Test::OctetSeq* -Database_i::get (Test::Index i, - CORBA::Environment &ACE_TRY_ENV) +Database_i::get (Test::Index i + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException,Test::OutOfRange)) { if (i >= this->max_range_) @@ -60,8 +60,8 @@ Database_i::get (Test::Index i, } CORBA::ULong -Database_i::get_crc (Test::Index i, - CORBA::Environment &ACE_TRY_ENV) +Database_i::get_crc (Test::Index i + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException,Test::OutOfRange)) { if (i >= this->max_range_) @@ -73,7 +73,7 @@ Database_i::get_crc (Test::Index i, } void -Database_i::shutdown (CORBA::Environment&) +Database_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->orb_->shutdown (); diff --git a/TAO/tests/OctetSeq/test_i.h b/TAO/tests/OctetSeq/test_i.h index 12205072e0a..08843c32828 100644 --- a/TAO/tests/OctetSeq/test_i.h +++ b/TAO/tests/OctetSeq/test_i.h @@ -35,19 +35,19 @@ public: void set (Test::Index i, const Test::OctetSeq& seq, CORBA::Double verification_token, - CORBA::Double_out returned_token, - CORBA::Environment&) + CORBA::Double_out returned_token + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((Test::OutOfRange)); - Test::OctetSeq* get (Test::Index i, - CORBA::Environment&) + Test::OctetSeq* get (Test::Index i + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException,Test::OutOfRange)); - CORBA::ULong get_crc (Test::Index i, - CORBA::Environment&) + CORBA::ULong get_crc (Test::Index i + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException,Test::OutOfRange)); - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Oneway_Buffering/Oneway_Buffering.cpp b/TAO/tests/Oneway_Buffering/Oneway_Buffering.cpp index 3e539d45dd1..f12cbec55dd 100644 --- a/TAO/tests/Oneway_Buffering/Oneway_Buffering.cpp +++ b/TAO/tests/Oneway_Buffering/Oneway_Buffering.cpp @@ -13,29 +13,29 @@ Oneway_Buffering::Oneway_Buffering (CORBA::ORB_ptr orb, } void -Oneway_Buffering::receive_data (const Test::Payload &the_payload, - CORBA::Environment &ACE_TRY_ENV) +Oneway_Buffering::receive_data (const Test::Payload &the_payload + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->admin_->request_received (the_payload.length (), ACE_TRY_ENV); + this->admin_->request_received (the_payload.length () TAO_ENV_ARG_PARAMETER); } void -Oneway_Buffering::flush (CORBA::Environment &) +Oneway_Buffering::flush (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { } void -Oneway_Buffering::sync (CORBA::Environment &ACE_TRY_ENV) +Oneway_Buffering::sync (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->admin_->flush (ACE_TRY_ENV); + this->admin_->flush (TAO_ENV_SINGLE_ARG_PARAMETER); } void -Oneway_Buffering::shutdown (CORBA::Environment &ACE_TRY_ENV) +Oneway_Buffering::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/Oneway_Buffering/Oneway_Buffering.h b/TAO/tests/Oneway_Buffering/Oneway_Buffering.h index 302ea846f43..4ea1dd52b64 100644 --- a/TAO/tests/Oneway_Buffering/Oneway_Buffering.h +++ b/TAO/tests/Oneway_Buffering/Oneway_Buffering.h @@ -26,17 +26,17 @@ public: Test::Oneway_Buffering_Admin_ptr admin); // = The skeleton methods - virtual void receive_data (const Test::Payload &the_payload, - CORBA::Environment &ACE_TRY_ENV) + virtual void receive_data (const Test::Payload &the_payload + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void flush (CORBA::Environment &ACE_TRY_ENV) + virtual void flush (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void sync (CORBA::Environment &ACE_TRY_ENV) + virtual void sync (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Oneway_Buffering/Oneway_Buffering_Admin.cpp b/TAO/tests/Oneway_Buffering/Oneway_Buffering_Admin.cpp index 3512584b812..bf3413506f7 100644 --- a/TAO/tests/Oneway_Buffering/Oneway_Buffering_Admin.cpp +++ b/TAO/tests/Oneway_Buffering/Oneway_Buffering_Admin.cpp @@ -13,22 +13,22 @@ Oneway_Buffering_Admin::Oneway_Buffering_Admin (CORBA::ORB_ptr orb) } CORBA::ULong -Oneway_Buffering_Admin::request_count (CORBA::Environment &) +Oneway_Buffering_Admin::request_count (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return this->request_count_; } CORBA::ULong -Oneway_Buffering_Admin::bytes_received_count (CORBA::Environment &) +Oneway_Buffering_Admin::bytes_received_count (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return this->bytes_received_count_; } void -Oneway_Buffering_Admin::request_received (CORBA::ULong payload_length, - CORBA::Environment &) +Oneway_Buffering_Admin::request_received (CORBA::ULong payload_length + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->request_count_++; @@ -36,14 +36,14 @@ Oneway_Buffering_Admin::request_received (CORBA::ULong payload_length, } void -Oneway_Buffering_Admin::flush (CORBA::Environment &) +Oneway_Buffering_Admin::flush (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { } void -Oneway_Buffering_Admin::shutdown (CORBA::Environment &ACE_TRY_ENV) +Oneway_Buffering_Admin::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/Oneway_Buffering/Oneway_Buffering_Admin.h b/TAO/tests/Oneway_Buffering/Oneway_Buffering_Admin.h index 56b2088e965..bce8067204a 100644 --- a/TAO/tests/Oneway_Buffering/Oneway_Buffering_Admin.h +++ b/TAO/tests/Oneway_Buffering/Oneway_Buffering_Admin.h @@ -25,20 +25,20 @@ public: Oneway_Buffering_Admin (CORBA::ORB_ptr orb); // = The skeleton methods - virtual CORBA::ULong request_count (CORBA::Environment &ACE_TRY_ENV) + virtual CORBA::ULong request_count (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual CORBA::ULong bytes_received_count (CORBA::Environment &ACE_TRY_ENV) + virtual CORBA::ULong bytes_received_count (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void request_received (CORBA::ULong payload_length, - CORBA::Environment &ACE_TRY_ENV) + virtual void request_received (CORBA::ULong payload_length + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void flush (CORBA::Environment &ACE_TRY_ENV) + virtual void flush (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Oneway_Buffering/admin.cpp b/TAO/tests/Oneway_Buffering/admin.cpp index 0b4ac68af67..f2e44e5ede2 100644 --- a/TAO/tests/Oneway_Buffering/admin.cpp +++ b/TAO/tests/Oneway_Buffering/admin.cpp @@ -17,14 +17,14 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -39,15 +39,15 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (root_poa.in ())) @@ -56,7 +56,7 @@ main (int argc, char *argv[]) 1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -69,11 +69,11 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var owner_transfer(oneway_buffering_admin_impl); Test::Oneway_Buffering_Admin_var oneway_buffering_admin = - oneway_buffering_admin_impl->_this (ACE_TRY_ENV); + oneway_buffering_admin_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (oneway_buffering_admin.in (), ACE_TRY_ENV); + orb->object_to_string (oneway_buffering_admin.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -86,18 +86,18 @@ main (int argc, char *argv[]) ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "(%P|%t) admin - event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Oneway_Buffering/client.cpp b/TAO/tests/Oneway_Buffering/client.cpp index 5cd6dafec55..388ddeafcf7 100644 --- a/TAO/tests/Oneway_Buffering/client.cpp +++ b/TAO/tests/Oneway_Buffering/client.cpp @@ -87,26 +87,26 @@ parse_args (int argc, char *argv[]) int run_message_count (CORBA::ORB_ptr orb, Test::Oneway_Buffering_ptr oneway_buffering, - Test::Oneway_Buffering_Admin_ptr oneway_buffering_admin, - CORBA::Environment &ACE_TRY_ENV); + Test::Oneway_Buffering_Admin_ptr oneway_buffering_admin + TAO_ENV_ARG_DECL); int run_timeout (CORBA::ORB_ptr orb, Test::Oneway_Buffering_ptr oneway_buffering, - Test::Oneway_Buffering_Admin_ptr oneway_buffering_admin, - CORBA::Environment &ACE_TRY_ENV); + Test::Oneway_Buffering_Admin_ptr oneway_buffering_admin + TAO_ENV_ARG_DECL); int run_timeout_reactive (CORBA::ORB_ptr orb, Test::Oneway_Buffering_ptr oneway_buffering, - Test::Oneway_Buffering_Admin_ptr oneway_buffering_admin, - CORBA::Environment &ACE_TRY_ENV); + Test::Oneway_Buffering_Admin_ptr oneway_buffering_admin + TAO_ENV_ARG_DECL); int run_buffer_size (CORBA::ORB_ptr orb, Test::Oneway_Buffering_ptr oneway_buffering, - Test::Oneway_Buffering_Admin_ptr oneway_buffering_admin, - CORBA::Environment &ACE_TRY_ENV); + Test::Oneway_Buffering_Admin_ptr oneway_buffering_admin + TAO_ENV_ARG_DECL); int main (int argc, char *argv[]) @@ -115,18 +115,18 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = - orb->string_to_object(server_ior, ACE_TRY_ENV); + orb->string_to_object(server_ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Oneway_Buffering_var oneway_buffering = - Test::Oneway_Buffering::_narrow(tmp.in (), ACE_TRY_ENV); + Test::Oneway_Buffering::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (oneway_buffering.in ())) @@ -138,11 +138,11 @@ main (int argc, char *argv[]) } tmp = - orb->string_to_object(admin_ior, ACE_TRY_ENV); + orb->string_to_object(admin_ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Oneway_Buffering_Admin_var oneway_buffering_admin = - Test::Oneway_Buffering_Admin::_narrow(tmp.in (), ACE_TRY_ENV); + Test::Oneway_Buffering_Admin::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (oneway_buffering_admin.in ())) @@ -160,8 +160,8 @@ main (int argc, char *argv[]) test_failed = run_message_count (orb.in (), oneway_buffering.in (), - oneway_buffering_admin.in (), - ACE_TRY_ENV); + oneway_buffering_admin.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } else if (run_timeout_test) @@ -171,8 +171,8 @@ main (int argc, char *argv[]) test_failed = run_timeout (orb.in (), oneway_buffering.in (), - oneway_buffering_admin.in (), - ACE_TRY_ENV); + oneway_buffering_admin.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } else if (run_timeout_reactive_test) @@ -182,8 +182,8 @@ main (int argc, char *argv[]) test_failed = run_timeout_reactive (orb.in (), oneway_buffering.in (), - oneway_buffering_admin.in (), - ACE_TRY_ENV); + oneway_buffering_admin.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } else if (run_buffer_size_test) @@ -193,8 +193,8 @@ main (int argc, char *argv[]) test_failed = run_buffer_size (orb.in (), oneway_buffering.in (), - oneway_buffering_admin.in (), - ACE_TRY_ENV); + oneway_buffering_admin.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } else @@ -203,13 +203,13 @@ main (int argc, char *argv[]) "ERROR: No test was configured\n")); } - oneway_buffering->shutdown (ACE_TRY_ENV); + oneway_buffering->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - oneway_buffering_admin->shutdown (ACE_TRY_ENV); + oneway_buffering_admin->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -227,15 +227,15 @@ int configure_policies (CORBA::ORB_ptr orb, const TAO::BufferingConstraint &buffering_constraint, Test::Oneway_Buffering_ptr oneway_buffering, - Test::Oneway_Buffering_out flusher, - CORBA::Environment &ACE_TRY_ENV) + Test::Oneway_Buffering_out flusher + TAO_ENV_ARG_DECL) { CORBA::Object_var object = - orb->resolve_initial_references ("PolicyCurrent", ACE_TRY_ENV); + orb->resolve_initial_references ("PolicyCurrent" TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::PolicyCurrent_var policy_current = - CORBA::PolicyCurrent::_narrow (object.in (), ACE_TRY_ENV); + CORBA::PolicyCurrent::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (CORBA::is_nil (policy_current.in ())) @@ -252,22 +252,22 @@ configure_policies (CORBA::ORB_ptr orb, CORBA::PolicyList policies (2); policies.length (2); policies[0] = orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE, - scope_as_any, - ACE_TRY_ENV); + scope_as_any + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); policies[1] = orb->create_policy (TAO::BUFFERING_CONSTRAINT_POLICY_TYPE, - buffering_as_any, - ACE_TRY_ENV); + buffering_as_any + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); - policy_current->set_policy_overrides (policies, CORBA::ADD_OVERRIDE, - ACE_TRY_ENV); + policy_current->set_policy_overrides (policies, CORBA::ADD_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); - policies[0]->destroy (ACE_TRY_ENV); + policies[0]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); - policies[1]->destroy (ACE_TRY_ENV); + policies[1]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); TAO::BufferingConstraint flush_constraint; @@ -280,51 +280,51 @@ configure_policies (CORBA::ORB_ptr orb, policies.length (1); policies[0] = orb->create_policy (TAO::BUFFERING_CONSTRAINT_POLICY_TYPE, - buffering_as_any, - ACE_TRY_ENV); + buffering_as_any + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); object = oneway_buffering->_set_policy_overrides (policies, - CORBA::ADD_OVERRIDE, - ACE_TRY_ENV); + CORBA::ADD_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); - policies[0]->destroy (ACE_TRY_ENV); + policies[0]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); flusher = - Test::Oneway_Buffering::_narrow (object.in (), ACE_TRY_ENV); + Test::Oneway_Buffering::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); return 0; } void -sync_server (Test::Oneway_Buffering_ptr flusher, - CORBA::Environment &ACE_TRY_ENV) +sync_server (Test::Oneway_Buffering_ptr flusher + TAO_ENV_ARG_DECL) { // Get back in sync with the server... - flusher->flush (ACE_TRY_ENV); + flusher->flush (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; - flusher->sync (ACE_TRY_ENV); + flusher->sync (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; } int run_liveness_test (Test::Oneway_Buffering_ptr oneway_buffering, Test::Oneway_Buffering_ptr flusher, - Test::Oneway_Buffering_Admin_ptr oneway_buffering_admin, - CORBA::Environment &ACE_TRY_ENV) + Test::Oneway_Buffering_Admin_ptr oneway_buffering_admin + TAO_ENV_ARG_DECL) { ACE_DEBUG ((LM_DEBUG, ".... checking for liveness\n")); int test_failed = 0; - sync_server (flusher, ACE_TRY_ENV); + sync_server (flusher TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::ULong send_count = - oneway_buffering_admin->request_count (ACE_TRY_ENV); + oneway_buffering_admin->request_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); int liveness_test_iterations = int(send_count); @@ -337,12 +337,12 @@ run_liveness_test (Test::Oneway_Buffering_ptr oneway_buffering, int depth = 0; for (int i = 0; i != liveness_test_iterations; ++i) { - oneway_buffering->receive_data (payload, ACE_TRY_ENV); + oneway_buffering->receive_data (payload TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); send_count++; CORBA::ULong receive_count = - oneway_buffering_admin->request_count (ACE_TRY_ENV); + oneway_buffering_admin->request_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Once the system has sent enough messages we don't @@ -360,13 +360,13 @@ run_liveness_test (Test::Oneway_Buffering_ptr oneway_buffering, "expected %u\n", i, receive_count, expected)); - sync_server (flusher, ACE_TRY_ENV); + sync_server (flusher TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); } if (depth++ == LIVENESS_MAX_DEPTH) { - sync_server (flusher, ACE_TRY_ENV); + sync_server (flusher TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); depth = 0; @@ -380,8 +380,8 @@ run_liveness_test (Test::Oneway_Buffering_ptr oneway_buffering, int run_message_count (CORBA::ORB_ptr orb, Test::Oneway_Buffering_ptr oneway_buffering, - Test::Oneway_Buffering_Admin_ptr oneway_buffering_admin, - CORBA::Environment &ACE_TRY_ENV) + Test::Oneway_Buffering_Admin_ptr oneway_buffering_admin + TAO_ENV_ARG_DECL) { TAO::BufferingConstraint buffering_constraint; buffering_constraint.mode = TAO::BUFFER_MESSAGE_COUNT; @@ -392,8 +392,8 @@ run_message_count (CORBA::ORB_ptr orb, Test::Oneway_Buffering_var flusher; int test_failed = configure_policies (orb, buffering_constraint, - oneway_buffering, flusher.out (), - ACE_TRY_ENV); + oneway_buffering, flusher.out () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (test_failed != 0) @@ -407,11 +407,11 @@ run_message_count (CORBA::ORB_ptr orb, CORBA::ULong send_count = 0; for (int i = 0; i != iterations; ++i) { - sync_server (flusher.in (), ACE_TRY_ENV); + sync_server (flusher.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::ULong initial_receive_count = - oneway_buffering_admin->request_count (ACE_TRY_ENV); + oneway_buffering_admin->request_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (initial_receive_count != send_count) @@ -424,12 +424,12 @@ run_message_count (CORBA::ORB_ptr orb, while (1) { - oneway_buffering->receive_data (payload, ACE_TRY_ENV); + oneway_buffering->receive_data (payload TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); send_count++; CORBA::ULong receive_count = - oneway_buffering_admin->request_count (ACE_TRY_ENV); + oneway_buffering_admin->request_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::ULong iteration_count = @@ -466,8 +466,8 @@ run_message_count (CORBA::ORB_ptr orb, int liveness_test_failed = run_liveness_test (oneway_buffering, flusher.in (), - oneway_buffering_admin, - ACE_TRY_ENV); + oneway_buffering_admin + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (liveness_test_failed) @@ -479,8 +479,8 @@ run_message_count (CORBA::ORB_ptr orb, int run_timeout (CORBA::ORB_ptr orb, Test::Oneway_Buffering_ptr oneway_buffering, - Test::Oneway_Buffering_Admin_ptr oneway_buffering_admin, - CORBA::Environment &ACE_TRY_ENV) + Test::Oneway_Buffering_Admin_ptr oneway_buffering_admin + TAO_ENV_ARG_DECL) { TAO::BufferingConstraint buffering_constraint; buffering_constraint.mode = TAO::BUFFER_TIMEOUT; @@ -491,8 +491,8 @@ run_timeout (CORBA::ORB_ptr orb, Test::Oneway_Buffering_var flusher; int test_failed = configure_policies (orb, buffering_constraint, - oneway_buffering, flusher.out (), - ACE_TRY_ENV); + oneway_buffering, flusher.out () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (test_failed != 0) @@ -506,11 +506,11 @@ run_timeout (CORBA::ORB_ptr orb, CORBA::ULong send_count = 0; for (int i = 0; i != iterations; ++i) { - sync_server (flusher.in (), ACE_TRY_ENV); + sync_server (flusher.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::ULong initial_receive_count = - oneway_buffering_admin->request_count (ACE_TRY_ENV); + oneway_buffering_admin->request_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (initial_receive_count != send_count) @@ -524,12 +524,12 @@ run_timeout (CORBA::ORB_ptr orb, ACE_Time_Value start = ACE_OS::gettimeofday (); while (1) { - oneway_buffering->receive_data (payload, ACE_TRY_ENV); + oneway_buffering->receive_data (payload TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); send_count++; CORBA::ULong receive_count = - oneway_buffering_admin->request_count (ACE_TRY_ENV); + oneway_buffering_admin->request_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_Time_Value elapsed = ACE_OS::gettimeofday () - start; @@ -566,8 +566,8 @@ run_timeout (CORBA::ORB_ptr orb, int liveness_test_failed = run_liveness_test (oneway_buffering, flusher.in (), - oneway_buffering_admin, - ACE_TRY_ENV); + oneway_buffering_admin + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (liveness_test_failed) @@ -580,8 +580,8 @@ run_timeout (CORBA::ORB_ptr orb, int run_timeout_reactive (CORBA::ORB_ptr orb, Test::Oneway_Buffering_ptr oneway_buffering, - Test::Oneway_Buffering_Admin_ptr oneway_buffering_admin, - CORBA::Environment &ACE_TRY_ENV) + Test::Oneway_Buffering_Admin_ptr oneway_buffering_admin + TAO_ENV_ARG_DECL) { TAO::BufferingConstraint buffering_constraint; buffering_constraint.mode = TAO::BUFFER_TIMEOUT; @@ -592,8 +592,8 @@ run_timeout_reactive (CORBA::ORB_ptr orb, Test::Oneway_Buffering_var flusher; int test_failed = configure_policies (orb, buffering_constraint, - oneway_buffering, flusher.out (), - ACE_TRY_ENV); + oneway_buffering, flusher.out () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (test_failed != 0) @@ -607,11 +607,11 @@ run_timeout_reactive (CORBA::ORB_ptr orb, CORBA::ULong send_count = 0; for (int i = 0; i != iterations; ++i) { - sync_server (flusher.in (), ACE_TRY_ENV); + sync_server (flusher.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::ULong initial_receive_count = - oneway_buffering_admin->request_count (ACE_TRY_ENV); + oneway_buffering_admin->request_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (initial_receive_count != send_count) @@ -625,18 +625,18 @@ run_timeout_reactive (CORBA::ORB_ptr orb, ACE_Time_Value start = ACE_OS::gettimeofday (); for (int j = 0; j != 20; ++j) { - oneway_buffering->receive_data (payload, ACE_TRY_ENV); + oneway_buffering->receive_data (payload TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); send_count++; } while (1) { CORBA::ULong receive_count = - oneway_buffering_admin->request_count (ACE_TRY_ENV); + oneway_buffering_admin->request_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_Time_Value sleep (0, 10000); - orb->run (sleep, ACE_TRY_ENV); + orb->run (sleep TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_Time_Value elapsed = ACE_OS::gettimeofday () - start; @@ -673,8 +673,8 @@ run_timeout_reactive (CORBA::ORB_ptr orb, int liveness_test_failed = run_liveness_test (oneway_buffering, flusher.in (), - oneway_buffering_admin, - ACE_TRY_ENV); + oneway_buffering_admin + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (liveness_test_failed) @@ -687,8 +687,8 @@ run_timeout_reactive (CORBA::ORB_ptr orb, int run_buffer_size (CORBA::ORB_ptr orb, Test::Oneway_Buffering_ptr oneway_buffering, - Test::Oneway_Buffering_Admin_ptr oneway_buffering_admin, - CORBA::Environment &ACE_TRY_ENV) + Test::Oneway_Buffering_Admin_ptr oneway_buffering_admin + TAO_ENV_ARG_DECL) { TAO::BufferingConstraint buffering_constraint; buffering_constraint.mode = TAO::BUFFER_MESSAGE_BYTES; @@ -699,8 +699,8 @@ run_buffer_size (CORBA::ORB_ptr orb, Test::Oneway_Buffering_var flusher; int test_failed = configure_policies (orb, buffering_constraint, - oneway_buffering, flusher.out (), - ACE_TRY_ENV); + oneway_buffering, flusher.out () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (test_failed != 0) @@ -714,11 +714,11 @@ run_buffer_size (CORBA::ORB_ptr orb, CORBA::ULong bytes_sent = 0; for (int i = 0; i != iterations; ++i) { - sync_server (flusher.in (), ACE_TRY_ENV); + sync_server (flusher.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::ULong initial_bytes_received = - oneway_buffering_admin->bytes_received_count (ACE_TRY_ENV); + oneway_buffering_admin->bytes_received_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (initial_bytes_received != bytes_sent) @@ -731,12 +731,12 @@ run_buffer_size (CORBA::ORB_ptr orb, while (1) { - oneway_buffering->receive_data (payload, ACE_TRY_ENV); + oneway_buffering->receive_data (payload TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); bytes_sent += PAYLOAD_LENGTH; CORBA::ULong bytes_received = - oneway_buffering_admin->bytes_received_count (ACE_TRY_ENV); + oneway_buffering_admin->bytes_received_count (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::ULong payload_delta = @@ -778,8 +778,8 @@ run_buffer_size (CORBA::ORB_ptr orb, int liveness_test_failed = run_liveness_test (oneway_buffering, flusher.in (), - oneway_buffering_admin, - ACE_TRY_ENV); + oneway_buffering_admin + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (liveness_test_failed) diff --git a/TAO/tests/Oneway_Buffering/server.cpp b/TAO/tests/Oneway_Buffering/server.cpp index 707890bdf9c..bc92d73ca4c 100644 --- a/TAO/tests/Oneway_Buffering/server.cpp +++ b/TAO/tests/Oneway_Buffering/server.cpp @@ -18,19 +18,19 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case 'k': - ior = get_opts.optarg; - break; + ior = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile> " - "-k <ior> " + "-o <iorfile> " + "-k <ior> " "\n", argv [0]), -1); @@ -45,15 +45,15 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (root_poa.in ())) @@ -62,18 +62,18 @@ main (int argc, char *argv[]) 1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = - orb->string_to_object(ior, ACE_TRY_ENV); + orb->string_to_object(ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Oneway_Buffering_Admin_var admin = - Test::Oneway_Buffering_Admin::_narrow(tmp.in (), ACE_TRY_ENV); + Test::Oneway_Buffering_Admin::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (admin.in ())) @@ -92,11 +92,11 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var owner_transfer(oneway_buffering_impl); Test::Oneway_Buffering_var oneway_buffering = - oneway_buffering_impl->_this (ACE_TRY_ENV); + oneway_buffering_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (oneway_buffering.in (), ACE_TRY_ENV); + orb->object_to_string (oneway_buffering.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -109,18 +109,18 @@ main (int argc, char *argv[]) ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Oneways_Invoking_Twoways/Client_Task.cpp b/TAO/tests/Oneways_Invoking_Twoways/Client_Task.cpp index 1a546611b1e..60599eb6d4c 100644 --- a/TAO/tests/Oneways_Invoking_Twoways/Client_Task.cpp +++ b/TAO/tests/Oneways_Invoking_Twoways/Client_Task.cpp @@ -21,7 +21,7 @@ Client_Task::svc (void) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) Starting client task\n")); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { for (int i = 0; i != 1; ++i) @@ -29,8 +29,8 @@ Client_Task::svc (void) ACE_DEBUG ((LM_DEBUG, "TAO (%P|%t) sending oneways...\n")); - this->sender_->send_ready_message (this->us_.in (), - ACE_TRY_ENV); + this->sender_->send_ready_message (this->us_.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/tests/Oneways_Invoking_Twoways/Receiver_i.cpp b/TAO/tests/Oneways_Invoking_Twoways/Receiver_i.cpp index 9f4e8c8f0ff..a615bc0fa09 100644 --- a/TAO/tests/Oneways_Invoking_Twoways/Receiver_i.cpp +++ b/TAO/tests/Oneways_Invoking_Twoways/Receiver_i.cpp @@ -19,20 +19,20 @@ Receiver_i::~Receiver_i (void) CORBA::Long -Receiver_i::receive_call (CORBA::Environment &ACE_TRY_ENV) +Receiver_i::receive_call (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) Doing a ping... \n")); - this->sender_->ping (ACE_TRY_ENV); + this->sender_->ping (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); return this->no_calls_++; } CORBA::Long -Receiver_i::get_call_count (CORBA::Environment & /*ACE_TRY_ENV*/) +Receiver_i::get_call_count (TAO_ENV_SINGLE_ARG_DECL_NOT_USED /*TAO_ENV_SINGLE_ARG_PARAMETER*/) ACE_THROW_SPEC ((CORBA::SystemException)) { return this->iteration_; diff --git a/TAO/tests/Oneways_Invoking_Twoways/Receiver_i.h b/TAO/tests/Oneways_Invoking_Twoways/Receiver_i.h index 4293dac976b..bc133c6d926 100644 --- a/TAO/tests/Oneways_Invoking_Twoways/Receiver_i.h +++ b/TAO/tests/Oneways_Invoking_Twoways/Receiver_i.h @@ -41,11 +41,11 @@ public: virtual ~Receiver_i (void); // = The skeleton methods - virtual CORBA::Long receive_call (CORBA::Environment &ACE_TRY_ENV) + virtual CORBA::Long receive_call (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); /// Retun the number of calls that every thread would make... - virtual CORBA::Long get_call_count (CORBA::Environment &ACE_TRY_ENV) + virtual CORBA::Long get_call_count (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Oneways_Invoking_Twoways/Sender_i.cpp b/TAO/tests/Oneways_Invoking_Twoways/Sender_i.cpp index 035dae27f42..43f09655404 100644 --- a/TAO/tests/Oneways_Invoking_Twoways/Sender_i.cpp +++ b/TAO/tests/Oneways_Invoking_Twoways/Sender_i.cpp @@ -15,8 +15,8 @@ Sender_i::~Sender_i (void) } void -Sender_i::active_objects (CORBA::Short no_threads, - CORBA::Environment & /*ACE_TRY_ENV */ ) +Sender_i::active_objects (CORBA::Short no_threads + TAO_ENV_ARG_DECL_NOT_USED /*TAO_ENV_SINGLE_ARG_PARAMETER */ ) ACE_THROW_SPEC ((CORBA::SystemException)) { this->active_objects_ = no_threads; @@ -24,8 +24,8 @@ Sender_i::active_objects (CORBA::Short no_threads, void -Sender_i::send_ready_message (Test::Receiver_ptr receiver, - CORBA::Environment &ACE_TRY_ENV) +Sender_i::send_ready_message (Test::Receiver_ptr receiver + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -38,14 +38,14 @@ Sender_i::send_ready_message (Test::Receiver_ptr receiver, i < this->number_; ++i) { - receiver->receive_call (ACE_TRY_ENV); + receiver->receive_call (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; } } void -Sender_i::ping (CORBA::Environment & /*ACE_TRY_ENV*/) +Sender_i::ping (TAO_ENV_SINGLE_ARG_DECL_NOT_USED /*TAO_ENV_SINGLE_ARG_PARAMETER*/) ACE_THROW_SPEC ((CORBA::SystemException)) { return; diff --git a/TAO/tests/Oneways_Invoking_Twoways/Sender_i.h b/TAO/tests/Oneways_Invoking_Twoways/Sender_i.h index 6b51ce92b1c..b878806fb08 100644 --- a/TAO/tests/Oneways_Invoking_Twoways/Sender_i.h +++ b/TAO/tests/Oneways_Invoking_Twoways/Sender_i.h @@ -41,15 +41,15 @@ public: virtual ~Sender_i (void); // = The skeleton methods - virtual void active_objects (CORBA::Short ao, - CORBA::Environment &ACE_TRY_ENV) + virtual void active_objects (CORBA::Short ao + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void send_ready_message (Test::Receiver_ptr receiver, - CORBA::Environment &ACE_TRY_ENV) + virtual void send_ready_message (Test::Receiver_ptr receiver + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void ping (CORBA::Environment &ACE_TRY_ENV) + virtual void ping (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Oneways_Invoking_Twoways/Server_Task.cpp b/TAO/tests/Oneways_Invoking_Twoways/Server_Task.cpp index 0b96b4f366f..1338704fc0d 100644 --- a/TAO/tests/Oneways_Invoking_Twoways/Server_Task.cpp +++ b/TAO/tests/Oneways_Invoking_Twoways/Server_Task.cpp @@ -17,12 +17,12 @@ int Server_Task::svc (void) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) Starting server task\n")); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { // run the test for at most 60 seconds... ACE_Time_Value tv (60, 0); - this->orb_->run (tv, ACE_TRY_ENV); + this->orb_->run (tv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Oneways_Invoking_Twoways/client.cpp b/TAO/tests/Oneways_Invoking_Twoways/client.cpp index 3428a3604f7..49526d4786c 100644 --- a/TAO/tests/Oneways_Invoking_Twoways/client.cpp +++ b/TAO/tests/Oneways_Invoking_Twoways/client.cpp @@ -40,11 +40,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -53,11 +53,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -65,11 +65,11 @@ main (int argc, char *argv[]) // Get the sender reference.. CORBA::Object_var tmp = - orb->string_to_object(ior, ACE_TRY_ENV); + orb->string_to_object(ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Sender_var sender = - Test::Sender::_narrow(tmp.in (), ACE_TRY_ENV); + Test::Sender::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (sender.in ())) @@ -90,11 +90,11 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var receiver_owner_transfer(receiver_impl); Test::Receiver_var receiver = - receiver_impl->_this (ACE_TRY_ENV); + receiver_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Activate poa manager - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Client_Task client_task (sender.in (), @@ -106,7 +106,7 @@ main (int argc, char *argv[]) // Before creating threads we will let the sender know that we // will have two threads that would make invocations.. - sender->active_objects ((CORBA::Short) 2, ACE_TRY_ENV); + sender->active_objects ((CORBA::Short) 2 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (server_task.activate (THR_NEW_LWP | THR_JOINABLE, 2,1) == -1) @@ -124,7 +124,7 @@ main (int argc, char *argv[]) ACE_DEBUG ((LM_DEBUG, "Event Loop finished \n")); - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Oneways_Invoking_Twoways/server.cpp b/TAO/tests/Oneways_Invoking_Twoways/server.cpp index 7a24398d2ff..c69f94b9103 100644 --- a/TAO/tests/Oneways_Invoking_Twoways/server.cpp +++ b/TAO/tests/Oneways_Invoking_Twoways/server.cpp @@ -39,11 +39,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -52,11 +52,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -70,11 +70,11 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var receiver_owner_transfer(sender_impl); Test::Sender_var sender = - sender_impl->_this (ACE_TRY_ENV); + sender_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (sender.in (), ACE_TRY_ENV); + orb->object_to_string (sender.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -87,7 +87,7 @@ main (int argc, char *argv[]) ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Server_Task server_task (orb.in (), @@ -101,10 +101,10 @@ main (int argc, char *argv[]) ACE_DEBUG ((LM_DEBUG, "Now terminating test\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/POA/Etherealization/Etherealization.cpp b/TAO/tests/POA/Etherealization/Etherealization.cpp index f7f173311e0..4a171233145 100644 --- a/TAO/tests/POA/Etherealization/Etherealization.cpp +++ b/TAO/tests/POA/Etherealization/Etherealization.cpp @@ -22,7 +22,7 @@ class test_i : public POA_test { public: - void method (CORBA::Environment & /*ACE_TRY_ENV*/) + void method (TAO_ENV_SINGLE_ARG_DECL_NOT_USED /*TAO_ENV_SINGLE_ARG_PARAMETER*/) ACE_THROW_SPEC ((CORBA::SystemException)) { } @@ -37,7 +37,7 @@ class test_i_with_reference_counting : public virtual PortableServer::RefCountSe public virtual POA_test { public: - void method (CORBA::Environment &) + void method (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { } @@ -114,32 +114,32 @@ Servant_Activator::etherealize (const PortableServer::ObjectId &id, int main (int argc, char **argv) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { // Initialize the ORB first. CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Obtain the RootPOA. CORBA::Object_var object = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the POA_var object from Object_var. PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (object.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the POAManager of the RootPOA. PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyList policies (3); @@ -147,30 +147,30 @@ main (int argc, char **argv) // ID Assignment Policy policies[0] = - root_poa->create_id_assignment_policy (PortableServer::USER_ID, - ACE_TRY_ENV); + root_poa->create_id_assignment_policy (PortableServer::USER_ID + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Lifespan Policy policies[1] = - root_poa->create_lifespan_policy (PortableServer::PERSISTENT, - ACE_TRY_ENV); + root_poa->create_lifespan_policy (PortableServer::PERSISTENT + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Request Processing Policy policies[2] = - root_poa->create_request_processing_policy (PortableServer::USE_SERVANT_MANAGER, - ACE_TRY_ENV); + root_poa->create_request_processing_policy (PortableServer::USE_SERVANT_MANAGER + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var child_poa = root_poa->create_POA ("child", poa_manager.in (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Create servant activator. @@ -178,8 +178,8 @@ main (int argc, char **argv) new Servant_Activator; // Set servant_activator as the servant_manager of child POA. - child_poa->set_servant_manager (servant_manager.in (), - ACE_TRY_ENV); + child_poa->set_servant_manager (servant_manager.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; { @@ -190,20 +190,20 @@ main (int argc, char **argv) object = child_poa->create_reference_with_id (id.in (), - "IDL:test:1.0", - ACE_TRY_ENV); + "IDL:test:1.0" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; test_var test = - test::_narrow (object.in (), - ACE_TRY_ENV); + test::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - test->method (ACE_TRY_ENV); + test->method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - child_poa->deactivate_object (id.in (), - ACE_TRY_ENV); + child_poa->deactivate_object (id.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -215,20 +215,20 @@ main (int argc, char **argv) object = child_poa->create_reference_with_id (id.in (), - "IDL:test:1.0", - ACE_TRY_ENV); + "IDL:test:1.0" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; test_var test = - test::_narrow (object.in (), - ACE_TRY_ENV); + test::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - test->method (ACE_TRY_ENV); + test->method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - child_poa->deactivate_object (id.in (), - ACE_TRY_ENV); + child_poa->deactivate_object (id.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } diff --git a/TAO/tests/POA/Excessive_Object_Deactivations/Excessive_Object_Deactivations.cpp b/TAO/tests/POA/Excessive_Object_Deactivations/Excessive_Object_Deactivations.cpp index f447dab8b42..127ae92a099 100644 --- a/TAO/tests/POA/Excessive_Object_Deactivations/Excessive_Object_Deactivations.cpp +++ b/TAO/tests/POA/Excessive_Object_Deactivations/Excessive_Object_Deactivations.cpp @@ -24,10 +24,10 @@ class test_i : public POA_test { public: - void deactivate_self (CORBA::Environment &ACE_TRY_ENV) + void deactivate_self (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - PortableServer::POA_ptr _default_POA (CORBA_Environment &ACE_TRY_ENV); + PortableServer::POA_ptr _default_POA (TAO_ENV_SINGLE_ARG_DECL); PortableServer::POA_var poa_; @@ -35,17 +35,17 @@ public: }; PortableServer::POA_ptr -test_i::_default_POA (CORBA_Environment & /*ACE_TRY_ENV*/) +test_i::_default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED /*TAO_ENV_SINGLE_ARG_PARAMETER*/) { return PortableServer::POA::_duplicate (this->poa_.in ()); } void -test_i::deactivate_self (CORBA::Environment &ACE_TRY_ENV) +test_i::deactivate_self (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->poa_->deactivate_object (this->id_, - ACE_TRY_ENV); + this->poa_->deactivate_object (this->id_ + TAO_ENV_ARG_PARAMETER); ACE_CHECK; // Exception flag @@ -53,8 +53,8 @@ test_i::deactivate_self (CORBA::Environment &ACE_TRY_ENV) ACE_TRY { - this->poa_->deactivate_object (this->id_, - ACE_TRY_ENV); + this->poa_->deactivate_object (this->id_ + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (PortableServer::POA::ObjectNotActive, ex) @@ -78,8 +78,8 @@ test_i::deactivate_self (CORBA::Environment &ACE_TRY_ENV) void test_object_deactivation (PortableServer::POA_ptr poa, - const PortableServer::ObjectId &id, - CORBA::Environment &ACE_TRY_ENV) + const PortableServer::ObjectId &id + TAO_ENV_ARG_DECL) { test_i servant; int expected_exception_raised = 0; @@ -89,8 +89,8 @@ test_object_deactivation (PortableServer::POA_ptr poa, ACE_TRY_EX (invalid_id) { - poa->deactivate_object (invalid_id.in (), - ACE_TRY_ENV); + poa->deactivate_object (invalid_id.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK_EX (invalid_id); } ACE_CATCH (PortableServer::POA::ObjectNotActive, ex) @@ -113,12 +113,12 @@ test_object_deactivation (PortableServer::POA_ptr poa, poa->activate_object_with_id (id, - &servant, - ACE_TRY_ENV); + &servant + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - poa->deactivate_object (id, - ACE_TRY_ENV); + poa->deactivate_object (id + TAO_ENV_ARG_PARAMETER); ACE_CHECK; // Reset flag @@ -126,8 +126,8 @@ test_object_deactivation (PortableServer::POA_ptr poa, ACE_TRY_EX (double_deactivate) { - poa->deactivate_object (id, - ACE_TRY_ENV); + poa->deactivate_object (id + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK_EX (double_deactivate); } ACE_CATCH (PortableServer::POA::ObjectNotActive, ex) @@ -148,8 +148,8 @@ test_object_deactivation (PortableServer::POA_ptr poa, ACE_ASSERT (expected_exception_raised); poa->activate_object_with_id (id, - &servant, - ACE_TRY_ENV); + &servant + TAO_ENV_ARG_PARAMETER); ACE_CHECK; servant.poa_ = @@ -158,10 +158,10 @@ test_object_deactivation (PortableServer::POA_ptr poa, servant.id_ = id; test_var test = - servant._this (ACE_TRY_ENV); + servant._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; - test->deactivate_self (ACE_TRY_ENV); + test->deactivate_self (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; // ACE_ASSERT dissappears in non-debug builds @@ -172,65 +172,65 @@ test_object_deactivation (PortableServer::POA_ptr poa, int main (int argc, char **argv) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { // Initialize the ORB first. CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Obtain the RootPOA. CORBA::Object_var obj = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the POA_var object from Object_var. PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (obj.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the POAManager of the RootPOA. PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyList empty_policies; PortableServer::POA_var child_poa = root_poa->create_POA ("child", poa_manager.in (), - empty_policies, - ACE_TRY_ENV); + empty_policies + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; obj = - root_poa->create_reference ("IDL:test:1.0", - ACE_TRY_ENV); + root_poa->create_reference ("IDL:test:1.0" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::ObjectId_var id = - root_poa->reference_to_id (obj.in (), - ACE_TRY_ENV); + root_poa->reference_to_id (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; test_object_deactivation (root_poa.in (), - id.in (), - ACE_TRY_ENV); + id.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; id = PortableServer::string_to_ObjectId ("good id"); test_object_deactivation (child_poa.in (), - id.in (), - ACE_TRY_ENV); + id.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/POA/Identity/Identity.cpp b/TAO/tests/POA/Identity/Identity.cpp index e1a949eda57..4a9fec96cce 100644 --- a/TAO/tests/POA/Identity/Identity.cpp +++ b/TAO/tests/POA/Identity/Identity.cpp @@ -30,7 +30,7 @@ public: { } - PortableServer::POA_ptr _default_POA (CORBA::Environment &) + PortableServer::POA_ptr _default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) { return PortableServer::POA::_duplicate (this->poa_.in ()); } @@ -46,76 +46,76 @@ create_poas (PortableServer::POA_ptr root_poa, PortableServer::POA_out first_poa, PortableServer::POA_out second_poa, PortableServer::POA_out third_poa, - PortableServer::POA_out forth_poa, - CORBA::Environment &ACE_TRY_ENV) + PortableServer::POA_out forth_poa + TAO_ENV_ARG_DECL) { // Policies for the new POAs CORBA::PolicyList policies (3); policies.length (3); - policies[0] = root_poa->create_lifespan_policy (lifespan_policy, - ACE_TRY_ENV); + policies[0] = root_poa->create_lifespan_policy (lifespan_policy + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - policies[1] = root_poa->create_id_uniqueness_policy (PortableServer::MULTIPLE_ID, - ACE_TRY_ENV); + policies[1] = root_poa->create_id_uniqueness_policy (PortableServer::MULTIPLE_ID + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - policies[2] = root_poa->create_id_assignment_policy (PortableServer::SYSTEM_ID, - ACE_TRY_ENV); + policies[2] = root_poa->create_id_assignment_policy (PortableServer::SYSTEM_ID + TAO_ENV_ARG_PARAMETER); ACE_CHECK; // Creation of the firstPOA ACE_CString name = "firstPOA"; first_poa = root_poa->create_POA (name.c_str (), PortableServer::POAManager::_nil (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - policies[1]->destroy (ACE_TRY_ENV); + policies[1]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; - policies[1] = root_poa->create_id_uniqueness_policy (PortableServer::UNIQUE_ID, - ACE_TRY_ENV); + policies[1] = root_poa->create_id_uniqueness_policy (PortableServer::UNIQUE_ID + TAO_ENV_ARG_PARAMETER); ACE_CHECK; // Creation of the secondPOA name = "secondPOA"; second_poa = root_poa->create_POA (name.c_str (), PortableServer::POAManager::_nil (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - policies[2]->destroy (ACE_TRY_ENV); + policies[2]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; - policies[2] = root_poa->create_id_assignment_policy (PortableServer::USER_ID, - ACE_TRY_ENV); + policies[2] = root_poa->create_id_assignment_policy (PortableServer::USER_ID + TAO_ENV_ARG_PARAMETER); ACE_CHECK; // Creation of the thirdPOA name = "thirdPOA"; third_poa = root_poa->create_POA (name.c_str (), PortableServer::POAManager::_nil (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - policies[1]->destroy (ACE_TRY_ENV); + policies[1]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; - policies[1] = root_poa->create_id_uniqueness_policy (PortableServer::MULTIPLE_ID, - ACE_TRY_ENV); + policies[1] = root_poa->create_id_uniqueness_policy (PortableServer::MULTIPLE_ID + TAO_ENV_ARG_PARAMETER); ACE_CHECK; // Creation of the forthPOA name = "forthPOA"; forth_poa = root_poa->create_POA (name.c_str (), PortableServer::POAManager::_nil (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_CHECK; // Creation of the new POAs over, so destroy the policies @@ -123,7 +123,7 @@ create_poas (PortableServer::POA_ptr root_poa, i < policies.length (); ++i) { - policies[i]->destroy (ACE_TRY_ENV); + policies[i]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; } } @@ -135,49 +135,49 @@ test_poas (CORBA::ORB_ptr orb, PortableServer::POA_ptr second_poa, PortableServer::POA_ptr third_poa, PortableServer::POA_ptr forth_poa, - int perform_deactivation_test, - CORBA::Environment &ACE_TRY_ENV) + int perform_deactivation_test + TAO_ENV_ARG_DECL) { { test_i servant (root_poa); - CORBA::Object_var obj = root_poa->create_reference ("IDL:test:1.0", - ACE_TRY_ENV); + CORBA::Object_var obj = root_poa->create_reference ("IDL:test:1.0" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - CORBA::String_var string = orb->object_to_string (obj.in (), - ACE_TRY_ENV); + CORBA::String_var string = orb->object_to_string (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); - PortableServer::ObjectId_var id = root_poa->reference_to_id (obj.in (), - ACE_TRY_ENV); + PortableServer::ObjectId_var id = root_poa->reference_to_id (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; root_poa->activate_object_with_id (id.in (), - &servant, - ACE_TRY_ENV); + &servant + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - obj = root_poa->id_to_reference (id.in (), - ACE_TRY_ENV); + obj = root_poa->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - string = orb->object_to_string (obj.in (), - ACE_TRY_ENV); + string = orb->object_to_string (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); PortableServer::Servant servant_from_reference = - root_poa->reference_to_servant (obj.in (), - ACE_TRY_ENV); + root_poa->reference_to_servant (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; PortableServer::Servant servant_from_id = - root_poa->id_to_servant (id.in (), - ACE_TRY_ENV); + root_poa->id_to_servant (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (servant_from_reference != servant_from_id @@ -188,50 +188,50 @@ test_poas (CORBA::ORB_ptr orb, "servant_from_id and &servant\n")); } - obj = root_poa->servant_to_reference (&servant, - ACE_TRY_ENV); + obj = root_poa->servant_to_reference (&servant + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - string = orb->object_to_string (obj.in (), - ACE_TRY_ENV); + string = orb->object_to_string (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); - obj = servant._this (ACE_TRY_ENV); + obj = servant._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; - string = orb->object_to_string (obj.in (), - ACE_TRY_ENV); + string = orb->object_to_string (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); - PortableServer::ObjectId_var id_from_servant = root_poa->servant_to_id (&servant, - ACE_TRY_ENV); + PortableServer::ObjectId_var id_from_servant = root_poa->servant_to_id (&servant + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_ASSERT (id_from_servant.in () == id.in ()); - root_poa->deactivate_object (id.in (), - ACE_TRY_ENV); + root_poa->deactivate_object (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (perform_deactivation_test) { root_poa->activate_object_with_id (id.in (), - &servant, - ACE_TRY_ENV); + &servant + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - servant_from_reference = root_poa->reference_to_servant (obj.in (), - ACE_TRY_ENV); + servant_from_reference = root_poa->reference_to_servant (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_ASSERT (servant_from_reference == &servant); - root_poa->deactivate_object (id.in (), - ACE_TRY_ENV); + root_poa->deactivate_object (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } } @@ -239,76 +239,76 @@ test_poas (CORBA::ORB_ptr orb, { test_i servant (root_poa); - PortableServer::ObjectId_var id = root_poa->activate_object (&servant, - ACE_TRY_ENV); + PortableServer::ObjectId_var id = root_poa->activate_object (&servant + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - CORBA::Object_var obj = root_poa->id_to_reference (id.in (), - ACE_TRY_ENV); + CORBA::Object_var obj = root_poa->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - CORBA::String_var string = orb->object_to_string (obj.in (), - ACE_TRY_ENV); + CORBA::String_var string = orb->object_to_string (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); obj = root_poa->create_reference_with_id (id.in (), - "IDL:test:1.0", - ACE_TRY_ENV); + "IDL:test:1.0" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - string = orb->object_to_string (obj.in (), - ACE_TRY_ENV); + string = orb->object_to_string (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); - root_poa->deactivate_object (id.in (), - ACE_TRY_ENV); + root_poa->deactivate_object (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } { test_i servant (first_poa); - CORBA::Object_var obj = first_poa->create_reference ("IDL:test:1.0", - ACE_TRY_ENV); + CORBA::Object_var obj = first_poa->create_reference ("IDL:test:1.0" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - CORBA::String_var string = orb->object_to_string (obj.in (), - ACE_TRY_ENV); + CORBA::String_var string = orb->object_to_string (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); - PortableServer::ObjectId_var id = first_poa->reference_to_id (obj.in (), - ACE_TRY_ENV); + PortableServer::ObjectId_var id = first_poa->reference_to_id (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; first_poa->activate_object_with_id (id.in (), - &servant, - ACE_TRY_ENV); + &servant + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - obj = first_poa->id_to_reference (id.in (), - ACE_TRY_ENV); + obj = first_poa->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - string = orb->object_to_string (obj.in (), - ACE_TRY_ENV); + string = orb->object_to_string (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); PortableServer::Servant servant_from_reference = - first_poa->reference_to_servant (obj.in (), - ACE_TRY_ENV); + first_poa->reference_to_servant (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; PortableServer::Servant servant_from_id = - first_poa->id_to_servant (id.in (), - ACE_TRY_ENV); + first_poa->id_to_servant (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (servant_from_reference != servant_from_id @@ -319,25 +319,25 @@ test_poas (CORBA::ORB_ptr orb, "servant_from_id and &servant\n")); } - first_poa->deactivate_object (id.in (), - ACE_TRY_ENV); + first_poa->deactivate_object (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (perform_deactivation_test) { first_poa->activate_object_with_id (id.in (), - &servant, - ACE_TRY_ENV); + &servant + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - servant_from_reference = first_poa->reference_to_servant (obj.in (), - ACE_TRY_ENV); + servant_from_reference = first_poa->reference_to_servant (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_ASSERT (servant_from_reference == &servant); - first_poa->deactivate_object (id.in (), - ACE_TRY_ENV); + first_poa->deactivate_object (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } } @@ -345,76 +345,76 @@ test_poas (CORBA::ORB_ptr orb, { test_i servant (first_poa); - PortableServer::ObjectId_var id = first_poa->activate_object (&servant, - ACE_TRY_ENV); + PortableServer::ObjectId_var id = first_poa->activate_object (&servant + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - CORBA::Object_var obj = first_poa->id_to_reference (id.in (), - ACE_TRY_ENV); + CORBA::Object_var obj = first_poa->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - CORBA::String_var string = orb->object_to_string (obj.in (), - ACE_TRY_ENV); + CORBA::String_var string = orb->object_to_string (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); obj = first_poa->create_reference_with_id (id.in (), - "IDL:test:1.0", - ACE_TRY_ENV); + "IDL:test:1.0" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - string = orb->object_to_string (obj.in (), - ACE_TRY_ENV); + string = orb->object_to_string (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); - first_poa->deactivate_object (id.in (), - ACE_TRY_ENV); + first_poa->deactivate_object (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } { test_i servant (second_poa); - CORBA::Object_var obj = second_poa->create_reference ("IDL:test:1.0", - ACE_TRY_ENV); + CORBA::Object_var obj = second_poa->create_reference ("IDL:test:1.0" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - CORBA::String_var string = orb->object_to_string (obj.in (), - ACE_TRY_ENV); + CORBA::String_var string = orb->object_to_string (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); - PortableServer::ObjectId_var id = second_poa->reference_to_id (obj.in (), - ACE_TRY_ENV); + PortableServer::ObjectId_var id = second_poa->reference_to_id (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; second_poa->activate_object_with_id (id.in (), - &servant, - ACE_TRY_ENV); + &servant + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - obj = second_poa->id_to_reference (id.in (), - ACE_TRY_ENV); + obj = second_poa->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - string = orb->object_to_string (obj.in (), - ACE_TRY_ENV); + string = orb->object_to_string (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); PortableServer::Servant servant_from_reference = - second_poa->reference_to_servant (obj.in (), - ACE_TRY_ENV); + second_poa->reference_to_servant (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; PortableServer::Servant servant_from_id = - second_poa->id_to_servant (id.in (), - ACE_TRY_ENV); + second_poa->id_to_servant (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (servant_from_reference != servant_from_id @@ -425,50 +425,50 @@ test_poas (CORBA::ORB_ptr orb, "servant_from_id and &servant\n")); } - obj = second_poa->servant_to_reference (&servant, - ACE_TRY_ENV); + obj = second_poa->servant_to_reference (&servant + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - string = orb->object_to_string (obj.in (), - ACE_TRY_ENV); + string = orb->object_to_string (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); - obj = servant._this (ACE_TRY_ENV); + obj = servant._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; - string = orb->object_to_string (obj.in (), - ACE_TRY_ENV); + string = orb->object_to_string (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); - PortableServer::ObjectId_var id_from_servant = second_poa->servant_to_id (&servant, - ACE_TRY_ENV); + PortableServer::ObjectId_var id_from_servant = second_poa->servant_to_id (&servant + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_ASSERT (id_from_servant.in () == id.in ()); - second_poa->deactivate_object (id.in (), - ACE_TRY_ENV); + second_poa->deactivate_object (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (perform_deactivation_test) { second_poa->activate_object_with_id (id.in (), - &servant, - ACE_TRY_ENV); + &servant + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - servant_from_reference = second_poa->reference_to_servant (obj.in (), - ACE_TRY_ENV); + servant_from_reference = second_poa->reference_to_servant (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_ASSERT (servant_from_reference == &servant); - second_poa->deactivate_object (id.in (), - ACE_TRY_ENV); + second_poa->deactivate_object (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } } @@ -476,33 +476,33 @@ test_poas (CORBA::ORB_ptr orb, { test_i servant (second_poa); - PortableServer::ObjectId_var id = second_poa->activate_object (&servant, - ACE_TRY_ENV); + PortableServer::ObjectId_var id = second_poa->activate_object (&servant + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - CORBA::Object_var obj = second_poa->id_to_reference (id.in (), - ACE_TRY_ENV); + CORBA::Object_var obj = second_poa->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - CORBA::String_var string = orb->object_to_string (obj.in (), - ACE_TRY_ENV); + CORBA::String_var string = orb->object_to_string (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); obj = second_poa->create_reference_with_id (id.in (), - "IDL:test:1.0", - ACE_TRY_ENV); + "IDL:test:1.0" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - string = orb->object_to_string (obj.in (), - ACE_TRY_ENV); + string = orb->object_to_string (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); - second_poa->deactivate_object (id.in (), - ACE_TRY_ENV); + second_poa->deactivate_object (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } @@ -511,18 +511,18 @@ test_poas (CORBA::ORB_ptr orb, PortableServer::ObjectId_var id = PortableServer::string_to_ObjectId ("hello"); CORBA::Object_var obj = third_poa->create_reference_with_id (id.in (), - "IDL:test:1.0", - ACE_TRY_ENV); + "IDL:test:1.0" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - CORBA::String_var string = orb->object_to_string (obj.in (), - ACE_TRY_ENV); + CORBA::String_var string = orb->object_to_string (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); - PortableServer::ObjectId_var id_from_reference = third_poa->reference_to_id (obj.in (), - ACE_TRY_ENV); + PortableServer::ObjectId_var id_from_reference = third_poa->reference_to_id (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; string = PortableServer::ObjectId_to_string (id_from_reference.in ()); @@ -531,28 +531,28 @@ test_poas (CORBA::ORB_ptr orb, ACE_ASSERT (id_from_reference.in () == id.in ()); third_poa->activate_object_with_id (id.in (), - &servant, - ACE_TRY_ENV); + &servant + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - obj = third_poa->id_to_reference (id.in (), - ACE_TRY_ENV); + obj = third_poa->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - string = orb->object_to_string (obj.in (), - ACE_TRY_ENV); + string = orb->object_to_string (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); PortableServer::Servant servant_from_reference = - third_poa->reference_to_servant (obj.in (), - ACE_TRY_ENV); + third_poa->reference_to_servant (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; PortableServer::Servant servant_from_id = - third_poa->id_to_servant (id.in (), - ACE_TRY_ENV); + third_poa->id_to_servant (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (servant_from_reference != servant_from_id @@ -563,27 +563,27 @@ test_poas (CORBA::ORB_ptr orb, "servant_from_id and &servant\n")); } - obj = third_poa->servant_to_reference (&servant, - ACE_TRY_ENV); + obj = third_poa->servant_to_reference (&servant + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - string = orb->object_to_string (obj.in (), - ACE_TRY_ENV); + string = orb->object_to_string (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); - obj = servant._this (ACE_TRY_ENV); + obj = servant._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; - string = orb->object_to_string (obj.in (), - ACE_TRY_ENV); + string = orb->object_to_string (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); - PortableServer::ObjectId_var id_from_servant = third_poa->servant_to_id (&servant, - ACE_TRY_ENV); + PortableServer::ObjectId_var id_from_servant = third_poa->servant_to_id (&servant + TAO_ENV_ARG_PARAMETER); ACE_CHECK; string = PortableServer::ObjectId_to_string (id_from_servant.in ()); @@ -591,25 +591,25 @@ test_poas (CORBA::ORB_ptr orb, ACE_ASSERT (id_from_servant.in () == id.in ()); - third_poa->deactivate_object (id.in (), - ACE_TRY_ENV); + third_poa->deactivate_object (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (perform_deactivation_test) { third_poa->activate_object_with_id (id.in (), - &servant, - ACE_TRY_ENV); + &servant + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - servant_from_reference = third_poa->reference_to_servant (obj.in (), - ACE_TRY_ENV); + servant_from_reference = third_poa->reference_to_servant (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_ASSERT (servant_from_reference == &servant); - third_poa->deactivate_object (id.in (), - ACE_TRY_ENV); + third_poa->deactivate_object (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } } @@ -619,18 +619,18 @@ test_poas (CORBA::ORB_ptr orb, PortableServer::ObjectId_var id = PortableServer::string_to_ObjectId ("hello"); CORBA::Object_var obj = forth_poa->create_reference_with_id (id.in (), - "IDL:test:1.0", - ACE_TRY_ENV); + "IDL:test:1.0" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - CORBA::String_var string = orb->object_to_string (obj.in (), - ACE_TRY_ENV); + CORBA::String_var string = orb->object_to_string (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); - PortableServer::ObjectId_var id_from_reference = forth_poa->reference_to_id (obj.in (), - ACE_TRY_ENV); + PortableServer::ObjectId_var id_from_reference = forth_poa->reference_to_id (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; string = PortableServer::ObjectId_to_string (id_from_reference.in ()); @@ -639,28 +639,28 @@ test_poas (CORBA::ORB_ptr orb, ACE_ASSERT (id_from_reference.in () == id.in ()); forth_poa->activate_object_with_id (id.in (), - &servant, - ACE_TRY_ENV); + &servant + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - obj = forth_poa->id_to_reference (id.in (), - ACE_TRY_ENV); + obj = forth_poa->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - string = orb->object_to_string (obj.in (), - ACE_TRY_ENV); + string = orb->object_to_string (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", string.in ())); PortableServer::Servant servant_from_reference = - forth_poa->reference_to_servant (obj.in (), - ACE_TRY_ENV); + forth_poa->reference_to_servant (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; PortableServer::Servant servant_from_id = - forth_poa->id_to_servant (id.in (), - ACE_TRY_ENV); + forth_poa->id_to_servant (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (servant_from_reference != servant_from_id @@ -676,18 +676,18 @@ test_poas (CORBA::ORB_ptr orb, if (perform_deactivation_test) { forth_poa->activate_object_with_id (id.in (), - &servant, - ACE_TRY_ENV); + &servant + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - servant_from_reference = forth_poa->reference_to_servant (obj.in (), - ACE_TRY_ENV); + servant_from_reference = forth_poa->reference_to_servant (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_ASSERT (servant_from_reference == &servant); - forth_poa->deactivate_object (id.in (), - ACE_TRY_ENV); + forth_poa->deactivate_object (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } } @@ -696,22 +696,22 @@ test_poas (CORBA::ORB_ptr orb, int main (int argc, char **argv) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { - CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, 0, - ACE_TRY_ENV); + CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Obtain the RootPOA. CORBA::Object_var obj = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - PortableServer::POA_var root_poa = PortableServer::POA::_narrow (obj.in (), - ACE_TRY_ENV); + PortableServer::POA_var root_poa = PortableServer::POA::_narrow (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; const TAO_Server_Strategy_Factory::Active_Object_Map_Creation_Parameters &creation_parameters @@ -729,8 +729,8 @@ main (int argc, char **argv) first_poa.out (), second_poa.out (), third_poa.out (), - forth_poa.out (), - ACE_TRY_ENV); + forth_poa.out () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; test_poas (orb.in (), @@ -739,28 +739,28 @@ main (int argc, char **argv) second_poa.in (), third_poa.in (), forth_poa.in (), - perform_deactivation_test, - ACE_TRY_ENV); + perform_deactivation_test + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; first_poa->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; second_poa->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; third_poa->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; forth_poa->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; create_poas (root_poa.in (), @@ -768,8 +768,8 @@ main (int argc, char **argv) first_poa.out (), second_poa.out (), third_poa.out (), - forth_poa.out (), - ACE_TRY_ENV); + forth_poa.out () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; test_poas (orb.in (), @@ -778,13 +778,13 @@ main (int argc, char **argv) second_poa.in (), third_poa.in (), forth_poa.in (), - perform_deactivation_test, - ACE_TRY_ENV); + perform_deactivation_test + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; root_poa->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/POA/Non_Servant_Upcalls/Non_Servant_Upcalls.cpp b/TAO/tests/POA/Non_Servant_Upcalls/Non_Servant_Upcalls.cpp index 431ca90b91b..1507a34bb43 100644 --- a/TAO/tests/POA/Non_Servant_Upcalls/Non_Servant_Upcalls.cpp +++ b/TAO/tests/POA/Non_Servant_Upcalls/Non_Servant_Upcalls.cpp @@ -51,17 +51,17 @@ test_i::~test_i (void) { ACE_TRY_NEW_ENV { - PortableServer::POA_var poa = this->_default_POA (ACE_TRY_ENV); + PortableServer::POA_var poa = this->_default_POA (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - PortableServer::ObjectId_var id = poa->servant_to_id (this->other_, - ACE_TRY_ENV); + PortableServer::ObjectId_var id = poa->servant_to_id (this->other_ + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "(%t) Deactivating other servant\n")); - poa->deactivate_object (id.in (), - ACE_TRY_ENV); + poa->deactivate_object (id.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -81,56 +81,56 @@ main (int argc, char **argv) // Initialize the ORB first. CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Obtain the RootPOA. CORBA::Object_var obj = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the POA_var object from Object_var. PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (obj.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the POAManager of the RootPOA. PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; test_i *servant1 = new test_i (0); test_i *servant2 = new test_i (servant1); PortableServer::ObjectId_var id1 = - root_poa->activate_object (servant1, - ACE_TRY_ENV); + root_poa->activate_object (servant1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Give ownership to POA. servant1->_remove_ref (); PortableServer::ObjectId_var id2 = - root_poa->activate_object (servant2, - ACE_TRY_ENV); + root_poa->activate_object (servant2 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Give ownership to POA. servant2->_remove_ref (); - root_poa->deactivate_object (id2.in (), - ACE_TRY_ENV); + root_poa->deactivate_object (id2.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; root_poa->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/POA/Object_Reactivation/Object_Reactivation.cpp b/TAO/tests/POA/Object_Reactivation/Object_Reactivation.cpp index 09f99b4856a..454cd4c1d5c 100644 --- a/TAO/tests/POA/Object_Reactivation/Object_Reactivation.cpp +++ b/TAO/tests/POA/Object_Reactivation/Object_Reactivation.cpp @@ -25,7 +25,7 @@ class test_i : public POA_test public: test_i (ACE_Auto_Event &event); - void deactivate_self (CORBA::Environment &ACE_TRY_ENV) + void deactivate_self (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: @@ -38,19 +38,19 @@ test_i::test_i (ACE_Auto_Event &event) } void -test_i::deactivate_self (CORBA::Environment &ACE_TRY_ENV) +test_i::deactivate_self (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - PortableServer::POA_var poa = this->_default_POA (ACE_TRY_ENV); + PortableServer::POA_var poa = this->_default_POA (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; - PortableServer::ObjectId_var id = poa->servant_to_id (this, - ACE_TRY_ENV); + PortableServer::ObjectId_var id = poa->servant_to_id (this + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "(%t) Deactivating servant\n")); - poa->deactivate_object (id.in (), - ACE_TRY_ENV); + poa->deactivate_object (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "(%t) Deactivation complete: signaling main thread and going to sleep\n")); @@ -113,15 +113,15 @@ Activator::svc (void) if (this->task_id_ == "first thread") { PortableServer::ObjectId_var id = - this->poa_->activate_object (this->servant_, - ACE_TRY_ENV); + this->poa_->activate_object (this->servant_ + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } else { this->poa_->activate_object_with_id (this->id_, - this->servant_, - ACE_TRY_ENV); + this->servant_ + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -157,7 +157,7 @@ Deactivator::svc (void) { ACE_TRY_NEW_ENV { - this->test_->deactivate_self (ACE_TRY_ENV); + this->test_->deactivate_self (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -173,35 +173,35 @@ Deactivator::svc (void) int main (int argc, char **argv) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { // Initialize the ORB first. CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Obtain the RootPOA. CORBA::Object_var obj = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the POA_var object from Object_var. PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (obj.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the POAManager of the RootPOA. PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_Auto_Event event1; @@ -210,10 +210,10 @@ main (int argc, char **argv) ACE_Auto_Event event2; test_i servant2 (event2); - test_var test_object1 = servant1._this (ACE_TRY_ENV); + test_var test_object1 = servant1._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - test_var test_object2 = servant2._this (ACE_TRY_ENV); + test_var test_object2 = servant2._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::ObjectId_var id1 = @@ -254,8 +254,8 @@ main (int argc, char **argv) return result; root_poa->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/POA/POA_Destruction/POA_Destruction.cpp b/TAO/tests/POA/POA_Destruction/POA_Destruction.cpp index ac5b10b626c..36800f959a1 100644 --- a/TAO/tests/POA/POA_Destruction/POA_Destruction.cpp +++ b/TAO/tests/POA/POA_Destruction/POA_Destruction.cpp @@ -22,65 +22,65 @@ class test_i : public POA_test { public: - void destroy_poa (CORBA::Environment &ACE_TRY_ENV) + void destroy_poa (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); }; void -test_i::destroy_poa (CORBA::Environment &ACE_TRY_ENV) +test_i::destroy_poa (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - PortableServer::POA_var poa = this->_default_POA (ACE_TRY_ENV); + PortableServer::POA_var poa = this->_default_POA (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::Boolean etherealize_objects = 1; CORBA::Boolean wait_for_completion = 0; poa->destroy (etherealize_objects, - wait_for_completion, - ACE_TRY_ENV); + wait_for_completion + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } int main (int argc, char **argv) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { // Initialize the ORB first. CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Obtain the RootPOA. CORBA::Object_var obj = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the POA_var object from Object_var. PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (obj.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the POAManager of the RootPOA. PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; test_i servant; - test_var test_object = servant._this (ACE_TRY_ENV); + test_var test_object = servant._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - test_object->destroy_poa (ACE_TRY_ENV); + test_object->destroy_poa (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/POA/Single_Threaded_POA/Single_Threaded_POA.cpp b/TAO/tests/POA/Single_Threaded_POA/Single_Threaded_POA.cpp index b6a0439899a..ecee66581cc 100644 --- a/TAO/tests/POA/Single_Threaded_POA/Single_Threaded_POA.cpp +++ b/TAO/tests/POA/Single_Threaded_POA/Single_Threaded_POA.cpp @@ -27,10 +27,10 @@ class test_i : public virtual POA_test public: test_i (PortableServer::POA_ptr poa); - void method (CORBA::Environment &ACE_TRY_ENV) + void method (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - PortableServer::POA_ptr _default_POA (CORBA_Environment &ACE_TRY_ENV); + PortableServer::POA_ptr _default_POA (TAO_ENV_SINGLE_ARG_DECL); private: PortableServer::POA_var poa_; @@ -44,7 +44,7 @@ test_i::test_i (PortableServer::POA_ptr poa) } void -test_i::method (CORBA::Environment &ACE_TRY_ENV) +test_i::method (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -62,16 +62,16 @@ test_i::method (CORBA::Environment &ACE_TRY_ENV) ACE_DEBUG ((LM_DEBUG, "Calling self from %t\n")); - test_var self = this->_this (ACE_TRY_ENV); + test_var self = this->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; - self->method (ACE_TRY_ENV); + self->method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; } } PortableServer::POA_ptr -test_i::_default_POA (CORBA_Environment &) +test_i::_default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) { return PortableServer::POA::_duplicate (this->poa_.in ()); } @@ -96,7 +96,7 @@ Worker::svc (void) { ACE_TRY_NEW_ENV { - this->test_->method (ACE_TRY_ENV); + this->test_->method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -117,23 +117,23 @@ main (int argc, char **argv) // Initialize the ORB first. CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Obtain the RootPOA. - CORBA::Object_var obj = orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + CORBA::Object_var obj = orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); // Get the POA_var object from Object_var. PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (obj.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the POAManager of the RootPOA. PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Policies for the new POA. @@ -141,21 +141,21 @@ main (int argc, char **argv) policies.length (2); policies[0] = - root_poa->create_implicit_activation_policy (PortableServer::IMPLICIT_ACTIVATION, - ACE_TRY_ENV); + root_poa->create_implicit_activation_policy (PortableServer::IMPLICIT_ACTIVATION + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; policies[1] = - root_poa->create_thread_policy (PortableServer::SINGLE_THREAD_MODEL, - ACE_TRY_ENV); + root_poa->create_thread_policy (PortableServer::SINGLE_THREAD_MODEL + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Creation of the child POA. PortableServer::POA_var child_poa = root_poa->create_POA ("child", poa_manager.in (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Destroy the policies @@ -163,20 +163,20 @@ main (int argc, char **argv) i < policies.length (); ++i) { - policies[i]->destroy (ACE_TRY_ENV); + policies[i]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; test_i servant1 (child_poa.in ()); test_i servant2 (child_poa.in ()); - test_var object1 = servant1._this (ACE_TRY_ENV); + test_var object1 = servant1._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - test_var object2 = servant2._this (ACE_TRY_ENV); + test_var object2 = servant2._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Worker worker1 (object1.in ()); @@ -194,8 +194,8 @@ main (int argc, char **argv) ACE_UNUSED_ARG (result); root_poa->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/POA/wait_for_completion/wait_for_completion.cpp b/TAO/tests/POA/wait_for_completion/wait_for_completion.cpp index 8cfb4941945..a6e778470ab 100644 --- a/TAO/tests/POA/wait_for_completion/wait_for_completion.cpp +++ b/TAO/tests/POA/wait_for_completion/wait_for_completion.cpp @@ -21,7 +21,7 @@ class test_i : public POA_test { public: - void destroy_poa (CORBA::Environment &ACE_TRY_ENV) + void destroy_poa (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); void test_poa (PortableServer::POA_ptr poa); @@ -36,48 +36,48 @@ test_i::test_poa (PortableServer::POA_ptr poa) } void -test_i::destroy_poa (CORBA::Environment &ACE_TRY_ENV) +test_i::destroy_poa (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { CORBA::Boolean etherealize_objects = 1; CORBA::Boolean wait_for_completion = 1; this->poa_->destroy (etherealize_objects, - wait_for_completion, - ACE_TRY_ENV); + wait_for_completion + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } PortableServer::POA_ptr init_orb (int argc, char **argv, - const char *orb_name, - CORBA::Environment &ACE_TRY_ENV) + const char *orb_name + TAO_ENV_ARG_DECL) { // Initialize the ORB first. CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - orb_name, - ACE_TRY_ENV); + orb_name + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (PortableServer::POA::_nil ()); // Obtain the RootPOA. CORBA::Object_var obj = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (PortableServer::POA::_nil ()); // Get the POA_var object from Object_var. PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (obj.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (PortableServer::POA::_nil ()); // Get the POAManager of the RootPOA. PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (PortableServer::POA::_nil ()); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (PortableServer::POA::_nil ()); return root_poa._retn (); @@ -87,26 +87,26 @@ int main (int argc, char **argv) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { PortableServer::POA_var first_poa = init_orb (argc, argv, - "first ORB", - ACE_TRY_ENV); + "first ORB" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var second_poa = init_orb (argc, argv, - "second ORB", - ACE_TRY_ENV); + "second ORB" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; test_i servant; - test_var test_object = servant._this (ACE_TRY_ENV); + test_var test_object = servant._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; int expected_exception_raised = 0; @@ -115,7 +115,7 @@ main (int argc, { servant.test_poa (first_poa.in ()); - test_object->destroy_poa (ACE_TRY_ENV); + test_object->destroy_poa (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK_EX (first_poa); } ACE_CATCH (CORBA::BAD_INV_ORDER, ex) @@ -140,10 +140,10 @@ main (int argc, servant.test_poa (second_poa.in ()); - test_object->destroy_poa (ACE_TRY_ENV); + test_object->destroy_poa (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - first_poa->destroy (1, 1, ACE_TRY_ENV); + first_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Param_Test/any.cpp b/TAO/tests/Param_Test/any.cpp index 045c618c27c..e12c722c98f 100644 --- a/TAO/tests/Param_Test/any.cpp +++ b/TAO/tests/Param_Test/any.cpp @@ -48,7 +48,7 @@ Test_Any::opname (void) const } void -Test_Any::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) +Test_Any::dii_req_invoke (CORBA::Request *req TAO_ENV_ARG_DECL) { req->add_in_arg ("o1") <<= this->in_; req->add_inout_arg ("o2") <<= this->inout_; @@ -56,7 +56,7 @@ Test_Any::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) req->set_return_type (CORBA::_tc_any); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; const CORBA::Any *tmp; @@ -64,13 +64,13 @@ Test_Any::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) this->ret_ = new CORBA::Any (*tmp); CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= tmp; this->inout_ = CORBA::Any (*tmp); CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= tmp; this->out_ = new CORBA::Any (*tmp); @@ -92,13 +92,13 @@ static const CORBA::TypeCode_ptr any_table [] = #endif /* any_table isn't currently used */ int -Test_Any::init_parameters (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Any::init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { // get access to a Coffee Object - this->cobj_ = objref->make_coffee (ACE_TRY_ENV); + this->cobj_ = objref->make_coffee (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; this->reset_parameters (); @@ -269,15 +269,15 @@ Test_Any::reset_parameters (void) } int -Test_Any::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Any::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { this->ret_ = objref->test_any (this->in_, this->inout_, - this->out_.out (), - ACE_TRY_ENV); + this->out_.out () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Param_Test/any.h b/TAO/tests/Param_Test/any.h index 921aa359526..713b16b4193 100644 --- a/TAO/tests/Param_Test/any.h +++ b/TAO/tests/Param_Test/any.h @@ -47,15 +47,15 @@ public: ANY_LAST_TEST_ITEM }; - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -70,7 +70,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/anyop.cpp b/TAO/tests/Param_Test/anyop.cpp index 5f142364b7a..ea71d452ae1 100644 --- a/TAO/tests/Param_Test/anyop.cpp +++ b/TAO/tests/Param_Test/anyop.cpp @@ -32,8 +32,8 @@ main (int argc, char *argv[]) { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_Get_Opt get_opt (argc, argv, "dn:l:"); @@ -90,13 +90,13 @@ main (int argc, char *argv[]) { CORBA::Object_var obj = - orb->string_to_object ("corbaloc:iiop:localhost:1234/Foo/Bar", - ACE_TRY_ENV); + orb->string_to_object ("corbaloc:iiop:localhost:1234/Foo/Bar" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Param_Test_var param_test = - Param_Test::_unchecked_narrow (obj.in (), - ACE_TRY_ENV); + Param_Test::_unchecked_narrow (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; TAO_Stub *stub = param_test->_stubobj (); stub->type_id = CORBA::string_dup ("IDL:Param_Test:1.0"); @@ -110,7 +110,7 @@ main (int argc, char *argv[]) "Cannot extract Param_Test (oh the horror)\n")); } CORBA::Boolean equiv = - param_test->_is_equivalent (o, ACE_TRY_ENV); + param_test->_is_equivalent (o TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (!equiv) { diff --git a/TAO/tests/Param_Test/bd_array_seq.cpp b/TAO/tests/Param_Test/bd_array_seq.cpp index c19db80d81b..1b7edb51d8e 100644 --- a/TAO/tests/Param_Test/bd_array_seq.cpp +++ b/TAO/tests/Param_Test/bd_array_seq.cpp @@ -48,15 +48,15 @@ Test_Bounded_Array_Sequence::opname (void) const } void -Test_Bounded_Array_Sequence::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Bounded_Array_Sequence::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_; req->add_inout_arg ("s2") <<= this->inout_.in (); req->add_out_arg ("s3") <<= this->out_.in (); req->set_return_type (Param_Test::_tc_Bounded_ArraySeq); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Param_Test::Bounded_ArraySeq *tmp; @@ -64,21 +64,21 @@ Test_Bounded_Array_Sequence::dii_req_invoke (CORBA::Request *req, this->ret_ = new Param_Test::Bounded_ArraySeq (*tmp); CORBA::NamedValue_ptr arg2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *arg2->value () >>= tmp; this->inout_ = new Param_Test::Bounded_ArraySeq (*tmp); CORBA::NamedValue_ptr arg3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *arg3->value () >>= tmp; this->out_ = new Param_Test::Bounded_ArraySeq (*tmp); } int -Test_Bounded_Array_Sequence::init_parameters (Param_Test_ptr, - CORBA::Environment &) +Test_Bounded_Array_Sequence::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { Generator *gen = GENERATOR::instance (); // value generator @@ -123,8 +123,8 @@ Test_Bounded_Array_Sequence::reset_parameters (void) } int -Test_Bounded_Array_Sequence::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Bounded_Array_Sequence::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -133,8 +133,8 @@ Test_Bounded_Array_Sequence::run_sii_test (Param_Test_ptr objref, this->ret_ = objref->test_bounded_array_sequence (this->in_, this->inout_.inout (), - out, - ACE_TRY_ENV); + out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/bd_array_seq.h b/TAO/tests/Param_Test/bd_array_seq.h index 411cf0ec1e1..23d342214a9 100644 --- a/TAO/tests/Param_Test/bd_array_seq.h +++ b/TAO/tests/Param_Test/bd_array_seq.h @@ -34,15 +34,15 @@ public: ~Test_Bounded_Array_Sequence (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -57,8 +57,8 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, - CORBA::Environment &); + void dii_req_invoke (CORBA::Request * + TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. protected: diff --git a/TAO/tests/Param_Test/bd_long_seq.cpp b/TAO/tests/Param_Test/bd_long_seq.cpp index eea7c524c9c..a32c2d50f10 100644 --- a/TAO/tests/Param_Test/bd_long_seq.cpp +++ b/TAO/tests/Param_Test/bd_long_seq.cpp @@ -47,15 +47,15 @@ Test_Bounded_Long_Sequence::opname (void) const } void -Test_Bounded_Long_Sequence::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Bounded_Long_Sequence::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_.in (); req->add_inout_arg ("s2") <<= this->inout_.in (); req->add_out_arg ("s3") <<= this->out_.in (); req->set_return_type (Param_Test::_tc_Bounded_Long_Seq); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; const Param_Test::Bounded_Long_Seq *tmp; @@ -63,21 +63,21 @@ Test_Bounded_Long_Sequence::dii_req_invoke (CORBA::Request *req, this->ret_ = new Param_Test::Bounded_Long_Seq (*tmp); CORBA::NamedValue_ptr arg2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *arg2->value () >>= tmp; this->inout_ = new Param_Test::Bounded_Long_Seq (*tmp); CORBA::NamedValue_ptr arg3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *arg3->value () >>= tmp; this->out_ = new Param_Test::Bounded_Long_Seq (*tmp); } int -Test_Bounded_Long_Sequence::init_parameters (Param_Test_ptr, - CORBA::Environment &) +Test_Bounded_Long_Sequence::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { // get some sequence length (32 in this case) CORBA::ULong len = this->in_->maximum (); @@ -114,16 +114,16 @@ Test_Bounded_Long_Sequence::reset_parameters (void) } int -Test_Bounded_Long_Sequence::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Bounded_Long_Sequence::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { Param_Test::Bounded_Long_Seq_out out (this->out_.out ()); this->ret_ = objref->test_bounded_long_sequence (this->in_.in (), this->inout_.inout (), - out, - ACE_TRY_ENV); + out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/bd_long_seq.h b/TAO/tests/Param_Test/bd_long_seq.h index 5dda51d2268..0809eb53f40 100644 --- a/TAO/tests/Param_Test/bd_long_seq.h +++ b/TAO/tests/Param_Test/bd_long_seq.h @@ -34,15 +34,15 @@ public: ~Test_Bounded_Long_Sequence (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -57,7 +57,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/bd_short_seq.cpp b/TAO/tests/Param_Test/bd_short_seq.cpp index 8d585809a4a..21836ba0f74 100644 --- a/TAO/tests/Param_Test/bd_short_seq.cpp +++ b/TAO/tests/Param_Test/bd_short_seq.cpp @@ -47,15 +47,15 @@ Test_Bounded_Short_Sequence::opname (void) const } void -Test_Bounded_Short_Sequence::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Bounded_Short_Sequence::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_.in (); req->add_inout_arg ("s2") <<= this->inout_.in (); req->add_out_arg ("s3") <<= this->out_.in (); req->set_return_type (Param_Test::_tc_Bounded_Short_Seq); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Param_Test::Bounded_Short_Seq *tmp; @@ -63,24 +63,23 @@ Test_Bounded_Short_Sequence::dii_req_invoke (CORBA::Request *req, this->ret_ = new Param_Test::Bounded_Short_Seq (*tmp); CORBA::NamedValue_ptr arg2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *arg2->value () >>= tmp; this->inout_ = new Param_Test::Bounded_Short_Seq (*tmp); CORBA::NamedValue_ptr arg3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *arg3->value () >>= tmp; this->out_ = new Param_Test::Bounded_Short_Seq (*tmp); } int -Test_Bounded_Short_Sequence::init_parameters (Param_Test_ptr /*objref*/, - CORBA::Environment & /*env*/) +Test_Bounded_Short_Sequence::init_parameters (Param_Test_ptr /*objref*/ + TAO_ENV_ARG_DECL_NOT_USED /*env*/) { // ACE_UNUSED_ARG (objref); - // ACE_UNUSED_ARG (env); // get some sequence length (32 in this case) CORBA::ULong len = this->in_->maximum (); @@ -119,8 +118,8 @@ Test_Bounded_Short_Sequence::reset_parameters (void) } int -Test_Bounded_Short_Sequence::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Bounded_Short_Sequence::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -128,8 +127,8 @@ Test_Bounded_Short_Sequence::run_sii_test (Param_Test_ptr objref, this->ret_ = objref->test_bounded_short_sequence (this->in_.in (), this->inout_.inout (), - out, - ACE_TRY_ENV); + out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/bd_short_seq.h b/TAO/tests/Param_Test/bd_short_seq.h index 5efe29e22a6..54831453981 100644 --- a/TAO/tests/Param_Test/bd_short_seq.h +++ b/TAO/tests/Param_Test/bd_short_seq.h @@ -34,15 +34,15 @@ public: ~Test_Bounded_Short_Sequence (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -57,7 +57,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/bd_str_seq.cpp b/TAO/tests/Param_Test/bd_str_seq.cpp index bd9aae472bd..3df97b029d1 100644 --- a/TAO/tests/Param_Test/bd_str_seq.cpp +++ b/TAO/tests/Param_Test/bd_str_seq.cpp @@ -47,8 +47,8 @@ Test_Bounded_String_Sequence::opname (void) const } void -Test_Bounded_String_Sequence::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Bounded_String_Sequence::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_.in (); req->add_inout_arg ("s2") <<= this->inout_.in (); @@ -56,7 +56,7 @@ Test_Bounded_String_Sequence::dii_req_invoke (CORBA::Request *req, req->set_return_type (Param_Test::_tc_Bounded_StrSeq); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; const Param_Test::Bounded_StrSeq *tmp; @@ -64,21 +64,21 @@ Test_Bounded_String_Sequence::dii_req_invoke (CORBA::Request *req, this->ret_ = new Param_Test::Bounded_StrSeq (*tmp); CORBA::NamedValue_ptr arg2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *arg2->value () >>= tmp; this->inout_ = new Param_Test::Bounded_StrSeq (*tmp); CORBA::NamedValue_ptr arg3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *arg3->value () >>= tmp; this->out_ = new Param_Test::Bounded_StrSeq (*tmp); } int -Test_Bounded_String_Sequence::init_parameters (Param_Test_ptr , - CORBA::Environment &) +Test_Bounded_String_Sequence::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { const char *choiceList[] = { @@ -111,8 +111,8 @@ Test_Bounded_String_Sequence::reset_parameters (void) } int -Test_Bounded_String_Sequence::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Bounded_String_Sequence::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -120,8 +120,8 @@ Test_Bounded_String_Sequence::run_sii_test (Param_Test_ptr objref, this->ret_ = objref->test_bounded_strseq (this->in_.in (), this->inout_.inout (), - out, - ACE_TRY_ENV); + out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/bd_str_seq.h b/TAO/tests/Param_Test/bd_str_seq.h index 48b60f9366b..9b6d776d2d0 100644 --- a/TAO/tests/Param_Test/bd_str_seq.h +++ b/TAO/tests/Param_Test/bd_str_seq.h @@ -34,15 +34,15 @@ public: ~Test_Bounded_String_Sequence (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -57,7 +57,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/bd_string.cpp b/TAO/tests/Param_Test/bd_string.cpp index aa2a1418189..88bce95539d 100644 --- a/TAO/tests/Param_Test/bd_string.cpp +++ b/TAO/tests/Param_Test/bd_string.cpp @@ -55,8 +55,8 @@ Test_Bounded_String::opname (void) const } void -Test_Bounded_String::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Bounded_String::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= CORBA::Any::from_string (this->in_, 128); req->add_inout_arg ("s2") <<= CORBA::Any::from_string (this->inout_, 128); @@ -67,7 +67,7 @@ Test_Bounded_String::dii_req_invoke (CORBA::Request *req, req->set_return_type (Param_Test::_tc_short_string); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; char *tmp; @@ -75,21 +75,21 @@ Test_Bounded_String::dii_req_invoke (CORBA::Request *req, this->ret_ = CORBA::string_dup (tmp); CORBA::NamedValue_ptr arg2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *arg2->value () >>= CORBA::Any::to_string (tmp, 128); this->inout_ = CORBA::string_dup (tmp); CORBA::NamedValue_ptr arg3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *arg3->value () >>= CORBA::Any::to_string (tmp, 128); this->out_ = CORBA::string_dup (tmp); } int -Test_Bounded_String::init_parameters (Param_Test_ptr, - CORBA::Environment &) +Test_Bounded_String::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { Generator *gen = GENERATOR::instance (); // value generator @@ -124,8 +124,8 @@ Test_Bounded_String::reset_parameters (void) } int -Test_Bounded_String::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Bounded_String::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -133,8 +133,8 @@ Test_Bounded_String::run_sii_test (Param_Test_ptr objref, this->ret_ = objref->test_bounded_string (this->in_, this->inout_, - str_out, - ACE_TRY_ENV); + str_out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/bd_string.h b/TAO/tests/Param_Test/bd_string.h index 46291917900..444ec8df45a 100644 --- a/TAO/tests/Param_Test/bd_string.h +++ b/TAO/tests/Param_Test/bd_string.h @@ -33,15 +33,15 @@ public: ~Test_Bounded_String (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -56,7 +56,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/bd_struct_seq.cpp b/TAO/tests/Param_Test/bd_struct_seq.cpp index 4671053d08f..3666187016c 100644 --- a/TAO/tests/Param_Test/bd_struct_seq.cpp +++ b/TAO/tests/Param_Test/bd_struct_seq.cpp @@ -50,15 +50,15 @@ Test_Bounded_Struct_Sequence::opname (void) const } void -Test_Bounded_Struct_Sequence::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Bounded_Struct_Sequence::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_; req->add_inout_arg ("s2") <<= this->inout_.in (); req->add_out_arg ("s3") <<= this->out_.in (); req->set_return_type (Param_Test::_tc_Bounded_StructSeq); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Param_Test::Bounded_StructSeq *tmp; @@ -66,21 +66,21 @@ Test_Bounded_Struct_Sequence::dii_req_invoke (CORBA::Request *req, this->ret_ = new Param_Test::Bounded_StructSeq (*tmp); CORBA::NamedValue_ptr arg2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *arg2->value () >>= tmp; this->inout_ = new Param_Test::Bounded_StructSeq (*tmp); CORBA::NamedValue_ptr arg3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *arg3->value () >>= tmp; this->out_ = new Param_Test::Bounded_StructSeq (*tmp); } int -Test_Bounded_Struct_Sequence::init_parameters (Param_Test_ptr /* objref */, - CORBA::Environment & /* env */) +Test_Bounded_Struct_Sequence::init_parameters (Param_Test_ptr /* objref */ + TAO_ENV_ARG_DECL_NOT_USED /* env */) { Generator *gen = GENERATOR::instance (); // value generator @@ -116,8 +116,8 @@ Test_Bounded_Struct_Sequence::reset_parameters (void) } int -Test_Bounded_Struct_Sequence::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Bounded_Struct_Sequence::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -125,8 +125,8 @@ Test_Bounded_Struct_Sequence::run_sii_test (Param_Test_ptr objref, this->ret_ = objref->test_bounded_struct_sequence (this->in_, this->inout_.inout (), - out, - ACE_TRY_ENV); + out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/bd_struct_seq.h b/TAO/tests/Param_Test/bd_struct_seq.h index a8ce07bd760..d06ff51c1c8 100644 --- a/TAO/tests/Param_Test/bd_struct_seq.h +++ b/TAO/tests/Param_Test/bd_struct_seq.h @@ -34,15 +34,15 @@ public: ~Test_Bounded_Struct_Sequence (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -57,7 +57,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. protected: diff --git a/TAO/tests/Param_Test/bd_wstr_seq.cpp b/TAO/tests/Param_Test/bd_wstr_seq.cpp index 2ba77400d20..a0b9ae9d756 100644 --- a/TAO/tests/Param_Test/bd_wstr_seq.cpp +++ b/TAO/tests/Param_Test/bd_wstr_seq.cpp @@ -47,8 +47,8 @@ Test_Bounded_WString_Sequence::opname (void) const } void -Test_Bounded_WString_Sequence::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Bounded_WString_Sequence::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_.in (); req->add_inout_arg ("s2") <<= this->inout_.in (); @@ -56,7 +56,7 @@ Test_Bounded_WString_Sequence::dii_req_invoke (CORBA::Request *req, req->set_return_type (Param_Test::_tc_Bounded_WStrSeq); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; const Param_Test::Bounded_WStrSeq *tmp; @@ -64,21 +64,21 @@ Test_Bounded_WString_Sequence::dii_req_invoke (CORBA::Request *req, this->ret_ = new Param_Test::Bounded_WStrSeq (*tmp); CORBA::NamedValue_ptr arg2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *arg2->value () >>= tmp; this->inout_ = new Param_Test::Bounded_WStrSeq (*tmp); CORBA::NamedValue_ptr arg3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *arg3->value () >>= tmp; this->out_ = new Param_Test::Bounded_WStrSeq (*tmp); } int -Test_Bounded_WString_Sequence::init_parameters (Param_Test_ptr , - CORBA::Environment &) +Test_Bounded_WString_Sequence::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { Generator *gen = GENERATOR::instance (); // value generator @@ -93,7 +93,7 @@ Test_Bounded_WString_Sequence::init_parameters (Param_Test_ptr , { this->in_[i] = gen->gen_wstring (); - // different from in_ + // different from in_ this->inout_[i] = gen->gen_wstring (); } @@ -110,8 +110,8 @@ Test_Bounded_WString_Sequence::reset_parameters (void) } int -Test_Bounded_WString_Sequence::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Bounded_WString_Sequence::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -119,8 +119,8 @@ Test_Bounded_WString_Sequence::run_sii_test (Param_Test_ptr objref, this->ret_ = objref->test_bounded_wstrseq (this->in_.in (), this->inout_.inout (), - out, - ACE_TRY_ENV); + out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/bd_wstr_seq.h b/TAO/tests/Param_Test/bd_wstr_seq.h index 108d53a4057..83c00d2f8a5 100644 --- a/TAO/tests/Param_Test/bd_wstr_seq.h +++ b/TAO/tests/Param_Test/bd_wstr_seq.h @@ -34,15 +34,15 @@ public: ~Test_Bounded_WString_Sequence (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -57,8 +57,8 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, - CORBA::Environment &); + void dii_req_invoke (CORBA::Request * + TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/bd_wstring.cpp b/TAO/tests/Param_Test/bd_wstring.cpp index 5c02052a481..3100895a2b7 100644 --- a/TAO/tests/Param_Test/bd_wstring.cpp +++ b/TAO/tests/Param_Test/bd_wstring.cpp @@ -55,8 +55,8 @@ Test_Bounded_WString::opname (void) const } void -Test_Bounded_WString::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Bounded_WString::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= CORBA::Any::from_wstring (this->in_, 128); req->add_inout_arg ("s2") <<= CORBA::Any::from_wstring (this->inout_, 128); @@ -67,7 +67,7 @@ Test_Bounded_WString::dii_req_invoke (CORBA::Request *req, req->set_return_type (Param_Test::_tc_short_wstring); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::WChar *tmp; @@ -75,21 +75,21 @@ Test_Bounded_WString::dii_req_invoke (CORBA::Request *req, this->ret_ = CORBA::wstring_dup (tmp); CORBA::NamedValue_ptr arg2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *arg2->value () >>= CORBA::Any::to_wstring (tmp, 128); this->inout_ = CORBA::wstring_dup (tmp); CORBA::NamedValue_ptr arg3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *arg3->value () >>= CORBA::Any::to_wstring (tmp, 128); this->out_ = CORBA::wstring_dup (tmp); } int -Test_Bounded_WString::init_parameters (Param_Test_ptr, - CORBA::Environment &) +Test_Bounded_WString::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { Generator *gen = GENERATOR::instance (); // value generator @@ -124,8 +124,8 @@ Test_Bounded_WString::reset_parameters (void) } int -Test_Bounded_WString::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Bounded_WString::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -133,8 +133,8 @@ Test_Bounded_WString::run_sii_test (Param_Test_ptr objref, this->ret_ = objref->test_bounded_wstring (this->in_, this->inout_, - str_out, - ACE_TRY_ENV); + str_out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/bd_wstring.h b/TAO/tests/Param_Test/bd_wstring.h index 8e864ce6f32..8a54c8df633 100644 --- a/TAO/tests/Param_Test/bd_wstring.h +++ b/TAO/tests/Param_Test/bd_wstring.h @@ -33,15 +33,15 @@ public: ~Test_Bounded_WString (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -56,8 +56,8 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, - CORBA::Environment &); + void dii_req_invoke (CORBA::Request * + TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/big_union.cpp b/TAO/tests/Param_Test/big_union.cpp index c91ebfdb755..0cb0f5589af 100644 --- a/TAO/tests/Param_Test/big_union.cpp +++ b/TAO/tests/Param_Test/big_union.cpp @@ -45,8 +45,8 @@ Test_Big_Union::opname (void) const } void -Test_Big_Union::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Big_Union::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_; req->add_inout_arg ("s2") <<= this->inout_; @@ -54,7 +54,7 @@ Test_Big_Union::dii_req_invoke (CORBA::Request *req, req->set_return_type (Param_Test::_tc_Big_Union); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Param_Test::Big_Union *tmp; @@ -62,26 +62,26 @@ Test_Big_Union::dii_req_invoke (CORBA::Request *req, this->ret_ = new Param_Test::Big_Union (*tmp); CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= tmp; this->inout_ = *tmp; CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= tmp; this->out_ = new Param_Test::Big_Union (*tmp); } int -Test_Big_Union::init_parameters (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Big_Union::init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { // get access to a Coffee Object - this->cobj_ = objref->make_coffee (ACE_TRY_ENV); + this->cobj_ = objref->make_coffee (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; this->reset_parameters (); @@ -228,15 +228,15 @@ Test_Big_Union::reset_parameters (void) } int -Test_Big_Union::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Big_Union::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { this->ret_ = objref->test_big_union (this->in_, this->inout_, - this->out_, - ACE_TRY_ENV); + this->out_ + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; @@ -286,7 +286,7 @@ Test_Big_Union::check_validity (void) break; case 1: { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { Coffee_ptr in = this->in_.the_interface (); @@ -301,16 +301,16 @@ Test_Big_Union::check_validity (void) return 0; Coffee::Desc_var in_desc = - in->description (ACE_TRY_ENV); + in->description (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Coffee::Desc_var inout_desc = - inout->description (ACE_TRY_ENV); + inout->description (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Coffee::Desc_var out_desc = - out->description (ACE_TRY_ENV); + out->description (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Coffee::Desc_var ret_desc = - ret->description (ACE_TRY_ENV); + ret->description (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (ACE_OS::strcmp (in_desc->name.in (), diff --git a/TAO/tests/Param_Test/big_union.h b/TAO/tests/Param_Test/big_union.h index e92b00b0046..08e5a702396 100644 --- a/TAO/tests/Param_Test/big_union.h +++ b/TAO/tests/Param_Test/big_union.h @@ -37,15 +37,15 @@ public: BIG_UNION_N_BRANCHES = 12 }; - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -60,7 +60,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/client.cpp b/TAO/tests/Param_Test/client.cpp index 1b62f5ffd33..3fe60d6cd70 100644 --- a/TAO/tests/Param_Test/client.cpp +++ b/TAO/tests/Param_Test/client.cpp @@ -65,10 +65,10 @@ Param_Test_Client<T>::run_sii_test (void) this->results_.iterations (opt->loop_count ()); // Declare the Env - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; // Initialize parameters for the test. - int check = this->test_object_->init_parameters (this->param_test_, - ACE_TRY_ENV); + int check = this->test_object_->init_parameters (this->param_test_ + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (check == -1) @@ -97,8 +97,8 @@ Param_Test_Client<T>::run_sii_test (void) this->results_.start_timer (); // make the call - this->test_object_->run_sii_test (this->param_test_, - ACE_TRY_ENV); + this->test_object_->run_sii_test (this->param_test_ + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // stop the timer. @@ -178,10 +178,10 @@ Param_Test_Client<T>::run_dii_test (void) this->results_.iterations (opt->loop_count ()); // Environment variable - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; // initialize parameters for the test - int check = this->test_object_->init_parameters (this->param_test_, - ACE_TRY_ENV); + int check = this->test_object_->init_parameters (this->param_test_ + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (check == -1) @@ -207,8 +207,8 @@ Param_Test_Client<T>::run_dii_test (void) ACE_TRY { - req = this->param_test_->_request (opname, - ACE_TRY_ENV); + req = this->param_test_->_request (opname + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (opt->debug ()) @@ -218,8 +218,8 @@ Param_Test_Client<T>::run_dii_test (void) } // Make the invocation, verify the result. - this->test_object_->dii_req_invoke (req.in (), - ACE_TRY_ENV); + this->test_object_->dii_req_invoke (req.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Param_Test/complex_any.cpp b/TAO/tests/Param_Test/complex_any.cpp index d3050e2852e..d3d621880fe 100644 --- a/TAO/tests/Param_Test/complex_any.cpp +++ b/TAO/tests/Param_Test/complex_any.cpp @@ -51,8 +51,8 @@ Test_Complex_Any::opname (void) const } void -Test_Complex_Any::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Complex_Any::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_; req->add_inout_arg ("s2") <<= this->inout_; @@ -60,7 +60,7 @@ Test_Complex_Any::dii_req_invoke (CORBA::Request *req, req->set_return_type (CORBA::_tc_any); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; const CORBA::Any *tmp; @@ -68,21 +68,21 @@ Test_Complex_Any::dii_req_invoke (CORBA::Request *req, this->ret_ = new CORBA::Any (*tmp); CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= tmp; this->inout_ = CORBA::Any (*tmp); CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= tmp; this->out_ = new CORBA::Any (*tmp); } int -Test_Complex_Any::init_parameters (Param_Test_ptr, - CORBA::Environment &) +Test_Complex_Any::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { return this->reset_parameters (); } @@ -167,15 +167,15 @@ Test_Complex_Any::reset_parameters (void) } int -Test_Complex_Any::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Complex_Any::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { this->ret_ = objref->test_complex_any (this->in_, this->inout_, - this->out_.out (), - ACE_TRY_ENV); + this->out_.out () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Param_Test/complex_any.h b/TAO/tests/Param_Test/complex_any.h index 026d441ab22..088e9fdeea7 100644 --- a/TAO/tests/Param_Test/complex_any.h +++ b/TAO/tests/Param_Test/complex_any.h @@ -33,15 +33,15 @@ public: ~Test_Complex_Any (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -56,7 +56,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/driver.cpp b/TAO/tests/Param_Test/driver.cpp index 645cf856148..cac0b11e525 100644 --- a/TAO/tests/Param_Test/driver.cpp +++ b/TAO/tests/Param_Test/driver.cpp @@ -61,8 +61,7 @@ int Driver::init (int argc, char **argv) { // environment to track exceptions - ACE_DECLARE_NEW_CORBA_ENV; - //CORBA::Environment env; + TAO_ENV_DECLARE_NEW_ENV; // retrieve the instance of Options Options *opt = OPTIONS::instance (); @@ -76,8 +75,8 @@ Driver::init (int argc, char **argv) // Retrieve the underlying ORB this->orb_ = CORBA::ORB_init (argc, argv, - "internet", - ACE_TRY_ENV); + "internet" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Parse command line and verify parameters. @@ -90,7 +89,7 @@ Driver::init (int argc, char **argv) ACE_OS::strcpy (exception_string,"ORB::string_to_object() failed."); CORBA::Object_var temp = - this->orb_->string_to_object (opt->param_test_ior (), ACE_TRY_ENV); + this->orb_->string_to_object (opt->param_test_ior () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; @@ -103,7 +102,7 @@ Driver::init (int argc, char **argv) // Get the object reference ACE_OS::strcpy (exception_string,"Param_Test::_narrow () failed."); - this->objref_ = Param_Test::_narrow (temp.in(), ACE_TRY_ENV); + this->objref_ = Param_Test::_narrow (temp.in() TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -614,12 +613,12 @@ Driver::run (void) } // Get in a new environment variable - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { if (opt->shutdown ()) { - this->objref_->shutdown (ACE_TRY_ENV); + this->objref_->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/tests/Param_Test/except.cpp b/TAO/tests/Param_Test/except.cpp index eec0aa7823f..5d2b8a77165 100644 --- a/TAO/tests/Param_Test/except.cpp +++ b/TAO/tests/Param_Test/except.cpp @@ -47,8 +47,8 @@ Test_Exception::opname (void) const } void -Test_Exception::dii_req_invoke (CORBA::Request_ptr req, - CORBA::Environment &ACE_TRY_ENV) +Test_Exception::dii_req_invoke (CORBA::Request_ptr req + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -61,18 +61,18 @@ Test_Exception::dii_req_invoke (CORBA::Request_ptr req, req->exceptions ()->add (CORBA::TypeCode::_duplicate (Param_Test::_tc_Ooops)); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; req->return_value () >>= this->ret_; CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= this->inout_; CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= this->out_; } @@ -131,8 +131,8 @@ Test_Exception::dii_req_invoke (CORBA::Request_ptr req, } int -Test_Exception::init_parameters (Param_Test_ptr, - CORBA::Environment &) +Test_Exception::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { Generator *gen = GENERATOR::instance (); // value generator @@ -151,16 +151,16 @@ Test_Exception::reset_parameters (void) } int -Test_Exception::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Exception::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { this->in_++; this->ret_ = objref->test_exception (this->in_, this->inout_, - this->out_, - ACE_TRY_ENV); + this->out_ + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (Param_Test::Ooops, ex) diff --git a/TAO/tests/Param_Test/except.h b/TAO/tests/Param_Test/except.h index fb85e1d71cc..ba7c1d9260a 100644 --- a/TAO/tests/Param_Test/except.h +++ b/TAO/tests/Param_Test/except.h @@ -30,15 +30,15 @@ public: ~Test_Exception (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -53,7 +53,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/fixed_array.cpp b/TAO/tests/Param_Test/fixed_array.cpp index cad9afe1d72..b34cdbd5e46 100644 --- a/TAO/tests/Param_Test/fixed_array.cpp +++ b/TAO/tests/Param_Test/fixed_array.cpp @@ -44,15 +44,15 @@ Test_Fixed_Array::opname (void) const } void -Test_Fixed_Array::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Fixed_Array::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= Param_Test::Fixed_Array_forany (this->in_); req->add_inout_arg ("s2") <<= Param_Test::Fixed_Array_forany (this->inout_); req->add_out_arg ("s3") <<= Param_Test::Fixed_Array_forany (this->out_); req->set_return_type (Param_Test::_tc_Fixed_Array); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Param_Test::Fixed_Array_forany forany; @@ -60,13 +60,13 @@ Test_Fixed_Array::dii_req_invoke (CORBA::Request *req, Param_Test::Fixed_Array_copy (this->ret_, forany.in ()); CORBA::NamedValue_ptr arg2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *arg2->value () >>= forany; Param_Test::Fixed_Array_copy (this->inout_, forany.in ()); CORBA::NamedValue_ptr arg3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; Param_Test::Fixed_Array_forany out_any (this->out_); *arg3->value () >>= forany; @@ -74,13 +74,12 @@ Test_Fixed_Array::dii_req_invoke (CORBA::Request *req, } int -Test_Fixed_Array::init_parameters (Param_Test_ptr /*objref*/, - CORBA::Environment &/*env*/) +Test_Fixed_Array::init_parameters (Param_Test_ptr /*objref*/ + TAO_ENV_ARG_DECL_NOT_USED/*env*/) { Generator *gen = GENERATOR::instance (); // value generator //ACE_UNUSED_ARG (objref); - //ACE_UNUSED_ARG (env); for (CORBA::ULong i=0; i < Param_Test::DIM1; i++) { @@ -107,15 +106,15 @@ Test_Fixed_Array::reset_parameters (void) } int -Test_Fixed_Array::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Fixed_Array::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { this->ret_ = objref->test_fixed_array (this->in_, this->inout_, - this->out_, - ACE_TRY_ENV); + this->out_ + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/fixed_array.h b/TAO/tests/Param_Test/fixed_array.h index 51cb8d1753d..c885b66f58e 100644 --- a/TAO/tests/Param_Test/fixed_array.h +++ b/TAO/tests/Param_Test/fixed_array.h @@ -33,15 +33,15 @@ public: ~Test_Fixed_Array (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -56,7 +56,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/fixed_struct.cpp b/TAO/tests/Param_Test/fixed_struct.cpp index d185f868fe0..46e87cc5b66 100644 --- a/TAO/tests/Param_Test/fixed_struct.cpp +++ b/TAO/tests/Param_Test/fixed_struct.cpp @@ -43,15 +43,15 @@ Test_Fixed_Struct::opname (void) const } void -Test_Fixed_Struct::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Fixed_Struct::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_; req->add_inout_arg ("s2") <<= this->inout_; req->add_out_arg ("s3") <<= this->out_; req->set_return_type (Param_Test::_tc_Fixed_Struct); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Param_Test::Fixed_Struct *tmp; @@ -59,26 +59,25 @@ Test_Fixed_Struct::dii_req_invoke (CORBA::Request *req, this->ret_ = *tmp; CORBA::NamedValue_ptr arg2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *arg2->value () >>= tmp; this->inout_ = *tmp; CORBA::NamedValue_ptr arg3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *arg3->value () >>= tmp; this->out_ = *tmp; } int -Test_Fixed_Struct::init_parameters (Param_Test_ptr /*objref*/, - CORBA::Environment &/*env*/) +Test_Fixed_Struct::init_parameters (Param_Test_ptr /*objref*/ + TAO_ENV_ARG_DECL_NOT_USED/*env*/) { Generator *gen = GENERATOR::instance (); // value generator //ACE_UNUSED_ARG (objref); - //ACE_UNUSED_ARG (env); this->in_ = gen->gen_fixed_struct (); ACE_OS::memset (&this->inout_, @@ -106,15 +105,15 @@ Test_Fixed_Struct::reset_parameters (void) } int -Test_Fixed_Struct::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Fixed_Struct::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { this->ret_ = objref->test_fixed_struct (this->in_, this->inout_, - this->out_, - ACE_TRY_ENV); + this->out_ + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/fixed_struct.h b/TAO/tests/Param_Test/fixed_struct.h index 81ec824b4a7..aeef44761a5 100644 --- a/TAO/tests/Param_Test/fixed_struct.h +++ b/TAO/tests/Param_Test/fixed_struct.h @@ -33,15 +33,15 @@ public: ~Test_Fixed_Struct (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -56,7 +56,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/multdim_array.cpp b/TAO/tests/Param_Test/multdim_array.cpp index b17e6e302b2..6dd783bf1e5 100644 --- a/TAO/tests/Param_Test/multdim_array.cpp +++ b/TAO/tests/Param_Test/multdim_array.cpp @@ -46,8 +46,8 @@ Test_Multdim_Array::opname (void) const } void -Test_Multdim_Array::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Multdim_Array::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= Param_Test::Multdim_Array_forany (this->in_.inout ()); req->add_inout_arg ("s2") <<= Param_Test::Multdim_Array_forany (this->inout_.inout ()); @@ -55,7 +55,7 @@ Test_Multdim_Array::dii_req_invoke (CORBA::Request *req, req->set_return_type (Param_Test::_tc_Multdim_Array); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; @@ -64,21 +64,21 @@ Test_Multdim_Array::dii_req_invoke (CORBA::Request *req, Param_Test::Multdim_Array_copy (this->ret_, forany.in ()); CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= forany; Param_Test::Multdim_Array_copy (this->inout_, forany.in ()); CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= forany; Param_Test::Multdim_Array_copy (this->out_, forany.in ()); } int -Test_Multdim_Array::init_parameters (Param_Test_ptr /*objref*/, - CORBA::Environment &/*env*/) +Test_Multdim_Array::init_parameters (Param_Test_ptr /*objref*/ + TAO_ENV_ARG_DECL_NOT_USED/*env*/) { Generator *gen = GENERATOR::instance (); // value generator @@ -133,14 +133,25 @@ Test_Multdim_Array::reset_parameters (void) } int -Test_Multdim_Array::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Multdim_Array::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { - this->ret_ = objref->test_multdim_array (this->in_.in (), - this->inout_.inout (), - this->out_.inout (), - ACE_TRY_ENV); - return (ACE_TRY_ENV.exception () ? -1:0); + ACE_TRY + { + this->ret_ = objref->test_multdim_array (this->in_.in (), + this->inout_.inout (), + this->out_.inout () + TAO_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + return 0; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Test_Multdim_Array::run_sii_test\n"); + } + ACE_ENDTRY; + return -1; } CORBA::Boolean diff --git a/TAO/tests/Param_Test/multdim_array.h b/TAO/tests/Param_Test/multdim_array.h index 2f8afdce885..65f04d5b2f5 100644 --- a/TAO/tests/Param_Test/multdim_array.h +++ b/TAO/tests/Param_Test/multdim_array.h @@ -33,15 +33,15 @@ public: ~Test_Multdim_Array (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -56,7 +56,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/nested_struct.cpp b/TAO/tests/Param_Test/nested_struct.cpp index 0bb1ad2adba..022c4fb538f 100644 --- a/TAO/tests/Param_Test/nested_struct.cpp +++ b/TAO/tests/Param_Test/nested_struct.cpp @@ -48,14 +48,14 @@ Test_Nested_Struct::opname (void) const } void -Test_Nested_Struct::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE_TRY_ENV) +Test_Nested_Struct::dii_req_invoke (CORBA::Request *req TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_; req->add_inout_arg ("s2") <<= this->inout_.in (); req->add_out_arg ("s3") <<= this->out_.in (); req->set_return_type (Param_Test::_tc_Nested_Struct); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Param_Test::Nested_Struct *tmp; @@ -63,21 +63,21 @@ Test_Nested_Struct::dii_req_invoke (CORBA::Request *req, CORBA::Environment &ACE this->ret_ = new Param_Test::Nested_Struct (*tmp); CORBA::NamedValue_ptr arg2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *arg2->value () >>= tmp; this->inout_ = new Param_Test::Nested_Struct (*tmp); CORBA::NamedValue_ptr arg3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *arg3->value () >>= tmp; this->out_ = new Param_Test::Nested_Struct (*tmp); } int -Test_Nested_Struct::init_parameters (Param_Test_ptr, - CORBA::Environment &) +Test_Nested_Struct::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { Generator *gen = GENERATOR::instance (); // value generator @@ -130,16 +130,16 @@ Test_Nested_Struct::reset_parameters (void) } int -Test_Nested_Struct::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Nested_Struct::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { Param_Test::Nested_Struct_out out (this->out_.out ()); this->ret_ = objref->test_nested_struct (this->in_, this->inout_.inout (), - out, - ACE_TRY_ENV); + out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/nested_struct.h b/TAO/tests/Param_Test/nested_struct.h index cbd260906ab..c90edc3a437 100644 --- a/TAO/tests/Param_Test/nested_struct.h +++ b/TAO/tests/Param_Test/nested_struct.h @@ -34,15 +34,15 @@ public: ~Test_Nested_Struct (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -57,7 +57,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/objref.cpp b/TAO/tests/Param_Test/objref.cpp index 9ef81ab4216..128959dfed3 100644 --- a/TAO/tests/Param_Test/objref.cpp +++ b/TAO/tests/Param_Test/objref.cpp @@ -43,8 +43,8 @@ Test_ObjRef::opname (void) const } void -Test_ObjRef::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_ObjRef::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_.in (); req->add_inout_arg ("s2") <<= this->inout_.in (); @@ -52,7 +52,7 @@ Test_ObjRef::dii_req_invoke (CORBA::Request *req, req->set_return_type (_tc_Coffee); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Coffee_ptr tmp; @@ -60,13 +60,13 @@ Test_ObjRef::dii_req_invoke (CORBA::Request *req, this->ret_ = Coffee::_duplicate (tmp); CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= tmp; this->inout_ = Coffee::_duplicate (tmp); CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= tmp; this->out_ = Coffee::_duplicate (tmp); @@ -82,13 +82,12 @@ static const char *Coffee_Flavor [] = { }; int -Test_ObjRef::init_parameters (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_ObjRef::init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { Coffee::Desc desc; Generator *gen = GENERATOR::instance (); // value generator - // New environment variable char msg_str[256] = ""; ACE_TRY @@ -96,7 +95,7 @@ Test_ObjRef::init_parameters (Param_Test_ptr objref, ACE_OS::strcpy (msg_str, "make_cofee"); // first get a Coffee object - this->in_ = objref->make_coffee (ACE_TRY_ENV); + this->in_ = objref->make_coffee (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Get some index into Coffee_Flavor []. @@ -105,7 +104,7 @@ Test_ObjRef::init_parameters (Param_Test_ptr objref, // set the attribute of the object ACE_OS::strcpy (msg_str, "set coffee attribute"); - this->in_->description (desc, ACE_TRY_ENV); // set the attribute for the in object + this->in_->description (desc TAO_ENV_ARG_PARAMETER); // set the attribute for the in object ACE_TRY_CHECK; this->inout_ = Coffee::_nil (); @@ -126,8 +125,7 @@ int Test_ObjRef::reset_parameters (void) { // Environemnt variable - ACE_DECLARE_NEW_CORBA_ENV; - //CORBA::Environment env; + TAO_ENV_DECLARE_NEW_ENV; Coffee::Desc desc; Generator *gen = GENERATOR::instance (); // value generator @@ -138,7 +136,7 @@ Test_ObjRef::reset_parameters (void) ACE_TRY { // set the attribute of the object - this->in_->description (desc, ACE_TRY_ENV); // set the attribute for the in object + this->in_->description (desc TAO_ENV_ARG_PARAMETER); // set the attribute for the in object ACE_TRY_CHECK; } ACE_CATCHANY @@ -156,8 +154,8 @@ Test_ObjRef::reset_parameters (void) } int -Test_ObjRef::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_ObjRef::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -165,8 +163,8 @@ Test_ObjRef::run_sii_test (Param_Test_ptr objref, this->ret_ = objref->test_objref (this->in_.in (), this->inout_.inout (), - out, - ACE_TRY_ENV); + out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; @@ -185,7 +183,7 @@ CORBA::Boolean Test_ObjRef::check_validity (void) { // Environemnt variable - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { @@ -195,24 +193,24 @@ Test_ObjRef::check_validity (void) || CORBA::is_nil (this->ret_.in ())) return 0; Coffee::Desc_var in_desc = - this->in_->description (ACE_TRY_ENV); + this->in_->description (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; const char *in = in_desc->name.in (); Coffee::Desc_var inout_desc = - this->inout_->description (ACE_TRY_ENV); + this->inout_->description (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; const char *inout = inout_desc->name.in (); Coffee::Desc_var out_desc = - this->out_->description (ACE_TRY_ENV); + this->out_->description (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; const char *out = out_desc->name.in (); - Coffee::Desc_var ret_desc = this->out_->description (ACE_TRY_ENV); + Coffee::Desc_var ret_desc = this->out_->description (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; const char* ret = ret_desc->name.in (); @@ -242,10 +240,8 @@ Test_ObjRef::check_validity (CORBA::Request_ptr) void Test_ObjRef::print_values (void) { - // CORBA::Environment env; - // Env. variable - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; Coffee::Desc_var ret_desc; const char *in = 0; @@ -254,23 +250,23 @@ Test_ObjRef::print_values (void) ACE_TRY { Coffee::Desc_var in_desc = - this->in_->description (ACE_TRY_ENV); + this->in_->description (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; in = in_desc->name.in (); Coffee::Desc_var inout_desc = - this->inout_->description (ACE_TRY_ENV); + this->inout_->description (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; inout = inout_desc->name.in (); Coffee::Desc_var out_desc = - this->out_->description (ACE_TRY_ENV); + this->out_->description (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; out = out_desc->name.in (); - ret_desc = this->out_->description (ACE_TRY_ENV); + ret_desc = this->out_->description (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Param_Test/objref.h b/TAO/tests/Param_Test/objref.h index 459f26a1ecc..77e9c0baa68 100644 --- a/TAO/tests/Param_Test/objref.h +++ b/TAO/tests/Param_Test/objref.h @@ -33,15 +33,15 @@ public: ~Test_ObjRef (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -56,7 +56,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/objref_struct.cpp b/TAO/tests/Param_Test/objref_struct.cpp index ef38d4054f4..4489417361f 100644 --- a/TAO/tests/Param_Test/objref_struct.cpp +++ b/TAO/tests/Param_Test/objref_struct.cpp @@ -48,8 +48,8 @@ Test_Objref_Struct::opname (void) const } void -Test_Objref_Struct::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Objref_Struct::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_; req->add_inout_arg ("s2") <<= this->inout_.in (); @@ -57,7 +57,7 @@ Test_Objref_Struct::dii_req_invoke (CORBA::Request *req, req->set_return_type (Param_Test::_tc_Objref_Struct); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Param_Test::Objref_Struct *tmp; @@ -65,21 +65,21 @@ Test_Objref_Struct::dii_req_invoke (CORBA::Request *req, this->ret_ = new Param_Test::Objref_Struct (*tmp); CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= tmp; this->inout_ = new Param_Test::Objref_Struct (*tmp); CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= tmp; this->out_ = new Param_Test::Objref_Struct (*tmp); } int -Test_Objref_Struct::init_parameters (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Objref_Struct::init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -88,22 +88,22 @@ Test_Objref_Struct::init_parameters (Param_Test_ptr objref, // Set the long member. this->in_.x = gen->gen_long (); - this->in_.y = objref->make_coffee (ACE_TRY_ENV); + this->in_.y = objref->make_coffee (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Coffee::Desc d; d.name = gen->gen_string (); - this->in_.y->description (d, - ACE_TRY_ENV); + this->in_.y->description (d + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - this->inout_->x = 0; + this->inout_->x = 0; - this->inout_->y = Coffee::_nil (); + this->inout_->y = Coffee::_nil (); Coffee::Desc dd; - dd.name = CORBA::string_dup (""); + dd.name = CORBA::string_dup (""); return 0; } @@ -124,19 +124,19 @@ Test_Objref_Struct::reset_parameters (void) this->out_ = new Param_Test::Objref_Struct; this->ret_ = new Param_Test::Objref_Struct; - this->inout_->x = 0; + this->inout_->x = 0; - this->inout_->y = Coffee::_nil (); + this->inout_->y = Coffee::_nil (); Coffee::Desc dd; - dd.name = CORBA::string_dup (""); + dd.name = CORBA::string_dup (""); return 0; } int -Test_Objref_Struct::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Objref_Struct::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -144,8 +144,8 @@ Test_Objref_Struct::run_sii_test (Param_Test_ptr objref, this->ret_ = objref->test_objref_struct (this->in_, this->inout_.inout (), - out, - ACE_TRY_ENV); + out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; @@ -168,7 +168,7 @@ Test_Objref_Struct::check_validity (void) || this->in_.x != this->ret_->x) return 0; - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { @@ -180,16 +180,16 @@ Test_Objref_Struct::check_validity (void) return 0; } - Coffee::Desc_var s_in = this->in_.y->description (ACE_TRY_ENV); + Coffee::Desc_var s_in = this->in_.y->description (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - Coffee::Desc_var s_out = this->out_->y->description (ACE_TRY_ENV); + Coffee::Desc_var s_out = this->out_->y->description (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - Coffee::Desc_var s_inout = this->inout_->y->description (ACE_TRY_ENV); + Coffee::Desc_var s_inout = this->inout_->y->description (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - Coffee::Desc_var s_ret = this->ret_->y->description (ACE_TRY_ENV); + Coffee::Desc_var s_ret = this->ret_->y->description (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (ACE_OS::strcmp (s_in->name, s_out->name) != 0 @@ -231,21 +231,21 @@ Test_Objref_Struct::print_values (void) this->out_->x, this->ret_->x )); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { - Coffee::Desc_var s_in = this->in_.y->description (ACE_TRY_ENV); + Coffee::Desc_var s_in = this->in_.y->description (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - Coffee::Desc_var s_out = this->out_->y->description (ACE_TRY_ENV); + Coffee::Desc_var s_out = this->out_->y->description (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - Coffee::Desc_var s_inout = this->inout_->y->description (ACE_TRY_ENV); + Coffee::Desc_var s_inout = this->inout_->y->description (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - Coffee::Desc_var s_ret = this->ret_->y->description (ACE_TRY_ENV); + Coffee::Desc_var s_ret = this->ret_->y->description (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, diff --git a/TAO/tests/Param_Test/objref_struct.h b/TAO/tests/Param_Test/objref_struct.h index 5ded88f67c5..e1c684a39c6 100644 --- a/TAO/tests/Param_Test/objref_struct.h +++ b/TAO/tests/Param_Test/objref_struct.h @@ -34,15 +34,15 @@ public: ~Test_Objref_Struct (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -57,7 +57,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/param_test_i.cpp b/TAO/tests/Param_Test/param_test_i.cpp index 0ffcbd5365d..689e66c5c81 100644 --- a/TAO/tests/Param_Test/param_test_i.cpp +++ b/TAO/tests/Param_Test/param_test_i.cpp @@ -35,7 +35,7 @@ Coffee_i::~Coffee_i (void) // get attribute Coffee::Desc * -Coffee_i::description (CORBA::Environment & /*env*/) +Coffee_i::description (TAO_ENV_SINGLE_ARG_DECL_NOT_USED /*env*/) ACE_THROW_SPEC ((CORBA::SystemException)) { Coffee::Desc *desc = new Coffee::Desc; @@ -45,8 +45,8 @@ Coffee_i::description (CORBA::Environment & /*env*/) // set attribute void -Coffee_i::description (const Coffee::Desc &description, - CORBA::Environment & /*env*/) +Coffee_i::description (const Coffee::Desc &description + TAO_ENV_ARG_DECL_NOT_USED /*env*/) ACE_THROW_SPEC ((CORBA::SystemException)) { this->name_ = CORBA::string_dup (description.name); @@ -74,8 +74,8 @@ Param_Test_i::~Param_Test_i (void) CORBA::Short Param_Test_i::test_short (CORBA::Short s1, CORBA::Short &s2, - CORBA::Short_out s3, - CORBA::Environment &) + CORBA::Short_out s3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { s2 = (CORBA::Short) (s1 * 2); @@ -93,8 +93,8 @@ Param_Test_i::test_short (CORBA::Short s1, CORBA::ULongLong Param_Test_i::test_ulonglong (CORBA::ULongLong s1, CORBA::ULongLong &s2, - CORBA::ULongLong_out s3, - CORBA::Environment &) + CORBA::ULongLong_out s3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { s2 = s1 * 2; @@ -108,8 +108,8 @@ Param_Test_i::test_ulonglong (CORBA::ULongLong s1, char * Param_Test_i::test_unbounded_string (const char *s1, char *&s2, - CORBA::String_out s3, - CORBA::Environment &) + CORBA::String_out s3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { char *retstr = CORBA::string_dup (s1); @@ -127,8 +127,8 @@ Param_Test_i::test_unbounded_string (const char *s1, char * Param_Test_i::test_bounded_string (const char *s1, char *&s2, - CORBA::String_out s3, - CORBA::Environment &) + CORBA::String_out s3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { char *retstr = CORBA::string_dup (s1); @@ -146,8 +146,8 @@ Param_Test_i::test_bounded_string (const char *s1, CORBA::WChar * Param_Test_i::test_unbounded_wstring (const CORBA::WChar *ws1, CORBA::WChar *&ws2, - CORBA::WString_out ws3, - CORBA::Environment &) + CORBA::WString_out ws3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { CORBA::WChar *retwstr = CORBA::wstring_dup (ws1); @@ -169,8 +169,8 @@ Param_Test_i::test_unbounded_wstring (const CORBA::WChar *ws1, CORBA::WChar * Param_Test_i::test_bounded_wstring (const CORBA::WChar *ws1, CORBA::WChar *&ws2, - CORBA::WString_out ws3, - CORBA::Environment &) + CORBA::WString_out ws3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { CORBA::WChar *retwstr = CORBA::wstring_dup (ws1); @@ -190,8 +190,8 @@ Param_Test_i::test_bounded_wstring (const CORBA::WChar *ws1, Param_Test::Fixed_Struct Param_Test_i::test_fixed_struct (const Param_Test::Fixed_Struct &s1, Param_Test::Fixed_Struct &s2, - Param_Test::Fixed_Struct_out s3, - CORBA::Environment &) + Param_Test::Fixed_Struct_out s3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { s2 = s1; @@ -204,8 +204,8 @@ Param_Test_i::test_fixed_struct (const Param_Test::Fixed_Struct &s1, Param_Test::Long_Seq * Param_Test_i::test_long_sequence (const Param_Test::Long_Seq & s1, Param_Test::Long_Seq & s2, - Param_Test::Long_Seq_out s3, - CORBA::Environment &) + Param_Test::Long_Seq_out s3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { Param_Test::Long_Seq @@ -222,8 +222,8 @@ Param_Test_i::test_long_sequence (const Param_Test::Long_Seq & s1, Param_Test::Short_Seq * Param_Test_i::test_short_sequence (const Param_Test::Short_Seq & s1, Param_Test::Short_Seq & s2, - Param_Test::Short_Seq_out s3, - CORBA::Environment &) + Param_Test::Short_Seq_out s3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { Param_Test::Short_Seq @@ -240,8 +240,8 @@ Param_Test_i::test_short_sequence (const Param_Test::Short_Seq & s1, Param_Test::Bounded_Short_Seq * Param_Test_i::test_bounded_short_sequence (const Param_Test::Bounded_Short_Seq & s1, Param_Test::Bounded_Short_Seq & s2, - Param_Test::Bounded_Short_Seq_out s3, - CORBA::Environment &) + Param_Test::Bounded_Short_Seq_out s3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { Param_Test::Bounded_Short_Seq @@ -258,8 +258,8 @@ Param_Test_i::test_bounded_short_sequence (const Param_Test::Bounded_Short_Seq & Param_Test::Bounded_Long_Seq * Param_Test_i::test_bounded_long_sequence (const Param_Test::Bounded_Long_Seq & s1, Param_Test::Bounded_Long_Seq & s2, - Param_Test::Bounded_Long_Seq_out s3, - CORBA::Environment &) + Param_Test::Bounded_Long_Seq_out s3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { Param_Test::Bounded_Long_Seq @@ -276,8 +276,8 @@ Param_Test_i::test_bounded_long_sequence (const Param_Test::Bounded_Long_Seq & s Param_Test::StrSeq * Param_Test_i::test_strseq (const Param_Test::StrSeq &s1, Param_Test::StrSeq &s2, - Param_Test::StrSeq_out s3, - CORBA::Environment &) + Param_Test::StrSeq_out s3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { // we copy the "in" sequences into all the inout, out and return sequences. @@ -312,8 +312,8 @@ Param_Test_i::test_strseq (const Param_Test::StrSeq &s1, Param_Test::Bounded_StrSeq * Param_Test_i::test_bounded_strseq (const Param_Test::Bounded_StrSeq & s1, Param_Test::Bounded_StrSeq & s2, - Param_Test::Bounded_StrSeq_out s3, - CORBA::Environment &) + Param_Test::Bounded_StrSeq_out s3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { // we copy the "in" sequences into all the inout, out and return sequences. @@ -333,8 +333,8 @@ Param_Test_i::test_bounded_strseq (const Param_Test::Bounded_StrSeq & s1, Param_Test::WStrSeq * Param_Test_i::test_wstrseq (const Param_Test::WStrSeq &ws1, Param_Test::WStrSeq &ws2, - Param_Test::WStrSeq_out ws3, - CORBA::Environment &) + Param_Test::WStrSeq_out ws3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { // we copy the "in" sequences into all the inout, out and return sequences. @@ -354,8 +354,8 @@ Param_Test_i::test_wstrseq (const Param_Test::WStrSeq &ws1, Param_Test::Bounded_WStrSeq * Param_Test_i::test_bounded_wstrseq (const Param_Test::Bounded_WStrSeq & ws1, Param_Test::Bounded_WStrSeq & ws2, - Param_Test::Bounded_WStrSeq_out ws3, - CORBA::Environment &) + Param_Test::Bounded_WStrSeq_out ws3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { // we copy the "in" sequences into all the inout, out and return sequences. @@ -376,8 +376,8 @@ Param_Test_i::test_bounded_wstrseq (const Param_Test::Bounded_WStrSeq & ws1, Param_Test::StructSeq * Param_Test_i::test_struct_sequence (const Param_Test::StructSeq &s1, Param_Test::StructSeq &s2, - Param_Test::StructSeq_out s3, - CORBA::Environment &) + Param_Test::StructSeq_out s3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { // we copy the "in" sequences into all the inout, out and return sequences. @@ -399,8 +399,8 @@ Param_Test_i::test_struct_sequence (const Param_Test::StructSeq &s1, Param_Test::Bounded_StructSeq * Param_Test_i::test_bounded_struct_sequence (const Param_Test::Bounded_StructSeq & s1, Param_Test::Bounded_StructSeq & s2, - Param_Test::Bounded_StructSeq_out s3, - CORBA::Environment &) + Param_Test::Bounded_StructSeq_out s3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { Param_Test::Bounded_StructSeq @@ -418,8 +418,8 @@ Param_Test_i::test_bounded_struct_sequence (const Param_Test::Bounded_StructSeq Param_Test::PathSpec * Param_Test_i::test_unbounded_struct_sequence (const Param_Test::PathSpec & s1, Param_Test::PathSpec & s2, - Param_Test::PathSpec_out s3, - CORBA::Environment &) + Param_Test::PathSpec_out s3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { Param_Test::PathSpec @@ -451,8 +451,8 @@ Param_Test_i::test_unbounded_struct_sequence (const Param_Test::PathSpec & s1, Param_Test::ArraySeq * Param_Test_i::test_array_sequence (const Param_Test::ArraySeq &s1, Param_Test::ArraySeq &s2, - Param_Test::ArraySeq_out s3, - CORBA::Environment &) + Param_Test::ArraySeq_out s3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { // we copy the "in" sequences into all the inout, out and return sequences. @@ -474,8 +474,8 @@ Param_Test_i::test_array_sequence (const Param_Test::ArraySeq &s1, Param_Test::Bounded_ArraySeq * Param_Test_i::test_bounded_array_sequence (const Param_Test::Bounded_ArraySeq & s1, Param_Test::Bounded_ArraySeq & s2, - Param_Test::Bounded_ArraySeq_out s3, - CORBA::Environment &) + Param_Test::Bounded_ArraySeq_out s3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { Param_Test::Bounded_ArraySeq @@ -492,8 +492,8 @@ Param_Test_i::test_bounded_array_sequence (const Param_Test::Bounded_ArraySeq & Param_Test::Coffee_Mix * Param_Test_i::test_coffe_mix (const Param_Test::Coffee_Mix & s1, Param_Test::Coffee_Mix & s2, - Param_Test::Coffee_Mix_out s3, - CORBA::Environment &) + Param_Test::Coffee_Mix_out s3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { Param_Test::Coffee_Mix @@ -535,8 +535,8 @@ Param_Test_i::test_coffe_mix (const Param_Test::Coffee_Mix & s1, Param_Test::Bounded_Coffee_Mix * Param_Test_i::test_bounded_coffe_mix (const Param_Test::Bounded_Coffee_Mix & s1, Param_Test::Bounded_Coffee_Mix & s2, - Param_Test::Bounded_Coffee_Mix_out s3, - CORBA::Environment &) + Param_Test::Bounded_Coffee_Mix_out s3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { Param_Test::Bounded_Coffee_Mix @@ -578,8 +578,8 @@ Param_Test_i::test_bounded_coffe_mix (const Param_Test::Bounded_Coffee_Mix & s1, Param_Test::AnySeq * Param_Test_i::test_anyseq (const Param_Test::AnySeq &s1, Param_Test::AnySeq &s2, - Param_Test::AnySeq_out s3, - CORBA::Environment &) + Param_Test::AnySeq_out s3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { // we copy the "in" sequences into all the inout, out and return sequences. @@ -602,8 +602,8 @@ Param_Test_i::test_anyseq (const Param_Test::AnySeq &s1, Param_Test::Var_Struct * Param_Test_i::test_var_struct (const Param_Test::Var_Struct &s1, Param_Test::Var_Struct &s2, - Param_Test::Var_Struct_out s3, - CORBA::Environment &) + Param_Test::Var_Struct_out s3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { // we copy the "in" sequences into all the inout, out and return sequences. @@ -624,8 +624,8 @@ Param_Test_i::test_var_struct (const Param_Test::Var_Struct &s1, Param_Test::Nested_Struct * Param_Test_i::test_nested_struct (const Param_Test::Nested_Struct &s1, Param_Test::Nested_Struct &s2, - Param_Test::Nested_Struct_out s3, - CORBA::Environment &) + Param_Test::Nested_Struct_out s3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { // we copy the "in" sequences into all the inout, out and return sequences. @@ -646,8 +646,8 @@ Param_Test_i::test_nested_struct (const Param_Test::Nested_Struct &s1, Param_Test::Recursive_Struct * Param_Test_i::test_recursive_struct (const Param_Test::Recursive_Struct &s1, Param_Test::Recursive_Struct &s2, - Param_Test::Recursive_Struct_out s3, - CORBA::Environment &) + Param_Test::Recursive_Struct_out s3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { // we copy the "in" structs into all the inout, out and return sequences. @@ -667,8 +667,8 @@ Param_Test_i::test_recursive_struct (const Param_Test::Recursive_Struct &s1, Param_Test::Objref_Struct * Param_Test_i::test_objref_struct (const Param_Test::Objref_Struct &s1, Param_Test::Objref_Struct &s2, - Param_Test::Objref_Struct_out s3, - CORBA::Environment &) + Param_Test::Objref_Struct_out s3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { // we copy the "in" sequences into all the inout, out and return sequences. @@ -687,32 +687,32 @@ Param_Test_i::test_objref_struct (const Param_Test::Objref_Struct &s1, // make a Coffee object Coffee_ptr -Param_Test_i::make_coffee (CORBA::Environment &ACE_TRY_ENV) +Param_Test_i::make_coffee (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - return this->obj_._this (ACE_TRY_ENV); + return this->obj_._this (TAO_ENV_SINGLE_ARG_PARAMETER); } // test for object references Coffee_ptr Param_Test_i::test_objref (Coffee_ptr o1, Coffee_ptr &o2, - Coffee_out o3, - CORBA::Environment &ACE_TRY_ENV) + Coffee_out o3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { Coffee_ptr ret = Coffee::_nil (); ACE_TRY { - Coffee_var myobj = obj_._this (ACE_TRY_ENV); + Coffee_var myobj = obj_._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (!CORBA::is_nil (o2)) CORBA::release (o2); - CORBA::Boolean equiv = myobj->_is_equivalent (o1, - ACE_TRY_ENV); + CORBA::Boolean equiv = myobj->_is_equivalent (o1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (equiv) @@ -746,8 +746,8 @@ Param_Test_i::test_objref (Coffee_ptr o1, CORBA::TypeCode_ptr Param_Test_i::test_typecode (CORBA::TypeCode_ptr t1, CORBA::TypeCode_ptr &t2, - CORBA::TypeCode_out t3, - CORBA::Environment &/*env*/) + CORBA::TypeCode_out t3 + TAO_ENV_ARG_DECL_NOT_USED/*env*/) ACE_THROW_SPEC ((CORBA::SystemException)) { // we simply assign t1 to the others @@ -761,8 +761,8 @@ Param_Test_i::test_typecode (CORBA::TypeCode_ptr t1, CORBA::Any * Param_Test_i::test_any (const CORBA::Any &a1, CORBA::Any &a2, - CORBA::Any_out a3, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Any_out a3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { CORBA::Any *ret; @@ -784,7 +784,7 @@ Param_Test_i::test_any (const CORBA::Any &a1, if (TAO_debug_level > 0) { CORBA::TypeCode_var tc = a1.type (); - int kind = tc->kind (ACE_TRY_ENV); + int kind = tc->kind (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (0); ACE_DEBUG ((LM_DEBUG, @@ -928,8 +928,8 @@ Param_Test_i::test_any (const CORBA::Any &a1, Param_Test::Fixed_Array_slice * Param_Test_i::test_fixed_array (const Param_Test::Fixed_Array a1, Param_Test::Fixed_Array a2, - Param_Test::Fixed_Array_out a3, - CORBA::Environment &) + Param_Test::Fixed_Array_out a3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { Param_Test::Fixed_Array_slice *ret; @@ -944,8 +944,8 @@ Param_Test_i::test_fixed_array (const Param_Test::Fixed_Array a1, Param_Test::Var_Array_slice * Param_Test_i::test_var_array (const Param_Test::Var_Array a1, Param_Test::Var_Array a2, - Param_Test::Var_Array_out a3, - CORBA::Environment &) + Param_Test::Var_Array_out a3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { Param_Test::Var_Array_slice *ret; @@ -959,8 +959,8 @@ Param_Test_i::test_var_array (const Param_Test::Var_Array a1, CORBA::ULong Param_Test_i::test_exception (CORBA::ULong s1, CORBA::ULong& s2, - CORBA::ULong_out s3, - CORBA::Environment &ACE_TRY_ENV) + CORBA::ULong_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, Param_Test::Ooops)) { @@ -981,7 +981,7 @@ Param_Test_i::test_exception (CORBA::ULong s1, // warning that test_exception is throwing an exception // not in its THROW_SPEC, but still test TAO's // conversion of such an exception to UNKNOWN. - this->throw_badboy (ACE_TRY_ENV); + this->throw_badboy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (0); return 0; @@ -990,8 +990,8 @@ Param_Test_i::test_exception (CORBA::ULong s1, Param_Test::Big_Union* Param_Test_i::test_big_union (const Param_Test::Big_Union& u1, Param_Test::Big_Union& u2, - Param_Test::Big_Union_out u3, - CORBA::Environment &) + Param_Test::Big_Union_out u3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { Param_Test::Big_Union_var ret (new Param_Test::Big_Union (u1)); @@ -1003,8 +1003,8 @@ Param_Test_i::test_big_union (const Param_Test::Big_Union& u1, Param_Test::Small_Union Param_Test_i::test_small_union (const Param_Test::Small_Union& u1, Param_Test::Small_Union& u2, - Param_Test::Small_Union_out u3, - CORBA::Environment &) + Param_Test::Small_Union_out u3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { u2 = u1; @@ -1015,8 +1015,8 @@ Param_Test_i::test_small_union (const Param_Test::Small_Union& u1, Param_Test::Recursive_Union* Param_Test_i::test_recursive_union (const Param_Test::Recursive_Union& ru1, Param_Test::Recursive_Union& ru2, - Param_Test::Recursive_Union_out ru3, - CORBA::Environment &) + Param_Test::Recursive_Union_out ru3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { Param_Test::Recursive_Union_var ret (new Param_Test::Recursive_Union (ru1)); @@ -1028,8 +1028,8 @@ Param_Test_i::test_recursive_union (const Param_Test::Recursive_Union& ru1, CORBA::Any* Param_Test_i::test_complex_any (const CORBA::Any &a1, CORBA::Any &a2, - CORBA::Any_out a3, - CORBA::Environment &) + CORBA::Any_out a3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { CORBA::Any_var ret (new CORBA::Any (a1)); @@ -1041,8 +1041,8 @@ Param_Test_i::test_complex_any (const CORBA::Any &a1, Param_Test::Multdim_Array_slice * Param_Test_i::test_multdim_array (const Param_Test::Multdim_Array a1, Param_Test::Multdim_Array a2, - Param_Test::Multdim_Array_out a3, - CORBA::Environment &) + Param_Test::Multdim_Array_out a3 + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { Param_Test::Multdim_Array_slice *ret; @@ -1054,14 +1054,14 @@ Param_Test_i::test_multdim_array (const Param_Test::Multdim_Array a1, } void -Param_Test_i::shutdown (CORBA::Environment &) +Param_Test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->orb_->shutdown (); } void -Param_Test_i::throw_badboy (CORBA::Environment &ACE_TRY_ENV) +Param_Test_i::throw_badboy (TAO_ENV_SINGLE_ARG_DECL) { ACE_THROW (Param_Test::BadBoy ()); } diff --git a/TAO/tests/Param_Test/param_test_i.h b/TAO/tests/Param_Test/param_test_i.h index e523a86d71b..4e4cd6f371d 100644 --- a/TAO/tests/Param_Test/param_test_i.h +++ b/TAO/tests/Param_Test/param_test_i.h @@ -31,12 +31,12 @@ public: // =methods for the attribute - virtual Coffee::Desc * description (CORBA::Environment &env) + virtual Coffee::Desc * description (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // get attribute - virtual void description (const Coffee::Desc &description, - CORBA::Environment &env) + virtual void description (const Coffee::Desc &description + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // set attribute @@ -62,51 +62,51 @@ public: virtual CORBA::Short test_short (CORBA::Short s1, CORBA::Short &s2, - CORBA::Short_out s3, - CORBA::Environment &env) + CORBA::Short_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // test for shorts virtual CORBA::ULongLong test_ulonglong (CORBA::ULongLong s1, CORBA::ULongLong &s2, - CORBA::ULongLong_out s3, - CORBA::Environment &env) + CORBA::ULongLong_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // test for unsigned long long virtual char *test_unbounded_string (const char *s1, char *&s2, - CORBA::String_out s3, - CORBA::Environment &env) + CORBA::String_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // test for unbounded strings virtual char *test_bounded_string (const char *s1, char *&s2, - CORBA::String_out s3, - CORBA::Environment &env) + CORBA::String_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // test for bounded strings virtual CORBA::WChar *test_unbounded_wstring (const CORBA::WChar *ws1, CORBA::WChar *&ws2, - CORBA::WString_out ws3, - CORBA::Environment &env) + CORBA::WString_out ws3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // test for unbounded wstrings virtual CORBA::WChar *test_bounded_wstring (const CORBA::WChar *ws1, CORBA::WChar *&ws2, - CORBA::WString_out ws3, - CORBA::Environment &env) + CORBA::WString_out ws3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // test for bounded wstrings virtual Param_Test::Fixed_Struct test_fixed_struct (const Param_Test::Fixed_Struct &s1, Param_Test::Fixed_Struct &s2, - Param_Test::Fixed_Struct_out s3, - CORBA::Environment &env) + Param_Test::Fixed_Struct_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // test for fixed structures @@ -114,221 +114,221 @@ public: virtual Param_Test::Long_Seq * test_long_sequence ( const Param_Test::Long_Seq & s1, Param_Test::Long_Seq & s2, - Param_Test::Long_Seq_out s3, - CORBA::Environment &env) + Param_Test::Long_Seq_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual Param_Test::Bounded_Long_Seq * test_bounded_long_sequence ( const Param_Test::Bounded_Long_Seq & s1, Param_Test::Bounded_Long_Seq & s2, - Param_Test::Bounded_Long_Seq_out s3, - CORBA::Environment &env) + Param_Test::Bounded_Long_Seq_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual Param_Test::Short_Seq * test_short_sequence ( const Param_Test::Short_Seq & s1, Param_Test::Short_Seq & s2, - Param_Test::Short_Seq_out s3, - CORBA::Environment &env) + Param_Test::Short_Seq_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual Param_Test::Bounded_Short_Seq * test_bounded_short_sequence ( const Param_Test::Bounded_Short_Seq & s1, Param_Test::Bounded_Short_Seq & s2, - Param_Test::Bounded_Short_Seq_out s3, - CORBA::Environment &env) + Param_Test::Bounded_Short_Seq_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual Param_Test::StrSeq * test_strseq ( const Param_Test::StrSeq & s1, Param_Test::StrSeq & s2, - Param_Test::StrSeq_out s3, - CORBA::Environment &env) + Param_Test::StrSeq_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual Param_Test::Bounded_StrSeq * test_bounded_strseq ( const Param_Test::Bounded_StrSeq & s1, Param_Test::Bounded_StrSeq & s2, - Param_Test::Bounded_StrSeq_out s3, - CORBA::Environment &env) + Param_Test::Bounded_StrSeq_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual Param_Test::WStrSeq * test_wstrseq ( const Param_Test::WStrSeq & ws1, Param_Test::WStrSeq & ws2, - Param_Test::WStrSeq_out ws3, - CORBA::Environment &env) + Param_Test::WStrSeq_out ws3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual Param_Test::Bounded_WStrSeq * test_bounded_wstrseq ( const Param_Test::Bounded_WStrSeq & ws1, Param_Test::Bounded_WStrSeq & ws2, - Param_Test::Bounded_WStrSeq_out ws3, - CORBA::Environment &env) + Param_Test::Bounded_WStrSeq_out ws3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual Param_Test::StructSeq * test_struct_sequence ( const Param_Test::StructSeq & s1, Param_Test::StructSeq & s2, - Param_Test::StructSeq_out s3, - CORBA::Environment &env) + Param_Test::StructSeq_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual Param_Test::PathSpec * test_unbounded_struct_sequence ( const Param_Test::PathSpec & s1, Param_Test::PathSpec & s2, - Param_Test::PathSpec_out s3, - CORBA::Environment &env) + Param_Test::PathSpec_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual Param_Test::Bounded_StructSeq * test_bounded_struct_sequence ( const Param_Test::Bounded_StructSeq & s1, Param_Test::Bounded_StructSeq & s2, - Param_Test::Bounded_StructSeq_out s3, - CORBA::Environment &env) + Param_Test::Bounded_StructSeq_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual Param_Test::ArraySeq * test_array_sequence ( const Param_Test::ArraySeq & s1, Param_Test::ArraySeq & s2, - Param_Test::ArraySeq_out s3, - CORBA::Environment &env) + Param_Test::ArraySeq_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual Param_Test::Bounded_ArraySeq * test_bounded_array_sequence ( const Param_Test::Bounded_ArraySeq & s1, Param_Test::Bounded_ArraySeq & s2, - Param_Test::Bounded_ArraySeq_out s3, - CORBA::Environment &env) + Param_Test::Bounded_ArraySeq_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual Param_Test::Coffee_Mix * test_coffe_mix ( const Param_Test::Coffee_Mix & s1, Param_Test::Coffee_Mix & s2, - Param_Test::Coffee_Mix_out s3, - CORBA::Environment &env) + Param_Test::Coffee_Mix_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual Param_Test::Bounded_Coffee_Mix * test_bounded_coffe_mix ( const Param_Test::Bounded_Coffee_Mix & s1, Param_Test::Bounded_Coffee_Mix & s2, - Param_Test::Bounded_Coffee_Mix_out s3, - CORBA::Environment &env) + Param_Test::Bounded_Coffee_Mix_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual Param_Test::AnySeq * test_anyseq ( const Param_Test::AnySeq & s1, Param_Test::AnySeq & s2, - Param_Test::AnySeq_out s3, - CORBA::Environment &env) + Param_Test::AnySeq_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // = End of sequences tests.... virtual Param_Test::Var_Struct * test_var_struct (const Param_Test::Var_Struct &s1, Param_Test::Var_Struct &s2, - Param_Test::Var_Struct_out s3, - CORBA::Environment &env) + Param_Test::Var_Struct_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // test for variable structs virtual Param_Test::Nested_Struct * test_nested_struct (const Param_Test::Nested_Struct &s1, Param_Test::Nested_Struct &s2, - Param_Test::Nested_Struct_out s3, - CORBA::Environment &env) + Param_Test::Nested_Struct_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // test for nested structs virtual Param_Test::Recursive_Struct * test_recursive_struct (const Param_Test::Recursive_Struct &rs1, Param_Test::Recursive_Struct &rs2, - Param_Test::Recursive_Struct_out rs3, - CORBA::Environment &env) + Param_Test::Recursive_Struct_out rs3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // test for recursive structs virtual Param_Test::Objref_Struct * test_objref_struct (const Param_Test::Objref_Struct &s1, Param_Test::Objref_Struct &s2, - Param_Test::Objref_Struct_out s3, - CORBA::Environment &env) + Param_Test::Objref_Struct_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual Coffee_ptr - make_coffee (CORBA::Environment &env) + make_coffee (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // make a coffee object virtual Coffee_ptr test_objref (Coffee_ptr o1, Coffee_ptr &o2, - Coffee_out o3, - CORBA::Environment &env) + Coffee_out o3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // test for object references virtual CORBA::TypeCode_ptr test_typecode (CORBA::TypeCode_ptr t1, CORBA::TypeCode_ptr &o2, - CORBA::TypeCode_out o3, - CORBA::Environment &env) + CORBA::TypeCode_out o3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // test for typecodes virtual CORBA::Any * test_any (const CORBA::Any &a1, CORBA::Any &a2, - CORBA::Any_out a3, - CORBA::Environment &env) + CORBA::Any_out a3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // test for Anys virtual Param_Test::Fixed_Array_slice * test_fixed_array (const Param_Test::Fixed_Array a1, Param_Test::Fixed_Array a2, - Param_Test::Fixed_Array_out a3, - CORBA::Environment &env) + Param_Test::Fixed_Array_out a3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // test for fixed size arrays virtual Param_Test::Var_Array_slice * test_var_array (const Param_Test::Var_Array a1, Param_Test::Var_Array a2, - Param_Test::Var_Array_out a3, - CORBA::Environment &env) + Param_Test::Var_Array_out a3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // test for arrays of variable types virtual CORBA::ULong test_exception (CORBA::ULong s1, CORBA::ULong& s2, - CORBA::ULong_out s3, - CORBA::Environment &env) + CORBA::ULong_out s3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, Param_Test::Ooops)); virtual Param_Test::Big_Union* test_big_union (const Param_Test::Big_Union& u1, Param_Test::Big_Union& u2, - Param_Test::Big_Union_out u3, - CORBA::Environment &env) + Param_Test::Big_Union_out u3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual Param_Test::Small_Union test_small_union (const Param_Test::Small_Union& u1, Param_Test::Small_Union& u2, - Param_Test::Small_Union_out u3, - CORBA::Environment &env) + Param_Test::Small_Union_out u3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual Param_Test::Recursive_Union* test_recursive_union (const Param_Test::Recursive_Union& ru1, Param_Test::Recursive_Union& ru2, - Param_Test::Recursive_Union_out ru3, - CORBA::Environment &env) + Param_Test::Recursive_Union_out ru3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual CORBA::Any* test_complex_any (const CORBA::Any &a1, CORBA::Any &a2, - CORBA::Any_out a3, - CORBA::Environment &env) + CORBA::Any_out a3 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // Test for multi dimensional arrays virtual Param_Test::Multdim_Array_slice * test_multdim_array (const Param_Test::Multdim_Array, Param_Test::Multdim_Array , - Param_Test::Multdim_Array_out , - CORBA::Environment &) + Param_Test::Multdim_Array_out + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment &env) + void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); @@ -339,7 +339,7 @@ private: Coffee_i obj_; // the coffee object reference we maintain - void throw_badboy (CORBA::Environment &ACE_TRY_ENV); + void throw_badboy (TAO_ENV_SINGLE_ARG_DECL); // Called by test_exception. This will avoid the compiler // warning that test_exception is throwing an exception // not in its THROW_SPEC, but still test TAO's diff --git a/TAO/tests/Param_Test/recursive_struct.cpp b/TAO/tests/Param_Test/recursive_struct.cpp index 3f868f8aefb..cbe8190640b 100644 --- a/TAO/tests/Param_Test/recursive_struct.cpp +++ b/TAO/tests/Param_Test/recursive_struct.cpp @@ -47,8 +47,8 @@ Test_Recursive_Struct::opname (void) const } void -Test_Recursive_Struct::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Recursive_Struct::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_; req->add_inout_arg ("s2") <<= this->inout_.in (); @@ -56,7 +56,7 @@ Test_Recursive_Struct::dii_req_invoke (CORBA::Request *req, req->set_return_type (Param_Test::_tc_Recursive_Struct); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Param_Test::Recursive_Struct *tmp; @@ -64,21 +64,21 @@ Test_Recursive_Struct::dii_req_invoke (CORBA::Request *req, this->ret_ = new Param_Test::Recursive_Struct (*tmp); CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= tmp; this->inout_ = new Param_Test::Recursive_Struct (*tmp); CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= tmp; this->out_ = new Param_Test::Recursive_Struct (*tmp); } int -Test_Recursive_Struct::init_parameters (Param_Test_ptr , - CORBA::Environment &) +Test_Recursive_Struct::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { // The client calls init_parameters() before the first // call and reset_parameters() after each call. For this @@ -116,8 +116,8 @@ Test_Recursive_Struct::reset_parameters (void) } int -Test_Recursive_Struct::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Recursive_Struct::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -125,8 +125,8 @@ Test_Recursive_Struct::run_sii_test (Param_Test_ptr objref, this->ret_ = objref->test_recursive_struct (this->in_, this->inout_.inout (), - out, - ACE_TRY_ENV); + out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/recursive_struct.h b/TAO/tests/Param_Test/recursive_struct.h index cb84b23be28..8e5af6b8d62 100644 --- a/TAO/tests/Param_Test/recursive_struct.h +++ b/TAO/tests/Param_Test/recursive_struct.h @@ -35,15 +35,15 @@ public: ~Test_Recursive_Struct (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -58,8 +58,8 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, - CORBA::Environment &); + void dii_req_invoke (CORBA::Request * + TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/recursive_union.cpp b/TAO/tests/Param_Test/recursive_union.cpp index fa8ede8eed0..1c9ec710040 100644 --- a/TAO/tests/Param_Test/recursive_union.cpp +++ b/TAO/tests/Param_Test/recursive_union.cpp @@ -47,8 +47,8 @@ Test_Recursive_Union::opname (void) const } void -Test_Recursive_Union::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Recursive_Union::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_; req->add_inout_arg ("s2") <<= this->inout_.in (); @@ -56,7 +56,7 @@ Test_Recursive_Union::dii_req_invoke (CORBA::Request *req, req->set_return_type (Param_Test::_tc_Recursive_Union); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Param_Test::Recursive_Union *tmp; @@ -64,21 +64,21 @@ Test_Recursive_Union::dii_req_invoke (CORBA::Request *req, this->ret_ = new Param_Test::Recursive_Union (*tmp); CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= tmp; this->inout_ = new Param_Test::Recursive_Union (*tmp); CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= tmp; this->out_ = new Param_Test::Recursive_Union (*tmp); } int -Test_Recursive_Union::init_parameters (Param_Test_ptr , - CORBA::Environment &) +Test_Recursive_Union::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { // The client calls init_parameters() before the first // call and reset_parameters() after each call. For this @@ -118,8 +118,8 @@ Test_Recursive_Union::reset_parameters (void) } int -Test_Recursive_Union::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Recursive_Union::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -127,8 +127,8 @@ Test_Recursive_Union::run_sii_test (Param_Test_ptr objref, this->ret_ = objref->test_recursive_union (this->in_, this->inout_.inout (), - out, - ACE_TRY_ENV); + out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/recursive_union.h b/TAO/tests/Param_Test/recursive_union.h index 3dad5de6eaf..d7faea6fef3 100644 --- a/TAO/tests/Param_Test/recursive_union.h +++ b/TAO/tests/Param_Test/recursive_union.h @@ -35,15 +35,15 @@ public: ~Test_Recursive_Union (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -58,8 +58,8 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, - CORBA::Environment &); + void dii_req_invoke (CORBA::Request * + TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/results.cpp b/TAO/tests/Param_Test/results.cpp index 8187d3ad3c1..23ce8f75a3e 100644 --- a/TAO/tests/Param_Test/results.cpp +++ b/TAO/tests/Param_Test/results.cpp @@ -102,8 +102,8 @@ Results::print_stats (void) } void -Results::print_exception (const char * /* call_name */, - CORBA::Environment &) +Results::print_exception (const char * /* call_name */ + TAO_ENV_ARG_DECL_NOT_USED) { //ACE_PRINT_EXCEPTION (call_name); } diff --git a/TAO/tests/Param_Test/results.h b/TAO/tests/Param_Test/results.h index 5f8139f655b..81225cd2d01 100644 --- a/TAO/tests/Param_Test/results.h +++ b/TAO/tests/Param_Test/results.h @@ -38,8 +38,8 @@ public: void print_stats (void); // prints the time stats - void print_exception (const char *call_name, - CORBA::Environment &); + void print_exception (const char *call_name + TAO_ENV_ARG_DECL_NOT_USED); // print the exception void start_timer (void); diff --git a/TAO/tests/Param_Test/server.cpp b/TAO/tests/Param_Test/server.cpp index 738a343337e..c1ed50851ec 100644 --- a/TAO/tests/Param_Test/server.cpp +++ b/TAO/tests/Param_Test/server.cpp @@ -61,12 +61,12 @@ main (int argc, char *argv[]) PortableServer::POA_var oa_ptr; Param_Test_i *param_test = 0; - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { const char *orb_name = ""; CORBA::ORB_var orb_ptr = - CORBA::ORB_init (argc, argv, orb_name, ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, orb_name TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var temp; // holder for the myriad of times we get @@ -74,8 +74,8 @@ main (int argc, char *argv[]) // Get the Root POA - temp = orb_ptr->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + temp = orb_ptr->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (temp.in())) @@ -83,29 +83,29 @@ main (int argc, char *argv[]) "(%P|%t) Unable to get root poa reference.\n"), 1); - oa_ptr = PortableServer::POA::_narrow (temp.in(), ACE_TRY_ENV); + oa_ptr = PortableServer::POA::_narrow (temp.in() TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - oa_ptr->the_POAManager (ACE_TRY_ENV); + oa_ptr->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyList policies (2); policies.length (2); policies[0] = - oa_ptr->create_id_assignment_policy (PortableServer::USER_ID, - ACE_TRY_ENV); + oa_ptr->create_id_assignment_policy (PortableServer::USER_ID + TAO_ENV_ARG_PARAMETER); policies[1] = - oa_ptr->create_lifespan_policy (PortableServer::PERSISTENT, - ACE_TRY_ENV); + oa_ptr->create_lifespan_policy (PortableServer::PERSISTENT + TAO_ENV_ARG_PARAMETER); // We use a different POA, otherwise the user would have to // change the object key each time it invokes the server. PortableServer::POA_var good_poa = oa_ptr->create_POA ("child_poa", poa_manager.in (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Parse remaining command line and verify parameters. @@ -123,20 +123,20 @@ main (int argc, char *argv[]) PortableServer::ObjectId_var id = PortableServer::string_to_ObjectId ("param_test"); good_poa->activate_object_with_id (id.in (), - param_test, - ACE_TRY_ENV); + param_test + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Stringify the objref we'll be implementing, and print it to // stdout. Someone will take that string and give it to a // client. Then release the object. - temp = good_poa->id_to_reference (id.in (), ACE_TRY_ENV); + temp = good_poa->id_to_reference (id.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var str = - orb_ptr->object_to_string (temp.in (), - ACE_TRY_ENV); + orb_ptr->object_to_string (temp.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (TAO_debug_level > 0) @@ -149,20 +149,20 @@ main (int argc, char *argv[]) // Make the POAs controlled by this manager active - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb_ptr->run (ACE_TRY_ENV); + orb_ptr->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; good_poa->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; oa_ptr->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (CORBA::SystemException, sysex) diff --git a/TAO/tests/Param_Test/short.cpp b/TAO/tests/Param_Test/short.cpp index f8d8bd3a5f0..6c906cbbadd 100644 --- a/TAO/tests/Param_Test/short.cpp +++ b/TAO/tests/Param_Test/short.cpp @@ -43,8 +43,8 @@ Test_Short::opname (void) const } void -Test_Short::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Short::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_; req->add_inout_arg ("s2") <<= this->inout_; @@ -52,25 +52,25 @@ Test_Short::dii_req_invoke (CORBA::Request *req, req->set_return_type (CORBA::_tc_short); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; req->return_value () >>= this->ret_; CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= this->inout_; CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= this->out_; } int -Test_Short::init_parameters (Param_Test_ptr /*objref*/, - CORBA::Environment &) +Test_Short::init_parameters (Param_Test_ptr /*objref*/ + TAO_ENV_ARG_DECL_NOT_USED) { Generator *gen = GENERATOR::instance (); // value generator @@ -89,15 +89,15 @@ Test_Short::reset_parameters (void) } int -Test_Short::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Short::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { this->ret_ = objref->test_short (this->in_, this->inout_, - this->out_, - ACE_TRY_ENV); + this->out_ + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/short.h b/TAO/tests/Param_Test/short.h index 285bd3ec428..035f428d59d 100644 --- a/TAO/tests/Param_Test/short.h +++ b/TAO/tests/Param_Test/short.h @@ -33,15 +33,15 @@ public: ~Test_Short (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -56,7 +56,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/small_union.cpp b/TAO/tests/Param_Test/small_union.cpp index d2036b5cb41..555e42c38c8 100644 --- a/TAO/tests/Param_Test/small_union.cpp +++ b/TAO/tests/Param_Test/small_union.cpp @@ -45,8 +45,8 @@ Test_Small_Union::opname (void) const } void -Test_Small_Union::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Small_Union::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_; req->add_inout_arg ("s2") <<= this->inout_; @@ -54,7 +54,7 @@ Test_Small_Union::dii_req_invoke (CORBA::Request *req, req->set_return_type (Param_Test::_tc_Small_Union); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Param_Test::Small_Union *tmp; @@ -62,26 +62,26 @@ Test_Small_Union::dii_req_invoke (CORBA::Request *req, this->ret_ = new Param_Test::Small_Union (*tmp); CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= tmp; this->inout_ = *tmp; CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= tmp; this->out_ = new Param_Test::Small_Union (*tmp); } int -Test_Small_Union::init_parameters (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Small_Union::init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { // get access to a Coffee Object - this->cobj_ = objref->make_coffee (ACE_TRY_ENV); + this->cobj_ = objref->make_coffee (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; this->reset_parameters (); @@ -129,15 +129,15 @@ Test_Small_Union::reset_parameters (void) } int -Test_Small_Union::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Small_Union::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { this->ret_ = objref->test_small_union (this->in_, this->inout_, - this->out_, - ACE_TRY_ENV); + this->out_ + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/small_union.h b/TAO/tests/Param_Test/small_union.h index f4b3bc22981..6e6a39025ab 100644 --- a/TAO/tests/Param_Test/small_union.h +++ b/TAO/tests/Param_Test/small_union.h @@ -33,15 +33,15 @@ public: ~Test_Small_Union (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -56,7 +56,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/typecode.cpp b/TAO/tests/Param_Test/typecode.cpp index ca4807dab86..23972a2ef3f 100644 --- a/TAO/tests/Param_Test/typecode.cpp +++ b/TAO/tests/Param_Test/typecode.cpp @@ -43,8 +43,8 @@ Test_TypeCode::opname (void) const } void -Test_TypeCode::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_TypeCode::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_.in (); req->add_inout_arg ("s2") <<= this->inout_.in (); @@ -52,7 +52,7 @@ Test_TypeCode::dii_req_invoke (CORBA::Request *req, req->set_return_type (CORBA::_tc_TypeCode); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::TypeCode_ptr tmp; @@ -60,21 +60,21 @@ Test_TypeCode::dii_req_invoke (CORBA::Request *req, this->ret_ = CORBA::TypeCode::_duplicate (tmp); CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= tmp; this->inout_ = CORBA::TypeCode::_duplicate (tmp); CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= tmp; this->out_ = CORBA::TypeCode::_duplicate (tmp); } int -Test_TypeCode::init_parameters (Param_Test_ptr, - CORBA::Environment &) +Test_TypeCode::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { static CORBA::TypeCode_ptr tc_table [] = { @@ -115,20 +115,20 @@ Test_TypeCode::reset_parameters (void) } int -Test_TypeCode::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_TypeCode::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { - this->init_parameters (objref, ACE_TRY_ENV); + this->init_parameters (objref TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::TypeCode_out out (this->out_); this->ret_ = objref->test_typecode (this->in_.in (), this->inout_.inout (), - out, - ACE_TRY_ENV); + out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; @@ -146,22 +146,22 @@ Test_TypeCode::run_sii_test (Param_Test_ptr objref, CORBA::Boolean Test_TypeCode::check_validity (void) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { CORBA::Boolean one, two, three; - one = this->in_.in ()->equal (this->inout_.in (), - ACE_TRY_ENV); + one = this->in_.in ()->equal (this->inout_.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - two = this->in_.in ()->equal (this->out_.in (), - ACE_TRY_ENV); + two = this->in_.in ()->equal (this->out_.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - three = this->in_.in ()->equal (this->ret_.in (), - ACE_TRY_ENV); + three = this->in_.in ()->equal (this->ret_.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (one && two && three) diff --git a/TAO/tests/Param_Test/typecode.h b/TAO/tests/Param_Test/typecode.h index cde6cfb1c2a..75d2ac358a3 100644 --- a/TAO/tests/Param_Test/typecode.h +++ b/TAO/tests/Param_Test/typecode.h @@ -33,15 +33,15 @@ public: ~Test_TypeCode (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -56,7 +56,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/ub_any_seq.cpp b/TAO/tests/Param_Test/ub_any_seq.cpp index 035ed312b29..a05bc294abc 100644 --- a/TAO/tests/Param_Test/ub_any_seq.cpp +++ b/TAO/tests/Param_Test/ub_any_seq.cpp @@ -51,8 +51,8 @@ Test_AnySeq::opname (void) const } void -Test_AnySeq::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_AnySeq::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_.in (); req->add_inout_arg ("s2") <<= this->inout_.in (); @@ -60,7 +60,7 @@ Test_AnySeq::dii_req_invoke (CORBA::Request *req, req->set_return_type (Param_Test::_tc_AnySeq); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Param_Test::AnySeq* tmp; @@ -68,21 +68,21 @@ Test_AnySeq::dii_req_invoke (CORBA::Request *req, this->ret_ = new Param_Test::AnySeq (*tmp); CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= tmp; this->inout_ = new Param_Test::AnySeq (*tmp); CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= tmp; this->out_ = new Param_Test::AnySeq (*tmp); } int -Test_AnySeq::init_parameters (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_AnySeq::init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { Generator *gen = GENERATOR::instance (); // value generator @@ -124,7 +124,7 @@ Test_AnySeq::init_parameters (Param_Test_ptr objref, ACE_TRY { // get access to a Coffee Object - Coffee_var cobj = objref->make_coffee (ACE_TRY_ENV); + Coffee_var cobj = objref->make_coffee (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // insert the coffee object into the Any @@ -197,8 +197,8 @@ Test_AnySeq::reset_parameters (void) int -Test_AnySeq::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_AnySeq::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -206,8 +206,8 @@ Test_AnySeq::run_sii_test (Param_Test_ptr objref, this->ret_ = objref->test_anyseq (this->in_.in (), this->inout_.inout (), - out, - ACE_TRY_ENV); + out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/ub_any_seq.h b/TAO/tests/Param_Test/ub_any_seq.h index 832921be5d0..5d610cc85c5 100644 --- a/TAO/tests/Param_Test/ub_any_seq.h +++ b/TAO/tests/Param_Test/ub_any_seq.h @@ -33,15 +33,15 @@ public: ~Test_AnySeq (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -56,7 +56,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. protected: diff --git a/TAO/tests/Param_Test/ub_array_seq.cpp b/TAO/tests/Param_Test/ub_array_seq.cpp index c21ca596b33..a4534a5129a 100644 --- a/TAO/tests/Param_Test/ub_array_seq.cpp +++ b/TAO/tests/Param_Test/ub_array_seq.cpp @@ -46,8 +46,8 @@ Test_Array_Sequence::opname (void) const } void -Test_Array_Sequence::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Array_Sequence::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_; req->add_inout_arg ("s2") <<= this->inout_.in (); @@ -55,7 +55,7 @@ Test_Array_Sequence::dii_req_invoke (CORBA::Request *req, req->set_return_type (Param_Test::_tc_ArraySeq); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Param_Test::ArraySeq *tmp; @@ -63,21 +63,21 @@ Test_Array_Sequence::dii_req_invoke (CORBA::Request *req, this->ret_ = new Param_Test::ArraySeq (*tmp); CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= tmp; this->inout_ = new Param_Test::ArraySeq (*tmp); CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= tmp; this->out_ = new Param_Test::ArraySeq (*tmp); } int -Test_Array_Sequence::init_parameters (Param_Test_ptr , - CORBA::Environment &) +Test_Array_Sequence::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { Generator *gen = GENERATOR::instance (); // value generator @@ -125,8 +125,8 @@ Test_Array_Sequence::reset_parameters (void) } int -Test_Array_Sequence::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Array_Sequence::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -134,8 +134,8 @@ Test_Array_Sequence::run_sii_test (Param_Test_ptr objref, this->ret_ = objref->test_array_sequence (this->in_, this->inout_.inout (), - out, - ACE_TRY_ENV); + out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/ub_array_seq.h b/TAO/tests/Param_Test/ub_array_seq.h index 0f7a0060dbf..aec3e9cc1a8 100644 --- a/TAO/tests/Param_Test/ub_array_seq.h +++ b/TAO/tests/Param_Test/ub_array_seq.h @@ -34,15 +34,15 @@ public: ~Test_Array_Sequence (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -57,8 +57,8 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, - CORBA::Environment &); + void dii_req_invoke (CORBA::Request * + TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. protected: diff --git a/TAO/tests/Param_Test/ub_long_seq.cpp b/TAO/tests/Param_Test/ub_long_seq.cpp index 87b7211e33c..eeae63f57e9 100644 --- a/TAO/tests/Param_Test/ub_long_seq.cpp +++ b/TAO/tests/Param_Test/ub_long_seq.cpp @@ -47,8 +47,8 @@ Test_Long_Sequence::opname (void) const } void -Test_Long_Sequence::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Long_Sequence::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_.in (); req->add_inout_arg ("s2") <<= this->inout_.in (); @@ -56,7 +56,7 @@ Test_Long_Sequence::dii_req_invoke (CORBA::Request *req, req->set_return_type (Param_Test::_tc_Long_Seq); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Param_Test::Long_Seq *tmp; @@ -64,21 +64,21 @@ Test_Long_Sequence::dii_req_invoke (CORBA::Request *req, this->ret_ = Param_Test::Long_Seq (*tmp); CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= tmp; this->inout_ = Param_Test::Long_Seq (*tmp); CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= tmp; this->out_ = Param_Test::Long_Seq (*tmp); } int -Test_Long_Sequence::init_parameters (Param_Test_ptr , - CORBA::Environment &) +Test_Long_Sequence::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { Generator *gen = GENERATOR::instance (); // value generator @@ -107,8 +107,8 @@ Test_Long_Sequence::reset_parameters (void) } int -Test_Long_Sequence::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Long_Sequence::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -116,8 +116,8 @@ Test_Long_Sequence::run_sii_test (Param_Test_ptr objref, this->ret_ = objref->test_long_sequence (this->in_.in (), this->inout_.inout (), - out, - ACE_TRY_ENV); + out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/ub_long_seq.h b/TAO/tests/Param_Test/ub_long_seq.h index 0a57a526d38..bf1dff7b476 100644 --- a/TAO/tests/Param_Test/ub_long_seq.h +++ b/TAO/tests/Param_Test/ub_long_seq.h @@ -34,15 +34,15 @@ public: ~Test_Long_Sequence (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -57,7 +57,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/ub_objref_seq.cpp b/TAO/tests/Param_Test/ub_objref_seq.cpp index 7c540d19e52..99a8e7f0761 100644 --- a/TAO/tests/Param_Test/ub_objref_seq.cpp +++ b/TAO/tests/Param_Test/ub_objref_seq.cpp @@ -57,8 +57,8 @@ Test_ObjRef_Sequence::opname (void) const } void -Test_ObjRef_Sequence::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_ObjRef_Sequence::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_; req->add_inout_arg ("s2") <<= this->inout_.in (); @@ -66,7 +66,7 @@ Test_ObjRef_Sequence::dii_req_invoke (CORBA::Request *req, req->set_return_type (Param_Test::_tc_Coffee_Mix); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Param_Test::Coffee_Mix *tmp; @@ -74,21 +74,21 @@ Test_ObjRef_Sequence::dii_req_invoke (CORBA::Request *req, this->ret_ = new Param_Test::Coffee_Mix (*tmp); CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= tmp; this->inout_ = new Param_Test::Coffee_Mix (*tmp); CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= tmp; this->out_ = new Param_Test::Coffee_Mix (*tmp); } int -Test_ObjRef_Sequence::init_parameters (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_ObjRef_Sequence::init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -106,7 +106,7 @@ Test_ObjRef_Sequence::init_parameters (Param_Test_ptr objref, { // generate some arbitrary string to be filled into the ith location in // the sequence - this->in_[i] = objref->make_coffee (ACE_TRY_ENV); + this->in_[i] = objref->make_coffee (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // select a Coffee flavor at random @@ -116,8 +116,8 @@ Test_ObjRef_Sequence::init_parameters (Param_Test_ptr objref, // set the attribute for the in object Coffee_ptr tmp = this->in_[i]; - tmp->description (desc, - ACE_TRY_ENV); + tmp->description (desc + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -143,8 +143,8 @@ Test_ObjRef_Sequence::reset_parameters (void) } int -Test_ObjRef_Sequence::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_ObjRef_Sequence::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -152,8 +152,8 @@ Test_ObjRef_Sequence::run_sii_test (Param_Test_ptr objref, this->ret_ = objref->test_coffe_mix (this->in_, this->inout_.inout (), - out, - ACE_TRY_ENV); + out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; @@ -171,23 +171,23 @@ Test_ObjRef_Sequence::run_sii_test (Param_Test_ptr objref, CORBA::Boolean Test_ObjRef_Sequence::check_validity (void) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { this->compare (this->in_, - this->inout_.in (), - ACE_TRY_ENV); + this->inout_.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; this->compare (this->in_, - this->out_.in (), - ACE_TRY_ENV); + this->out_.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; this->compare (this->in_, - this->ret_.in (), - ACE_TRY_ENV); + this->ret_.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 1; @@ -232,8 +232,8 @@ Test_ObjRef_Sequence::print_values (void) CORBA::Boolean Test_ObjRef_Sequence::compare (const Param_Test::Coffee_Mix &s1, - const Param_Test::Coffee_Mix &s2, - CORBA::Environment &ACE_TRY_ENV) + const Param_Test::Coffee_Mix &s2 + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -261,12 +261,12 @@ Test_ObjRef_Sequence::compare (const Param_Test::Coffee_Mix &s1, return 0; } - Coffee::Desc_var desc1 = vs1->description (ACE_TRY_ENV); + Coffee::Desc_var desc1 = vs1->description (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var n1 = desc1->name.in (); - Coffee::Desc_var desc2 = vs2->description (ACE_TRY_ENV); + Coffee::Desc_var desc2 = vs2->description (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var n2 = desc2->name.in (); diff --git a/TAO/tests/Param_Test/ub_objref_seq.h b/TAO/tests/Param_Test/ub_objref_seq.h index b1736c89fd7..fe9ad8e0ff3 100644 --- a/TAO/tests/Param_Test/ub_objref_seq.h +++ b/TAO/tests/Param_Test/ub_objref_seq.h @@ -34,15 +34,15 @@ public: ~Test_ObjRef_Sequence (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -57,13 +57,13 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. protected: CORBA::Boolean compare (const Param_Test::Coffee_Mix &s1, - const Param_Test::Coffee_Mix &s2, - CORBA::Environment& env); + const Param_Test::Coffee_Mix &s2 + TAO_ENV_ARG_DECL); // compare void print_sequence (const Param_Test::Coffee_Mix &s); diff --git a/TAO/tests/Param_Test/ub_short_seq.cpp b/TAO/tests/Param_Test/ub_short_seq.cpp index bc7d7632a8c..b6d97bb5af4 100644 --- a/TAO/tests/Param_Test/ub_short_seq.cpp +++ b/TAO/tests/Param_Test/ub_short_seq.cpp @@ -47,8 +47,8 @@ Test_Short_Sequence::opname (void) const } void -Test_Short_Sequence::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Short_Sequence::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_.in (); req->add_inout_arg ("s2") <<= this->inout_.in (); @@ -56,7 +56,7 @@ Test_Short_Sequence::dii_req_invoke (CORBA::Request *req, req->set_return_type (Param_Test::_tc_Short_Seq); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Param_Test::Short_Seq *tmp; @@ -64,21 +64,21 @@ Test_Short_Sequence::dii_req_invoke (CORBA::Request *req, this->ret_ = new Param_Test::Short_Seq (*tmp); CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= tmp; this->inout_ = new Param_Test::Short_Seq (*tmp); CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= tmp; this->out_ = new Param_Test::Short_Seq (*tmp); } int -Test_Short_Sequence::init_parameters (Param_Test_ptr, - CORBA::Environment &) +Test_Short_Sequence::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { Generator *gen = GENERATOR::instance (); // value generator @@ -109,8 +109,8 @@ Test_Short_Sequence::reset_parameters (void) } int -Test_Short_Sequence::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Short_Sequence::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -118,8 +118,8 @@ Test_Short_Sequence::run_sii_test (Param_Test_ptr objref, this->ret_ = objref->test_short_sequence (this->in_.in (), this->inout_.inout (), - out, - ACE_TRY_ENV); + out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/ub_short_seq.h b/TAO/tests/Param_Test/ub_short_seq.h index 9aa38e21a8e..556f82606ec 100644 --- a/TAO/tests/Param_Test/ub_short_seq.h +++ b/TAO/tests/Param_Test/ub_short_seq.h @@ -34,15 +34,15 @@ public: ~Test_Short_Sequence (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -57,7 +57,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/ub_str_seq.cpp b/TAO/tests/Param_Test/ub_str_seq.cpp index 301a40ce27c..a7bb6108914 100644 --- a/TAO/tests/Param_Test/ub_str_seq.cpp +++ b/TAO/tests/Param_Test/ub_str_seq.cpp @@ -47,8 +47,8 @@ Test_String_Sequence::opname (void) const } void -Test_String_Sequence::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_String_Sequence::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_.in (); req->add_inout_arg ("s2") <<= this->inout_.in (); @@ -56,7 +56,7 @@ Test_String_Sequence::dii_req_invoke (CORBA::Request *req, req->set_return_type (Param_Test::_tc_StrSeq); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Param_Test::StrSeq *tmp; @@ -64,21 +64,21 @@ Test_String_Sequence::dii_req_invoke (CORBA::Request *req, this->ret_ = new Param_Test::StrSeq (*tmp); CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= tmp; this->inout_ = new Param_Test::StrSeq (*tmp); CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= tmp; this->out_ = new Param_Test::StrSeq (*tmp); } int -Test_String_Sequence::init_parameters (Param_Test_ptr , - CORBA::Environment &) +Test_String_Sequence::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { const char *choiceList[] = { @@ -113,8 +113,8 @@ Test_String_Sequence::reset_parameters (void) } int -Test_String_Sequence::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_String_Sequence::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -122,8 +122,8 @@ Test_String_Sequence::run_sii_test (Param_Test_ptr objref, this->ret_ = objref->test_strseq (this->in_.in (), this->inout_.inout (), - out, - ACE_TRY_ENV); + out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/ub_str_seq.h b/TAO/tests/Param_Test/ub_str_seq.h index 24f438c84b7..25cc75e3dc8 100644 --- a/TAO/tests/Param_Test/ub_str_seq.h +++ b/TAO/tests/Param_Test/ub_str_seq.h @@ -34,15 +34,15 @@ public: ~Test_String_Sequence (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -57,7 +57,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/ub_string.cpp b/TAO/tests/Param_Test/ub_string.cpp index 06c8ef2fde4..ff695b3e18e 100644 --- a/TAO/tests/Param_Test/ub_string.cpp +++ b/TAO/tests/Param_Test/ub_string.cpp @@ -55,8 +55,8 @@ Test_Unbounded_String::opname (void) const } void -Test_Unbounded_String::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Unbounded_String::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_; req->add_inout_arg ("s2") <<= this->inout_; @@ -67,7 +67,7 @@ Test_Unbounded_String::dii_req_invoke (CORBA::Request *req, req->set_return_type (CORBA::_tc_string); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; const char *tmp; @@ -75,21 +75,21 @@ Test_Unbounded_String::dii_req_invoke (CORBA::Request *req, this->ret_ = CORBA::string_dup (tmp); CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= tmp; this->inout_ = CORBA::string_dup (tmp); CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= tmp; this->out_ = CORBA::string_dup (tmp); } int -Test_Unbounded_String::init_parameters (Param_Test_ptr , - CORBA::Environment &) +Test_Unbounded_String::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { Generator *gen = GENERATOR::instance (); // value generator @@ -125,8 +125,8 @@ Test_Unbounded_String::reset_parameters (void) } int -Test_Unbounded_String::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Unbounded_String::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -134,8 +134,8 @@ Test_Unbounded_String::run_sii_test (Param_Test_ptr objref, this->ret_ = objref->test_unbounded_string (this->in_, this->inout_, - str_out, - ACE_TRY_ENV); + str_out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/ub_string.h b/TAO/tests/Param_Test/ub_string.h index f20176a3e98..00491ae399c 100644 --- a/TAO/tests/Param_Test/ub_string.h +++ b/TAO/tests/Param_Test/ub_string.h @@ -33,15 +33,15 @@ public: ~Test_Unbounded_String (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -56,7 +56,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/ub_struct_seq.cpp b/TAO/tests/Param_Test/ub_struct_seq.cpp index 0b6cbc779e7..be2efce2d3d 100644 --- a/TAO/tests/Param_Test/ub_struct_seq.cpp +++ b/TAO/tests/Param_Test/ub_struct_seq.cpp @@ -48,8 +48,8 @@ Test_Struct_Sequence::opname (void) const } void -Test_Struct_Sequence::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Struct_Sequence::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_; req->add_inout_arg ("s2") <<= this->inout_.in (); @@ -57,7 +57,7 @@ Test_Struct_Sequence::dii_req_invoke (CORBA::Request *req, req->set_return_type (Param_Test::_tc_StructSeq); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Param_Test::StructSeq *tmp; @@ -65,21 +65,21 @@ Test_Struct_Sequence::dii_req_invoke (CORBA::Request *req, this->ret_ = new Param_Test::StructSeq (*tmp); CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= tmp; this->inout_ = new Param_Test::StructSeq (*tmp); CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= tmp; this->out_ = new Param_Test::StructSeq (*tmp); } int -Test_Struct_Sequence::init_parameters (Param_Test_ptr, - CORBA::Environment &) +Test_Struct_Sequence::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { Generator *gen = GENERATOR::instance (); // value generator @@ -110,8 +110,8 @@ Test_Struct_Sequence::reset_parameters (void) } int -Test_Struct_Sequence::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Struct_Sequence::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -119,8 +119,8 @@ Test_Struct_Sequence::run_sii_test (Param_Test_ptr objref, this->ret_ = objref->test_struct_sequence (this->in_, this->inout_.inout (), - out, - ACE_TRY_ENV); + out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; @@ -255,8 +255,8 @@ Test_Unbounded_Struct_Sequence::opname (void) const } void -Test_Unbounded_Struct_Sequence::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Unbounded_Struct_Sequence::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_; req->add_inout_arg ("s2") <<= this->inout_.in (); @@ -264,7 +264,7 @@ Test_Unbounded_Struct_Sequence::dii_req_invoke (CORBA::Request *req, req->set_return_type (Param_Test::_tc_PathSpec); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Param_Test::PathSpec *tmp; @@ -272,21 +272,21 @@ Test_Unbounded_Struct_Sequence::dii_req_invoke (CORBA::Request *req, this->ret_ = new Param_Test::PathSpec (*tmp); CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= tmp; this->inout_ = new Param_Test::PathSpec (*tmp); CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= tmp; this->out_ = new Param_Test::PathSpec (*tmp); } int -Test_Unbounded_Struct_Sequence::init_parameters (Param_Test_ptr , - CORBA::Environment &) +Test_Unbounded_Struct_Sequence::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { Generator *gen = GENERATOR::instance (); // value generator @@ -318,14 +318,14 @@ Test_Unbounded_Struct_Sequence::reset_parameters (void) } int -Test_Unbounded_Struct_Sequence::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Unbounded_Struct_Sequence::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { Param_Test::PathSpec_out out (this->out_.out ()); this->ret_ = objref->test_unbounded_struct_sequence (this->in_, this->inout_.inout (), - out, - ACE_TRY_ENV); + out + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); return 0; diff --git a/TAO/tests/Param_Test/ub_struct_seq.h b/TAO/tests/Param_Test/ub_struct_seq.h index 465b6b5574d..9fae482e77b 100644 --- a/TAO/tests/Param_Test/ub_struct_seq.h +++ b/TAO/tests/Param_Test/ub_struct_seq.h @@ -34,15 +34,15 @@ public: ~Test_Struct_Sequence (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -57,7 +57,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. protected: @@ -97,15 +97,15 @@ public: ~Test_Unbounded_Struct_Sequence (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -120,7 +120,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. protected: diff --git a/TAO/tests/Param_Test/ub_wstr_seq.cpp b/TAO/tests/Param_Test/ub_wstr_seq.cpp index c609165f1d1..15852c15044 100644 --- a/TAO/tests/Param_Test/ub_wstr_seq.cpp +++ b/TAO/tests/Param_Test/ub_wstr_seq.cpp @@ -47,8 +47,8 @@ Test_WString_Sequence::opname (void) const } void -Test_WString_Sequence::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_WString_Sequence::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_.in (); req->add_inout_arg ("s2") <<= this->inout_.in (); @@ -56,7 +56,7 @@ Test_WString_Sequence::dii_req_invoke (CORBA::Request *req, req->set_return_type (Param_Test::_tc_WStrSeq); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Param_Test::WStrSeq *tmp; @@ -64,21 +64,21 @@ Test_WString_Sequence::dii_req_invoke (CORBA::Request *req, this->ret_ = new Param_Test::WStrSeq (*tmp); CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= tmp; this->inout_ = new Param_Test::WStrSeq (*tmp); CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= tmp; this->out_ = new Param_Test::WStrSeq (*tmp); } int -Test_WString_Sequence::init_parameters (Param_Test_ptr , - CORBA::Environment &) +Test_WString_Sequence::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { Generator *gen = GENERATOR::instance (); // value generator @@ -108,8 +108,8 @@ Test_WString_Sequence::reset_parameters (void) } int -Test_WString_Sequence::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_WString_Sequence::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -117,8 +117,8 @@ Test_WString_Sequence::run_sii_test (Param_Test_ptr objref, this->ret_ = objref->test_wstrseq (this->in_.in (), this->inout_.inout (), - out, - ACE_TRY_ENV); + out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/ub_wstr_seq.h b/TAO/tests/Param_Test/ub_wstr_seq.h index fee0572fb65..31e426c263f 100644 --- a/TAO/tests/Param_Test/ub_wstr_seq.h +++ b/TAO/tests/Param_Test/ub_wstr_seq.h @@ -34,15 +34,15 @@ public: ~Test_WString_Sequence (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -57,8 +57,8 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, - CORBA::Environment &); + void dii_req_invoke (CORBA::Request * + TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/ub_wstring.cpp b/TAO/tests/Param_Test/ub_wstring.cpp index 93318ed53fd..255e49b96b0 100644 --- a/TAO/tests/Param_Test/ub_wstring.cpp +++ b/TAO/tests/Param_Test/ub_wstring.cpp @@ -55,8 +55,8 @@ Test_Unbounded_WString::opname (void) const } void -Test_Unbounded_WString::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Unbounded_WString::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_; req->add_inout_arg ("s2") <<= this->inout_; @@ -67,7 +67,7 @@ Test_Unbounded_WString::dii_req_invoke (CORBA::Request *req, req->set_return_type (CORBA::_tc_wstring); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; const CORBA::WChar *tmp; @@ -75,21 +75,21 @@ Test_Unbounded_WString::dii_req_invoke (CORBA::Request *req, this->ret_ = CORBA::wstring_dup (tmp); CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= tmp; this->inout_ = CORBA::wstring_dup (tmp); CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= tmp; this->out_ = CORBA::wstring_dup (tmp); } int -Test_Unbounded_WString::init_parameters (Param_Test_ptr, - CORBA::Environment &) +Test_Unbounded_WString::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { Generator *gen = GENERATOR::instance (); // value generator @@ -124,8 +124,8 @@ Test_Unbounded_WString::reset_parameters (void) } int -Test_Unbounded_WString::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Unbounded_WString::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -133,8 +133,8 @@ Test_Unbounded_WString::run_sii_test (Param_Test_ptr objref, this->ret_ = objref->test_unbounded_wstring (this->in_, this->inout_, - str_out, - ACE_TRY_ENV); + str_out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/ub_wstring.h b/TAO/tests/Param_Test/ub_wstring.h index e2509254885..54b98554916 100644 --- a/TAO/tests/Param_Test/ub_wstring.h +++ b/TAO/tests/Param_Test/ub_wstring.h @@ -33,15 +33,15 @@ public: ~Test_Unbounded_WString (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -56,8 +56,8 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, - CORBA::Environment &); + void dii_req_invoke (CORBA::Request * + TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/ulonglong.cpp b/TAO/tests/Param_Test/ulonglong.cpp index 5f92783911d..05360195cb3 100644 --- a/TAO/tests/Param_Test/ulonglong.cpp +++ b/TAO/tests/Param_Test/ulonglong.cpp @@ -39,8 +39,8 @@ Test_ULongLong::opname (void) const } void -Test_ULongLong::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_ULongLong::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_; req->add_inout_arg ("s2") <<= this->inout_; @@ -48,25 +48,25 @@ Test_ULongLong::dii_req_invoke (CORBA::Request *req, req->set_return_type (CORBA::_tc_ulonglong); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; req->return_value () >>= this->ret_; CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= this->inout_; CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= this->out_; } int -Test_ULongLong::init_parameters (Param_Test_ptr , - CORBA::Environment &) +Test_ULongLong::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { Generator *gen = GENERATOR::instance (); // value generator @@ -85,15 +85,15 @@ Test_ULongLong::reset_parameters (void) } int -Test_ULongLong::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_ULongLong::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { this->ret_ = objref->test_ulonglong (this->in_, this->inout_, - this->out_, - ACE_TRY_ENV); + this->out_ + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; diff --git a/TAO/tests/Param_Test/ulonglong.h b/TAO/tests/Param_Test/ulonglong.h index 452f9721aa6..630fd839570 100644 --- a/TAO/tests/Param_Test/ulonglong.h +++ b/TAO/tests/Param_Test/ulonglong.h @@ -30,15 +30,15 @@ public: ~Test_ULongLong (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -53,7 +53,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/var_array.cpp b/TAO/tests/Param_Test/var_array.cpp index ea7a29e70f9..7a429a50a7e 100644 --- a/TAO/tests/Param_Test/var_array.cpp +++ b/TAO/tests/Param_Test/var_array.cpp @@ -45,8 +45,8 @@ Test_Var_Array::opname (void) const } void -Test_Var_Array::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Var_Array::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= Param_Test::Var_Array_forany (this->in_); req->add_inout_arg ("s2") <<= Param_Test::Var_Array_forany (this->inout_); @@ -54,7 +54,7 @@ Test_Var_Array::dii_req_invoke (CORBA::Request *req, req->set_return_type (Param_Test::_tc_Var_Array); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Param_Test::Var_Array_forany forany; @@ -63,21 +63,21 @@ Test_Var_Array::dii_req_invoke (CORBA::Request *req, this->ret_ = Param_Test::Var_Array_dup (forany.in ()); CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= forany; Param_Test::Var_Array_copy (this->inout_, forany.in ()); CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= forany; this->out_ = Param_Test::Var_Array_dup (forany.in ()); } int -Test_Var_Array::init_parameters (Param_Test_ptr , - CORBA::Environment &) +Test_Var_Array::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { Generator *gen = GENERATOR::instance (); // value generator @@ -103,16 +103,16 @@ Test_Var_Array::reset_parameters (void) } int -Test_Var_Array::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Var_Array::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { Param_Test::Var_Array_out out_arr (this->out_.out ()); this->ret_ = objref->test_var_array (this->in_, this->inout_, - out_arr, - ACE_TRY_ENV); + out_arr + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/var_array.h b/TAO/tests/Param_Test/var_array.h index f281f8dc558..f964a09a1a3 100644 --- a/TAO/tests/Param_Test/var_array.h +++ b/TAO/tests/Param_Test/var_array.h @@ -33,15 +33,15 @@ public: ~Test_Var_Array (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -56,7 +56,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *,CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Param_Test/var_struct.cpp b/TAO/tests/Param_Test/var_struct.cpp index ce87174a3b2..849d80bcb16 100644 --- a/TAO/tests/Param_Test/var_struct.cpp +++ b/TAO/tests/Param_Test/var_struct.cpp @@ -48,8 +48,8 @@ Test_Var_Struct::opname (void) const } void -Test_Var_Struct::dii_req_invoke (CORBA::Request *req, - CORBA::Environment &ACE_TRY_ENV) +Test_Var_Struct::dii_req_invoke (CORBA::Request *req + TAO_ENV_ARG_DECL) { req->add_in_arg ("s1") <<= this->in_; req->add_inout_arg ("s2") <<= this->inout_.in (); @@ -57,7 +57,7 @@ Test_Var_Struct::dii_req_invoke (CORBA::Request *req, req->set_return_type (Param_Test::_tc_Var_Struct); - req->invoke (ACE_TRY_ENV); + req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Param_Test::Var_Struct *tmp; @@ -65,21 +65,21 @@ Test_Var_Struct::dii_req_invoke (CORBA::Request *req, this->ret_ = new Param_Test::Var_Struct (*tmp); CORBA::NamedValue_ptr o2 = - req->arguments ()->item (1, ACE_TRY_ENV); + req->arguments ()->item (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o2->value () >>= tmp; this->inout_ = new Param_Test::Var_Struct (*tmp); CORBA::NamedValue_ptr o3 = - req->arguments ()->item (2, ACE_TRY_ENV); + req->arguments ()->item (2 TAO_ENV_ARG_PARAMETER); ACE_CHECK; *o3->value () >>= tmp; this->out_ = new Param_Test::Var_Struct (*tmp); } int -Test_Var_Struct::init_parameters (Param_Test_ptr, - CORBA::Environment &) +Test_Var_Struct::init_parameters (Param_Test_ptr + TAO_ENV_ARG_DECL_NOT_USED) { Generator *gen = GENERATOR::instance (); // value generator @@ -133,16 +133,16 @@ Test_Var_Struct::reset_parameters (void) } int -Test_Var_Struct::run_sii_test (Param_Test_ptr objref, - CORBA::Environment &ACE_TRY_ENV) +Test_Var_Struct::run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL) { ACE_TRY { Param_Test::Var_Struct_out out (this->out_.out ()); this->ret_ = objref->test_var_struct (this->in_, this->inout_.inout (), - out, - ACE_TRY_ENV); + out + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; return 0; diff --git a/TAO/tests/Param_Test/var_struct.h b/TAO/tests/Param_Test/var_struct.h index de08ee37c24..b9fea7c0028 100644 --- a/TAO/tests/Param_Test/var_struct.h +++ b/TAO/tests/Param_Test/var_struct.h @@ -34,15 +34,15 @@ public: ~Test_Var_Struct (void); // dtor - int run_sii_test (Param_Test_ptr objref, - CORBA::Environment &env); + int run_sii_test (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // run the SII test const char *opname (void) const; // return operation name - int init_parameters (Param_Test_ptr objref, - CORBA::Environment &env); + int init_parameters (Param_Test_ptr objref + TAO_ENV_ARG_DECL); // set values for parameters int reset_parameters (void); @@ -57,7 +57,7 @@ public: void print_values (void); // print all the values - void dii_req_invoke (CORBA::Request *, CORBA::Environment &); + void dii_req_invoke (CORBA::Request * TAO_ENV_ARG_DECL_NOT_USED); // invoke DII request with appropriate exception handling. private: diff --git a/TAO/tests/Policies/Manipulation.cpp b/TAO/tests/Policies/Manipulation.cpp index 35e6907b42b..4993239c92d 100644 --- a/TAO/tests/Policies/Manipulation.cpp +++ b/TAO/tests/Policies/Manipulation.cpp @@ -62,8 +62,8 @@ private: void perform_iteration (ACE_RANDR_TYPE &seed, CORBA::PolicyList_var &policies, CORBA::PolicyManager_ptr policy_manager, - CORBA::PolicyCurrent_ptr policy_current, - CORBA::Environment &ACE_TRY_ENV); + CORBA::PolicyCurrent_ptr policy_current + TAO_ENV_ARG_DECL); private: CORBA::ORB_var orb_; @@ -82,19 +82,19 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = - orb->string_to_object ("corbaloc:iiop:localhost:12345/FakeIOR", - ACE_TRY_ENV); + orb->string_to_object ("corbaloc:iiop:localhost:12345/FakeIOR" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test_var test = - Test::_unchecked_narrow (object.in (), ACE_TRY_ENV); + Test::_unchecked_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (test.in ())) @@ -144,8 +144,8 @@ void Manipulation::perform_iteration (ACE_RANDR_TYPE &seed, CORBA::PolicyList_var &policies, CORBA::PolicyManager_ptr policy_manager, - CORBA::PolicyCurrent_ptr policy_current, - CORBA::Environment &ACE_TRY_ENV) + CORBA::PolicyCurrent_ptr policy_current + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -205,8 +205,8 @@ Manipulation::perform_iteration (ACE_RANDR_TYPE &seed, } policy = this->orb_->create_policy (policy_type, - any, - ACE_TRY_ENV); + any + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::SetOverrideType override_type = CORBA::SET_OVERRIDE; @@ -226,16 +226,16 @@ Manipulation::perform_iteration (ACE_RANDR_TYPE &seed, { CORBA::Object_var tmp = this->test_->_set_policy_overrides (policy_list, - override_type, - ACE_TRY_ENV); + override_type + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } else if (operation == ADD_CURRENT_POLICY || operation == SET_CURRENT_POLICY) { policy_current->set_policy_overrides (policy_list, - override_type, - ACE_TRY_ENV); + override_type + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } else @@ -243,25 +243,25 @@ Manipulation::perform_iteration (ACE_RANDR_TYPE &seed, // operation == ADD_CURRENT_POLICY // || operation == SET_CURRENT_POLICY) policy_manager->set_policy_overrides (policy_list, - override_type, - ACE_TRY_ENV); + override_type + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } - policy_list[0]->destroy (ACE_TRY_ENV); + policy_list[0]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } else if (operation == SAVE_CURRENT_POLICIES) { CORBA::PolicyTypeSeq types; policies = - policy_current->get_policy_overrides (types, ACE_TRY_ENV); + policy_current->get_policy_overrides (types TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } else if (operation == SAVE_MANAGER_POLICIES) { CORBA::PolicyTypeSeq types; policies = - policy_manager->get_policy_overrides (types, ACE_TRY_ENV); + policy_manager->get_policy_overrides (types TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } else if (operation == RESTORE_CURRENT_POLICIES) @@ -269,8 +269,8 @@ Manipulation::perform_iteration (ACE_RANDR_TYPE &seed, if (policies.ptr () != 0) { policy_current->set_policy_overrides (policies.in (), - CORBA::SET_OVERRIDE, - ACE_TRY_ENV); + CORBA::SET_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } } @@ -279,8 +279,8 @@ Manipulation::perform_iteration (ACE_RANDR_TYPE &seed, if (policies.ptr () != 0) { policy_manager->set_policy_overrides (policies.in (), - CORBA::SET_OVERRIDE, - ACE_TRY_ENV); + CORBA::SET_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } } @@ -306,21 +306,21 @@ Manipulation::svc (void) ACE_static_cast (ACE_RANDR_TYPE, ACE_OS::gethrtime().lo()); #endif CORBA::Object_var object = - this->orb_->resolve_initial_references ("ORBPolicyManager", - ACE_TRY_ENV); + this->orb_->resolve_initial_references ("ORBPolicyManager" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyManager_var policy_manager = - CORBA::PolicyManager::_narrow (object.in (), ACE_TRY_ENV); + CORBA::PolicyManager::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; object = - this->orb_->resolve_initial_references ("PolicyCurrent", - ACE_TRY_ENV); + this->orb_->resolve_initial_references ("PolicyCurrent" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyCurrent_var policy_current = - CORBA::PolicyCurrent::_narrow (object.in (), ACE_TRY_ENV); + CORBA::PolicyCurrent::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; @@ -330,8 +330,8 @@ Manipulation::svc (void) this->perform_iteration (seed, policies, policy_manager.in (), - policy_current.in (), - ACE_TRY_ENV); + policy_current.in () + TAO_ENV_ARG_PARAMETER); } } ACE_CATCHANY diff --git a/TAO/tests/Portable_Interceptors/Benchmark/Client_ORBInitializer.cpp b/TAO/tests/Portable_Interceptors/Benchmark/Client_ORBInitializer.cpp index 7a1d81fa95e..2e59b25ca5c 100644 --- a/TAO/tests/Portable_Interceptors/Benchmark/Client_ORBInitializer.cpp +++ b/TAO/tests/Portable_Interceptors/Benchmark/Client_ORBInitializer.cpp @@ -28,7 +28,6 @@ Client_ORBInitializer::post_init ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; PortableInterceptor::ClientRequestInterceptor_ptr tmp = PortableInterceptor::ClientRequestInterceptor::_nil (); @@ -68,7 +67,7 @@ Client_ORBInitializer::post_init ( PortableInterceptor::ClientRequestInterceptor_var interceptor = tmp; - info->add_client_request_interceptor (interceptor.in (), - ACE_TRY_ENV); + info->add_client_request_interceptor (interceptor.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } diff --git a/TAO/tests/Portable_Interceptors/Benchmark/Server_ORBInitializer.cpp b/TAO/tests/Portable_Interceptors/Benchmark/Server_ORBInitializer.cpp index 7c0e609f4a5..c1cabcaa2d4 100644 --- a/TAO/tests/Portable_Interceptors/Benchmark/Server_ORBInitializer.cpp +++ b/TAO/tests/Portable_Interceptors/Benchmark/Server_ORBInitializer.cpp @@ -30,7 +30,6 @@ Server_ORBInitializer::post_init ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; PortableInterceptor::ServerRequestInterceptor_ptr tmp = PortableInterceptor::ServerRequestInterceptor::_nil (); @@ -70,7 +69,7 @@ Server_ORBInitializer::post_init ( PortableInterceptor::ServerRequestInterceptor_var interceptor = tmp; - info->add_server_request_interceptor (interceptor.in (), - ACE_TRY_ENV); + info->add_server_request_interceptor (interceptor.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } diff --git a/TAO/tests/Portable_Interceptors/Benchmark/client.cpp b/TAO/tests/Portable_Interceptors/Benchmark/client.cpp index dba57b7a213..32370917a2d 100644 --- a/TAO/tests/Portable_Interceptors/Benchmark/client.cpp +++ b/TAO/tests/Portable_Interceptors/Benchmark/client.cpp @@ -49,8 +49,8 @@ parse_args (int argc, char *argv[]) void -run_test (Test_Interceptors::Secure_Vault_ptr server, - CORBA::Environment &ACE_TRY_ENV) +run_test (Test_Interceptors::Secure_Vault_ptr server + TAO_ENV_ARG_DECL) { int i = 0; const char user[] = "root"; @@ -68,7 +68,7 @@ run_test (Test_Interceptors::Secure_Vault_ptr server, // Record current time. ACE_hrtime_t latency_base = ACE_OS::gethrtime (); - server->ready (ACE_TRY_ENV); + server->ready (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; // Grab timestamp again. @@ -96,7 +96,7 @@ run_test (Test_Interceptors::Secure_Vault_ptr server, // Record current time. ACE_hrtime_t latency_base = ACE_OS::gethrtime (); - server->authenticate (user, ACE_TRY_ENV); + server->authenticate (user TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Grab timestamp again. @@ -133,8 +133,8 @@ run_test (Test_Interceptors::Secure_Vault_ptr server, ACE_hrtime_t latency_base = ACE_OS::gethrtime (); server->update_records (id, - record, - ACE_TRY_ENV); + record + TAO_ENV_ARG_PARAMETER); // Grab timestamp again. ACE_hrtime_t now = ACE_OS::gethrtime (); @@ -190,24 +190,24 @@ main (int argc, char *argv[]) PortableInterceptor::ORBInitializer_var initializer = temp_initializer; - PortableInterceptor::register_orb_initializer (initializer.in (), - ACE_TRY_ENV); + PortableInterceptor::register_orb_initializer (initializer.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test_Interceptors::Secure_Vault_var server = - Test_Interceptors::Secure_Vault::_narrow (object.in (), - ACE_TRY_ENV); + Test_Interceptors::Secure_Vault::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -223,10 +223,10 @@ main (int argc, char *argv[]) // This test is useful for benchmarking the differences when // the same method is intercepted by different interceptors // wanting to achieve different functionality. - run_test (server.in (), ACE_TRY_ENV); + run_test (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Portable_Interceptors/Benchmark/interceptors.cpp b/TAO/tests/Portable_Interceptors/Benchmark/interceptors.cpp index 937fca29e1b..9c9eb160a09 100644 --- a/TAO/tests/Portable_Interceptors/Benchmark/interceptors.cpp +++ b/TAO/tests/Portable_Interceptors/Benchmark/interceptors.cpp @@ -61,9 +61,8 @@ Vault_Client_Request_Interceptor::send_request ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; - CORBA::String_var op = ri->operation (ACE_TRY_ENV); + CORBA::String_var op = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (ACE_OS::strcmp (op.in (), "authenticate") == 0) @@ -82,14 +81,14 @@ Vault_Client_Request_Interceptor::send_request ( sc.context_data.replace (string_len, string_len, buf, 1); // Add this context to the service context list. - ri->add_request_service_context (sc, 0, ACE_TRY_ENV); + ri->add_request_service_context (sc, 0 TAO_ENV_ARG_PARAMETER); ACE_CHECK; } if (ACE_OS::strcmp (op.in (), "update_records") == 0) { Dynamic::ParameterList_var paramlist = - ri->arguments (ACE_TRY_ENV); + ri->arguments (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Test_Interceptors::Secure_Vault::Record *record; @@ -107,15 +106,14 @@ Vault_Client_Request_Interceptor::receive_reply ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; - CORBA::String_var op = ri->operation (ACE_TRY_ENV); + CORBA::String_var op = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (ACE_OS::strcmp (op.in (), "update_records") == 0) { CORBA::Long result; - CORBA::Any_var result_any = ri->result (ACE_TRY_ENV); + CORBA::Any_var result_any = ri->result (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; (result_any.in ()) >>= result; @@ -139,18 +137,17 @@ Vault_Client_Request_Interceptor::receive_exception ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; - CORBA::Any_var any = ri->received_exception (ACE_TRY_ENV); + CORBA::Any_var any = ri->received_exception (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::TypeCode_var tc = any->type (); - const char *id = tc->id (ACE_TRY_ENV); + const char *id = tc->id (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::String_var exception_id = - ri->received_exception_id (ACE_TRY_ENV); + ri->received_exception_id (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (ACE_OS::strcmp (id, exception_id.in ()) != 0) @@ -214,16 +211,15 @@ Vault_Server_Request_Interceptor::receive_request ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; - CORBA::String_var op = ri->operation (ACE_TRY_ENV); + CORBA::String_var op = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (ACE_OS::strcmp (op.in (), "authenticate") == 0) { IOP::ServiceId id = request_ctx_id; IOP::ServiceContext_var sc = - ri->get_request_service_context (id, ACE_TRY_ENV); + ri->get_request_service_context (id TAO_ENV_ARG_PARAMETER); ACE_CHECK; const char *buf = @@ -237,7 +233,7 @@ Vault_Server_Request_Interceptor::receive_request ( if (ACE_OS::strcmp (op.in (), "update_records") == 0) { Dynamic::ParameterList_var paramlist = - ri->arguments (ACE_TRY_ENV); + ri->arguments (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Test_Interceptors::Secure_Vault::Record *record; @@ -255,15 +251,14 @@ Vault_Server_Request_Interceptor::send_reply ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; - CORBA::String_var op = ri->operation (ACE_TRY_ENV); + CORBA::String_var op = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (ACE_OS::strcmp (op.in (), "update_records") == 0) { CORBA::Long result; - CORBA::Any_var result_any = ri->result (ACE_TRY_ENV); + CORBA::Any_var result_any = ri->result (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; (result_any.in ()) >>= result; @@ -347,7 +342,6 @@ Vault_Client_Request_Context_Interceptor::send_request ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; // MAke the context to send the context to the target IOP::ServiceContext sc; @@ -366,7 +360,7 @@ Vault_Client_Request_Context_Interceptor::send_request ( sc.context_data.replace (string_len, string_len, buf, 1); // Add this context to the service context list. - ri->add_request_service_context (sc, 0, ACE_TRY_ENV); + ri->add_request_service_context (sc, 0 TAO_ENV_ARG_PARAMETER); ACE_CHECK; } @@ -396,18 +390,17 @@ Vault_Client_Request_Context_Interceptor::receive_exception ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; - CORBA::Any_var any = ri->received_exception (ACE_TRY_ENV); + CORBA::Any_var any = ri->received_exception (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::TypeCode_var tc = any->type (); - const char *id = tc->id (ACE_TRY_ENV); + const char *id = tc->id (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::String_var exception_id = - ri->received_exception_id (ACE_TRY_ENV); + ri->received_exception_id (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (ACE_OS::strcmp (id, exception_id.in ()) != 0) @@ -473,11 +466,10 @@ Vault_Server_Request_Context_Interceptor::receive_request ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; IOP::ServiceId id = request_ctx_id; IOP::ServiceContext_var sc = - ri->get_request_service_context (id, ACE_TRY_ENV); + ri->get_request_service_context (id TAO_ENV_ARG_PARAMETER); ACE_CHECK; const char *buf = ACE_reinterpret_cast (const char *, @@ -571,15 +563,14 @@ Vault_Client_Request_Dynamic_Interceptor::send_request ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; - CORBA::String_var op = ri->operation (ACE_TRY_ENV); + CORBA::String_var op = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (ACE_OS::strcmp (op.in (), "authenticate") == 0) { Dynamic::ParameterList_var paramlist = - ri->arguments (ACE_TRY_ENV); + ri->arguments (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; const char *user; @@ -591,7 +582,7 @@ Vault_Client_Request_Dynamic_Interceptor::send_request ( if (ACE_OS::strcmp (op.in (), "update_records") == 0) { Dynamic::ParameterList_var paramlist = - ri->arguments (ACE_TRY_ENV); + ri->arguments (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Test_Interceptors::Secure_Vault::Record *record; @@ -609,16 +600,15 @@ Vault_Client_Request_Dynamic_Interceptor::receive_reply ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; - CORBA::String_var op = ri->operation (ACE_TRY_ENV); + CORBA::String_var op = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (ACE_OS::strcmp (op.in (), "ready") == 0) { CORBA::Short result; - CORBA::Any_var result_any = ri->result (ACE_TRY_ENV); + CORBA::Any_var result_any = ri->result (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; (result_any.in ()) >>= result; @@ -628,7 +618,7 @@ Vault_Client_Request_Dynamic_Interceptor::receive_reply ( { CORBA::Long result; - CORBA::Any_var result_any = ri->result (ACE_TRY_ENV); + CORBA::Any_var result_any = ri->result (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; (result_any.in ()) >>= result; @@ -652,18 +642,17 @@ Vault_Client_Request_Dynamic_Interceptor::receive_exception ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; - CORBA::Any_var any = ri->received_exception (ACE_TRY_ENV); + CORBA::Any_var any = ri->received_exception (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::TypeCode_var tc = any->type (); - const char *id = tc->id (ACE_TRY_ENV); + const char *id = tc->id (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::String_var exception_id = - ri->received_exception_id (ACE_TRY_ENV); + ri->received_exception_id (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (ACE_OS::strcmp (id, exception_id.in ()) != 0) @@ -719,15 +708,14 @@ Vault_Server_Request_Dynamic_Interceptor::receive_request ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; - CORBA::String_var op = ri->operation (ACE_TRY_ENV); + CORBA::String_var op = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (ACE_OS::strcmp (op.in (), "authenticate") == 0) { Dynamic::ParameterList_var paramlist = - ri->arguments (ACE_TRY_ENV); + ri->arguments (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; const char *user; @@ -739,7 +727,7 @@ Vault_Server_Request_Dynamic_Interceptor::receive_request ( if (ACE_OS::strcmp (op.in (), "update_records") == 0) { Dynamic::ParameterList_var paramlist = - ri->arguments (ACE_TRY_ENV); + ri->arguments (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Test_Interceptors::Secure_Vault::Record *record; @@ -767,15 +755,14 @@ Vault_Server_Request_Dynamic_Interceptor::send_reply ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; - CORBA::String_var op = ri->operation (ACE_TRY_ENV); + CORBA::String_var op = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (ACE_OS::strcmp (op.in (), "ready") == 0) { CORBA::Short result; - CORBA::Any_var result_any = ri->result (ACE_TRY_ENV); + CORBA::Any_var result_any = ri->result (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; (result_any.in ()) >>= result; @@ -784,7 +771,7 @@ Vault_Server_Request_Dynamic_Interceptor::send_reply ( if (ACE_OS::strcmp (op.in (), "update_records") == 0) { CORBA::Long result; - CORBA::Any_var result_any = ri->result (ACE_TRY_ENV); + CORBA::Any_var result_any = ri->result (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; (result_any.in ()) >>= result; @@ -894,18 +881,17 @@ Vault_Client_Request_NOOP_Interceptor::receive_exception ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; - CORBA::Any_var any = ri->received_exception (ACE_TRY_ENV); + CORBA::Any_var any = ri->received_exception (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::TypeCode_var tc = any->type (); - const char *id = tc->id (ACE_TRY_ENV); + const char *id = tc->id (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::String_var exception_id = - ri->received_exception_id (ACE_TRY_ENV); + ri->received_exception_id (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (ACE_OS::strcmp (id, exception_id.in ()) != 0) diff --git a/TAO/tests/Portable_Interceptors/Benchmark/server.cpp b/TAO/tests/Portable_Interceptors/Benchmark/server.cpp index 50fbc18e35e..c25209504bb 100644 --- a/TAO/tests/Portable_Interceptors/Benchmark/server.cpp +++ b/TAO/tests/Portable_Interceptors/Benchmark/server.cpp @@ -52,19 +52,19 @@ main (int argc, char *argv[]) PortableInterceptor::ORBInitializer_var initializer = temp_initializer; - PortableInterceptor::register_orb_initializer (initializer.in (), - ACE_TRY_ENV); + PortableInterceptor::register_orb_initializer (initializer.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) ACE_ERROR_RETURN ((LM_ERROR, @@ -72,35 +72,35 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Secure_Vault_i server_impl (orb.in ()); PortableServer::ObjectId_var id = - root_poa->activate_object (&server_impl, - ACE_TRY_ENV); + root_poa->activate_object (&server_impl + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var test_obj = - root_poa->id_to_reference (id.in (), - ACE_TRY_ENV); + root_poa->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test_Interceptors::Secure_Vault_var server = - Test_Interceptors::Secure_Vault::_narrow (test_obj.in (), - ACE_TRY_ENV); + Test_Interceptors::Secure_Vault::_narrow (test_obj.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -120,12 +120,12 @@ main (int argc, char *argv[]) ACE_OS::fclose (output_file); } - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Portable_Interceptors/Benchmark/test_i.cpp b/TAO/tests/Portable_Interceptors/Benchmark/test_i.cpp index 934e5482291..748820c893b 100644 --- a/TAO/tests/Portable_Interceptors/Benchmark/test_i.cpp +++ b/TAO/tests/Portable_Interceptors/Benchmark/test_i.cpp @@ -12,15 +12,15 @@ Secure_Vault_i::Secure_Vault_i (CORBA::ORB_ptr orb) // ctor CORBA::Short -Secure_Vault_i::ready (CORBA::Environment &) +Secure_Vault_i::ready (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return 1; } void -Secure_Vault_i::authenticate (const char * user, - CORBA::Environment &ACE_TRY_ENV) +Secure_Vault_i::authenticate (const char * user + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, Test_Interceptors::Invalid)) { @@ -31,16 +31,16 @@ Secure_Vault_i::authenticate (const char * user, CORBA::Long Secure_Vault_i::update_records (CORBA::Long, - const Test_Interceptors::Secure_Vault::Record &, - CORBA::Environment &) + const Test_Interceptors::Secure_Vault::Record & + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return 1; } void -Secure_Vault_i::shutdown (CORBA::Environment &ACE_TRY_ENV) +Secure_Vault_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/Portable_Interceptors/Benchmark/test_i.h b/TAO/tests/Portable_Interceptors/Benchmark/test_i.h index 573c522a3e0..07891acfc20 100644 --- a/TAO/tests/Portable_Interceptors/Benchmark/test_i.h +++ b/TAO/tests/Portable_Interceptors/Benchmark/test_i.h @@ -27,25 +27,21 @@ public: Secure_Vault_i (CORBA::ORB_ptr orb); // ctor - virtual CORBA::Short ready (CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + virtual CORBA::Short ready (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void authenticate (const char * user, - CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + virtual void authenticate (const char * user + TAO_ENV_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException, Test_Interceptors::Invalid)); // Passwd sent in the service context list virtual CORBA::Long update_records (CORBA::Long id, - const Test_Interceptors::Secure_Vault::Record & val, - CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + const Test_Interceptors::Secure_Vault::Record & val + TAO_ENV_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Portable_Interceptors/Dynamic/Echo_Client_ORBInitializer.cpp b/TAO/tests/Portable_Interceptors/Dynamic/Echo_Client_ORBInitializer.cpp index 09676fcd3d3..bd736641a5a 100644 --- a/TAO/tests/Portable_Interceptors/Dynamic/Echo_Client_ORBInitializer.cpp +++ b/TAO/tests/Portable_Interceptors/Dynamic/Echo_Client_ORBInitializer.cpp @@ -24,7 +24,6 @@ Echo_Client_ORBInitializer::post_init ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; PortableInterceptor::ClientRequestInterceptor_ptr interceptor = PortableInterceptor::ClientRequestInterceptor::_nil (); diff --git a/TAO/tests/Portable_Interceptors/Dynamic/Echo_Server_ORBInitializer.cpp b/TAO/tests/Portable_Interceptors/Dynamic/Echo_Server_ORBInitializer.cpp index c6b393e442c..3951c2527a6 100644 --- a/TAO/tests/Portable_Interceptors/Dynamic/Echo_Server_ORBInitializer.cpp +++ b/TAO/tests/Portable_Interceptors/Dynamic/Echo_Server_ORBInitializer.cpp @@ -24,7 +24,6 @@ Echo_Server_ORBInitializer::post_init ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; PortableInterceptor::ServerRequestInterceptor_ptr interceptor = PortableInterceptor::ServerRequestInterceptor::_nil (); diff --git a/TAO/tests/Portable_Interceptors/Dynamic/client.cpp b/TAO/tests/Portable_Interceptors/Dynamic/client.cpp index edb75f81cb8..d725bb1c6d7 100644 --- a/TAO/tests/Portable_Interceptors/Dynamic/client.cpp +++ b/TAO/tests/Portable_Interceptors/Dynamic/client.cpp @@ -38,16 +38,16 @@ parse_args (int argc, char *argv[]) } void -run_test (Test_Interceptors::Visual_ptr server, - CORBA::Environment &ACE_TRY_ENV) +run_test (Test_Interceptors::Visual_ptr server + TAO_ENV_ARG_DECL) { - server->normal (10, ACE_TRY_ENV); + server->normal (10 TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::Long one = 1, two = 1, result = 0; result = server->calculate (one, - two, - ACE_TRY_ENV); + two + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -57,7 +57,7 @@ run_test (Test_Interceptors::Visual_ptr server, ACE_TRY { - server->user (ACE_TRY_ENV); + server->user (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (Test_Interceptors::Silly, userex) @@ -69,7 +69,7 @@ run_test (Test_Interceptors::Visual_ptr server, ACE_TRY_EX (SYS) { - server->system (ACE_TRY_ENV); + server->system (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK_EX (SYS); } ACE_CATCH (CORBA::INV_OBJREF, sysex) @@ -93,23 +93,23 @@ main (int argc, char *argv[]) PortableInterceptor::ORBInitializer_var orb_initializer = temp_initializer; - PortableInterceptor::register_orb_initializer (orb_initializer.in (), - ACE_TRY_ENV); + PortableInterceptor::register_orb_initializer (orb_initializer.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test_Interceptors::Visual_var server = - Test_Interceptors::Visual::_narrow (object.in (), ACE_TRY_ENV); + Test_Interceptors::Visual::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -120,9 +120,9 @@ main (int argc, char *argv[]) 1); } - run_test (server.in (), ACE_TRY_ENV); + run_test (server.in () TAO_ENV_ARG_PARAMETER); - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Portable_Interceptors/Dynamic/interceptors.cpp b/TAO/tests/Portable_Interceptors/Dynamic/interceptors.cpp index 093a0497204..c3292620654 100644 --- a/TAO/tests/Portable_Interceptors/Dynamic/interceptors.cpp +++ b/TAO/tests/Portable_Interceptors/Dynamic/interceptors.cpp @@ -64,9 +64,8 @@ Echo_Client_Request_Interceptor::send_request ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; - CORBA::String_var op = ri->operation (ACE_TRY_ENV); + CORBA::String_var op = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -77,7 +76,7 @@ Echo_Client_Request_Interceptor::send_request ( if (ACE_OS::strcmp (op.in (), "normal") == 0) { Dynamic::ParameterList_var paramlist = - ri->arguments (ACE_TRY_ENV); + ri->arguments (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::Long param; @@ -98,9 +97,8 @@ Echo_Client_Request_Interceptor::receive_other ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; - CORBA::String_var op = ri->operation (ACE_TRY_ENV); + CORBA::String_var op = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -115,9 +113,8 @@ Echo_Client_Request_Interceptor::receive_reply ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; - CORBA::String_var op = ri->operation (ACE_TRY_ENV); + CORBA::String_var op = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -128,7 +125,7 @@ Echo_Client_Request_Interceptor::receive_reply ( if (ACE_OS::strcmp (op.in (), "normal") == 0) { Dynamic::ParameterList_var paramlist = - ri->arguments (ACE_TRY_ENV); + ri->arguments (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::Long param; @@ -143,7 +140,7 @@ Echo_Client_Request_Interceptor::receive_reply ( if (ACE_OS::strcmp (op.in (), "calculate") == 0) { Dynamic::ParameterList_var paramlist = - ri->arguments (ACE_TRY_ENV); + ri->arguments (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::Long param1, param2, result; @@ -152,7 +149,7 @@ Echo_Client_Request_Interceptor::receive_reply ( paramlist[i++].argument >>= param1; paramlist[i].argument >>= param2; - CORBA::Any_var result_any = ri->result (ACE_TRY_ENV); + CORBA::Any_var result_any = ri->result (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; (result_any.in ()) >>= result; @@ -172,9 +169,8 @@ Echo_Client_Request_Interceptor::receive_exception ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; - CORBA::String_var op = ri->operation (ACE_TRY_ENV); + CORBA::String_var op = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -184,7 +180,7 @@ Echo_Client_Request_Interceptor::receive_exception ( CORBA::String_var exception_id = - ri->received_exception_id (ACE_TRY_ENV); + ri->received_exception_id (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -244,9 +240,8 @@ Echo_Server_Request_Interceptor::receive_request ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; - CORBA::String_var op = ri->operation (ACE_TRY_ENV); + CORBA::String_var op = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -256,7 +251,7 @@ Echo_Server_Request_Interceptor::receive_request ( if (ACE_OS::strcmp (op.in (), "normal") == 0) { Dynamic::ParameterList_var paramlist = - ri->arguments (ACE_TRY_ENV); + ri->arguments (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::Long param; @@ -271,7 +266,7 @@ Echo_Server_Request_Interceptor::receive_request ( } CORBA::String_var tmdi = - ri->target_most_derived_interface (ACE_TRY_ENV); + ri->target_most_derived_interface (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -285,9 +280,8 @@ Echo_Server_Request_Interceptor::send_reply ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; - CORBA::String_var op = ri->operation (ACE_TRY_ENV); + CORBA::String_var op = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -297,7 +291,7 @@ Echo_Server_Request_Interceptor::send_reply ( if (ACE_OS::strcmp (op.in (), "normal") == 0) { Dynamic::ParameterList_var paramlist = - ri->arguments (ACE_TRY_ENV); + ri->arguments (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::Long param; @@ -312,7 +306,7 @@ Echo_Server_Request_Interceptor::send_reply ( if (ACE_OS::strcmp (op.in (), "calculate") == 0) { Dynamic::ParameterList_var paramlist = - ri->arguments (ACE_TRY_ENV); + ri->arguments (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::Long param1, param2, result = 0; @@ -321,7 +315,7 @@ Echo_Server_Request_Interceptor::send_reply ( paramlist[i++].argument >>= param1; paramlist[i].argument >>= param2; - CORBA::Any_var result_any = ri->result (ACE_TRY_ENV); + CORBA::Any_var result_any = ri->result (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; (result_any.in ()) >>= result; @@ -341,9 +335,8 @@ Echo_Server_Request_Interceptor::send_exception ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; - CORBA::String_var op = ri->operation (ACE_TRY_ENV); + CORBA::String_var op = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -353,12 +346,12 @@ Echo_Server_Request_Interceptor::send_exception ( CORBA::Any_var any = - ri->sending_exception (ACE_TRY_ENV); + ri->sending_exception (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::TypeCode_var type = any->type (); - const char *exception_id = type->id (ACE_TRY_ENV); + const char *exception_id = type->id (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, diff --git a/TAO/tests/Portable_Interceptors/Dynamic/interceptors.h b/TAO/tests/Portable_Interceptors/Dynamic/interceptors.h index fccabebecf0..68777008e86 100644 --- a/TAO/tests/Portable_Interceptors/Dynamic/interceptors.h +++ b/TAO/tests/Portable_Interceptors/Dynamic/interceptors.h @@ -42,7 +42,7 @@ public: virtual void send_poll ( PortableInterceptor::ClientRequestInfo_ptr - TAO_ENV_ARG_DECL_WITH_DEFAULTS + TAO_ENV_ARG_DECL_WITH_DEFAULTS ) ACE_THROW_SPEC (( CORBA::SystemException @@ -65,7 +65,7 @@ public: virtual void receive_reply (PortableInterceptor::ClientRequestInfo_ptr ri TAO_ENV_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); - + virtual void receive_exception ( PortableInterceptor::ClientRequestInfo_ptr ri TAO_ENV_ARG_DECL_WITH_DEFAULTS) @@ -123,10 +123,10 @@ public: TAO_ENV_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)); - + virtual void send_other ( PortableInterceptor::ServerRequestInfo_ptr - TAO_ENV_ARG_DECL_WITH_DEFAULTS + TAO_ENV_ARG_DECL_WITH_DEFAULTS ) ACE_THROW_SPEC (( CORBA::SystemException, diff --git a/TAO/tests/Portable_Interceptors/Dynamic/server.cpp b/TAO/tests/Portable_Interceptors/Dynamic/server.cpp index 7ac5b662972..3acaf0dba2f 100644 --- a/TAO/tests/Portable_Interceptors/Dynamic/server.cpp +++ b/TAO/tests/Portable_Interceptors/Dynamic/server.cpp @@ -50,16 +50,16 @@ main (int argc, char *argv[]) PortableInterceptor::ORBInitializer_var orb_initializer = temp_initializer; - PortableInterceptor::register_orb_initializer (orb_initializer.in (), - ACE_TRY_ENV); + PortableInterceptor::register_orb_initializer (orb_initializer.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -68,14 +68,14 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -84,22 +84,22 @@ main (int argc, char *argv[]) Visual_i server_impl (orb.in ()); PortableServer::ObjectId_var id = - root_poa->activate_object (&server_impl, - ACE_TRY_ENV); + root_poa->activate_object (&server_impl + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var test_obj = - root_poa->id_to_reference (id.in (), - ACE_TRY_ENV); + root_poa->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test_Interceptors::Visual_var server = - Test_Interceptors::Visual::_narrow (test_obj.in (), - ACE_TRY_ENV); + Test_Interceptors::Visual::_narrow (test_obj.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Test_Interceptors::Visual: <%s>\n", ior.in ())); @@ -117,12 +117,12 @@ main (int argc, char *argv[]) ACE_OS::fclose (output_file); } - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Portable_Interceptors/Dynamic/test_i.cpp b/TAO/tests/Portable_Interceptors/Dynamic/test_i.cpp index 731f0b30ea8..64c80dd0a86 100644 --- a/TAO/tests/Portable_Interceptors/Dynamic/test_i.cpp +++ b/TAO/tests/Portable_Interceptors/Dynamic/test_i.cpp @@ -11,8 +11,8 @@ Visual_i::Visual_i (CORBA::ORB_ptr orb) // ctor void -Visual_i::normal (CORBA::Long arg, - CORBA::Environment&) +Visual_i::normal (CORBA::Long arg + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "Visual::normal called with %d\n", arg)); @@ -20,8 +20,8 @@ Visual_i::normal (CORBA::Long arg, CORBA::Long Visual_i::calculate (CORBA::Long one, - CORBA::Long two, - CORBA::Environment&) + CORBA::Long two + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "Visual::calculate\n")); @@ -29,7 +29,7 @@ Visual_i::calculate (CORBA::Long one, } void -Visual_i::user (CORBA::Environment &ACE_TRY_ENV) +Visual_i::user (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException,Test_Interceptors::Silly)) { ACE_DEBUG ((LM_DEBUG, "Visual::user, throwning Silly\n")); @@ -37,7 +37,7 @@ Visual_i::user (CORBA::Environment &ACE_TRY_ENV) } void -Visual_i::system (CORBA::Environment &ACE_TRY_ENV) +Visual_i::system (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "Visual::user, throwing INV_OBJREF\n")); @@ -45,7 +45,7 @@ Visual_i::system (CORBA::Environment &ACE_TRY_ENV) } void -Visual_i::shutdown (CORBA::Environment&) +Visual_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->orb_->shutdown (); diff --git a/TAO/tests/Portable_Interceptors/Dynamic/test_i.h b/TAO/tests/Portable_Interceptors/Dynamic/test_i.h index 5def6b74e00..1c679a55b7c 100644 --- a/TAO/tests/Portable_Interceptors/Dynamic/test_i.h +++ b/TAO/tests/Portable_Interceptors/Dynamic/test_i.h @@ -27,23 +27,23 @@ public: Visual_i (CORBA::ORB_ptr orb); // ctor - void normal (CORBA::Long arg, - CORBA::Environment&) + void normal (CORBA::Long arg + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); CORBA::Long calculate ( CORBA::Long one, - CORBA::Long two, - CORBA::Environment&) + CORBA::Long two + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void user (CORBA::Environment&) + void user (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException,Test_Interceptors::Silly)); - void system (CORBA::Environment&) + void system (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Portable_Interceptors/ForwardRequest/Client_ORBInitializer.cpp b/TAO/tests/Portable_Interceptors/ForwardRequest/Client_ORBInitializer.cpp index 5679d03a868..8ff1de5e5be 100644 --- a/TAO/tests/Portable_Interceptors/ForwardRequest/Client_ORBInitializer.cpp +++ b/TAO/tests/Portable_Interceptors/ForwardRequest/Client_ORBInitializer.cpp @@ -26,12 +26,10 @@ Client_ORBInitializer::post_init ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; - - CORBA::String_var orb_id = info->orb_id (ACE_TRY_ENV); + CORBA::String_var orb_id = info->orb_id (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; - CORBA::StringSeq_var args = info->arguments (ACE_TRY_ENV); + CORBA::StringSeq_var args = info->arguments (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::String_var forward_str; diff --git a/TAO/tests/Portable_Interceptors/ForwardRequest/Client_Request_Interceptor.cpp b/TAO/tests/Portable_Interceptors/ForwardRequest/Client_Request_Interceptor.cpp index c180e9e2067..104ad3d7681 100644 --- a/TAO/tests/Portable_Interceptors/ForwardRequest/Client_Request_Interceptor.cpp +++ b/TAO/tests/Portable_Interceptors/ForwardRequest/Client_Request_Interceptor.cpp @@ -38,12 +38,10 @@ Client_Request_Interceptor::send_request ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; - ++this->request_count_; CORBA::Boolean response_expected = - ri->response_expected (ACE_TRY_ENV); + ri->response_expected (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (!response_expected) // A one-way request. @@ -59,19 +57,19 @@ Client_Request_Interceptor::send_request ( int argc = 0; this->orb_ = CORBA::ORB_init (argc, 0, - this->orb_id_.in (), - ACE_TRY_ENV); + this->orb_id_.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } CORBA::Object_var forward = - this->orb_->string_to_object (this->forward_str_.in (), - ACE_TRY_ENV); + this->orb_->string_to_object (this->forward_str_.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::String_var forward_str = - this->orb_->object_to_string (forward.in (), - ACE_TRY_ENV); + this->orb_->object_to_string (forward.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -118,14 +116,13 @@ Client_Request_Interceptor::receive_other ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; CORBA::Boolean response_expected = - ri->response_expected (ACE_TRY_ENV); + ri->response_expected (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; PortableInterceptor::ReplyStatus reply_status = - ri->reply_status (ACE_TRY_ENV); + ri->reply_status (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (!response_expected // A one-way or asynchronous request. @@ -139,7 +136,7 @@ Client_Request_Interceptor::receive_other ( // This will throw an exception if a location forward has not // occured. If an exception is thrown then something is wrong with // the PortableInterceptor::ForwardRequest support. - CORBA::Object_var forward = ri->forward_reference (ACE_TRY_ENV); + CORBA::Object_var forward = ri->forward_reference (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (CORBA::is_nil (forward.in ())) diff --git a/TAO/tests/Portable_Interceptors/ForwardRequest/Server_ORBInitializer.cpp b/TAO/tests/Portable_Interceptors/ForwardRequest/Server_ORBInitializer.cpp index 5727f3bed21..9fed7eb387f 100644 --- a/TAO/tests/Portable_Interceptors/ForwardRequest/Server_ORBInitializer.cpp +++ b/TAO/tests/Portable_Interceptors/ForwardRequest/Server_ORBInitializer.cpp @@ -29,8 +29,6 @@ Server_ORBInitializer::post_init ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; - PortableInterceptor::ServerRequestInterceptor_ptr interceptor; // Install the server request interceptor. ACE_NEW_THROW_EX (interceptor, @@ -44,8 +42,8 @@ Server_ORBInitializer::post_init ( this->server_interceptor_ = interceptor; - info->add_server_request_interceptor (interceptor, - ACE_TRY_ENV); + info->add_server_request_interceptor (interceptor + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } diff --git a/TAO/tests/Portable_Interceptors/ForwardRequest/Server_Request_Interceptor.cpp b/TAO/tests/Portable_Interceptors/ForwardRequest/Server_Request_Interceptor.cpp index 81b29ec8b2e..650431f5134 100644 --- a/TAO/tests/Portable_Interceptors/ForwardRequest/Server_Request_Interceptor.cpp +++ b/TAO/tests/Portable_Interceptors/ForwardRequest/Server_Request_Interceptor.cpp @@ -20,8 +20,8 @@ Server_Request_Interceptor::~Server_Request_Interceptor (void) void Server_Request_Interceptor::forward_references ( CORBA::Object_ptr obj1, - CORBA::Object_ptr obj2, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Object_ptr obj2 + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { if (CORBA::is_nil (obj1) || CORBA::is_nil (obj2)) @@ -57,12 +57,10 @@ Server_Request_Interceptor::receive_request_service_contexts ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; - this->request_count_++; CORBA::Boolean response_expected = - ri->response_expected (ACE_TRY_ENV); + ri->response_expected (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (!response_expected) // A one-way request. @@ -99,10 +97,8 @@ Server_Request_Interceptor::receive_request ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; - CORBA::Boolean response_expected = - ri->response_expected (ACE_TRY_ENV); + ri->response_expected (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (!response_expected) // A one-way request. @@ -160,10 +156,8 @@ Server_Request_Interceptor::send_other ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; - CORBA::Boolean response_expected = - ri->response_expected (ACE_TRY_ENV); + ri->response_expected (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (!response_expected) // A one-way request. @@ -175,7 +169,7 @@ Server_Request_Interceptor::send_other ( // This will throw an exception if a location forward has not // occured. If an exception is thrown then something is wrong with // the PortableInterceptor::ForwardRequest support. - CORBA::Object_var forward = ri->forward_reference (ACE_TRY_ENV); + CORBA::Object_var forward = ri->forward_reference (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (CORBA::is_nil (forward.in ())) diff --git a/TAO/tests/Portable_Interceptors/ForwardRequest/Server_Request_Interceptor.h b/TAO/tests/Portable_Interceptors/ForwardRequest/Server_Request_Interceptor.h index 4ff3b9871cc..189fa3d6ee0 100644 --- a/TAO/tests/Portable_Interceptors/ForwardRequest/Server_Request_Interceptor.h +++ b/TAO/tests/Portable_Interceptors/ForwardRequest/Server_Request_Interceptor.h @@ -68,9 +68,8 @@ public: /// Set the references to which requests will be forwarded. virtual void forward_references (CORBA::Object_ptr obj1, - CORBA::Object_ptr obj2, - CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + CORBA::Object_ptr obj2 + TAO_ENV_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); /** diff --git a/TAO/tests/Portable_Interceptors/ForwardRequest/client.cpp b/TAO/tests/Portable_Interceptors/ForwardRequest/client.cpp index 8aefaba9f60..0d3e80d0426 100644 --- a/TAO/tests/Portable_Interceptors/ForwardRequest/client.cpp +++ b/TAO/tests/Portable_Interceptors/ForwardRequest/client.cpp @@ -50,7 +50,7 @@ main (int argc, char *argv[]) { int status = 0; - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { #if TAO_HAS_INTERCEPTORS == 1 @@ -63,15 +63,15 @@ main (int argc, char *argv[]) PortableInterceptor::ORBInitializer_var orb_initializer = temp_initializer; - PortableInterceptor::register_orb_initializer (orb_initializer.in (), - ACE_TRY_ENV); + PortableInterceptor::register_orb_initializer (orb_initializer.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; #endif /* TAO_HAS_INTERCEPTORS == 1 */ CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "Client ORB", - ACE_TRY_ENV); + "Client ORB" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (::parse_args (argc, argv) != 0) @@ -81,11 +81,11 @@ main (int argc, char *argv[]) // IOR occurs during the various interceptions executed during // this test. CORBA::Object_var object = - orb->string_to_object (ior1, ACE_TRY_ENV); + orb->string_to_object (ior1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ForwardRequestTest::test_var server = - ForwardRequestTest::test::_narrow (object.in (), ACE_TRY_ENV); + ForwardRequestTest::test::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -112,7 +112,7 @@ main (int argc, char *argv[]) if (i > 1) old_number = number; - number = server->number (ACE_TRY_ENV); + number = server->number (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; @@ -141,7 +141,7 @@ main (int argc, char *argv[]) } } - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Portable_Interceptors/ForwardRequest/server.cpp b/TAO/tests/Portable_Interceptors/ForwardRequest/server.cpp index 9eadd3a9241..cdfc78c8ac8 100644 --- a/TAO/tests/Portable_Interceptors/ForwardRequest/server.cpp +++ b/TAO/tests/Portable_Interceptors/ForwardRequest/server.cpp @@ -56,7 +56,7 @@ parse_args (int argc, char *argv[]) int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { Server_ORBInitializer *temp_initializer = 0; @@ -66,16 +66,16 @@ main (int argc, char *argv[]) PortableInterceptor::ORBInitializer_var orb_initializer = temp_initializer; - PortableInterceptor::register_orb_initializer (orb_initializer.in (), - ACE_TRY_ENV); + PortableInterceptor::register_orb_initializer (orb_initializer.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "Server ORB", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "Server ORB" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -84,11 +84,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (::parse_args (argc, argv) != 0) @@ -102,22 +102,22 @@ main (int argc, char *argv[]) PortableServer::POA_var first_poa = root_poa->create_POA ("first POA", poa_manager.in (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::ObjectId_var oid1 = - first_poa->activate_object (&servant1, - ACE_TRY_ENV); + first_poa->activate_object (&servant1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var obj1 = - first_poa->servant_to_reference (&servant1, - ACE_TRY_ENV); + first_poa->servant_to_reference (&servant1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior1 = - orb->object_to_string (obj1.in (), ACE_TRY_ENV); + orb->object_to_string (obj1.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -130,29 +130,29 @@ main (int argc, char *argv[]) PortableServer::POA_var second_poa = root_poa->create_POA ("second POA", poa_manager.in (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::ObjectId_var oid2 = - second_poa->activate_object (&servant2, - ACE_TRY_ENV); + second_poa->activate_object (&servant2 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var obj2 = - second_poa->servant_to_reference (&servant2, - ACE_TRY_ENV); + second_poa->servant_to_reference (&servant2 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior2 = - orb->object_to_string (obj2.in (), ACE_TRY_ENV); + orb->object_to_string (obj2.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "ForwardRequestTest::test servant 2: <%s>\n", ior2.in ())); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Set the forward references in the server request interceptor. @@ -161,7 +161,7 @@ main (int argc, char *argv[]) ForwardRequestTest::ServerRequestInterceptor_var interceptor = ForwardRequestTest::ServerRequestInterceptor::_narrow ( - server_interceptor.in (), ACE_TRY_ENV); + server_interceptor.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (interceptor.in ())) @@ -171,8 +171,8 @@ main (int argc, char *argv[]) -1); interceptor->forward_references (obj1.in (), - obj2.in (), - ACE_TRY_ENV); + obj2.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Write each IOR to a file. @@ -199,13 +199,13 @@ main (int argc, char *argv[]) ACE_OS::fclose (output_file); // Run the ORB event loop. - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Event loop finished.\n")); diff --git a/TAO/tests/Portable_Interceptors/ForwardRequest/test_i.cpp b/TAO/tests/Portable_Interceptors/ForwardRequest/test_i.cpp index edd9b01080e..abe34922f30 100644 --- a/TAO/tests/Portable_Interceptors/ForwardRequest/test_i.cpp +++ b/TAO/tests/Portable_Interceptors/ForwardRequest/test_i.cpp @@ -18,18 +18,18 @@ test_i::~test_i (void) } CORBA::Short -test_i::number (CORBA::Environment &) +test_i::number (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return this->number_; } void -test_i::shutdown (CORBA::Environment &ACE_TRY_ENV) +test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "Server is shutting down via object %d.\n", this->number_)); - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/Portable_Interceptors/ForwardRequest/test_i.h b/TAO/tests/Portable_Interceptors/ForwardRequest/test_i.h index 261f380aba6..04ef8b96d8e 100644 --- a/TAO/tests/Portable_Interceptors/ForwardRequest/test_i.h +++ b/TAO/tests/Portable_Interceptors/ForwardRequest/test_i.h @@ -37,13 +37,11 @@ public: ~test_i (void); /// Return the number assigned to this object. - virtual CORBA::Short number (CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + virtual CORBA::Short number (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); /// Shutdown the ORB. - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Portable_Interceptors/IORInterceptor/FOO_ClientRequestInterceptor.cpp b/TAO/tests/Portable_Interceptors/IORInterceptor/FOO_ClientRequestInterceptor.cpp index f583ef93960..2adf3bbcd2e 100644 --- a/TAO/tests/Portable_Interceptors/IORInterceptor/FOO_ClientRequestInterceptor.cpp +++ b/TAO/tests/Portable_Interceptors/IORInterceptor/FOO_ClientRequestInterceptor.cpp @@ -28,14 +28,12 @@ FOO_ClientRequestInterceptor::send_request ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; - // Verify that the tagged component that was supposed to be embedded // into the IOR by the FOO_IORInterceptor is actually in the IOR // profile. IOP::TaggedComponent_var component = - ri->get_effective_component (FOO::COMPONENT_ID, - ACE_TRY_ENV); + ri->get_effective_component (FOO::COMPONENT_ID + TAO_ENV_ARG_PARAMETER); ACE_CHECK; // The correct tagged component appears to exist. Display the diff --git a/TAO/tests/Portable_Interceptors/IORInterceptor/FOO_Client_ORBInitializer.cpp b/TAO/tests/Portable_Interceptors/IORInterceptor/FOO_Client_ORBInitializer.cpp index 7a1e9bf9ea6..1986211dd64 100644 --- a/TAO/tests/Portable_Interceptors/IORInterceptor/FOO_Client_ORBInitializer.cpp +++ b/TAO/tests/Portable_Interceptors/IORInterceptor/FOO_Client_ORBInitializer.cpp @@ -21,8 +21,6 @@ FOO_Client_ORBInitializer::post_init ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; - PortableInterceptor::ClientRequestInterceptor_ptr foo; ACE_NEW_THROW_EX (foo, FOO_ClientRequestInterceptor, @@ -36,7 +34,7 @@ FOO_Client_ORBInitializer::post_init ( PortableInterceptor::ClientRequestInterceptor_var interceptor = foo; - info->add_client_request_interceptor (interceptor.in (), - ACE_TRY_ENV); + info->add_client_request_interceptor (interceptor.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } diff --git a/TAO/tests/Portable_Interceptors/IORInterceptor/FOO_IORInterceptor_ORBInitializer.cpp b/TAO/tests/Portable_Interceptors/IORInterceptor/FOO_IORInterceptor_ORBInitializer.cpp index 8e5c94b4a99..3781f73dd95 100644 --- a/TAO/tests/Portable_Interceptors/IORInterceptor/FOO_IORInterceptor_ORBInitializer.cpp +++ b/TAO/tests/Portable_Interceptors/IORInterceptor/FOO_IORInterceptor_ORBInitializer.cpp @@ -21,7 +21,6 @@ FOO_IORInterceptor_ORBInitializer::post_init ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; PortableInterceptor::IORInterceptor_ptr foo; ACE_NEW_THROW_EX (foo, @@ -36,7 +35,7 @@ FOO_IORInterceptor_ORBInitializer::post_init ( PortableInterceptor::IORInterceptor_var ior_interceptor = foo; - info->add_ior_interceptor (ior_interceptor.in (), - ACE_TRY_ENV); + info->add_ior_interceptor (ior_interceptor.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } diff --git a/TAO/tests/Portable_Interceptors/IORInterceptor/client.cpp b/TAO/tests/Portable_Interceptors/IORInterceptor/client.cpp index e5d7604a380..53095e667a2 100644 --- a/TAO/tests/Portable_Interceptors/IORInterceptor/client.cpp +++ b/TAO/tests/Portable_Interceptors/IORInterceptor/client.cpp @@ -37,7 +37,7 @@ parse_args (int argc, char *argv[]) int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { #if TAO_HAS_INTERCEPTORS == 1 @@ -50,24 +50,24 @@ main (int argc, char *argv[]) PortableInterceptor::ORBInitializer_var orb_initializer = temp_initializer; - PortableInterceptor::register_orb_initializer (orb_initializer.in (), - ACE_TRY_ENV); + PortableInterceptor::register_orb_initializer (orb_initializer.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; #endif /* TAO_HAS_INTERCEPTORS == 1 */ CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "client_orb", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "client_orb" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var obj = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; FOO::test_var server = - FOO::test::_narrow (obj.in (), ACE_TRY_ENV); + FOO::test::_narrow (obj.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -78,7 +78,7 @@ main (int argc, char *argv[]) 1); } - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Portable_Interceptors/IORInterceptor/server.cpp b/TAO/tests/Portable_Interceptors/IORInterceptor/server.cpp index c67e5c3c709..1dc39b2df36 100644 --- a/TAO/tests/Portable_Interceptors/IORInterceptor/server.cpp +++ b/TAO/tests/Portable_Interceptors/IORInterceptor/server.cpp @@ -39,7 +39,7 @@ parse_args (int argc, char *argv[]) int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { #if TAO_HAS_INTERCEPTORS == 1 @@ -52,25 +52,25 @@ main (int argc, char *argv[]) PortableInterceptor::ORBInitializer_var orb_initializer = temp_initializer; - PortableInterceptor::register_orb_initializer (orb_initializer.in (), - ACE_TRY_ENV); + PortableInterceptor::register_orb_initializer (orb_initializer.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; #endif /* TAO_HAS_INTERCEPTORS == 1 */ CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "test_orb", - ACE_TRY_ENV); + "test_orb" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var obj = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (obj.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (obj.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (root_poa.in ())) @@ -79,10 +79,10 @@ main (int argc, char *argv[]) -1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -90,11 +90,11 @@ main (int argc, char *argv[]) test_i server_impl (orb.in ()); - obj = server_impl._this (ACE_TRY_ENV); + obj = server_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - FOO::test_var server = FOO::test::_narrow (obj.in (), - ACE_TRY_ENV); + FOO::test_var server = FOO::test::_narrow (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -104,7 +104,7 @@ main (int argc, char *argv[]) -1); CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_INFO, "FOO::test: <%s>\n", ior.in ())); @@ -123,7 +123,7 @@ main (int argc, char *argv[]) ACE_OS::fclose (output_file); } - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_INFO, "Event loop finished.\n")); diff --git a/TAO/tests/Portable_Interceptors/IORInterceptor/test_i.cpp b/TAO/tests/Portable_Interceptors/IORInterceptor/test_i.cpp index f80354bf8d0..1bcd569d623 100644 --- a/TAO/tests/Portable_Interceptors/IORInterceptor/test_i.cpp +++ b/TAO/tests/Portable_Interceptors/IORInterceptor/test_i.cpp @@ -12,10 +12,10 @@ test_i::test_i (CORBA::ORB_ptr orb) } void -test_i::shutdown (CORBA::Environment &ACE_TRY_ENV) +test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "\"test_i\" is shutting down.\n")); - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/Portable_Interceptors/IORInterceptor/test_i.h b/TAO/tests/Portable_Interceptors/IORInterceptor/test_i.h index 693d577b31b..2309de5d64b 100644 --- a/TAO/tests/Portable_Interceptors/IORInterceptor/test_i.h +++ b/TAO/tests/Portable_Interceptors/IORInterceptor/test_i.h @@ -34,8 +34,7 @@ public: test_i (CORBA::ORB_ptr orb); /// Shutdown the ORB. - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Portable_Interceptors/PICurrent/ServerORBInitializer.cpp b/TAO/tests/Portable_Interceptors/PICurrent/ServerORBInitializer.cpp index 7f747dc9947..76c69b76129 100644 --- a/TAO/tests/Portable_Interceptors/PICurrent/ServerORBInitializer.cpp +++ b/TAO/tests/Portable_Interceptors/PICurrent/ServerORBInitializer.cpp @@ -23,9 +23,7 @@ ServerORBInitializer::post_init ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; - - ::slot_id = info->allocate_slot_id (ACE_TRY_ENV); + ::slot_id = info->allocate_slot_id (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; PortableInterceptor::ServerRequestInterceptor_ptr tmp; @@ -40,7 +38,7 @@ ServerORBInitializer::post_init ( PortableInterceptor::ServerRequestInterceptor_var interceptor = tmp; - info->add_server_request_interceptor (interceptor.in (), - ACE_TRY_ENV); + info->add_server_request_interceptor (interceptor.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } diff --git a/TAO/tests/Portable_Interceptors/PICurrent/ServerRequestInterceptor.cpp b/TAO/tests/Portable_Interceptors/PICurrent/ServerRequestInterceptor.cpp index dae6f2b6a99..4f7354e6843 100644 --- a/TAO/tests/Portable_Interceptors/PICurrent/ServerRequestInterceptor.cpp +++ b/TAO/tests/Portable_Interceptors/PICurrent/ServerRequestInterceptor.cpp @@ -34,9 +34,8 @@ ServerRequestInterceptor::receive_request_service_contexts ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; - CORBA::String_var op = ri->operation (ACE_TRY_ENV); + CORBA::String_var op = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (ACE_OS::strcmp (op.in (), "invoke_me") != 0) @@ -51,7 +50,7 @@ ServerRequestInterceptor::receive_request_service_contexts ( ACE_TRY { - ri->set_slot (this->slot_id_, data, ACE_TRY_ENV); + ri->set_slot (this->slot_id_, data TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (PortableInterceptor::InvalidSlot, ex) @@ -89,9 +88,8 @@ ServerRequestInterceptor::send_reply ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; - CORBA::String_var op = ri->operation (ACE_TRY_ENV); + CORBA::String_var op = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (ACE_OS::strcmp (op.in (), "invoke_me") != 0) @@ -104,7 +102,7 @@ ServerRequestInterceptor::send_reply ( // Retrieve the data stored in the RSC. This data should be // different from the original data stored into the RSC by the // receive_request_service_contexts() interception point. - data = ri->get_slot (this->slot_id_, ACE_TRY_ENV); + data = ri->get_slot (this->slot_id_ TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (PortableInterceptor::InvalidSlot, ex) diff --git a/TAO/tests/Portable_Interceptors/PICurrent/client.cpp b/TAO/tests/Portable_Interceptors/PICurrent/client.cpp index e2638125471..86a6cc69e5b 100644 --- a/TAO/tests/Portable_Interceptors/PICurrent/client.cpp +++ b/TAO/tests/Portable_Interceptors/PICurrent/client.cpp @@ -37,7 +37,7 @@ parse_args (int argc, char *argv[]) int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { #if 0 @@ -50,24 +50,24 @@ main (int argc, char *argv[]) PortableInterceptor::ORBInitializer_var orb_initializer = temp_initializer; - PortableInterceptor::register_orb_initializer (orb_initializer.in (), - ACE_TRY_ENV); + PortableInterceptor::register_orb_initializer (orb_initializer.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; #endif /* 0 */ CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "client_orb", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "client_orb" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var obj = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PICurrentTest::test_var server = - PICurrentTest::test::_narrow (obj.in (), ACE_TRY_ENV); + PICurrentTest::test::_narrow (obj.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -78,10 +78,10 @@ main (int argc, char *argv[]) 1); } - server->invoke_me (ACE_TRY_ENV); + server->invoke_me (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Portable_Interceptors/PICurrent/server.cpp b/TAO/tests/Portable_Interceptors/PICurrent/server.cpp index 32568337887..85b1c03a21c 100644 --- a/TAO/tests/Portable_Interceptors/PICurrent/server.cpp +++ b/TAO/tests/Portable_Interceptors/PICurrent/server.cpp @@ -41,7 +41,7 @@ parse_args (int argc, char *argv[]) int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { PortableInterceptor::ORBInitializer_ptr temp_initializer = @@ -53,23 +53,23 @@ main (int argc, char *argv[]) PortableInterceptor::ORBInitializer_var orb_initializer = temp_initializer; - PortableInterceptor::register_orb_initializer (orb_initializer.in (), - ACE_TRY_ENV); + PortableInterceptor::register_orb_initializer (orb_initializer.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "test_orb", - ACE_TRY_ENV); + "test_orb" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var obj = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (obj.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (obj.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (root_poa.in ())) @@ -78,20 +78,20 @@ main (int argc, char *argv[]) -1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return -1; - obj = orb->resolve_initial_references ("PICurrent", ACE_TRY_ENV); + obj = orb->resolve_initial_references ("PICurrent" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableInterceptor::Current_var pi_current = - PortableInterceptor::Current::_narrow (obj.in (), ACE_TRY_ENV); + PortableInterceptor::Current::_narrow (obj.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (pi_current.in ())) @@ -103,12 +103,12 @@ main (int argc, char *argv[]) ::slot_id, orb.in ()); - obj = server_impl._this (ACE_TRY_ENV); + obj = server_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; PICurrentTest::test_var server = - PICurrentTest::test::_narrow (obj.in (), - ACE_TRY_ENV); + PICurrentTest::test::_narrow (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -118,7 +118,7 @@ main (int argc, char *argv[]) -1); CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_INFO, "PICurrentTest::test: <%s>\n", ior.in ())); @@ -137,7 +137,7 @@ main (int argc, char *argv[]) ACE_OS::fclose (output_file); } - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_INFO, "Event loop finished.\n")); diff --git a/TAO/tests/Portable_Interceptors/PICurrent/test_i.cpp b/TAO/tests/Portable_Interceptors/PICurrent/test_i.cpp index bd0c90a8198..dbea3421c8e 100644 --- a/TAO/tests/Portable_Interceptors/PICurrent/test_i.cpp +++ b/TAO/tests/Portable_Interceptors/PICurrent/test_i.cpp @@ -20,7 +20,7 @@ test_i::~test_i (void) } void -test_i::invoke_me (CORBA::Environment &ACE_TRY_ENV) +test_i::invoke_me (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -39,7 +39,7 @@ test_i::invoke_me (CORBA::Environment &ACE_TRY_ENV) // receive_request_service_contexts() interception point, and // then copied into the TSC current. retrieved_any = - this->current_->get_slot (this->slot_id_, ACE_TRY_ENV); + this->current_->get_slot (this->slot_id_ TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (PortableInterceptor::InvalidSlot, ex) @@ -88,7 +88,7 @@ test_i::invoke_me (CORBA::Environment &ACE_TRY_ENV) ACE_TRY_EX (foo) { - this->current_->set_slot (this->slot_id_, data, ACE_TRY_ENV); + this->current_->set_slot (this->slot_id_, data TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK_EX (foo); } ACE_CATCH (PortableInterceptor::InvalidSlot, ex) @@ -113,11 +113,11 @@ test_i::invoke_me (CORBA::Environment &ACE_TRY_ENV) } void -test_i::shutdown (CORBA::Environment &ACE_TRY_ENV) +test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) Server is shutting down.\n")); - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/Portable_Interceptors/PICurrent/test_i.h b/TAO/tests/Portable_Interceptors/PICurrent/test_i.h index 598bdfba9a8..ed0f81b6c2d 100644 --- a/TAO/tests/Portable_Interceptors/PICurrent/test_i.h +++ b/TAO/tests/Portable_Interceptors/PICurrent/test_i.h @@ -38,13 +38,11 @@ public: ~test_i (void); /// Return the number assigned to this object. - virtual void invoke_me (CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + virtual void invoke_me (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); /// Shutdown the ORB. - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Client_ORBInitializer.cpp b/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Client_ORBInitializer.cpp index 3661e72841f..642c66c8913 100644 --- a/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Client_ORBInitializer.cpp +++ b/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Client_ORBInitializer.cpp @@ -26,7 +26,6 @@ Client_ORBInitializer::post_init ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; // Create and register the test request interceptors. PortableInterceptor::ClientRequestInterceptor_ptr ci = @@ -43,8 +42,8 @@ Client_ORBInitializer::post_init ( PortableInterceptor::ClientRequestInterceptor_var ci_interceptor = ci; - info->add_client_request_interceptor (ci_interceptor.in (), - ACE_TRY_ENV); + info->add_client_request_interceptor (ci_interceptor.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_NEW_THROW_EX (ci, @@ -58,8 +57,8 @@ Client_ORBInitializer::post_init ( ci_interceptor = ci; - info->add_client_request_interceptor (ci_interceptor.in (), - ACE_TRY_ENV); + info->add_client_request_interceptor (ci_interceptor.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_NEW_THROW_EX (ci, @@ -73,7 +72,7 @@ Client_ORBInitializer::post_init ( ci_interceptor = ci; - info->add_client_request_interceptor (ci_interceptor.in (), - ACE_TRY_ENV); + info->add_client_request_interceptor (ci_interceptor.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } diff --git a/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Client_Request_Interceptor.cpp b/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Client_Request_Interceptor.cpp index 9eceac9aa11..5cb7411e4ee 100644 --- a/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Client_Request_Interceptor.cpp +++ b/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Client_Request_Interceptor.cpp @@ -19,10 +19,9 @@ Client_Request_Interceptor::send_request ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; CORBA::Boolean client_side = - this->client_side_test (ri, ACE_TRY_ENV); + this->client_side_test (ri TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (!client_side) @@ -36,7 +35,7 @@ Client_Request_Interceptor::send_request ( { // Determine which test scenario we are in Dynamic::ParameterList_var paramlist = - ri->arguments (ACE_TRY_ENV); + ri->arguments (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Test::TestScenario scenario; @@ -79,10 +78,9 @@ Client_Request_Interceptor::send_poll ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; CORBA::Boolean client_side = - this->client_side_test (ri, ACE_TRY_ENV); + this->client_side_test (ri TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (!client_side) @@ -101,10 +99,9 @@ Client_Request_Interceptor::receive_reply ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; CORBA::Boolean client_side = - this->client_side_test (ri, ACE_TRY_ENV); + this->client_side_test (ri TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (!client_side) @@ -120,7 +117,7 @@ Client_Request_Interceptor::receive_reply ( { // Determine which test scenario we are in Dynamic::ParameterList_var paramlist = - ri->arguments (ACE_TRY_ENV); + ri->arguments (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Test::TestScenario scenario; @@ -162,10 +159,9 @@ Client_Request_Interceptor::receive_exception ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; CORBA::Boolean client_side = - this->client_side_test (ri, ACE_TRY_ENV); + this->client_side_test (ri TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (!client_side) @@ -181,7 +177,7 @@ Client_Request_Interceptor::receive_exception ( { // Determine which test scenario we are in Dynamic::ParameterList_var paramlist = - ri->arguments (ACE_TRY_ENV); + ri->arguments (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Test::TestScenario scenario; @@ -196,12 +192,12 @@ Client_Request_Interceptor::receive_exception ( switch (scenario) { case 4: - exception = ri->received_exception (ACE_TRY_ENV); + exception = ri->received_exception (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; tc = exception->type (); - id = tc->id (ACE_TRY_ENV); + id = tc->id (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (ACE_OS_String::strcmp (id, "IDL:Test/X:1.0") == 0) @@ -247,10 +243,9 @@ Client_Request_Interceptor::receive_other ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; CORBA::Boolean client_side = - this->client_side_test (ri, ACE_TRY_ENV); + this->client_side_test (ri TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (!client_side) @@ -265,10 +260,10 @@ Client_Request_Interceptor::receive_other ( CORBA::Boolean Client_Request_Interceptor::client_side_test ( - PortableInterceptor::ClientRequestInfo_ptr info, - CORBA::Environment &ACE_TRY_ENV) + PortableInterceptor::ClientRequestInfo_ptr info + TAO_ENV_ARG_DECL) { - CORBA::String_var op = info->operation (ACE_TRY_ENV); + CORBA::String_var op = info->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (0); return ACE_OS_String::strcmp (op.in (), "client_test") == 0 ? 1 : 0; diff --git a/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Client_Request_Interceptor.h b/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Client_Request_Interceptor.h index ac150fb9ea7..c7fe08002a5 100644 --- a/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Client_Request_Interceptor.h +++ b/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Client_Request_Interceptor.h @@ -94,8 +94,8 @@ private: // Returns 1 if the client-side test is currently being run, and 0 // otherwise. CORBA::Boolean client_side_test ( - PortableInterceptor::ClientRequestInfo_ptr info, - CORBA::Environment &ACE_TRY_ENV); + PortableInterceptor::ClientRequestInfo_ptr info + TAO_ENV_ARG_DECL); }; diff --git a/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Request_Interceptor.cpp b/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Request_Interceptor.cpp index 57fc83eae65..a9e5723dc47 100644 --- a/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Request_Interceptor.cpp +++ b/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Request_Interceptor.cpp @@ -25,7 +25,6 @@ void Request_Interceptor::destroy (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; CORBA::ULong s_count = this->starting_interception_point_count_.value (); diff --git a/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Server_ORBInitializer.cpp b/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Server_ORBInitializer.cpp index c6b994c7f66..1e5ef57fd73 100644 --- a/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Server_ORBInitializer.cpp +++ b/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Server_ORBInitializer.cpp @@ -26,7 +26,6 @@ Server_ORBInitializer::post_init ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; // Create and register the test request interceptors. PortableInterceptor::ServerRequestInterceptor_ptr si = @@ -43,8 +42,8 @@ Server_ORBInitializer::post_init ( PortableInterceptor::ServerRequestInterceptor_var si_interceptor = si; - info->add_server_request_interceptor (si_interceptor.in (), - ACE_TRY_ENV); + info->add_server_request_interceptor (si_interceptor.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_NEW_THROW_EX (si, @@ -58,8 +57,8 @@ Server_ORBInitializer::post_init ( si_interceptor = si; - info->add_server_request_interceptor (si_interceptor.in (), - ACE_TRY_ENV); + info->add_server_request_interceptor (si_interceptor.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_NEW_THROW_EX (si, @@ -73,7 +72,7 @@ Server_ORBInitializer::post_init ( si_interceptor = si; - info->add_server_request_interceptor (si_interceptor.in (), - ACE_TRY_ENV); + info->add_server_request_interceptor (si_interceptor.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } diff --git a/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Server_Request_Interceptor.cpp b/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Server_Request_Interceptor.cpp index b45a3e8fb41..625574cfa47 100644 --- a/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Server_Request_Interceptor.cpp +++ b/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Server_Request_Interceptor.cpp @@ -21,10 +21,9 @@ Server_Request_Interceptor::receive_request_service_contexts ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; CORBA::Boolean server_side = - this->server_side_test (ri, ACE_TRY_ENV); + this->server_side_test (ri TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (!server_side) @@ -69,10 +68,9 @@ Server_Request_Interceptor::receive_request ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; CORBA::Boolean server_side = - this->server_side_test (ri, ACE_TRY_ENV); + this->server_side_test (ri TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (!server_side) @@ -89,10 +87,9 @@ Server_Request_Interceptor::send_reply ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; CORBA::Boolean server_side = - this->server_side_test (ri, ACE_TRY_ENV); + this->server_side_test (ri TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (!server_side) @@ -108,7 +105,7 @@ Server_Request_Interceptor::send_reply ( { // Determine which test scenario we are in Dynamic::ParameterList_var paramlist = - ri->arguments (ACE_TRY_ENV); + ri->arguments (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Test::TestScenario scenario; @@ -150,10 +147,9 @@ Server_Request_Interceptor::send_exception ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; CORBA::Boolean server_side = - this->server_side_test (ri, ACE_TRY_ENV); + this->server_side_test (ri TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (!server_side) @@ -169,7 +165,7 @@ Server_Request_Interceptor::send_exception ( { // Determine which test scenario we are in Dynamic::ParameterList_var paramlist = - ri->arguments (ACE_TRY_ENV); + ri->arguments (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; Test::TestScenario scenario; @@ -184,12 +180,12 @@ Server_Request_Interceptor::send_exception ( switch (scenario) { case 4: - exception = ri->sending_exception (ACE_TRY_ENV); + exception = ri->sending_exception (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; tc = exception->type (); - id = tc->id (ACE_TRY_ENV); + id = tc->id (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (ACE_OS_String::strcmp (id, "IDL:Test/X:1.0") == 0) @@ -235,10 +231,9 @@ Server_Request_Interceptor::send_other ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; CORBA::Boolean server_side = - this->server_side_test (ri, ACE_TRY_ENV); + this->server_side_test (ri TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (!server_side) @@ -253,10 +248,10 @@ Server_Request_Interceptor::send_other ( CORBA::Boolean Server_Request_Interceptor::server_side_test ( - PortableInterceptor::ServerRequestInfo_ptr info, - CORBA::Environment &ACE_TRY_ENV) + PortableInterceptor::ServerRequestInfo_ptr info + TAO_ENV_ARG_DECL) { - CORBA::String_var op = info->operation (ACE_TRY_ENV); + CORBA::String_var op = info->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (0); return ACE_OS_String::strcmp (op.in (), "server_test") == 0 ? 1 : 0; diff --git a/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Server_Request_Interceptor.h b/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Server_Request_Interceptor.h index 1b70a2f41c6..1e6c84778ad 100644 --- a/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Server_Request_Interceptor.h +++ b/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/Server_Request_Interceptor.h @@ -96,8 +96,8 @@ private: /// Returns 1 if the server-side test is currently being run, and 0 /// otherwise. CORBA::Boolean server_side_test ( - PortableInterceptor::ServerRequestInfo_ptr info, - CORBA::Environment &ACE_TRY_ENV); + PortableInterceptor::ServerRequestInfo_ptr info + TAO_ENV_ARG_DECL); private: diff --git a/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/client.cpp b/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/client.cpp index 181e9df512d..1a99d53e0f2 100644 --- a/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/client.cpp +++ b/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/client.cpp @@ -41,7 +41,7 @@ parse_args (int argc, char *argv[]) } void -client_test (Test_ptr server, CORBA::Environment &ACE_TRY_ENV) +client_test (Test_ptr server TAO_ENV_ARG_DECL) { // Currently, there are only four scenarios for the client side // tests. @@ -56,7 +56,7 @@ client_test (Test_ptr server, CORBA::Environment &ACE_TRY_ENV) ACE_TRY { - server->client_test (i, ACE_TRY_ENV); + server->client_test (i TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (Test::X, ex) @@ -89,7 +89,7 @@ client_test (Test_ptr server, CORBA::Environment &ACE_TRY_ENV) } void -server_test (Test_ptr server, CORBA::Environment &ACE_TRY_ENV) +server_test (Test_ptr server TAO_ENV_ARG_DECL) { // Currently, there are only four scenarios for the server side // tests. @@ -104,7 +104,7 @@ server_test (Test_ptr server, CORBA::Environment &ACE_TRY_ENV) ACE_TRY { - server->server_test (i, ACE_TRY_ENV); + server->server_test (i TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (Test::X, ex) @@ -139,7 +139,7 @@ server_test (Test_ptr server, CORBA::Environment &ACE_TRY_ENV) int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { PortableInterceptor::ORBInitializer_ptr temp_initializer = @@ -151,25 +151,25 @@ main (int argc, char *argv[]) PortableInterceptor::ORBInitializer_var orb_initializer = temp_initializer; - PortableInterceptor::register_orb_initializer (orb_initializer.in (), - ACE_TRY_ENV); + PortableInterceptor::register_orb_initializer (orb_initializer.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "Client ORB", - ACE_TRY_ENV); + "Client ORB" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (::parse_args (argc, argv) != 0) return -1; CORBA::Object_var object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test_var server = - Test::_narrow (object.in (), ACE_TRY_ENV); + Test::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -180,13 +180,13 @@ main (int argc, char *argv[]) 1); } - ::client_test (server.in (), ACE_TRY_ENV); + ::client_test (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - ::server_test (server.in (), ACE_TRY_ENV); + ::server_test (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/server.cpp b/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/server.cpp index f89e7c4e978..f3b08527929 100644 --- a/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/server.cpp +++ b/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/server.cpp @@ -43,7 +43,7 @@ parse_args (int argc, char *argv[]) int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { Server_ORBInitializer *temp_initializer = 0; @@ -53,16 +53,16 @@ main (int argc, char *argv[]) PortableInterceptor::ORBInitializer_var orb_initializer = temp_initializer; - PortableInterceptor::register_orb_initializer (orb_initializer.in (), - ACE_TRY_ENV); + PortableInterceptor::register_orb_initializer (orb_initializer.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "Server ORB", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "Server ORB" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -71,11 +71,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (::parse_args (argc, argv) != 0) @@ -83,18 +83,18 @@ main (int argc, char *argv[]) test_i servant (orb.in ()); - CORBA::Object_var obj = servant._this (ACE_TRY_ENV); + CORBA::Object_var obj = servant._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (obj.in (), ACE_TRY_ENV); + orb->object_to_string (obj.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Servant:\n<%s>\n", ior.in ())); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Write IOR to a file. @@ -109,13 +109,13 @@ main (int argc, char *argv[]) ACE_OS::fclose (output_file); // Run the ORB event loop. - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Event loop finished.\n")); diff --git a/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/test_i.cpp b/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/test_i.cpp index 9717d06b34b..682c1eec724 100644 --- a/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/test_i.cpp +++ b/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/test_i.cpp @@ -12,8 +12,8 @@ test_i::test_i (CORBA::ORB_ptr orb) } void -test_i::client_test (Test::TestScenario scenario, - CORBA::Environment &ACE_TRY_ENV) +test_i::client_test (Test::TestScenario scenario + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((Test::X, Test::UnknownScenario, CORBA::SystemException)) @@ -34,8 +34,8 @@ test_i::client_test (Test::TestScenario scenario, } void -test_i::server_test (Test::TestScenario scenario, - CORBA::Environment &ACE_TRY_ENV) +test_i::server_test (Test::TestScenario scenario + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((Test::X, Test::UnknownScenario, CORBA::SystemException)) @@ -56,11 +56,11 @@ test_i::server_test (Test::TestScenario scenario, } void -test_i::shutdown (CORBA::Environment &ACE_TRY_ENV) +test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_INFO, "Server is shutting down.\n")); - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/test_i.h b/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/test_i.h index af862f149d9..d0a480c43d7 100644 --- a/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/test_i.h +++ b/TAO/tests/Portable_Interceptors/Request_Interceptor_Flow/test_i.h @@ -33,24 +33,21 @@ public: test_i (CORBA::ORB_ptr orb); /// The client-side test operation. - virtual void client_test (Test::TestScenario scenario, - CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + virtual void client_test (Test::TestScenario scenario + TAO_ENV_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((Test::X, Test::UnknownScenario, CORBA::SystemException)); /// The server-side test operation. - virtual void server_test (Test::TestScenario scenario, - CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + virtual void server_test (Test::TestScenario scenario + TAO_ENV_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((Test::X, Test::UnknownScenario, CORBA::SystemException)); /// Shutdown the ORB. - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/Client_ORBInitializer.cpp b/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/Client_ORBInitializer.cpp index a5a4f69e84e..4244d28739f 100644 --- a/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/Client_ORBInitializer.cpp +++ b/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/Client_ORBInitializer.cpp @@ -26,10 +26,9 @@ Client_ORBInitializer::post_init ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; CORBA::String_var orb_id = - info->orb_id (ACE_TRY_ENV); + info->orb_id (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; PortableInterceptor::ClientRequestInterceptor_ptr interceptor = @@ -44,8 +43,8 @@ Client_ORBInitializer::post_init ( PortableInterceptor::ClientRequestInterceptor_var client_interceptor = interceptor; - info->add_client_request_interceptor (client_interceptor.in (), - ACE_TRY_ENV); + info->add_client_request_interceptor (client_interceptor.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } diff --git a/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/Server_ORBInitializer.cpp b/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/Server_ORBInitializer.cpp index 5cd4a2011e2..6546f4ef6f9 100644 --- a/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/Server_ORBInitializer.cpp +++ b/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/Server_ORBInitializer.cpp @@ -26,8 +26,6 @@ Server_ORBInitializer::post_init ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; - PortableInterceptor::ServerRequestInterceptor_ptr interceptor = PortableInterceptor::ServerRequestInterceptor::_nil (); @@ -40,8 +38,8 @@ Server_ORBInitializer::post_init ( PortableInterceptor::ServerRequestInterceptor_var server_interceptor = interceptor; - info->add_server_request_interceptor (server_interceptor.in (), - ACE_TRY_ENV); + info->add_server_request_interceptor (server_interceptor.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } diff --git a/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/client.cpp b/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/client.cpp index 92ee62afd33..67ecc0f5985 100644 --- a/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/client.cpp +++ b/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/client.cpp @@ -36,23 +36,23 @@ parse_args (int argc, char *argv[]) } void -run_test (Test_Interceptors::Visual_ptr server, - CORBA::Environment &ACE_TRY_ENV) +run_test (Test_Interceptors::Visual_ptr server + TAO_ENV_ARG_DECL) { - server->normal (10, ACE_TRY_ENV); + server->normal (10 TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "\"normal\" operation done\n")); - server->nothing (ACE_TRY_ENV); + server->nothing (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "\"nothing\" operation done\n")); ACE_TRY { - server->user (ACE_TRY_ENV); + server->user (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (Test_Interceptors::Silly, userex) @@ -64,7 +64,7 @@ run_test (Test_Interceptors::Visual_ptr server, ACE_TRY_EX (SYS) { - server->system (ACE_TRY_ENV); + server->system (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK_EX (SYS); } ACE_CATCH (CORBA::INV_OBJREF, sysex) @@ -88,23 +88,23 @@ main (int argc, char *argv[]) PortableInterceptor::ORBInitializer_var initializer = temp_initializer; - PortableInterceptor::register_orb_initializer (initializer.in (), - ACE_TRY_ENV); + PortableInterceptor::register_orb_initializer (initializer.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test_Interceptors::Visual_var server = - Test_Interceptors::Visual::_narrow (object.in (), ACE_TRY_ENV); + Test_Interceptors::Visual::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -115,10 +115,10 @@ main (int argc, char *argv[]) 1); } - run_test (server.in (), ACE_TRY_ENV); + run_test (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/interceptors.cpp b/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/interceptors.cpp index bf1ddc0a93e..e370378705d 100644 --- a/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/interceptors.cpp +++ b/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/interceptors.cpp @@ -65,25 +65,24 @@ Echo_Client_Request_Interceptor::send_request ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; if (CORBA::is_nil (this->orb_.in ())) { int argc = 0; this->orb_ = CORBA::ORB_init (argc, 0, - this->orb_id_.in (), - ACE_TRY_ENV); + this->orb_id_.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } - CORBA::String_var operation = ri->operation (ACE_TRY_ENV); + CORBA::String_var operation = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; - CORBA::Object_var target = ri->target (ACE_TRY_ENV); + CORBA::Object_var target = ri->target (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::String_var ior = - this->orb_->object_to_string (target.in (), ACE_TRY_ENV); + this->orb_->object_to_string (target.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -106,12 +105,12 @@ Echo_Client_Request_Interceptor::send_request ( sc.context_data.replace (string_len, string_len, buf, 1); // Add this context to the service context list. - ri->add_request_service_context (sc, 0, ACE_TRY_ENV); + ri->add_request_service_context (sc, 0 TAO_ENV_ARG_PARAMETER); ACE_CHECK; // Check that the request service context can be retrieved. IOP::ServiceContext_var sc2 = - ri->get_request_service_context (::service_id, ACE_TRY_ENV); + ri->get_request_service_context (::service_id TAO_ENV_ARG_PARAMETER); ACE_CHECK; const char *buf2 = @@ -134,25 +133,24 @@ Echo_Client_Request_Interceptor::receive_reply ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; if (CORBA::is_nil (this->orb_.in ())) { int argc = 0; this->orb_ = CORBA::ORB_init (argc, 0, - this->orb_id_.in (), - ACE_TRY_ENV); + this->orb_id_.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } - CORBA::String_var operation = ri->operation (ACE_TRY_ENV); + CORBA::String_var operation = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; - CORBA::Object_var target = ri->target (ACE_TRY_ENV); + CORBA::Object_var target = ri->target (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::String_var ior = - this->orb_->object_to_string (target.in (), ACE_TRY_ENV); + this->orb_->object_to_string (target.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -165,7 +163,7 @@ Echo_Client_Request_Interceptor::receive_reply ( // Check that the reply service context was received as // expected. IOP::ServiceContext_var sc = - ri->get_reply_service_context (::service_id, ACE_TRY_ENV); + ri->get_reply_service_context (::service_id TAO_ENV_ARG_PARAMETER); ACE_CHECK; const char *buf = @@ -183,7 +181,7 @@ Echo_Client_Request_Interceptor::receive_reply ( // Check that no one has messed with the request service context. IOP::ServiceContext_var sc2 = - ri->get_request_service_context (::service_id, ACE_TRY_ENV); + ri->get_request_service_context (::service_id TAO_ENV_ARG_PARAMETER); ACE_CHECK; const char *buf2 = @@ -218,25 +216,24 @@ Echo_Client_Request_Interceptor::receive_exception ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; if (CORBA::is_nil (this->orb_.in ())) { int argc = 0; this->orb_ = CORBA::ORB_init (argc, 0, - this->orb_id_.in (), - ACE_TRY_ENV); + this->orb_id_.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } - CORBA::String_var operation = ri->operation (ACE_TRY_ENV); + CORBA::String_var operation = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; - CORBA::Object_var target = ri->target (ACE_TRY_ENV); + CORBA::Object_var target = ri->target (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::String_var ior = - this->orb_->object_to_string (target.in (), ACE_TRY_ENV); + this->orb_->object_to_string (target.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -249,7 +246,7 @@ Echo_Client_Request_Interceptor::receive_exception ( // Check that the reply service context was received as // expected. IOP::ServiceContext_var sc = - ri->get_reply_service_context (::service_id, ACE_TRY_ENV); + ri->get_reply_service_context (::service_id TAO_ENV_ARG_PARAMETER); ACE_CHECK; const char *buf = @@ -267,7 +264,7 @@ Echo_Client_Request_Interceptor::receive_exception ( // Check that no one has messed with the request service context. IOP::ServiceContext_var sc2 = - ri->get_request_service_context (::service_id, ACE_TRY_ENV); + ri->get_request_service_context (::service_id TAO_ENV_ARG_PARAMETER); ACE_CHECK; const char *buf2 = @@ -326,9 +323,8 @@ Echo_Server_Request_Interceptor::receive_request_service_contexts ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; - CORBA::String_var operation = ri->operation (ACE_TRY_ENV); + CORBA::String_var operation = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -345,7 +341,7 @@ Echo_Server_Request_Interceptor::receive_request_service_contexts ( IOP::ServiceId id = ::service_id; IOP::ServiceContext_var sc = - ri->get_request_service_context (id, ACE_TRY_ENV); + ri->get_request_service_context (id TAO_ENV_ARG_PARAMETER); ACE_CHECK; const char *buf = @@ -375,7 +371,7 @@ Echo_Server_Request_Interceptor::receive_request_service_contexts ( scc.context_data.replace (string_len, string_len, buff, 1); // Add this context to the service context list. - ri->add_reply_service_context (scc, 0, ACE_TRY_ENV); + ri->add_reply_service_context (scc, 0 TAO_ENV_ARG_PARAMETER); ACE_CHECK; } @@ -396,9 +392,8 @@ Echo_Server_Request_Interceptor::send_reply ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; - CORBA::String_var operation = ri->operation (ACE_TRY_ENV); + CORBA::String_var operation = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -408,7 +403,7 @@ Echo_Server_Request_Interceptor::send_reply ( // Check that the reply service context is set as expected. IOP::ServiceContext_var sc = - ri->get_reply_service_context (::service_id, ACE_TRY_ENV); + ri->get_reply_service_context (::service_id TAO_ENV_ARG_PARAMETER); ACE_CHECK; const char *buf = ACE_reinterpret_cast (const char *, @@ -427,7 +422,7 @@ Echo_Server_Request_Interceptor::send_reply ( // Check that the request service context hasn't been changed. IOP::ServiceContext_var sc2 = - ri->get_request_service_context (::service_id, ACE_TRY_ENV); + ri->get_request_service_context (::service_id TAO_ENV_ARG_PARAMETER); ACE_CHECK; const char *buf2 = ACE_reinterpret_cast (const char *, @@ -451,9 +446,8 @@ Echo_Server_Request_Interceptor::send_exception ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; - CORBA::String_var operation = ri->operation (ACE_TRY_ENV); + CORBA::String_var operation = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -463,7 +457,7 @@ Echo_Server_Request_Interceptor::send_exception ( // Check that the reply service context is set as expected. IOP::ServiceContext_var sc = - ri->get_reply_service_context (::service_id, ACE_TRY_ENV); + ri->get_reply_service_context (::service_id TAO_ENV_ARG_PARAMETER); ACE_CHECK; const char *buf = ACE_reinterpret_cast (const char *, @@ -482,7 +476,7 @@ Echo_Server_Request_Interceptor::send_exception ( // Check that the request service context hasn't been changed. IOP::ServiceContext_var sc2 = - ri->get_request_service_context (::service_id, ACE_TRY_ENV); + ri->get_request_service_context (::service_id TAO_ENV_ARG_PARAMETER); ACE_CHECK; const char *buf2 = ACE_reinterpret_cast (const char *, diff --git a/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/server.cpp b/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/server.cpp index c59db7dad2e..b90dc3879b5 100644 --- a/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/server.cpp +++ b/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/server.cpp @@ -49,17 +49,17 @@ main (int argc, char *argv[]) PortableInterceptor::ORBInitializer_var initializer = temp_initializer; - PortableInterceptor::register_orb_initializer (initializer.in (), - ACE_TRY_ENV); + PortableInterceptor::register_orb_initializer (initializer.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Now we can create the ORB CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -68,14 +68,14 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -84,22 +84,22 @@ main (int argc, char *argv[]) Visual_i server_impl (orb.in ()); PortableServer::ObjectId_var id = - root_poa->activate_object (&server_impl, - ACE_TRY_ENV); + root_poa->activate_object (&server_impl + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var test_obj = - root_poa->id_to_reference (id.in (), - ACE_TRY_ENV); + root_poa->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test_Interceptors::Visual_var server = - Test_Interceptors::Visual::_narrow (test_obj.in (), - ACE_TRY_ENV); + Test_Interceptors::Visual::_narrow (test_obj.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -119,12 +119,12 @@ main (int argc, char *argv[]) ACE_OS::fclose (output_file); } - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/test_i.cpp b/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/test_i.cpp index 9c2439038eb..3d6d031610a 100644 --- a/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/test_i.cpp +++ b/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/test_i.cpp @@ -13,22 +13,22 @@ Visual_i::Visual_i (CORBA::ORB_ptr orb) } void -Visual_i::normal (CORBA::Long arg, - CORBA::Environment &) +Visual_i::normal (CORBA::Long arg + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "Visual::normal called with %d\n", arg)); } void -Visual_i::nothing (CORBA::Environment &) +Visual_i::nothing (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "Visual::nothing\n")); } void -Visual_i::user (CORBA::Environment &ACE_TRY_ENV) +Visual_i::user (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, Test_Interceptors::Silly)) { @@ -37,7 +37,7 @@ Visual_i::user (CORBA::Environment &ACE_TRY_ENV) } void -Visual_i::system (CORBA::Environment &ACE_TRY_ENV) +Visual_i::system (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "Visual::user, throwing INV_OBJREF\n")); @@ -45,9 +45,9 @@ Visual_i::system (CORBA::Environment &ACE_TRY_ENV) } void -Visual_i::shutdown (CORBA::Environment &ACE_TRY_ENV) +Visual_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); ACE_CHECK; } diff --git a/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/test_i.h b/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/test_i.h index 2f41cee3958..7fc612e7210 100644 --- a/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/test_i.h +++ b/TAO/tests/Portable_Interceptors/Service_Context_Manipulation/test_i.h @@ -28,26 +28,21 @@ public: Visual_i (CORBA::ORB_ptr orb); - void normal (CORBA::Long arg, - CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + void normal (CORBA::Long arg + TAO_ENV_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); - void nothing (CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + void nothing (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); - void user (CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + void user (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException, Test_Interceptors::Silly)); - void system (CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + void system (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/QtTests/client.cpp b/TAO/tests/QtTests/client.cpp index 274596b42ff..e64d14733a2 100755 --- a/TAO/tests/QtTests/client.cpp +++ b/TAO/tests/QtTests/client.cpp @@ -24,21 +24,21 @@ main (int argc, char *argv[]) QApplication app (argc, argv); TAO_QtResource_Factory::set_context (&app); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Client client (orb.in (), app); - client.parse_args (argc, argv, ACE_TRY_ENV); + client.parse_args (argc, argv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Creates the Qt widgets - client.create_widgets (ACE_TRY_ENV); + client.create_widgets (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // This may look a bit suspect, but Qt wants the manager widget @@ -74,8 +74,8 @@ Client::~Client (void) void Client::parse_args (int argc, - char *argv[], - CORBA::Environment &ACE_TRY_ENV) + char *argv[] + TAO_ENV_ARG_DECL) { const char *ior = "file://test.ior"; @@ -98,11 +98,11 @@ Client::parse_args (int argc, } CORBA::Object_var object = - this->orb_->string_to_object (ior, ACE_TRY_ENV); + this->orb_->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_CHECK; this->server_ = - LCD_Display::_narrow (object.in (), ACE_TRY_ENV); + LCD_Display::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (CORBA::is_nil(this->server_.in ())) @@ -113,7 +113,7 @@ Client::parse_args (int argc, } void -Client::create_widgets (CORBA::Environment &/*ACE_TRY_ENV*/) +Client::create_widgets (TAO_ENV_SINGLE_ARG_DECL_NOT_USED/*TAO_ENV_SINGLE_ARG_PARAMETER*/) { // Ewsize the box this->box_.resize (200,120); diff --git a/TAO/tests/QtTests/client.h b/TAO/tests/QtTests/client.h index 089d378548c..bbd8a4dc4ba 100755 --- a/TAO/tests/QtTests/client.h +++ b/TAO/tests/QtTests/client.h @@ -38,13 +38,13 @@ public: ~Client (void); //Dtor.. - void create_widgets (CORBA::Environment &); + void create_widgets (TAO_ENV_SINGLE_ARG_DECL_NOT_USED); // Adds the callbacks to the GUI underneath..... void show (void); - void parse_args (int argc, char *argv[], - CORBA::Environment &ACE_TRY_ENV); + void parse_args (int argc, char *argv[] + TAO_ENV_ARG_DECL); QVBox box_; // A box widget.. diff --git a/TAO/tests/QtTests/server.cpp b/TAO/tests/QtTests/server.cpp index e580ca26a3c..009f27951d7 100755 --- a/TAO/tests/QtTests/server.cpp +++ b/TAO/tests/QtTests/server.cpp @@ -36,14 +36,14 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -63,15 +63,15 @@ main (int argc, char *argv[]) QApplication app (argc, argv); TAO_QtResource_Factory::set_context (&app); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -80,11 +80,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Create the Qt stuff.. @@ -92,7 +92,7 @@ main (int argc, char *argv[]) LCD_Display_imp display_impl (orb.in ()); LCD_Display_var server = - display_impl._this (ACE_TRY_ENV); + display_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Create the LCD after the QVbox is created. @@ -115,7 +115,7 @@ main (int argc, char *argv[]) // End of QT specific stuff.. CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); @@ -123,17 +123,17 @@ main (int argc, char *argv[]) // If the ior_output_file exists, output the ior to it if (ior_output_file != 0) { - FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); - if (output_file == 0) - ACE_ERROR_RETURN ((LM_ERROR, - "Cannot open output file for writing IOR: %s", - ior_output_file), - 1); - ACE_OS::fprintf (output_file, "%s", ior.in ()); - ACE_OS::fclose (output_file); + FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); + if (output_file == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot open output file for writing IOR: %s", + ior_output_file), + 1); + ACE_OS::fprintf (output_file, "%s", ior.in ()); + ACE_OS::fclose (output_file); } - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // We choose to run the main Qt event loop.. diff --git a/TAO/tests/QtTests/test_i.cpp b/TAO/tests/QtTests/test_i.cpp index 3b63ecbef4b..6277525c83a 100755 --- a/TAO/tests/QtTests/test_i.cpp +++ b/TAO/tests/QtTests/test_i.cpp @@ -11,13 +11,13 @@ ACE_RCSID(FL_Cube, test_i, "$Id$") LCD_Display_imp::LCD_Display_imp (CORBA::ORB_ptr orb) - + : orb_ (CORBA::ORB::_duplicate (orb)) { } void -LCD_Display_imp::shutdown (CORBA::Environment&) +LCD_Display_imp::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -26,9 +26,9 @@ LCD_Display_imp::shutdown (CORBA::Environment&) this->orb_->destroy (); } -void -LCD_Display_imp::send_val (CORBA::Long val, - CORBA::Environment &) +void +LCD_Display_imp::send_val (CORBA::Long val + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, diff --git a/TAO/tests/QtTests/test_i.h b/TAO/tests/QtTests/test_i.h index 41ad4cf02e8..e13be721eba 100755 --- a/TAO/tests/QtTests/test_i.h +++ b/TAO/tests/QtTests/test_i.h @@ -41,11 +41,11 @@ public: // ctor - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void send_val (CORBA::Long val, - CORBA::Environment &) + void send_val (CORBA::Long val + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); signals: diff --git a/TAO/tests/RTCORBA/Banded_Connections/client.cpp b/TAO/tests/RTCORBA/Banded_Connections/client.cpp index 5d4e5abca60..566e7060c23 100644 --- a/TAO/tests/RTCORBA/Banded_Connections/client.cpp +++ b/TAO/tests/RTCORBA/Banded_Connections/client.cpp @@ -40,23 +40,23 @@ parse_args (int argc, char *argv[]) } CORBA::Short -get_server_priority (Test_ptr server, - CORBA::Environment &ACE_TRY_ENV) +get_server_priority (Test_ptr server + TAO_ENV_ARG_DECL) { // Get the Priority Model Policy from the stub. CORBA::Policy_var policy = - server->_get_policy (RTCORBA::PRIORITY_MODEL_POLICY_TYPE, - ACE_TRY_ENV); + server->_get_policy (RTCORBA::PRIORITY_MODEL_POLICY_TYPE + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Narrow down to correct type. RTCORBA::PriorityModelPolicy_var priority_policy = - RTCORBA::PriorityModelPolicy::_narrow (policy.in (), ACE_TRY_ENV); + RTCORBA::PriorityModelPolicy::_narrow (policy.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Make sure that we have the SERVER_DECLARED priority model. RTCORBA::PriorityModel priority_model = - priority_policy->priority_model (ACE_TRY_ENV); + priority_policy->priority_model (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (priority_model != RTCORBA::SERVER_DECLARED) ACE_ERROR_RETURN ((LM_ERROR, @@ -65,20 +65,20 @@ get_server_priority (Test_ptr server, -1); // Return the server priority. - return priority_policy->server_priority (ACE_TRY_ENV); + return priority_policy->server_priority (TAO_ENV_SINGLE_ARG_PARAMETER); } void invocation_exception_test (Test_ptr obj, - CORBA::Short priority, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Short priority + TAO_ENV_ARG_DECL) { ACE_TRY { // Invoke method on test object. obj->test_method (1, - priority, - ACE_TRY_ENV); + priority + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // This next line of code should not run because an exception @@ -114,8 +114,8 @@ main (int argc, char *argv[]) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "", - ACE_TRY_ENV); + "" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Parse arguments. @@ -127,43 +127,43 @@ main (int argc, char *argv[]) // Get the RTORB. CORBA::Object_var object = - orb->resolve_initial_references ("RTORB", - ACE_TRY_ENV); + orb->resolve_initial_references ("RTORB" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::RTORB_var rt_orb = - RTCORBA::RTORB::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::RTORB::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the RTCurrent. object = - orb->resolve_initial_references ("RTCurrent", - ACE_TRY_ENV); + orb->resolve_initial_references ("RTCurrent" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::Current_var current = - RTCORBA::Current::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::Current::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Test object 1 (with CLIENT_PROPAGATED priority model). object = - orb->string_to_object (ior1, - ACE_TRY_ENV); + orb->string_to_object (ior1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test_var client_propagated_obj = - Test::_narrow (object.in (), ACE_TRY_ENV); + Test::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Test object 2 (with SERVER_DECLARED priority model). - object = orb->string_to_object (ior2, - ACE_TRY_ENV); + object = orb->string_to_object (ior2 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test_var server_declared_obj = - Test::_narrow (object.in (), ACE_TRY_ENV); + Test::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Test: Attempt to set priority bands that do not match server @@ -182,33 +182,33 @@ main (int argc, char *argv[]) CORBA::PolicyList policies; policies.length (1); policies[0] = - rt_orb->create_priority_banded_connection_policy (false_bands, - ACE_TRY_ENV); + rt_orb->create_priority_banded_connection_policy (false_bands + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Set false bands at the object level. Note that a new object // is returned. object = client_propagated_obj->_set_policy_overrides (policies, - CORBA::SET_OVERRIDE, - ACE_TRY_ENV); + CORBA::SET_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; client_propagated_obj = - Test::_narrow (object.in (), ACE_TRY_ENV); + Test::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Invoking on this object with false bands should produce an // exception. invocation_exception_test (client_propagated_obj.in (), - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the correct bands from the <server_declared_obj>. policies[0] = - server_declared_obj->_get_policy (RTCORBA::PRIORITY_BANDED_CONNECTION_POLICY_TYPE, - ACE_TRY_ENV); + server_declared_obj->_get_policy (RTCORBA::PRIORITY_BANDED_CONNECTION_POLICY_TYPE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::PriorityBandedConnectionPolicy_var bands_policy = @@ -221,13 +221,13 @@ main (int argc, char *argv[]) // object is returned. object = client_propagated_obj->_set_policy_overrides (policies, - CORBA::SET_OVERRIDE, - ACE_TRY_ENV); + CORBA::SET_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Overwrite existing <client_propagated_obj>. client_propagated_obj = - Test::_narrow (object.in (), ACE_TRY_ENV); + Test::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Test: Attempt invocation on <client_propagated_obj> with @@ -242,15 +242,15 @@ main (int argc, char *argv[]) bands[bands->length () - 1].high + 1; // Reset the current thread's priority. - current->the_priority (client_priority, - ACE_TRY_ENV); + current->the_priority (client_priority + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Invoking on this object with an invalid client thread // priority should produce an exception. invocation_exception_test (client_propagated_obj.in (), - client_priority, - ACE_TRY_ENV); + client_priority + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Test: Make invocations on the <client_propagated_obj>. @@ -267,14 +267,14 @@ main (int argc, char *argv[]) (bands[i].low + bands[i].high) / 2; // Reset the current thread's priority. - current->the_priority (client_priority, - ACE_TRY_ENV); + current->the_priority (client_priority + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Invoke test method on server. client_propagated_obj->test_method (1, // CLIENT_PROPAGATED - client_priority, - ACE_TRY_ENV); + client_priority + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -285,18 +285,18 @@ main (int argc, char *argv[]) // Get the <server_priority> from the stub. CORBA::Short server_priority = - get_server_priority (server_declared_obj.in (), - ACE_TRY_ENV); + get_server_priority (server_declared_obj.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Invoke test method on server. server_declared_obj->test_method (0, // SERVER_DECLARED - server_priority, - ACE_TRY_ENV); + server_priority + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Testing over. Shut down Server ORB. - server_declared_obj->shutdown (ACE_TRY_ENV); + server_declared_obj->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/RTCORBA/Banded_Connections/server.cpp b/TAO/tests/RTCORBA/Banded_Connections/server.cpp index d5ab8565867..76c3f99f1d9 100644 --- a/TAO/tests/RTCORBA/Banded_Connections/server.cpp +++ b/TAO/tests/RTCORBA/Banded_Connections/server.cpp @@ -11,15 +11,15 @@ class Test_i : public POA_Test { public: Test_i (CORBA::ORB_ptr orb, - RTCORBA::PriorityBands &bands, - CORBA::Environment &ACE_TRY_ENV); + RTCORBA::PriorityBands &bands + TAO_ENV_ARG_DECL); void test_method (CORBA::Boolean client_propagated, - CORBA::Short priority, - CORBA::Environment&) + CORBA::Short priority + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: @@ -29,33 +29,33 @@ private: }; Test_i::Test_i (CORBA::ORB_ptr orb, - RTCORBA::PriorityBands &bands, - CORBA::Environment &ACE_TRY_ENV) + RTCORBA::PriorityBands &bands + TAO_ENV_ARG_DECL) : orb_ (CORBA::ORB::_duplicate (orb)), bands_ (bands), rt_current_ () { // We resolve and store the RT Current for later use. CORBA::Object_var obj = - this->orb_->resolve_initial_references ("RTCurrent", - ACE_TRY_ENV); + this->orb_->resolve_initial_references ("RTCurrent" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; this->rt_current_ = - RTCORBA::Current::_narrow (obj.in (), - ACE_TRY_ENV); + RTCORBA::Current::_narrow (obj.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } void Test_i::test_method (CORBA::Boolean client_propagated, - CORBA::Short client_priority, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Short client_priority + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { // Get the upcall thread's priority. CORBA::Short server_priority = - this->rt_current_->the_priority (ACE_TRY_ENV); + this->rt_current_->the_priority (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; // Check which policy we are dealing with. @@ -116,11 +116,11 @@ Test_i::test_method (CORBA::Boolean client_propagated, } void -Test_i::shutdown (CORBA::Environment& ACE_TRY_ENV) +Test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, - ACE_TRY_ENV); + this->orb_->shutdown (0 + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } @@ -232,25 +232,25 @@ int create_object (PortableServer::POA_ptr poa, CORBA::ORB_ptr orb, Test_i *server_impl, - const char *filename, - CORBA::Environment &ACE_TRY_ENV) + const char *filename + TAO_ENV_ARG_DECL) { // Register servant with the POA. PortableServer::ObjectId_var id; - id = poa->activate_object (server_impl, - ACE_TRY_ENV); + id = poa->activate_object (server_impl + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Create object reference. CORBA::Object_var server = - poa->id_to_reference (id.in (), - ACE_TRY_ENV); + poa->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Print out the IOR. CORBA::String_var ior = - orb->object_to_string (server.in (), - ACE_TRY_ENV); + orb->object_to_string (server.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Print ior to the file. @@ -275,16 +275,16 @@ create_object (PortableServer::POA_ptr poa, void object_activation_exception_test (RTPortableServer::POA_ptr poa, Test_i *server_impl, - CORBA::Short priority, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Short priority + TAO_ENV_ARG_DECL) { ACE_TRY { // Register servant with POA. PortableServer::ObjectId_var id = poa->activate_object_with_priority (server_impl, - priority, - ACE_TRY_ENV); + priority + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // This next line of code should not run because an exception @@ -310,8 +310,8 @@ object_activation_exception_test (RTPortableServer::POA_ptr poa, void poa_creation_exception_test (PortableServer::POA_ptr root_poa, PortableServer::POAManager_ptr manager, - CORBA::PolicyList &policies, - CORBA::Environment &ACE_TRY_ENV) + CORBA::PolicyList &policies + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -319,8 +319,8 @@ poa_creation_exception_test (PortableServer::POA_ptr root_poa, PortableServer::POA_var child_poa = root_poa->create_POA ("Child_POA", manager, - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // This next line of code should not run because an exception @@ -356,8 +356,8 @@ main (int argc, char *argv[]) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "", - ACE_TRY_ENV); + "" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Parse arguments. @@ -369,28 +369,28 @@ main (int argc, char *argv[]) // Get the RTORB. CORBA::Object_var object = - orb->resolve_initial_references ("RTORB", - ACE_TRY_ENV); + orb->resolve_initial_references ("RTORB" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::RTORB_var rt_orb = - RTCORBA::RTORB::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::RTORB::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the RootPOA. object = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the POA Manager. PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Obtain priority bands to be used in this test from the file @@ -435,8 +435,8 @@ main (int argc, char *argv[]) allow_borrowing, allow_request_buffering, max_buffered_requests, - max_request_buffer_size, - ACE_TRY_ENV); + max_request_buffer_size + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Test: Attempt to create a POA with priority bands that do not @@ -454,22 +454,22 @@ main (int argc, char *argv[]) // Create a bands policy. poa_policy_list[0] = - rt_orb->create_priority_banded_connection_policy (false_bands, - ACE_TRY_ENV); + rt_orb->create_priority_banded_connection_policy (false_bands + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Create a thread-pool policy. poa_policy_list[1] = - rt_orb->create_threadpool_policy (threadpool_id, - ACE_TRY_ENV); + rt_orb->create_threadpool_policy (threadpool_id + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Try to create a POA with invalid policies. Should throw an // exception. poa_creation_exception_test (root_poa.in (), poa_manager.in (), - poa_policy_list, - ACE_TRY_ENV); + poa_policy_list + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Two policies for the next POA. @@ -478,14 +478,14 @@ main (int argc, char *argv[]) // Create a priority model policy. poa_policy_list[0] = rt_orb->create_priority_model_policy (RTCORBA::CLIENT_PROPAGATED, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Create a thread-pool policy. poa_policy_list[1] = - rt_orb->create_threadpool_policy (threadpool_id, - ACE_TRY_ENV); + rt_orb->create_threadpool_policy (threadpool_id + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Create POA with CLIENT_PROPAGATED priority model, with lanes @@ -493,8 +493,8 @@ main (int argc, char *argv[]) PortableServer::POA_var client_propagated_poa = root_poa->create_POA ("client_propagated_poa", poa_manager.in (), - poa_policy_list, - ACE_TRY_ENV); + poa_policy_list + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Three policies for the next POA. @@ -507,20 +507,20 @@ main (int argc, char *argv[]) // Create a priority model policy. poa_policy_list[0] = rt_orb->create_priority_model_policy (RTCORBA::SERVER_DECLARED, - poa_priority, - ACE_TRY_ENV); + poa_priority + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Create a bands policy. poa_policy_list[1] = - rt_orb->create_priority_banded_connection_policy (bands, - ACE_TRY_ENV); + rt_orb->create_priority_banded_connection_policy (bands + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Create a thread-pool policy. poa_policy_list[2] = - rt_orb->create_threadpool_policy (threadpool_id, - ACE_TRY_ENV); + rt_orb->create_threadpool_policy (threadpool_id + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Create POA with SERVER_DECLARED priority model, with bands @@ -528,8 +528,8 @@ main (int argc, char *argv[]) PortableServer::POA_var server_declared_poa = root_poa->create_POA ("server_declared_poa", poa_manager.in (), - poa_policy_list, - ACE_TRY_ENV); + poa_policy_list + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Test: Attempt to register an object with priority that @@ -538,55 +538,55 @@ main (int argc, char *argv[]) "\n<---Test--->: Servant priority does not match lanes\n\n")); RTPortableServer::POA_var rt_server_declared_poa = - RTPortableServer::POA::_narrow (server_declared_poa.in (), ACE_TRY_ENV); + RTPortableServer::POA::_narrow (server_declared_poa.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Activation with incorrect priority should fail. CORBA::Short wrong_priority = 10000; object_activation_exception_test (rt_server_declared_poa.in (), 0, - wrong_priority, - ACE_TRY_ENV); + wrong_priority + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Create first servant and register with <client_propagated_poa>. Test_i server_impl (orb.in (), - bands, - ACE_TRY_ENV); + bands + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; result = create_object (client_propagated_poa.in (), orb.in (), &server_impl, - ior_output_file1, - ACE_TRY_ENV); + ior_output_file1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result != 0) return result; // Create second servant and register with <server_declared_poa>. Test_i server_impl2 (orb.in (), - bands, - ACE_TRY_ENV); + bands + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; result = create_object (server_declared_poa.in (), orb.in (), &server_impl2, - ior_output_file2, - ACE_TRY_ENV); + ior_output_file2 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result != 0) return result; // Activate POA manager. - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Run ORB. - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Destroy ORB. - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/RTCORBA/Client_Propagated/Client_ORBInitializer.cpp b/TAO/tests/RTCORBA/Client_Propagated/Client_ORBInitializer.cpp index 11463bd4333..5a57d02a41b 100644 --- a/TAO/tests/RTCORBA/Client_Propagated/Client_ORBInitializer.cpp +++ b/TAO/tests/RTCORBA/Client_Propagated/Client_ORBInitializer.cpp @@ -26,10 +26,9 @@ Client_ORBInitializer::post_init ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; CORBA::String_var orb_id = - info->orb_id (ACE_TRY_ENV); + info->orb_id (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; PortableInterceptor::ClientRequestInterceptor_ptr interceptor = @@ -44,8 +43,8 @@ Client_ORBInitializer::post_init ( PortableInterceptor::ClientRequestInterceptor_var client_interceptor = interceptor; - info->add_client_request_interceptor (client_interceptor.in (), - ACE_TRY_ENV); + info->add_client_request_interceptor (client_interceptor.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } diff --git a/TAO/tests/RTCORBA/Client_Propagated/client.cpp b/TAO/tests/RTCORBA/Client_Propagated/client.cpp index 5f30bea8cb3..1b21f8edc82 100644 --- a/TAO/tests/RTCORBA/Client_Propagated/client.cpp +++ b/TAO/tests/RTCORBA/Client_Propagated/client.cpp @@ -53,24 +53,24 @@ main (int argc, char *argv[]) PortableInterceptor::ORBInitializer_var initializer = temp_initializer; - PortableInterceptor::register_orb_initializer (initializer.in (), - ACE_TRY_ENV); + PortableInterceptor::register_orb_initializer (initializer.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Initialize and obtain reference to the Test object. CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test_var server = - Test::_narrow (object.in (), ACE_TRY_ENV); + Test::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -84,12 +84,12 @@ main (int argc, char *argv[]) // Check that the object is configured with CLIENT_PROPAGATED // PriorityModelPolicy. CORBA::Policy_var policy = - server->_get_policy (RTCORBA::PRIORITY_MODEL_POLICY_TYPE, - ACE_TRY_ENV); + server->_get_policy (RTCORBA::PRIORITY_MODEL_POLICY_TYPE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::PriorityModelPolicy_var priority_policy = - RTCORBA::PriorityModelPolicy::_narrow (policy.in (), ACE_TRY_ENV); + RTCORBA::PriorityModelPolicy::_narrow (policy.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (priority_policy.in ())) @@ -98,7 +98,7 @@ main (int argc, char *argv[]) 1); RTCORBA::PriorityModel priority_model = - priority_policy->priority_model (ACE_TRY_ENV); + priority_policy->priority_model (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (priority_model != RTCORBA::CLIENT_PROPAGATED) @@ -110,18 +110,18 @@ main (int argc, char *argv[]) // Make several invocation, changing the priority of this thread // for each. object = - orb->resolve_initial_references ("RTCurrent", ACE_TRY_ENV); + orb->resolve_initial_references ("RTCurrent" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::Current_var current = - RTCORBA::Current::_narrow (object.in (), ACE_TRY_ENV); + RTCORBA::Current::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - object = orb->resolve_initial_references ("PriorityMappingManager", - ACE_TRY_ENV); + object = orb->resolve_initial_references ("PriorityMappingManager" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::PriorityMappingManager_var mapping_manager = - RTCORBA::PriorityMappingManager::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::PriorityMappingManager::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::PriorityMapping *pm = @@ -145,11 +145,11 @@ main (int argc, char *argv[]) for (int i = 0; i < 3; ++i) { - current->the_priority (desired_priority, ACE_TRY_ENV); + current->the_priority (desired_priority TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Short priority = - current->the_priority (ACE_TRY_ENV); + current->the_priority (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (desired_priority != priority) @@ -159,14 +159,14 @@ main (int argc, char *argv[]) 1); - server->test_method (priority, ACE_TRY_ENV); + server->test_method (priority TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; desired_priority++; } // Shut down Server ORB. - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (CORBA::DATA_CONVERSION, ex) diff --git a/TAO/tests/RTCORBA/Client_Propagated/interceptors.cpp b/TAO/tests/RTCORBA/Client_Propagated/interceptors.cpp index 9ac2b144c31..a8b90cfe9b2 100644 --- a/TAO/tests/RTCORBA/Client_Propagated/interceptors.cpp +++ b/TAO/tests/RTCORBA/Client_Propagated/interceptors.cpp @@ -70,14 +70,13 @@ Client_Request_Interceptor::receive_reply ( TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - TAO_ENV_ARG_DEFN; ACE_TRY { // Try to get the RTCorbaPriority context. If its not there, // report the fact via an exception. IOP::ServiceContext_var sc = - ri->get_reply_service_context (IOP::RTCorbaPriority, ACE_TRY_ENV); + ri->get_reply_service_context (IOP::RTCorbaPriority TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -109,25 +108,24 @@ Client_Request_Interceptor::receive_exception ( ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::ForwardRequest)) { - TAO_ENV_ARG_DEFN; if (CORBA::is_nil (this->orb_.in ())) { int argc = 0; this->orb_ = CORBA::ORB_init (argc, 0, - this->orb_id_.in (), - ACE_TRY_ENV); + this->orb_id_.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } - CORBA::String_var operation = ri->operation (ACE_TRY_ENV); + CORBA::String_var operation = ri->operation (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; - CORBA::Object_var target = ri->target (ACE_TRY_ENV); + CORBA::Object_var target = ri->target (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::String_var ior = - this->orb_->object_to_string (target.in (), ACE_TRY_ENV); + this->orb_->object_to_string (target.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -141,6 +139,6 @@ Client_Request_Interceptor::receive_exception ( // Try to get the RTCorbaPriority context. If its not there, // report the fact via an exception. IOP::ServiceContext_var sc = - ri->get_reply_service_context (IOP::RTCorbaPriority, ACE_TRY_ENV); + ri->get_reply_service_context (IOP::RTCorbaPriority TAO_ENV_ARG_PARAMETER); ACE_CHECK; } diff --git a/TAO/tests/RTCORBA/Client_Propagated/server.cpp b/TAO/tests/RTCORBA/Client_Propagated/server.cpp index b9fa96e6108..a7a5637a71d 100644 --- a/TAO/tests/RTCORBA/Client_Propagated/server.cpp +++ b/TAO/tests/RTCORBA/Client_Propagated/server.cpp @@ -16,11 +16,11 @@ public: // ctor // = The Test methods. - void test_method (CORBA::Short priority, - CORBA::Environment&) + void test_method (CORBA::Short priority + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: @@ -34,26 +34,26 @@ Test_i::Test_i (CORBA::ORB_ptr orb) } void -Test_i::test_method (CORBA::Short priority, - CORBA::Environment &ACE_TRY_ENV) +Test_i::test_method (CORBA::Short priority + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { // Use RTCurrent to find out the CORBA priority of the current // thread. CORBA::Object_var obj = - this->orb_->resolve_initial_references ("RTCurrent", ACE_TRY_ENV); + this->orb_->resolve_initial_references ("RTCurrent" TAO_ENV_ARG_PARAMETER); ACE_CHECK; RTCORBA::Current_var current = - RTCORBA::Current::_narrow (obj.in (), ACE_TRY_ENV); + RTCORBA::Current::_narrow (obj.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (CORBA::is_nil (obj.in ())) ACE_THROW (CORBA::INTERNAL ()); CORBA::Short servant_thread_priority = - current->the_priority (ACE_TRY_ENV); + current->the_priority (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; // Print out the info. @@ -69,10 +69,10 @@ Test_i::test_method (CORBA::Short priority, } void -Test_i::shutdown (CORBA::Environment& ACE_TRY_ENV) +Test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } //************************************************************************* @@ -119,18 +119,18 @@ main (int argc, char *argv[]) // parse arguments and get all the references (ORB, // RootPOA, RTORB, RTCurrent, POAManager). CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (root_poa.in ())) @@ -139,20 +139,20 @@ main (int argc, char *argv[]) -1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - object = orb->resolve_initial_references ("RTORB", ACE_TRY_ENV); + object = orb->resolve_initial_references ("RTORB" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; object = - orb->resolve_initial_references ("RTCurrent", ACE_TRY_ENV); + orb->resolve_initial_references ("RTCurrent" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::Current_var current = - RTCORBA::Current::_narrow (object.in (), ACE_TRY_ENV); + RTCORBA::Current::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Create POA with CLIENT_PROPAGATED PriorityModelPolicy, @@ -161,31 +161,31 @@ main (int argc, char *argv[]) poa_policy_list.length (1); poa_policy_list[0] = rt_orb->create_priority_model_policy (RTCORBA::CLIENT_PROPAGATED, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var child_poa = root_poa->create_POA ("Child_POA", poa_manager.in (), - poa_policy_list, - ACE_TRY_ENV); + poa_policy_list + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test_i server_impl (orb.in ()); PortableServer::ObjectId_var id = - child_poa->activate_object (&server_impl, ACE_TRY_ENV); + child_poa->activate_object (&server_impl TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var server = - child_poa->id_to_reference (id.in (), - ACE_TRY_ENV); + child_poa->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Print Object IOR. CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n\n", ior.in ())); @@ -204,21 +204,21 @@ main (int argc, char *argv[]) // Get the initial priority of the current thread. CORBA::Short initial_thread_priority = - current->the_priority (ACE_TRY_ENV); + current->the_priority (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Run ORB Event loop. - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Server ORB event loop finished\n")); // Get the final priority of the current thread. CORBA::Short final_thread_priority = - current->the_priority (ACE_TRY_ENV); + current->the_priority (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (final_thread_priority != initial_thread_priority) diff --git a/TAO/tests/RTCORBA/Client_Protocol/client.cpp b/TAO/tests/RTCORBA/Client_Protocol/client.cpp index a480729d6c3..d5d56cc5d92 100644 --- a/TAO/tests/RTCORBA/Client_Protocol/client.cpp +++ b/TAO/tests/RTCORBA/Client_Protocol/client.cpp @@ -63,12 +63,12 @@ check_for_nil (CORBA::Object_ptr obj, const char *msg) void exception_test (Test_ptr server, - const char *msg, - CORBA::Environment &ACE_TRY_ENV) + const char *msg + TAO_ENV_ARG_DECL) { ACE_TRY { - server->test_method (ACE_TRY_ENV); + server->test_method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (CORBA::INV_POLICY, ex) @@ -94,7 +94,7 @@ main (int argc, char *argv[]) // ORB. CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Parse arguments. @@ -103,48 +103,48 @@ main (int argc, char *argv[]) // RTORB. CORBA::Object_var object = - orb->resolve_initial_references ("RTORB", ACE_TRY_ENV); + orb->resolve_initial_references ("RTORB" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (rt_orb.in (), "RTORB") == -1) return 1; // PolicyManager. - object = orb->resolve_initial_references ("ORBPolicyManager", - ACE_TRY_ENV); + object = orb->resolve_initial_references ("ORBPolicyManager" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyManager_var policy_manager = - CORBA::PolicyManager::_narrow (object.in (), ACE_TRY_ENV); + CORBA::PolicyManager::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (policy_manager.in (), "PolicyManager") == -1) return 1; // PolicyCurrent. - object = orb->resolve_initial_references ("PolicyCurrent", - ACE_TRY_ENV); + object = orb->resolve_initial_references ("PolicyCurrent" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyCurrent_var policy_current = - CORBA::PolicyCurrent::_narrow (object.in (), ACE_TRY_ENV); + CORBA::PolicyCurrent::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (policy_current.in (), "PolicyCurrent") == -1) return 1; // Test object 1 (ClientProtocolPolicy set on server). - object = orb->string_to_object (ior1, ACE_TRY_ENV); + object = orb->string_to_object (ior1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - Test_var server1 = Test::_narrow (object.in (), ACE_TRY_ENV); + Test_var server1 = Test::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (server1.in (), "server1") == -1) return 1; // Test object 2 (no client-exposed ClientProtocolPolicy). - object = orb->string_to_object (ior2, ACE_TRY_ENV); + object = orb->string_to_object (ior2 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - Test_var server2 = Test::_narrow (object.in (), ACE_TRY_ENV); + Test_var server2 = Test::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (server2.in (), "server2") == -1) return 1; @@ -155,7 +155,7 @@ main (int argc, char *argv[]) // ClientProtocolPolicy set on the server side. ACE_DEBUG ((LM_DEBUG, "\n Test 1\n")); - server1->test_method (ACE_TRY_ENV); + server1->test_method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Test 2: Set the ORB-level ClientProtocolPolicy override, and @@ -175,17 +175,17 @@ main (int argc, char *argv[]) CORBA::PolicyList policy_list; policy_list.length (1); policy_list[0] = - rt_orb->create_client_protocol_policy (protocols, - ACE_TRY_ENV); + rt_orb->create_client_protocol_policy (protocols + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; policy_manager->set_policy_overrides (policy_list, - CORBA::SET_OVERRIDE, - ACE_TRY_ENV); + CORBA::SET_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; exception_test (server1.in (), - "ERROR: Test 2 failed\n", ACE_TRY_ENV); + "ERROR: Test 2 failed\n" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Test 3: Attempt the invocation on the second object reference @@ -194,7 +194,7 @@ main (int argc, char *argv[]) // conflicts. ACE_DEBUG ((LM_DEBUG, "\n Test 3\n")); - server2->test_method (ACE_TRY_ENV); + server2->test_method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Test 4: Override ClientProtocolPolicy on the Current level. @@ -211,17 +211,17 @@ main (int argc, char *argv[]) protocols[1].protocol_type = 4; protocols[2].protocol_type = 5; policy_list[0] = - rt_orb->create_client_protocol_policy (protocols, - ACE_TRY_ENV); + rt_orb->create_client_protocol_policy (protocols + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; policy_current->set_policy_overrides (policy_list, - CORBA::SET_OVERRIDE, - ACE_TRY_ENV); + CORBA::SET_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; exception_test (server2.in (), - "ERROR: Test 4 failed\n", ACE_TRY_ENV); + "ERROR: Test 4 failed\n" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Test 5: Override ClientProtocolPolicy on the Current level @@ -234,22 +234,22 @@ main (int argc, char *argv[]) protocols[0].protocol_type = 3; protocols[1].protocol_type = protocol_type; policy_list[0] = - rt_orb->create_client_protocol_policy (protocols, - ACE_TRY_ENV); + rt_orb->create_client_protocol_policy (protocols + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; policy_current->set_policy_overrides (policy_list, - CORBA::SET_OVERRIDE, - ACE_TRY_ENV); + CORBA::SET_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - server2->test_method (ACE_TRY_ENV); + server2->test_method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Testing over. Shut down server ORB. ACE_DEBUG ((LM_DEBUG, "\n Testing over\n")); - server2->shutdown (ACE_TRY_ENV); + server2->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/RTCORBA/Client_Protocol/server.cpp b/TAO/tests/RTCORBA/Client_Protocol/server.cpp index c147e991bdb..c2aba8d8213 100644 --- a/TAO/tests/RTCORBA/Client_Protocol/server.cpp +++ b/TAO/tests/RTCORBA/Client_Protocol/server.cpp @@ -16,10 +16,10 @@ public: Test_i (CORBA::ORB_ptr orb); // ctor - void test_method (CORBA::Environment&) + void test_method (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: @@ -33,7 +33,7 @@ Test_i::Test_i (CORBA::ORB_ptr orb) } void -Test_i::test_method (CORBA::Environment& /*ACE_TRY_ENV*/) +Test_i::test_method (TAO_ENV_SINGLE_ARG_DECL_NOT_USED /*TAO_ENV_SINGLE_ARG_PARAMETER*/) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -41,10 +41,10 @@ Test_i::test_method (CORBA::Environment& /*ACE_TRY_ENV*/) } void -Test_i::shutdown (CORBA::Environment& ACE_TRY_ENV) +Test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } //************************************************************************* @@ -112,22 +112,22 @@ int create_object (PortableServer::POA_ptr poa, CORBA::ORB_ptr orb, Test_i *server_impl, - const char *filename, - CORBA::Environment &ACE_TRY_ENV) + const char *filename + TAO_ENV_ARG_DECL) { // Register with poa. PortableServer::ObjectId_var id = - poa->activate_object (server_impl, ACE_TRY_ENV); + poa->activate_object (server_impl TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::Object_var server = - poa->id_to_reference (id.in (), - ACE_TRY_ENV); + poa->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Print out the IOR. CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, "<%s>\n\n", ior.in ())); @@ -155,7 +155,7 @@ main (int argc, char *argv[]) { // ORB. CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Parse arguments. @@ -164,27 +164,27 @@ main (int argc, char *argv[]) // RTORB. CORBA::Object_var object = - orb->resolve_initial_references ("RTORB", ACE_TRY_ENV); + orb->resolve_initial_references ("RTORB" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (rt_orb.in (), "RTORB") == -1) return 1; // RootPOA. object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (root_poa.in (), "RootPOA") == -1) return 1; // POAManager. PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Create child POA with RTCORBA::ClientProtocolPolicy set. @@ -201,15 +201,15 @@ main (int argc, char *argv[]) CORBA::PolicyList poa_policy_list; poa_policy_list.length (1); poa_policy_list[0] = - rt_orb->create_client_protocol_policy (protocols, - ACE_TRY_ENV); + rt_orb->create_client_protocol_policy (protocols + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var poa = root_poa->create_POA ("Child_POA", poa_manager.in (), - poa_policy_list, - ACE_TRY_ENV); + poa_policy_list + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Servant. @@ -219,7 +219,7 @@ main (int argc, char *argv[]) int result; ACE_DEBUG ((LM_DEBUG, "\nActivated object one as ")); result = create_object (poa.in (), orb.in (), &server_impl, - ior_output_file1, ACE_TRY_ENV); + ior_output_file1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result == -1) return 1; @@ -227,16 +227,16 @@ main (int argc, char *argv[]) // Create object 2. ACE_DEBUG ((LM_DEBUG, "\nActivated object two as ")); result = create_object (root_poa.in (), orb.in (), &server_impl, - ior_output_file2, ACE_TRY_ENV); + ior_output_file2 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result == -1) return 1; // Run ORB Event loop. - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Server ORB event loop finished\n\n")); diff --git a/TAO/tests/RTCORBA/Collocation/Collocation.cpp b/TAO/tests/RTCORBA/Collocation/Collocation.cpp index c13bcaf59b1..fea2d7d3fd8 100644 --- a/TAO/tests/RTCORBA/Collocation/Collocation.cpp +++ b/TAO/tests/RTCORBA/Collocation/Collocation.cpp @@ -30,13 +30,13 @@ public: PortableServer::POA_ptr poa, Tests &tests); - void start (CORBA::Environment &ACE_TRY_ENV) + void start (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - void method (CORBA::Environment &ACE_TRY_ENV) + void method (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - PortableServer::POA_ptr _default_POA (CORBA_Environment &ACE_TRY_ENV); + PortableServer::POA_ptr _default_POA (TAO_ENV_SINGLE_ARG_DECL); int client_propagated (void); @@ -106,7 +106,7 @@ test_i::invocation_lane (CORBA::ULong lane) } void -test_i::start (CORBA::Environment &ACE_TRY_ENV) +test_i::start (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -126,17 +126,17 @@ test_i::start (CORBA::Environment &ACE_TRY_ENV) if (test->servant_->client_propagated ()) { CORBA::Object_var object = - this->orb_->resolve_initial_references ("RTCurrent", - ACE_TRY_ENV); + this->orb_->resolve_initial_references ("RTCurrent" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; RTCORBA::Current_var current = - RTCORBA::Current::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::Current::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::Short current_thread_priority = - current->the_priority (ACE_TRY_ENV); + current->the_priority (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (current_thread_priority == default_thread_priority) @@ -145,25 +145,25 @@ test_i::start (CORBA::Environment &ACE_TRY_ENV) test->servant_->invocation_lane (1); } - test->object_->method (ACE_TRY_ENV); + test->object_->method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; CORBA::String_var ior = - this->orb_->object_to_string (test->object_.in (), - ACE_TRY_ENV); + this->orb_->object_to_string (test->object_.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::Object_var object = - this->orb_->string_to_object (ior.in (), - ACE_TRY_ENV); + this->orb_->string_to_object (ior.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; test_var test_from_string = - test::_narrow (object.in (), - ACE_TRY_ENV); + test::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - test_from_string->method (ACE_TRY_ENV); + test_from_string->method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; iterator.advance (); @@ -204,14 +204,14 @@ test_i::thread_info (const char *method_name) } void -test_i::method (CORBA::Environment &) +test_i::method (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->thread_info ("test_i::method"); } PortableServer::POA_ptr -test_i::_default_POA (CORBA_Environment &) +test_i::_default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) { return PortableServer::POA::_duplicate (this->poa_.in ()); } @@ -220,17 +220,17 @@ class Server { public: Server (int argc, - char *argv[], - CORBA::Environment &ACE_TRY_ENV); + char *argv[] + TAO_ENV_ARG_DECL); - void create_servant_in_root_poa (CORBA::Environment &ACE_TRY_ENV); - void create_poa_and_servant_with_tp_policy (CORBA::Environment &ACE_TRY_ENV); + void create_servant_in_root_poa (TAO_ENV_SINGLE_ARG_DECL); + void create_poa_and_servant_with_tp_policy (TAO_ENV_SINGLE_ARG_DECL); void create_poa_and_servant_with_tp_with_lanes_policy (const char *poa_name, - RTCORBA::PriorityModel priority_model, - CORBA::Environment &ACE_TRY_ENV); - void test (CORBA::Environment &ACE_TRY_ENV); - void start_testing (CORBA::Environment &ACE_TRY_ENV); - void shutdown (CORBA::Environment &ACE_TRY_ENV); + RTCORBA::PriorityModel priority_model + TAO_ENV_ARG_DECL); + void test (TAO_ENV_SINGLE_ARG_DECL); + void start_testing (TAO_ENV_SINGLE_ARG_DECL); + void shutdown (TAO_ENV_SINGLE_ARG_DECL); CORBA::ORB_var orb_; RTCORBA::RTORB_var rt_orb_; @@ -250,8 +250,8 @@ public: }; Server::Server (int argc, - char *argv[], - CORBA::Environment &ACE_TRY_ENV) + char *argv[] + TAO_ENV_ARG_DECL) : stacksize_ (0), static_threads_ (1), dynamic_threads_ (0), @@ -263,55 +263,55 @@ Server::Server (int argc, this->orb_ = CORBA::ORB_init (argc, argv, - "", - ACE_TRY_ENV); + "" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::Object_var object = - this->orb_->resolve_initial_references ("RTORB", - ACE_TRY_ENV); + this->orb_->resolve_initial_references ("RTORB" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; this->rt_orb_ = - RTCORBA::RTORB::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::RTORB::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; object = - this->orb_->resolve_initial_references ("RTCurrent", - ACE_TRY_ENV); + this->orb_->resolve_initial_references ("RTCurrent" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; this->current_ = - RTCORBA::Current::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::Current::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; default_thread_priority = - this->current_->the_priority (ACE_TRY_ENV); + this->current_->the_priority (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; object = - this->orb_->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + this->orb_->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; this->root_poa_ = - PortableServer::POA::_narrow (object.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; this->poa_manager_ = - this->root_poa_->the_POAManager (ACE_TRY_ENV); + this->root_poa_->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; - this->poa_manager_->activate (ACE_TRY_ENV); + this->poa_manager_->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; } void -Server::create_servant_in_root_poa (CORBA::Environment &ACE_TRY_ENV) +Server::create_servant_in_root_poa (TAO_ENV_SINGLE_ARG_DECL) { test_i *servant = 0; ACE_NEW_THROW_EX (servant, @@ -329,12 +329,12 @@ Server::create_servant_in_root_poa (CORBA::Environment &ACE_TRY_ENV) this->tests_[this->tests_.size () - 1].servant_ = servant; this->tests_[this->tests_.size () - 1].object_ = - servant->_this (ACE_TRY_ENV); + servant->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; } void -Server::create_poa_and_servant_with_tp_policy (CORBA::Environment &ACE_TRY_ENV) +Server::create_poa_and_servant_with_tp_policy (TAO_ENV_SINGLE_ARG_DECL) { RTCORBA::ThreadpoolId threadpool_id = this->rt_orb_->create_threadpool (this->stacksize_, @@ -343,18 +343,18 @@ Server::create_poa_and_servant_with_tp_policy (CORBA::Environment &ACE_TRY_ENV) default_thread_priority, this->allow_request_buffering_, this->max_buffered_requests_, - this->max_request_buffer_size_, - ACE_TRY_ENV); + this->max_request_buffer_size_ + TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::Policy_var threadpool_policy = - this->rt_orb_->create_threadpool_policy (threadpool_id, - ACE_TRY_ENV); + this->rt_orb_->create_threadpool_policy (threadpool_id + TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::Policy_var implicit_activation_policy = - this->root_poa_->create_implicit_activation_policy (PortableServer::IMPLICIT_ACTIVATION, - ACE_TRY_ENV); + this->root_poa_->create_implicit_activation_policy (PortableServer::IMPLICIT_ACTIVATION + TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::PolicyList policies; @@ -370,8 +370,8 @@ Server::create_poa_and_servant_with_tp_policy (CORBA::Environment &ACE_TRY_ENV) PortableServer::POA_var poa = this->root_poa_->create_POA ("tp_child", this->poa_manager_.in (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_CHECK; test_i *servant = 0; @@ -390,14 +390,14 @@ Server::create_poa_and_servant_with_tp_policy (CORBA::Environment &ACE_TRY_ENV) this->tests_[this->tests_.size () - 1].servant_ = servant; this->tests_[this->tests_.size () - 1].object_ = - servant->_this (ACE_TRY_ENV); + servant->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; } void Server::create_poa_and_servant_with_tp_with_lanes_policy (const char *poa_name, - RTCORBA::PriorityModel priority_model, - CORBA::Environment &ACE_TRY_ENV) + RTCORBA::PriorityModel priority_model + TAO_ENV_ARG_DECL) { RTCORBA::ThreadpoolLanes lanes (2); lanes.length (2); @@ -416,19 +416,19 @@ Server::create_poa_and_servant_with_tp_with_lanes_policy (const char *poa_name, this->allow_borrowing_, this->allow_request_buffering_, this->max_buffered_requests_, - this->max_request_buffer_size_, - ACE_TRY_ENV); + this->max_request_buffer_size_ + TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::Policy_var threadpool_policy = - this->rt_orb_->create_threadpool_policy (threadpool_id, - ACE_TRY_ENV); + this->rt_orb_->create_threadpool_policy (threadpool_id + TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::Policy_var priority_model_policy = this->rt_orb_->create_priority_model_policy (priority_model, - default_thread_priority, - ACE_TRY_ENV); + default_thread_priority + TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::PolicyList policies; @@ -444,13 +444,13 @@ Server::create_poa_and_servant_with_tp_with_lanes_policy (const char *poa_name, PortableServer::POA_var poa = this->root_poa_->create_POA (poa_name, this->poa_manager_.in (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_CHECK; RTPortableServer::POA_var rt_poa = - RTPortableServer::POA::_narrow (poa.in (), - ACE_TRY_ENV); + RTPortableServer::POA::_narrow (poa.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; test_i *servant1 = 0; @@ -482,14 +482,14 @@ Server::create_poa_and_servant_with_tp_with_lanes_policy (const char *poa_name, id1 = rt_poa->activate_object_with_priority (servant1, - default_thread_priority, - ACE_TRY_ENV); + default_thread_priority + TAO_ENV_ARG_PARAMETER); ACE_CHECK; id2 = rt_poa->activate_object_with_priority (servant2, - default_thread_priority + 1, - ACE_TRY_ENV); + default_thread_priority + 1 + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } else @@ -500,45 +500,45 @@ Server::create_poa_and_servant_with_tp_with_lanes_policy (const char *poa_name, servant2->client_propagated (1); id1 = - rt_poa->activate_object (servant1, - ACE_TRY_ENV); + rt_poa->activate_object (servant1 + TAO_ENV_ARG_PARAMETER); ACE_CHECK; id2 = - rt_poa->activate_object (servant2, - ACE_TRY_ENV); + rt_poa->activate_object (servant2 + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } CORBA::Object_var object1 = - poa->id_to_reference (id1.in (), - ACE_TRY_ENV); + poa->id_to_reference (id1.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::Object_var object2 = - poa->id_to_reference (id2.in (), - ACE_TRY_ENV); + poa->id_to_reference (id2.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; this->tests_.size (this->tests_.size () + 1); this->tests_[this->tests_.size () - 1].object_ = - test::_narrow (object1.in (), - ACE_TRY_ENV); + test::_narrow (object1.in () + TAO_ENV_ARG_PARAMETER); this->tests_[this->tests_.size () - 1].servant_ = servant1; ACE_CHECK; this->tests_.size (this->tests_.size () + 1); this->tests_[this->tests_.size () - 1].object_ = - test::_narrow (object2.in (), - ACE_TRY_ENV); + test::_narrow (object2.in () + TAO_ENV_ARG_PARAMETER); this->tests_[this->tests_.size () - 1].servant_ = servant2; ACE_CHECK; } void -Server::start_testing (CORBA::Environment &ACE_TRY_ENV) +Server::start_testing (TAO_ENV_SINGLE_ARG_DECL) { Tests::ITERATOR iterator (this->tests_); while (!iterator.done ()) @@ -549,7 +549,7 @@ Server::start_testing (CORBA::Environment &ACE_TRY_ENV) if (test->servant_->client_propagated ()) { CORBA::Short current_thread_priority = - this->current_->the_priority (ACE_TRY_ENV); + this->current_->the_priority (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; if (current_thread_priority == default_thread_priority) @@ -558,7 +558,7 @@ Server::start_testing (CORBA::Environment &ACE_TRY_ENV) test->servant_->invocation_lane (1); } - test->object_->start (ACE_TRY_ENV); + test->object_->start (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; iterator.advance (); @@ -566,29 +566,29 @@ Server::start_testing (CORBA::Environment &ACE_TRY_ENV) } void -Server::test (CORBA::Environment &ACE_TRY_ENV) +Server::test (TAO_ENV_SINGLE_ARG_DECL) { - this->start_testing (ACE_TRY_ENV); + this->start_testing (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, "\n\n*** Changing priority to be higher ***\n\n")); - this->current_->the_priority (default_thread_priority + 1, - ACE_TRY_ENV); + this->current_->the_priority (default_thread_priority + 1 + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - this->start_testing (ACE_TRY_ENV); + this->start_testing (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; } void -Server::shutdown (CORBA::Environment &ACE_TRY_ENV) +Server::shutdown (TAO_ENV_SINGLE_ARG_DECL) { - this->orb_->shutdown (1, ACE_TRY_ENV); + this->orb_->shutdown (1 TAO_ENV_ARG_PARAMETER); ACE_CHECK; - this->orb_->destroy (ACE_TRY_ENV); + this->orb_->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; } @@ -598,30 +598,30 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { Server server (argc, - argv, - ACE_TRY_ENV); + argv + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - server.create_servant_in_root_poa (ACE_TRY_ENV); + server.create_servant_in_root_poa (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - server.create_poa_and_servant_with_tp_policy (ACE_TRY_ENV); + server.create_poa_and_servant_with_tp_policy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; server.create_poa_and_servant_with_tp_with_lanes_policy ("tp_with_lanes_client_propagated_poa", - RTCORBA::CLIENT_PROPAGATED, - ACE_TRY_ENV); + RTCORBA::CLIENT_PROPAGATED + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; server.create_poa_and_servant_with_tp_with_lanes_policy ("tp_with_lanes_server_declared_poa", - RTCORBA::SERVER_DECLARED, - ACE_TRY_ENV); + RTCORBA::SERVER_DECLARED + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - server.test (ACE_TRY_ENV); + server.test (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - server.shutdown (ACE_TRY_ENV); + server.shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/RTCORBA/Destroy_Thread_Pool/Destroy_Thread_Pool.cpp b/TAO/tests/RTCORBA/Destroy_Thread_Pool/Destroy_Thread_Pool.cpp index a66be2852ec..9ed5a011b1a 100644 --- a/TAO/tests/RTCORBA/Destroy_Thread_Pool/Destroy_Thread_Pool.cpp +++ b/TAO/tests/RTCORBA/Destroy_Thread_Pool/Destroy_Thread_Pool.cpp @@ -43,8 +43,8 @@ parse_args (int argc, char *argv[]) } RTCORBA::ThreadpoolId -create_threadpool (RTCORBA::RTORB_ptr rt_orb, - CORBA_Environment &ACE_TRY_ENV) +create_threadpool (RTCORBA::RTORB_ptr rt_orb + TAO_ENV_ARG_DECL) { RTCORBA::ThreadpoolId id = rt_orb->create_threadpool (stacksize, @@ -53,16 +53,16 @@ create_threadpool (RTCORBA::RTORB_ptr rt_orb, default_thread_priority, allow_request_buffering, max_buffered_requests, - max_request_buffer_size, - ACE_TRY_ENV); + max_request_buffer_size + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (0); return id; } RTCORBA::ThreadpoolId -create_threadpool_with_lanes (RTCORBA::RTORB_ptr rt_orb, - CORBA_Environment &ACE_TRY_ENV) +create_threadpool_with_lanes (RTCORBA::RTORB_ptr rt_orb + TAO_ENV_ARG_DECL) { RTCORBA::ThreadpoolLanes lanes (2); lanes.length (2); @@ -81,8 +81,8 @@ create_threadpool_with_lanes (RTCORBA::RTORB_ptr rt_orb, allow_borrowing, allow_request_buffering, max_buffered_requests, - max_request_buffer_size, - ACE_TRY_ENV); + max_request_buffer_size + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (0); return id; @@ -96,32 +96,32 @@ main (int argc, char *argv[]) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "", - ACE_TRY_ENV); + "" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var object = - orb->resolve_initial_references ("RTORB", - ACE_TRY_ENV); + orb->resolve_initial_references ("RTORB" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::RTORB_var rt_orb = - RTCORBA::RTORB::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::RTORB::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; object = - orb->resolve_initial_references ("RTCurrent", - ACE_TRY_ENV); + orb->resolve_initial_references ("RTCurrent" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::Current_var current = - RTCORBA::Current::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::Current::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; default_thread_priority = - current->the_priority (ACE_TRY_ENV); + current->the_priority (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; int result = @@ -135,25 +135,25 @@ main (int argc, char *argv[]) ++i) { RTCORBA::ThreadpoolId id = - create_threadpool (rt_orb.in (), - ACE_TRY_ENV); + create_threadpool (rt_orb.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - rt_orb->destroy_threadpool (id, - ACE_TRY_ENV); + rt_orb->destroy_threadpool (id + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; id = - create_threadpool_with_lanes (rt_orb.in (), - ACE_TRY_ENV); + create_threadpool_with_lanes (rt_orb.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - rt_orb->destroy_threadpool (id, - ACE_TRY_ENV); + rt_orb->destroy_threadpool (id + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/RTCORBA/Explicit_Binding/client.cpp b/TAO/tests/RTCORBA/Explicit_Binding/client.cpp index daf081c5e77..924ea8c69de 100644 --- a/TAO/tests/RTCORBA/Explicit_Binding/client.cpp +++ b/TAO/tests/RTCORBA/Explicit_Binding/client.cpp @@ -54,7 +54,7 @@ main (int argc, char *argv[]) // ORB. CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Parse arguments. @@ -63,29 +63,29 @@ main (int argc, char *argv[]) // RTORB. CORBA::Object_var object = - orb->resolve_initial_references ("RTORB", ACE_TRY_ENV); + orb->resolve_initial_references ("RTORB" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (rt_orb.in (), "RTORB") == -1) return 1; // PolicyCurrent. - object = orb->resolve_initial_references ("PolicyCurrent", - ACE_TRY_ENV); + object = orb->resolve_initial_references ("PolicyCurrent" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyCurrent_var policy_current = - CORBA::PolicyCurrent::_narrow (object.in (), ACE_TRY_ENV); + CORBA::PolicyCurrent::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (policy_current.in (), "PolicyCurrent") == -1) return 1; // Test object. - object = orb->string_to_object (ior, ACE_TRY_ENV); + object = orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - Test_var server = Test::_narrow (object.in (), ACE_TRY_ENV); + Test_var server = Test::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (server.in (), "server") == -1) return 1; @@ -107,21 +107,21 @@ main (int argc, char *argv[]) CORBA::PolicyList policy_list; policy_list.length (1); policy_list[0] = - rt_orb->create_client_protocol_policy (protocols, - ACE_TRY_ENV); + rt_orb->create_client_protocol_policy (protocols + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; policy_current->set_policy_overrides (policy_list, - CORBA::SET_OVERRIDE, - ACE_TRY_ENV); + CORBA::SET_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "\n Test 1\n")); CORBA::PolicyList_var pols; - int status = server->_validate_connection (pols.out (), - ACE_TRY_ENV); + int status = server->_validate_connection (pols.out () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (!status) @@ -134,7 +134,7 @@ main (int argc, char *argv[]) // NO new connections should get established. ACE_DEBUG ((LM_DEBUG, "\n Test 2\n")); - server->test_method (ACE_TRY_ENV); + server->test_method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Test 3: Check that <validate_connection> detects policy @@ -149,17 +149,17 @@ main (int argc, char *argv[]) protocols[0].protocol_type = TAO_TAG_UIOP_PROFILE; policy_list[0] = - rt_orb->create_client_protocol_policy (protocols, - ACE_TRY_ENV); + rt_orb->create_client_protocol_policy (protocols + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; policy_current->set_policy_overrides (policy_list, - CORBA::SET_OVERRIDE, - ACE_TRY_ENV); + CORBA::SET_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - status = server->_validate_connection (pols.out (), - ACE_TRY_ENV); + status = server->_validate_connection (pols.out () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (status) @@ -187,15 +187,15 @@ main (int argc, char *argv[]) "\n Testing over - shutting down\n")); protocols[0].protocol_type = TAO_TAG_SHMEM_PROFILE; policy_list[0] = - rt_orb->create_client_protocol_policy (protocols, - ACE_TRY_ENV); + rt_orb->create_client_protocol_policy (protocols + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; policy_current->set_policy_overrides (policy_list, - CORBA::SET_OVERRIDE, - ACE_TRY_ENV); + CORBA::SET_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/RTCORBA/Explicit_Binding/server.cpp b/TAO/tests/RTCORBA/Explicit_Binding/server.cpp index a65ad7ebd74..ea30d8e4266 100644 --- a/TAO/tests/RTCORBA/Explicit_Binding/server.cpp +++ b/TAO/tests/RTCORBA/Explicit_Binding/server.cpp @@ -17,10 +17,10 @@ public: // ctor // = The Test methods. - void test_method (CORBA::Environment&) + void test_method (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: @@ -34,7 +34,7 @@ Test_i::Test_i (CORBA::ORB_ptr orb) } void -Test_i::test_method (CORBA::Environment &/* ACE_TRY_ENV */) +Test_i::test_method (TAO_ENV_SINGLE_ARG_DECL_NOT_USED/* TAO_ENV_SINGLE_ARG_PARAMETER */) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -42,10 +42,10 @@ Test_i::test_method (CORBA::Environment &/* ACE_TRY_ENV */) } void -Test_i::shutdown (CORBA::Environment& ACE_TRY_ENV) +Test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } //************************************************************************* @@ -95,23 +95,23 @@ int create_object (PortableServer::POA_ptr poa, CORBA::ORB_ptr orb, Test_i *server_impl, - const char *filename, - CORBA::Environment &ACE_TRY_ENV) + const char *filename + TAO_ENV_ARG_DECL) { // Register with poa. PortableServer::ObjectId_var id = - poa->activate_object (server_impl, ACE_TRY_ENV); + poa->activate_object (server_impl TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::Object_var server = - poa->id_to_reference (id.in (), - ACE_TRY_ENV); + poa->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Print out the IOR. CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, "<%s>\n\n", ior.in ())); @@ -139,7 +139,7 @@ main (int argc, char *argv[]) { // ORB. CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Parse arguments. @@ -148,17 +148,17 @@ main (int argc, char *argv[]) // RootPOA. CORBA::Object_var object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (root_poa.in (), "RootPOA") == -1) return 1; // POAManager. PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Servant. @@ -169,17 +169,17 @@ main (int argc, char *argv[]) result = create_object (root_poa.in (), orb.in (), &server_impl, - ior_output_file, - ACE_TRY_ENV); + ior_output_file + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result == -1) return 1; // Run ORB Event loop. - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Server ORB event loop finished\n")); diff --git a/TAO/tests/RTCORBA/Linear_Priority/client.cpp b/TAO/tests/RTCORBA/Linear_Priority/client.cpp index c55f59580c5..556c5fa5b20 100644 --- a/TAO/tests/RTCORBA/Linear_Priority/client.cpp +++ b/TAO/tests/RTCORBA/Linear_Priority/client.cpp @@ -91,13 +91,13 @@ Worker_Thread::svc (void) { ACE_TRY_NEW_ENV { - this->current_->the_priority (this->priority_, - ACE_TRY_ENV); + this->current_->the_priority (this->priority_ + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; for (int i = 0; i < iterations; i++) { - this->test_->method (ACE_TRY_ENV); + this->test_->method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } @@ -122,8 +122,8 @@ main (int argc, char **argv) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; int result = @@ -132,47 +132,47 @@ main (int argc, char **argv) return result; CORBA::Object_var object = - orb->resolve_initial_references ("RTORB", - ACE_TRY_ENV); + orb->resolve_initial_references ("RTORB" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::RTORB_var rt_orb = - RTCORBA::RTORB::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::RTORB::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; object = - orb->resolve_initial_references ("RTCurrent", - ACE_TRY_ENV); + orb->resolve_initial_references ("RTCurrent" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::Current_var current = - RTCORBA::Current::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::Current::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - current->the_priority (0, - ACE_TRY_ENV); + current->the_priority (0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; object = - orb->resolve_initial_references ("ORBPolicyManager", - ACE_TRY_ENV); + orb->resolve_initial_references ("ORBPolicyManager" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyManager_var policy_manager = - CORBA::PolicyManager::_narrow (object.in (), - ACE_TRY_ENV); + CORBA::PolicyManager::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; object = - orb->string_to_object (ior, - ACE_TRY_ENV); + orb->string_to_object (ior + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; test_var test = - test::_narrow (object.in (), - ACE_TRY_ENV); + test::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Short_Array priorities; @@ -190,15 +190,15 @@ main (int argc, char **argv) get_priority_bands ("client", bands_file, rt_orb.in (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result != 0) return result; policy_manager->set_policy_overrides (policies, - CORBA::SET_OVERRIDE, - ACE_TRY_ENV); + CORBA::SET_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; u_long i = 0; @@ -244,7 +244,7 @@ main (int argc, char **argv) if (shutdown_server) { - test->shutdown (ACE_TRY_ENV); + test->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/tests/RTCORBA/Linear_Priority/readers.cpp b/TAO/tests/RTCORBA/Linear_Priority/readers.cpp index f596ac6908e..c5f1b31b73f 100644 --- a/TAO/tests/RTCORBA/Linear_Priority/readers.cpp +++ b/TAO/tests/RTCORBA/Linear_Priority/readers.cpp @@ -9,8 +9,8 @@ int get_priority_bands (const char *test_type, const char *bands_file, RTCORBA::RTORB_ptr rt_orb, - CORBA::PolicyList &policies, - CORBA::Environment &ACE_TRY_ENV) + CORBA::PolicyList &policies + TAO_ENV_ARG_DECL) { // // Read bands from a file. @@ -89,8 +89,8 @@ get_priority_bands (const char *test_type, "\n\n")); CORBA::Policy_var banded_connection_policy = - rt_orb->create_priority_banded_connection_policy (bands, - ACE_TRY_ENV); + rt_orb->create_priority_banded_connection_policy (bands + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); policies.length (policies.length () + 1); @@ -187,8 +187,8 @@ get_priority_lanes (const char *test_type, CORBA::ULong max_buffered_requests, CORBA::ULong max_request_buffer_size, CORBA::Boolean allow_borrowing, - CORBA::PolicyList &policies, - CORBA::Environment &ACE_TRY_ENV) + CORBA::PolicyList &policies + TAO_ENV_ARG_DECL) { Short_Array priorities; int result = @@ -218,13 +218,13 @@ get_priority_lanes (const char *test_type, allow_borrowing, allow_request_buffering, max_buffered_requests, - max_request_buffer_size, - ACE_TRY_ENV); + max_request_buffer_size + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::Policy_var threadpool_policy = - rt_orb->create_threadpool_policy (threadpool_id, - ACE_TRY_ENV); + rt_orb->create_threadpool_policy (threadpool_id + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); policies.length (policies.length () + 1); @@ -244,8 +244,8 @@ get_auto_priority_lanes_and_bands (CORBA::ULong number_of_lanes, CORBA::ULong max_buffered_requests, CORBA::ULong max_request_buffer_size, CORBA::Boolean allow_borrowing, - CORBA::PolicyList &policies, - CORBA::Environment &ACE_TRY_ENV) + CORBA::PolicyList &policies + TAO_ENV_ARG_DECL) { RTCORBA::ThreadpoolLanes lanes; lanes.length (number_of_lanes); @@ -299,20 +299,20 @@ get_auto_priority_lanes_and_bands (CORBA::ULong number_of_lanes, allow_borrowing, allow_request_buffering, max_buffered_requests, - max_request_buffer_size, - ACE_TRY_ENV); + max_request_buffer_size + TAO_ENV_ARG_PARAMETER); ACE_CHECK; policies.length (policies.length () + 1); policies[policies.length () - 1] = - rt_orb->create_priority_banded_connection_policy (bands, - ACE_TRY_ENV); + rt_orb->create_priority_banded_connection_policy (bands + TAO_ENV_ARG_PARAMETER); ACE_CHECK; policies.length (policies.length () + 1); policies[policies.length () - 1] = - rt_orb->create_threadpool_policy (threadpool_id, - ACE_TRY_ENV); + rt_orb->create_threadpool_policy (threadpool_id + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } diff --git a/TAO/tests/RTCORBA/Linear_Priority/server.cpp b/TAO/tests/RTCORBA/Linear_Priority/server.cpp index 94a8bd5b96d..2f4a26e031b 100644 --- a/TAO/tests/RTCORBA/Linear_Priority/server.cpp +++ b/TAO/tests/RTCORBA/Linear_Priority/server.cpp @@ -14,13 +14,13 @@ public: test_i (CORBA::ORB_ptr orb, PortableServer::POA_ptr poa); - void method (CORBA::Environment &ACE_TRY_ENV) + void method (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment &ACE_TRY_ENV) + void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - PortableServer::POA_ptr _default_POA (CORBA_Environment &ACE_TRY_ENV); + PortableServer::POA_ptr _default_POA (TAO_ENV_SINGLE_ARG_DECL); private: @@ -36,7 +36,7 @@ test_i::test_i (CORBA::ORB_ptr orb, } void -test_i::method (CORBA::Environment &) +test_i::method (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -44,19 +44,19 @@ test_i::method (CORBA::Environment &) } void -test_i::shutdown (CORBA::Environment &ACE_TRY_ENV) +test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "test_i::shutdown\n")); - this->orb_->shutdown (0, - ACE_TRY_ENV); + this->orb_->shutdown (0 + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } PortableServer::POA_ptr -test_i::_default_POA (CORBA_Environment &) +test_i::_default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) { return PortableServer::POA::_duplicate (this->poa_.in ()); } @@ -108,16 +108,16 @@ parse_args (int argc, char **argv) static void write_iors_to_file (CORBA::Object_ptr object, CORBA::ORB_ptr orb, - const char *filename, - CORBA::Environment &ACE_TRY_ENV) + const char *filename + TAO_ENV_ARG_DECL) { FILE *file = ACE_OS::fopen (filename, "w"); ACE_ASSERT (file != 0); CORBA::String_var ior = - orb->object_to_string (object, - ACE_TRY_ENV); + orb->object_to_string (object + TAO_ENV_ARG_PARAMETER); ACE_CHECK; u_int result = 0; @@ -144,18 +144,18 @@ main (int argc, char **argv) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var object = - orb->resolve_initial_references ("RTORB", - ACE_TRY_ENV); + orb->resolve_initial_references ("RTORB" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::RTORB_var rt_orb = - RTCORBA::RTORB::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::RTORB::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; int result = @@ -164,17 +164,17 @@ main (int argc, char **argv) return result; object = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (object.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyList policies; @@ -183,8 +183,8 @@ main (int argc, char **argv) get_priority_bands ("server", bands_file, rt_orb.in (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result != 0) return result; @@ -200,22 +200,22 @@ main (int argc, char **argv) max_buffered_requests, max_request_buffer_size, allow_borrowing, - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result != 0) return result; CORBA::Policy_var priority_model_policy = rt_orb->create_priority_model_policy (RTCORBA::CLIENT_PROPAGATED, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Implicit_activation policy. CORBA::Policy_var implicit_activation_policy = - root_poa->create_implicit_activation_policy (PortableServer::IMPLICIT_ACTIVATION, - ACE_TRY_ENV); + root_poa->create_implicit_activation_policy (PortableServer::IMPLICIT_ACTIVATION + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; policies.length (policies.length () + 1); @@ -229,8 +229,8 @@ main (int argc, char **argv) PortableServer::POA_var poa = root_poa->create_POA ("child", poa_manager.in (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; test_i *servant = 0; @@ -243,22 +243,22 @@ main (int argc, char **argv) PortableServer::ServantBase_var safe_servant (servant); test_var test = - servant->_this (ACE_TRY_ENV); + servant->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; write_iors_to_file (test.in (), orb.in (), - ior, - ACE_TRY_ENV); + ior + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/RTCORBA/MT_Client_Protocol_Priority/client.cpp b/TAO/tests/RTCORBA/MT_Client_Protocol_Priority/client.cpp index 14b94dc9382..8b2e6eb4110 100644 --- a/TAO/tests/RTCORBA/MT_Client_Protocol_Priority/client.cpp +++ b/TAO/tests/RTCORBA/MT_Client_Protocol_Priority/client.cpp @@ -151,7 +151,7 @@ main (int argc, char *argv[]) // ORB. CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Parse arguments. @@ -160,12 +160,12 @@ main (int argc, char *argv[]) // Priority Mapping Manager. CORBA::Object_var object = - orb->resolve_initial_references ("PriorityMappingManager", - ACE_TRY_ENV); + orb->resolve_initial_references ("PriorityMappingManager" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::PriorityMappingManager_var mapping_manager = - RTCORBA::PriorityMappingManager::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::PriorityMappingManager::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (mapping_manager.in (), "Mapping Manager") == -1) return 1; @@ -175,19 +175,19 @@ main (int argc, char *argv[]) // RTCurrent. object = - orb->resolve_initial_references ("RTCurrent", ACE_TRY_ENV); + orb->resolve_initial_references ("RTCurrent" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::Current_var current = - RTCORBA::Current::_narrow (object.in (), ACE_TRY_ENV); + RTCORBA::Current::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (current.in (), "RTCurrent") == -1) return 1; // Obtain Test object reference. object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - Test_var server = Test::_narrow (object.in (), ACE_TRY_ENV); + Test_var server = Test::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (server.in (), "Test object") == -1) return 1; @@ -195,19 +195,19 @@ main (int argc, char *argv[]) // Check that test object is configured with CLIENT_PROPAGATED // PriorityModelPolicy. CORBA::Policy_var policy = - server->_get_policy (RTCORBA::PRIORITY_MODEL_POLICY_TYPE, - ACE_TRY_ENV); + server->_get_policy (RTCORBA::PRIORITY_MODEL_POLICY_TYPE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::PriorityModelPolicy_var priority_policy = - RTCORBA::PriorityModelPolicy::_narrow (policy.in (), ACE_TRY_ENV); + RTCORBA::PriorityModelPolicy::_narrow (policy.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (priority_policy.in (), "PriorityModelPolicy") == -1) return 1; RTCORBA::PriorityModel priority_model = - priority_policy->priority_model (ACE_TRY_ENV); + priority_policy->priority_model (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (priority_model != RTCORBA::CLIENT_PROPAGATED) ACE_ERROR_RETURN ((LM_ERROR, @@ -264,9 +264,9 @@ main (int argc, char *argv[]) // Testing over. Shut down the server. ACE_DEBUG ((LM_DEBUG, "Client threads finished\n")); - current->the_priority (priority1, ACE_TRY_ENV); + current->the_priority (priority1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -299,21 +299,21 @@ Worker_Thread::svc (void) { // RTORB. CORBA::Object_var object = - this->orb_->resolve_initial_references ("RTORB", ACE_TRY_ENV); + this->orb_->resolve_initial_references ("RTORB" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (rt_orb.in (), "RTORB") == -1) return 0; // PolicyCurrent. object = - this->orb_->resolve_initial_references ("PolicyCurrent", - ACE_TRY_ENV); + this->orb_->resolve_initial_references ("PolicyCurrent" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyCurrent_var policy_current = - CORBA::PolicyCurrent::_narrow (object.in (), ACE_TRY_ENV); + CORBA::PolicyCurrent::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (policy_current.in (), "PolicyCurrent") == -1) @@ -331,13 +331,13 @@ Worker_Thread::svc (void) CORBA::PolicyList policy_list; policy_list.length (1); policy_list[0] = - rt_orb->create_client_protocol_policy (protocols, - ACE_TRY_ENV); + rt_orb->create_client_protocol_policy (protocols + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; policy_current->set_policy_overrides (policy_list, - CORBA::SET_OVERRIDE, - ACE_TRY_ENV); + CORBA::SET_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Wait for other threads. @@ -346,7 +346,7 @@ Worker_Thread::svc (void) for (int i = 0; i < iterations; ++i) { // Invoke method. - this->server_->test_method (ACE_TRY_ENV); + this->server_->test_method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/tests/RTCORBA/MT_Client_Protocol_Priority/server.cpp b/TAO/tests/RTCORBA/MT_Client_Protocol_Priority/server.cpp index 9a0ca3232bc..873bdf1165a 100644 --- a/TAO/tests/RTCORBA/MT_Client_Protocol_Priority/server.cpp +++ b/TAO/tests/RTCORBA/MT_Client_Protocol_Priority/server.cpp @@ -16,10 +16,10 @@ public: Test_i (CORBA::ORB_ptr orb); // ctor - void test_method (CORBA::Environment&) + void test_method (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: @@ -33,17 +33,17 @@ Test_i::Test_i (CORBA::ORB_ptr orb) } void -Test_i::test_method (CORBA::Environment& /* ACE_TRY_ENV */) +Test_i::test_method (TAO_ENV_SINGLE_ARG_DECL_NOT_USED /* TAO_ENV_SINGLE_ARG_PARAMETER */) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "test_method invoked\n")); } void -Test_i::shutdown (CORBA::Environment& ACE_TRY_ENV) +Test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } //************************************************************************* @@ -100,7 +100,7 @@ main (int argc, char *argv[]) { // ORB. CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Parse arguments. @@ -109,27 +109,27 @@ main (int argc, char *argv[]) // RTORB. CORBA::Object_var object = - orb->resolve_initial_references ("RTORB", ACE_TRY_ENV); + orb->resolve_initial_references ("RTORB" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (rt_orb.in (), "RTORB") == -1) return 1; // RootPOA. object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (root_poa.in (), "RootPOA") == -1) return 1; // POAManager. PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Create POA with CLIENT_PROPAGATED PriorityModelPolicy. @@ -137,32 +137,32 @@ main (int argc, char *argv[]) poa_policy_list.length (1); poa_policy_list[0] = rt_orb->create_priority_model_policy (RTCORBA::CLIENT_PROPAGATED, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var child_poa = root_poa->create_POA ("Child_POA", poa_manager.in (), - poa_policy_list, - ACE_TRY_ENV); + poa_policy_list + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Create object. Test_i server_impl (orb.in ()); PortableServer::ObjectId_var id = - child_poa->activate_object (&server_impl, ACE_TRY_ENV); + child_poa->activate_object (&server_impl TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var server = - child_poa->id_to_reference (id.in (), - ACE_TRY_ENV); + child_poa->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Print Object IOR. CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n\n", ior.in ())); @@ -180,11 +180,11 @@ main (int argc, char *argv[]) } // Activate POA manager. - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Start ORB event loop. - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Server ORB event loop finished\n\n")); diff --git a/TAO/tests/RTCORBA/ORB_init/ORB_init.cpp b/TAO/tests/RTCORBA/ORB_init/ORB_init.cpp index 7f30a09d190..e8c7cadba07 100644 --- a/TAO/tests/RTCORBA/ORB_init/ORB_init.cpp +++ b/TAO/tests/RTCORBA/ORB_init/ORB_init.cpp @@ -30,20 +30,20 @@ test_multiple_orbs (const char *test_name, orbs[i] = CORBA::ORB_init (argc, argv, - name, - ACE_TRY_ENV); + name + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (rt_orb) { CORBA::Object_var object = - orbs[i]->resolve_initial_references ("RTORB", - ACE_TRY_ENV); + orbs[i]->resolve_initial_references ("RTORB" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; rt_orbs[i] = - RTCORBA::RTORB::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::RTORB::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_ASSERT (rt_orbs[i].in () != RTCORBA::RTORB::_nil ()); @@ -56,7 +56,7 @@ test_multiple_orbs (const char *test_name, i < iterations; ++i) { - orbs[i]->destroy (ACE_TRY_ENV); + orbs[i]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/tests/RTCORBA/Persistent_IOR/client.cpp b/TAO/tests/RTCORBA/Persistent_IOR/client.cpp index 96fe92a903d..3affdc5150b 100644 --- a/TAO/tests/RTCORBA/Persistent_IOR/client.cpp +++ b/TAO/tests/RTCORBA/Persistent_IOR/client.cpp @@ -57,8 +57,8 @@ main (int argc, char **argv) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; int result = @@ -67,24 +67,24 @@ main (int argc, char **argv) return result; CORBA::Object_var object = - orb->string_to_object (ior, - ACE_TRY_ENV); + orb->string_to_object (ior + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; test_var test = - test::_narrow (object.in (), - ACE_TRY_ENV); + test::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; for (int i = 0; i < iterations; i++) { - test->method (ACE_TRY_ENV); + test->method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } if (shutdown_server) { - test->shutdown (ACE_TRY_ENV); + test->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/tests/RTCORBA/Persistent_IOR/server.cpp b/TAO/tests/RTCORBA/Persistent_IOR/server.cpp index 818330b693e..c4bf7b418d1 100644 --- a/TAO/tests/RTCORBA/Persistent_IOR/server.cpp +++ b/TAO/tests/RTCORBA/Persistent_IOR/server.cpp @@ -12,13 +12,13 @@ public: test_i (CORBA::ORB_ptr orb, PortableServer::POA_ptr poa); - void method (CORBA::Environment &ACE_TRY_ENV) + void method (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment &ACE_TRY_ENV) + void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - PortableServer::POA_ptr _default_POA (CORBA_Environment &ACE_TRY_ENV); + PortableServer::POA_ptr _default_POA (TAO_ENV_SINGLE_ARG_DECL); private: @@ -34,7 +34,7 @@ test_i::test_i (CORBA::ORB_ptr orb, } void -test_i::method (CORBA::Environment &) +test_i::method (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -42,19 +42,19 @@ test_i::method (CORBA::Environment &) } void -test_i::shutdown (CORBA::Environment &ACE_TRY_ENV) +test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "test_i::shutdown\n")); - this->orb_->shutdown (0, - ACE_TRY_ENV); + this->orb_->shutdown (0 + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } PortableServer::POA_ptr -test_i::_default_POA (CORBA_Environment &) +test_i::_default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) { return PortableServer::POA::_duplicate (this->poa_.in ()); } @@ -111,16 +111,16 @@ parse_args (int argc, char *argv[]) static void write_iors_to_file (CORBA::Object_ptr object, CORBA::ORB_ptr orb, - const char *filename, - CORBA::Environment &ACE_TRY_ENV) + const char *filename + TAO_ENV_ARG_DECL) { FILE *file = ACE_OS::fopen (filename, "w"); ACE_ASSERT (file != 0); CORBA::String_var ior = - orb->object_to_string (object, - ACE_TRY_ENV); + orb->object_to_string (object + TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (debug) @@ -143,19 +143,19 @@ write_iors_to_file (CORBA::Object_ptr object, void create_poa_and_servant_with_persistent_policy (CORBA::ORB_ptr orb, PortableServer::POA_ptr root_poa, - PortableServer::POAManager_ptr poa_manager, - CORBA::Environment &ACE_TRY_ENV) + PortableServer::POAManager_ptr poa_manager + TAO_ENV_ARG_DECL) { CORBA::PolicyList policies; CORBA::Policy_var implicit_activation_policy = - root_poa->create_implicit_activation_policy (PortableServer::IMPLICIT_ACTIVATION, - ACE_TRY_ENV); + root_poa->create_implicit_activation_policy (PortableServer::IMPLICIT_ACTIVATION + TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::Policy_var lifespan_policy = - root_poa->create_lifespan_policy (PortableServer::PERSISTENT, - ACE_TRY_ENV); + root_poa->create_lifespan_policy (PortableServer::PERSISTENT + TAO_ENV_ARG_PARAMETER); ACE_CHECK; policies.length (policies.length () + 1); @@ -169,8 +169,8 @@ create_poa_and_servant_with_persistent_policy (CORBA::ORB_ptr orb, PortableServer::POA_var poa = root_poa->create_POA ("persistent_child", poa_manager, - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_CHECK; test_i *servant = 0; @@ -183,13 +183,13 @@ create_poa_and_servant_with_persistent_policy (CORBA::ORB_ptr orb, PortableServer::ServantBase_var safe_servant (servant); test_var test = - servant->_this (ACE_TRY_ENV); + servant->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; write_iors_to_file (test.in (), orb, - persistent_ior, - ACE_TRY_ENV); + persistent_ior + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } @@ -197,8 +197,8 @@ void create_poa_and_servant_with_tp_policy (CORBA::ORB_ptr orb, RTCORBA::RTORB_ptr rt_orb, PortableServer::POA_ptr root_poa, - PortableServer::POAManager_ptr poa_manager, - CORBA::Environment &ACE_TRY_ENV) + PortableServer::POAManager_ptr poa_manager + TAO_ENV_ARG_DECL) { RTCORBA::ThreadpoolId threadpool_id = rt_orb->create_threadpool (stacksize, @@ -207,18 +207,18 @@ create_poa_and_servant_with_tp_policy (CORBA::ORB_ptr orb, default_thread_priority, allow_request_buffering, max_buffered_requests, - max_request_buffer_size, - ACE_TRY_ENV); + max_request_buffer_size + TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::Policy_var threadpool_policy = - rt_orb->create_threadpool_policy (threadpool_id, - ACE_TRY_ENV); + rt_orb->create_threadpool_policy (threadpool_id + TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::Policy_var implicit_activation_policy = - root_poa->create_implicit_activation_policy (PortableServer::IMPLICIT_ACTIVATION, - ACE_TRY_ENV); + root_poa->create_implicit_activation_policy (PortableServer::IMPLICIT_ACTIVATION + TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::PolicyList policies; @@ -234,8 +234,8 @@ create_poa_and_servant_with_tp_policy (CORBA::ORB_ptr orb, PortableServer::POA_var poa = root_poa->create_POA ("tp_child", poa_manager, - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_CHECK; test_i *servant = 0; @@ -248,20 +248,20 @@ create_poa_and_servant_with_tp_policy (CORBA::ORB_ptr orb, PortableServer::ServantBase_var safe_servant (servant); test_var test = - servant->_this (ACE_TRY_ENV); + servant->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; write_iors_to_file (test.in (), orb, - transient_ior, - ACE_TRY_ENV); + transient_ior + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } void create_poa_with_tp_and_persistent_policy (RTCORBA::RTORB_ptr rt_orb, - PortableServer::POA_ptr root_poa, - CORBA::Environment &ACE_TRY_ENV) + PortableServer::POA_ptr root_poa + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -274,18 +274,18 @@ create_poa_with_tp_and_persistent_policy (RTCORBA::RTORB_ptr rt_orb, default_thread_priority, allow_request_buffering, max_buffered_requests, - max_request_buffer_size, - ACE_TRY_ENV); + max_request_buffer_size + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Policy_var threadpool_policy = - rt_orb->create_threadpool_policy (threadpool_id, - ACE_TRY_ENV); + rt_orb->create_threadpool_policy (threadpool_id + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Policy_var lifespan_policy = - root_poa->create_lifespan_policy (PortableServer::PERSISTENT, - ACE_TRY_ENV); + root_poa->create_lifespan_policy (PortableServer::PERSISTENT + TAO_ENV_ARG_PARAMETER); ACE_CHECK; policies.length (policies.length () + 1); @@ -299,8 +299,8 @@ create_poa_with_tp_and_persistent_policy (RTCORBA::RTORB_ptr rt_orb, PortableServer::POA_var invalid_poa = root_poa->create_POA ("invalid", PortableServer::POAManager::_nil (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // This next line of code should not run because an exception @@ -331,8 +331,8 @@ main (int argc, char **argv) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; int result = @@ -341,68 +341,68 @@ main (int argc, char **argv) return result; CORBA::Object_var object = - orb->resolve_initial_references ("RTORB", - ACE_TRY_ENV); + orb->resolve_initial_references ("RTORB" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::RTORB_var rt_orb = - RTCORBA::RTORB::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::RTORB::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; object = - orb->resolve_initial_references ("RTCurrent", - ACE_TRY_ENV); + orb->resolve_initial_references ("RTCurrent" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::Current_var current = - RTCORBA::Current::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::Current::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; default_thread_priority = - current->the_priority (ACE_TRY_ENV); + current->the_priority (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; object = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (object.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; create_poa_and_servant_with_tp_policy (orb.in (), rt_orb.in (), root_poa.in (), - poa_manager.in (), - ACE_TRY_ENV); + poa_manager.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; create_poa_and_servant_with_persistent_policy (orb.in (), root_poa.in (), - poa_manager.in (), - ACE_TRY_ENV); + poa_manager.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; create_poa_with_tp_and_persistent_policy (rt_orb.in (), - root_poa.in (), - ACE_TRY_ENV); + root_poa.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/RTCORBA/Policy_Combinations/client.cpp b/TAO/tests/RTCORBA/Policy_Combinations/client.cpp index bf74a4cd00e..24688032808 100644 --- a/TAO/tests/RTCORBA/Policy_Combinations/client.cpp +++ b/TAO/tests/RTCORBA/Policy_Combinations/client.cpp @@ -64,8 +64,8 @@ main (int argc, char **argv) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; int result = @@ -93,53 +93,53 @@ main (int argc, char **argv) return result; CORBA::Object_var object = - orb->resolve_initial_references ("RTCurrent", - ACE_TRY_ENV); + orb->resolve_initial_references ("RTCurrent" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::Current_var current = - RTCORBA::Current::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::Current::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; default_thread_priority = - current->the_priority (ACE_TRY_ENV); + current->the_priority (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; object = - orb->string_to_object (ior, - ACE_TRY_ENV); + orb->string_to_object (ior + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; test_var test = - test::_narrow (object.in (), - ACE_TRY_ENV); + test::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; for (int i = 0; i < iterations; i++) { - current->the_priority (default_thread_priority, - ACE_TRY_ENV); + current->the_priority (default_thread_priority + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Short priority = - test->method (ACE_TRY_ENV); + test->method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (priority != TAO_INVALID_PRIORITY) { - current->the_priority (priority, - ACE_TRY_ENV); + current->the_priority (priority + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - test->prioritized_method (ACE_TRY_ENV); + test->prioritized_method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } if (shutdown_server) { - test->shutdown (ACE_TRY_ENV); + test->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/tests/RTCORBA/Policy_Combinations/server.cpp b/TAO/tests/RTCORBA/Policy_Combinations/server.cpp index 6d98f81ab1b..879aa6ccb6e 100644 --- a/TAO/tests/RTCORBA/Policy_Combinations/server.cpp +++ b/TAO/tests/RTCORBA/Policy_Combinations/server.cpp @@ -16,16 +16,16 @@ public: CORBA::Short server_priority, CORBA::Short client_priority); - CORBA::Short method (CORBA::Environment &ACE_TRY_ENV) + CORBA::Short method (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - void prioritized_method (CORBA::Environment &ACE_TRY_ENV) + void prioritized_method (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment &ACE_TRY_ENV) + void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - PortableServer::POA_ptr _default_POA (CORBA_Environment &ACE_TRY_ENV); + PortableServer::POA_ptr _default_POA (TAO_ENV_SINGLE_ARG_DECL); private: @@ -47,7 +47,7 @@ test_i::test_i (CORBA::ORB_ptr orb, } CORBA::Short -test_i::method (CORBA::Environment &) +test_i::method (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -57,21 +57,21 @@ test_i::method (CORBA::Environment &) } void -test_i::prioritized_method (CORBA::Environment &ACE_TRY_ENV) +test_i::prioritized_method (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { CORBA::Object_var object = - this->orb_->resolve_initial_references ("RTCurrent", - ACE_TRY_ENV); + this->orb_->resolve_initial_references ("RTCurrent" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; RTCORBA::Current_var current = - RTCORBA::Current::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::Current::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::Short priority = - current->the_priority (ACE_TRY_ENV); + current->the_priority (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -84,19 +84,19 @@ test_i::prioritized_method (CORBA::Environment &ACE_TRY_ENV) } void -test_i::shutdown (CORBA::Environment &ACE_TRY_ENV) +test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "test_i::shutdown\n")); - this->orb_->shutdown (0, - ACE_TRY_ENV); + this->orb_->shutdown (0 + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } PortableServer::POA_ptr -test_i::_default_POA (CORBA_Environment &) +test_i::_default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) { return PortableServer::POA::_duplicate (this->poa_.in ()); } @@ -146,16 +146,16 @@ parse_args (int argc, char **argv) static void write_iors_to_file (CORBA::Object_ptr object, CORBA::ORB_ptr orb, - const char *filename, - CORBA::Environment &ACE_TRY_ENV) + const char *filename + TAO_ENV_ARG_DECL) { FILE *file = ACE_OS::fopen (filename, "w"); ACE_ASSERT (file != 0); CORBA::String_var ior = - orb->object_to_string (object, - ACE_TRY_ENV); + orb->object_to_string (object + TAO_ENV_ARG_PARAMETER); ACE_CHECK; u_int result = 0; @@ -178,87 +178,87 @@ public: PortableServer::POA_ptr root_poa, PortableServer::POAManager_ptr poa_manager); - void test_root_poa (CORBA::Environment &ACE_TRY_ENV); - void test_child_poa (CORBA::Environment &ACE_TRY_ENV); + void test_root_poa (TAO_ENV_SINGLE_ARG_DECL); + void test_child_poa (TAO_ENV_SINGLE_ARG_DECL); typedef void (server::*test_function) (CORBA::PolicyList &policies, CORBA::Short server_priority, CORBA::Short client_priority, - const char *test_name, - CORBA::Environment &ACE_TRY_ENV); + const char *test_name + TAO_ENV_ARG_DECL); void test_default_pool_poa (CORBA::Short server_priority, CORBA::Short client_priority, server::test_function function, - const char *test_name, - CORBA::Environment &ACE_TRY_ENV); + const char *test_name + TAO_ENV_ARG_DECL); void test_bands_poa (CORBA::PolicyList &policies, CORBA::Short server_priority, CORBA::Short client_priority, server::test_function function, - const char *test_name, - CORBA::Environment &ACE_TRY_ENV); + const char *test_name + TAO_ENV_ARG_DECL); void test_no_lanes_poa (CORBA::Short server_priority, CORBA::Short client_priority, server::test_function function, - const char *test_name, - CORBA::Environment &ACE_TRY_ENV); + const char *test_name + TAO_ENV_ARG_DECL); void test_lanes_poa (CORBA::Short server_priority, CORBA::Short client_priority, server::test_function function, - const char *test_name, - CORBA::Environment &ACE_TRY_ENV); + const char *test_name + TAO_ENV_ARG_DECL); void test_no_bands_client_propagated_poa (CORBA::PolicyList &policies, CORBA::Short server_priority, CORBA::Short client_priority, - const char *test_name, - CORBA::Environment &ACE_TRY_ENV); + const char *test_name + TAO_ENV_ARG_DECL); void test_bands_client_propagated_poa (CORBA::PolicyList &policies, CORBA::Short server_priority, CORBA::Short client_priority, - const char *test_name, - CORBA::Environment &ACE_TRY_ENV); + const char *test_name + TAO_ENV_ARG_DECL); void test_no_bands_server_declared_poa (CORBA::PolicyList &policies, CORBA::Short server_priority, CORBA::Short client_priority, - const char *test_name, - CORBA::Environment &ACE_TRY_ENV); + const char *test_name + TAO_ENV_ARG_DECL); void test_bands_server_declared_poa (CORBA::PolicyList &policies, CORBA::Short server_priority, CORBA::Short client_priority, - const char *test_name, - CORBA::Environment &ACE_TRY_ENV); + const char *test_name + TAO_ENV_ARG_DECL); - void test_default_pool_no_bands_client_propagated_poa (CORBA::Environment &ACE_TRY_ENV); + void test_default_pool_no_bands_client_propagated_poa (TAO_ENV_SINGLE_ARG_DECL); - void test_no_lanes_no_bands_client_propagated_poa (CORBA::Environment &ACE_TRY_ENV); + void test_no_lanes_no_bands_client_propagated_poa (TAO_ENV_SINGLE_ARG_DECL); - void test_lanes_no_bands_client_propagated_poa (CORBA::Environment &ACE_TRY_ENV); + void test_lanes_no_bands_client_propagated_poa (TAO_ENV_SINGLE_ARG_DECL); - void test_default_pool_bands_client_propagated_poa (CORBA::Environment &ACE_TRY_ENV); + void test_default_pool_bands_client_propagated_poa (TAO_ENV_SINGLE_ARG_DECL); - void test_no_lanes_bands_client_propagated_poa (CORBA::Environment &ACE_TRY_ENV); + void test_no_lanes_bands_client_propagated_poa (TAO_ENV_SINGLE_ARG_DECL); - void test_lanes_bands_client_propagated_poa (CORBA::Environment &ACE_TRY_ENV); + void test_lanes_bands_client_propagated_poa (TAO_ENV_SINGLE_ARG_DECL); - void test_default_pool_no_bands_server_declared_poa (CORBA::Environment &ACE_TRY_ENV); + void test_default_pool_no_bands_server_declared_poa (TAO_ENV_SINGLE_ARG_DECL); - void test_no_lanes_no_bands_server_declared_poa (CORBA::Environment &ACE_TRY_ENV); + void test_no_lanes_no_bands_server_declared_poa (TAO_ENV_SINGLE_ARG_DECL); - void test_lanes_no_bands_server_declared_poa (CORBA::Environment &ACE_TRY_ENV); + void test_lanes_no_bands_server_declared_poa (TAO_ENV_SINGLE_ARG_DECL); - void test_default_pool_bands_server_declared_poa (CORBA::Environment &ACE_TRY_ENV); + void test_default_pool_bands_server_declared_poa (TAO_ENV_SINGLE_ARG_DECL); - void test_no_lanes_bands_server_declared_poa (CORBA::Environment &ACE_TRY_ENV); + void test_no_lanes_bands_server_declared_poa (TAO_ENV_SINGLE_ARG_DECL); - void test_lanes_bands_server_declared_poa (CORBA::Environment &ACE_TRY_ENV); + void test_lanes_bands_server_declared_poa (TAO_ENV_SINGLE_ARG_DECL); private: @@ -280,7 +280,7 @@ server::server (CORBA::ORB_ptr orb, } void -server::test_root_poa (CORBA::Environment &ACE_TRY_ENV) +server::test_root_poa (TAO_ENV_SINGLE_ARG_DECL) { test_i *servant = 0; ACE_NEW_THROW_EX (servant, @@ -294,31 +294,31 @@ server::test_root_poa (CORBA::Environment &ACE_TRY_ENV) PortableServer::ServantBase_var safe_servant (servant); test_var test = - servant->_this (ACE_TRY_ENV); + servant->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; write_iors_to_file (test.in (), this->orb_.in (), - "root", - ACE_TRY_ENV); + "root" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } void -server::test_child_poa (CORBA::Environment &ACE_TRY_ENV) +server::test_child_poa (TAO_ENV_SINGLE_ARG_DECL) { CORBA::PolicyList policies; policies.length (1); policies[policies.length () - 1] = - this->root_poa_->create_implicit_activation_policy (PortableServer::IMPLICIT_ACTIVATION, - ACE_TRY_ENV); + this->root_poa_->create_implicit_activation_policy (PortableServer::IMPLICIT_ACTIVATION + TAO_ENV_ARG_PARAMETER); ACE_CHECK; PortableServer::POA_var poa = this->root_poa_->create_POA ("child", this->poa_manager_.in (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_CHECK; test_i *servant = 0; @@ -333,13 +333,13 @@ server::test_child_poa (CORBA::Environment &ACE_TRY_ENV) PortableServer::ServantBase_var safe_servant (servant); test_var test = - servant->_this (ACE_TRY_ENV); + servant->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; write_iors_to_file (test.in (), this->orb_.in (), - "child", - ACE_TRY_ENV); + "child" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } @@ -347,15 +347,15 @@ void server::test_default_pool_poa (CORBA::Short server_priority, CORBA::Short client_priority, server::test_function function, - const char *test_name, - CORBA::Environment &ACE_TRY_ENV) + const char *test_name + TAO_ENV_ARG_DECL) { CORBA::PolicyList empty_policies; (this->*function) (empty_policies, server_priority, client_priority, - test_name, - ACE_TRY_ENV); + test_name + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } @@ -364,8 +364,8 @@ server::test_bands_poa (CORBA::PolicyList &policies, CORBA::Short server_priority, CORBA::Short client_priority, server::test_function function, - const char *test_name, - CORBA::Environment &ACE_TRY_ENV) + const char *test_name + TAO_ENV_ARG_DECL) { RTCORBA::PriorityBands bands; bands.length (3); @@ -379,15 +379,15 @@ server::test_bands_poa (CORBA::PolicyList &policies, policies.length (policies.length () + 1); policies[policies.length () - 1] = - this->rt_orb_->create_priority_banded_connection_policy (bands, - ACE_TRY_ENV); + this->rt_orb_->create_priority_banded_connection_policy (bands + TAO_ENV_ARG_PARAMETER); ACE_CHECK; (this->*function) (policies, server_priority, client_priority, - test_name, - ACE_TRY_ENV); + test_name + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } @@ -395,8 +395,8 @@ void server::test_no_lanes_poa (CORBA::Short server_priority, CORBA::Short client_priority, server::test_function function, - const char *test_name, - CORBA::Environment &ACE_TRY_ENV) + const char *test_name + TAO_ENV_ARG_DECL) { RTCORBA::ThreadpoolId threadpool_id = this->rt_orb_->create_threadpool (stacksize, @@ -405,13 +405,13 @@ server::test_no_lanes_poa (CORBA::Short server_priority, default_thread_priority, allow_request_buffering, max_buffered_requests, - max_request_buffer_size, - ACE_TRY_ENV); + max_request_buffer_size + TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::Policy_var threadpool_policy = - this->rt_orb_->create_threadpool_policy (threadpool_id, - ACE_TRY_ENV); + this->rt_orb_->create_threadpool_policy (threadpool_id + TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::PolicyList policies; @@ -422,8 +422,8 @@ server::test_no_lanes_poa (CORBA::Short server_priority, (this->*function) (policies, server_priority, client_priority, - test_name, - ACE_TRY_ENV); + test_name + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } @@ -431,8 +431,8 @@ void server::test_lanes_poa (CORBA::Short server_priority, CORBA::Short client_priority, server::test_function function, - const char *test_name, - CORBA::Environment &ACE_TRY_ENV) + const char *test_name + TAO_ENV_ARG_DECL) { RTCORBA::ThreadpoolLanes lanes; lanes.length (3); @@ -455,13 +455,13 @@ server::test_lanes_poa (CORBA::Short server_priority, allow_borrowing, allow_request_buffering, max_buffered_requests, - max_request_buffer_size, - ACE_TRY_ENV); + max_request_buffer_size + TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::Policy_var threadpool_policy = - this->rt_orb_->create_threadpool_policy (threadpool_id, - ACE_TRY_ENV); + this->rt_orb_->create_threadpool_policy (threadpool_id + TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::PolicyList policies; @@ -472,8 +472,8 @@ server::test_lanes_poa (CORBA::Short server_priority, (this->*function) (policies, server_priority, client_priority, - test_name, - ACE_TRY_ENV); + test_name + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } @@ -481,26 +481,26 @@ void server::test_no_bands_client_propagated_poa (CORBA::PolicyList &policies, CORBA::Short server_priority, CORBA::Short client_priority, - const char *test_name, - CORBA::Environment &ACE_TRY_ENV) + const char *test_name + TAO_ENV_ARG_DECL) { policies.length (policies.length () + 1); policies[policies.length () - 1] = this->rt_orb_->create_priority_model_policy (RTCORBA::CLIENT_PROPAGATED, - default_thread_priority, - ACE_TRY_ENV); + default_thread_priority + TAO_ENV_ARG_PARAMETER); ACE_CHECK; PortableServer::POA_var poa = this->root_poa_->create_POA (test_name, this->poa_manager_.in (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_CHECK; RTPortableServer::POA_var rt_poa = - RTPortableServer::POA::_narrow (poa.in (), - ACE_TRY_ENV); + RTPortableServer::POA::_narrow (poa.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; test_i *servant = 0; @@ -515,19 +515,19 @@ server::test_no_bands_client_propagated_poa (CORBA::PolicyList &policies, PortableServer::ServantBase_var safe_servant (servant); PortableServer::ObjectId_var id = - rt_poa->activate_object (servant, - ACE_TRY_ENV); + rt_poa->activate_object (servant + TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::Object_var object = - poa->id_to_reference (id.in (), - ACE_TRY_ENV); + poa->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; write_iors_to_file (object.in (), this->orb_.in (), - test_name, - ACE_TRY_ENV); + test_name + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } @@ -535,81 +535,81 @@ void server::test_bands_client_propagated_poa (CORBA::PolicyList &policies, CORBA::Short server_priority, CORBA::Short client_priority, - const char *test_name, - CORBA::Environment &ACE_TRY_ENV) + const char *test_name + TAO_ENV_ARG_DECL) { this->test_bands_poa (policies, server_priority, client_priority, &server::test_no_bands_client_propagated_poa, - test_name, - ACE_TRY_ENV); + test_name + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } void -server::test_default_pool_no_bands_client_propagated_poa (CORBA::Environment &ACE_TRY_ENV) +server::test_default_pool_no_bands_client_propagated_poa (TAO_ENV_SINGLE_ARG_DECL) { this->test_default_pool_poa (::client_priority + 1, ::client_priority + 1, &server::test_no_bands_client_propagated_poa, - "default_pool_no_bands_client_propagated", - ACE_TRY_ENV); + "default_pool_no_bands_client_propagated" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } void -server::test_no_lanes_no_bands_client_propagated_poa (CORBA::Environment &ACE_TRY_ENV) +server::test_no_lanes_no_bands_client_propagated_poa (TAO_ENV_SINGLE_ARG_DECL) { this->test_no_lanes_poa (::client_priority - 1, ::client_priority - 1, &server::test_no_bands_client_propagated_poa, - "no_lanes_no_bands_client_propagated", - ACE_TRY_ENV); + "no_lanes_no_bands_client_propagated" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } void -server::test_lanes_no_bands_client_propagated_poa (CORBA::Environment &ACE_TRY_ENV) +server::test_lanes_no_bands_client_propagated_poa (TAO_ENV_SINGLE_ARG_DECL) { this->test_lanes_poa (::client_priority, ::client_priority, &server::test_no_bands_client_propagated_poa, - "lanes_no_bands_client_propagated", - ACE_TRY_ENV); + "lanes_no_bands_client_propagated" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } void -server::test_default_pool_bands_client_propagated_poa (CORBA::Environment &ACE_TRY_ENV) +server::test_default_pool_bands_client_propagated_poa (TAO_ENV_SINGLE_ARG_DECL) { this->test_default_pool_poa (::client_priority + 1, ::client_priority + 1, &server::test_bands_client_propagated_poa, - "default_pool_bands_client_propagated", - ACE_TRY_ENV); + "default_pool_bands_client_propagated" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } void -server::test_no_lanes_bands_client_propagated_poa (CORBA::Environment &ACE_TRY_ENV) +server::test_no_lanes_bands_client_propagated_poa (TAO_ENV_SINGLE_ARG_DECL) { this->test_no_lanes_poa (::client_priority - 1, ::client_priority - 1, &server::test_bands_client_propagated_poa, - "no_lanes_bands_client_propagated", - ACE_TRY_ENV); + "no_lanes_bands_client_propagated" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } void -server::test_lanes_bands_client_propagated_poa (CORBA::Environment &ACE_TRY_ENV) +server::test_lanes_bands_client_propagated_poa (TAO_ENV_SINGLE_ARG_DECL) { this->test_lanes_poa (::client_priority, ::client_priority + 1, &server::test_bands_client_propagated_poa, - "lanes_bands_client_propagated", - ACE_TRY_ENV); + "lanes_bands_client_propagated" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } @@ -618,26 +618,26 @@ void server::test_no_bands_server_declared_poa (CORBA::PolicyList &policies, CORBA::Short server_priority, CORBA::Short client_priority, - const char *test_name, - CORBA::Environment &ACE_TRY_ENV) + const char *test_name + TAO_ENV_ARG_DECL) { policies.length (policies.length () + 1); policies[policies.length () - 1] = this->rt_orb_->create_priority_model_policy (RTCORBA::SERVER_DECLARED, - default_thread_priority, - ACE_TRY_ENV); + default_thread_priority + TAO_ENV_ARG_PARAMETER); ACE_CHECK; PortableServer::POA_var poa = this->root_poa_->create_POA (test_name, this->poa_manager_.in (), - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_CHECK; RTPortableServer::POA_var rt_poa = - RTPortableServer::POA::_narrow (poa.in (), - ACE_TRY_ENV); + RTPortableServer::POA::_narrow (poa.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; test_i *servant = 0; @@ -653,19 +653,19 @@ server::test_no_bands_server_declared_poa (CORBA::PolicyList &policies, PortableServer::ObjectId_var id = rt_poa->activate_object_with_priority (servant, - ::server_priority, - ACE_TRY_ENV); + ::server_priority + TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::Object_var object = - poa->id_to_reference (id.in (), - ACE_TRY_ENV); + poa->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; write_iors_to_file (object.in (), this->orb_.in (), - test_name, - ACE_TRY_ENV); + test_name + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } @@ -673,81 +673,81 @@ void server::test_bands_server_declared_poa (CORBA::PolicyList &policies, CORBA::Short server_priority, CORBA::Short client_priority, - const char *test_name, - CORBA::Environment &ACE_TRY_ENV) + const char *test_name + TAO_ENV_ARG_DECL) { this->test_bands_poa (policies, server_priority, client_priority, &server::test_no_bands_server_declared_poa, - test_name, - ACE_TRY_ENV); + test_name + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } void -server::test_default_pool_no_bands_server_declared_poa (CORBA::Environment &ACE_TRY_ENV) +server::test_default_pool_no_bands_server_declared_poa (TAO_ENV_SINGLE_ARG_DECL) { this->test_default_pool_poa (::server_priority, ::client_priority + 1, &server::test_no_bands_server_declared_poa, - "default_pool_no_bands_server_declared", - ACE_TRY_ENV); + "default_pool_no_bands_server_declared" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } void -server::test_no_lanes_no_bands_server_declared_poa (CORBA::Environment &ACE_TRY_ENV) +server::test_no_lanes_no_bands_server_declared_poa (TAO_ENV_SINGLE_ARG_DECL) { this->test_no_lanes_poa (::server_priority, ::client_priority - 1, &server::test_no_bands_server_declared_poa, - "no_lanes_no_bands_server_declared", - ACE_TRY_ENV); + "no_lanes_no_bands_server_declared" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } void -server::test_lanes_no_bands_server_declared_poa (CORBA::Environment &ACE_TRY_ENV) +server::test_lanes_no_bands_server_declared_poa (TAO_ENV_SINGLE_ARG_DECL) { this->test_lanes_poa (::server_priority, ::client_priority + 1, &server::test_no_bands_server_declared_poa, - "lanes_no_bands_server_declared", - ACE_TRY_ENV); + "lanes_no_bands_server_declared" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } void -server::test_default_pool_bands_server_declared_poa (CORBA::Environment &ACE_TRY_ENV) +server::test_default_pool_bands_server_declared_poa (TAO_ENV_SINGLE_ARG_DECL) { this->test_default_pool_poa (::server_priority, ::client_priority - 1, &server::test_bands_server_declared_poa, - "default_pool_bands_server_declared", - ACE_TRY_ENV); + "default_pool_bands_server_declared" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } void -server::test_no_lanes_bands_server_declared_poa (CORBA::Environment &ACE_TRY_ENV) +server::test_no_lanes_bands_server_declared_poa (TAO_ENV_SINGLE_ARG_DECL) { this->test_no_lanes_poa (::server_priority, ::client_priority + 1, &server::test_bands_server_declared_poa, - "no_lanes_bands_server_declared", - ACE_TRY_ENV); + "no_lanes_bands_server_declared" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } void -server::test_lanes_bands_server_declared_poa (CORBA::Environment &ACE_TRY_ENV) +server::test_lanes_bands_server_declared_poa (TAO_ENV_SINGLE_ARG_DECL) { this->test_lanes_poa (::server_priority, ::client_priority - 1, &server::test_bands_server_declared_poa, - "lanes_bands_server_declared", - ACE_TRY_ENV); + "lanes_bands_server_declared" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } @@ -763,18 +763,18 @@ main (int argc, char **argv) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var object = - orb->resolve_initial_references ("RTORB", - ACE_TRY_ENV); + orb->resolve_initial_references ("RTORB" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::RTORB_var rt_orb = - RTCORBA::RTORB::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::RTORB::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // The following sets the current thread to the lowest priority @@ -797,17 +797,17 @@ main (int argc, char **argv) return result; object = - orb->resolve_initial_references ("RTCurrent", - ACE_TRY_ENV); + orb->resolve_initial_references ("RTCurrent" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::Current_var current = - RTCORBA::Current::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::Current::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; default_thread_priority = - current->the_priority (ACE_TRY_ENV); + current->the_priority (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; client_priority = @@ -822,17 +822,17 @@ main (int argc, char **argv) return result; object = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (object.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; server server (orb.in (), @@ -840,55 +840,55 @@ main (int argc, char **argv) root_poa.in (), poa_manager.in ()); - server.test_root_poa (ACE_TRY_ENV); + server.test_root_poa (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - server.test_child_poa (ACE_TRY_ENV); + server.test_child_poa (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - server.test_default_pool_no_bands_client_propagated_poa (ACE_TRY_ENV); + server.test_default_pool_no_bands_client_propagated_poa (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - server.test_default_pool_no_bands_server_declared_poa (ACE_TRY_ENV); + server.test_default_pool_no_bands_server_declared_poa (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - server.test_no_lanes_no_bands_client_propagated_poa (ACE_TRY_ENV); + server.test_no_lanes_no_bands_client_propagated_poa (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - server.test_no_lanes_no_bands_server_declared_poa (ACE_TRY_ENV); + server.test_no_lanes_no_bands_server_declared_poa (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - server.test_lanes_no_bands_client_propagated_poa (ACE_TRY_ENV); + server.test_lanes_no_bands_client_propagated_poa (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - server.test_lanes_no_bands_server_declared_poa (ACE_TRY_ENV); + server.test_lanes_no_bands_server_declared_poa (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - server.test_default_pool_bands_client_propagated_poa (ACE_TRY_ENV); + server.test_default_pool_bands_client_propagated_poa (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - server.test_default_pool_bands_server_declared_poa (ACE_TRY_ENV); + server.test_default_pool_bands_server_declared_poa (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - server.test_no_lanes_bands_client_propagated_poa (ACE_TRY_ENV); + server.test_no_lanes_bands_client_propagated_poa (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - server.test_no_lanes_bands_server_declared_poa (ACE_TRY_ENV); + server.test_no_lanes_bands_server_declared_poa (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - server.test_lanes_bands_client_propagated_poa (ACE_TRY_ENV); + server.test_lanes_bands_client_propagated_poa (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - server.test_lanes_bands_server_declared_poa (ACE_TRY_ENV); + server.test_lanes_bands_server_declared_poa (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/RTCORBA/Private_Connection/client.cpp b/TAO/tests/RTCORBA/Private_Connection/client.cpp index 3e03e33daac..9639177547a 100644 --- a/TAO/tests/RTCORBA/Private_Connection/client.cpp +++ b/TAO/tests/RTCORBA/Private_Connection/client.cpp @@ -57,7 +57,7 @@ main (int argc, char *argv[]) // ORB. CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Parse arguments. @@ -66,37 +66,37 @@ main (int argc, char *argv[]) // RTORB. CORBA::Object_var object = - orb->resolve_initial_references ("RTORB", ACE_TRY_ENV); + orb->resolve_initial_references ("RTORB" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (rt_orb.in (), "RTORB") == -1) return 1; // PolicyCurrent. - object = orb->resolve_initial_references ("PolicyCurrent", - ACE_TRY_ENV); + object = orb->resolve_initial_references ("PolicyCurrent" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyCurrent_var policy_current = - CORBA::PolicyCurrent::_narrow (object.in (), ACE_TRY_ENV); + CORBA::PolicyCurrent::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (policy_current.in (), "PolicyCurrent") == -1) return 1; // Test object 1. - object = orb->string_to_object (ior1, ACE_TRY_ENV); + object = orb->string_to_object (ior1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - Test_var server1 = Test::_narrow (object.in (), ACE_TRY_ENV); + Test_var server1 = Test::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (server1.in (), "server1") == -1) return 1; // Test object 2. - object = orb->string_to_object (ior2, ACE_TRY_ENV); + object = orb->string_to_object (ior2 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - Test_var server2 = Test::_narrow (object.in (), ACE_TRY_ENV); + Test_var server2 = Test::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (server2.in (), "server2") == -1) return 1; @@ -106,34 +106,34 @@ main (int argc, char *argv[]) // following three. ACE_DEBUG ((LM_DEBUG, "\n Invocation 1 --> new connection\n")); - server1->test_method (ACE_TRY_ENV); + server1->test_method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "\n Invocation 2 --> use connection from invocation 1\n")); - server2->test_method (ACE_TRY_ENV); + server2->test_method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "\n Invocation 3 --> use connection from invocation 1\n")); - server1->test_method (ACE_TRY_ENV); + server1->test_method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "\n Invocation 4 --> use connection from invocation 1\n")); - server2->test_method (ACE_TRY_ENV); + server2->test_method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Set RTCORBA::PrivateConnectionPolicy on PolicyCurrent. CORBA::PolicyList policy_list; policy_list.length (1); policy_list[0] = - rt_orb->create_private_connection_policy (ACE_TRY_ENV); + rt_orb->create_private_connection_policy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; policy_current->set_policy_overrides (policy_list, - CORBA::SET_OVERRIDE, - ACE_TRY_ENV); + CORBA::SET_OVERRIDE + TAO_ENV_ARG_PARAMETER); // Make four invocations on test objects again. This time, // since RTCORBA::PrivateConnectionPolicy is set, we expect a @@ -143,28 +143,28 @@ main (int argc, char *argv[]) // third, and <server2>'s reused on fourth. ACE_DEBUG ((LM_DEBUG, "\n Invocation 5 --> new connection\n")); - server1->test_method (ACE_TRY_ENV); + server1->test_method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "\n Invocation 6 --> new connection\n")); - server2->test_method (ACE_TRY_ENV); + server2->test_method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "\n Invocation 7 --> use connection from invocation 5\n")); - server1->test_method (ACE_TRY_ENV); + server1->test_method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "\n Invocation 8 --> use connection from invocation 6\n")); - server2->test_method (ACE_TRY_ENV); + server2->test_method (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Testing over. Shut down Server ORB. ACE_DEBUG ((LM_DEBUG, "\n Testing over - shutting down\n")); - server1->shutdown (ACE_TRY_ENV); + server1->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/RTCORBA/Private_Connection/server.cpp b/TAO/tests/RTCORBA/Private_Connection/server.cpp index 729bfcf46c4..7b8d15d709b 100644 --- a/TAO/tests/RTCORBA/Private_Connection/server.cpp +++ b/TAO/tests/RTCORBA/Private_Connection/server.cpp @@ -15,10 +15,10 @@ public: // ctor // = The Test methods. - void test_method (CORBA::Environment&) + void test_method (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: @@ -32,7 +32,7 @@ Test_i::Test_i (CORBA::ORB_ptr orb) } void -Test_i::test_method (CORBA::Environment &/* ACE_TRY_ENV */) +Test_i::test_method (TAO_ENV_SINGLE_ARG_DECL_NOT_USED/* TAO_ENV_SINGLE_ARG_PARAMETER */) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -40,10 +40,10 @@ Test_i::test_method (CORBA::Environment &/* ACE_TRY_ENV */) } void -Test_i::shutdown (CORBA::Environment& ACE_TRY_ENV) +Test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } //************************************************************************* @@ -99,23 +99,23 @@ int create_object (PortableServer::POA_ptr poa, CORBA::ORB_ptr orb, Test_i *server_impl, - const char *filename, - CORBA::Environment &ACE_TRY_ENV) + const char *filename + TAO_ENV_ARG_DECL) { // Register with poa. PortableServer::ObjectId_var id = - poa->activate_object (server_impl, ACE_TRY_ENV); + poa->activate_object (server_impl TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::Object_var server = - poa->id_to_reference (id.in (), - ACE_TRY_ENV); + poa->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Print out the IOR. CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, "<%s>\n\n", ior.in ())); @@ -143,7 +143,7 @@ main (int argc, char *argv[]) { // ORB. CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Parse arguments. @@ -152,17 +152,17 @@ main (int argc, char *argv[]) // RootPOA. CORBA::Object_var object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (root_poa.in (), "RootPOA") == -1) return 1; // POAManager. PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Servants. @@ -174,8 +174,8 @@ main (int argc, char *argv[]) result = create_object (root_poa.in (), orb.in (), &server_impl1, - ior_output_file1, - ACE_TRY_ENV); + ior_output_file1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result == -1) return 1; @@ -183,17 +183,17 @@ main (int argc, char *argv[]) result = create_object (root_poa.in (), orb.in (), &server_impl2, - ior_output_file2, - ACE_TRY_ENV); + ior_output_file2 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result == -1) return 1; // Run ORB Event loop. - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Server ORB event loop finished\n")); diff --git a/TAO/tests/RTCORBA/RTMutex/server.cpp b/TAO/tests/RTCORBA/RTMutex/server.cpp index d60948d5a8d..b5db53f4614 100644 --- a/TAO/tests/RTCORBA/RTMutex/server.cpp +++ b/TAO/tests/RTCORBA/RTMutex/server.cpp @@ -66,22 +66,22 @@ test_mutex_simple (RTCORBA::RTORB_ptr rt_orb) { RTCORBA::Mutex_var my_mutex; - my_mutex = rt_orb->create_mutex (ACE_TRY_ENV); + my_mutex = rt_orb->create_mutex (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - my_mutex->lock (ACE_TRY_ENV); + my_mutex->lock (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - my_mutex->unlock (ACE_TRY_ENV); + my_mutex->unlock (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - my_mutex->lock (ACE_TRY_ENV); + my_mutex->lock (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - my_mutex->unlock (ACE_TRY_ENV); + my_mutex->unlock (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - rt_orb->destroy_mutex (my_mutex.in (), ACE_TRY_ENV); + rt_orb->destroy_mutex (my_mutex.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -109,7 +109,7 @@ test_named_mutex_simple (RTCORBA::RTORB_ptr rt_orb) CORBA::Boolean created_flag; larry_mutex1 = rt_orb->create_named_mutex ("larry", - created_flag, ACE_TRY_ENV); + created_flag TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (created_flag != 1) @@ -118,8 +118,8 @@ test_named_mutex_simple (RTCORBA::RTORB_ptr rt_orb) 1); moe_mutex1 = rt_orb->create_named_mutex ("moe", - created_flag, - ACE_TRY_ENV); + created_flag + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (created_flag != 1) @@ -127,18 +127,18 @@ test_named_mutex_simple (RTCORBA::RTORB_ptr rt_orb) "ERROR: Expected named mutex moe to be created, but it wasn't\n"), 1); - larry_mutex1->lock (ACE_TRY_ENV); + larry_mutex1->lock (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - larry_mutex1->unlock (ACE_TRY_ENV); + larry_mutex1->unlock (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Test creating the mutex a second time { RTCORBA::Mutex_var larry_mutex2; larry_mutex2 = rt_orb->create_named_mutex ("larry", - created_flag, - ACE_TRY_ENV); + created_flag + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (created_flag != 0) @@ -153,18 +153,18 @@ test_named_mutex_simple (RTCORBA::RTORB_ptr rt_orb) "ERROR: Should have gotten the same mutex, but didn't\n"), 1); - larry_mutex2->lock (ACE_TRY_ENV); + larry_mutex2->lock (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - larry_mutex2->unlock (ACE_TRY_ENV); + larry_mutex2->unlock (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } // test opening the mutex { RTCORBA::Mutex_var larry_mutex3; - larry_mutex3 = rt_orb->open_named_mutex ("larry", - ACE_TRY_ENV); + larry_mutex3 = rt_orb->open_named_mutex ("larry" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // test the pointers... @@ -174,24 +174,24 @@ test_named_mutex_simple (RTCORBA::RTORB_ptr rt_orb) "ERROR: Should have gotten the same mutex, but didn't\n"), 1); - larry_mutex3->lock (ACE_TRY_ENV); + larry_mutex3->lock (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - larry_mutex3->unlock (ACE_TRY_ENV); + larry_mutex3->unlock (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } // Make sure that nothing has been broken behind the scenes. - larry_mutex1->lock (ACE_TRY_ENV); + larry_mutex1->lock (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - larry_mutex1->unlock (ACE_TRY_ENV); + larry_mutex1->unlock (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - rt_orb->destroy_mutex (larry_mutex1.in (), ACE_TRY_ENV); + rt_orb->destroy_mutex (larry_mutex1.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - rt_orb->destroy_mutex (moe_mutex1.in (), ACE_TRY_ENV); + rt_orb->destroy_mutex (moe_mutex1.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -216,7 +216,7 @@ test_named_mutex_exception (RTCORBA::RTORB_ptr rt_orb) { RTCORBA::Mutex_var larry_mutex1; - larry_mutex1 = rt_orb->open_named_mutex ("larry", ACE_TRY_ENV); + larry_mutex1 = rt_orb->open_named_mutex ("larry" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_ERROR_RETURN ((LM_ERROR, @@ -340,7 +340,7 @@ test_mutex_threads (RTCORBA::RTORB_ptr rt_orb) ACE_TRY_NEW_ENV { - RTCORBA::Mutex_ptr mutex = rt_orb->create_mutex (ACE_TRY_ENV); + RTCORBA::Mutex_ptr mutex = rt_orb->create_mutex (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; test_data.mutex = mutex; @@ -385,7 +385,7 @@ mutex_test_try_lock_thread (void *args) { // check that try_lock (0) returns false ACE_DEBUG ((LM_DEBUG,"attempting try_lock (0) - expect failure (but no exceptions) \n")); - result = mutex->try_lock (0u, ACE_TRY_ENV); + result = mutex->try_lock (0u TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result) @@ -405,7 +405,7 @@ mutex_test_try_lock_thread (void *args) "attempting try_lock (5 sec) - expect failure after 5 secs (but no exceptions)\n")); timer.start (); - result = mutex->try_lock (50000000u /*5sec*/,ACE_TRY_ENV); + result = mutex->try_lock (50000000u /*5sec*/ TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; timer.stop (); @@ -456,12 +456,12 @@ test_mutex_try_lock (RTCORBA::RTORB_ptr rt_orb) ACE_TRY_NEW_ENV { - RTCORBA::Mutex_ptr mutex = rt_orb->create_mutex (ACE_TRY_ENV); + RTCORBA::Mutex_ptr mutex = rt_orb->create_mutex (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Test out try_lock and keep the lock so that the spawned task // can test out try_lock failure cases - result = mutex->try_lock (0u, ACE_TRY_ENV); + result = mutex->try_lock (0u TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (!result) ACE_ERROR_RETURN ((LM_ERROR, @@ -506,7 +506,7 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { // ORB. - CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Parse arguments. @@ -515,10 +515,10 @@ main (int argc, char *argv[]) // RTORB. CORBA::Object_var object = - orb->resolve_initial_references ("RTORB", ACE_TRY_ENV); + orb->resolve_initial_references ("RTORB" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (rt_orb.in (), "RTORB") == -1) return 1; diff --git a/TAO/tests/RTCORBA/Server_Declared/client.cpp b/TAO/tests/RTCORBA/Server_Declared/client.cpp index 2cb28785ec2..fdb42ab30ed 100644 --- a/TAO/tests/RTCORBA/Server_Declared/client.cpp +++ b/TAO/tests/RTCORBA/Server_Declared/client.cpp @@ -50,23 +50,23 @@ check_for_nil (CORBA::Object_ptr obj, const char *msg) } CORBA::Short -check_policy (Test_ptr server, - CORBA::Environment &ACE_TRY_ENV) +check_policy (Test_ptr server + TAO_ENV_ARG_DECL) { CORBA::Policy_var policy = - server->_get_policy (RTCORBA::PRIORITY_MODEL_POLICY_TYPE, - ACE_TRY_ENV); + server->_get_policy (RTCORBA::PRIORITY_MODEL_POLICY_TYPE + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); RTCORBA::PriorityModelPolicy_var priority_policy = - RTCORBA::PriorityModelPolicy::_narrow (policy.in (), ACE_TRY_ENV); + RTCORBA::PriorityModelPolicy::_narrow (policy.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (check_for_nil (priority_policy.in (), "PriorityModelPolicy") == -1) return -1; RTCORBA::PriorityModel priority_model = - priority_policy->priority_model (ACE_TRY_ENV); + priority_policy->priority_model (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (priority_model != RTCORBA::SERVER_DECLARED) ACE_ERROR_RETURN ((LM_ERROR, @@ -74,7 +74,7 @@ check_policy (Test_ptr server, "RTCORBA::SERVER_DECLARED!\n"), -1); - return priority_policy->server_priority (ACE_TRY_ENV); + return priority_policy->server_priority (TAO_ENV_SINGLE_ARG_PARAMETER); } int @@ -90,7 +90,7 @@ main (int argc, char *argv[]) // ORB. CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Parse arguments. @@ -99,19 +99,19 @@ main (int argc, char *argv[]) // Test object 1. CORBA::Object_var object = - orb->string_to_object (ior1, ACE_TRY_ENV); + orb->string_to_object (ior1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - Test_var server1 = Test::_narrow (object.in (), ACE_TRY_ENV); + Test_var server1 = Test::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (server1.in (), "server1") == -1) return 1; // Test object 2. - object = orb->string_to_object (ior2, ACE_TRY_ENV); + object = orb->string_to_object (ior2 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - Test_var server2 = Test::_narrow (object.in (), ACE_TRY_ENV); + Test_var server2 = Test::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (server2.in (), "server2") == -1) return 1; @@ -121,7 +121,7 @@ main (int argc, char *argv[]) // Test object 1. CORBA::Short server1_priority = - check_policy (server1.in (), ACE_TRY_ENV); + check_policy (server1.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (server1_priority == -1) @@ -129,7 +129,7 @@ main (int argc, char *argv[]) // Test object 2. CORBA::Short server2_priority = - check_policy (server2.in (), ACE_TRY_ENV); + check_policy (server2.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (server2_priority == -1) return 1; @@ -137,16 +137,16 @@ main (int argc, char *argv[]) // Testing: make several invocations on test objects. for (int i = 0; i < 5; ++i) { - server1->test_method (server1_priority, ACE_TRY_ENV); + server1->test_method (server1_priority TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - server2->test_method (server2_priority, ACE_TRY_ENV); + server2->test_method (server2_priority TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } // Testing over. Shut down Server ORB. - server1->shutdown (ACE_TRY_ENV); + server1->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } diff --git a/TAO/tests/RTCORBA/Server_Declared/server.cpp b/TAO/tests/RTCORBA/Server_Declared/server.cpp index b214fe6b6ee..20fc89252ac 100644 --- a/TAO/tests/RTCORBA/Server_Declared/server.cpp +++ b/TAO/tests/RTCORBA/Server_Declared/server.cpp @@ -15,11 +15,11 @@ public: Test_i (CORBA::ORB_ptr orb); // ctor - void test_method (CORBA::Short priority, - CORBA::Environment&) + void test_method (CORBA::Short priority + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: @@ -33,26 +33,26 @@ Test_i::Test_i (CORBA::ORB_ptr orb) } void -Test_i::test_method (CORBA::Short priority, - CORBA::Environment& ACE_TRY_ENV) +Test_i::test_method (CORBA::Short priority + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { // Use RTCurrent to find out the CORBA priority of the current // thread. CORBA::Object_var obj = - this->orb_->resolve_initial_references ("RTCurrent", ACE_TRY_ENV); + this->orb_->resolve_initial_references ("RTCurrent" TAO_ENV_ARG_PARAMETER); ACE_CHECK; RTCORBA::Current_var current = - RTCORBA::Current::_narrow (obj.in (), ACE_TRY_ENV); + RTCORBA::Current::_narrow (obj.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (CORBA::is_nil (obj.in ())) ACE_THROW (CORBA::INTERNAL ()); CORBA::Short servant_thread_priority = - current->the_priority (ACE_TRY_ENV); + current->the_priority (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; // Print out the info. @@ -68,10 +68,10 @@ Test_i::test_method (CORBA::Short priority, } void -Test_i::shutdown (CORBA::Environment& ACE_TRY_ENV) +Test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } //************************************************************************* @@ -159,29 +159,29 @@ create_object (RTPortableServer::POA_ptr poa, CORBA::ORB_ptr orb, Test_i *server_impl, CORBA::Short priority, - const char *filename, - CORBA::Environment &ACE_TRY_ENV) + const char *filename + TAO_ENV_ARG_DECL) { // Register with poa. PortableServer::ObjectId_var id; if (priority > -1) id = poa->activate_object_with_priority (server_impl, - priority, - ACE_TRY_ENV); + priority + TAO_ENV_ARG_PARAMETER); else - id = poa->activate_object (server_impl, ACE_TRY_ENV); + id = poa->activate_object (server_impl TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::Object_var server = - poa->id_to_reference (id.in (), - ACE_TRY_ENV); + poa->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Print out the IOR. CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, "<%s>\n\n", ior.in ())); @@ -213,7 +213,7 @@ main (int argc, char *argv[]) { // ORB. CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Parse arguments. @@ -222,27 +222,27 @@ main (int argc, char *argv[]) // RTORB. CORBA::Object_var object = - orb->resolve_initial_references ("RTORB", ACE_TRY_ENV); + orb->resolve_initial_references ("RTORB" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (rt_orb.in (), "RTORB") == -1) return 1; // RootPOA. object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (root_poa.in (), "RootPOA") == -1) return 1; // POAManager. PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Create child POA with SERVER_DECLARED PriorityModelPolicy, @@ -252,24 +252,24 @@ main (int argc, char *argv[]) poa_policy_list.length (2); poa_policy_list[0] = rt_orb->create_priority_model_policy (RTCORBA::SERVER_DECLARED, - poa_priority, - ACE_TRY_ENV); + poa_priority + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; poa_policy_list[1] = - root_poa->create_id_uniqueness_policy (PortableServer::MULTIPLE_ID, - ACE_TRY_ENV); + root_poa->create_id_uniqueness_policy (PortableServer::MULTIPLE_ID + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var child_poa = root_poa->create_POA ("Child_POA", poa_manager.in (), - poa_policy_list, - ACE_TRY_ENV); + poa_policy_list + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTPortableServer::POA_var rt_poa = - RTPortableServer::POA::_narrow (child_poa.in (), ACE_TRY_ENV); + RTPortableServer::POA::_narrow (child_poa.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (check_for_nil (rt_poa.in (), "RTPOA") == -1) return 1; @@ -282,7 +282,7 @@ main (int argc, char *argv[]) int result; ACE_DEBUG ((LM_DEBUG, "\nActivated object one as ")); result = create_object (rt_poa.in (), orb.in (), &server_impl, - -1, ior_output_file1, ACE_TRY_ENV); + -1, ior_output_file1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result == -1) return 1; @@ -290,17 +290,17 @@ main (int argc, char *argv[]) // Create object 2 (override POA's priority). ACE_DEBUG ((LM_DEBUG, "\nActivated object two as ")); result = create_object (rt_poa.in (), orb.in (), &server_impl, - object_priority, ior_output_file2, ACE_TRY_ENV); + object_priority, ior_output_file2 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result == -1) return 1; // Activate POA manager. - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Start ORB event loop. - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Server ORB event loop finished\n\n")); diff --git a/TAO/tests/RTCORBA/Server_Protocol/client.cpp b/TAO/tests/RTCORBA/Server_Protocol/client.cpp index 78bc5b69407..dfd281c6433 100644 --- a/TAO/tests/RTCORBA/Server_Protocol/client.cpp +++ b/TAO/tests/RTCORBA/Server_Protocol/client.cpp @@ -39,18 +39,18 @@ main (int argc, char *argv[]) { // Initialize and obtain reference to the Test object. CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test_var server = - Test::_narrow (object.in (), ACE_TRY_ENV); + Test::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -62,13 +62,13 @@ main (int argc, char *argv[]) } // Make an invocation on the obtained Test object. - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY { ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Catched exception:"); + "Caught exception:"); return 1; } ACE_ENDTRY; diff --git a/TAO/tests/RTCORBA/Server_Protocol/server.cpp b/TAO/tests/RTCORBA/Server_Protocol/server.cpp index cd3802e1386..7601a327a51 100644 --- a/TAO/tests/RTCORBA/Server_Protocol/server.cpp +++ b/TAO/tests/RTCORBA/Server_Protocol/server.cpp @@ -16,7 +16,7 @@ public: Test_i (CORBA::ORB_ptr orb); // ctor - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: @@ -30,12 +30,12 @@ Test_i::Test_i (CORBA::ORB_ptr orb) } void -Test_i::shutdown (CORBA::Environment& ACE_TRY_ENV) +Test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "Received request to shut down the ORB\n")); - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } //************************************************************************* @@ -84,8 +84,8 @@ parse_args (int argc, char *argv[]) } int -check_default_server_protocol (CORBA::ORB_ptr orb, - CORBA::Environment &ACE_TRY_ENV) +check_default_server_protocol (CORBA::ORB_ptr orb + TAO_ENV_ARG_DECL) { // Users should never write code like below. // It is for testing purposes only! (Unfortunately, there @@ -94,8 +94,8 @@ check_default_server_protocol (CORBA::ORB_ptr orb, orb->orb_core ()->get_default_policies ()->get_policy (RTCORBA::SERVER_PROTOCOL_POLICY_TYPE); RTCORBA::ServerProtocolPolicy_var policy = - RTCORBA::ServerProtocolPolicy::_narrow (server_protocol.in (), - ACE_TRY_ENV); + RTCORBA::ServerProtocolPolicy::_narrow (server_protocol.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (CORBA::is_nil (policy.in ())) @@ -104,7 +104,7 @@ check_default_server_protocol (CORBA::ORB_ptr orb, "is missing\n"), -1); - RTCORBA::ProtocolList_var protocols = policy->protocols (ACE_TRY_ENV); + RTCORBA::ProtocolList_var protocols = policy->protocols (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, @@ -125,8 +125,8 @@ check_default_server_protocol (CORBA::ORB_ptr orb, { RTCORBA::TCPProtocolProperties_var tcp_properties = RTCORBA::TCPProtocolProperties::_narrow (properties.in - (), - ACE_TRY_ENV); + () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (!CORBA::is_nil (tcp_properties.in ())) @@ -143,8 +143,8 @@ check_default_server_protocol (CORBA::ORB_ptr orb, { RTCORBA::UnixDomainProtocolProperties_var uiop_properties = RTCORBA::UnixDomainProtocolProperties::_narrow (properties.in - (), - ACE_TRY_ENV); + () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); @@ -169,18 +169,18 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (root_poa.in ())) @@ -189,18 +189,18 @@ main (int argc, char *argv[]) -1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - object = orb->resolve_initial_references ("RTORB", ACE_TRY_ENV); + object = orb->resolve_initial_references ("RTORB" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Check ORB default ServerProtocol configuration. - int result = check_default_server_protocol (orb.in (), - ACE_TRY_ENV); + int result = check_default_server_protocol (orb.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result != 0) return 1; @@ -221,8 +221,8 @@ main (int argc, char *argv[]) CORBA::PolicyList poa_policy_list; poa_policy_list.length (1); poa_policy_list[0] = - rt_orb->create_server_protocol_policy (protocols, - ACE_TRY_ENV); + rt_orb->create_server_protocol_policy (protocols + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var poa; @@ -232,8 +232,8 @@ main (int argc, char *argv[]) poa = root_poa->create_POA ("Child_POA", poa_manager.in (), - poa_policy_list, - ACE_TRY_ENV); + poa_policy_list + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -246,17 +246,17 @@ main (int argc, char *argv[]) Test_i server_impl (orb.in ()); PortableServer::ObjectId_var id = - poa->activate_object (&server_impl, ACE_TRY_ENV); + poa->activate_object (&server_impl TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var server = - poa->id_to_reference (id.in (), - ACE_TRY_ENV); + poa->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Print Object IOR. CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "\nActivated as <%s>\n\n", ior.in ())); @@ -274,10 +274,10 @@ main (int argc, char *argv[]) } // Run ORB Event loop. - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Server ORB event loop finished\n\n")); diff --git a/TAO/tests/RTCORBA/Thread_Pool/client.cpp b/TAO/tests/RTCORBA/Thread_Pool/client.cpp index 9921524a61a..0bc45408f53 100644 --- a/TAO/tests/RTCORBA/Thread_Pool/client.cpp +++ b/TAO/tests/RTCORBA/Thread_Pool/client.cpp @@ -58,7 +58,7 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; int result = @@ -67,11 +67,11 @@ main (int argc, char *argv[]) return result; CORBA::Object_var object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; test_var test = - test::_narrow (object.in (), ACE_TRY_ENV); + test::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; pid_t pid = @@ -81,8 +81,8 @@ main (int argc, char *argv[]) { CORBA::Long r = test->method (pid, - i, - ACE_TRY_ENV); + i + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_ASSERT (r == i); @@ -92,7 +92,7 @@ main (int argc, char *argv[]) if (shutdown_server) { - test->shutdown (ACE_TRY_ENV); + test->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/tests/RTCORBA/Thread_Pool/server.cpp b/TAO/tests/RTCORBA/Thread_Pool/server.cpp index 0d50b2c58b7..20645be64e4 100644 --- a/TAO/tests/RTCORBA/Thread_Pool/server.cpp +++ b/TAO/tests/RTCORBA/Thread_Pool/server.cpp @@ -57,12 +57,12 @@ parse_args (int argc, char *argv[]) int write_ior_to_file (CORBA::ORB_ptr orb, - test_ptr test, - CORBA_Environment &ACE_TRY_ENV) + test_ptr test + TAO_ENV_ARG_DECL) { CORBA::String_var ior = - orb->object_to_string (test, - ACE_TRY_ENV); + orb->object_to_string (test + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); char filename[BUFSIZ]; @@ -96,8 +96,8 @@ create_POA_and_register_servant (CORBA::Policy_ptr threadpool_policy, PortableServer::POAManager_ptr poa_manager, PortableServer::POA_ptr root_poa, CORBA::ORB_ptr orb, - RTCORBA::RTORB_ptr rt_orb, - CORBA_Environment &ACE_TRY_ENV) + RTCORBA::RTORB_ptr rt_orb + TAO_ENV_ARG_DECL) { // Policies for the firstPOA to be created. CORBA::PolicyList policies (3); policies.length (3); @@ -105,8 +105,8 @@ create_POA_and_register_servant (CORBA::Policy_ptr threadpool_policy, // Implicit_activation policy. policies[0] = root_poa->create_implicit_activation_policy - (PortableServer::IMPLICIT_ACTIVATION, - ACE_TRY_ENV); + (PortableServer::IMPLICIT_ACTIVATION + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Thread pool policy. @@ -116,16 +116,16 @@ create_POA_and_register_servant (CORBA::Policy_ptr threadpool_policy, // Priority Model policy. policies[2] = rt_orb->create_priority_model_policy (RTCORBA::CLIENT_PROPAGATED, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Create the POA under the RootPOA. PortableServer::POA_var poa = root_poa->create_POA (poa_name, poa_manager, - policies, - ACE_TRY_ENV); + policies + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Creation of POAs is over. Destroy the Policy objects. @@ -133,7 +133,7 @@ create_POA_and_register_servant (CORBA::Policy_ptr threadpool_policy, i < policies.length (); ++i) { - policies[i]->destroy (ACE_TRY_ENV); + policies[i]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); } @@ -146,13 +146,13 @@ create_POA_and_register_servant (CORBA::Policy_ptr threadpool_policy, ACE_UNUSED_ARG (safe_servant); test_var test = - servant->_this (ACE_TRY_ENV); + servant->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); int result = write_ior_to_file (orb, - test.in (), - ACE_TRY_ENV); + test.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); return result; @@ -170,46 +170,46 @@ main (int argc, char *argv[]) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "", - ACE_TRY_ENV); + "" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var object = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (object.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; object = - orb->resolve_initial_references ("RTORB", - ACE_TRY_ENV); + orb->resolve_initial_references ("RTORB" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::RTORB_var rt_orb = - RTCORBA::RTORB::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::RTORB::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; object = - orb->resolve_initial_references ("RTCurrent", - ACE_TRY_ENV); + orb->resolve_initial_references ("RTCurrent" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::Current_var current = - RTCORBA::Current::_narrow (object.in (), - ACE_TRY_ENV); + RTCORBA::Current::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::Priority default_thread_priority = - current->the_priority (ACE_TRY_ENV); + current->the_priority (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; int result = @@ -221,19 +221,19 @@ main (int argc, char *argv[]) root_poa.in (), nap_time); test_var test = - servant._this (ACE_TRY_ENV); + servant._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; result = write_ior_to_file (orb.in (), - test.in (), - ACE_TRY_ENV); + test.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result != 0) return result; - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::ULong stacksize = 0; @@ -248,13 +248,13 @@ main (int argc, char *argv[]) default_thread_priority, allow_request_buffering, max_buffered_requests, - max_request_buffer_size, - ACE_TRY_ENV); + max_request_buffer_size + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Policy_var threadpool_policy_1 = - rt_orb->create_threadpool_policy (threadpool_id_1, - ACE_TRY_ENV); + rt_orb->create_threadpool_policy (threadpool_id_1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Boolean allow_borrowing = 0; @@ -275,13 +275,13 @@ main (int argc, char *argv[]) allow_borrowing, allow_request_buffering, max_buffered_requests, - max_request_buffer_size, - ACE_TRY_ENV); + max_request_buffer_size + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Policy_var threadpool_policy_2 = - rt_orb->create_threadpool_policy (threadpool_id_2, - ACE_TRY_ENV); + rt_orb->create_threadpool_policy (threadpool_id_2 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; result = @@ -290,8 +290,8 @@ main (int argc, char *argv[]) poa_manager.in (), root_poa.in (), orb.in (), - rt_orb.in (), - ACE_TRY_ENV); + rt_orb.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result != 0) return result; @@ -302,16 +302,16 @@ main (int argc, char *argv[]) poa_manager.in (), root_poa.in (), orb.in (), - rt_orb.in (), - ACE_TRY_ENV); + rt_orb.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result != 0) return result; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/RTCORBA/Thread_Pool/test_i.cpp b/TAO/tests/RTCORBA/Thread_Pool/test_i.cpp index 0597652d87d..03c8b5b52b4 100644 --- a/TAO/tests/RTCORBA/Thread_Pool/test_i.cpp +++ b/TAO/tests/RTCORBA/Thread_Pool/test_i.cpp @@ -18,8 +18,8 @@ test_i::test_i (CORBA::ORB_ptr orb, CORBA::Long test_i::method (CORBA::Long client_id, - CORBA::Long iteration, - CORBA::Environment &) + CORBA::Long iteration + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { // Get the ORB_Core's TSS resources. @@ -49,16 +49,16 @@ test_i::method (CORBA::Long client_id, } PortableServer::POA_ptr -test_i::_default_POA (CORBA_Environment &) +test_i::_default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) { return PortableServer::POA::_duplicate (this->poa_.in ()); } void -test_i::shutdown (CORBA::Environment& ACE_TRY_ENV) +test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, - ACE_TRY_ENV); + this->orb_->shutdown (0 + TAO_ENV_ARG_PARAMETER); ACE_CHECK; } diff --git a/TAO/tests/RTCORBA/Thread_Pool/test_i.h b/TAO/tests/RTCORBA/Thread_Pool/test_i.h index c5d058eb758..5fed9fa6379 100644 --- a/TAO/tests/RTCORBA/Thread_Pool/test_i.h +++ b/TAO/tests/RTCORBA/Thread_Pool/test_i.h @@ -22,16 +22,16 @@ public: /// Test method. CORBA::Long method (CORBA::Long client_id, - CORBA::Long iteration, - CORBA::Environment &) + CORBA::Long iteration + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); /// Shutdown the server. - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); /// Our POA. - PortableServer::POA_ptr _default_POA (CORBA_Environment &ACE_TRY_ENV); + PortableServer::POA_ptr _default_POA (TAO_ENV_SINGLE_ARG_DECL); private: /// ORB. diff --git a/TAO/tests/Reliable_Oneways/Oneway_Receiver.cpp b/TAO/tests/Reliable_Oneways/Oneway_Receiver.cpp index d737813d0a6..0de4f50137e 100644 --- a/TAO/tests/Reliable_Oneways/Oneway_Receiver.cpp +++ b/TAO/tests/Reliable_Oneways/Oneway_Receiver.cpp @@ -12,29 +12,29 @@ Oneway_Receiver::Oneway_Receiver (CORBA::ORB_ptr orb) } void -Oneway_Receiver::raise_no_permission (CORBA::Environment &ACE_TRY_ENV) +Oneway_Receiver::raise_no_permission (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_THROW (CORBA::NO_PERMISSION ()); } void -Oneway_Receiver::destroy (CORBA::Environment &ACE_TRY_ENV) +Oneway_Receiver::destroy (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - PortableServer::POA_var poa = this->_default_POA (ACE_TRY_ENV); + PortableServer::POA_var poa = this->_default_POA (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; PortableServer::ObjectId_var id = - poa->servant_to_id (this, ACE_TRY_ENV); + poa->servant_to_id (this TAO_ENV_ARG_PARAMETER); ACE_CHECK; - poa->deactivate_object (id.in (), ACE_TRY_ENV); + poa->deactivate_object (id.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK; } Test::Shutdown_Helper_ptr -Oneway_Receiver::get_shutdown_helper (CORBA::Environment &ACE_TRY_ENV) +Oneway_Receiver::get_shutdown_helper (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { Shutdown_Helper *shutdown_helper; @@ -45,5 +45,5 @@ Oneway_Receiver::get_shutdown_helper (CORBA::Environment &ACE_TRY_ENV) PortableServer::ServantBase_var transfer_ownership(shutdown_helper); - return shutdown_helper->_this (ACE_TRY_ENV); + return shutdown_helper->_this (TAO_ENV_SINGLE_ARG_PARAMETER); } diff --git a/TAO/tests/Reliable_Oneways/Oneway_Receiver.h b/TAO/tests/Reliable_Oneways/Oneway_Receiver.h index 5aa895838e3..0dba48dc0e8 100644 --- a/TAO/tests/Reliable_Oneways/Oneway_Receiver.h +++ b/TAO/tests/Reliable_Oneways/Oneway_Receiver.h @@ -25,13 +25,13 @@ public: Oneway_Receiver (CORBA::ORB_ptr orb); // = The skeleton methods - virtual void raise_no_permission (CORBA::Environment &ACE_TRY_ENV) + virtual void raise_no_permission (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void destroy (CORBA::Environment &ACE_TRY_ENV) + virtual void destroy (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual Test::Shutdown_Helper_ptr get_shutdown_helper (CORBA::Environment &ACE_TRY_ENV) + virtual Test::Shutdown_Helper_ptr get_shutdown_helper (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Reliable_Oneways/Shutdown_Helper.cpp b/TAO/tests/Reliable_Oneways/Shutdown_Helper.cpp index 733c7107c99..8c5e8b0781e 100644 --- a/TAO/tests/Reliable_Oneways/Shutdown_Helper.cpp +++ b/TAO/tests/Reliable_Oneways/Shutdown_Helper.cpp @@ -11,8 +11,8 @@ Shutdown_Helper::Shutdown_Helper (CORBA::ORB_ptr orb) } void -Shutdown_Helper::shutdown (CORBA::Environment &ACE_TRY_ENV) +Shutdown_Helper::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/Reliable_Oneways/Shutdown_Helper.h b/TAO/tests/Reliable_Oneways/Shutdown_Helper.h index 4de5df9dbf8..09ee8bba3fa 100644 --- a/TAO/tests/Reliable_Oneways/Shutdown_Helper.h +++ b/TAO/tests/Reliable_Oneways/Shutdown_Helper.h @@ -25,7 +25,7 @@ public: Shutdown_Helper (CORBA::ORB_ptr orb); // = The skeleton methods - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Reliable_Oneways/client.cpp b/TAO/tests/Reliable_Oneways/client.cpp index a33b230801b..ea3ca82198a 100644 --- a/TAO/tests/Reliable_Oneways/client.cpp +++ b/TAO/tests/Reliable_Oneways/client.cpp @@ -31,12 +31,12 @@ parse_args (int argc, char *argv[]) switch (c) { case 'k': - ior = get_opts.optarg; - break; + ior = get_opts.optarg; + break; case 'i': - iterations = ACE_OS::atoi (get_opts.optarg); - break; + iterations = ACE_OS::atoi (get_opts.optarg); + break; case 'n': test_sync_none = 1; @@ -58,7 +58,7 @@ parse_args (int argc, char *argv[]) default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-k <ior> " + "-k <ior> " "-n -t -s -r " "\n", argv [0]), @@ -68,14 +68,14 @@ parse_args (int argc, char *argv[]) return 0; } -void run_test_sync_with_target (Test::Oneway_Receiver_ptr oneway_receiver, - CORBA::Environment &ACE_TRY_ENV); -void run_test_sync_with_server (Test::Oneway_Receiver_ptr oneway_receiver, - CORBA::Environment &ACE_TRY_ENV); -void run_test_sync_with_transport (Test::Oneway_Receiver_ptr oneway_receiver, - CORBA::Environment &ACE_TRY_ENV); -void run_test_sync_none (Test::Oneway_Receiver_ptr oneway_receiver, - CORBA::Environment &ACE_TRY_ENV); +void run_test_sync_with_target (Test::Oneway_Receiver_ptr oneway_receiver + TAO_ENV_ARG_DECL); +void run_test_sync_with_server (Test::Oneway_Receiver_ptr oneway_receiver + TAO_ENV_ARG_DECL); +void run_test_sync_with_transport (Test::Oneway_Receiver_ptr oneway_receiver + TAO_ENV_ARG_DECL); +void run_test_sync_none (Test::Oneway_Receiver_ptr oneway_receiver + TAO_ENV_ARG_DECL); int @@ -84,18 +84,18 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = - orb->string_to_object(ior, ACE_TRY_ENV); + orb->string_to_object(ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Oneway_Receiver_var oneway_receiver = - Test::Oneway_Receiver::_narrow(tmp.in (), ACE_TRY_ENV); + Test::Oneway_Receiver::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (oneway_receiver.in ())) @@ -109,29 +109,29 @@ main (int argc, char *argv[]) if (test_sync_with_target) { ACE_DEBUG ((LM_DEBUG, "Running SYNC_WITH_TARGET\n")); - run_test_sync_with_target (oneway_receiver.in (), - ACE_TRY_ENV); + run_test_sync_with_target (oneway_receiver.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } else if (test_sync_with_server) { ACE_DEBUG ((LM_DEBUG, "Running SYNC_WITH_SERVER\n")); - run_test_sync_with_server (oneway_receiver.in (), - ACE_TRY_ENV); + run_test_sync_with_server (oneway_receiver.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } else if (test_sync_with_transport) { ACE_DEBUG ((LM_DEBUG, "Running SYNC_WITH_TRANSPORT\n")); - run_test_sync_with_transport (oneway_receiver.in (), - ACE_TRY_ENV); + run_test_sync_with_transport (oneway_receiver.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } else { ACE_DEBUG ((LM_DEBUG, "Running SYNC_NONE\n")); - run_test_sync_none (oneway_receiver.in (), - ACE_TRY_ENV); + run_test_sync_none (oneway_receiver.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -147,7 +147,7 @@ main (int argc, char *argv[]) "ERROR: Mismatched number of calls (%d + %d != %d)\n", successful_calls, failed_calls, iterations)); - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -162,19 +162,19 @@ main (int argc, char *argv[]) } void -set_sync_scope_policy (Messaging::SyncScope sync_scope, - CORBA::Environment &ACE_TRY_ENV) +set_sync_scope_policy (Messaging::SyncScope sync_scope + TAO_ENV_ARG_DECL) { int argc = 0; - CORBA::ORB_var orb = CORBA::ORB_init (argc, 0, "", ACE_TRY_ENV); + CORBA::ORB_var orb = CORBA::ORB_init (argc, 0, "" TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::Object_var object = - orb->resolve_initial_references ("PolicyCurrent", ACE_TRY_ENV); + orb->resolve_initial_references ("PolicyCurrent" TAO_ENV_ARG_PARAMETER); ACE_CHECK; CORBA::PolicyCurrent_var policy_current = - CORBA::PolicyCurrent::_narrow (object.in (), ACE_TRY_ENV); + CORBA::PolicyCurrent::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (CORBA::is_nil (policy_current.in ())) @@ -188,23 +188,23 @@ set_sync_scope_policy (Messaging::SyncScope sync_scope, CORBA::PolicyList policies(1); policies.length (1); policies[0] = orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE, - scope_as_any, - ACE_TRY_ENV); + scope_as_any + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - policy_current->set_policy_overrides (policies, CORBA::ADD_OVERRIDE, - ACE_TRY_ENV); + policy_current->set_policy_overrides (policies, CORBA::ADD_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - policies[0]->destroy (ACE_TRY_ENV); + policies[0]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; } void run_one_iteration (int i, Test::Oneway_Receiver_ptr oneway_receiver, - Test::Shutdown_Helper_ptr shutdown_helper, - CORBA::Environment &ACE_TRY_ENV) + Test::Shutdown_Helper_ptr shutdown_helper + TAO_ENV_ARG_DECL) { ACE_TRY { @@ -212,14 +212,14 @@ run_one_iteration (int i, { ACE_DEBUG ((LM_DEBUG, "Destroying object\n")); server_status = DESTROYED; - oneway_receiver->destroy (ACE_TRY_ENV); + oneway_receiver->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } if (i == 2 * iterations / 3) { ACE_DEBUG ((LM_DEBUG, "Shutting down server process\n")); server_status = SHUTDOWN; - shutdown_helper->shutdown (ACE_TRY_ENV); + shutdown_helper->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } @@ -228,7 +228,7 @@ run_one_iteration (int i, } ACE_ENDTRY; - oneway_receiver->raise_no_permission (ACE_TRY_ENV); + oneway_receiver->raise_no_permission (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; } @@ -242,14 +242,14 @@ call_failed (const CORBA::SystemException &ex) } void -run_test_sync_with_target (Test::Oneway_Receiver_ptr oneway_receiver, - CORBA::Environment &ACE_TRY_ENV) +run_test_sync_with_target (Test::Oneway_Receiver_ptr oneway_receiver + TAO_ENV_ARG_DECL) { - set_sync_scope_policy (Messaging::SYNC_WITH_TARGET, ACE_TRY_ENV); + set_sync_scope_policy (Messaging::SYNC_WITH_TARGET TAO_ENV_ARG_PARAMETER); ACE_CHECK; Test::Shutdown_Helper_var shutdown_helper = - oneway_receiver->get_shutdown_helper (ACE_TRY_ENV); + oneway_receiver->get_shutdown_helper (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; int had_comm_failure = 0; @@ -257,8 +257,8 @@ run_test_sync_with_target (Test::Oneway_Receiver_ptr oneway_receiver, { ACE_TRY { - run_one_iteration (i, oneway_receiver, shutdown_helper.in (), - ACE_TRY_ENV); + run_one_iteration (i, oneway_receiver, shutdown_helper.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (CORBA::NO_PERMISSION, ex) @@ -299,14 +299,14 @@ run_test_sync_with_target (Test::Oneway_Receiver_ptr oneway_receiver, } void -run_test_sync_with_server (Test::Oneway_Receiver_ptr oneway_receiver, - CORBA::Environment &ACE_TRY_ENV) +run_test_sync_with_server (Test::Oneway_Receiver_ptr oneway_receiver + TAO_ENV_ARG_DECL) { - set_sync_scope_policy (Messaging::SYNC_WITH_SERVER, ACE_TRY_ENV); + set_sync_scope_policy (Messaging::SYNC_WITH_SERVER TAO_ENV_ARG_PARAMETER); ACE_CHECK; Test::Shutdown_Helper_var shutdown_helper = - oneway_receiver->get_shutdown_helper (ACE_TRY_ENV); + oneway_receiver->get_shutdown_helper (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; int had_comm_failure = 0; @@ -314,8 +314,8 @@ run_test_sync_with_server (Test::Oneway_Receiver_ptr oneway_receiver, { ACE_TRY { - run_one_iteration (i, oneway_receiver, shutdown_helper.in (), - ACE_TRY_ENV); + run_one_iteration (i, oneway_receiver, shutdown_helper.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (server_status == DESTROYED @@ -360,38 +360,38 @@ run_test_sync_with_server (Test::Oneway_Receiver_ptr oneway_receiver, /// Helper routine to run the sync_with_transport and sync_none tests. void -run_test_unreliable (Test::Oneway_Receiver_ptr oneway_receiver, - CORBA::Environment &ACE_TRY_ENV); +run_test_unreliable (Test::Oneway_Receiver_ptr oneway_receiver + TAO_ENV_ARG_DECL); void -run_test_sync_with_transport (Test::Oneway_Receiver_ptr oneway_receiver, - CORBA::Environment &ACE_TRY_ENV) +run_test_sync_with_transport (Test::Oneway_Receiver_ptr oneway_receiver + TAO_ENV_ARG_DECL) { - set_sync_scope_policy (Messaging::SYNC_WITH_TRANSPORT, ACE_TRY_ENV); + set_sync_scope_policy (Messaging::SYNC_WITH_TRANSPORT TAO_ENV_ARG_PARAMETER); ACE_CHECK; - run_test_unreliable (oneway_receiver, ACE_TRY_ENV); + run_test_unreliable (oneway_receiver TAO_ENV_ARG_PARAMETER); ACE_CHECK; } void -run_test_sync_none (Test::Oneway_Receiver_ptr oneway_receiver, - CORBA::Environment &ACE_TRY_ENV) +run_test_sync_none (Test::Oneway_Receiver_ptr oneway_receiver + TAO_ENV_ARG_DECL) { - set_sync_scope_policy (Messaging::SYNC_NONE, ACE_TRY_ENV); + set_sync_scope_policy (Messaging::SYNC_NONE TAO_ENV_ARG_PARAMETER); ACE_CHECK; - run_test_unreliable (oneway_receiver, ACE_TRY_ENV); + run_test_unreliable (oneway_receiver TAO_ENV_ARG_PARAMETER); ACE_CHECK; } void -run_test_unreliable (Test::Oneway_Receiver_ptr oneway_receiver, - CORBA::Environment &ACE_TRY_ENV) +run_test_unreliable (Test::Oneway_Receiver_ptr oneway_receiver + TAO_ENV_ARG_DECL) { Test::Shutdown_Helper_var shutdown_helper = - oneway_receiver->get_shutdown_helper (ACE_TRY_ENV); + oneway_receiver->get_shutdown_helper (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; int undetected = 0; @@ -400,8 +400,8 @@ run_test_unreliable (Test::Oneway_Receiver_ptr oneway_receiver, { ACE_TRY { - run_one_iteration (i, oneway_receiver, shutdown_helper.in (), - ACE_TRY_ENV); + run_one_iteration (i, oneway_receiver, shutdown_helper.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // A few failures can go undetected... diff --git a/TAO/tests/Reliable_Oneways/server.cpp b/TAO/tests/Reliable_Oneways/server.cpp index 0fcd864c9d7..2475bfc8d22 100644 --- a/TAO/tests/Reliable_Oneways/server.cpp +++ b/TAO/tests/Reliable_Oneways/server.cpp @@ -17,14 +17,14 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -39,15 +39,15 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (root_poa.in ())) @@ -56,7 +56,7 @@ main (int argc, char *argv[]) 1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -69,11 +69,11 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var owner_transfer(oneway_receiver_impl); Test::Oneway_Receiver_var oneway_receiver = - oneway_receiver_impl->_this (ACE_TRY_ENV); + oneway_receiver_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (oneway_receiver.in (), ACE_TRY_ENV); + orb->object_to_string (oneway_receiver.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -82,22 +82,22 @@ main (int argc, char *argv[]) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_output_file), - 1); + 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Server_Leaks/Ping_Service.cpp b/TAO/tests/Server_Leaks/Ping_Service.cpp index 084c3cb6415..ad640088619 100644 --- a/TAO/tests/Server_Leaks/Ping_Service.cpp +++ b/TAO/tests/Server_Leaks/Ping_Service.cpp @@ -11,14 +11,14 @@ Ping_Service::Ping_Service (CORBA::ORB_ptr orb) } void -Ping_Service::ping (CORBA::Environment &) +Ping_Service::ping (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { } void -Ping_Service::shutdown (CORBA::Environment &ACE_TRY_ENV) +Ping_Service::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/Server_Leaks/Ping_Service.h b/TAO/tests/Server_Leaks/Ping_Service.h index dfdb8d89e14..728a5e6def7 100644 --- a/TAO/tests/Server_Leaks/Ping_Service.h +++ b/TAO/tests/Server_Leaks/Ping_Service.h @@ -25,10 +25,10 @@ public: Ping_Service (CORBA::ORB_ptr orb); // = The skeleton methods - virtual void ping (CORBA::Environment &ACE_TRY_ENV) + virtual void ping (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Server_Leaks/client.cpp b/TAO/tests/Server_Leaks/client.cpp index 923e4a11f84..5505a41b60b 100644 --- a/TAO/tests/Server_Leaks/client.cpp +++ b/TAO/tests/Server_Leaks/client.cpp @@ -18,19 +18,19 @@ parse_args (int argc, char *argv[]) switch (c) { case 'k': - ior = get_opts.optarg; - break; + ior = get_opts.optarg; + break; case 'x': - do_shutdown = 1; - break; + do_shutdown = 1; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-k <ior> " - "-x " + "-k <ior> " + "-x " "\n", argv [0]), -1); @@ -45,18 +45,18 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = - orb->string_to_object(ior, ACE_TRY_ENV); + orb->string_to_object(ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Ping_Service_var ping_service = - Test::Ping_Service::_narrow(tmp.in (), ACE_TRY_ENV); + Test::Ping_Service::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (ping_service.in ())) @@ -69,17 +69,17 @@ main (int argc, char *argv[]) for (int i = 0; i != 10; ++i) { - ping_service->ping (ACE_TRY_ENV); + ping_service->ping (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } - + if (do_shutdown) { - ping_service->shutdown (ACE_TRY_ENV); + ping_service->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Server_Leaks/server.cpp b/TAO/tests/Server_Leaks/server.cpp index e681ec8564a..47e9986ae9c 100644 --- a/TAO/tests/Server_Leaks/server.cpp +++ b/TAO/tests/Server_Leaks/server.cpp @@ -17,13 +17,13 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -38,15 +38,15 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (root_poa.in ())) @@ -55,7 +55,7 @@ main (int argc, char *argv[]) 1); PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -68,11 +68,11 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var owner_transfer(ping_service_impl); Test::Ping_Service_var ping_service = - ping_service_impl->_this (ACE_TRY_ENV); + ping_service_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (ping_service.in (), ACE_TRY_ENV); + orb->object_to_string (ping_service.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -81,22 +81,22 @@ main (int argc, char *argv[]) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_output_file), - 1); + 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Single_Read/client.cpp b/TAO/tests/Single_Read/client.cpp index 4b424e7e13b..68a1e72872c 100644 --- a/TAO/tests/Single_Read/client.cpp +++ b/TAO/tests/Single_Read/client.cpp @@ -71,7 +71,7 @@ parse_args (int argc, char **argv) int main (int argc, char **argv) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { @@ -79,8 +79,8 @@ main (int argc, char **argv) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Initialize options based on command-line arguments. @@ -90,13 +90,13 @@ main (int argc, char **argv) // Get an object reference from the argument string. CORBA::Object_var object = - orb->string_to_object (IOR, - ACE_TRY_ENV); + orb->string_to_object (IOR + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Try to narrow the object reference to a <test> reference. - test_var test_object = test::_narrow (object.in (), - ACE_TRY_ENV); + test_var test_object = test::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; test::data the_data0 (data_bytes); @@ -118,20 +118,20 @@ main (int argc, char **argv) // Invoke the oneway method. test_object->method (i, - the_data0, - ACE_TRY_ENV); + the_data0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Invoke the oneway method. test_object->method (i, - the_data1, - ACE_TRY_ENV); + the_data1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Invoke the oneway method. test_object->method (i, - the_data2, - ACE_TRY_ENV); + the_data2 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -140,7 +140,7 @@ main (int argc, char **argv) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) Sending a shutdown call..\n")); - test_object->shutdown (ACE_TRY_ENV); + test_object->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -150,7 +150,7 @@ main (int argc, char **argv) // static destructors to flush the queues, it will be too late. // Therefore, we use explicit destruction here and flush the // queues before main() ends. - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Single_Read/server.cpp b/TAO/tests/Single_Read/server.cpp index b84f0bc46a3..6607db33fdc 100644 --- a/TAO/tests/Single_Read/server.cpp +++ b/TAO/tests/Single_Read/server.cpp @@ -41,22 +41,22 @@ main (int argc, char *argv[]) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "", - ACE_TRY_ENV); + "" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -65,12 +65,12 @@ main (int argc, char *argv[]) test_i servant (orb.in ()); test_var server = - servant._this (ACE_TRY_ENV); + servant._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (server.in (), - ACE_TRY_ENV); + orb->object_to_string (server.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); @@ -84,17 +84,17 @@ main (int argc, char *argv[]) ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); root_poa->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Single_Read/test_i.cpp b/TAO/tests/Single_Read/test_i.cpp index 6aa56f3de51..2ee2f038975 100644 --- a/TAO/tests/Single_Read/test_i.cpp +++ b/TAO/tests/Single_Read/test_i.cpp @@ -11,8 +11,8 @@ test_i::test_i (CORBA::ORB_ptr orb) void test_i::method (CORBA::ULong request_number, - const test::data &, - CORBA::Environment &) + const test::data & + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -27,11 +27,11 @@ test_i::method (CORBA::ULong request_number, } void -test_i::shutdown (CORBA::Environment &ACE_TRY_ENV) +test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) About to invoke shudown... ")); - this->orb_->shutdown (0, - ACE_TRY_ENV); + this->orb_->shutdown (0 + TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/Single_Read/test_i.h b/TAO/tests/Single_Read/test_i.h index 0d5e0887b9e..8f921b977d1 100644 --- a/TAO/tests/Single_Read/test_i.h +++ b/TAO/tests/Single_Read/test_i.h @@ -29,11 +29,11 @@ public: // = The test interface methods. void method (CORBA::ULong request_number, - const test::data &, - CORBA::Environment &) + const test::data & + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment &) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Smart_Proxies/Benchmark/Smart_Proxy_Impl.cpp b/TAO/tests/Smart_Proxies/Benchmark/Smart_Proxy_Impl.cpp index 871d79432df..65826c42908 100644 --- a/TAO/tests/Smart_Proxies/Benchmark/Smart_Proxy_Impl.cpp +++ b/TAO/tests/Smart_Proxies/Benchmark/Smart_Proxy_Impl.cpp @@ -8,8 +8,8 @@ Smart_Test_Factory::Smart_Test_Factory (void) } Test_ptr -Smart_Test_Factory::create_proxy (Test_ptr proxy, - CORBA::Environment &) +Smart_Test_Factory::create_proxy (Test_ptr proxy + TAO_ENV_ARG_DECL_NOT_USED) { ACE_DEBUG ((LM_DEBUG, "create_smart_proxy\n")); @@ -18,7 +18,7 @@ Smart_Test_Factory::create_proxy (Test_ptr proxy, ACE_NEW_RETURN (proxy, Smart_Test_Proxy (proxy), 0); return proxy; - + } Smart_Test_Proxy::Smart_Test_Proxy (Test_ptr proxy) @@ -27,13 +27,13 @@ Smart_Test_Proxy::Smart_Test_Proxy (Test_ptr proxy) { } -CORBA::Short -Smart_Test_Proxy::box_prices (CORBA::Environment &ACE_TRY_ENV) +CORBA::Short +Smart_Test_Proxy::box_prices (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { if (this->price_ == 0) { - this->price_ = TAO_Test_Smart_Proxy_Base::box_prices (ACE_TRY_ENV); + this->price_ = TAO_Test_Smart_Proxy_Base::box_prices (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (0); } return this->price_; diff --git a/TAO/tests/Smart_Proxies/Benchmark/Smart_Proxy_Impl.h b/TAO/tests/Smart_Proxies/Benchmark/Smart_Proxy_Impl.h index 649ccc37f99..5cafabfec5e 100644 --- a/TAO/tests/Smart_Proxies/Benchmark/Smart_Proxy_Impl.h +++ b/TAO/tests/Smart_Proxies/Benchmark/Smart_Proxy_Impl.h @@ -6,21 +6,19 @@ class Smart_Test_Factory : public virtual TAO_Test_Default_Proxy_Factory public: Smart_Test_Factory (void); - - virtual Test_ptr create_proxy (Test_ptr proxy, - CORBA::Environment &env = - TAO_default_environment ()); - // This method will create the smart_proxy. + + virtual Test_ptr create_proxy (Test_ptr proxy + TAO_ENV_ARG_DECL_WITH_DEFAULTS); + // This method will create the smart_proxy. }; -class Smart_Test_Proxy : public virtual TAO_Test_Smart_Proxy_Base +class Smart_Test_Proxy : public virtual TAO_Test_Smart_Proxy_Base { public: Smart_Test_Proxy (Test_ptr proxy); - virtual CORBA::Short box_prices(CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) - ACE_THROW_SPEC ((CORBA::SystemException)); + virtual CORBA::Short box_prices(TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); // "Smartify" the method call! private: diff --git a/TAO/tests/Smart_Proxies/Benchmark/client.cpp b/TAO/tests/Smart_Proxies/Benchmark/client.cpp index 898df5db6f2..f019ad60a01 100644 --- a/TAO/tests/Smart_Proxies/Benchmark/client.cpp +++ b/TAO/tests/Smart_Proxies/Benchmark/client.cpp @@ -118,16 +118,16 @@ main (int argc, char *argv[]) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "", - ACE_TRY_ENV); + "" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = - orb->string_to_object (ior, - ACE_TRY_ENV); + orb->string_to_object (ior + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (register_smart_proxy == 1) { @@ -150,8 +150,8 @@ main (int argc, char *argv[]) } Test_var server = - Test::_narrow (object.in (), - ACE_TRY_ENV); + Test::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); if (CORBA::is_nil (server.in ())) ACE_ERROR_RETURN ((LM_ERROR, @@ -174,7 +174,7 @@ main (int argc, char *argv[]) // Record current time. ACE_hrtime_t latency_base = ACE_OS::gethrtime (); - price = server->box_prices (ACE_TRY_ENV); + price = server->box_prices (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (price < 300) @@ -194,13 +194,13 @@ main (int argc, char *argv[]) marker.dump_stats ("buying tickets ", gsf); - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; /* Test_var server1 = - Test::_narrow (object.in (), - ACE_TRY_ENV); + Test::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); if (CORBA::is_nil (server1.in ())) ACE_ERROR_RETURN ((LM_ERROR, @@ -223,7 +223,7 @@ main (int argc, char *argv[]) // Record current time. ACE_hrtime_t latency_base = ACE_OS::gethrtime (); - price1 = server1->box_prices (ACE_TRY_ENV); + price1 = server1->box_prices (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (price1 < 300) @@ -243,7 +243,7 @@ main (int argc, char *argv[]) marker1.dump_stats ("buying tickets using a default proxy ", gsf1); - server1->shutdown (ACE_TRY_ENV); + server1->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; */ } diff --git a/TAO/tests/Smart_Proxies/Benchmark/server.cpp b/TAO/tests/Smart_Proxies/Benchmark/server.cpp index 55dd4a8b809..9c6f0e15935 100644 --- a/TAO/tests/Smart_Proxies/Benchmark/server.cpp +++ b/TAO/tests/Smart_Proxies/Benchmark/server.cpp @@ -28,14 +28,14 @@ class Test_i : public POA_Test public: Test_i (CORBA::ORB_ptr orb); - CORBA::Short box_prices (CORBA::Environment &ACE_TRY_ENV) + CORBA::Short box_prices (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - CORBA::Long tickets (CORBA::Short number, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Long tickets (CORBA::Short number + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment &ACE_TRY_ENV) + void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: @@ -49,25 +49,25 @@ Test_i::Test_i (CORBA::ORB_ptr orb) } CORBA::Short -Test_i::box_prices (CORBA::Environment &) +Test_i::box_prices (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return 125; } CORBA::Long -Test_i::tickets (CORBA::Short number, - CORBA::Environment &) +Test_i::tickets (CORBA::Short number + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return 125 * number; } void -Test_i::shutdown (CORBA::Environment &ACE_TRY_ENV) +Test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } static const char *ior_output_file = 0; @@ -100,7 +100,7 @@ parse_args (int argc, char *argv[]) int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { @@ -109,35 +109,35 @@ main (int argc, char *argv[]) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "", - ACE_TRY_ENV); + "" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test_i servant (orb.in ()); // Obtain RootPOA. CORBA::Object_var object = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (object.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the POAManager of the RootPOA. PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Test_var Test_object = - servant._this (ACE_TRY_ENV); + servant._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (Test_object.in (), - ACE_TRY_ENV); + orb->object_to_string (Test_object.in () + TAO_ENV_ARG_PARAMETER); // If the ior_output_file exists, output the ior to it if (ior_output_file != 0) @@ -157,18 +157,18 @@ main (int argc, char *argv[]) ACE_OS::fclose (output_file); } - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); root_poa->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Smart_Proxies/Collocation/Coll_Tester.cpp b/TAO/tests/Smart_Proxies/Collocation/Coll_Tester.cpp index cfe0ba58e66..a12bd8c64a6 100644 --- a/TAO/tests/Smart_Proxies/Collocation/Coll_Tester.cpp +++ b/TAO/tests/Smart_Proxies/Collocation/Coll_Tester.cpp @@ -22,10 +22,10 @@ Collocation_Test::Collocation_Test (void) } int -Collocation_Test::init (int argc, char *argv[], CORBA::Environment &ACE_TRY_ENV) +Collocation_Test::init (int argc, char *argv[] TAO_ENV_ARG_DECL) { // Initialize the ORB. - this->orb_ = CORBA::ORB_init (argc, argv, 0, ACE_TRY_ENV); + this->orb_ = CORBA::ORB_init (argc, argv, 0 TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); int result = this->parse_args (argc, argv); @@ -34,52 +34,52 @@ Collocation_Test::init (int argc, char *argv[], CORBA::Environment &ACE_TRY_ENV) // Get an Object reference to RootPOA. CORBA::Object_var obj = - this->orb_->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + this->orb_->resolve_initial_references ("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Narrow the Object reference to a POA reference this->root_poa_ = - PortableServer::POA::_narrow (obj.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (obj.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Get the POAManager of RootPOA this->poa_manager_ = - this->root_poa_->the_POAManager (ACE_TRY_ENV); + this->root_poa_->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // Activate the diamond servant and its base classes under RootPOA. PortableServer::ObjectId_var id = - this->root_poa_->activate_object (&this->top_servant_, - ACE_TRY_ENV); + this->root_poa_->activate_object (&this->top_servant_ + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // // We only care about the most derived class here. -// this->diamond_obj_ = this->diamond_servant_._this (ACE_TRY_ENV); +// this->diamond_obj_ = this->diamond_servant_._this (TAO_ENV_SINGLE_ARG_PARAMETER); // ACE_CHECK_RETURN (-1); id = - this->root_poa_->activate_object (&this->diamond_servant_, - ACE_TRY_ENV); + this->root_poa_->activate_object (&this->diamond_servant_ + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); // We only care about the most derived class here. - this->diamond_obj_ = this->root_poa_->id_to_reference (id.in (), - ACE_TRY_ENV); + this->diamond_obj_ = this->root_poa_->id_to_reference (id.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); id = - this->root_poa_->activate_object (&this->left_servant_, - ACE_TRY_ENV); + this->root_poa_->activate_object (&this->left_servant_ + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); id = - this->root_poa_->activate_object (&this->right_servant_, - ACE_TRY_ENV); + this->root_poa_->activate_object (&this->right_servant_ + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::String_var str = - this->orb_->object_to_string (this->diamond_obj_.in (), - ACE_TRY_ENV); + this->orb_->object_to_string (this->diamond_obj_.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, "Diamond Servant activated:\n %s\n", @@ -97,45 +97,45 @@ Collocation_Test::parse_args (int argc, char *argv[]) } int -Collocation_Test::test_narrow (CORBA::Environment &ACE_TRY_ENV) +Collocation_Test::test_narrow (TAO_ENV_SINGLE_ARG_DECL) { // Ensure that the smart proxy is the one which is used by registering // the user-defined factory. Its necessary to create one on the heap so // the lifetime of the factory object can be managed by the framework. Smart_Diamond_Top_Factory *factory = 0; ACE_NEW_RETURN (factory, - Smart_Diamond_Top_Factory, - -1); + Smart_Diamond_Top_Factory, + -1); Diamond::Top_var top = - Diamond::Top::_narrow (this->diamond_obj_, ACE_TRY_ENV); + Diamond::Top::_narrow (this->diamond_obj_ TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); Diamond::Left_var left = - Diamond::Left::_narrow (this->diamond_obj_, ACE_TRY_ENV); + Diamond::Left::_narrow (this->diamond_obj_ TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); Diamond::Right_var right = - Diamond::Right::_narrow (this->diamond_obj_, ACE_TRY_ENV); + Diamond::Right::_narrow (this->diamond_obj_ TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); Diamond::Buttom_var buttom = - Diamond::Buttom::_narrow (this->diamond_obj_, ACE_TRY_ENV); + Diamond::Buttom::_narrow (this->diamond_obj_ TAO_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); - CORBA::String_var str = top->shape (ACE_TRY_ENV); + CORBA::String_var str = top->shape (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, "Calling top->shape: %s\n", str.in ())); - str = left->shape (ACE_TRY_ENV); + str = left->shape (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, "Calling left->shape: %s\n", str.in ())); - str = right->shape (ACE_TRY_ENV); + str = right->shape (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, "Calling right->shape: %s\n", str.in ())); - str = buttom->shape (ACE_TRY_ENV); + str = buttom->shape (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, "Calling buttom->shape: %s\n", str.in ())); @@ -143,12 +143,12 @@ Collocation_Test::test_narrow (CORBA::Environment &ACE_TRY_ENV) } int -Collocation_Test::run (CORBA::Environment &ACE_TRY_ENV) +Collocation_Test::run (TAO_ENV_SINGLE_ARG_DECL) { - this->poa_manager_->activate (ACE_TRY_ENV); + this->poa_manager_->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); - this->test_narrow (ACE_TRY_ENV); + this->test_narrow (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); return 0; diff --git a/TAO/tests/Smart_Proxies/Collocation/Coll_Tester.h b/TAO/tests/Smart_Proxies/Collocation/Coll_Tester.h index 110712c0122..5d7a4ff12fc 100644 --- a/TAO/tests/Smart_Proxies/Collocation/Coll_Tester.h +++ b/TAO/tests/Smart_Proxies/Collocation/Coll_Tester.h @@ -27,17 +27,17 @@ class Collocation_Test public: Collocation_Test (void); - int init (int argc, char *argv[], CORBA::Environment &); + int init (int argc, char *argv[] TAO_ENV_ARG_DECL_NOT_USED); // Initializing the Collocation_Test object. int parse_args (int argc, char *argv[]); // Parse the test specific arguments. - int test_narrow (CORBA::Environment &); + int test_narrow (TAO_ENV_SINGLE_ARG_DECL_NOT_USED); // This test narrow an object reference to its base class and see // if it works correctly. - int run (CORBA::Environment &); + int run (TAO_ENV_SINGLE_ARG_DECL_NOT_USED); // Run the test. private: diff --git a/TAO/tests/Smart_Proxies/Collocation/Diamond_i.cpp b/TAO/tests/Smart_Proxies/Collocation/Diamond_i.cpp index 4eca173bdfe..df102e638a8 100644 --- a/TAO/tests/Smart_Proxies/Collocation/Diamond_i.cpp +++ b/TAO/tests/Smart_Proxies/Collocation/Diamond_i.cpp @@ -13,7 +13,7 @@ Top_i::~Top_i () } char * -Top_i::shape (CORBA::Environment &) +Top_i::shape (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC (( CORBA::SystemException )) @@ -32,7 +32,7 @@ Left_i::~Left_i () } char * -Left_i::shape (CORBA::Environment &) +Left_i::shape (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC (( CORBA::SystemException )) @@ -41,7 +41,7 @@ Left_i::shape (CORBA::Environment &) } char * -Left_i::color (CORBA::Environment &) +Left_i::color (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC (( CORBA::SystemException )) @@ -60,7 +60,7 @@ Right_i::~Right_i () } char * -Right_i::shape (CORBA::Environment &) +Right_i::shape (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC (( CORBA::SystemException )) @@ -69,7 +69,7 @@ Right_i::shape (CORBA::Environment &) } char * -Right_i::color (CORBA::Environment &) +Right_i::color (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC (( CORBA::SystemException )) @@ -79,7 +79,7 @@ Right_i::color (CORBA::Environment &) } CORBA::Long -Right_i::width (CORBA::Environment &) +Right_i::width (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC (( CORBA::SystemException )) @@ -98,7 +98,7 @@ Buttom_i::~Buttom_i () } char * -Buttom_i::shape (CORBA::Environment &) +Buttom_i::shape (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC (( CORBA::SystemException )) @@ -107,7 +107,7 @@ Buttom_i::shape (CORBA::Environment &) } char * -Buttom_i::color (CORBA::Environment &) +Buttom_i::color (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC (( CORBA::SystemException )) @@ -116,7 +116,7 @@ Buttom_i::color (CORBA::Environment &) } CORBA::Long -Buttom_i::width (CORBA::Environment &) +Buttom_i::width (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC (( CORBA::SystemException )) @@ -125,7 +125,7 @@ Buttom_i::width (CORBA::Environment &) } char * -Buttom_i::name (CORBA::Environment &) +Buttom_i::name (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC (( CORBA::SystemException )) diff --git a/TAO/tests/Smart_Proxies/Collocation/Diamond_i.h b/TAO/tests/Smart_Proxies/Collocation/Diamond_i.h index d5e05acf379..3b4540e57e9 100644 --- a/TAO/tests/Smart_Proxies/Collocation/Diamond_i.h +++ b/TAO/tests/Smart_Proxies/Collocation/Diamond_i.h @@ -16,7 +16,7 @@ public: ~Top_i (void); // Ctor and dtor. - virtual char* shape (CORBA::Environment &) + virtual char* shape (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); // Return the shape of this object (interface.) }; @@ -28,11 +28,11 @@ public: ~Left_i (void); // Ctor, dtor. - virtual char * shape (CORBA::Environment &) + virtual char * shape (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); // Return the shape of this object (interface.) - virtual char * color (CORBA::Environment &) + virtual char * color (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); // Return the color of this object (interface.) }; @@ -44,15 +44,15 @@ public: ~Right_i (void); // Ctor, dtor. - virtual char * shape (CORBA::Environment &) + virtual char * shape (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); // Return the shape of this object (interface.) - virtual char * color (CORBA::Environment &) + virtual char * color (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); // Return the color of this object (interface.) - virtual CORBA::Long width (CORBA::Environment &) + virtual CORBA::Long width (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); // Return the width of the stuff. }; @@ -64,19 +64,19 @@ public: ~Buttom_i (void); // Ctor, dtor. - virtual char * shape (CORBA::Environment &) + virtual char * shape (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); // Return the shape of this object (interface.) - virtual char * color (CORBA::Environment &) + virtual char * color (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); // Return the color of this object (interface.) - virtual CORBA::Long width (CORBA::Environment &) + virtual CORBA::Long width (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); // Return the width of the stuff. - virtual char * name (CORBA::Environment &) + virtual char * name (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); // Return the name of the object. }; diff --git a/TAO/tests/Smart_Proxies/Collocation/Smart_Proxy_Impl.cpp b/TAO/tests/Smart_Proxies/Collocation/Smart_Proxy_Impl.cpp index e21a2b22e41..65b2483243b 100644 --- a/TAO/tests/Smart_Proxies/Collocation/Smart_Proxy_Impl.cpp +++ b/TAO/tests/Smart_Proxies/Collocation/Smart_Proxy_Impl.cpp @@ -8,15 +8,15 @@ Smart_Diamond_Top_Factory::Smart_Diamond_Top_Factory (void) } Diamond::Top_ptr -Smart_Diamond_Top_Factory::create_proxy (Diamond::Top_ptr proxy, - CORBA::Environment & - ) +Smart_Diamond_Top_Factory::create_proxy (Diamond::Top_ptr proxy + TAO_ENV_ARG_DECL_NOT_USED + ) { ACE_DEBUG ((LM_DEBUG, "create_smart_proxy\n")); if (CORBA::is_nil (proxy) == 0) - ACE_NEW_RETURN (proxy, - Smart_Diamond_Top_Proxy (proxy), - 0); + ACE_NEW_RETURN (proxy, + Smart_Diamond_Top_Proxy (proxy), + 0); return proxy; } @@ -28,31 +28,31 @@ Smart_Diamond_Top_Proxy::Smart_Diamond_Top_Proxy (Diamond::Top_ptr proxy) char * Smart_Diamond_Top_Proxy::shape ( - CORBA::Environment &ACE_TRY_ENV - ) + TAO_ENV_SINGLE_ARG_DECL + ) ACE_THROW_SPEC (( CORBA::SystemException )) { ACE_DEBUG ((LM_DEBUG, "Smart_proxy: This is ")); - + CORBA::Short retval = 0; char *ans= 0; - ACE_TRY + ACE_TRY { - ans = ACE_OS::strdup (TAO_Diamond_Top_Smart_Proxy_Base::shape(ACE_TRY_ENV)); + ans = ACE_OS::strdup (TAO_Diamond_Top_Smart_Proxy_Base::shape(TAO_ENV_SINGLE_ARG_PARAMETER)); - ACE_TRY_CHECK; + ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "%s\n", ans)); - + } - ACE_CATCHANY + ACE_CATCHANY { ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Uncaught Exception"); return 0; } ACE_ENDTRY; - + return ans; } diff --git a/TAO/tests/Smart_Proxies/Collocation/Smart_Proxy_Impl.h b/TAO/tests/Smart_Proxies/Collocation/Smart_Proxy_Impl.h index cfef0a4876e..beda2599b3f 100644 --- a/TAO/tests/Smart_Proxies/Collocation/Smart_Proxy_Impl.h +++ b/TAO/tests/Smart_Proxies/Collocation/Smart_Proxy_Impl.h @@ -9,25 +9,23 @@ class ACE_Svc_Export Smart_Diamond_Top_Factory : public virtual Diamond::TAO_Dia public: Smart_Diamond_Top_Factory (void); - - virtual Diamond::Top_ptr create_proxy (Diamond::Top_ptr proxy, - CORBA::Environment &env = - TAO_default_environment () - ); - // This method will create the smart_proxy. + + virtual Diamond::Top_ptr create_proxy (Diamond::Top_ptr proxy + TAO_ENV_ARG_DECL_WITH_DEFAULTS); + ); + // This method will create the smart_proxy. }; -class ACE_Svc_Export Smart_Diamond_Top_Proxy : public virtual Diamond::TAO_Diamond_Top_Smart_Proxy_Base +class ACE_Svc_Export Smart_Diamond_Top_Proxy : public virtual Diamond::TAO_Diamond_Top_Smart_Proxy_Base { public: Smart_Diamond_Top_Proxy (Diamond::Top_ptr proxy); virtual char * shape ( - CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment () - ) + TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC (( CORBA::SystemException )); diff --git a/TAO/tests/Smart_Proxies/Collocation/main.cpp b/TAO/tests/Smart_Proxies/Collocation/main.cpp index 84ce376b7fc..71ff66d922a 100644 --- a/TAO/tests/Smart_Proxies/Collocation/main.cpp +++ b/TAO/tests/Smart_Proxies/Collocation/main.cpp @@ -12,10 +12,10 @@ int main (int argc, char *argv[]) ACE_TRY_NEW_ENV { - coll_test.init (argc, argv, ACE_TRY_ENV); + coll_test.init (argc, argv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - coll_test.run (ACE_TRY_ENV); + coll_test.run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Smart_Proxies/On_Demand/Smart_Proxy_Impl.cpp b/TAO/tests/Smart_Proxies/On_Demand/Smart_Proxy_Impl.cpp index 32017e2c2c7..5d05e7d417e 100644 --- a/TAO/tests/Smart_Proxies/On_Demand/Smart_Proxy_Impl.cpp +++ b/TAO/tests/Smart_Proxies/On_Demand/Smart_Proxy_Impl.cpp @@ -6,20 +6,20 @@ Smart_Test_Proxy::Smart_Test_Proxy (Test_ptr proxy) { } -CORBA::Short -Smart_Test_Proxy::method (CORBA::Short boo, - CORBA::Environment &ACE_TRY_ENV) +CORBA::Short +Smart_Test_Proxy::method (CORBA::Short boo + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, Test::Oops)) { ACE_DEBUG ((LM_DEBUG, "Yahoo, I am smart\n")); - + CORBA::Short retval = 0; - ACE_TRY + ACE_TRY { - retval = TAO_Test_Smart_Proxy_Base::method (boo, - ACE_TRY_ENV); + retval = TAO_Test_Smart_Proxy_Base::method (boo + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (Test::Oops, reason) @@ -29,7 +29,7 @@ Smart_Test_Proxy::method (CORBA::Short boo, return -1; } ACE_ENDTRY; - + return retval; } diff --git a/TAO/tests/Smart_Proxies/On_Demand/Smart_Proxy_Impl.h b/TAO/tests/Smart_Proxies/On_Demand/Smart_Proxy_Impl.h index f1e2a0178df..b466f3fbe0c 100644 --- a/TAO/tests/Smart_Proxies/On_Demand/Smart_Proxy_Impl.h +++ b/TAO/tests/Smart_Proxies/On_Demand/Smart_Proxy_Impl.h @@ -2,15 +2,14 @@ #include "testC.h" -class Smart_Test_Proxy : public virtual TAO_Test_Smart_Proxy_Base +class Smart_Test_Proxy : public virtual TAO_Test_Smart_Proxy_Base { public: Smart_Test_Proxy (Test_ptr proxy); - virtual CORBA::Short method (CORBA::Short boo, - CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) - ACE_THROW_SPEC ((CORBA::SystemException, + virtual CORBA::Short method (CORBA::Short boo + TAO_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, Test::Oops)); // "Smartify" the method call! diff --git a/TAO/tests/Smart_Proxies/On_Demand/Smart_Test_Factory.cpp b/TAO/tests/Smart_Proxies/On_Demand/Smart_Test_Factory.cpp index f5894d0e5c2..20d025118f4 100644 --- a/TAO/tests/Smart_Proxies/On_Demand/Smart_Test_Factory.cpp +++ b/TAO/tests/Smart_Proxies/On_Demand/Smart_Test_Factory.cpp @@ -9,8 +9,8 @@ Smart_Test_Factory::Smart_Test_Factory (void) } Test_ptr -Smart_Test_Factory::create_proxy (Test_ptr proxy, - CORBA::Environment &) +Smart_Test_Factory::create_proxy (Test_ptr proxy + TAO_ENV_ARG_DECL_NOT_USED) { ACE_DEBUG ((LM_DEBUG, "create_smart_proxy\n")); @@ -19,7 +19,7 @@ Smart_Test_Factory::create_proxy (Test_ptr proxy, ACE_NEW_RETURN (proxy, Smart_Test_Proxy (proxy), 0); return proxy; - + } // The following Factory is used by the <ACE_Service_Config> to diff --git a/TAO/tests/Smart_Proxies/On_Demand/Smart_Test_Factory.h b/TAO/tests/Smart_Proxies/On_Demand/Smart_Test_Factory.h index 74b463910d7..4ce95df91b1 100644 --- a/TAO/tests/Smart_Proxies/On_Demand/Smart_Test_Factory.h +++ b/TAO/tests/Smart_Proxies/On_Demand/Smart_Test_Factory.h @@ -12,9 +12,8 @@ public: Smart_Test_Factory (void); - virtual Test_ptr create_proxy (Test_ptr proxy, - CORBA::Environment &env = - TAO_default_environment ()); + virtual Test_ptr create_proxy (Test_ptr proxy + TAO_ENV_ARG_DECL_WITH_DEFAULTS); // This method will create the smart_proxy. }; diff --git a/TAO/tests/Smart_Proxies/On_Demand/client.cpp b/TAO/tests/Smart_Proxies/On_Demand/client.cpp index 13302959bce..701aa5e3d8e 100644 --- a/TAO/tests/Smart_Proxies/On_Demand/client.cpp +++ b/TAO/tests/Smart_Proxies/On_Demand/client.cpp @@ -57,35 +57,35 @@ main (int argc, char *argv[]) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "", - ACE_TRY_ENV); + "" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; - + CORBA::Object_var object = - orb->string_to_object (ior, - ACE_TRY_ENV); + orb->string_to_object (ior + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // To use the smart proxy just enter it as a svc.conf // entry. - + Test_var server = - Test::_narrow (object.in (), - ACE_TRY_ENV); + Test::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - + if (CORBA::is_nil (server.in ())) ACE_ERROR_RETURN ((LM_ERROR, "Object reference <%s> is nil\n", ior), 1); - + server->method (0); - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } diff --git a/TAO/tests/Smart_Proxies/On_Demand/server.cpp b/TAO/tests/Smart_Proxies/On_Demand/server.cpp index bb65e5ecb54..8260da63128 100644 --- a/TAO/tests/Smart_Proxies/On_Demand/server.cpp +++ b/TAO/tests/Smart_Proxies/On_Demand/server.cpp @@ -28,12 +28,12 @@ class Test_i : public POA_Test public: Test_i (CORBA::ORB_ptr orb); - CORBA::Short method (CORBA::Short boo, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Short method (CORBA::Short boo + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, Test::Oops)); - void shutdown (CORBA::Environment &ACE_TRY_ENV) + void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: @@ -47,8 +47,8 @@ Test_i::Test_i (CORBA::ORB_ptr orb) } CORBA::Short -Test_i :: method (CORBA::Short boo, - CORBA::Environment &ACE_TRY_ENV) +Test_i :: method (CORBA::Short boo + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, Test::Oops)) { @@ -62,7 +62,7 @@ Test_i :: method (CORBA::Short boo, } void -Test_i::shutdown (CORBA::Environment &) +Test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->orb_->shutdown (); @@ -98,7 +98,7 @@ parse_args (int argc, char *argv[]) int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { @@ -107,34 +107,34 @@ main (int argc, char *argv[]) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "", - ACE_TRY_ENV); + "" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test_i servant (orb.in ()); // Obtain RootPOA. CORBA::Object_var object = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (object.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the POAManager of the RootPOA. PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Test_var Test_object = - servant._this (ACE_TRY_ENV); + servant._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (Test_object.in (), - ACE_TRY_ENV); + orb->object_to_string (Test_object.in () + TAO_ENV_ARG_PARAMETER); // If the ior_output_file exists, output the ior to it if (ior_output_file != 0) @@ -154,17 +154,17 @@ main (int argc, char *argv[]) ACE_OS::fclose (output_file); } - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); root_poa->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Smart_Proxies/Policy/Smart_Proxy_Impl.cpp b/TAO/tests/Smart_Proxies/Policy/Smart_Proxy_Impl.cpp index e016b3b16c1..1fdcda810e7 100644 --- a/TAO/tests/Smart_Proxies/Policy/Smart_Proxy_Impl.cpp +++ b/TAO/tests/Smart_Proxies/Policy/Smart_Proxy_Impl.cpp @@ -10,8 +10,8 @@ Smart_Test_Factory::Smart_Test_Factory (int one_shot_factory) } Test_ptr -Smart_Test_Factory::create_proxy (Test_ptr proxy, - CORBA::Environment &) +Smart_Test_Factory::create_proxy (Test_ptr proxy + TAO_ENV_ARG_DECL_NOT_USED) { ACE_DEBUG ((LM_DEBUG, "create_smart_proxy\n")); @@ -20,7 +20,7 @@ Smart_Test_Factory::create_proxy (Test_ptr proxy, ACE_NEW_RETURN (proxy, Smart_Test_Proxy (proxy), 0); return proxy; - + } Smart_Test_Proxy::Smart_Test_Proxy (Test_ptr proxy) @@ -28,20 +28,20 @@ Smart_Test_Proxy::Smart_Test_Proxy (Test_ptr proxy) { } -CORBA::Short -Smart_Test_Proxy::method (CORBA::Short boo, - CORBA::Environment &ACE_TRY_ENV) +CORBA::Short +Smart_Test_Proxy::method (CORBA::Short boo + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, Test::Oops)) { ACE_DEBUG ((LM_DEBUG, "Yahoo, I am smart\n")); - + CORBA::Short retval = 0; - ACE_TRY + ACE_TRY { - retval = TAO_Test_Smart_Proxy_Base::method (boo, - ACE_TRY_ENV); + retval = TAO_Test_Smart_Proxy_Base::method (boo + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (Test::Oops, reason) @@ -51,6 +51,6 @@ Smart_Test_Proxy::method (CORBA::Short boo, return -1; } ACE_ENDTRY; - + return retval; } diff --git a/TAO/tests/Smart_Proxies/Policy/Smart_Proxy_Impl.h b/TAO/tests/Smart_Proxies/Policy/Smart_Proxy_Impl.h index 776b11b6b78..10edb88bf24 100644 --- a/TAO/tests/Smart_Proxies/Policy/Smart_Proxy_Impl.h +++ b/TAO/tests/Smart_Proxies/Policy/Smart_Proxy_Impl.h @@ -7,22 +7,20 @@ class Smart_Test_Factory : public virtual TAO_Test_Default_Proxy_Factory public: Smart_Test_Factory (int one_shot_factory = 1); - - virtual Test_ptr create_proxy (Test_ptr proxy, - CORBA::Environment &env = - TAO_default_environment ()); - // This method will create the smart_proxy. + + virtual Test_ptr create_proxy (Test_ptr proxy + TAO_ENV_ARG_DECL_WITH_DEFAULTS); + // This method will create the smart_proxy. }; -class Smart_Test_Proxy : public virtual TAO_Test_Smart_Proxy_Base +class Smart_Test_Proxy : public virtual TAO_Test_Smart_Proxy_Base { public: Smart_Test_Proxy (Test_ptr proxy); - virtual CORBA::Short method (CORBA::Short boo, - CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) - ACE_THROW_SPEC ((CORBA::SystemException, + virtual CORBA::Short method (CORBA::Short boo + TAO_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, Test::Oops)); // "Smartify" the method call! diff --git a/TAO/tests/Smart_Proxies/Policy/client.cpp b/TAO/tests/Smart_Proxies/Policy/client.cpp index fc775d205a0..5c5c0f2211a 100644 --- a/TAO/tests/Smart_Proxies/Policy/client.cpp +++ b/TAO/tests/Smart_Proxies/Policy/client.cpp @@ -56,7 +56,7 @@ parse_args (int argc, char *argv[]) return 0; } -int +int run_test (CORBA::ORB_ptr orb_ptr, int target) { @@ -67,28 +67,28 @@ run_test (CORBA::ORB_ptr orb_ptr, if (target == 1) { object = - orb->string_to_object (ior1, - ACE_TRY_ENV); + orb->string_to_object (ior1 + TAO_ENV_ARG_PARAMETER); } else { object = - orb->string_to_object (ior2, - ACE_TRY_ENV); + orb->string_to_object (ior2 + TAO_ENV_ARG_PARAMETER); } ACE_TRY_CHECK; - + Test_var server = - Test::_narrow (object.in (), - ACE_TRY_ENV); + Test::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); if (CORBA::is_nil (server.in ())) ACE_ERROR_RETURN ((LM_ERROR, "Object reference is nil\n"), 1); - + server->method (0); - server->shutdown (ACE_TRY_ENV); - + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; } ACE_CATCHANY @@ -97,7 +97,7 @@ run_test (CORBA::ORB_ptr orb_ptr, "Client-side exception:"); } ACE_ENDTRY; -return 0; +return 0; } int @@ -108,13 +108,13 @@ main (int argc, char *argv[]) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "", - ACE_TRY_ENV); + "" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; - + // To use the smart proxy it is necessary to allocate the // user-defined smart factory on the heap as the smart proxy // generated classes take care of destroying the object. This @@ -126,14 +126,14 @@ main (int argc, char *argv[]) // this interface) but if there is a need for flexibility per // object instance then <one_shot_factory> needs to be set to 0. Smart_Test_Factory *test_factory = 0; - ACE_NEW_RETURN (test_factory, + ACE_NEW_RETURN (test_factory, Smart_Test_Factory (one_shot_factory), -1); - - // To make KAI Compiler happy as it considers <test_factory> to be + + // To make KAI Compiler happy as it considers <test_factory> to be // an unused variable. ACE_UNUSED_ARG (test_factory); - + run_test (orb.in (), 1); run_test (orb.in (), 2); diff --git a/TAO/tests/Smart_Proxies/Policy/server.cpp b/TAO/tests/Smart_Proxies/Policy/server.cpp index 64260ee25f2..6c1780056d6 100644 --- a/TAO/tests/Smart_Proxies/Policy/server.cpp +++ b/TAO/tests/Smart_Proxies/Policy/server.cpp @@ -28,12 +28,12 @@ class Test_i : public POA_Test public: Test_i (CORBA::ORB_ptr orb); - CORBA::Short method (CORBA::Short boo, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Short method (CORBA::Short boo + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, Test::Oops)); - void shutdown (CORBA::Environment &ACE_TRY_ENV) + void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: @@ -47,8 +47,8 @@ Test_i::Test_i (CORBA::ORB_ptr orb) } CORBA::Short -Test_i :: method (CORBA::Short boo, - CORBA::Environment &ACE_TRY_ENV) +Test_i :: method (CORBA::Short boo + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, Test::Oops)) { @@ -62,10 +62,10 @@ Test_i :: method (CORBA::Short boo, } void -Test_i::shutdown (CORBA::Environment &ACE_TRY_ENV) +Test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } static const char *ior_output_file = 0; @@ -98,7 +98,7 @@ parse_args (int argc, char *argv[]) int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { @@ -107,35 +107,35 @@ main (int argc, char *argv[]) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "", - ACE_TRY_ENV); + "" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test_i servant (orb.in ()); // Obtain RootPOA. CORBA::Object_var object = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (object.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the POAManager of the RootPOA. PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Test_var Test_object = - servant._this (ACE_TRY_ENV); + servant._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (Test_object.in (), - ACE_TRY_ENV); + orb->object_to_string (Test_object.in () + TAO_ENV_ARG_PARAMETER); // If the ior_output_file exists, output the ior to it if (ior_output_file != 0) @@ -155,18 +155,18 @@ main (int argc, char *argv[]) ACE_OS::fclose (output_file); } - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); root_poa->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Smart_Proxies/Smart_Proxy_Impl.cpp b/TAO/tests/Smart_Proxies/Smart_Proxy_Impl.cpp index 4c6919c093e..996a0e588d4 100644 --- a/TAO/tests/Smart_Proxies/Smart_Proxy_Impl.cpp +++ b/TAO/tests/Smart_Proxies/Smart_Proxy_Impl.cpp @@ -9,8 +9,8 @@ Smart_Test_Factory::Smart_Test_Factory (void) } Test_ptr -Smart_Test_Factory::create_proxy (Test_ptr proxy, - CORBA::Environment &) +Smart_Test_Factory::create_proxy (Test_ptr proxy + TAO_ENV_ARG_DECL_NOT_USED) { ACE_DEBUG ((LM_DEBUG, "create_smart_proxy\n")); @@ -19,7 +19,7 @@ Smart_Test_Factory::create_proxy (Test_ptr proxy, ACE_NEW_RETURN (proxy, Smart_Test_Proxy (proxy), 0); return proxy; - + } Smart_Test_Proxy::Smart_Test_Proxy (Test_ptr proxy) @@ -27,20 +27,20 @@ Smart_Test_Proxy::Smart_Test_Proxy (Test_ptr proxy) { } -CORBA::Short -Smart_Test_Proxy::method (CORBA::Short boo, - CORBA::Environment &ACE_TRY_ENV) +CORBA::Short +Smart_Test_Proxy::method (CORBA::Short boo + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, Test::Oops)) { ACE_DEBUG ((LM_DEBUG, "Yahoo, I am smart\n")); - + CORBA::Short retval = 0; - ACE_TRY + ACE_TRY { - retval = TAO_Test_Smart_Proxy_Base::method (boo, - ACE_TRY_ENV); + retval = TAO_Test_Smart_Proxy_Base::method (boo + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (Test::Oops, reason) @@ -50,6 +50,6 @@ Smart_Test_Proxy::method (CORBA::Short boo, return -1; } ACE_ENDTRY; - + return retval; } diff --git a/TAO/tests/Smart_Proxies/Smart_Proxy_Impl.h b/TAO/tests/Smart_Proxies/Smart_Proxy_Impl.h index 09e9f3677ed..838a34b97ae 100644 --- a/TAO/tests/Smart_Proxies/Smart_Proxy_Impl.h +++ b/TAO/tests/Smart_Proxies/Smart_Proxy_Impl.h @@ -7,22 +7,20 @@ class Smart_Test_Factory : public virtual TAO_Test_Default_Proxy_Factory public: Smart_Test_Factory (void); - - virtual Test_ptr create_proxy (Test_ptr proxy, - CORBA::Environment &env = - TAO_default_environment ()); - // This method will create the smart_proxy. + + virtual Test_ptr create_proxy (Test_ptr proxy + TAO_ENV_ARG_DECL_WITH_DEFAULTS); + // This method will create the smart_proxy. }; -class Smart_Test_Proxy : public virtual TAO_Test_Smart_Proxy_Base +class Smart_Test_Proxy : public virtual TAO_Test_Smart_Proxy_Base { public: Smart_Test_Proxy (Test_ptr proxy); - virtual CORBA::Short method (CORBA::Short boo, - CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment ()) - ACE_THROW_SPEC ((CORBA::SystemException, + virtual CORBA::Short method (CORBA::Short boo + TAO_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, Test::Oops)); // "Smartify" the method call! diff --git a/TAO/tests/Smart_Proxies/client.cpp b/TAO/tests/Smart_Proxies/client.cpp index 818e5baa50c..caeee42c552 100644 --- a/TAO/tests/Smart_Proxies/client.cpp +++ b/TAO/tests/Smart_Proxies/client.cpp @@ -57,16 +57,16 @@ main (int argc, char *argv[]) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "", - ACE_TRY_ENV); + "" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; - + CORBA::Object_var object = - orb->string_to_object (ior, - ACE_TRY_ENV); + orb->string_to_object (ior + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // To use the smart proxy it is necessary to allocate the @@ -77,28 +77,28 @@ main (int argc, char *argv[]) // proxy designer who now can manage the lifetime of the object // much surely. Smart_Test_Factory *test_factory = 0; - ACE_NEW_RETURN (test_factory, + ACE_NEW_RETURN (test_factory, Smart_Test_Factory, -1); - // To make KAI Compiler happy as it considers <test_factory> to be + // To make KAI Compiler happy as it considers <test_factory> to be // an unused variable. ACE_UNUSED_ARG (test_factory); Test_var server = - Test::_narrow (object.in (), - ACE_TRY_ENV); + Test::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - + if (CORBA::is_nil (server.in ())) ACE_ERROR_RETURN ((LM_ERROR, "Object reference <%s> is nil\n", ior), 1); - + server->method (0); - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } diff --git a/TAO/tests/Smart_Proxies/server.cpp b/TAO/tests/Smart_Proxies/server.cpp index 5f94f63a638..71b28c0ecff 100644 --- a/TAO/tests/Smart_Proxies/server.cpp +++ b/TAO/tests/Smart_Proxies/server.cpp @@ -28,12 +28,12 @@ class Test_i : public POA_Test public: Test_i (CORBA::ORB_ptr orb); - CORBA::Short method (CORBA::Short boo, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Short method (CORBA::Short boo + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, Test::Oops)); - void shutdown (CORBA::Environment &ACE_TRY_ENV) + void shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: @@ -47,8 +47,8 @@ Test_i::Test_i (CORBA::ORB_ptr orb) } CORBA::Short -Test_i :: method (CORBA::Short boo, - CORBA::Environment &ACE_TRY_ENV) +Test_i :: method (CORBA::Short boo + TAO_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException, Test::Oops)) { @@ -62,7 +62,7 @@ Test_i :: method (CORBA::Short boo, } void -Test_i::shutdown (CORBA::Environment &) +Test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->orb_->shutdown (); @@ -98,7 +98,7 @@ parse_args (int argc, char *argv[]) int main (int argc, char *argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { @@ -107,34 +107,34 @@ main (int argc, char *argv[]) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "", - ACE_TRY_ENV); + "" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test_i servant (orb.in ()); // Obtain RootPOA. CORBA::Object_var object = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (object.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the POAManager of the RootPOA. PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Test_var Test_object = - servant._this (ACE_TRY_ENV); + servant._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (Test_object.in (), - ACE_TRY_ENV); + orb->object_to_string (Test_object.in () + TAO_ENV_ARG_PARAMETER); // If the ior_output_file exists, output the ior to it if (ior_output_file != 0) @@ -154,17 +154,17 @@ main (int argc, char *argv[]) ACE_OS::fclose (output_file); } - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); root_poa->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Strategies/client.cpp b/TAO/tests/Strategies/client.cpp index 7b9280c9ec1..ad0a7a6378b 100644 --- a/TAO/tests/Strategies/client.cpp +++ b/TAO/tests/Strategies/client.cpp @@ -67,18 +67,18 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Simple_Server_var server = - Simple_Server::_narrow (object.in (), ACE_TRY_ENV); + Simple_Server::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -91,7 +91,7 @@ main (int argc, char *argv[]) // Invoke a request on the server CORBA::Boolean ret_value = - server->print_status (ACE_TRY_ENV); + server->print_status (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (ret_value == 0) @@ -103,11 +103,11 @@ main (int argc, char *argv[]) if (server_shutdown) { - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Strategies/server.cpp b/TAO/tests/Strategies/server.cpp index 1f73206fca6..47dd25e76ed 100644 --- a/TAO/tests/Strategies/server.cpp +++ b/TAO/tests/Strategies/server.cpp @@ -17,13 +17,13 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -38,11 +38,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -51,11 +51,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -64,40 +64,40 @@ main (int argc, char *argv[]) Simple_Server_i server_impl (orb.in ()); Simple_Server_var server = - server_impl._this (ACE_TRY_ENV); + server_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); // If the ior_output_file exists, output the ior to it if (ior_output_file != 0) - { - FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); - if (output_file == 0) - ACE_ERROR_RETURN ((LM_ERROR, - "Cannot open output file for writing IOR: %s", - ior_output_file), - 1); - ACE_OS::fprintf (output_file, "%s", ior.in ()); - ACE_OS::fclose (output_file); - } - - poa_manager->activate (ACE_TRY_ENV); + { + FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); + if (output_file == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot open output file for writing IOR: %s", + ior_output_file), + 1); + ACE_OS::fprintf (output_file, "%s", ior.in ()); + ACE_OS::fclose (output_file); + } + + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); - root_poa->destroy (1, 1, ACE_TRY_ENV); + root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Strategies/simple_test_i.cpp b/TAO/tests/Strategies/simple_test_i.cpp index e9c74c69fdd..8c9c75ef9b1 100644 --- a/TAO/tests/Strategies/simple_test_i.cpp +++ b/TAO/tests/Strategies/simple_test_i.cpp @@ -10,7 +10,7 @@ ACE_RCSID(tests, simple_test_i, "$Id$") CORBA::Boolean -Simple_Server_i::print_status (CORBA::Environment&) +Simple_Server_i::print_status (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { if (TAO_debug_level > 0) @@ -20,7 +20,7 @@ Simple_Server_i::print_status (CORBA::Environment&) } void -Simple_Server_i::shutdown (CORBA::Environment&) +Simple_Server_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->orb_->shutdown (0); diff --git a/TAO/tests/Strategies/simple_test_i.h b/TAO/tests/Strategies/simple_test_i.h index 95215ae32cd..f58ecb402d5 100644 --- a/TAO/tests/Strategies/simple_test_i.h +++ b/TAO/tests/Strategies/simple_test_i.h @@ -31,10 +31,10 @@ public: // ctor // = The Simple_Server methods. - CORBA::Boolean print_status (CORBA::Environment&) + CORBA::Boolean print_status (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Timed_Buffered_Oneways/client.cpp b/TAO/tests/Timed_Buffered_Oneways/client.cpp index 383e8d62720..ad3665fbd00 100644 --- a/TAO/tests/Timed_Buffered_Oneways/client.cpp +++ b/TAO/tests/Timed_Buffered_Oneways/client.cpp @@ -115,22 +115,22 @@ parse_args (int argc, char **argv) } void -setup_timeouts (CORBA::ORB_ptr orb, - CORBA::Environment &ACE_TRY_ENV) +setup_timeouts (CORBA::ORB_ptr orb + TAO_ENV_ARG_DECL) { // Escape value. if (timeout == -1) return; // Obtain PolicyCurrent. - CORBA::Object_var object = orb->resolve_initial_references ("PolicyCurrent", - ACE_TRY_ENV); + CORBA::Object_var object = orb->resolve_initial_references ("PolicyCurrent" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; // Narrow down to correct type. CORBA::PolicyCurrent_var policy_current = - CORBA::PolicyCurrent::_narrow (object.in (), - ACE_TRY_ENV); + CORBA::PolicyCurrent::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; TimeBase::TimeT rt_timeout = 10000 * timeout; @@ -143,32 +143,32 @@ setup_timeouts (CORBA::ORB_ptr orb, rt_timeout_policy_list[0] = orb->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE, - rt_timeout_any, - ACE_TRY_ENV); + rt_timeout_any + TAO_ENV_ARG_PARAMETER); ACE_CHECK; policy_current->set_policy_overrides (rt_timeout_policy_list, - CORBA::ADD_OVERRIDE, - ACE_TRY_ENV); + CORBA::ADD_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_CHECK; - rt_timeout_policy_list[0]->destroy (ACE_TRY_ENV); + rt_timeout_policy_list[0]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; } void -setup_buffering_constraints (CORBA::ORB_ptr orb, - CORBA::Environment &ACE_TRY_ENV) +setup_buffering_constraints (CORBA::ORB_ptr orb + TAO_ENV_ARG_DECL) { // Obtain PolicyCurrent. - CORBA::Object_var object = orb->resolve_initial_references ("PolicyCurrent", - ACE_TRY_ENV); + CORBA::Object_var object = orb->resolve_initial_references ("PolicyCurrent" + TAO_ENV_ARG_PARAMETER); ACE_CHECK; // Narrow down to correct type. CORBA::PolicyCurrent_var policy_current = - CORBA::PolicyCurrent::_narrow (object.in (), - ACE_TRY_ENV); + CORBA::PolicyCurrent::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_CHECK; // Setup the sync scope policy, i.e., the ORB will buffer oneways. @@ -186,18 +186,18 @@ setup_buffering_constraints (CORBA::ORB_ptr orb, // Setup the sync scope policy. sync_policy_list[0] = orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE, - sync_any, - ACE_TRY_ENV); + sync_any + TAO_ENV_ARG_PARAMETER); ACE_CHECK; // Setup the sync scope. policy_current->set_policy_overrides (sync_policy_list, - CORBA::ADD_OVERRIDE, - ACE_TRY_ENV); + CORBA::ADD_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_CHECK; // We are now done with this policy. - sync_policy_list[0]->destroy (ACE_TRY_ENV); + sync_policy_list[0]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; // Flush buffers. @@ -218,25 +218,25 @@ setup_buffering_constraints (CORBA::ORB_ptr orb, // Setup the buffering constraint policy. buffering_constraint_policy_list[0] = orb->create_policy (TAO::BUFFERING_CONSTRAINT_POLICY_TYPE, - buffering_constraint_any, - ACE_TRY_ENV); + buffering_constraint_any + TAO_ENV_ARG_PARAMETER); ACE_CHECK; // Setup the constraints. policy_current->set_policy_overrides (buffering_constraint_policy_list, - CORBA::ADD_OVERRIDE, - ACE_TRY_ENV); + CORBA::ADD_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_CHECK; // We are done with the policy. - buffering_constraint_policy_list[0]->destroy (ACE_TRY_ENV); + buffering_constraint_policy_list[0]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; } int main (int argc, char **argv) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { @@ -244,8 +244,8 @@ main (int argc, char **argv) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - 0, - ACE_TRY_ENV); + 0 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Initialize options based on command-line arguments. @@ -255,23 +255,23 @@ main (int argc, char **argv) // Get an object reference from the argument string. CORBA::Object_var object = - orb->string_to_object (IOR, - ACE_TRY_ENV); + orb->string_to_object (IOR + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Try to narrow the object reference to a <test> reference. - test_var test_object = test::_narrow (object.in (), - ACE_TRY_ENV); + test_var test_object = test::_narrow (object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Setup buffering. - setup_buffering_constraints (orb.in (), - ACE_TRY_ENV); + setup_buffering_constraints (orb.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Setup timeout. - setup_timeouts (orb.in (), - ACE_TRY_ENV); + setup_timeouts (orb.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; test::data the_data (data_bytes); @@ -286,8 +286,8 @@ main (int argc, char **argv) // Invoke the oneway method. test_object->method (i, the_data, - work, - ACE_TRY_ENV); + work + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Interval between successive calls. @@ -300,7 +300,7 @@ main (int argc, char **argv) // Shutdown server. if (shutdown_server) { - test_object->shutdown (ACE_TRY_ENV); + test_object->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -310,7 +310,7 @@ main (int argc, char **argv) // static destructors to flush the queues, it will be too late. // Therefore, we use explicit destruction here and flush the // queues before main() ends. - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Timed_Buffered_Oneways/server.cpp b/TAO/tests/Timed_Buffered_Oneways/server.cpp index b84f0bc46a3..6607db33fdc 100644 --- a/TAO/tests/Timed_Buffered_Oneways/server.cpp +++ b/TAO/tests/Timed_Buffered_Oneways/server.cpp @@ -41,22 +41,22 @@ main (int argc, char *argv[]) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "", - ACE_TRY_ENV); + "" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references ("RootPOA", - ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), - ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -65,12 +65,12 @@ main (int argc, char *argv[]) test_i servant (orb.in ()); test_var server = - servant._this (ACE_TRY_ENV); + servant._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (server.in (), - ACE_TRY_ENV); + orb->object_to_string (server.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); @@ -84,17 +84,17 @@ main (int argc, char *argv[]) ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); root_poa->destroy (1, - 1, - ACE_TRY_ENV); + 1 + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Timed_Buffered_Oneways/test_i.cpp b/TAO/tests/Timed_Buffered_Oneways/test_i.cpp index b29dbf3fedf..ae78c1de3e6 100644 --- a/TAO/tests/Timed_Buffered_Oneways/test_i.cpp +++ b/TAO/tests/Timed_Buffered_Oneways/test_i.cpp @@ -12,8 +12,8 @@ test_i::test_i (CORBA::ORB_ptr orb) void test_i::method (CORBA::ULong request_number, const test::data &, - CORBA::ULong work, - CORBA::Environment &) + CORBA::ULong work + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -29,9 +29,9 @@ test_i::method (CORBA::ULong request_number, } void -test_i::shutdown (CORBA::Environment &ACE_TRY_ENV) +test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0, - ACE_TRY_ENV); + this->orb_->shutdown (0 + TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/Timed_Buffered_Oneways/test_i.h b/TAO/tests/Timed_Buffered_Oneways/test_i.h index 5bf704ff3de..06723f6b263 100644 --- a/TAO/tests/Timed_Buffered_Oneways/test_i.h +++ b/TAO/tests/Timed_Buffered_Oneways/test_i.h @@ -30,11 +30,11 @@ public: // = The test interface methods. void method (CORBA::ULong request_number, const test::data &, - CORBA::ULong work, - CORBA::Environment &) + CORBA::ULong work + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment &) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Timeout/client.cpp b/TAO/tests/Timeout/client.cpp index b19f30c2f42..dc5416aceeb 100644 --- a/TAO/tests/Timeout/client.cpp +++ b/TAO/tests/Timeout/client.cpp @@ -53,12 +53,12 @@ static int in_time_count = 0; void send_echo (CORBA::ORB_ptr orb, Simple_Server_ptr server, - CORBA::Long t, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Long t + TAO_ENV_ARG_DECL) { ACE_TRY { - server->echo (0, t, ACE_TRY_ENV); + server->echo (0, t TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; in_time_count++; @@ -76,7 +76,7 @@ send_echo (CORBA::ORB_ptr orb, (max_timeout % 1000) * 1000); // This is a non-standard TAO call. - orb->run (tv, ACE_TRY_ENV); + orb->run (tv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_ENDTRY; @@ -88,18 +88,18 @@ int main (int argc, char* argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = - orb->string_to_object (ior, ACE_TRY_ENV); + orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Simple_Server_var server = - Simple_Server::_narrow (object.in (), ACE_TRY_ENV); + Simple_Server::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -111,21 +111,21 @@ int main (int argc, char* argv[]) } object = - orb->resolve_initial_references ("ORBPolicyManager", - ACE_TRY_ENV); + orb->resolve_initial_references ("ORBPolicyManager" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyManager_var policy_manager = - CORBA::PolicyManager::_narrow (object.in (), ACE_TRY_ENV); + CORBA::PolicyManager::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; object = - orb->resolve_initial_references ("PolicyCurrent", - ACE_TRY_ENV); + orb->resolve_initial_references ("PolicyCurrent" + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyCurrent_var policy_current = - CORBA::PolicyCurrent::_narrow (object.in (), ACE_TRY_ENV); + CORBA::PolicyCurrent::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; TimeBase::TimeT mid_value = @@ -142,20 +142,20 @@ int main (int argc, char* argv[]) policy_list.length (1); policy_list[0] = orb->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE, - any_object, - ACE_TRY_ENV); + any_object + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; object = server->_set_policy_overrides (policy_list, - CORBA::SET_OVERRIDE, - ACE_TRY_ENV); + CORBA::SET_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Simple_Server_var timeout_server = - Simple_Server::_narrow (object.in (), ACE_TRY_ENV); + Simple_Server::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - policy_list[0]->destroy (ACE_TRY_ENV); + policy_list[0]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; policy_list[0] = CORBA::Policy::_nil (); @@ -174,15 +174,15 @@ int main (int argc, char* argv[]) policy_list.length (0); policy_manager->set_policy_overrides (policy_list, - CORBA::SET_OVERRIDE, - ACE_TRY_ENV); + CORBA::SET_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; policy_current->set_policy_overrides (policy_list, - CORBA::SET_OVERRIDE, - ACE_TRY_ENV); + CORBA::SET_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - send_echo (orb.in (), server.in (), t, ACE_TRY_ENV); + send_echo (orb.in (), server.in (), t TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // ACE_DEBUG ((LM_DEBUG, @@ -191,19 +191,19 @@ int main (int argc, char* argv[]) policy_list.length (1); policy_list[0] = orb->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE, - any_orb, - ACE_TRY_ENV); + any_orb + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; policy_manager->set_policy_overrides (policy_list, - CORBA::SET_OVERRIDE, - ACE_TRY_ENV); + CORBA::SET_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - send_echo (orb.in (), server.in (), t, ACE_TRY_ENV); + send_echo (orb.in (), server.in (), t TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - policy_list[0]->destroy (ACE_TRY_ENV); + policy_list[0]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // ACE_DEBUG ((LM_DEBUG, @@ -212,24 +212,24 @@ int main (int argc, char* argv[]) policy_list.length (1); policy_list[0] = orb->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE, - any_thread, - ACE_TRY_ENV); + any_thread + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; policy_current->set_policy_overrides (policy_list, - CORBA::SET_OVERRIDE, - ACE_TRY_ENV); + CORBA::SET_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - send_echo (orb.in (), server.in (), t, ACE_TRY_ENV); + send_echo (orb.in (), server.in (), t TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - policy_list[0]->destroy (ACE_TRY_ENV); + policy_list[0]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // ACE_DEBUG ((LM_DEBUG, // "client(%P) Use the object policies\n")); - send_echo (orb.in (), timeout_server.in (), t, ACE_TRY_ENV); + send_echo (orb.in (), timeout_server.in (), t TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -238,18 +238,18 @@ int main (int argc, char* argv[]) // "resynch with server\n")); policy_list.length (0); policy_manager->set_policy_overrides (policy_list, - CORBA::SET_OVERRIDE, - ACE_TRY_ENV); + CORBA::SET_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; policy_current->set_policy_overrides (policy_list, - CORBA::SET_OVERRIDE, - ACE_TRY_ENV); + CORBA::SET_OVERRIDE + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - send_echo (orb.in (), server.in (), 0, ACE_TRY_ENV); + send_echo (orb.in (), server.in (), 0 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - server->shutdown (ACE_TRY_ENV); + server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (timeout_count == 0) @@ -263,7 +263,7 @@ int main (int argc, char* argv[]) ACE_DEBUG ((LM_DEBUG, "In time = %d, timed out = %d\n", in_time_count, timeout_count)); - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Timeout/server.cpp b/TAO/tests/Timeout/server.cpp index acdf5ddacbd..c79786c701e 100644 --- a/TAO/tests/Timeout/server.cpp +++ b/TAO/tests/Timeout/server.cpp @@ -17,14 +17,14 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -40,14 +40,14 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -56,42 +56,42 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Simple_Server_i server_impl (orb.in ()); Simple_Server_var server = - server_impl._this (ACE_TRY_ENV); + server_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); // If the ior_output_file exists, output the ior to it if (ior_output_file != 0) - { - FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); - if (output_file == 0) - ACE_ERROR_RETURN ((LM_ERROR, - "Cannot open output file for writing IOR: %s", - ior_output_file), - 1); - ACE_OS::fprintf (output_file, "%s", ior.in ()); - ACE_OS::fclose (output_file); - } - - poa_manager->activate (ACE_TRY_ENV); + { + FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); + if (output_file == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot open output file for writing IOR: %s", + ior_output_file), + 1); + ACE_OS::fprintf (output_file, "%s", ior.in ()); + ACE_OS::fclose (output_file); + } + + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); @@ -99,7 +99,7 @@ main (int argc, char *argv[]) ACE_CATCHANY { ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Catched exception:"); + "Caught exception:"); return 1; } ACE_ENDTRY; diff --git a/TAO/tests/Timeout/test_i.cpp b/TAO/tests/Timeout/test_i.cpp index f51c48e0ad7..bbf564047ba 100644 --- a/TAO/tests/Timeout/test_i.cpp +++ b/TAO/tests/Timeout/test_i.cpp @@ -16,8 +16,8 @@ Simple_Server_i::Simple_Server_i (CORBA::ORB_ptr orb) CORBA::Long Simple_Server_i::echo (CORBA::Long x, - CORBA::Long msecs, - CORBA::Environment&) + CORBA::Long msecs + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_Time_Value tv (msecs / 1000, (msecs % 1000) * 1000); @@ -30,10 +30,10 @@ Simple_Server_i::echo (CORBA::Long x, } void -Simple_Server_i::shutdown (CORBA::Environment& ACE_TRY_ENV) +Simple_Server_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, "server (%P) Received shutdown request from client\n")); - this->orb_->shutdown (0, ACE_TRY_ENV); + this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); } diff --git a/TAO/tests/Timeout/test_i.h b/TAO/tests/Timeout/test_i.h index 74a62f9800a..fcc74c77fab 100644 --- a/TAO/tests/Timeout/test_i.h +++ b/TAO/tests/Timeout/test_i.h @@ -32,10 +32,10 @@ public: // = The Simple_Server methods. CORBA::Long echo (CORBA::Long x, - CORBA::Long msecs, - CORBA::Environment&) + CORBA::Long msecs + TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/Xt_Stopwatch/Client.h b/TAO/tests/Xt_Stopwatch/Client.h index 983eecd6295..0d116185253 100644 --- a/TAO/tests/Xt_Stopwatch/Client.h +++ b/TAO/tests/Xt_Stopwatch/Client.h @@ -48,8 +48,8 @@ public: void add_callback (Control &); // Adds the callbacks to the GUI underneath..... - void parse_args (int argc, char *argv[], - CORBA::Environment &ACE_TRY_ENV); + void parse_args (int argc, char *argv[] + TAO_ENV_ARG_DECL); private: CORBA::ORB_var orb_; diff --git a/TAO/tests/Xt_Stopwatch/Control.cpp b/TAO/tests/Xt_Stopwatch/Control.cpp index 755765b0073..9e7745c2f24 100644 --- a/TAO/tests/Xt_Stopwatch/Control.cpp +++ b/TAO/tests/Xt_Stopwatch/Control.cpp @@ -1,4 +1,5 @@ // $Id$ + #include "Control.h" #if defined (ACE_HAS_XT) diff --git a/TAO/tests/Xt_Stopwatch/client.cpp b/TAO/tests/Xt_Stopwatch/client.cpp index 2c513e36a9c..b81d13c6c98 100644 --- a/TAO/tests/Xt_Stopwatch/client.cpp +++ b/TAO/tests/Xt_Stopwatch/client.cpp @@ -7,7 +7,7 @@ ACE_RCSID(Xt_Stopwatch, client, "$Id$") #if !defined (ACE_HAS_XT) -int +int main (int, char *[]) { ACE_ERROR ((LM_INFO, @@ -38,17 +38,17 @@ main (int argc, char *argv[]) Control control (toplevel); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Client client (orb.in ()); - client.parse_args (argc, argv, ACE_TRY_ENV); + client.parse_args (argc, argv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; client.add_callback (control); @@ -60,7 +60,7 @@ main (int argc, char *argv[]) } ACE_CATCHANY { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Catched exception:"); + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Caught exception:"); return 1; } ACE_ENDTRY; @@ -78,8 +78,8 @@ Client::~Client (void) void Client::parse_args (int argc, - char *argv[], - CORBA::Environment &ACE_TRY_ENV) + char *argv[] + TAO_ENV_ARG_DECL) { const char *ior = "file://test.ior"; @@ -102,11 +102,11 @@ Client::parse_args (int argc, } CORBA::Object_var object = - this->orb_->string_to_object (ior, ACE_TRY_ENV); + this->orb_->string_to_object (ior TAO_ENV_ARG_PARAMETER); ACE_CHECK; this->server_ = - Stopwatch::_narrow (object.in (), ACE_TRY_ENV); + Stopwatch::_narrow (object.in () TAO_ENV_ARG_PARAMETER); ACE_CHECK; if (CORBA::is_nil(this->server_.in ())) @@ -157,10 +157,10 @@ Client::stop_callback (Widget /*widget*/, void Client::start_hook (void) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { - this->server_->start (ACE_TRY_ENV); + this->server_->start (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -175,10 +175,10 @@ Client::start_hook (void) void Client::stop_hook (void) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { - this->server_->stop (ACE_TRY_ENV); + this->server_->stop (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/tests/Xt_Stopwatch/server.cpp b/TAO/tests/Xt_Stopwatch/server.cpp index e7c69d49af1..0086ad471bd 100644 --- a/TAO/tests/Xt_Stopwatch/server.cpp +++ b/TAO/tests/Xt_Stopwatch/server.cpp @@ -7,7 +7,7 @@ ACE_RCSID(Xt_Stopwatch, server, "$Id$") #if !defined (ACE_HAS_XT) -int +int main (int, char *[]) { ACE_ERROR ((LM_INFO, @@ -34,14 +34,14 @@ parse_args (int argc, char *argv[]) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile>" "\n", argv [0]), -1); @@ -72,16 +72,16 @@ main (int argc, char *argv[]) Stopwatch_display stopwatch (toplevel); - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -90,26 +90,26 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (ACE_TRY_ENV); + root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; stopwatch.manage (); - // Make a timer class + // Make a timer class Timer_imp timer (app, 100, &stopwatch); Stopwatch_imp server_impl (orb.in (), &timer); Stopwatch_var server = - server_impl._this (ACE_TRY_ENV); + server_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (server.in (), ACE_TRY_ENV); + orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); @@ -117,26 +117,26 @@ main (int argc, char *argv[]) // If the ior_output_file exists, output the ior to it if (ior_output_file != 0) { - FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); - if (output_file == 0) - ACE_ERROR_RETURN ((LM_ERROR, - "Cannot open output file for writing IOR: %s", - ior_output_file), - 1); - ACE_OS::fprintf (output_file, "%s", ior.in ()); - ACE_OS::fclose (output_file); + FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); + if (output_file == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot open output file for writing IOR: %s", + ior_output_file), + 1); + ACE_OS::fprintf (output_file, "%s", ior.in ()); + ACE_OS::fclose (output_file); } - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - + XtRealizeWidget (toplevel); XtAppMainLoop (app); } ACE_CATCHANY { ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "Catched exception:"); + "Caught exception:"); return 1; } ACE_ENDTRY; diff --git a/TAO/tests/Xt_Stopwatch/test_i.cpp b/TAO/tests/Xt_Stopwatch/test_i.cpp index 21acce664fb..4b42f8473db 100644 --- a/TAO/tests/Xt_Stopwatch/test_i.cpp +++ b/TAO/tests/Xt_Stopwatch/test_i.cpp @@ -17,21 +17,21 @@ Stopwatch_imp::Stopwatch_imp (CORBA::ORB_ptr orb, Timer_imp *timer) } void -Stopwatch_imp::start (CORBA::Environment&) +Stopwatch_imp::start (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->timer_->start (); } void -Stopwatch_imp::stop (CORBA::Environment&) +Stopwatch_imp::stop (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->timer_->stop (); } void -Stopwatch_imp::shutdown (CORBA::Environment&) +Stopwatch_imp::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->orb_->shutdown (0); diff --git a/TAO/tests/Xt_Stopwatch/test_i.h b/TAO/tests/Xt_Stopwatch/test_i.h index e3faf1830d1..550d3c2390d 100644 --- a/TAO/tests/Xt_Stopwatch/test_i.h +++ b/TAO/tests/Xt_Stopwatch/test_i.h @@ -34,13 +34,13 @@ public: // ctor // = The Simple_Server methods. - void start (CORBA::Environment&) + void start (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void stop (CORBA::Environment&) + void stop (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (CORBA::Environment&) + void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/tests/ior_corbaloc/client.cpp b/TAO/tests/ior_corbaloc/client.cpp index a3acd04fbeb..1fec9b81a41 100644 --- a/TAO/tests/ior_corbaloc/client.cpp +++ b/TAO/tests/ior_corbaloc/client.cpp @@ -24,7 +24,7 @@ int main (int argc, char *argv []) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { @@ -32,12 +32,12 @@ int main (int argc, char *argv []) IOR_corbaloc_Client_i client; int init_result; - init_result = client.init (argc, argv, ACE_TRY_ENV); + init_result = client.init (argc, argv TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (init_result == 0) { - client.run (ACE_TRY_ENV); + client.run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } return 0; diff --git a/TAO/tests/ior_corbaloc/corbaname_client.cpp b/TAO/tests/ior_corbaloc/corbaname_client.cpp index 9f9335fe7a4..c240ebce76a 100644 --- a/TAO/tests/ior_corbaloc/corbaname_client.cpp +++ b/TAO/tests/ior_corbaloc/corbaname_client.cpp @@ -18,7 +18,7 @@ int main (int argc, char *argv []) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { @@ -26,39 +26,39 @@ int main (int argc, char *argv []) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "" /* the ORB name, it can be anything! */, - ACE_TRY_ENV); + "" /* the ORB name, it can be anything! */ + TAO_ENV_ARG_PARAMETER); if(argc < 2 ) - { - ACE_ERROR_RETURN((LM_ERROR, + { + ACE_ERROR_RETURN((LM_ERROR, "Usage:\n %s [corbaname URL]\n", - argv[0]), + argv[0]), 1); - } - + } + // Get an object reference using a corbaname: style URL CORBA::Object_var obj = - orb->string_to_object (argv[1], - ACE_TRY_ENV); + orb->string_to_object (argv[1] + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Narrow corbaloc::Status_var factory = - corbaloc::Status::_narrow (obj.in (), ACE_TRY_ENV); + corbaloc::Status::_narrow (obj.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (factory.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "ERROR: Object reference <%s> is nil\n", - argv[1]), + argv[1]), -1); } // Invoke a request on the server CORBA::Boolean ret_value = - factory->print_status (ACE_TRY_ENV); + factory->print_status (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (ret_value != 0) @@ -66,7 +66,7 @@ int main (int argc, char *argv []) ACE_DEBUG ((LM_DEBUG, "The server has not been contacted. Error!!\n", 0)); - } + } return 0; } diff --git a/TAO/tests/ior_corbaloc/ior_corbaloc_client_i.cpp b/TAO/tests/ior_corbaloc/ior_corbaloc_client_i.cpp index 4e0a2a56dea..7b81ae125a2 100644 --- a/TAO/tests/ior_corbaloc/ior_corbaloc_client_i.cpp +++ b/TAO/tests/ior_corbaloc/ior_corbaloc_client_i.cpp @@ -33,7 +33,7 @@ IOR_corbaloc_Client_i::~IOR_corbaloc_Client_i (void) } int -IOR_corbaloc_Client_i::run (CORBA::Environment &ACE_TRY_ENV) +IOR_corbaloc_Client_i::run (TAO_ENV_SINGLE_ARG_DECL) { ACE_TRY @@ -45,13 +45,13 @@ IOR_corbaloc_Client_i::run (CORBA::Environment &ACE_TRY_ENV) // Resolve the name CORBA::Object_var factory_object = - this->naming_context_->resolve (name, - ACE_TRY_ENV); + this->naming_context_->resolve (name TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Narrow corbaloc::Status_var factory = - corbaloc::Status::_narrow (factory_object.in (), ACE_TRY_ENV); + corbaloc::Status::_narrow (factory_object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (factory.in ())) @@ -64,7 +64,7 @@ IOR_corbaloc_Client_i::run (CORBA::Environment &ACE_TRY_ENV) // Invoke a request on the server CORBA::Boolean ret_value = - factory->print_status (ACE_TRY_ENV); + factory->print_status (TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (ret_value != 0) @@ -72,7 +72,7 @@ IOR_corbaloc_Client_i::run (CORBA::Environment &ACE_TRY_ENV) ACE_DEBUG ((LM_DEBUG, "The server has not been contacted. Error!!\n", 0)); - } + } } ACE_CATCH (CosNaming::NamingContext::NotFound, ex) { @@ -94,8 +94,8 @@ IOR_corbaloc_Client_i::run (CORBA::Environment &ACE_TRY_ENV) int IOR_corbaloc_Client_i::init (int& argc, - char *argv[], - CORBA::Environment &ACE_TRY_ENV) + char *argv[] + TAO_ENV_ARG_DECL) { ACE_TRY @@ -105,20 +105,20 @@ IOR_corbaloc_Client_i::init (int& argc, CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "" /* the ORB name, it can be anything! */, - ACE_TRY_ENV); + "" /* the ORB name, it can be anything! */ + TAO_ENV_ARG_PARAMETER); if(argc < 2){ - ACE_DEBUG((LM_DEBUG, "\nUsage:\n %s [corbaloc URL for NameService]\n", argv[0])); - ACE_OS::exit(-1); + ACE_DEBUG((LM_DEBUG, "\nUsage:\n %s [corbaloc URL for NameService]\n", argv[0])); + ACE_OS::exit(-1); } corbaloc_url_ = argv[1]; // Get a reference to the Naming Service CORBA::Object_var naming_context_object = - orb->string_to_object (corbaloc_url_.c_str(), - ACE_TRY_ENV); + orb->string_to_object (corbaloc_url_.c_str() + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (naming_context_object.in ())) @@ -128,8 +128,8 @@ IOR_corbaloc_Client_i::init (int& argc, // Narrow to get the correct reference this->naming_context_ = - CosNaming::NamingContextExt::_narrow (naming_context_object.in (), - ACE_TRY_ENV); + CosNaming::NamingContextExt::_narrow (naming_context_object.in () + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (this->naming_context_.in ())) diff --git a/TAO/tests/ior_corbaloc/ior_corbaloc_client_i.h b/TAO/tests/ior_corbaloc/ior_corbaloc_client_i.h index 246167e39a3..f785eb1dd80 100644 --- a/TAO/tests/ior_corbaloc/ior_corbaloc_client_i.h +++ b/TAO/tests/ior_corbaloc/ior_corbaloc_client_i.h @@ -35,14 +35,14 @@ class IOR_corbaloc_Client_i // public: - // = COnstructor and destructor. + // = Constructor and destructor. IOR_corbaloc_Client_i (void); ~IOR_corbaloc_Client_i (void); - int run (CORBA::Environment &ACE_TRY_ENV); + int run (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS); // Execute the client example code. - int init (int& argc, char *argv[], CORBA::Environment &ACE_TRY_ENV); + int init (int& argc, char *argv[] TAO_ENV_ARG_DECL_WITH_DEFAULTS); // Initialize the client communication endpoint with the server. private: diff --git a/TAO/tests/ior_corbaloc/server.cpp b/TAO/tests/ior_corbaloc/server.cpp index 68a9f5a19bb..8dfc85c305b 100644 --- a/TAO/tests/ior_corbaloc/server.cpp +++ b/TAO/tests/ior_corbaloc/server.cpp @@ -10,15 +10,15 @@ int main (int argc, char* argv[]) { - ACE_DECLARE_NEW_CORBA_ENV; + TAO_ENV_DECLARE_NEW_ENV; ACE_TRY { // First initialize the ORB, that will remove some arguments... CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, - "" /* the ORB name, it can be anything! */, - ACE_TRY_ENV); + "" /* the ORB name, it can be anything! */ + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if(argc < 2){ @@ -27,21 +27,21 @@ int main (int argc, char* argv[]) } // Get a reference to the RootPOA CORBA::Object_var poa_object = - orb->resolve_initial_references ("RootPOA", ACE_TRY_ENV); + orb->resolve_initial_references ("RootPOA" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // narrow down to the correct reference PortableServer::POA_var poa = - PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Set a POA Manager PortableServer::POAManager_var poa_manager = - poa->the_POAManager (ACE_TRY_ENV); + poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Activate the POA Manager - poa_manager->activate (ACE_TRY_ENV); + poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Create the servant @@ -54,13 +54,13 @@ int main (int argc, char* argv[]) // Get a reference to Naming Context CORBA::Object_var naming_context_object = - orb->resolve_initial_references ("NameService", ACE_TRY_ENV); + orb->resolve_initial_references ("NameService" TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Narrow down the reference CosNaming::NamingContext_var naming_context = - CosNaming::NamingContext::_narrow (naming_context_object.in(), - ACE_TRY_ENV); + CosNaming::NamingContext::_narrow (naming_context_object.in() + TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Bind Iterator_Factory to the Naming Context @@ -72,13 +72,13 @@ int main (int argc, char* argv[]) ACE_TRY_CHECK; // Run the orb - orb->run (ACE_TRY_ENV); + orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Destroy the POA, waiting until the destruction terminates - poa->destroy (1, 1, ACE_TRY_ENV); + poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (ACE_TRY_ENV); + orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (CORBA::SystemException, ex) { @@ -86,7 +86,7 @@ int main (int argc, char* argv[]) } ACE_CATCHANY { ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught in server"); - } + } ACE_ENDTRY; ACE_CHECK_RETURN (-1); diff --git a/TAO/tests/ior_corbaloc/status_i.cpp b/TAO/tests/ior_corbaloc/status_i.cpp index e80af02f9ae..d645e7c0170 100644 --- a/TAO/tests/ior_corbaloc/status_i.cpp +++ b/TAO/tests/ior_corbaloc/status_i.cpp @@ -2,14 +2,14 @@ #include "status_i.h" -corbaloc_Status_i::corbaloc_Status_i (CORBA::Environment &) - : server_name_() +corbaloc_Status_i::corbaloc_Status_i (TAO_ENV_ARG_DECL_NOT_USED) + : server_name_() { // Constructor } CORBA::Boolean -corbaloc_Status_i::print_status (CORBA::Environment &) +corbaloc_Status_i::print_status (TAO_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { @@ -17,7 +17,7 @@ corbaloc_Status_i::print_status (CORBA::Environment &) // return true == 0; ACE_DEBUG((LM_DEBUG, "Invoking print_status() method for servant with name: %s\nregistered in Naming Service\n", - - server_name_.c_str() )); + + server_name_.c_str() )); return 0; } diff --git a/TAO/tests/ior_corbaloc/status_i.h b/TAO/tests/ior_corbaloc/status_i.h index dfdbc403099..cc197646643 100644 --- a/TAO/tests/ior_corbaloc/status_i.h +++ b/TAO/tests/ior_corbaloc/status_i.h @@ -9,13 +9,12 @@ class corbaloc_Status_i : public POA_corbaloc::Status { public: - corbaloc_Status_i (CORBA::Environment & = - TAO_default_environment()); + corbaloc_Status_i (TAO_ENV_ARG_DECL_WITH_DEFAULTS); - CORBA::Boolean print_status (CORBA::Environment & = TAO_default_environment()) + CORBA::Boolean print_status (TAO_ENV_ARG_DECL_WITH_DEFAULTS) throw (CORBA::SystemException); - void set_name(const char *name){ server_name_=name; } + void set_name(const char *name){ server_name_=name; } private: ACE_CString server_name_; |