1 files changed, 83 insertions, 83 deletions

diff --git a/ace/Local_Tokens.cpp b/ace/Local_Tokens.cpp
index c8b3f39efa2..e1f47c3e760 100644
--- a/ace/Local_Tokens.cpp
+++ b/ace/Local_Tokens.cpp
@@ -16,11 +16,11 @@ ACE_Tokens::dump (void) const
 {
   ACE_TRACE ("ACE_Tokens::dump");
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
-  ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("ACE_Tokens::dump:\n")
-			ASYS_TEXT (" reference_cont_ = %d\n")
-			ASYS_TEXT (" token_name_ = %s\n"),
+  ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("ACE_Tokens::dump:\n")
+			ACE_TEXT (" reference_cont_ = %d\n")
+			ACE_TEXT (" token_name_ = %s\n"),
 			reference_count_, token_name_));
-  ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("waiters_\n")));
+  ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("waiters_\n")));
   this->waiters_.dump ();
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
@@ -55,24 +55,24 @@ ACE_TPQ_Entry::dump (void) const
   ACE_TRACE ("ACE_TPQ_Entry::dump");
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
   ACE_DEBUG ((LM_DEBUG,
-	      ASYS_TEXT ("ACE_TPQ_Entry::dump:\n")
-	      ASYS_TEXT (" nesting_level_ = %d\n")
-	      ASYS_TEXT (" client_id_ = %s\n"),
+	      ACE_TEXT ("ACE_TPQ_Entry::dump:\n")
+	      ACE_TEXT (" nesting_level_ = %d\n")
+	      ACE_TEXT (" client_id_ = %s\n"),
 	      nesting_level_,
 	      client_id_));
 
   if (next_ != 0)
     {
-      ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("next:.\n")));
+      ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("next:.\n")));
       next_->dump ();
     }
 
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("ACE_TPQ_Entry::dump end.\n")));
+  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE_TPQ_Entry::dump end.\n")));
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
 
 ACE_TPQ_Entry::ACE_TPQ_Entry (const ACE_Token_Proxy *new_proxy,
-			      const ASYS_TCHAR *client_id)
+			      const ACE_TCHAR *client_id)
   : cond_var_ (lock_),
     next_ (0),
     // This const typecast is safe.
@@ -87,12 +87,12 @@ ACE_TPQ_Entry::ACE_TPQ_Entry (const ACE_Token_Proxy *new_proxy,
   else
     {
       // Just make sure we have enough space.
-      ASYS_TCHAR host_name[MAXHOSTNAMELEN];
-      ASYS_TCHAR name[(sizeof host_name / sizeof (ASYS_TCHAR)) + 256];
+      ACE_TCHAR host_name[MAXHOSTNAMELEN];
+      ACE_TCHAR name[(sizeof host_name / sizeof (ACE_TCHAR)) + 256];
       ACE_OS::hostname (host_name, sizeof host_name);
 
       ACE_OS::sprintf (name,
-		       ASYS_TEXT ("/%s/%u/%lu"),
+		       ACE_TEXT ("/%s/%u/%lu"),
 		       host_name,
 		       ACE_static_cast (unsigned int, ACE_OS::getpid ()),
 		       ACE_Thread::self ());
@@ -135,7 +135,7 @@ ACE_TPQ_Entry::operator= (const ACE_TPQ_Entry& rhs)
 }
 
 void
-ACE_TPQ_Entry::client_id (const ASYS_TCHAR *id)
+ACE_TPQ_Entry::client_id (const ACE_TCHAR *id)
 {
   ACE_TRACE ("ACE_TPQ_Entry::client_id");
 
@@ -147,7 +147,7 @@ ACE_TPQ_Entry::client_id (const ASYS_TCHAR *id)
   if (n >= ACE_MAXCLIENTIDLEN)
     n = ACE_MAXCLIENTIDLEN - 1;
 
-  ACE_OS::strncpy (this->client_id_, (ASYS_TCHAR *) id, n);
+  ACE_OS::strncpy (this->client_id_, (ACE_TCHAR *) id, n);
   this->client_id_[ACE_MAXCLIENTIDLEN - 1] = '\0';
 }
 
@@ -161,17 +161,17 @@ ACE_TSS_TPQ_Entry::dump (void) const
 			(char *) " client_id_ = %s\n",
 			(char *) client_id_ == 0 ? (char *) "0" : (char *) client_id_));
 #else /* ! defined (ACE_HAS_BROKEN_CONDITIONAL_STRING_CASTS) */
