ChangeLogTag:Tue Jan 29 21:09:12 2002 Oliver Kellogg <oliver.kellogg@sysde.eads.net>

7 files changed, 66 insertions, 66 deletions

diff --git a/TAO/orbsvcs/tests/Concurrency/CC_client.cpp b/TAO/orbsvcs/tests/Concurrency/CC_client.cpp
index 66be6ea80a1..10037b9b448 100644
--- a/TAO/orbsvcs/tests/Concurrency/CC_client.cpp
+++ b/TAO/orbsvcs/tests/Concurrency/CC_client.cpp
@@ -357,14 +357,14 @@ CC_Client::print_usage (void)
 int
 CC_Client::init_naming_service (void)
 {
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
       ACE_NEW_RETURN (naming_service_,
                       CC_naming_service,
                       -1);
 
-      this->naming_service_->Init (this->orb_ TAO_ENV_ARG_PARAMETER);
+      this->naming_service_->Init (this->orb_ ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -382,14 +382,14 @@ CC_Client::init (int argc, char **argv)
   this->argc_ = argc;
   this->argv_ = argv;
 
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
       // Retrieve the ORB.
       this->orb_ = CORBA::ORB_init (this->argc_,
                                     this->argv_,
                                     "internet"
-                                    TAO_ENV_ARG_PARAMETER);
+                                    ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       // Parse command line and verify parameters.
@@ -413,14 +413,14 @@ CC_Client::init (int argc, char **argv)
 
           CORBA::Object_var factory_object =
             this->orb_->string_to_object (this->cc_factory_key_
-                                          TAO_ENV_ARG_PARAMETER);
+                                          ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
 #if 0
           // The test cannot currently run without the naming service.
           this->factory_ =
             CosConcurrencyControl::LockSetFactory::_narrow
-            (factory_object.in () TAO_ENV_ARG_PARAMETER);
+            (factory_object.in () ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           if (CORBA::is_nil (this->factory_.in ()))
diff --git a/TAO/orbsvcs/tests/Concurrency/CC_command.cpp b/TAO/orbsvcs/tests/Concurrency/CC_command.cpp
index 3023e65b043..541d04b0eea 100644
--- a/TAO/orbsvcs/tests/Concurrency/CC_command.cpp
+++ b/TAO/orbsvcs/tests/Concurrency/CC_command.cpp
@@ -41,7 +41,7 @@ CC_Command::CC_Command(void)
 
 CosConcurrencyControl::LockSet_var
 CC_Command::GetLockSet (const char *lock_set_name
-                        TAO_ENV_ARG_DECL)
+                        ACE_ENV_ARG_DECL)
 {
   CosConcurrencyControl::LockSet_var ccls_ret;
 
@@ -52,12 +52,12 @@ CC_Command::GetLockSet (const char *lock_set_name
           CORBA::Object_var ccls_obj =
             CC_naming_service::Instance()->get_obj_from_name ("",
                                                               lock_set_name
-                                                              TAO_ENV_ARG_PARAMETER);
+                                                              ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           ccls_ret =
             CosConcurrencyControl::LockSet::_narrow (ccls_obj.in ()
-                                                     TAO_ENV_ARG_PARAMETER);
+                                                     ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
         }
       else
@@ -160,7 +160,7 @@ int CC_CreateLockSet_Cmd::execute(void)
 
   printf("Executing create command (lock set: %s)\n", name_);
 
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
       CosConcurrencyControl::LockSet_ptr lock_set =
@@ -168,7 +168,7 @@ int CC_CreateLockSet_Cmd::execute(void)
       if(ACE_OS::strcmp(name_,"")!=0)// Do not bind an empty name
         {
           CC_naming_service::Instance()->bind_name(name_,
-                                                   lock_set TAO_ENV_ARG_PARAMETER);
+                                                   lock_set ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
         }
       else
@@ -214,14 +214,14 @@ int CC_Lock_Cmd::execute(void)
   printf("Executing lock command (lock set: %s, mode: %s)\n",
          name_, CC_TestUtils::get_lock_mode_name(mode_));
 
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
       CosConcurrencyControl::LockSet_var ccls =
-        GetLockSet(name_ TAO_ENV_ARG_PARAMETER);
+        GetLockSet(name_ ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
       ccls->lock (mode_
-                  TAO_ENV_ARG_PARAMETER);
+                  ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -261,14 +261,14 @@ int CC_UnLock_Cmd::execute(void)
   printf("Executing unlock command (lock set: %s, mode: %s)\n",
          name_, CC_TestUtils::get_lock_mode_name(mode_));
 
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
-      CosConcurrencyControl::LockSet_var ccls = GetLockSet(name_ TAO_ENV_ARG_PARAMETER);
+      CosConcurrencyControl::LockSet_var ccls = GetLockSet(name_ ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       ccls->unlock (mode_
-                    TAO_ENV_ARG_PARAMETER);
+                    ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
     }
@@ -311,14 +311,14 @@ int CC_TryLock_Cmd::execute(void)
 
   CORBA::Boolean lock_not_held;
 
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
-      CosConcurrencyControl::LockSet_var ccls = GetLockSet(name_ TAO_ENV_ARG_PARAMETER);
+      CosConcurrencyControl::LockSet_var ccls = GetLockSet(name_ ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       lock_not_held = ccls->try_lock (mode_
-                                      TAO_ENV_ARG_PARAMETER);
+                                      ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (lock_not_held)
@@ -376,14 +376,14 @@ int CC_ChangeMode_Cmd::execute(void)
          name_, CC_TestUtils::get_lock_mode_name(held_mode_),
          CC_TestUtils::get_lock_mode_name(new_mode_));
 
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
-      CosConcurrencyControl::LockSet_var ccls = GetLockSet(name_ TAO_ENV_ARG_PARAMETER);
+      CosConcurrencyControl::LockSet_var ccls = GetLockSet(name_ ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       ccls->change_mode (held_mode_, new_mode_
-                    TAO_ENV_ARG_PARAMETER);
+                    ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
     }
@@ -570,18 +570,18 @@ CC_Lookup_Cmd::execute(void)
   // Do the lookup if we haven't done it before
   if(cc_lockset_.in() == 0)
     {
-      TAO_ENV_DECLARE_NEW_ENV;
+      ACE_DECLARE_NEW_CORBA_ENV;
       ACE_TRY
         {
           CORBA::Object_var ccls_obj =
             CC_naming_service::Instance()->get_obj_from_name ("",
                                                               name_
-                                                              TAO_ENV_ARG_PARAMETER);
+                                                              ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           CosConcurrencyControl::LockSet_var ccls =
             CosConcurrencyControl::LockSet::_narrow (ccls_obj.in ()
-                                                     TAO_ENV_ARG_PARAMETER);
+                                                     ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           cc_lockset_ = ccls;
diff --git a/TAO/orbsvcs/tests/Concurrency/CC_command.h b/TAO/orbsvcs/tests/Concurrency/CC_command.h
index 0d075725d06..735d38d7c21 100644
--- a/TAO/orbsvcs/tests/Concurrency/CC_command.h
+++ b/TAO/orbsvcs/tests/Concurrency/CC_command.h
@@ -45,7 +45,7 @@ class CC_Command
  protected:
   CosConcurrencyControl::LockSet_var
     GetLockSet (const char *lock_set_name
-                TAO_ENV_ARG_DECL);
+                ACE_ENV_ARG_DECL);
   // Function to look up the lock set we are operating on, or if the
   // name is "" return the global lock set variable
 
diff --git a/TAO/orbsvcs/tests/Concurrency/CC_naming_service.cpp b/TAO/orbsvcs/tests/Concurrency/CC_naming_service.cpp
index 7333698f6b6..48dc3110cdf 100644
--- a/TAO/orbsvcs/tests/Concurrency/CC_naming_service.cpp
+++ b/TAO/orbsvcs/tests/Concurrency/CC_naming_service.cpp
@@ -22,12 +22,12 @@
 ACE_RCSID(Concurrency, CC_naming_service, "$Id$")
 
 CC_naming_service::CC_naming_service (CORBA::ORB_var orb
-                                      TAO_ENV_ARG_DECL)
+                                      ACE_ENV_ARG_DECL)
   : cc_factory_key_ (0),
     orb_ (0),
     factory_ (0)
 {
-  this->Init(orb TAO_ENV_ARG_PARAMETER);
+  this->Init(orb ACE_ENV_ARG_PARAMETER);
   ACE_CHECK;
 
   instance_ = this;
@@ -42,7 +42,7 @@ CC_naming_service::CC_naming_service(void)
 
 void
 CC_naming_service::Init(CORBA::ORB_var orb
-                        TAO_ENV_ARG_DECL)
+                        ACE_ENV_ARG_DECL)
 {
   this->orb_ = orb;
 
@@ -71,7 +71,7 @@ CC_naming_service::Instance(void)
 CORBA::Object_var
 CC_naming_service::get_obj_from_name (const char *c_name,
                                       const char *name
-                                      TAO_ENV_ARG_DECL)
+                                      ACE_ENV_ARG_DECL)
 {
   ACE_DEBUG ((LM_DEBUG, "C: %s, N: %s\n", c_name, name));
   CORBA::Object_var obj;
@@ -83,7 +83,7 @@ CC_naming_service::get_obj_from_name (const char *c_name,
           CosNaming::Name ns_name (1);
           ns_name.length (1);
           ns_name[0].id = CORBA::string_dup (name);
-          obj = my_name_client_->resolve (ns_name TAO_ENV_ARG_PARAMETER);
+          obj = my_name_client_->resolve (ns_name ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
         }
       else
@@ -92,7 +92,7 @@ CC_naming_service::get_obj_from_name (const char *c_name,
           ns_name.length (2);
           ns_name[0].id = CORBA::string_dup (c_name);
           ns_name[1].id = CORBA::string_dup (name);
-          obj = my_name_client_->resolve (ns_name TAO_ENV_ARG_PARAMETER);
+          obj = my_name_client_->resolve (ns_name ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
         }
       if (CORBA::is_nil (obj.in ()) )
@@ -113,7 +113,7 @@ CC_naming_service::get_obj_from_name (const char *c_name,
 void
 CC_naming_service::bind_name (const char *n,
                               CORBA::Object_ptr obj
-                              TAO_ENV_ARG_DECL)
+                              ACE_ENV_ARG_DECL)
 {
   ACE_DEBUG ((LM_DEBUG, "CC_Client::bind_name\n"));
 
@@ -124,7 +124,7 @@ CC_naming_service::bind_name (const char *n,
       ns_name[0].id = CORBA::string_dup (n);
       my_name_client_->bind (ns_name,
                              obj
-                             TAO_ENV_ARG_PARAMETER);
+                             ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -144,7 +144,7 @@ CC_naming_service::get_lock_set_factory (void)
 int
 CC_naming_service::init_naming_service (void)
 {
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
       // Initialize the naming services
@@ -156,12 +156,12 @@ CC_naming_service::init_naming_service (void)
 
       CORBA::Object_var factory_obj = get_obj_from_name ("CosConcurrency",
                                                          "LockSetFactory"
-                                                         TAO_ENV_ARG_PARAMETER);
+                                                         ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       this->factory_ =
         CosConcurrencyControl::LockSetFactory::_narrow
-        (factory_obj.in () TAO_ENV_ARG_PARAMETER);
+        (factory_obj.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (this->factory_.in ()))
diff --git a/TAO/orbsvcs/tests/Concurrency/CC_naming_service.h b/TAO/orbsvcs/tests/Concurrency/CC_naming_service.h
index f86de983f9b..2b42fb5da9e 100644
--- a/TAO/orbsvcs/tests/Concurrency/CC_naming_service.h
+++ b/TAO/orbsvcs/tests/Concurrency/CC_naming_service.h
@@ -39,24 +39,24 @@ public:
   CC_naming_service ();
   // Default constructor
 
-  CC_naming_service (CORBA::ORB_var orb_ TAO_ENV_ARG_DECL);
+  CC_naming_service (CORBA::ORB_var orb_ ACE_ENV_ARG_DECL);
   // Constructor
 
   ~CC_naming_service (void);
   // Default destructor.
 
-  void Init (CORBA::ORB_var orb_ TAO_ENV_ARG_DECL);
+  void Init (CORBA::ORB_var orb_ ACE_ENV_ARG_DECL);
   // Initialization method must be called after first call of Instance()
   // in order to initialize the object correctly
 
   CORBA::Object_var get_obj_from_name (const char *c_name,
                                        const char *name
-                                       TAO_ENV_ARG_DECL);
+                                       ACE_ENV_ARG_DECL);
   // Lookup a name in the naming service (context, name)
 
   void bind_name (const char *n,
                   CORBA::Object_ptr obj
-                  TAO_ENV_ARG_DECL);
+                  ACE_ENV_ARG_DECL);
   // Bind a name in the concurrency context.
 
   CosConcurrencyControl::LockSetFactory_var get_lock_set_factory (void);
diff --git a/TAO/orbsvcs/tests/Concurrency/CC_test_utils.cpp b/TAO/orbsvcs/tests/Concurrency/CC_test_utils.cpp
index 428869028e4..baf8c02bdda 100644
--- a/TAO/orbsvcs/tests/Concurrency/CC_test_utils.cpp
+++ b/TAO/orbsvcs/tests/Concurrency/CC_test_utils.cpp
@@ -53,7 +53,7 @@ CC_TestUtils::create_lock_set (void)
   ACE_TRY
     {
       lock_set =
-        CC_naming_service::Instance()->get_lock_set_factory ()->create (TAO_ENV_SINGLE_ARG_PARAMETER);
+        CC_naming_service::Instance()->get_lock_set_factory ()->create (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (lock_set))
diff --git a/TAO/orbsvcs/tests/Concurrency/CC_tests.cpp b/TAO/orbsvcs/tests/Concurrency/CC_tests.cpp
index fdcddbb53bf..d4e132a0617 100644
--- a/TAO/orbsvcs/tests/Concurrency/CC_tests.cpp
+++ b/TAO/orbsvcs/tests/Concurrency/CC_tests.cpp
@@ -37,11 +37,11 @@ CC_Test::create_lock_set (void)
   // Create the lock set and return an obj ref corresponding to the
   // key.
   CosConcurrencyControl::LockSet_ptr lock_set(0);
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
       lock_set =
-        this->naming_service_->get_lock_set_factory ()->create (TAO_ENV_SINGLE_ARG_PARAMETER);
+        this->naming_service_->get_lock_set_factory ()->create (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (lock_set))
@@ -101,10 +101,10 @@ Test_Single_Lock_With_Mode::run (int /* times_to_run */)
 
   CosConcurrencyControl::LockSet_ptr cc_lock_set_ = create_lock_set ();
 
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
-      cc_lock_set_->lock (mode_ TAO_ENV_ARG_PARAMETER);
+      cc_lock_set_->lock (mode_ ACE_ENV_ARG_PARAMETER);
 
       ACE_TRY_CHECK;
       ACE_DEBUG ((LM_DEBUG,
@@ -112,7 +112,7 @@ Test_Single_Lock_With_Mode::run (int /* times_to_run */)
                   get_lock_mode_name (mode_)));
 
       lock_not_held = cc_lock_set_->try_lock (mode_
-                                              TAO_ENV_ARG_PARAMETER);
+                                              ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (lock_not_held)
@@ -128,13 +128,13 @@ Test_Single_Lock_With_Mode::run (int /* times_to_run */)
                     get_lock_mode_name (mode_)));
 
       cc_lock_set_->unlock (mode_
-                            TAO_ENV_ARG_PARAMETER);
+                            ACE_ENV_ARG_PARAMETER);
       ACE_DEBUG ((LM_DEBUG,
                   "%s lock released\n",
                   get_lock_mode_name (mode_)));
 
       lock_not_held = cc_lock_set_->try_lock (mode_
-                                              TAO_ENV_ARG_PARAMETER);
+                                              ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (lock_not_held)
@@ -179,20 +179,20 @@ Test_Setup_LockSet::~Test_Setup_LockSet (void)
 int
 Test_Setup_LockSet::run (int /* times_to_run */)
 {
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
       CosConcurrencyControl::LockSet_ptr cc_lock_set_ =
         create_lock_set ();
       this->naming_service_->bind_name (my_name_, cc_lock_set_
-                                        TAO_ENV_ARG_PARAMETER);
+                                        ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       ACE_DEBUG ((LM_DEBUG,
                   "Name bound\n"));
 
       cc_lock_set_->lock (CosConcurrencyControl::read
-                          TAO_ENV_ARG_PARAMETER);
+                          ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       ACE_DEBUG ((LM_DEBUG,
@@ -226,22 +226,22 @@ Test_Use_Already_Created_LockSet::~Test_Use_Already_Created_LockSet (void)
 int
 Test_Use_Already_Created_LockSet::run (int /* times_to_run */)
 {
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
       CORBA::Object_var ccls_obj =
         this->naming_service_->get_obj_from_name (ACE_const_cast (char *, ""),
                                                   my_name_
-                                                  TAO_ENV_ARG_PARAMETER);
+                                                  ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CosConcurrencyControl::LockSet_var ccls =
         CosConcurrencyControl::LockSet::_narrow (ccls_obj.in ()
-                                                 TAO_ENV_ARG_PARAMETER);
+                                                 ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       ccls->lock (CosConcurrencyControl::read
-                  TAO_ENV_ARG_PARAMETER);
+                  ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
     }
@@ -273,21 +273,21 @@ Test_Unlock_Already_Created_LockSet::~Test_Unlock_Already_Created_LockSet (void)
 int
 Test_Unlock_Already_Created_LockSet::run (int /* times_to_run */)
 {
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
       CORBA::Object_var ccls_obj =
         this->naming_service_->get_obj_from_name (ACE_const_cast (char *, ""), my_name_
-                                                 TAO_ENV_ARG_PARAMETER);
+                                                 ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CosConcurrencyControl::LockSet_var ccls =
         CosConcurrencyControl::LockSet::_narrow (ccls_obj.in ()
-                                                 TAO_ENV_ARG_PARAMETER);
+                                                 ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       ccls->unlock (CosConcurrencyControl::read
-                    TAO_ENV_ARG_PARAMETER);
+                    ACE_ENV_ARG_PARAMETER);
     }
   ACE_CATCHANY
     {
@@ -320,11 +320,11 @@ Test_Release_Not_Held_Lock::run (int /* times_to_run */)
 
   // Create the lock set
   CosConcurrencyControl::LockSet_ptr cc_lock_set_ = create_lock_set ();
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
       // lock the lock
-      cc_lock_set_->lock (mode_ TAO_ENV_ARG_PARAMETER);
+      cc_lock_set_->lock (mode_ ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       ACE_DEBUG ((LM_DEBUG,
@@ -333,7 +333,7 @@ Test_Release_Not_Held_Lock::run (int /* times_to_run */)
 
       // check to see if the lock is held
       lock_not_held = cc_lock_set_->try_lock (mode_
-                                              TAO_ENV_ARG_PARAMETER);
+                                              ACE_ENV_ARG_PARAMETER);
 
       if (lock_not_held)
         {
@@ -349,14 +349,14 @@ Test_Release_Not_Held_Lock::run (int /* times_to_run */)
 
       // release the lock
       cc_lock_set_->unlock (mode_
-                            TAO_ENV_ARG_PARAMETER);
+                            ACE_ENV_ARG_PARAMETER);
       ACE_DEBUG ((LM_DEBUG,
                   "%s lock released\n",
                   get_lock_mode_name (mode_)));
 
       // release the lock again. this should raise an exception
       cc_lock_set_->unlock (mode_
-                            TAO_ENV_ARG_PARAMETER);
+                            ACE_ENV_ARG_PARAMETER);
 
       ACE_DEBUG ((LM_DEBUG,
                   "attemptet to release %s lock\n",