Converting debugging messages for CE using the ASYS_TEXT macro.

9 files changed, 93 insertions, 93 deletions

diff --git a/ace/Addr.cpp b/ace/Addr.cpp
index 026eaa2f209..8fe82db73f6 100644
--- a/ace/Addr.cpp
+++ b/ace/Addr.cpp
@@ -34,8 +34,8 @@ ACE_Addr::dump (void) const
   ACE_TRACE ("ACE_Addr::dump");
 
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
-  ACE_DEBUG ((LM_DEBUG, "addr_type_ = %d", this->addr_type_));
-  ACE_DEBUG ((LM_DEBUG, "\naddr_size_ = %d", this->addr_size_));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("addr_type_ = %d"), this->addr_type_));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("\naddr_size_ = %d"), this->addr_size_));
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
 
diff --git a/ace/Handle_Set.cpp b/ace/Handle_Set.cpp
index b888b01db52..2fcba51379c 100644
--- a/ace/Handle_Set.cpp
+++ b/ace/Handle_Set.cpp
@@ -17,20 +17,20 @@ ACE_Handle_Set::dump (void) const
 
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 
-  ACE_DEBUG ((LM_DEBUG, "\nsize_ = %d", this->size_));  
-  ACE_DEBUG ((LM_DEBUG, "\nmax_handle_ = %d", this->max_handle_));  
-  ACE_DEBUG ((LM_DEBUG, "\n[ "));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\nsize_ = %d"), this->size_));  
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\nmax_handle_ = %d"), this->max_handle_));  
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\n[ ")));
 
 #if defined (ACE_WIN32)
-  for (size_t i = 0; i < this->mask_.fd_count + 1; i++) 
-    ACE_DEBUG ((LM_DEBUG, " %x ", this->mask_.fd_array[i]));
+  for (ssize_t i = 0; i < this->mask_.fd_count + 1; i++) 
+    ACE_DEBUG ((LM_DEBUG, ASYS_TEXT(" %x "), this->mask_.fd_array[i]));
 #else /* !ACE_WIN32 */
   for (ACE_HANDLE i = 0; i < this->max_handle_ + 1; i++) 
     if (this->is_set (i))
-      ACE_DEBUG ((LM_DEBUG, " %d ", i));
+      ACE_DEBUG ((LM_DEBUG, ASYS_TEXT(" %d "), i));
 #endif /* ACE_WIN32 */
 
-  ACE_DEBUG ((LM_DEBUG, " ]\n"));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT(" ]\n")));
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
 
@@ -222,12 +222,12 @@ ACE_Handle_Set_Iterator::dump (void) const
 
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 #if defined(ACE_WIN32) || !defined(ACE_HAS_BIG_FD_SET)
-  ACE_DEBUG ((LM_DEBUG, "\nhandle_index_ = %d", this->handle_index_));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\nhandle_index_ = %d"), this->handle_index_));
 #elif defined(ACE_HAS_BIG_FD_SET)
-  ACE_DEBUG ((LM_DEBUG, "\nword_max_ = %d", this->word_max_));
-  ACE_DEBUG ((LM_DEBUG, "\nword_val_ = %d", this->word_val_));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\nword_max_ = %d"), this->word_max_));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\nword_val_ = %d"), this->word_val_));
 #endif
-  ACE_DEBUG ((LM_DEBUG, "\nword_num_ = %d", this->word_num_));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\nword_num_ = %d"), this->word_num_));
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
 
diff --git a/ace/IPC_SAP.cpp b/ace/IPC_SAP.cpp
index 421f0d67672..3770694befa 100644
--- a/ace/IPC_SAP.cpp
+++ b/ace/IPC_SAP.cpp
@@ -11,8 +11,8 @@ ACE_IPC_SAP::dump (void) const
   ACE_TRACE ("ACE_IPC_SAP::dump");
 
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
-  ACE_DEBUG ((LM_DEBUG, "handle_ = %d", this->handle_));
-  ACE_DEBUG ((LM_DEBUG, "\npid_ = %d", this->pid_));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("handle_ = %d"), this->handle_));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("\npid_ = %d"), this->pid_));
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
 
diff --git a/ace/Malloc.cpp b/ace/Malloc.cpp
index 4e9e78e552e..57f94a23874 100644
--- a/ace/Malloc.cpp
+++ b/ace/Malloc.cpp
@@ -28,7 +28,7 @@ ACE_Control_Block::dump (void) const
 
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
   this->name_head_->dump ();
-  ACE_DEBUG ((LM_DEBUG, "freep_ = %x", this->freep_));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("freep_ = %x"), this->freep_));
 
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
@@ -54,10 +54,10 @@ ACE_Name_Node::dump (void) const
   ACE_TRACE ("ACE_Name_Node");
 
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
-  ACE_DEBUG ((LM_DEBUG, "pointer = %x", this->pointer_));
-  ACE_DEBUG ((LM_DEBUG, "\nnext_ = %x", this->next_));
-  ACE_DEBUG ((LM_DEBUG, "\nname_ = %s", this->name_));
-  ACE_DEBUG ((LM_DEBUG, "\n"));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("pointer = %x"), this->pointer_));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\nnext_ = %x"), this->next_));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\nname_ = %s"), this->name_));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\n")));
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
 
@@ -138,10 +138,10 @@ ACE_Malloc_Stats::dump (void) const
   int ninuse  = this->ninuse_.value ();
   int nchunks = this->nchunks_.value ();
 
-  ACE_DEBUG ((LM_DEBUG, "nblocks = %d", nblocks));
-  ACE_DEBUG ((LM_DEBUG, "\nninuse = %d", ninuse));
-  ACE_DEBUG ((LM_DEBUG, "\nnchunks = %d", nchunks));
-  ACE_DEBUG ((LM_DEBUG, "\n"));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("nblocks = %d"), nblocks));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\nninuse = %d"), ninuse));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\nnchunks = %d"), nchunks));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\n")));
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
 
diff --git a/ace/Malloc_T.cpp b/ace/Malloc_T.cpp
index 2ebcd4fc868..45f2c3b220a 100644
--- a/ace/Malloc_T.cpp
+++ b/ace/Malloc_T.cpp
@@ -70,8 +70,8 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::dump (void) const
 
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
   this->memory_pool_.dump ();
-  ACE_DEBUG ((LM_DEBUG, "cb_ptr_ = %x", this->cb_ptr_));
-  ACE_DEBUG ((LM_DEBUG, "\n"));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("cb_ptr_ = %x"), this->cb_ptr_));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\n")));
 #if defined (ACE_HAS_MALLOC_STATS)
   this->cp_ptr_->malloc_stats_.dump ();
 #endif /* ACE_HAS_MALLOC_STATS */
@@ -87,14 +87,14 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::print_stats (void) const
   ACE_GUARD (ACE_LOCK, ace_mon, this->lock_);
 
   this->cb_ptr_->malloc_stats_.dump ();
-  ACE_DEBUG ((LM_DEBUG, "(%P|%t) contents of freelist:\n"));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("(%P|%t) contents of freelist:\n")));
 
   for (ACE_Malloc_Header *currp = this->cb_ptr_->freep_->s_.next_block_; 
        ; 
        currp = currp->s_.next_block_)
     {
       ACE_DEBUG ((LM_DEBUG, 
-		  "(%P|%t) ptr = %u, ACE_Malloc_Header units = %d, byte units = %d\n", 
+		  ASYS_TEXT ("(%P|%t) ptr = %u, ACE_Malloc_Header units = %d, byte units = %d\n"), 
 		  currp, currp->s_.size_, 
 		  currp->s_.size_ * sizeof (ACE_Malloc_Header)));
       if (currp == this->cb_ptr_->freep_)
@@ -138,7 +138,7 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::open (void)
     ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t) %p\n", "init_acquire failed"), -1);
   else if (first_time)
     {
-      // ACE_DEBUG ((LM_DEBUG, "(%P|%t) first time in, control block = %u\n", this->cb_ptr_));
+      // ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("(%P|%t) first time in, control block = %u\n"), this->cb_ptr_));
 
 #if defined (ACE_HAS_MALLOC_STATS)
       // Call the constructor on the ACE_LOCK, using the placement
@@ -227,7 +227,7 @@ template <ACE_MEM_POOL_1, class ACE_LOCK> int
 ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::remove (void)
 {
   ACE_TRACE ("ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::remove");
-  // ACE_DEBUG ((LM_DEBUG, "(%P|%t) destroying ACE_Malloc\n"));
+  // ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("(%P|%t) destroying ACE_Malloc\n")));
   int result = 0;
 
 #if defined (ACE_HAS_MALLOC_STATS)
@@ -574,8 +574,8 @@ ACE_Malloc_Iterator<ACE_MEM_POOL_2, ACE_LOCK>::dump (void) const
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
   this->curr_->dump ();
   this->guard_.dump ();
-  ACE_DEBUG ((LM_DEBUG, "name_ = %s", this->name_));
-  ACE_DEBUG ((LM_DEBUG, "\n"));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("name_ = %s"), this->name_));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\n")));
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
 