-  ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("ACE_TSS_TPQ_Entry::dump:\n")
-			ASYS_TEXT (" client_id_ = %s\n"),
-			client_id_ == 0 ? ASYS_TEXT ("0") : client_id_));
+  ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("ACE_TSS_TPQ_Entry::dump:\n")
+			ACE_TEXT (" client_id_ = %s\n"),
+			client_id_ == 0 ? ACE_TEXT ("0") : client_id_));
 #endif /* ! defined (ACE_HAS_BROKEN_CONDITIONAL_STRING_CASTS) */
-  ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("base:\n")));
+  ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("base:\n")));
   ACE_TPQ_ENTRY::dump ();
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
 
 ACE_TSS_TPQ_Entry::ACE_TSS_TPQ_Entry (const ACE_Token_Proxy *proxy,
-				      const ASYS_TCHAR *client_id)
+				      const ACE_TCHAR *client_id)
 : proxy_ (proxy),
   client_id_ (client_id)
 {
@@ -244,10 +244,10 @@ ACE_TPQ_Iterator::dump (void) const
 {
   ACE_TRACE ("ACE_TPQ_Iterator::dump");
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
-  ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("ACE_TPQ_Iterator::dump:\n")
-	      ASYS_TEXT (" current_ = %d\n"),
+  ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("ACE_TPQ_Iterator::dump:\n")
+	      ACE_TEXT (" current_ = %d\n"),
 	      (long) this->current_));
-  ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("head_ and tail_\n")));
+  ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("head_ and tail_\n")));
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
 
@@ -256,14 +256,14 @@ ACE_Token_Proxy_Queue::dump (void) const
 {
   ACE_TRACE ("ACE_Token_Proxy_Queue::dump");
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("ACE_Token_Proxy_Queue::dump:\n")
-			ASYS_TEXT (" size_ = %d\n"),
+  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE_Token_Proxy_Queue::dump:\n")
+			ACE_TEXT (" size_ = %d\n"),
 			size_));
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("head_ and tail_\n")));
+  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("head_ and tail_\n")));
   if (this->head_ != 0)
     this->head_->dump ();
 
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("ACE_Token_Proxy_Queue::dump end.\n")));
+  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE_Token_Proxy_Queue::dump end.\n")));
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
 
