ChangeLogTag: Thu Jan 25 17:39:59 UTC 2007 Chad Elliott <elliott_c@ociweb.com>

4 files changed, 84 insertions, 131 deletions

diff --git a/TAO/interop-tests/wchar/client.cpp b/TAO/interop-tests/wchar/client.cpp
index fd798d30ef6..04b5ca47d56 100644
--- a/TAO/interop-tests/wchar/client.cpp
+++ b/TAO/interop-tests/wchar/client.cpp
@@ -101,67 +101,59 @@ assign_wstruct (short key, interop::wstruct & ws)
 
 CORBA::Boolean
 run_one_test (interop::WChar_Passer_ptr server,
-              int test_num ACE_ENV_ARG_DECL)
+              int test_num)
 {
   switch (test_num)
     {
     case WCHAR_TO_SERVER:
       return server->wchar_to_server (ref.get_wchar(data_set),
-                                      data_set
-                                      ACE_ENV_ARG_PARAMETER);
+                                      data_set);
     case WSTRING_TO_SERVER:
       return server->wstring_to_server (ref.get_wstring(data_set),
-                                        data_set
-                                        ACE_ENV_ARG_PARAMETER);
+                                        data_set);
     case WARRAY_TO_SERVER:
       return server->warray_to_server (ref.get_warray(data_set),
-                                       data_set
-                                       ACE_ENV_ARG_PARAMETER);
+                                       data_set);
     case ANY_WCHAR_TO_SERVER:
       {
         CORBA::Any a;
         a <<= CORBA::Any::from_wchar(ref.get_wchar(data_set));
-        return server->any_to_server (a,data_set ACE_ENV_ARG_PARAMETER);
+        return server->any_to_server (a,data_set);
       }
     case WSTRING_EXCEPTION:
       {
-        ACE_TRY_NEW_ENV
+        try
           {
-            server->exception_test(data_set ACE_ENV_ARG_PARAMETER);
+            server->exception_test(data_set);
           }
-        ACE_CATCH (interop::WChar_Passer::WStringException, e)
+        catch (const interop::WChar_Passer::WStringException& e)
           {
             return ref.match_except (data_set,e.why.in());
           }
-        ACE_ENDTRY;
         break;
       }
     case WCHAR_FROM_SERVER:
       {
-        CORBA::WChar wc = server->wchar_from_server (data_set
-                                                     ACE_ENV_ARG_PARAMETER);
+        CORBA::WChar wc = server->wchar_from_server (data_set);
         return ref.match_wchar (data_set,wc);
       }
     case WSTRING_FROM_SERVER:
       {
         CORBA::WString_var ws =
-          server->wstring_from_server (data_set
-                                       ACE_ENV_ARG_PARAMETER);
+          server->wstring_from_server (data_set);
         return ref.match_wstring (data_set,ws.in());
       }
     case WARRAY_FROM_SERVER:
       {
         interop::warray_var wa =
-          server->warray_from_server (data_set
-                                      ACE_ENV_ARG_PARAMETER);
+          server->warray_from_server (data_set);
         return ref.match_warray (data_set,wa.in());
       }
     case ANY_WCHAR_FROM_SERVER:
       {
         CORBA::WChar wc;
         CORBA::Any_var test = server->any_from_server (data_set,
-                                                       interop::is_wchar
-                                                       ACE_ENV_ARG_PARAMETER);
+                                                       interop::is_wchar);
         if (test >>= CORBA::Any::to_wchar(wc))
           {
             return ref.match_wchar (data_set,wc);
@@ -172,15 +164,13 @@ run_one_test (interop::WChar_Passer_ptr server,
       {
         CORBA::Any a;
         a <<= ref.get_wstring(data_set);
-        return server->any_to_server (a,data_set
-                                      ACE_ENV_ARG_PARAMETER);
+        return server->any_to_server (a,data_set);
       }
     case ANY_WSTRING_FROM_SERVER:
       {
         const CORBA::WChar *ws;
         CORBA::Any_var test = server->any_from_server (data_set,
-                                                       interop::is_wstring
-                                                       ACE_ENV_ARG_PARAMETER);
+                                                       interop::is_wstring);
         if (test >>= ws)
           {
             return ref.match_wstring (data_set,ws);
@@ -192,7 +182,7 @@ run_one_test (interop::WChar_Passer_ptr server,
         CORBA::Any a;
         a <<= ref.get_wstring(data_set);
         const CORBA::WChar *ws;
-        CORBA::Any_var test = server->any_echo (a ACE_ENV_ARG_PARAMETER);
+        CORBA::Any_var test = server->any_echo (a);
         if (test >>= ws)
           {
             return ref.match_wstring (data_set,ws);
@@ -202,7 +192,7 @@ run_one_test (interop::WChar_Passer_ptr server,
     case WSTRUCTSEQ_FROM_SERVER:
       {
         interop::wstructseq_var wsList =
-          server->wstructseq_from_server(data_set ACE_ENV_ARG_PARAMETER);
+          server->wstructseq_from_server(data_set);
         int result = 1;
 
         for (CORBA::ULong i = 0; i < wsList->length(); i++)
@@ -219,13 +209,11 @@ run_one_test (interop::WChar_Passer_ptr server,
         {
           assign_wstruct(data_set, (*wsList)[i]);
         }
-        return server->wstructseq_to_server(wsList.in(), data_set
-                                            ACE_ENV_ARG_PARAMETER);
+        return server->wstructseq_to_server(wsList.in(), data_set);
       }
     case NUL_WSTRING_TO_SERVER:
       return server->wstring_to_server (L"",
-                                        -1
-                                        ACE_ENV_ARG_PARAMETER);
+                                        -1);
     default:
       break;
     }
@@ -233,7 +221,7 @@ run_one_test (interop::WChar_Passer_ptr server,
 }
 
 short
-run_tests (interop::WChar_Passer_ptr server ACE_ENV_ARG_DECL)
+run_tests (interop::WChar_Passer_ptr server)
 {
   short successes = 0;
   short numtests = 0;
@@ -242,7 +230,7 @@ run_tests (interop::WChar_Passer_ptr server ACE_ENV_ARG_DECL)
   for (int i = 0; i < LAST_TEST; i++, t <<= 1)
     if ((tests_to_run & t) == t)
       {
-        CORBA::Boolean result = run_one_test (server,t ACE_ENV_ARG_PARAMETER);
+        CORBA::Boolean result = run_one_test (server,t);
         ++numtests;
         if (result) ++successes;
         if (verbose)
@@ -315,7 +303,7 @@ ACE_TMAIN( int argc, ACE_TCHAR *argv[] )
   ACE_UNUSED_ARG (argv);
   ACE_ERROR_RETURN ((LM_ERROR,ACE_TEXT ("This test requires wchar support\n")),0);
 #else
-  ACE_TRY_NEW_ENV
+  try
   {
     ACE_Argv_Type_Converter command_line(argc, argv);
     // Initialize orb
@@ -324,7 +312,7 @@ ACE_TMAIN( int argc, ACE_TCHAR *argv[] )
       return 0;
 
     // Destringify ior
-    CORBA::Object_var obj = orb->string_to_object( ACE_TEXT_ALWAYS_CHAR(ior) ACE_ENV_ARG_PARAMETER);
+    CORBA::Object_var obj = orb->string_to_object( ACE_TEXT_ALWAYS_CHAR(ior));
     if( CORBA::is_nil( obj.in() ) )
       ACE_ERROR_RETURN ((LM_ERROR,
                          "arg is not a valid ior sting"),
@@ -332,14 +320,14 @@ ACE_TMAIN( int argc, ACE_TCHAR *argv[] )
 
     // Narrow
     interop::WChar_Passer_var server =
-      interop::WChar_Passer::_narrow( obj.in() ACE_ENV_ARG_PARAMETER);
+      interop::WChar_Passer::_narrow( obj.in());
 
     if( CORBA::is_nil( server.in() ))
       ACE_ERROR_RETURN ((LM_ERROR,
                          "arg is not a interop::WChar_Passer reference\n"),
                         -1);
 
-    short result = run_tests (server.in() ACE_ENV_ARG_PARAMETER);
+    short result = run_tests (server.in());
     CORBA::String_var server_orb =
       server->orb_name();
     ACE_ERROR ((LM_ERROR,
@@ -351,12 +339,11 @@ ACE_TMAIN( int argc, ACE_TCHAR *argv[] )
       server->shutdown();
     }
   }
-  ACE_CATCH(CORBA::Exception, ex)
+  catch (const CORBA::Exception& ex)
   {
-    ACE_PRINT_EXCEPTION(ex, "Uncaught CORBA exception: ");
+    ex._tao_print_exception ("Uncaught CORBA exception: ");
     return 1;
   }
-  ACE_ENDTRY;
   return 0;
 #endif
 }
diff --git a/TAO/interop-tests/wchar/interop_wchar_i.cpp b/TAO/interop-tests/wchar/interop_wchar_i.cpp
index fdad0ebf491..df242339900 100644
--- a/TAO/interop-tests/wchar/interop_wchar_i.cpp
+++ b/TAO/interop-tests/wchar/interop_wchar_i.cpp
@@ -46,16 +46,14 @@ interop_WChar_Passer_i::orb_name (void)
 
 CORBA::Boolean
 interop_WChar_Passer_i::wchar_to_server (CORBA::WChar test,
-                                         CORBA::Short key
-                                         ACE_ENV_ARG_DECL_NOT_USED)
+                                         CORBA::Short key)
   ACE_THROW_SPEC (( CORBA::SystemException ))
 {
   return ref_.match_wchar (key,test);
 }
 
 CORBA::WChar
-interop_WChar_Passer_i::wchar_from_server (CORBA::Short key
-                                           ACE_ENV_ARG_DECL_NOT_USED)
+interop_WChar_Passer_i::wchar_from_server (CORBA::Short key)
   ACE_THROW_SPEC (( CORBA::SystemException ))
 {
   return ref_.get_wchar (key);
@@ -63,16 +61,14 @@ interop_WChar_Passer_i::wchar_from_server (CORBA::Short key
 
 CORBA::Boolean
 interop_WChar_Passer_i::wstring_to_server (const CORBA::WChar * test,
-                                           CORBA::Short key
-                                           ACE_ENV_ARG_DECL_NOT_USED)
+                                           CORBA::Short key)
   ACE_THROW_SPEC (( CORBA::SystemException ))
 {
   return ref_.match_wstring(key,test);
 }
 
 CORBA::WChar *
-interop_WChar_Passer_i::wstring_from_server (CORBA::Short key
-                                             ACE_ENV_ARG_DECL_NOT_USED)
+interop_WChar_Passer_i::wstring_from_server (CORBA::Short key)
   ACE_THROW_SPEC (( CORBA::SystemException ))
 {
   return CORBA::wstring_dup (ref_.get_wstring(key));
@@ -80,16 +76,14 @@ interop_WChar_Passer_i::wstring_from_server (CORBA::Short key
 
 CORBA::Boolean
 interop_WChar_Passer_i::warray_to_server (const interop::warray test,
-                                          CORBA::Short key
-                                          ACE_ENV_ARG_DECL_NOT_USED)
+                                          CORBA::Short key)
   ACE_THROW_SPEC (( CORBA::SystemException ))
 {
   return ref_.match_warray(key,test);
 }
 
 interop::warray_slice *
-interop_WChar_Passer_i::warray_from_server (CORBA::Short key
-                                            ACE_ENV_ARG_DECL_NOT_USED)
+interop_WChar_Passer_i::warray_from_server (CORBA::Short key)
   ACE_THROW_SPEC (( CORBA::SystemException ))
 {
   return interop::warray_dup (ref_.get_warray(key));
@@ -97,25 +91,23 @@ interop_WChar_Passer_i::warray_from_server (CORBA::Short key
 
 CORBA::Boolean
 interop_WChar_Passer_i::wstruct_to_server (const interop::wstruct & test,
-                                           CORBA::Short key
-                                           ACE_ENV_ARG_DECL)
+                                           CORBA::Short key)
   ACE_THROW_SPEC (( CORBA::SystemException ))
 {
   return
     ref_.match_wchar (key,test.st_char) &&
     ref_.match_wstring (key,test.st_string) &&
     ref_.match_warray (key,test.st_array) &&
-    this->any_to_server (test.st_any,key ACE_ENV_ARG_PARAMETER);
+    this->any_to_server (test.st_any,key);
 }
 
 interop::wstruct *
-interop_WChar_Passer_i::wstruct_from_server (CORBA::Short key
-                                             ACE_ENV_ARG_DECL)
+interop_WChar_Passer_i::wstruct_from_server (CORBA::Short key)
   ACE_THROW_SPEC (( CORBA::SystemException ))
 {
   interop::wstruct_var ws = new interop::wstruct ();
-  ws->st_char = this->wchar_from_server(key ACE_ENV_ARG_PARAMETER);
-  ws->st_string = this->wstring_from_server(key ACE_ENV_ARG_PARAMETER);
+  ws->st_char = this->wchar_from_server(key);
+  ws->st_string = this->wstring_from_server(key);
   ref_.assign_warray (key, ws->st_array);
   ws->st_any <<= ref_.get_wstring(key);
   return ws._retn ();
@@ -123,21 +115,19 @@ interop_WChar_Passer_i::wstruct_from_server (CORBA::Short key
 
 CORBA::Boolean
 interop_WChar_Passer_i::wstructseq_to_server (const interop::wstructseq & test,
-                                              CORBA::Short key
-                                              ACE_ENV_ARG_DECL)
+                                              CORBA::Short key)
   ACE_THROW_SPEC (( CORBA::SystemException ))
 {
   CORBA::Boolean result = 1;
   for (CORBA::ULong i = 0; result && i < test.length(); i++)
     {
-      result = this->wstruct_to_server(test[i], key ACE_ENV_ARG_PARAMETER);
+      result = this->wstruct_to_server(test[i], key);
     }
   return result;
 }
 
 interop::wstructseq *
-interop_WChar_Passer_i::wstructseq_from_server (CORBA::Short key
-                                                ACE_ENV_ARG_DECL)
+interop_WChar_Passer_i::wstructseq_from_server (CORBA::Short key)
     ACE_THROW_SPEC (( CORBA::SystemException ))
 {
   interop::wstructseq_var wsListI = new interop::wstructseq();
@@ -145,8 +135,8 @@ interop_WChar_Passer_i::wstructseq_from_server (CORBA::Short key
 
   for (CORBA::ULong i = 0; i < wsListI->length(); i++)
     {
-      wsListI[i].st_char = this->wchar_from_server(key ACE_ENV_ARG_PARAMETER);
-      wsListI[i].st_string = this->wstring_from_server(key ACE_ENV_ARG_PARAMETER);
+      wsListI[i].st_char = this->wchar_from_server(key);
+      wsListI[i].st_string = this->wstring_from_server(key);
       ref_.assign_warray (key, wsListI[i].st_array);
       // this is to keep Cxx on TRUE64 happy
       // it won't cast a wide character literal (i.e. L"")
@@ -160,17 +150,16 @@ interop_WChar_Passer_i::wstructseq_from_server (CORBA::Short key
 
 CORBA::Boolean
 interop_WChar_Passer_i::wunion_to_server (const interop::wunion & test,
-                                          CORBA::Short key
-                                          ACE_ENV_ARG_DECL)
+                                          CORBA::Short key)
   ACE_THROW_SPEC (( CORBA::SystemException ))
 {
   switch (test._d()) {
   case interop::is_wchar :
-    return this->wchar_to_server (test.u_char(),key  ACE_ENV_ARG_PARAMETER);
+    return this->wchar_to_server (test.u_char(),key);
   case interop::is_wstring :
-    return this->wstring_to_server (test.u_string(),key  ACE_ENV_ARG_PARAMETER);
+    return this->wstring_to_server (test.u_string(),key);
   case interop::is_warray :
-    return this->warray_to_server (test.u_array(),key ACE_ENV_ARG_PARAMETER);
+    return this->warray_to_server (test.u_array(),key);
   default:
     /*return 0*/;
   }
@@ -179,8 +168,7 @@ interop_WChar_Passer_i::wunion_to_server (const interop::wunion & test,
 
 interop::wunion *
 interop_WChar_Passer_i::wunion_from_server (CORBA::Short key,
-                                            interop::wchar_types type
-                                            ACE_ENV_ARG_DECL_NOT_USED)
+                                            interop::wchar_types type)
   ACE_THROW_SPEC (( CORBA::SystemException ))
 {
   interop::wunion *wu = new interop::wunion ();
@@ -201,8 +189,7 @@ interop_WChar_Passer_i::wunion_from_server (CORBA::Short key,
 
 CORBA::Boolean
 interop_WChar_Passer_i::any_to_server (const CORBA::Any &test,
-                                       CORBA::Short key
-                                       ACE_ENV_ARG_DECL)
+                                       CORBA::Short key)
   ACE_THROW_SPEC (( CORBA::SystemException ))
 {
   CORBA::WChar wc;
@@ -212,23 +199,22 @@ interop_WChar_Passer_i::any_to_server (const CORBA::Any &test,
 
   if (test >>= CORBA::Any::to_wchar(wc))
     {
-      return this->wchar_to_server(wc,key ACE_ENV_ARG_PARAMETER);
+      return this->wchar_to_server(wc,key);
     }
   else if (test >>= ws)
     {
-      return this->wstring_to_server (ws,key ACE_ENV_ARG_PARAMETER);
+      return this->wstring_to_server (ws,key);
     }
   else if (test >>= forany)
     {
-      return this->warray_to_server (forany.in(),key ACE_ENV_ARG_PARAMETER);
+      return this->warray_to_server (forany.in(),key);
     }
   return 0;
 }
 
 CORBA::Any*
 interop_WChar_Passer_i::any_from_server (CORBA::Short key,
-                                         interop::wchar_types type
-                                         ACE_ENV_ARG_DECL_NOT_USED)
+                                         interop::wchar_types type)
   ACE_THROW_SPEC (( CORBA::SystemException ))
 {
   CORBA::Any *any = new CORBA::Any;
@@ -250,26 +236,24 @@ interop_WChar_Passer_i::any_from_server (CORBA::Short key,
 }
 
 CORBA::Any *
-interop_WChar_Passer_i::any_echo (const CORBA::Any &test
-                                  ACE_ENV_ARG_DECL_NOT_USED)
+interop_WChar_Passer_i::any_echo (const CORBA::Any &test)
   ACE_THROW_SPEC (( CORBA::SystemException ))
 {
   return new CORBA::Any (test);
 }
 
 void
-interop_WChar_Passer_i::exception_test ( CORBA::Short key
-                                         ACE_ENV_ARG_DECL)
+interop_WChar_Passer_i::exception_test ( CORBA::Short key)
   ACE_THROW_SPEC ((CORBA::SystemException,
                    interop::WChar_Passer::WStringException))
 {
-  ACE_THROW (interop::WChar_Passer::WStringException(ref_.get_except(key),
-                                             this->wchar_from_server(key ACE_ENV_ARG_PARAMETER)));
+  throw interop::WChar_Passer::WStringException(ref_.get_except(key),
+                                                this->wchar_from_server(key));
 }
 
 void
 interop_WChar_Passer_i::shutdown (void)
   ACE_THROW_SPEC (( CORBA::SystemException ))
 {
-  this->orb_->shutdown(0 ACE_ENV_ARG_PARAMETER);
+  this->orb_->shutdown(0);
 }
diff --git a/TAO/interop-tests/wchar/interop_wchar_i.h b/TAO/interop-tests/wchar/interop_wchar_i.h
index 37b6b18469d..bec5f5c7e3c 100644
--- a/TAO/interop-tests/wchar/interop_wchar_i.h
+++ b/TAO/interop-tests/wchar/interop_wchar_i.h
@@ -46,76 +46,60 @@ public:
     ACE_THROW_SPEC (( CORBA::SystemException ));
 
   virtual CORBA::Boolean wchar_to_server (CORBA::WChar test,
-                                          CORBA::Short key
-                                          ACE_ENV_ARG_DECL)
+                                          CORBA::Short key)
     ACE_THROW_SPEC (( CORBA::SystemException ));
 
-  virtual CORBA::WChar wchar_from_server (CORBA::Short key
-                                          ACE_ENV_ARG_DECL)
+  virtual CORBA::WChar wchar_from_server (CORBA::Short key)
     ACE_THROW_SPEC (( CORBA::SystemException ));
 
   virtual CORBA::Boolean wstring_to_server (const CORBA::WChar * test,
-                                            CORBA::Short key
-                                            ACE_ENV_ARG_DECL)
+                                            CORBA::Short key)
     ACE_THROW_SPEC (( CORBA::SystemException ));
 
-  virtual CORBA::WChar * wstring_from_server (CORBA::Short key
-                                              ACE_ENV_ARG_DECL)
+  virtual CORBA::WChar * wstring_from_server (CORBA::Short key)
     ACE_THROW_SPEC (( CORBA::SystemException ));
 
   virtual CORBA::Boolean warray_to_server (const interop::warray test,
-                                           CORBA::Short key
-                                           ACE_ENV_ARG_DECL)
+                                           CORBA::Short key)
     ACE_THROW_SPEC (( CORBA::SystemException ));
 
-  virtual interop::warray_slice * warray_from_server (CORBA::Short key
-                                                      ACE_ENV_ARG_DECL)
+  virtual interop::warray_slice * warray_from_server (CORBA::Short key)
     ACE_THROW_SPEC (( CORBA::SystemException ));
 
   virtual CORBA::Boolean wstruct_to_server (const interop::wstruct & test,
-                                            CORBA::Short key
-                                            ACE_ENV_ARG_DECL)
+                                            CORBA::Short key)
     ACE_THROW_SPEC (( CORBA::SystemException ));
 
-  virtual interop::wstruct * wstruct_from_server (CORBA::Short key
-                                                  ACE_ENV_ARG_DECL)
+  virtual interop::wstruct * wstruct_from_server (CORBA::Short key)
     ACE_THROW_SPEC (( CORBA::SystemException ));
 
   virtual CORBA::Boolean wstructseq_to_server (const interop::wstructseq & test,
-                                            CORBA::Short key
-                                            ACE_ENV_ARG_DECL)
+                                            CORBA::Short key)
     ACE_THROW_SPEC (( CORBA::SystemException ));
 
-  virtual interop::wstructseq * wstructseq_from_server (CORBA::Short key
-                                             ACE_ENV_ARG_DECL)
+  virtual interop::wstructseq * wstructseq_from_server (CORBA::Short key)
     ACE_THROW_SPEC (( CORBA::SystemException ));
 
  virtual CORBA::Boolean wunion_to_server (const interop::wunion & test,
-                                           CORBA::Short key
-                                           ACE_ENV_ARG_DECL)
+                                           CORBA::Short key)
     ACE_THROW_SPEC (( CORBA::SystemException ));
 
   virtual interop::wunion * wunion_from_server (CORBA::Short key,
-                                                interop::wchar_types type
-                                                ACE_ENV_ARG_DECL)
+                                                interop::wchar_types type)
     ACE_THROW_SPEC (( CORBA::SystemException ));
 
   virtual CORBA::Boolean any_to_server (const CORBA::Any &test,
-                                        CORBA::Short key
-                                        ACE_ENV_ARG_DECL)
+                                        CORBA::Short key)
   ACE_THROW_SPEC (( CORBA::SystemException ));
 
   virtual CORBA::Any* any_from_server (CORBA::Short key,
-                                       interop::wchar_types type
-                                       ACE_ENV_ARG_DECL)
+                                       interop::wchar_types type)
   ACE_THROW_SPEC (( CORBA::SystemException ));
 
-  virtual CORBA::Any* any_echo (const CORBA::Any &test
-                                ACE_ENV_ARG_DECL)
+  virtual CORBA::Any* any_echo (const CORBA::Any &test)
   ACE_THROW_SPEC (( CORBA::SystemException ));
 
-virtual void exception_test (CORBA::Short key
-                             ACE_ENV_ARG_DECL)
+virtual void exception_test (CORBA::Short key)
   ACE_THROW_SPEC (( CORBA::SystemException,
                     interop::WChar_Passer::WStringException ));
 
diff --git a/TAO/interop-tests/wchar/server.cpp b/TAO/interop-tests/wchar/server.cpp
index f0fcb41d069..0ba8e111404 100644
--- a/TAO/interop-tests/wchar/server.cpp
+++ b/TAO/interop-tests/wchar/server.cpp
@@ -80,8 +80,7 @@ ACE_TMAIN( int argc, ACE_TCHAR *argv[] )
   ACE_OS::fclose (output_file);
   ACE_ERROR_RETURN ((LM_ERROR,"This test requires wchar support\n"),0);
 #else
-  ACE_DECLARE_NEW_ENV;
-  ACE_TRY
+  try
     {
         // Initialize orb
         CORBA::ORB_var orb = CORBA::ORB_init( command_line.get_argc(), command_line.get_ASCII_argv() );
@@ -89,17 +88,17 @@ ACE_TMAIN( int argc, ACE_TCHAR *argv[] )
         //Get reference to Root POA
         CORBA::Object_var obj =
         orb->resolve_initial_references( "RootPOA"
-                                         ACE_ENV_ARG_PARAMETER );
+ );
 
         PortableServer::POA_var poa =
           PortableServer::POA::_narrow( obj.in()
-                                        ACE_ENV_ARG_PARAMETER );
+ );
 
         PortableServer::POAManager_var mgr =
-          poa->the_POAManager( ACE_ENV_SINGLE_ARG_PARAMETER );
+          poa->the_POAManager( );
 
         // Activate POA Manager
-        mgr->activate( ACE_ENV_SINGLE_ARG_PARAMETER );
+        mgr->activate( );
 
         // Create an object
         interop_WChar_Passer_i servant(orb.in(), verbose);
@@ -107,11 +106,11 @@ ACE_TMAIN( int argc, ACE_TCHAR *argv[] )
         // Register the servant with the RootPOA, obtain its object
         // reference, stringify it, and write it to a file.
         obj = poa->servant_to_reference( &servant
-                                         ACE_ENV_ARG_PARAMETER );
+ );
 
         CORBA::String_var str =
           orb->object_to_string( obj.in()
-                                 ACE_ENV_ARG_PARAMETER );
+ );
 
         FILE *output_file = ACE_OS::fopen (ior_output_file, ACE_TEXT("w"));
         if (output_file == 0)
@@ -124,15 +123,14 @@ ACE_TMAIN( int argc, ACE_TCHAR *argv[] )
         ACE_OS::fclose (output_file);
 
         // Accept requests
-        orb->run( ACE_ENV_SINGLE_ARG_PARAMETER );
-        orb->destroy( ACE_ENV_SINGLE_ARG_PARAMETER );
+        orb->run( );
+        orb->destroy( );
       }
-    ACE_CATCH(CORBA::Exception, ex)
+    catch (const CORBA::Exception& ex)
       {
-        ACE_PRINT_EXCEPTION(ex, "uncaught exception");
+        ex._tao_print_exception ("uncaught exception");
         return 1;
       }
-    ACE_ENDTRY;
 
     return 0;
 #endif /* ACE_HAS_WCHAR */