diff --git a/ace/Message_Block.cpp b/ace/Message_Block.cpp
index 31d86595042..e3709d700ab 100644
--- a/ace/Message_Block.cpp
+++ b/ace/Message_Block.cpp
@@ -67,22 +67,22 @@ ACE_Data_Block::dump (void) const
   ACE_TRACE ("ACE_Data_Block::dump");
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
   ACE_DEBUG ((LM_DEBUG,
-	     "-----( Data Block )-----\n"
-	     "type_ = %d\n"
-	     "cur_size_ = %u\n"
-	     "max_size_ = %u\n"
-	     "flags_ = %u\n"
-	     "base_ = %u\n"
-	     "locking_strategy_ = %u\n"
-	     "reference_count_ = %u\n"
-	     "---------------------------\n",
-	     this->type_,
-	     this->cur_size_,
-	     this->max_size_,
-	     this->flags_,
-	     this->base_,
-	     this->locking_strategy_,
-	     this->reference_count_));
+              ASYS_TEXT ("-----( Data Block )-----\n")
+              ASYS_TEXT ("type_ = %d\n")
+              ASYS_TEXT ("cur_size_ = %u\n")
+              ASYS_TEXT ("max_size_ = %u\n")
+              ASYS_TEXT ("flags_ = %u\n")
+              ASYS_TEXT ("base_ = %u\n")
+              ASYS_TEXT ("locking_strategy_ = %u\n")
+              ASYS_TEXT ("reference_count_ = %u\n")
+              ASYS_TEXT ("---------------------------\n"),
+              this->type_,
+              this->cur_size_,
+              this->max_size_,
+              this->flags_,
+              this->base_,
+              this->locking_strategy_,
+              this->reference_count_));
   this->allocator_strategy_->dump ();
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
@@ -93,20 +93,20 @@ ACE_Message_Block::dump (void) const
   ACE_TRACE ("ACE_Message_Block::dump");
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
   ACE_DEBUG ((LM_DEBUG,
-	     "-----( Message Block )-----\n"
-	     "priority_ = %d\n"
-	     "next_ = %u\n"
-	     "prev_ = %u\n"
-	     "cont_ = %u\n"
-	     "rd_ptr_ = %u\n"
-	     "wr_ptr_ = %u\n"
-	     "---------------------------\n",
-	     this->priority_,
-	     this->next_,
-	     this->prev_,
-	     this->cont_,
-	     this->rd_ptr_,
-	     this->wr_ptr_));
+              ASYS_TEXT ("-----( Message Block )-----\n")
+              ASYS_TEXT ("priority_ = %d\n")
+              ASYS_TEXT ("next_ = %u\n")
+              ASYS_TEXT ("prev_ = %u\n")
+              ASYS_TEXT ("cont_ = %u\n")
+              ASYS_TEXT ("rd_ptr_ = %u\n")
+              ASYS_TEXT ("wr_ptr_ = %u\n")
+              ASYS_TEXT ("---------------------------\n"),
+              this->priority_,
+              this->next_,
+              this->prev_,
+              this->cont_,
+              this->rd_ptr_,
+              this->wr_ptr_));
   this->data_block ()->dump ();
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
@@ -221,7 +221,7 @@ ACE_Message_Block::ACE_Message_Block (const char *data,
 		    ACE_Message_Block::DONT_DELETE, // flags
 		    0, // priority
 		    0) == -1) // data block
-    ACE_ERROR ((LM_ERROR, "ACE_Message_Block"));
+    ACE_ERROR ((LM_ERROR, ASYS_TEXT ("ACE_Message_Block")));
 }
 
 ACE_Message_Block::ACE_Message_Block (void)
@@ -237,7 +237,7 @@ ACE_Message_Block::ACE_Message_Block (void)
 		    ACE_Message_Block::DONT_DELETE, // flags
 		    0, // priority
 		    0) == -1) // data block