@@ -345,13 +345,13 @@ ACE_Token_Proxy_Queue::dequeue (void)
 
   if (this->head_ == 0 && this->size_ != 0)
     ACE_ERROR ((LM_ERROR,
-                ASYS_TEXT ("incorrect size = %d\n"),
+                ACE_TEXT ("incorrect size = %d\n"),
                 this->size_));
 }
 
 /*
 int
-ACE_Token_Proxy_Queue::member (const ASYS_TCHAR *id)
+ACE_Token_Proxy_Queue::member (const ACE_TCHAR *id)
 {
   ACE_TRACE ("ACE_Token_Proxy_Queue::member");
 
@@ -418,16 +418,16 @@ ACE_Mutex_Token::dump (void) const
 {
   ACE_TRACE ("ACE_Mutex_Token::dump");
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
-  ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("ACE_Mutex_Token::dump:\n")));
-  ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("lock_\n")));
+  ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("ACE_Mutex_Token::dump:\n")));
+  ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("lock_\n")));
   lock_.dump ();
-  ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("base:\n")));
+  ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("base:\n")));
   ACE_Tokens::dump ();
-  ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("ACE_Mutex_Token::dump end.\n")));
+  ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("ACE_Mutex_Token::dump end.\n")));
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
 
-ACE_Mutex_Token::ACE_Mutex_Token (const ASYS_TCHAR *name)
+ACE_Mutex_Token::ACE_Mutex_Token (const ACE_TCHAR *name)
 {
   ACE_TRACE ("ACE_Mutex_Token::ACE_Mutex_Token");
 
@@ -599,7 +599,7 @@ ACE_Mutex_Token::release (ACE_TPQ_Entry *caller)
 
 int
 ACE_Mutex_Token::owners (OWNER_STACK &stack,
-			 const ASYS_TCHAR *id)
+			 const ACE_TCHAR *id)
 {
   ACE_TRACE ("ACE_Mutex_Token::owners");
   if (this->owner () != 0)
@@ -615,7 +615,7 @@ ACE_Mutex_Token::owners (OWNER_STACK &stack,
 }
 
 int
-ACE_Mutex_Token::is_waiting_for (const ASYS_TCHAR *id)
+ACE_Mutex_Token::is_waiting_for (const ACE_TCHAR *id)
 {
   ACE_TRACE ("ACE_Mutex_Token::is_waiting_for");
   // If there is no owner, or <id> is the owner, return false.
@@ -637,7 +637,7 @@ ACE_Mutex_Token::is_waiting_for (const ASYS_TCHAR *id)
 }
 
 int
-ACE_Mutex_Token::is_owner (const ASYS_TCHAR *id)
+ACE_Mutex_Token::is_owner (const ACE_TCHAR *id)
 {
   ACE_TRACE ("ACE_Mutex_Token::is_owner");
   // If there is an owner, return whether it is <id>.
@@ -653,17 +653,17 @@ ACE_RW_Token::dump (void) const
 {
   ACE_TRACE ("ACE_RW_Token::dump");
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
-  ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("ACE_RW_Token::dump:\n")
-			ASYS_TEXT ("num_writers_ = %d\n"), num_writers_));
-  ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("lock_\n")));
+  ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("ACE_RW_Token::dump:\n")
+			ACE_TEXT ("num_writers_ = %d\n"), num_writers_));
+  ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("lock_\n")));
   this->lock_.dump ();
-  ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("base:\n")));
+  ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("base:\n")));
   ACE_Tokens::dump ();
-  ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("ACE_RW_Token::dump end.\n")));
+  ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("ACE_RW_Token::dump end.\n")));
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
 
-ACE_RW_Token::ACE_RW_Token (const ASYS_TCHAR *name)
+ACE_RW_Token::ACE_RW_Token (const ACE_TCHAR *name)
 : num_writers_ (0)
 {
   ACE_TRACE ("ACE_RW_Token::ACE_RW_Token");
@@ -931,7 +931,7 @@ ACE_RW_Token::notify_new_owner (ACE_TPQ_Entry *old_owner)
 
 int
 ACE_RW_Token::owners (OWNER_STACK &stack,
-		      const ASYS_TCHAR *id)
+		      const ACE_TCHAR *id)
 {
   ACE_TRACE ("ACE_RW_Token::owners");
 
@@ -975,7 +975,7 @@ ACE_RW_Token::owners (OWNER_STACK &stack,
 }
 
 int
-ACE_RW_Token::is_waiting_for (const ASYS_TCHAR *id)
+ACE_RW_Token::is_waiting_for (const ACE_TCHAR *id)
 {
   ACE_TRACE ("ACE_RW_Token::is_waiting_for");
   // If there is no owner, or <id> is the owner, return false.
@@ -998,7 +998,7 @@ ACE_RW_Token::is_waiting_for (const ASYS_TCHAR *id)
 }
 
 int
-ACE_RW_Token::is_owner (const ASYS_TCHAR *id)
+ACE_RW_Token::is_owner (const ACE_TCHAR *id)
 {
   ACE_TRACE ("ACE_Mutex_Token::is_owner");
   // If there is no owner, return false.
@@ -1031,22 +1031,22 @@ ACE_Token_Proxy::dump (void) const
 {
   ACE_TRACE ("ACE_Token_Proxy::dump");
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
-  ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("ACE_Token_Proxy::dump:\n")
-			ASYS_TEXT (" type = %d\n")
-			ASYS_TEXT (" ignore_deadlock_ = %d\n")
-			ASYS_TEXT (" debug_ = %d\n"),
+  ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("ACE_Token_Proxy::dump:\n")
+			ACE_TEXT (" type = %d\n")
+			ACE_TEXT (" ignore_deadlock_ = %d\n")
+			ACE_TEXT (" debug_ = %d\n"),
 			(int) this->type (), ignore_deadlock_, debug_));
-  ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("mutex_, and waiter_\n")));
+  ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("mutex_, and waiter_\n")));
 
   if (this->token_ != 0)
     this->token_->dump ();
 
   this->waiter_.dump ();
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("ACE_Token_Proxy::dump end.\n")));
+  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE_Token_Proxy::dump end.\n")));
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
 
-const ASYS_TCHAR *
+const ACE_TCHAR *
 ACE_Token_Proxy::client_id (void) const
 {
   ACE_TRACE ("ACE_Token_Proxy::client_id");
@@ -1055,29 +1055,29 @@ ACE_Token_Proxy::client_id (void) const
     ACE_const_cast (ACE_Token_Proxy *, this);
   const ACE_TPQ_Entry *temp =
     nc_this->waiter_.operator->();
-  const ASYS_TCHAR *id = temp->client_id ();
+  const ACE_TCHAR *id = temp->client_id ();
 
   if (id == 0)
-    return ASYS_TEXT ("ERROR NO CLIENT ID");
+    return ACE_TEXT ("ERROR NO CLIENT ID");
   else
     return id;
 }
 
 void
-ACE_Token_Proxy::client_id (const ASYS_TCHAR *client_id)
+ACE_Token_Proxy::client_id (const ACE_TCHAR *client_id)
 {
   ACE_TRACE ("ACE_Token_Proxy::client_id");
   this->waiter_->client_id (client_id);
 }
 
-const ASYS_TCHAR *
+const ACE_TCHAR *
 ACE_Token_Proxy::owner_id (void)
 {
   ACE_TRACE ("ACE_Token_Proxy::owner_id");
   return this->token_->owner_id ();
 }
 
-const ASYS_TCHAR *
+const ACE_TCHAR *
 ACE_Token_Proxy::name (void) const
 {
   ACE_TRACE ("ACE_Token_Proxy::owner_id");
@@ -1114,7 +1114,7 @@ ACE_Token_Proxy::~ACE_Token_Proxy (void)
 }
 
 int
-ACE_Token_Proxy::open (const ASYS_TCHAR *token_name,
+ACE_Token_Proxy::open (const ACE_TCHAR *token_name,
 		       int ignore_deadlock,
 		       int debug)
 {
@@ -1125,12 +1125,12 @@ ACE_Token_Proxy::open (const ASYS_TCHAR *token_name,
   this->debug_ = debug;
 
   // Used in case a name was not specified.
-  ASYS_TCHAR name[BUFSIZ];
+  ACE_TCHAR name[BUFSIZ];
 
   // We must have a name.
   if (token_name == 0)
     {
-      ACE_OS::sprintf (name, ASYS_TEXT ("token %lx"),
+      ACE_OS::sprintf (name, ACE_TEXT ("token %lx"),
                        ACE_reinterpret_cast (long, this));
       token_name = name;
     }
@@ -1143,7 +1143,7 @@ ACE_Token_Proxy::open (const ASYS_TCHAR *token_name,
   if (this->token_ == 0)
     {
       errno = ENOMEM;
-      ACE_ERROR_RETURN ((LM_ERROR, ASYS_TEXT ("Can't allocate mutex")), -1);
+      ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Can't allocate mutex")), -1);
     }
 
   return 0;
@@ -1158,7 +1158,7 @@ ACE_Token_Proxy::acquire (int notify,
   if (this->token_ == 0)
     {
       errno = ENOENT;
-      ACE_ERROR_RETURN ((LM_ERROR, ASYS_TEXT ("Not open.\n")), -1);
+      ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Not open.\n")), -1);
     }
 
   // Make sure no one calls our token_acquired until we have a chance
@@ -1188,8 +1188,8 @@ ACE_Token_Proxy::acquire (int notify,
 	case EWOULDBLOCK :
 	  if (this->debug_)
 	    ACE_DEBUG ((LM_DEBUG,
-			ASYS_TEXT ("(%t) waiting for %s, owner is %s, ")
-			ASYS_TEXT ("total waiters == %d\n"),
+			ACE_TEXT ("(%t) waiting for %s, owner is %s, ")
+			ACE_TEXT ("total waiters == %d\n"),
 			this->name (),
 			this->token_->owner_id (),
 			token_->no_of_waiters ()));
@@ -1209,8 +1209,8 @@ ACE_Token_Proxy::acquire (int notify,
 	default :
 	  waiter_->cond_var_.mutex ().release ();
 	  ACE_ERROR_RETURN ((LM_ERROR,
-			     ASYS_TEXT ("%p\n"),
-                             ASYS_TEXT ("Token Proxy acquire.")),
+			     ACE_TEXT ("%p\n"),
+                             ACE_TEXT ("Token Proxy acquire.")),
                             -1);
 	}
     }
@@ -1219,7 +1219,7 @@ ACE_Token_Proxy::acquire (int notify,
     {
       if (debug_)
 	ACE_DEBUG ((LM_DEBUG,
-                    ASYS_TEXT ("(%t) acquired %s\n"),
+                    ACE_TEXT ("(%t) acquired %s\n"),
 		    this->name ()));
       waiter_->cond_var_.mutex ().release ();
     }
@@ -1235,7 +1235,7 @@ ACE_Token_Proxy::tryacquire (void (*sleep_hook)(void *))
     {
       errno = ENOENT;
       ACE_ERROR_RETURN ((LM_ERROR,
-                         ASYS_TEXT ("Not open.\n")),
+                         ACE_TEXT ("Not open.\n")),
                         -1);
     }
 
@@ -1253,7 +1253,7 @@ ACE_Token_Proxy::renew (int requeue_position,
     {
       errno = ENOENT;
       ACE_ERROR_RETURN ((LM_ERROR,
-                         ASYS_TEXT ("Not open.\n")),
+                         ACE_TEXT ("Not open.\n")),
                         -1);
     }
 
@@ -1266,10 +1266,10 @@ ACE_Token_Proxy::renew (int requeue_position,
       // check for error
       if (errno != EWOULDBLOCK)
 	ACE_ERROR_RETURN ((LM_ERROR,
-			   ASYS_TEXT ("%p renew failed\n"), ASYS_TEXT ("ACE_Token_Proxy")), -1);
+			   ACE_TEXT ("%p renew failed\n"), ACE_TEXT ("ACE_Token_Proxy")), -1);
 
       if (this->debug_)
-	ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("(%t) renew blocking for %s, owner is %s\n"),
+	ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("(%t) renew blocking for %s, owner is %s\n"),
 		    this->name (),
 		    token_->owner_id ()));
 
@@ -1280,7 +1280,7 @@ ACE_Token_Proxy::renew (int requeue_position,
     // we have the token
     {
       if (this->debug_)
-	ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("(%t) renewed %s\n"),
+	ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("(%t) renewed %s\n"),
 		    this->name ()));
       waiter_->cond_var_.mutex ().release ();
       return 0;
@@ -1315,12 +1315,12 @@ ACE_Token_Proxy::handle_options (ACE_Synch_Options &options,
 	  // We come here if a timeout occurs or some serious
 	  // ACE_Condition object error.
 	  cv.mutex ().release ();
-	  ACE_ERROR_RETURN ((LM_ERROR, ASYS_TEXT ("condition variable wait")
-			     ASYS_TEXT (" bombed.")), -1);
+	  ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("condition variable wait")
+			     ACE_TEXT (" bombed.")), -1);
 	}
 
       if (this->debug_)
-	ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("(%t) unblocking.\n"),
+	ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("(%t) unblocking.\n"),
 		    this->client_id ()));
       cv.mutex ().release ();
       return 0;       // operation succeeded
@@ -1336,7 +1336,7 @@ ACE_Token_Proxy::release (ACE_Synch_Options &)
     {
       errno = ENOENT;
       if (debug_)
-	ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("Must open before releasing.\n")));
+	ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("Must open before releasing.\n")));
       ACE_RETURN (-1);
     }
 
@@ -1345,13 +1345,13 @@ ACE_Token_Proxy::release (ACE_Synch_Options &)
       // Release failed.
       this->token_->remove (this->waiter_);
       if (debug_)
-	ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("(%t) %p.\n"), ASYS_TEXT ("release failed")));
+	ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("(%t) %p.\n"), ACE_TEXT ("release failed")));
       return -1;
     }
   else
     {
       if (this->debug_)
-	ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("(%t) released %s, owner is %s\n"),
+	ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("(%t) released %s, owner is %s\n"),
 		    this->name (),
 		    token_->owner_id ()));
 
@@ -1389,7 +1389,7 @@ ACE_Token_Proxy::token_acquired (ACE_TPQ_Entry *e)
   return;
 }
 
-ACE_Token_Name::ACE_Token_Name (const ASYS_TCHAR *token_name)
+ACE_Token_Name::ACE_Token_Name (const ACE_TCHAR *token_name)
 {
   ACE_TRACE ("ACE_Token_Name::ACE_Token_Name");
   this->name (token_name);
@@ -1416,9 +1416,9 @@ ACE_Token_Name::dump (void) const
 			(char *) " token_name_ = %s\n",
 	      (char *) token_name_ == 0 ? (char *) "no name" : (char *) token_name_));
 #else /* ! defined (ACE_HAS_BROKEN_CONDITIONAL_STRING_CASTS) */
-  ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("ACE_Token_Name::dump:\n")
-			ASYS_TEXT (" token_name_ = %s\n"),
-	      token_name_ == 0 ? ASYS_TEXT ("no name") : token_name_));
+  ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("ACE_Token_Name::dump:\n")
+			ACE_TEXT (" token_name_ = %s\n"),
+	      token_name_ == 0 ? ACE_TEXT ("no name") : token_name_));
 #endif /* ! defined (ACE_HAS_BROKEN_CONDITIONAL_STRING_CASTS) */
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }