Exception handling stuff

4 files changed, 66 insertions, 83 deletions

diff --git a/TAO/orbsvcs/orbsvcs/Concurrency/CC_LockSet.cpp b/TAO/orbsvcs/orbsvcs/Concurrency/CC_LockSet.cpp
index dcbfb0e8b6c..dc108b20904 100644
--- a/TAO/orbsvcs/orbsvcs/Concurrency/CC_LockSet.cpp
+++ b/TAO/orbsvcs/orbsvcs/Concurrency/CC_LockSet.cpp
@@ -22,16 +22,17 @@ ACE_RCSID(Concurrency, CC_LockSet, "$Id$")
 CC_LockSet::CC_LockSet (void)
   : related_lockset_ (0)
 {
-  TAO_TRY
+  ACE_TRY_NEW_ENV
     {
-      this->Init (TAO_TRY_ENV);
-      TAO_CHECK_ENV;
+      this->Init (ACE_TRY_ENV);
+      ACE_TRY_CHECK;
     }
-  TAO_CATCHANY
+  ACE_CATCHANY
     {
-      TAO_TRY_ENV.print_exception ("CC_LockSet::CC_LockSet (void)");
+      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
+                           "CC_LockSet::CC_LockSet (void)");
     }
-  TAO_ENDTRY;
+  ACE_ENDTRY;
 }
 
 // Constructor used to create related lock sets.
@@ -39,22 +40,23 @@ CC_LockSet::CC_LockSet (void)
 CC_LockSet::CC_LockSet (CosConcurrencyControl::LockSet_ptr related)
   : related_lockset_ (related)
 {
-  TAO_TRY
+  ACE_TRY_NEW_ENV
     {
-      this->Init (TAO_TRY_ENV);
-      TAO_CHECK_ENV;
+      this->Init (ACE_TRY_ENV);
+      ACE_TRY_CHECK;
     }
-  TAO_CATCHANY
+  ACE_CATCHANY
     {
-      TAO_TRY_ENV.print_exception ("CC_LockSet::CC_LockSet (...)");
+      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
+                           "CC_LockSet::CC_LockSet (...)");
     }
-  TAO_ENDTRY;
+  ACE_ENDTRY;
 }
 
 // Initialization.
 
 void
-CC_LockSet::Init (CORBA::Environment &TAO_IN_ENV)
+CC_LockSet::Init (CORBA::Environment &ACE_TRY_ENV)
 {
   // Set the mode of the statically allocated locks
   lock_[CC_IR] = 0;
@@ -65,7 +67,7 @@ CC_LockSet::Init (CORBA::Environment &TAO_IN_ENV)
 
   // Acquire the semaphore in order to be able to put requests on hold
   if (semaphore_.acquire () == -1)
-    TAO_THROW (CORBA::INTERNAL ());
+    ACE_THROW (CORBA::INTERNAL ());
 }
 
 // Destructor
@@ -91,7 +93,7 @@ CORBA::Boolean CC_LockSet::compatible (CC_LockModeEnum mr)
 
 void
 CC_LockSet::lock (CosConcurrencyControl::lock_mode mode,
-                  CORBA::Environment &TAO_IN_ENV)
+                  CORBA::Environment &ACE_TRY_ENV)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_DEBUG ((LM_DEBUG, "CC_LockSet::lock\n"));
@@ -105,7 +107,7 @@ CC_LockSet::lock (CosConcurrencyControl::lock_mode mode,
   // the FIFO properties of ACE_Token!
   if (this->lock_i (lm) == 1)
     if (semaphore_.acquire () == -1)
-      TAO_THROW (CORBA::INTERNAL ());
+      ACE_THROW (CORBA::INTERNAL ());
 }
 
 // Tries to lock. If it is not possible false is returned.
@@ -153,7 +155,7 @@ CC_LockSet::lmconvert (CosConcurrencyControl::lock_mode mode)
 
 void
 CC_LockSet::unlock (CosConcurrencyControl::lock_mode mode,
-                    CORBA::Environment &TAO_IN_ENV)
+                    CORBA::Environment &ACE_TRY_ENV)
     ACE_THROW_SPEC ((CORBA::SystemException,
                      CosConcurrencyControl::LockNotHeld))
 {
@@ -164,42 +166,32 @@ CC_LockSet::unlock (CosConcurrencyControl::lock_mode mode,
 
   ACE_GUARD (ACE_SYNCH_MUTEX, ace_mon, this->mlock_);
 
-  TAO_TRY
+  if (lock_[lm] == 0) // This lock is not held.
+    ACE_THROW (CosConcurrencyControl::LockNotHeld());
+  else
+    lock_[lm]--;
+
+  // If we do not have a lock held in a weaker mode than the
+  // strongest held and we have requests on the semaphore signal
+  // the semaphore.
+  while (lock_queue_.size () > 0)
     {
-      if (lock_[lm] == 0) // This lock is not held.
-        TAO_THROW (CosConcurrencyControl::LockNotHeld());
-      else
-        lock_[lm]--;
+      CC_LockModeEnum lock_on_queue = CC_EM;
 
-      TAO_CHECK_ENV;
+      lock_queue_.dequeue_head (lock_on_queue);
 
-      // If we do not have a lock held in a weaker mode than the
-      // strongest held and we have requests on the semaphore signal
-      // the semaphore.
-      while (lock_queue_.size () > 0)
+      if (compatible (lock_on_queue) == 1)
         {
-          CC_LockModeEnum lock_on_queue = CC_EM;
-
-          lock_queue_.dequeue_head (lock_on_queue);
-
-          if (compatible (lock_on_queue) == 1)
-            {
-              if (semaphore_.release () == -1)
-                TAO_THROW (CORBA::INTERNAL ());
-              lock_[lock_on_queue]++;
-            }
-          else
-            {
-              lock_queue_.enqueue_head (lock_on_queue);
-              break;
-            }
+          if (semaphore_.release () == -1)
+            ACE_THROW (CORBA::INTERNAL ());
+          lock_[lock_on_queue]++;
+        }
+      else
+        {
+          lock_queue_.enqueue_head (lock_on_queue);
+          break;
         }
     }
-  TAO_CATCHANY
-    {
-      TAO_RETHROW;
-    }
-  TAO_ENDTRY;
   this->dump ();
 }
 
@@ -208,7 +200,7 @@ CC_LockSet::unlock (CosConcurrencyControl::lock_mode mode,
 void
 CC_LockSet::change_mode (CosConcurrencyControl::lock_mode held_mode,
                          CosConcurrencyControl::lock_mode new_mode,
-                         CORBA::Environment &TAO_IN_ENV)
+                         CORBA::Environment &ACE_TRY_ENV)
     ACE_THROW_SPEC ((CORBA::SystemException,
                      CosConcurrencyControl::LockNotHeld))
 {
@@ -217,25 +209,16 @@ CC_LockSet::change_mode (CosConcurrencyControl::lock_mode held_mode,
   CC_LockModeEnum lm_held = lmconvert (held_mode);
   CC_LockModeEnum lm_new = lmconvert (new_mode);
 
-  TAO_TRY
+  if (this->lock_held (lm_held) == 0) // This lock is not held
+    ACE_THROW (CosConcurrencyControl::LockNotHeld());
+  else if (this->change_mode_i (lm_held, lm_new)==1)
     {
-      if (this->lock_held (lm_held) == 0) // This lock is not held
-        TAO_THROW (CosConcurrencyControl::LockNotHeld());
-      else if (this->change_mode_i (lm_held, lm_new)==1)
-        {
-          this->unlock (held_mode, TAO_IN_ENV);
-          TAO_CHECK_ENV;
+      this->unlock (held_mode, ACE_TRY_ENV);
+      ACE_CHECK;
 
-          if (semaphore_.acquire () == -1)
-            TAO_THROW (CORBA::INTERNAL ());
-        }
+      if (semaphore_.acquire () == -1)
+        ACE_THROW (CORBA::INTERNAL ());
     }
-  TAO_CATCHANY
-    {
-      TAO_RETHROW;
-    }
-  TAO_ENDTRY;
-
   //  this->dump ();
 }
 
diff --git a/TAO/orbsvcs/orbsvcs/Concurrency/CC_LockSetFactory.cpp b/TAO/orbsvcs/orbsvcs/Concurrency/CC_LockSetFactory.cpp
index 6c8d8d48641..ae042fe6cb1 100644
--- a/TAO/orbsvcs/orbsvcs/Concurrency/CC_LockSetFactory.cpp
+++ b/TAO/orbsvcs/orbsvcs/Concurrency/CC_LockSetFactory.cpp
@@ -36,7 +36,7 @@ CC_LockSetFactory::create (CORBA::Environment &ACE_TRY_ENV)
 
   ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->lock_, CosConcurrencyControl::LockSet::_nil ());
 
-  TAO_IN_ENV.exception (new CORBA::NO_MEMORY ());
+  ACE_TRY_ENV.exception (new CORBA::NO_MEMORY ());
   ACE_NEW_THROW_EX (ls,
                     CC_LockSet,
                     CORBA::NO_MEMORY());
diff --git a/TAO/orbsvcs/orbsvcs/Concurrency/Concurrency_Utils.cpp b/TAO/orbsvcs/orbsvcs/Concurrency/Concurrency_Utils.cpp
index 6a376c9de47..25ac44f4314 100644
--- a/TAO/orbsvcs/orbsvcs/Concurrency/Concurrency_Utils.cpp
+++ b/TAO/orbsvcs/orbsvcs/Concurrency/Concurrency_Utils.cpp
@@ -41,41 +41,44 @@ int
 TAO_Concurrency_Server::init (CORBA::ORB_var &orb,
 			      PortableServer::POA_var &poa)
 {
-  TAO_TRY
+  ACE_TRY_NEW_ENV
     {
+      // @@ Huh?!?
+
       // Get the naming context ptr to NameService.
-      TAO_CHECK_ENV;
+      //      ACE_TRY_CHECK;
 
-      PortableServer::ObjectId_var id = 
+      PortableServer::ObjectId_var id =
 	PortableServer::string_to_ObjectId ("ConcurrencyService");
 
       poa->activate_object_with_id (id.in (),
                                     &lock_set_factory_,
-                                    TAO_TRY_ENV);
-      TAO_CHECK_ENV;
-      
+                                    ACE_TRY_ENV);
+      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.
-      CORBA::Object_var obj = 
+      CORBA::Object_var obj =
 	poa->id_to_reference (id.in (),
-                              TAO_TRY_ENV);
-      TAO_CHECK_ENV;
+                              ACE_TRY_ENV);
+      ACE_TRY_CHECK;
 
       CORBA::String_var str =
 	orb->object_to_string (obj.in (),
-			       TAO_TRY_ENV);
-      TAO_CHECK_ENV;
+			       ACE_TRY_ENV);
+      ACE_TRY_CHECK;
 
-      ACE_DEBUG ((LM_DEBUG, 
+      ACE_DEBUG ((LM_DEBUG,
                   "listening as object <%s>\n",
                   str.in ()));
     }
-  TAO_CATCHANY
+  ACE_CATCHANY
     {
-      TAO_TRY_ENV.print_exception ("Concurrency Service");
+      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
+                           "Concurrency Service");
     }
-  TAO_ENDTRY;
+  ACE_ENDTRY;
   return 0;
 }
 
@@ -92,5 +95,3 @@ TAO_Concurrency_Server::GetLockSetFactory(void)
 TAO_Concurrency_Server::~TAO_Concurrency_Server (void)
 {
 }
-
-
diff --git a/TAO/orbsvcs/orbsvcs/Concurrency/Concurrency_Utils.h b/TAO/orbsvcs/orbsvcs/Concurrency/Concurrency_Utils.h
index 112b433a9c3..e067efcc60e 100644
--- a/TAO/orbsvcs/orbsvcs/Concurrency/Concurrency_Utils.h
+++ b/TAO/orbsvcs/orbsvcs/Concurrency/Concurrency_Utils.h
@@ -62,4 +62,3 @@ private:
 };
 
 #endif /* _CONCURRENCY_SERVER_H */
-