-    ACE_ERROR ((LM_ERROR, "ACE_Message_Block"));
+    ACE_ERROR ((LM_ERROR, ASYS_TEXT ("ACE_Message_Block")));
 }
 
 ACE_Message_Block::ACE_Message_Block (size_t size,
@@ -259,7 +259,7 @@ ACE_Message_Block::ACE_Message_Block (size_t size,
 		    msg_data ? ACE_Message_Block::DONT_DELETE : 0,
 		    priority,
 		    0) == -1) // data block
-    ACE_ERROR ((LM_ERROR, "ACE_Message_Block"));
+    ACE_ERROR ((LM_ERROR, ASYS_TEXT ("ACE_Message_Block")));
 }
 
 int
@@ -323,7 +323,7 @@ ACE_Message_Block::ACE_Message_Block (size_t size,
 		    flags,
 		    priority,
 		    db) == -1)
-    ACE_ERROR ((LM_ERROR, "ACE_Message_Block"));
+    ACE_ERROR ((LM_ERROR, ASYS_TEXT ("ACE_Message_Block")));
 }
 
 ACE_Message_Block::ACE_Message_Block (ACE_Data_Block *data_block)
@@ -339,7 +339,7 @@ ACE_Message_Block::ACE_Message_Block (ACE_Data_Block *data_block)
 		    0,         // flags
 		    0,         // priority
 		    data_block) == -1) // data block
-    ACE_ERROR ((LM_ERROR, "ACE_Message_Block"));
+    ACE_ERROR ((LM_ERROR, ASYS_TEXT ("ACE_Message_Block")));
 }
 
 int
diff --git a/ace/SOCK.cpp b/ace/SOCK.cpp
index 7b30cb7d6fc..3347ae4652d 100644
--- a/ace/SOCK.cpp
+++ b/ace/SOCK.cpp
@@ -99,5 +99,5 @@ ACE_SOCK::ACE_SOCK (int type,
   ACE_TRACE ("ACE_SOCK::ACE_SOCK");
   if (this->open (type, protocol_family, 
                   protocol, reuse_addr) == -1)
-    ACE_ERROR ((LM_ERROR, "%p\n", "ACE_SOCK::ACE_SOCK"));
+    ACE_ERROR ((LM_ERROR, ASYS_TEXT ("%p\n"), ASYS_TEXT ("ACE_SOCK::ACE_SOCK")));
 }
diff --git a/ace/SOCK_Acceptor.cpp b/ace/SOCK_Acceptor.cpp
index f83a3ef90ca..612d4a6b993 100644
--- a/ace/SOCK_Acceptor.cpp
+++ b/ace/SOCK_Acceptor.cpp
@@ -50,7 +50,7 @@ ACE_SOCK_Acceptor::ACE_SOCK_Acceptor (const ACE_Addr &local_sap,
   ACE_TRACE ("ACE_SOCK_Acceptor::ACE_SOCK_Acceptor");
   if (this->open (local_sap, reuse_addr, protocol_family, 
 		  backlog, protocol) == -1)
-    ACE_ERROR ((LM_ERROR, "%p\n", "ACE_SOCK_Acceptor"));
+    ACE_ERROR ((LM_ERROR, ASYS_TEXT ("%p\n"), ASYS_TEXT ("ACE_SOCK_Acceptor")));
 }
 
 void
diff --git a/ace/Synch.cpp b/ace/Synch.cpp
index 806027f3084..0732dc4f9f4 100644
--- a/ace/Synch.cpp
+++ b/ace/Synch.cpp
@@ -113,7 +113,7 @@ ACE_RW_Mutex::dump (void) const
 // ACE_TRACE ("ACE_RW_Mutex::dump");
 
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
-  ACE_DEBUG ((LM_DEBUG, "\n"));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\n")));
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
 
@@ -121,7 +121,7 @@ ACE_RW_Mutex::ACE_RW_Mutex (int type, LPCTSTR name, void *arg)
 {
 // ACE_TRACE ("ACE_RW_Mutex::ACE_RW_Mutex");
   if (ACE_OS::rwlock_init (&this->lock_, type, name, arg) != 0)
-    ACE_ERROR ((LM_ERROR, "%p\n", "ACE_RW_Mutex::ACE_RW_Mutex"));
+    ACE_ERROR ((LM_ERROR, ASYS_TEXT("%p\n"), ASYS_TEXT("ACE_RW_Mutex::ACE_RW_Mutex")));
 }
 
 ACE_RW_Mutex::~ACE_RW_Mutex (void)
@@ -138,7 +138,7 @@ ACE_Semaphore::dump (void) const
 // ACE_TRACE ("ACE_Semaphore::dump");
 
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
-  ACE_DEBUG ((LM_DEBUG, "\n"));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\n")));
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
 
@@ -151,7 +151,7 @@ ACE_Semaphore::ACE_Semaphore (u_int count,
 // ACE_TRACE ("ACE_Semaphore::ACE_Semaphore");
   if (ACE_OS::sema_init (&this->semaphore_, count, type,
                          name, arg, max) != 0)
-    ACE_ERROR ((LM_ERROR, "%p\n", "ACE_Semaphore::ACE_Semaphore"));
+    ACE_ERROR ((LM_ERROR, ASYS_TEXT("%p\n"), ASYS_TEXT("ACE_Semaphore::ACE_Semaphore")));
 }
 
 ACE_Semaphore::~ACE_Semaphore (void)
@@ -174,7 +174,7 @@ ACE_File_Lock::ACE_File_Lock (ACE_HANDLE h)
 {
 // ACE_TRACE ("ACE_File_Lock::ACE_File_Lock");
   if (ACE_OS::flock_init (&this->lock_) == -1)
-    ACE_ERROR ((LM_ERROR, "%p\n", "ACE_File_Lock::ACE_File_Lock"));
+    ACE_ERROR ((LM_ERROR, ASYS_TEXT("%p\n"), ASYS_TEXT("ACE_File_Lock::ACE_File_Lock")));
   this->set_handle (h);
 }
 
@@ -185,7 +185,7 @@ ACE_File_Lock::ACE_File_Lock (LPCTSTR name,
 // ACE_TRACE ("ACE_File_Lock::ACE_File_Lock");
 
   if (this->open (name, flags, perms) == -1)
-    ACE_ERROR ((LM_ERROR, "%p\n", "ACE_File_Lock::ACE_File_Lock"));
+    ACE_ERROR ((LM_ERROR, ASYS_TEXT("%p\n"), ASYS_TEXT("ACE_File_Lock::ACE_File_Lock")));
 }
 
 int
@@ -232,7 +232,7 @@ ACE_Process_Semaphore::~ACE_Process_Semaphore (void)
 {
 // ACE_TRACE ("ACE_Process_Semaphore::~ACE_Process_Semaphore");
   //  if (this->remove () == -1)
-  //    ACE_ERROR ((LM_ERROR, "%p\n", "ACE_Process_Mutex::~ACE_Process_Mutex"));
+  //    ACE_ERROR ((LM_ERROR, ASYS_TEXT("%p\n"), ASYS_TEXT("ACE_Process_Mutex::~ACE_Process_Mutex")));
 }
 
 // Explicitly destroy the semaphore.
@@ -282,7 +282,7 @@ ACE_Mutex::dump (void) const
 // ACE_TRACE ("ACE_Mutex::dump");
 
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
-  ACE_DEBUG ((LM_DEBUG, "\n"));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\n")));
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
 
@@ -291,7 +291,7 @@ ACE_Mutex::ACE_Mutex (int type, LPCTSTR name, void *arg)
 // ACE_TRACE ("ACE_Mutex::ACE_Mutex");
 
   if (ACE_OS::mutex_init (&this->lock_, type, name, arg) != 0)
-    ACE_ERROR ((LM_ERROR, "%p\n", "ACE_Mutex::ACE_Mutex"));
+    ACE_ERROR ((LM_ERROR, ASYS_TEXT("%p\n"), ASYS_TEXT("ACE_Mutex::ACE_Mutex")));
 }
 
 ACE_Mutex::~ACE_Mutex (void)
@@ -312,7 +312,7 @@ ACE_Event::ACE_Event (int manual_reset,
                           type,
                           name,
                           arg) != 0)
-    ACE_ERROR ((LM_ERROR, "%p\n", "ACE_Event::ACE_Event"));
+    ACE_ERROR ((LM_ERROR, ASYS_TEXT("%p\n"), ASYS_TEXT("ACE_Event::ACE_Event")));
 }
 
 ACE_Event::~ACE_Event (void)
@@ -439,7 +439,7 @@ ACE_Thread_Mutex_Guard::dump (void) const
 // ACE_TRACE ("ACE_Thread_Mutex_Guard::dump");
 
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
-  ACE_DEBUG ((LM_DEBUG, "\n"));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\n")));
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
 
@@ -591,11 +591,11 @@ ACE_Recursive_Thread_Mutex::dump (void) const
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
   this->lock_available_.dump ();
   this->nesting_mutex_.dump ();
-  ACE_DEBUG ((LM_DEBUG, "nesting_level_ = %d", this->nesting_level_));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("nesting_level_ = %d"), this->nesting_level_));
 #if !defined (ACE_HAS_DCETHREADS) && !defined (ACE_HAS_PTHREADS)
-  ACE_DEBUG ((LM_DEBUG, "\nowner_id_ = %u", this->owner_id_));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\nowner_id_ = %u"), this->owner_id_));
 #else
-  ACE_DEBUG ((LM_DEBUG, "\n"));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\n")));
 #endif /* !ACE_HAS_DCETHREADS */
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
@@ -609,10 +609,10 @@ ACE_Condition_Thread_Mutex::dump (void) const
 // ACE_TRACE ("ACE_Condition_Thread_Mutex::dump");
 
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
-  ACE_DEBUG ((LM_DEBUG, "\n"));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\n")));
 #if defined (ACE_WIN32)
   ACE_DEBUG ((LM_DEBUG,
-              "waiters = %d\n",
+              ASYS_TEXT ("waiters = %d\n"),
               this->cond_.waiters ()));
 #endif /* ACE_WIN32 */
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
@@ -632,8 +632,8 @@ ACE_Condition_Thread_Mutex::ACE_Condition_Thread_Mutex (const ACE_Thread_Mutex &
 
 // ACE_TRACE ("ACE_Condition_Thread_Mutex::ACE_Condition_Thread_Mutex");
   if (ACE_OS::cond_init (&this->cond_, USYNC_THREAD, name, arg) != 0)
-    ACE_ERROR ((LM_ERROR, "%p\n",
-                "ACE_Condition_Thread_Mutex::ACE_Condition_Thread_Mutex"));
+    ACE_ERROR ((LM_ERROR, ASYS_TEXT ("%p\n"),
+                ASYS_TEXT ("ACE_Condition_Thread_Mutex::ACE_Condition_Thread_Mutex")));
 }
 
 ACE_Condition_Thread_Mutex::~ACE_Condition_Thread_Mutex (void)
@@ -693,8 +693,8 @@ ACE_Sub_Barrier::dump (void) const
 
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
   this->barrier_finished_.dump ();
-  ACE_DEBUG ((LM_DEBUG, "running_threads_ = %d", this->running_threads_));
-  ACE_DEBUG ((LM_DEBUG, "\n"));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("running_threads_ = %d"), this->running_threads_));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\n")));
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
 
@@ -719,8 +719,8 @@ ACE_Barrier::dump (void) const
 
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
   this->lock_.dump ();
-  ACE_DEBUG ((LM_DEBUG, "current_generation_ = %d", this->current_generation_));
-  ACE_DEBUG ((LM_DEBUG, "\ncount_ = %d", this->count_));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("current_generation_ = %d"), this->current_generation_));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\ncount_ = %d"), this->count_));
   this->sub_barrier_1_.dump ();
   this->sub_barrier_2_.dump ();
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
@@ -829,7 +829,7 @@ ACE_Thread_Mutex::dump (void) const
 // ACE_TRACE ("ACE_Thread_Mutex::dump");
 
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
-  ACE_DEBUG ((LM_DEBUG, "\n"));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\n")));
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
 
@@ -844,7 +844,7 @@ ACE_Thread_Mutex::ACE_Thread_Mutex (LPCTSTR name, void *arg)
 //  ACE_TRACE ("ACE_Thread_Mutex::ACE_Thread_Mutex");
 
   if (ACE_OS::thread_mutex_init (&this->lock_, USYNC_THREAD, name, arg) != 0)
-    ACE_ERROR ((LM_ERROR, "%p\n", "ACE_Thread_Mutex::ACE_Thread_Mutex"));
+    ACE_ERROR ((LM_ERROR, ASYS_TEXT("%p\n"), ASYS_TEXT("ACE_Thread_Mutex::ACE_Thread_Mutex")));
 }
 
 ACE_ALLOC_HOOK_DEFINE(ACE_RW_Thread_Mutex)