ChangeLogTag: Mon Feb 1 17:35:08 UTC 2010 Chris Cleeland <cleeland_c@local>

10 files changed, 576 insertions, 554 deletions

diff --git a/ACE/ChangeLog b/ACE/ChangeLog
index 8d1da17d18b..98fd3a8401f 100644
--- a/ACE/ChangeLog
+++ b/ACE/ChangeLog
@@ -1,3 +1,25 @@
+Mon Feb  1 17:35:08 UTC 2010  Chris Cleeland  <cleeland_c@local>
+
+        * ace/Obstack_T.h:
+        * ace/Obstack_T.inl:
+        * ace/Obstack_T.cpp:
+        * ace/SStringfwd.h:
+        * ace/String_Base.h:
+        * ace/String_Base.inl:
+        * ace/String_Base.cpp:
+        * ace/Tokenizer_T.h:
+        * ace/Tokenizer_T.cpp:
+
+          Integrated changes originally done in OCITAO 1.4a by Steve Totten
+          to fulfill [RT 13868].
+
+          Wed Feb  1 10:40:35 2006  Steve Totten  <totten_s@ociweb.com>
+
+          Changed the use of "CHAR" as a template parameter to "ACE_CHAR_T" to
+          avoid possible clash with "CHAR" used as a preprocessor macro.
+          Thanks to Jennifer Kahng <jennifer dot kahng at lmco dot com> for
+          reporting the problem.  This change resolves [RT 8287].
+
 Mon Feb  1 11:21:30 UTC 2010  Johnny Willemsen  <jwillemsen@remedy.nl>
 
         * ace/Connector.cpp:
@@ -19,7 +41,7 @@ Mon Feb  1 11:21:30 UTC 2010  Johnny Willemsen  <jwillemsen@remedy.nl>
 
 Sun Jan 31 01:04:43 CST 2010  Johnny Willemsen  <jwillemsen@remedy.nl>
 
-	* ACE version 5.7.6 released.
+        * ACE version 5.7.6 released.
 
 Fri Jan 29 14:24:30 UTC 2010  Johnny Willemsen  <jwillemsen@remedy.nl>
 
diff --git a/ACE/ace/Obstack_T.cpp b/ACE/ace/Obstack_T.cpp
index ecce0636b2d..dc1d0acfc6c 100644
--- a/ACE/ace/Obstack_T.cpp
+++ b/ACE/ace/Obstack_T.cpp
@@ -19,11 +19,11 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 
 ACE_ALLOC_HOOK_DEFINE(ACE_Obstack_T)
 
-template <class CHAR> void
-ACE_Obstack_T<CHAR>::dump (void) const
+template <class ACE_CHAR_T> void
+ACE_Obstack_T<ACE_CHAR_T>::dump (void) const
 {
 #if defined (ACE_HAS_DUMP)
-  ACE_TRACE ("ACE_Obstack_T<CHAR>::dump");
+  ACE_TRACE ("ACE_Obstack_T<ACE_CHAR_T>::dump");
 
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
   ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("size_ = %d\n"), this->size_));
@@ -33,13 +33,13 @@ ACE_Obstack_T<CHAR>::dump (void) const
 #endif /* ACE_HAS_DUMP */
 }
 
-template <class CHAR> int
-ACE_Obstack_T<CHAR>::request (size_t len)
+template <class ACE_CHAR_T> int
+ACE_Obstack_T<ACE_CHAR_T>::request (size_t len)
 {
-  ACE_TRACE ("ACE_Obstack_T<CHAR>::request");
+  ACE_TRACE ("ACE_Obstack_T<ACE_CHAR_T>::request");
 
   // normalize the length.
-  len *= sizeof (CHAR);
+  len *= sizeof (ACE_CHAR_T);
 
   // Check to see if there's room for the requested length, including
   // any part of an existing string, if any.
@@ -89,15 +89,15 @@ ACE_Obstack_T<CHAR>::request (size_t len)
   return 0;
 }
 
-template <class CHAR> CHAR *
-ACE_Obstack_T<CHAR>::grow (CHAR c)
+template <class ACE_CHAR_T> ACE_CHAR_T *
+ACE_Obstack_T<ACE_CHAR_T>::grow (ACE_CHAR_T c)
 {
-  ACE_TRACE ("ACE_Obstack_T<CHAR>::grow");
+  ACE_TRACE ("ACE_Obstack_T<ACE_CHAR_T>::grow");
 
   if (this->request (1) == 0)
     {
-      CHAR *retv = reinterpret_cast<CHAR *> (this->curr_->cur_);
-      this->curr_->cur_ += sizeof (CHAR);
+      ACE_CHAR_T *retv = reinterpret_cast<ACE_CHAR_T *> (this->curr_->cur_);
+      this->curr_->cur_ += sizeof (ACE_CHAR_T);
       *retv = c;
       return retv;
     }
@@ -105,10 +105,10 @@ ACE_Obstack_T<CHAR>::grow (CHAR c)
     return 0;
 }
 
-template <class CHAR> ACE_Obchunk *
-ACE_Obstack_T<CHAR>::new_chunk (void)
+template <class ACE_CHAR_T> ACE_Obchunk *
+ACE_Obstack_T<ACE_CHAR_T>::new_chunk (void)
 {
-  ACE_TRACE ("ACE_Obstack_T<CHAR>::new_chunk");
+  ACE_TRACE ("ACE_Obstack_T<ACE_CHAR_T>::new_chunk");
 
   ACE_Obchunk *temp = 0;
 
@@ -120,15 +120,15 @@ ACE_Obstack_T<CHAR>::new_chunk (void)
   return temp;
 }
 
-template <class CHAR>
-ACE_Obstack_T<CHAR>::ACE_Obstack_T (size_t size,
+template <class ACE_CHAR_T>
+ACE_Obstack_T<ACE_CHAR_T>::ACE_Obstack_T (size_t size,
                                     ACE_Allocator *allocator_strategy)
   : allocator_strategy_ (allocator_strategy),
     size_ (size),
     head_ (0),
     curr_ (0)
 {
-  ACE_TRACE ("ACE_Obstack_T<CHAR>::ACE_Obstack");
+  ACE_TRACE ("ACE_Obstack_T<ACE_CHAR_T>::ACE_Obstack");
 
   if (this->allocator_strategy_ == 0)
     ACE_ALLOCATOR (this->allocator_strategy_,
@@ -138,10 +138,10 @@ ACE_Obstack_T<CHAR>::ACE_Obstack_T (size_t size,
   this->curr_ = this->head_;
 }
 
-template <class CHAR>
-ACE_Obstack_T<CHAR>::~ACE_Obstack_T (void)
+template <class ACE_CHAR_T>
+ACE_Obstack_T<ACE_CHAR_T>::~ACE_Obstack_T (void)
 {
-  ACE_TRACE ("ACE_Obstack_T<CHAR>::~ACE_Obstack_T");
+  ACE_TRACE ("ACE_Obstack_T<ACE_CHAR_T>::~ACE_Obstack_T");
 
   ACE_Obchunk *temp = this->head_;
 
@@ -154,23 +154,23 @@ ACE_Obstack_T<CHAR>::~ACE_Obstack_T (void)
     }
 }
 
-template <class CHAR> CHAR *
-ACE_Obstack_T<CHAR>::copy (const CHAR *s,
+template <class ACE_CHAR_T> ACE_CHAR_T *
+ACE_Obstack_T<ACE_CHAR_T>::copy (const ACE_CHAR_T *s,
                            size_t len)
 {
-  ACE_TRACE ("ACE_Obstack_T<CHAR>::copy");
+  ACE_TRACE ("ACE_Obstack_T<ACE_CHAR_T>::copy");
 
   if (this->request (len) != 0)
     return 0;
 
-  size_t tsize = len * sizeof (CHAR);
+  size_t tsize = len * sizeof (ACE_CHAR_T);
   ACE_OS::memcpy (this->curr_->cur_, s, tsize);
   this->curr_->cur_ += tsize ;
   return this->freeze ();
 }
 
-template <class CHAR> void
-ACE_Obstack_T<CHAR>::unwind (void* obj)
+template <class ACE_CHAR_T> void
+ACE_Obstack_T<ACE_CHAR_T>::unwind (void* obj)
 {
   if (obj >= this->curr_->contents_ && obj < this->curr_->end_)
     this->curr_->block_ = this->curr_->cur_ = reinterpret_cast<char*> (obj);
@@ -178,8 +178,8 @@ ACE_Obstack_T<CHAR>::unwind (void* obj)
     this->unwind_i (obj);
 }
 
-template <class CHAR> void
-ACE_Obstack_T<CHAR>::unwind_i (void* obj)
+template <class ACE_CHAR_T> void
+ACE_Obstack_T<ACE_CHAR_T>::unwind_i (void* obj)
 {
   ACE_Obchunk* curr = this->head_;
   while (curr != 0 && (curr->contents_ > obj || curr->end_ < obj))
@@ -194,29 +194,29 @@ ACE_Obstack_T<CHAR>::unwind_i (void* obj)
                 ACE_TEXT ("Deletion of non-existent object.\n%a")));
 }
 
-template <class CHAR> void
-ACE_Obstack_T<CHAR>::release (void)
+template <class ACE_CHAR_T> void
+ACE_Obstack_T<ACE_CHAR_T>::release (void)
 {
-  ACE_TRACE ("ACE_Obstack_T<CHAR>::release");
+  ACE_TRACE ("ACE_Obstack_T<ACE_CHAR_T>::release");
 
   this->curr_ = this->head_;
   this->curr_->block_ = this->curr_->cur_ = this->curr_->contents_;
 }
 
-template <class CHAR> void
-ACE_Obstack_T<CHAR>::grow_fast (CHAR c)
+template <class ACE_CHAR_T> void
+ACE_Obstack_T<ACE_CHAR_T>::grow_fast (ACE_CHAR_T c)
 {
-  * (reinterpret_cast<CHAR *> (this->curr_->cur_)) = c;
-  this->curr_->cur_ += sizeof (CHAR);
+  * (reinterpret_cast<ACE_CHAR_T *> (this->curr_->cur_)) = c;
+  this->curr_->cur_ += sizeof (ACE_CHAR_T);
 }
 
-template <class CHAR> CHAR *
-ACE_Obstack_T<CHAR>::freeze (void)
+template <class ACE_CHAR_T> ACE_CHAR_T *
+ACE_Obstack_T<ACE_CHAR_T>::freeze (void)
 {
-  CHAR *retv = reinterpret_cast<CHAR *> (this->curr_->block_);
-  * (reinterpret_cast<CHAR *> (this->curr_->cur_)) = 0;
+  ACE_CHAR_T *retv = reinterpret_cast<ACE_CHAR_T *> (this->curr_->block_);
+  * (reinterpret_cast<ACE_CHAR_T *> (this->curr_->cur_)) = 0;
 
-  this->curr_->cur_ += sizeof (CHAR);
+  this->curr_->cur_ += sizeof (ACE_CHAR_T);
   this->curr_->block_ = this->curr_->cur_;
   return retv;
 }
diff --git a/ACE/ace/Obstack_T.h b/ACE/ace/Obstack_T.h
index 3e24ab31925..ed1d1d20259 100644
--- a/ACE/ace/Obstack_T.h
+++ b/ACE/ace/Obstack_T.h
@@ -34,12 +34,12 @@ class ACE_Allocator;
  * The implementation is similar to the GNU obstack utility,
  * which is used extensively in the GCC compiler.
  */
-template <class CHAR>
+template <class ACE_CHAR_T>
 class ACE_Obstack_T
 {
 public:
   // = Initialization and termination methods.
-  ACE_Obstack_T (size_t size = (4096 * sizeof (CHAR)) - sizeof (ACE_Obchunk),
+  ACE_Obstack_T (size_t size = (4096 * sizeof (ACE_CHAR_T)) - sizeof (ACE_Obchunk),
                  ACE_Allocator *allocator_strategy = 0);
   ~ACE_Obstack_T (void);
 
@@ -47,32 +47,32 @@ public:
   /// a new string.  Return -1 if fail, 0 if success.
   int request (size_t len);
 
-  /// Inserting a new CHAR \a c into the current building
+  /// Inserting a new ACE_CHAR_T \a c into the current building
   /// block without freezing (null terminating) the block.
   /// This function will create new chunk by checking the
   /// boundary of current Obchunk.  Return
   /// the location \a c gets inserted to, or 0 if error.
-  CHAR *grow (CHAR c);
+  ACE_CHAR_T *grow (ACE_CHAR_T c);
 
-  /// Inserting a new CHAR \a c into the current building
+  /// Inserting a new ACE_CHAR_T \a c into the current building
   /// block without freezing (null terminating) the block and without
   /// checking for out-of-bound error.
-  void grow_fast (CHAR c);
+  void grow_fast (ACE_CHAR_T c);
 
   /// Freeze the current building block by null terminating it.
   /// Return the starting address of the current building block, 0
   /// if error occurs.
-  CHAR *freeze (void);
+  ACE_CHAR_T *freeze (void);
 
   /// Copy the data into the current Obchunk and freeze the current
   /// block.  Return the starting address of the current building
   /// block, 0 if error occurs.  @a len specify the string length,
   /// not the actually data size.
-  CHAR *copy (const CHAR *data,
+  ACE_CHAR_T *copy (const ACE_CHAR_T *data,
               size_t len);
 
   /// Return the maximum @a length or @a size of a string that can be put
-  /// into this Obstack. @a size = @a length * sizeof (CHAR).
+  /// into this Obstack. @a size = @a length * sizeof (ACE_CHAR_T).
   ///
   /// @deprecated No need to use this function as you can put objects of
   /// arbitrary lengths into the obstack now.
diff --git a/ACE/ace/Obstack_T.inl b/ACE/ace/Obstack_T.inl
index 1eddbdcf4e6..411b6aea1e0 100644
--- a/ACE/ace/Obstack_T.inl
+++ b/ACE/ace/Obstack_T.inl
@@ -4,14 +4,14 @@
 
 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 
-template <class CHAR> ACE_INLINE size_t
-ACE_Obstack_T<CHAR>::length () const
+template <class ACE_CHAR_T> ACE_INLINE size_t
+ACE_Obstack_T<ACE_CHAR_T>::length () const
 {
-  return this->size_ / sizeof (CHAR);
+  return this->size_ / sizeof (ACE_CHAR_T);
 }
 
-template <class CHAR> ACE_INLINE size_t
-ACE_Obstack_T<CHAR>::size () const
+template <class ACE_CHAR_T> ACE_INLINE size_t
+ACE_Obstack_T<ACE_CHAR_T>::size () const
 {
   return this->size_;
 }
diff --git a/ACE/ace/SStringfwd.h b/ACE/ace/SStringfwd.h
index fb28ee8a469..cab3ecfe8ec 100644
--- a/ACE/ace/SStringfwd.h
+++ b/ACE/ace/SStringfwd.h
@@ -33,7 +33,7 @@
 
 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 
-template <class CHAR> class ACE_String_Base;  // Forward declaration.
+template <class ACE_CHAR_T> class ACE_String_Base;  // Forward declaration.
 
 typedef ACE_WCHAR_T ACE_WSTRING_TYPE;
 
diff --git a/ACE/ace/String_Base.cpp b/ACE/ace/String_Base.cpp
index 75e958335b5..b674c659859 100644
--- a/ACE/ace/String_Base.cpp
+++ b/ACE/ace/String_Base.cpp
@@ -19,26 +19,26 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 
 ACE_ALLOC_HOOK_DEFINE(ACE_String_Base)
 
-template <class CHAR>
-CHAR ACE_String_Base<CHAR>::NULL_String_ = 0;
+template <class ACE_CHAR_T>
+ACE_CHAR_T ACE_String_Base<ACE_CHAR_T>::NULL_String_ = 0;
 
 // Default constructor.
 
-template <class CHAR>
-ACE_String_Base<CHAR>::ACE_String_Base (ACE_Allocator *the_allocator)
+template <class ACE_CHAR_T>
+ACE_String_Base<ACE_CHAR_T>::ACE_String_Base (ACE_Allocator *the_allocator)
   : allocator_ (the_allocator ? the_allocator : ACE_Allocator::instance ()),
     len_ (0),
     buf_len_ (0),
-    rep_ (&ACE_String_Base<CHAR>::NULL_String_),
+    rep_ (&ACE_String_Base<ACE_CHAR_T>::NULL_String_),
     release_ (false)
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::ACE_String_Base");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::ACE_String_Base");
 }
 
 // Constructor that actually copies memory.
 
-template <class CHAR>
-ACE_String_Base<CHAR>::ACE_String_Base (const CHAR *s,
+template <class ACE_CHAR_T>
+ACE_String_Base<ACE_CHAR_T>::ACE_String_Base (const ACE_CHAR_T *s,
                                         ACE_Allocator *the_allocator,
                                         bool release)
   : allocator_ (the_allocator ? the_allocator : ACE_Allocator::instance ()),
@@ -47,12 +47,12 @@ ACE_String_Base<CHAR>::ACE_String_Base (const CHAR *s,
     rep_ (0),
     release_ (false)
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::ACE_String_Base");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::ACE_String_Base");
   this->set (s, release);
 }
 
-template <class CHAR>
-ACE_String_Base<CHAR>::ACE_String_Base (CHAR c,
+template <class ACE_CHAR_T>
+ACE_String_Base<ACE_CHAR_T>::ACE_String_Base (ACE_CHAR_T c,
                                         ACE_Allocator *the_allocator)
   : allocator_ (the_allocator ? the_allocator : ACE_Allocator::instance ()),
     len_ (0),
@@ -60,17 +60,17 @@ ACE_String_Base<CHAR>::ACE_String_Base (CHAR c,
     rep_ (0),
     release_ (false)
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::ACE_String_Base");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::ACE_String_Base");
 
   this->set (&c, 1, true);
 }
 
 // Constructor that actually copies memory.
 
-template <class CHAR>
-ACE_String_Base<CHAR>::ACE_String_Base (
-  const CHAR *s,
-  typename ACE_String_Base<CHAR>::size_type  len,
+template <class ACE_CHAR_T>
+ACE_String_Base<ACE_CHAR_T>::ACE_String_Base (
+  const ACE_CHAR_T *s,
+  typename ACE_String_Base<ACE_CHAR_T>::size_type  len,
   ACE_Allocator *the_allocator,
   bool release)
   : allocator_ (the_allocator ? the_allocator : ACE_Allocator::instance ()),
@@ -79,30 +79,30 @@ ACE_String_Base<CHAR>::ACE_String_Base (
     rep_ (0),
     release_ (false)
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::ACE_String_Base");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::ACE_String_Base");
 
   this->set (s, len, release);
 }
 
 // Copy constructor.
 
-template <class CHAR>
-ACE_String_Base<CHAR>::ACE_String_Base (const ACE_String_Base<CHAR> &s)
+template <class ACE_CHAR_T>
+ACE_String_Base<ACE_CHAR_T>::ACE_String_Base (const ACE_String_Base<ACE_CHAR_T> &s)
   : allocator_ (s.allocator_ ? s.allocator_ : ACE_Allocator::instance ()),
     len_ (0),
     buf_len_ (0),
     rep_ (0),
     release_ (false)
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::ACE_String_Base");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::ACE_String_Base");
 
   this->set (s.rep_, s.len_, true);
 }
 
-template <class CHAR>
-ACE_String_Base<CHAR>::ACE_String_Base (
-  typename ACE_String_Base<CHAR>::size_type len,
-  CHAR c,
+template <class ACE_CHAR_T>
+ACE_String_Base<ACE_CHAR_T>::ACE_String_Base (
+  typename ACE_String_Base<ACE_CHAR_T>::size_type len,
+  ACE_CHAR_T c,
   ACE_Allocator *the_allocator)
   : allocator_ (the_allocator ? the_allocator : ACE_Allocator::instance ()),
     len_ (0),
@@ -110,33 +110,33 @@ ACE_String_Base<CHAR>::ACE_String_Base (
     rep_ (0),
     release_ (false)
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::ACE_String_Base");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::ACE_String_Base");
 
   this->resize (len, c);
 }
 
-template <class CHAR>
-ACE_String_Base<CHAR>::~ACE_String_Base (void)
+template <class ACE_CHAR_T>
+ACE_String_Base<ACE_CHAR_T>::~ACE_String_Base (void)
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::~ACE_String_Base");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::~ACE_String_Base");
 
   if (this->buf_len_ != 0 && this->release_)
       this->allocator_->free (this->rep_);
 }
 
 // this method might benefit from a little restructuring.
-template <class CHAR> void
-ACE_String_Base<CHAR>::set (const CHAR *s,
-                            typename ACE_String_Base<CHAR>::size_type len,
+template <class ACE_CHAR_T> void
+ACE_String_Base<ACE_CHAR_T>::set (const ACE_CHAR_T *s,
+                            typename ACE_String_Base<ACE_CHAR_T>::size_type len,
                             bool release)
 {
   // Case 1. Going from memory to more memory
   size_type new_buf_len = len + 1;
   if (s != 0 && len != 0 && release && this->buf_len_ < new_buf_len)
     {
-      CHAR *temp = 0;
+      ACE_CHAR_T *temp = 0;
       ACE_ALLOCATOR (temp,
-                     (CHAR *) this->allocator_->malloc (new_buf_len * sizeof (CHAR)));
+                     (ACE_CHAR_T *) this->allocator_->malloc (new_buf_len * sizeof (ACE_CHAR_T)));
 
       if (this->buf_len_ != 0 && this->release_)
         this->allocator_->free (this->rep_);
@@ -145,7 +145,7 @@ ACE_String_Base<CHAR>::set (const CHAR *s,
       this->buf_len_ = new_buf_len;
       this->release_ = true;
       this->len_ = len;
-      ACE_OS::memcpy (this->rep_, s, len * sizeof (CHAR));
+      ACE_OS::memcpy (this->rep_, s, len * sizeof (ACE_CHAR_T));
       this->rep_[len] = 0;
     }
   else // Case 2. No memory allocation is necessary.
@@ -164,19 +164,19 @@ ACE_String_Base<CHAR>::set (const CHAR *s,
         {
           this->buf_len_ = 0;
           this->len_ = 0;
-          this->rep_ = &ACE_String_Base<CHAR>::NULL_String_;
+          this->rep_ = &ACE_String_Base<ACE_CHAR_T>::NULL_String_;
           this->release_ = false;
         }
       else if (!release) // Note: No guarantee that rep_ is null terminated.
         {
           this->buf_len_ = len;
           this->len_ = len;
-          this->rep_ = const_cast <CHAR *> (s);
+          this->rep_ = const_cast <ACE_CHAR_T *> (s);
           this->release_ = false;
         }
       else
         {
-          ACE_OS::memcpy (this->rep_, s, len * sizeof (CHAR));
+          ACE_OS::memcpy (this->rep_, s, len * sizeof (ACE_CHAR_T));
           this->rep_[len] = 0;
           this->len_ = len;
         }
@@ -184,12 +184,12 @@ ACE_String_Base<CHAR>::set (const CHAR *s,
 }
 
 // Return substring.
-template <class CHAR> ACE_String_Base<CHAR>
-ACE_String_Base<CHAR>::substring (
-  typename ACE_String_Base<CHAR>::size_type offset,
-  typename ACE_String_Base<CHAR>::size_type length) const
+template <class ACE_CHAR_T> ACE_String_Base<ACE_CHAR_T>
+ACE_String_Base<ACE_CHAR_T>::substring (
+  typename ACE_String_Base<ACE_CHAR_T>::size_type offset,
+  typename ACE_String_Base<ACE_CHAR_T>::size_type length) const
 {
-  ACE_String_Base<CHAR> nill;
+  ACE_String_Base<ACE_CHAR_T> nill;
   size_type count = length;
 
   // case 1. empty string
@@ -206,36 +206,36 @@ ACE_String_Base<CHAR>::substring (
   else if (length == npos || count > (this->len_ - offset))
     count = this->len_ - offset;
 
-  return ACE_String_Base<CHAR> (&this->rep_[offset], count, this->allocator_);
+  return ACE_String_Base<ACE_CHAR_T> (&this->rep_[offset], count, this->allocator_);
 }
 
-template <class CHAR> ACE_String_Base<CHAR> &
-ACE_String_Base<CHAR>::append (const CHAR* s,
-                               typename ACE_String_Base<CHAR>::size_type slen)
+template <class ACE_CHAR_T> ACE_String_Base<ACE_CHAR_T> &
+ACE_String_Base<ACE_CHAR_T>::append (const ACE_CHAR_T* s,
+                               typename ACE_String_Base<ACE_CHAR_T>::size_type slen)
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::append(const CHAR*, size_type)");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::append(const ACE_CHAR_T*, size_type)");
   if (slen > 0 && slen != npos)
   {
     // case 1. No memory allocation needed.
     if (this->buf_len_ >= this->len_ + slen + 1)
     {
       // Copy in data from new string.
-      ACE_OS::memcpy (this->rep_ + this->len_, s, slen * sizeof (CHAR));
+      ACE_OS::memcpy (this->rep_ + this->len_, s, slen * sizeof (ACE_CHAR_T));
     }
     else // case 2. Memory reallocation is needed
     {
       const size_type new_buf_len =
         ace_max(this->len_ + slen + 1, this->buf_len_ + this->buf_len_ / 2);
 
-      CHAR *t = 0;
+      ACE_CHAR_T *t = 0;
 
       ACE_ALLOCATOR_RETURN (t,
-        (CHAR *) this->allocator_->malloc (new_buf_len * sizeof (CHAR)), *this);
+        (ACE_CHAR_T *) this->allocator_->malloc (new_buf_len * sizeof (ACE_CHAR_T)), *this);
 
       // Copy memory from old string into new string.
-      ACE_OS::memcpy (t, this->rep_, this->len_ * sizeof (CHAR));
+      ACE_OS::memcpy (t, this->rep_, this->len_ * sizeof (ACE_CHAR_T));
 
-      ACE_OS::memcpy (t + this->len_, s, slen * sizeof (CHAR));
+      ACE_OS::memcpy (t + this->len_, s, slen * sizeof (ACE_CHAR_T));
 
       if (this->buf_len_ != 0 && this->release_)
         this->allocator_->free (this->rep_);
@@ -252,29 +252,29 @@ ACE_String_Base<CHAR>::append (const CHAR* s,
   return *this;
 }
 
-template <class CHAR> u_long
-ACE_String_Base<CHAR>::hash (void) const
+template <class ACE_CHAR_T> u_long
+ACE_String_Base<ACE_CHAR_T>::hash (void) const
 {
   return
     ACE::hash_pjw (reinterpret_cast<char *> (
-                      const_cast<CHAR *> (this->rep_)),
-                   this->len_ * sizeof (CHAR));
+                      const_cast<ACE_CHAR_T *> (this->rep_)),
+                   this->len_ * sizeof (ACE_CHAR_T));
 }
 
-template <class CHAR> void
-ACE_String_Base<CHAR>::resize (typename ACE_String_Base<CHAR>::size_type len,
-                               CHAR c)
+template <class ACE_CHAR_T> void
+ACE_String_Base<ACE_CHAR_T>::resize (typename ACE_String_Base<ACE_CHAR_T>::size_type len,
+                               ACE_CHAR_T c)
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::resize");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::resize");
 
   fast_resize(len);
-  ACE_OS::memset (this->rep_, c, this->buf_len_ * sizeof (CHAR));
+  ACE_OS::memset (this->rep_, c, this->buf_len_ * sizeof (ACE_CHAR_T));
 }
 
-template <class CHAR> void
-ACE_String_Base<CHAR>::fast_resize (size_t len)
+template <class ACE_CHAR_T> void
+ACE_String_Base<ACE_CHAR_T>::fast_resize (size_t len)
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::fast_resize");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::fast_resize");
 
   // Only reallocate if we don't have enough space...
   if (this->buf_len_ <= len)
@@ -282,8 +282,8 @@ ACE_String_Base<CHAR>::fast_resize (size_t len)
       if (this->buf_len_ != 0 && this->release_)
         this->allocator_->free (this->rep_);
 
-      this->rep_ = static_cast<CHAR*>
-                     (this->allocator_->malloc ((len + 1) * sizeof (CHAR)));
+      this->rep_ = static_cast<ACE_CHAR_T*>
+                     (this->allocator_->malloc ((len + 1) * sizeof (ACE_CHAR_T)));
       this->buf_len_ = len + 1;
       this->release_ = true;
     }
@@ -292,8 +292,8 @@ ACE_String_Base<CHAR>::fast_resize (size_t len)
     this->rep_[0] = 0;
 }
 
-template <class CHAR> void
-ACE_String_Base<CHAR>::clear (bool release)
+template <class ACE_CHAR_T> void
+ACE_String_Base<ACE_CHAR_T>::clear (bool release)
 {
   // This can't use set(), because that would free memory if release=false
   if (release)
@@ -301,7 +301,7 @@ ACE_String_Base<CHAR>::clear (bool release)
     if (this->buf_len_ != 0 && this->release_)
       this->allocator_->free (this->rep_);
 
-    this->rep_ = &ACE_String_Base<CHAR>::NULL_String_;
+    this->rep_ = &ACE_String_Base<ACE_CHAR_T>::NULL_String_;
     this->len_ = 0;
     this->buf_len_ = 0;
     this->release_ = false;
@@ -313,20 +313,20 @@ ACE_String_Base<CHAR>::clear (bool release)
 }
 
 // Assignment operator (does copy memory).
-template <class CHAR> ACE_String_Base<CHAR> &
-ACE_String_Base<CHAR>::operator= (const CHAR *s)
+template <class ACE_CHAR_T> ACE_String_Base<ACE_CHAR_T> &
+ACE_String_Base<ACE_CHAR_T>::operator= (const ACE_CHAR_T *s)
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::operator=");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::operator=");
   if (s != 0)
     this->set (s, true);
   return *this;
 }
 
 // Assignment operator (does copy memory).
-template <class CHAR> ACE_String_Base<CHAR> &
-ACE_String_Base<CHAR>::operator= (const ACE_String_Base<CHAR> &s)
+template <class ACE_CHAR_T> ACE_String_Base<ACE_CHAR_T> &
+ACE_String_Base<ACE_CHAR_T>::operator= (const ACE_String_Base<ACE_CHAR_T> &s)
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::operator=");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::operator=");
 
   // Check for self-assignment.
   if (this != &s)
@@ -337,8 +337,8 @@ ACE_String_Base<CHAR>::operator= (const ACE_String_Base<CHAR> &s)
   return *this;
 }
 
-template <class CHAR> void
-ACE_String_Base<CHAR>::set (const CHAR *s, bool release)
+template <class ACE_CHAR_T> void
+ACE_String_Base<ACE_CHAR_T>::set (const ACE_CHAR_T *s, bool release)
 {
   size_t length = 0;
   if (s != 0)
@@ -347,42 +347,42 @@ ACE_String_Base<CHAR>::set (const CHAR *s, bool release)
   this->set (s, length, release);
 }
 
-template <class CHAR> void
-ACE_String_Base<CHAR>::fast_clear (void)
+template <class ACE_CHAR_T> void
+ACE_String_Base<ACE_CHAR_T>::fast_clear (void)
 {
   this->len_ = 0;
   if (this->release_)
     {
       // String retains the original buffer.
-      if (this->rep_ != &ACE_String_Base<CHAR>::NULL_String_)
+      if (this->rep_ != &ACE_String_Base<ACE_CHAR_T>::NULL_String_)
         this->rep_[0] = 0;
     }
   else
     {
       // External buffer: string relinquishes control of it.
       this->buf_len_ = 0;
-      this->rep_ = &ACE_String_Base<CHAR>::NULL_String_;
+      this->rep_ = &ACE_String_Base<ACE_CHAR_T>::NULL_String_;
     }
 }
 
 // Get a copy of the underlying representation.
 
-template <class CHAR> CHAR *
-ACE_String_Base<CHAR>::rep (void) const
+template <class ACE_CHAR_T> ACE_CHAR_T *
+ACE_String_Base<ACE_CHAR_T>::rep (void) const
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::rep");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::rep");
 
-  CHAR *new_string;
-  ACE_NEW_RETURN (new_string, CHAR[this->len_ + 1], 0);
+  ACE_CHAR_T *new_string;
+  ACE_NEW_RETURN (new_string, ACE_CHAR_T[this->len_ + 1], 0);
   ACE_OS::strsncpy (new_string, this->rep_, this->len_+1);
 
   return new_string;
 }
 
-template <class CHAR> int
-ACE_String_Base<CHAR>::compare (const ACE_String_Base<CHAR> &s) const
+template <class ACE_CHAR_T> int
+ACE_String_Base<ACE_CHAR_T>::compare (const ACE_String_Base<ACE_CHAR_T> &s) const
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::compare");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::compare");
 
   if (this->rep_ == s.rep_)
     return 0;
@@ -392,7 +392,7 @@ ACE_String_Base<CHAR>::compare (const ACE_String_Base<CHAR> &s) const
 
   int result = ACE_OS::memcmp (this->rep_,
                                s.rep_,
-                               smaller_length * sizeof (CHAR));
+                               smaller_length * sizeof (ACE_CHAR_T));
 
   if (result == 0 && this->len_ != s.len_)
     result = this->len_ > s.len_ ? 1 : -1;
@@ -401,56 +401,56 @@ ACE_String_Base<CHAR>::compare (const ACE_String_Base<CHAR> &s) const
 
 // Comparison operator.
 
-template <class CHAR> bool
-ACE_String_Base<CHAR>::operator== (const ACE_String_Base<CHAR> &s) const
+template <class ACE_CHAR_T> bool
+ACE_String_Base<ACE_CHAR_T>::operator== (const ACE_String_Base<ACE_CHAR_T> &s) const
 {
   return this->len_ == s.len_ &&
          ACE_OS::memcmp (this->rep_,
                          s.rep_,
-                         this->len_ * sizeof (CHAR)) == 0;
+                         this->len_ * sizeof (ACE_CHAR_T)) == 0;
 }
 
-template <class CHAR> bool
-ACE_String_Base<CHAR>::operator== (const CHAR *s) const
+template <class ACE_CHAR_T> bool
+ACE_String_Base<ACE_CHAR_T>::operator== (const ACE_CHAR_T *s) const
 {
   size_t len = ACE_OS::strlen (s);
   return this->len_ == len &&
          ACE_OS::memcmp (this->rep_,
                          s,
-                         len * sizeof (CHAR)) == 0;
+                         len * sizeof (ACE_CHAR_T)) == 0;
 }
 
-template <class CHAR> typename ACE_String_Base<CHAR>::size_type
-ACE_String_Base<CHAR>::find (
-  const CHAR *s,
-  typename ACE_String_Base<CHAR>::size_type pos) const
+template <class ACE_CHAR_T> typename ACE_String_Base<ACE_CHAR_T>::size_type
+ACE_String_Base<ACE_CHAR_T>::find (
+  const ACE_CHAR_T *s,
+  typename ACE_String_Base<ACE_CHAR_T>::size_type pos) const
 {
-  CHAR *substr = this->rep_ + pos;
+  ACE_CHAR_T *substr = this->rep_ + pos;
   size_t len = ACE_OS::strlen (s);
-  CHAR *pointer = ACE_OS::strnstr (substr, s, len);
+  ACE_CHAR_T *pointer = ACE_OS::strnstr (substr, s, len);
   if (pointer == 0)
-    return ACE_String_Base<CHAR>::npos;
+    return ACE_String_Base<ACE_CHAR_T>::npos;
   else
     return pointer - this->rep_;
 }
 
-template <class CHAR> typename ACE_String_Base<CHAR>::size_type
-ACE_String_Base<CHAR>::find (
-  CHAR c,
-  typename ACE_String_Base<CHAR>::size_type pos) const
+template <class ACE_CHAR_T> typename ACE_String_Base<ACE_CHAR_T>::size_type
+ACE_String_Base<ACE_CHAR_T>::find (
+  ACE_CHAR_T c,
+  typename ACE_String_Base<ACE_CHAR_T>::size_type pos) const
 {
-  CHAR *substr = this->rep_ + pos;
-  CHAR *pointer = ACE_OS::strnchr (substr, c, this->len_ - pos);
+  ACE_CHAR_T *substr = this->rep_ + pos;
+  ACE_CHAR_T *pointer = ACE_OS::strnchr (substr, c, this->len_ - pos);
   if (pointer == 0)
-    return ACE_String_Base<CHAR>::npos;
+    return ACE_String_Base<ACE_CHAR_T>::npos;
   else
     return pointer - this->rep_;
 }
 
-template <class CHAR> typename ACE_String_Base<CHAR>::size_type
-ACE_String_Base<CHAR>::rfind (
-  CHAR c,
-  typename ACE_String_Base<CHAR>::size_type pos) const
+template <class ACE_CHAR_T> typename ACE_String_Base<ACE_CHAR_T>::size_type
+ACE_String_Base<ACE_CHAR_T>::rfind (
+  ACE_CHAR_T c,
+  typename ACE_String_Base<ACE_CHAR_T>::size_type pos) const
 {
   if (pos == npos || pos > this->len_)
     pos = this->len_;
@@ -461,11 +461,11 @@ ACE_String_Base<CHAR>::rfind (
     if (this->rep_[i] == c)
       return i;
 
-  return ACE_String_Base<CHAR>::npos;
+  return ACE_String_Base<ACE_CHAR_T>::npos;
 }
 
-template <class CHAR> void
-ACE_String_Base<CHAR>::swap (ACE_String_Base<CHAR> & str)
+template <class ACE_CHAR_T> void
+ACE_String_Base<ACE_CHAR_T>::swap (ACE_String_Base<ACE_CHAR_T> & str)
 {
   std::swap (this->allocator_ , str.allocator_);
   std::swap (this->len_       , str.len_);
@@ -476,10 +476,10 @@ ACE_String_Base<CHAR>::swap (ACE_String_Base<CHAR> & str)
 
 // ----------------------------------------------
 
-template <class CHAR>
-int ACE_String_Base_Iterator <CHAR>::next (CHAR * & ch) const
+template <class ACE_CHAR_T>
+int ACE_String_Base_Iterator <ACE_CHAR_T>::next (ACE_CHAR_T * & ch) const
 {
-  ACE_TRACE ("ACE_String_Base_Iterator<CHAR>::next");
+  ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::next");
 
   if (0 == this->done ())
   {
@@ -493,10 +493,10 @@ int ACE_String_Base_Iterator <CHAR>::next (CHAR * & ch) const
   }
 }
 
-template <class CHAR>
-int ACE_String_Base_Iterator <CHAR>::advance (void)
+template <class ACE_CHAR_T>
+int ACE_String_Base_Iterator <ACE_CHAR_T>::advance (void)
 {
-  ACE_TRACE ("ACE_String_Base_Iterator<CHAR>::advance");
+  ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::advance");
 
   if (this->index_ < this->str_->length ())
   {
@@ -509,12 +509,12 @@ int ACE_String_Base_Iterator <CHAR>::advance (void)
   }
 }
 
-template <class CHAR>
-const ACE_String_Base_Iterator <CHAR> &
-ACE_String_Base_Iterator <CHAR>::
-operator = (const ACE_String_Base_Iterator <CHAR> & rhs)
+template <class ACE_CHAR_T>
+const ACE_String_Base_Iterator <ACE_CHAR_T> &
+ACE_String_Base_Iterator <ACE_CHAR_T>::
+operator = (const ACE_String_Base_Iterator <ACE_CHAR_T> & rhs)
 {
-  ACE_TRACE ("ACE_String_Base_Iterator<CHAR>::operator =");
+  ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::operator =");
 
   if (this == &rhs)
     return *this;
@@ -526,10 +526,10 @@ operator = (const ACE_String_Base_Iterator <CHAR> & rhs)
 
 // ----------------------------------------------
 
-template <class CHAR>
-int ACE_String_Base_Const_Iterator <CHAR>::next (const CHAR * & ch) const
+template <class ACE_CHAR_T>
+int ACE_String_Base_Const_Iterator <ACE_CHAR_T>::next (const ACE_CHAR_T * & ch) const
 {
-  ACE_TRACE ("ACE_String_Base_Const_Iterator<CHAR>::next");
+  ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::next");
 
   if (0 == this->done ())
   {
@@ -543,10 +543,10 @@ int ACE_String_Base_Const_Iterator <CHAR>::next (const CHAR * & ch) const
   }
 }
 
-template <class CHAR>
-int ACE_String_Base_Const_Iterator <CHAR>::advance (void)
+template <class ACE_CHAR_T>
+int ACE_String_Base_Const_Iterator <ACE_CHAR_T>::advance (void)
 {
-  ACE_TRACE ("ACE_String_Base_Const_Iterator<CHAR>::advance");
+  ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::advance");
 
   if (this->index_ < this->str_->length ())
   {
@@ -559,12 +559,12 @@ int ACE_String_Base_Const_Iterator <CHAR>::advance (void)
   }
 }
 
-template <class CHAR>
-const ACE_String_Base_Const_Iterator <CHAR> &
-ACE_String_Base_Const_Iterator <CHAR>::
-operator = (const ACE_String_Base_Const_Iterator <CHAR> & rhs)
+template <class ACE_CHAR_T>
+const ACE_String_Base_Const_Iterator <ACE_CHAR_T> &
+ACE_String_Base_Const_Iterator <ACE_CHAR_T>::
+operator = (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & rhs)
 {
-  ACE_TRACE ("ACE_String_Base_Const_Iterator<CHAR>::operator =");
+  ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::operator =");
 
   if (this == &rhs)
     return *this;
@@ -576,64 +576,64 @@ operator = (const ACE_String_Base_Const_Iterator <CHAR> & rhs)
 
 // ----------------------------------------------
 
-template <class CHAR> ACE_String_Base<CHAR>
-operator+ (const ACE_String_Base<CHAR> &s, const ACE_String_Base<CHAR> &t)
+template <class ACE_CHAR_T> ACE_String_Base<ACE_CHAR_T>
+operator+ (const ACE_String_Base<ACE_CHAR_T> &s, const ACE_String_Base<ACE_CHAR_T> &t)
 {
-  ACE_String_Base<CHAR> temp (s.length () + t.length ());
+  ACE_String_Base<ACE_CHAR_T> temp (s.length () + t.length ());
   temp += s;
   temp += t;
   return temp;
 }
 
-template <class CHAR> ACE_String_Base<CHAR>
-operator+ (const CHAR *s, const ACE_String_Base<CHAR> &t)
+template <class ACE_CHAR_T> ACE_String_Base<ACE_CHAR_T>
+operator+ (const ACE_CHAR_T *s, const ACE_String_Base<ACE_CHAR_T> &t)
 {
   size_t slen = 0;
   if (s != 0)
     slen = ACE_OS::strlen (s);
-  ACE_String_Base<CHAR> temp (slen + t.length ());
+  ACE_String_Base<ACE_CHAR_T> temp (slen + t.length ());
   if (slen > 0)
     temp.append (s, slen);
   temp += t;
   return temp;
 }
 
-template <class CHAR> ACE_String_Base<CHAR>
-operator+ (const ACE_String_Base<CHAR> &s, const CHAR *t)
+template <class ACE_CHAR_T> ACE_String_Base<ACE_CHAR_T>
+operator+ (const ACE_String_Base<ACE_CHAR_T> &s, const ACE_CHAR_T *t)
 {
   size_t tlen = 0;
   if (t != 0)
     tlen = ACE_OS::strlen (t);
-  ACE_String_Base<CHAR> temp (s.length () + tlen);
+  ACE_String_Base<ACE_CHAR_T> temp (s.length () + tlen);
   temp += s;
   if (tlen > 0)
     temp.append (t, tlen);
   return temp;
 }
 
-template <class CHAR> ACE_String_Base<CHAR>
-operator + (const ACE_String_Base<CHAR> &t,
-            const CHAR c)
+template <class ACE_CHAR_T> ACE_String_Base<ACE_CHAR_T>
+operator + (const ACE_String_Base<ACE_CHAR_T> &t,
+            const ACE_CHAR_T c)
 {
-  ACE_String_Base<CHAR> temp (t.length () + 1);
+  ACE_String_Base<ACE_CHAR_T> temp (t.length () + 1);
   temp += t;
   temp += c;
   return temp;
 }
 
-template <class CHAR> ACE_String_Base<CHAR>
-operator + (const CHAR c,
-            const ACE_String_Base<CHAR> &t)
+template <class ACE_CHAR_T> ACE_String_Base<ACE_CHAR_T>
+operator + (const ACE_CHAR_T c,
+            const ACE_String_Base<ACE_CHAR_T> &t)
 {
-  ACE_String_Base<CHAR> temp (t.length () + 1);
+  ACE_String_Base<ACE_CHAR_T> temp (t.length () + 1);
   temp += c;
   temp += t;
   return temp;
 }
 
-template <class CHAR>
-ACE_String_Base<CHAR> &
-ACE_String_Base<CHAR>::operator+= (const CHAR* s)
+template <class ACE_CHAR_T>
+ACE_String_Base<ACE_CHAR_T> &
+ACE_String_Base<ACE_CHAR_T>::operator+= (const ACE_CHAR_T* s)
 {
   size_t slen = 0;
   if (s != 0)
@@ -641,19 +641,19 @@ ACE_String_Base<CHAR>::operator+= (const CHAR* s)
   return this->append (s, slen);
 }
 
-template <class CHAR>
-ACE_String_Base<CHAR> &
-ACE_String_Base<CHAR>::operator+= (const ACE_String_Base<CHAR> &s)
+template <class ACE_CHAR_T>
+ACE_String_Base<ACE_CHAR_T> &
+ACE_String_Base<ACE_CHAR_T>::operator+= (const ACE_String_Base<ACE_CHAR_T> &s)
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::operator+=(const ACE_String_Base<CHAR> &)");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::operator+=(const ACE_String_Base<ACE_CHAR_T> &)");
   return this->append (s.rep_, s.len_);
 }
 
-template <class CHAR>
-ACE_String_Base<CHAR> &
-ACE_String_Base<CHAR>::operator+= (const CHAR c)
+template <class ACE_CHAR_T>
+ACE_String_Base<ACE_CHAR_T> &
+ACE_String_Base<ACE_CHAR_T>::operator+= (const ACE_CHAR_T c)
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::operator+=(const CHAR)");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::operator+=(const ACE_CHAR_T)");
   const size_type slen = 1;
   return this->append (&c, slen);
 }
diff --git a/ACE/ace/String_Base.h b/ACE/ace/String_Base.h
index 55c2eb3f9a4..ae775c35dc3 100644
--- a/ACE/ace/String_Base.h
+++ b/ACE/ace/String_Base.h
@@ -28,11 +28,11 @@
 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 
 // Forward decl.
-template <class CHAR>
+template <class ACE_CHAR_T>
 class ACE_String_Base_Iterator;
 
 // Forward decl.
-template <class CHAR>
+template <class ACE_CHAR_T>
 class ACE_String_Base_Const_Iterator;
 
 /**
@@ -63,22 +63,22 @@ class ACE_String_Base_Const_Iterator;
  *     many STL class templates.  If you find yourself casting you're
  *     probably doing something wrong.
  */
-template <class CHAR>
+template <class ACE_CHAR_T>
 class ACE_String_Base : public ACE_String_Base_Const
 {
 public:
   using ACE_String_Base_Const::size_type;
 
-  friend class ACE_String_Base_Iterator <CHAR>;
-  friend class ACE_String_Base_Const_Iterator <CHAR>;
+  friend class ACE_String_Base_Iterator <ACE_CHAR_T>;
+  friend class ACE_String_Base_Const_Iterator <ACE_CHAR_T>;
 
   // ACE-style iterators
-  typedef ACE_String_Base_Iterator <CHAR> ITERATOR;
-  typedef ACE_String_Base_Const_Iterator <CHAR> CONST_ITERATOR;
+  typedef ACE_String_Base_Iterator <ACE_CHAR_T> ITERATOR;
+  typedef ACE_String_Base_Const_Iterator <ACE_CHAR_T> CONST_ITERATOR;
 
   // STL-style iterators
-  typedef ACE_String_Base_Iterator <CHAR> iterator;
-  typedef ACE_String_Base_Const_Iterator <CHAR> const_iterator;
+  typedef ACE_String_Base_Iterator <ACE_CHAR_T> iterator;
+  typedef ACE_String_Base_Const_Iterator <ACE_CHAR_T> const_iterator;
 
    /**
     *  Default constructor.
@@ -101,9 +101,9 @@ public:
    * @param the_allocator ACE_Allocator associated with string
    * @param release Allocator responsible(true)/not reponsible(false) for
    *    freeing memory.
-   * @return ACE_String_Base containing const CHAR *s
+   * @return ACE_String_Base containing const ACE_CHAR_T *s
    */
-  ACE_String_Base (const CHAR *s,
+  ACE_String_Base (const ACE_CHAR_T *s,
                    ACE_Allocator *the_allocator = 0,
                    bool release = true);
 
@@ -122,9 +122,9 @@ public:
    * @param the_allocator ACE_Allocator associated with string
    * @param release Allocator responsible(true)/not reponsible(false) for
    *    freeing memory.
-   * @return ACE_String_Base containing const CHAR *s
+   * @return ACE_String_Base containing const ACE_CHAR_T *s
    */
-  ACE_String_Base (const CHAR *s,
+  ACE_String_Base (const ACE_CHAR_T *s,
                    size_type len,
                    ACE_Allocator *the_allocator = 0,
                    bool release = true);
@@ -135,16 +135,16 @@ public:
    *  @param s Input ACE_String_Base string to copy
    *  @return Copy of input string @a s
    */
-  ACE_String_Base (const ACE_String_Base < CHAR > &s);
+  ACE_String_Base (const ACE_String_Base < ACE_CHAR_T > &s);
 
   /**
    *  Constructor that copies @a c into dynamically allocated memory.
    *
    *  @param c Single input character.
    *  @param the_allocator ACE_Allocator associated with string
-   *  @return ACE_String_Base containing CHAR 'c'
+   *  @return ACE_String_Base containing ACE_CHAR_T 'c'
    */
-  ACE_String_Base (CHAR c, ACE_Allocator *the_allocator = 0);
+  ACE_String_Base (ACE_CHAR_T c, ACE_Allocator *the_allocator = 0);
 
   /**
    *  Constructor that allocates a len long string.
@@ -160,7 +160,7 @@ public:
    *  @return Empty ACE_String_Base with room for len CHARs
    */
   ACE_String_Base (size_type len,
-                   CHAR c = 0,
+                   ACE_CHAR_T c = 0,
                    ACE_Allocator *the_allocator = 0);
 
   /**
@@ -175,7 +175,7 @@ public:
    * @param slot Index of the desired character
    * @return The character at index @a slot
    */
-  const CHAR & operator[] (size_type slot) const;
+  const ACE_CHAR_T & operator[] (size_type slot) const;
 
   /**
    * Return the <slot'th> character by reference in the string
@@ -184,15 +184,15 @@ public:
    * @param slot Index of the desired character
    * @return The character at index @a slot
    */
-  CHAR & operator[] (size_type slot);
+  ACE_CHAR_T & operator[] (size_type slot);
 
   /**
    *  Assignment operator (does copy memory).
    *
-   *  @param s Input null-terminated CHAR string to assign to this object.
+   *  @param s Input null-terminated ACE_CHAR_T string to assign to this object.
    *  @return Return a copy of the this string.
    */
-  ACE_String_Base < CHAR > &operator = (const CHAR * s);
+  ACE_String_Base < ACE_CHAR_T > &operator = (const ACE_CHAR_T * s);
 
   /**
    *  Assignment operator (does copy memory).
@@ -200,7 +200,7 @@ public:
    *  @param s Input ACE_String_Base string to assign to this object.
    *  @return Return a copy of the this string.
    */
-  ACE_String_Base < CHAR > &operator = (const ACE_String_Base < CHAR > &s);
+  ACE_String_Base < ACE_CHAR_T > &operator = (const ACE_String_Base < ACE_CHAR_T > &s);
 
   /**
    *  Assignment alternative method (does not copy memory).
@@ -208,7 +208,7 @@ public:
    *  @param s Input ACE_String_Base string to assign to this object.
    *  @return Return this string.
    */
-  ACE_String_Base < CHAR > &assign_nocopy (const ACE_String_Base < CHAR > &s);
+  ACE_String_Base < ACE_CHAR_T > &assign_nocopy (const ACE_String_Base < ACE_CHAR_T > &s);
 
   /**
    * Copy @a s into this @a ACE_String_Base.
@@ -227,7 +227,7 @@ public:
    * @param release Allocator responsible(true)/not reponsible(false) for
    *    freeing memory.
    */
-  void set (const CHAR * s, bool release = true);
+  void set (const ACE_CHAR_T * s, bool release = true);
 
   /**
    *  Copy @a len bytes of @a s (will zero terminate the result).
@@ -247,7 +247,7 @@ public:
    *  @param release Allocator responsible(true)/not reponsible(false) for
    *    freeing memory.
    */
-  void set (const CHAR * s, size_type len, bool release);
+  void set (const ACE_CHAR_T * s, size_type len, bool release);
 
   /**
    * Clear this string. Memory is _not_ freed if @a release is false.
@@ -291,7 +291,7 @@ public:
    * @param length How many characters to return starting at the offset.
    * @return The string containing the desired substring
    */
-  ACE_String_Base < CHAR > substring (size_type offset,
+  ACE_String_Base < ACE_CHAR_T > substring (size_type offset,
                                       size_type length = npos) const;
 
   /**
@@ -301,7 +301,7 @@ public:
    * @param length How many characters to return starting at the offset.
    * @return The string containing the desired substring
    */
-  ACE_String_Base < CHAR > substr (size_type offset,
+  ACE_String_Base < ACE_CHAR_T > substr (size_type offset,
                                    size_type length = npos) const;
 
   /**
@@ -311,7 +311,7 @@ public:
    *  @return The combined string (input append to the end of the old). New
    *    string is zero terminated.
    */
-  ACE_String_Base < CHAR > &operator += (const ACE_String_Base < CHAR > &s);
+  ACE_String_Base < ACE_CHAR_T > &operator += (const ACE_String_Base < ACE_CHAR_T > &s);
 
   /**
    *  Concat operator (copies memory).
@@ -320,26 +320,26 @@ public:
    *  @return The combined string (input append to the end of the old). New
    *    string is zero terminated.
    */
-  ACE_String_Base < CHAR >& operator += (const CHAR* s);
+  ACE_String_Base < ACE_CHAR_T >& operator += (const ACE_CHAR_T* s);
 
   /**
    *  Concat operator (copies memory).
    *
-   *  @param c Input CHAR to concatenate to this string.
+   *  @param c Input ACE_CHAR_T to concatenate to this string.
    *  @return The combined string (input append to the end of the old). New
    *    string is zero terminated.
    */
-  ACE_String_Base < CHAR >& operator += (const CHAR c);
+  ACE_String_Base < ACE_CHAR_T >& operator += (const ACE_CHAR_T c);
 
   /**
    *  Append function (copies memory).
    *
-   *  @param s Input CHAR array to concatenate to this string.
+   *  @param s Input ACE_CHAR_T array to concatenate to this string.
    *  @param slen The length of the array.
    *  @return The combined string (input append to the end of the old). New
    *    string is zero terminated.
    */
-  ACE_String_Base < CHAR >& append (const CHAR* s, size_type slen);
+  ACE_String_Base < ACE_CHAR_T >& append (const ACE_CHAR_T* s, size_type slen);
 
   /**
    *  Returns a hash value for this string.
@@ -359,7 +359,7 @@ public:
    *  Return the number of allocated CHARs in the string object.
    *  This may be greater than the current length of the string.
    *
-   *  @return Maximum number of CHAR units that can be stored, including
+   *  @return Maximum number of ACE_CHAR_T units that can be stored, including
    *          any terminating nul that may be needed.
    */
   size_t capacity (void) const;
@@ -386,7 +386,7 @@ public:
    * @return Pointer reference to the string data. Returned string is
    *    zero terminated.
    */
-  CHAR *rep (void) const;
+  ACE_CHAR_T *rep (void) const;
 
   /**
    * Get at the underlying representation directly!
@@ -397,12 +397,12 @@ public:
    *    that the string is zero terminated.
    *
    */
-  const CHAR *fast_rep (void) const;
+  const ACE_CHAR_T *fast_rep (void) const;
 
   /**
    *  Same as STL String's <c_str> and <fast_rep>.
    */
-  const CHAR *c_str (void) const;
+  const ACE_CHAR_T *c_str (void) const;
 
   /**
    *  Comparison operator that will match substrings.  Returns the
@@ -412,7 +412,7 @@ public:
    *  @return Integer index value of the first location of string @a s or
    *          @c npos (not found).
    */
-  size_type strstr (const ACE_String_Base<CHAR> &s) const;
+  size_type strstr (const ACE_String_Base<ACE_CHAR_T> &s) const;
 
   /**
    *  Find <str> starting at pos.  Returns the slot of the first
@@ -423,7 +423,7 @@ public:
    *  @return Index value of the first location of string @a str else
    *          @c npos.
    */
-  size_type find (const ACE_String_Base<CHAR> &str, size_type pos = 0) const;
+  size_type find (const ACE_String_Base<ACE_CHAR_T> &str, size_type pos = 0) const;
 
   /**
    *  Find @a s starting at pos.  Returns the slot of the first
@@ -434,7 +434,7 @@ public:
    *  @return Index value of the first location of string @a str else
    *          @c npos.
    */
-  size_type find (const CHAR *s, size_type pos = 0) const;
+  size_type find (const ACE_CHAR_T *s, size_type pos = 0) const;
 
   /**
    *  Find @a c starting at pos.  Returns the slot of the first
@@ -445,7 +445,7 @@ public:
    *  @return Index value of the first location of string @a str else
    *          @c npos.
    */
-  size_type find (CHAR c, size_type pos = 0) const;
+  size_type find (ACE_CHAR_T c, size_type pos = 0) const;
 
   /**
    *  Find @a c starting at pos (counting from the end).  Returns the
@@ -456,7 +456,7 @@ public:
    *  @return Index value of the first location of string @a str else
    *          @c npos.
    */
-  size_type rfind (CHAR c, size_type pos = npos) const;
+  size_type rfind (ACE_CHAR_T c, size_type pos = npos) const;
 
   /**
    *  Equality comparison operator (must match entire string).
@@ -464,7 +464,7 @@ public:
    * @param s Input ACE_String_Base string to compare against stored string.
    * @return @c true if equal, @c false otherwise.
    */
-  bool operator == (const ACE_String_Base<CHAR> &s) const;
+  bool operator == (const ACE_String_Base<ACE_CHAR_T> &s) const;
 
   /**
    *  Equality comparison operator (must match entire string).
@@ -472,7 +472,7 @@ public:
    * @param s Null terminated string to compare against stored string.
    * @return @c true if equal, @c false otherwise.
    */
-  bool operator == (const CHAR *s) const;
+  bool operator == (const ACE_CHAR_T *s) const;
 
   /**
    *  Less than comparison operator.
@@ -480,7 +480,7 @@ public:
    *  @param s Input ACE_String_Base string to compare against stored string.
    *  @return @c true if less than, @c false otherwise.
    */
-  bool operator < (const ACE_String_Base<CHAR> &s) const;
+  bool operator < (const ACE_String_Base<ACE_CHAR_T> &s) const;
 
   /**
    *  Greater than comparison operator.
@@ -488,7 +488,7 @@ public:
    *  @param s Input ACE_String_Base string to compare against stored string.
    *  @return @c true if greater than, @c false otherwise.
    */
-  bool operator > (const ACE_String_Base<CHAR> &s) const;
+  bool operator > (const ACE_String_Base<ACE_CHAR_T> &s) const;
 
   /**
    *  Inequality comparison operator.
@@ -496,7 +496,7 @@ public:
    *  @param s String to compare against stored string.
    *  @return @c true if not equal, @c false otherwise.
    */
-  bool operator != (const ACE_String_Base<CHAR> &s) const;
+  bool operator != (const ACE_String_Base<ACE_CHAR_T> &s) const;
 
   /**
    *  Inequality comparison operator.
@@ -504,7 +504,7 @@ public:
    *  @param s Null terminated string to compare against stored string.
    *  @return @c true if not equal, @c false otherwise.
    */
-  bool operator != (const CHAR *s) const;
+  bool operator != (const ACE_CHAR_T *s) const;
 
   /**
    *  Performs a strncmp comparison.
@@ -513,7 +513,7 @@ public:
    *  @return Integer value of result (less than 0, 0, greater than 0)
    *    depending on how input string @a s is to the stored string.
    */
-  int compare (const ACE_String_Base<CHAR> &s) const;
+  int compare (const ACE_String_Base<ACE_CHAR_T> &s) const;
 
   /**
    *  Dump the state of an object.
@@ -537,16 +537,16 @@ public:
    * it doesn't fill the buffer, so is much faster.
    *
    * @param len The number of CHARs to reserve
-   * @param c The CHAR to use when filling the string.
+   * @param c The ACE_CHAR_T to use when filling the string.
    */
-  void resize (size_type len, CHAR c = 0);
+  void resize (size_type len, ACE_CHAR_T c = 0);
   void fast_resize (size_t len);
 
   /// Swap the contents of this @c ACE_String_Base with @a str.
   /**
    * @note This is non-throwing operation.
    */
-  void swap (ACE_String_Base<CHAR> & str);
+  void swap (ACE_String_Base<ACE_CHAR_T> & str);
 
   iterator begin (void);
   const_iterator begin (void) const;
@@ -579,7 +579,7 @@ protected:
   /**
    *  Pointer to data.
    */
-  CHAR *rep_;
+  ACE_CHAR_T *rep_;
 
   /**
    *  Flag that indicates if we own the memory
@@ -589,7 +589,7 @@ protected:
   /**
    *  Represents the "NULL" string to simplify the internal logic.
    */
-  static CHAR NULL_String_;
+  static ACE_CHAR_T NULL_String_;
 };
 
 /**
@@ -603,15 +603,15 @@ protected:
  * category. Future versions of the class will support the operations
  * of std::random_access_iterator_tag.
  */
-template <class CHAR>
+template <class ACE_CHAR_T>
 class ACE_String_Base_Iterator
 {
 public:
   // = std::iterator_traits typedefs/traits.
   typedef std::bidirectional_iterator_tag iterator_category;
-  typedef CHAR                            value_type;
-  typedef CHAR &                          reference;
-  typedef CHAR *                          pointer;
+  typedef ACE_CHAR_T                            value_type;
+  typedef ACE_CHAR_T &                          reference;
+  typedef ACE_CHAR_T *                          pointer;
   typedef ptrdiff_t                       difference_type;
 
   /**
@@ -619,14 +619,14 @@ public:
    *
    * @param[in]       str         Target string for iterator.
    */
-  ACE_String_Base_Iterator (ACE_String_Base <CHAR> & str, int end = 0);
+  ACE_String_Base_Iterator (ACE_String_Base <ACE_CHAR_T> & str, int end = 0);
 
   /**
    * Copy constructor
    *
    * @param[in]       iter        Iterator to copy.
    */
-  ACE_String_Base_Iterator (const ACE_String_Base_Iterator <CHAR> & iter);
+  ACE_String_Base_Iterator (const ACE_String_Base_Iterator <ACE_CHAR_T> & iter);
 
   /// Destructor.
   ~ACE_String_Base_Iterator (void);
@@ -646,7 +646,7 @@ public:
    * @retval         0          All characters have been seen.
    * @retval         1          Items still remain to be seen.
    */
-  int next (CHAR * & ch) const;
+  int next (ACE_CHAR_T * & ch) const;
 
   /**
    * Move to the next character in the string.
@@ -662,58 +662,58 @@ public:
    * @param[in]       iter      Right-hand side of operator.
    * @return          Reference to self.
    */
-  const ACE_String_Base_Iterator <CHAR> & operator = (const ACE_String_Base_Iterator <CHAR> & iter);
+  const ACE_String_Base_Iterator <ACE_CHAR_T> & operator = (const ACE_String_Base_Iterator <ACE_CHAR_T> & iter);
 
   /**
    * Dereference operator
    *
    * @return          Reference to current character seen by iterator.
    */
-  CHAR & operator * (void);
+  ACE_CHAR_T & operator * (void);
 
   /**
    * Prefix operator
    */
-  ACE_String_Base_Iterator <CHAR> & operator ++ (void);
+  ACE_String_Base_Iterator <ACE_CHAR_T> & operator ++ (void);
 
   /**
    * Postfix operator
    */
-  ACE_String_Base_Iterator <CHAR> operator ++ (int);
+  ACE_String_Base_Iterator <ACE_CHAR_T> operator ++ (int);
 
   /**
    * Prefix operator
    */
-  ACE_String_Base_Iterator <CHAR> & operator -- (void);
+  ACE_String_Base_Iterator <ACE_CHAR_T> & operator -- (void);
 
   /**
    * Postfix operator
    */
-  ACE_String_Base_Iterator <CHAR> operator -- (int);
+  ACE_String_Base_Iterator <ACE_CHAR_T> operator -- (int);
 
   /**
    * Eqaulity comparison operator
    *
    * @param[in]       rhs       Right-hand side of operator.
    */
-  bool operator == (const ACE_String_Base_Iterator <CHAR> & rhs) const;
+  bool operator == (const ACE_String_Base_Iterator <ACE_CHAR_T> & rhs) const;
 
   /**
    * Ineqaulity comparison operator
    *
    * @param[in]       rhs       Right-hand side of operator.
    */
-  bool operator != (const ACE_String_Base_Iterator <CHAR> & rhs) const;
+  bool operator != (const ACE_String_Base_Iterator <ACE_CHAR_T> & rhs) const;
 
-  bool operator < (const ACE_String_Base_Iterator <CHAR> & rhs) const;
-  bool operator > (const ACE_String_Base_Iterator <CHAR> & rhs) const;
+  bool operator < (const ACE_String_Base_Iterator <ACE_CHAR_T> & rhs) const;
+  bool operator > (const ACE_String_Base_Iterator <ACE_CHAR_T> & rhs) const;
 
-  bool operator <= (const ACE_String_Base_Iterator <CHAR> & rhs) const;
-  bool operator >= (const ACE_String_Base_Iterator <CHAR> & rhs) const;
+  bool operator <= (const ACE_String_Base_Iterator <ACE_CHAR_T> & rhs) const;
+  bool operator >= (const ACE_String_Base_Iterator <ACE_CHAR_T> & rhs) const;
 
 private:
   /// Target string to iterate over.
-  ACE_String_Base <CHAR> * str_;
+  ACE_String_Base <ACE_CHAR_T> * str_;
 
   /// Current location in the string.
   size_t index_;
@@ -730,15 +730,15 @@ private:
  * category. Future versions of the class will support the operations
  * of std::random_access_iterator_tag.
  */
-template <class CHAR>
+template <class ACE_CHAR_T>
 class ACE_String_Base_Const_Iterator
 {
 public:
   // = std::iterator_traits typedefs/traits.
   typedef std::bidirectional_iterator_tag iterator_category;
-  typedef const CHAR                      value_type;
-  typedef const CHAR &                    reference;
-  typedef const CHAR *                    pointer;
+  typedef const ACE_CHAR_T                      value_type;
+  typedef const ACE_CHAR_T &                    reference;
+  typedef const ACE_CHAR_T *                    pointer;
   typedef ptrdiff_t                       difference_type;
 
   /**
@@ -746,14 +746,14 @@ public:
    *
    * @param[in]       str         Target string for iterator.
    */
-  ACE_String_Base_Const_Iterator (const ACE_String_Base <CHAR> & str, int end = 0);
+  ACE_String_Base_Const_Iterator (const ACE_String_Base <ACE_CHAR_T> & str, int end = 0);
 
   /**
    * Copy constructor
    *
    * @param[in]       iter        Iterator to copy.
    */
-  ACE_String_Base_Const_Iterator (const ACE_String_Base_Const_Iterator <CHAR> & iter);
+  ACE_String_Base_Const_Iterator (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & iter);
 
   /// Destructor.
   ~ACE_String_Base_Const_Iterator (void);
@@ -773,7 +773,7 @@ public:
    * @retval         0          All characters have been seen.
    * @retval         1          Items still remain to be seen.
    */
-  int next (const CHAR * & ch) const;
+  int next (const ACE_CHAR_T * & ch) const;
 
   /**
    * Move to the next character in the string.
@@ -789,88 +789,88 @@ public:
    * @param[in]       iter      Right-hand side of operator.
    * @return          Reference to self.
    */
-  const ACE_String_Base_Const_Iterator <CHAR> & operator = (const ACE_String_Base_Const_Iterator <CHAR> & iter);
+  const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & operator = (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & iter);
 
   /**
    * Dereference operator
    *
    * @return          Reference to current character seen by iterator.
    */
-  const CHAR & operator * (void);
+  const ACE_CHAR_T & operator * (void);
 
   /**
    * Prefix operator
    */
-  ACE_String_Base_Const_Iterator <CHAR> & operator ++ (void);
+  ACE_String_Base_Const_Iterator <ACE_CHAR_T> & operator ++ (void);
 
   /**
    * Postfix operator
    */
-  ACE_String_Base_Const_Iterator <CHAR> operator ++ (int);
+  ACE_String_Base_Const_Iterator <ACE_CHAR_T> operator ++ (int);
 
   /**
    * Prefix operator
    */
-  ACE_String_Base_Const_Iterator <CHAR> & operator -- (void);
+  ACE_String_Base_Const_Iterator <ACE_CHAR_T> & operator -- (void);
 
   /**
    * Postfix operator
    */
-  ACE_String_Base_Const_Iterator <CHAR> operator -- (int);
+  ACE_String_Base_Const_Iterator <ACE_CHAR_T> operator -- (int);
 
   /**
    * Eqaulity comparison operator
    *
    * @param[in]       rhs       Right-hand side of operator.
    */
-  bool operator == (const ACE_String_Base_Const_Iterator <CHAR> & rhs) const;
+  bool operator == (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & rhs) const;
 
   /**
    * Ineqaulity comparison operator
    *
    * @param[in]       rhs       Right-hand side of operator.
    */
-  bool operator != (const ACE_String_Base_Const_Iterator <CHAR> & rhs) const;
+  bool operator != (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & rhs) const;
 
-  bool operator < (const ACE_String_Base_Const_Iterator <CHAR> & rhs) const;
-  bool operator > (const ACE_String_Base_Const_Iterator <CHAR> & rhs) const;
+  bool operator < (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & rhs) const;
+  bool operator > (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & rhs) const;
 
-  bool operator <= (const ACE_String_Base_Const_Iterator <CHAR> & rhs) const;
-  bool operator >= (const ACE_String_Base_Const_Iterator <CHAR> & rhs) const;
+  bool operator <= (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & rhs) const;
+  bool operator >= (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & rhs) const;
 
 private:
   /// Target string to iterate over.
-  const ACE_String_Base <CHAR> * str_;
+  const ACE_String_Base <ACE_CHAR_T> * str_;
 
   /// Current location in the string.
   size_t index_;
 };
 
-template < class CHAR >
-  ACE_String_Base < CHAR > operator + (const ACE_String_Base < CHAR > &,
-                                       const ACE_String_Base < CHAR > &);
-template < class CHAR >
-  ACE_String_Base < CHAR > operator + (const ACE_String_Base < CHAR > &,
-                                       const CHAR *);
-template < class CHAR >
-  ACE_String_Base < CHAR > operator + (const CHAR *,
-                                       const ACE_String_Base < CHAR > &);
-
-template < class CHAR >
-  ACE_String_Base < CHAR > operator + (const ACE_String_Base < CHAR > &t,
-                                       const CHAR c);
-
-template < class CHAR >
-  ACE_String_Base < CHAR > operator + (const CHAR c,
-                                       const ACE_String_Base < CHAR > &t);
-
-template <class CHAR>
-  bool operator == (const CHAR *s,
-                    const ACE_String_Base<CHAR> &t);
-
-template <class CHAR>
-  bool operator != (const CHAR *s,
-                    const ACE_String_Base<CHAR> &t);
+template < class ACE_CHAR_T >
+  ACE_String_Base < ACE_CHAR_T > operator + (const ACE_String_Base < ACE_CHAR_T > &,
+                                       const ACE_String_Base < ACE_CHAR_T > &);
+template < class ACE_CHAR_T >
+  ACE_String_Base < ACE_CHAR_T > operator + (const ACE_String_Base < ACE_CHAR_T > &,
+                                       const ACE_CHAR_T *);
+template < class ACE_CHAR_T >
+  ACE_String_Base < ACE_CHAR_T > operator + (const ACE_CHAR_T *,
+                                       const ACE_String_Base < ACE_CHAR_T > &);
+
+template < class ACE_CHAR_T >
+  ACE_String_Base < ACE_CHAR_T > operator + (const ACE_String_Base < ACE_CHAR_T > &t,
+                                       const ACE_CHAR_T c);
+
+template < class ACE_CHAR_T >
+  ACE_String_Base < ACE_CHAR_T > operator + (const ACE_CHAR_T c,
+                                       const ACE_String_Base < ACE_CHAR_T > &t);
+
+template <class ACE_CHAR_T>
+  bool operator == (const ACE_CHAR_T *s,
+                    const ACE_String_Base<ACE_CHAR_T> &t);
+
+template <class ACE_CHAR_T>
+  bool operator != (const ACE_CHAR_T *s,
+                    const ACE_String_Base<ACE_CHAR_T> &t);
 
 ACE_END_VERSIONED_NAMESPACE_DECL
 
diff --git a/ACE/ace/String_Base.inl b/ACE/ace/String_Base.inl
index 17643cbe089..29c262e2b56 100644
--- a/ACE/ace/String_Base.inl
+++ b/ACE/ace/String_Base.inl
@@ -9,214 +9,214 @@
 
 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 
-template <class CHAR> ACE_INLINE void
-ACE_String_Base<CHAR>::dump (void) const
+template <class ACE_CHAR_T> ACE_INLINE void
+ACE_String_Base<ACE_CHAR_T>::dump (void) const
 {
 #if defined (ACE_HAS_DUMP)
-  ACE_TRACE ("ACE_String_Base<CHAR>::dump");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::dump");
 #endif /* ACE_HAS_DUMP */
 }
 
 // Assignment method (does not copy memory)
-template <class CHAR> ACE_INLINE ACE_String_Base<CHAR> &
-ACE_String_Base<CHAR>::assign_nocopy (const ACE_String_Base<CHAR> &s)
+template <class ACE_CHAR_T> ACE_INLINE ACE_String_Base<ACE_CHAR_T> &
+ACE_String_Base<ACE_CHAR_T>::assign_nocopy (const ACE_String_Base<ACE_CHAR_T> &s)
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::assign_nocopy");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::assign_nocopy");
   this->set (s.rep_, s.len_, false);
   return *this;
 }
 
-template <class CHAR> ACE_INLINE typename ACE_String_Base<CHAR>::size_type
-ACE_String_Base<CHAR>::length (void) const
+template <class ACE_CHAR_T> ACE_INLINE typename ACE_String_Base<ACE_CHAR_T>::size_type
+ACE_String_Base<ACE_CHAR_T>::length (void) const
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::length");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::length");
   return this->len_;
 }
 
-template <class CHAR> ACE_INLINE size_t
-ACE_String_Base<CHAR>::capacity (void) const
+template <class ACE_CHAR_T> ACE_INLINE size_t
+ACE_String_Base<ACE_CHAR_T>::capacity (void) const
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::capacity");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::capacity");
   return this->buf_len_;
 }
 
-template <class CHAR> ACE_INLINE bool
-ACE_String_Base<CHAR>::is_empty (void) const
+template <class ACE_CHAR_T> ACE_INLINE bool
+ACE_String_Base<ACE_CHAR_T>::is_empty (void) const
 {
   return this->len_ == 0;
 }
 
-template <class CHAR> ACE_INLINE bool
-ACE_String_Base<CHAR>::empty (void) const
+template <class ACE_CHAR_T> ACE_INLINE bool
+ACE_String_Base<ACE_CHAR_T>::empty (void) const
 {
   return this->is_empty ();
 }
 
-template <class CHAR> ACE_INLINE ACE_String_Base<CHAR>
-ACE_String_Base<CHAR>::substr (
-  typename ACE_String_Base<CHAR>::size_type offset,
-  typename ACE_String_Base<CHAR>::size_type length) const
+template <class ACE_CHAR_T> ACE_INLINE ACE_String_Base<ACE_CHAR_T>
+ACE_String_Base<ACE_CHAR_T>::substr (
+  typename ACE_String_Base<ACE_CHAR_T>::size_type offset,
+  typename ACE_String_Base<ACE_CHAR_T>::size_type length) const
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::substr");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::substr");
   return this->substring (offset, length);
 }
 
 // Return the <slot'th> character in the string.
 
-template <class CHAR> ACE_INLINE const CHAR &
-ACE_String_Base<CHAR>::operator[] (
-  typename ACE_String_Base<CHAR>::size_type slot) const
+template <class ACE_CHAR_T> ACE_INLINE const ACE_CHAR_T &
+ACE_String_Base<ACE_CHAR_T>::operator[] (
+  typename ACE_String_Base<ACE_CHAR_T>::size_type slot) const
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::operator[]");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::operator[]");
   return this->rep_[slot];
 }
 
 // Return the <slot'th> character in the string by reference.
 
-template <class CHAR> ACE_INLINE CHAR &
-ACE_String_Base<CHAR>::operator[] (
-  typename ACE_String_Base<CHAR>::size_type slot)
+template <class ACE_CHAR_T> ACE_INLINE ACE_CHAR_T &
+ACE_String_Base<ACE_CHAR_T>::operator[] (
+  typename ACE_String_Base<ACE_CHAR_T>::size_type slot)
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::operator[]");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::operator[]");
   return this->rep_[slot];
 }
 
-template <class CHAR> ACE_INLINE const CHAR *
-ACE_String_Base<CHAR>::fast_rep (void) const
+template <class ACE_CHAR_T> ACE_INLINE const ACE_CHAR_T *
+ACE_String_Base<ACE_CHAR_T>::fast_rep (void) const
 {
   return this->rep_;
 }
 
-template <class CHAR> ACE_INLINE const CHAR *
-ACE_String_Base<CHAR>::c_str (void) const
+template <class ACE_CHAR_T> ACE_INLINE const ACE_CHAR_T *
+ACE_String_Base<ACE_CHAR_T>::c_str (void) const
 {
   return this->rep_;
 }
 
 // Less than comparison operator.
 
-template <class CHAR> ACE_INLINE bool
-ACE_String_Base<CHAR>::operator < (const ACE_String_Base<CHAR> &s) const
+template <class ACE_CHAR_T> ACE_INLINE bool
+ACE_String_Base<ACE_CHAR_T>::operator < (const ACE_String_Base<ACE_CHAR_T> &s) const
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::operator <");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::operator <");
   return compare (s) < 0;
 }
 
 // Greater than comparison operator.
 
-template <class CHAR> ACE_INLINE bool
-ACE_String_Base<CHAR>::operator > (const ACE_String_Base &s) const
+template <class ACE_CHAR_T> ACE_INLINE bool
+ACE_String_Base<ACE_CHAR_T>::operator > (const ACE_String_Base &s) const
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::operator >");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::operator >");
   return compare (s) > 0;
 }
 
 
 // Comparison operator.
 
-template <class CHAR> ACE_INLINE bool
-ACE_String_Base<CHAR>::operator!= (const ACE_String_Base<CHAR> &s) const
+template <class ACE_CHAR_T> ACE_INLINE bool
+ACE_String_Base<ACE_CHAR_T>::operator!= (const ACE_String_Base<ACE_CHAR_T> &s) const
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::operator!=");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::operator!=");
   return !(*this == s);
 }
 
-template <class CHAR> ACE_INLINE bool
-ACE_String_Base<CHAR>::operator!= (const CHAR *s) const
+template <class ACE_CHAR_T> ACE_INLINE bool
+ACE_String_Base<ACE_CHAR_T>::operator!= (const ACE_CHAR_T *s) const
 {
   return !(*this == s);
 }
 
-template <class CHAR> ACE_INLINE typename ACE_String_Base<CHAR>::size_type
-ACE_String_Base<CHAR>::find (const ACE_String_Base<CHAR>&str,
-                             typename ACE_String_Base<CHAR>::size_type pos) const
+template <class ACE_CHAR_T> ACE_INLINE typename ACE_String_Base<ACE_CHAR_T>::size_type
+ACE_String_Base<ACE_CHAR_T>::find (const ACE_String_Base<ACE_CHAR_T>&str,
+                             typename ACE_String_Base<ACE_CHAR_T>::size_type pos) const
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::find");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::find");
   return this->find (str.rep_, pos);
 }
 
-template <class CHAR> ACE_INLINE typename ACE_String_Base<CHAR>::size_type
-ACE_String_Base<CHAR>::strstr (const ACE_String_Base<CHAR> &s) const
+template <class ACE_CHAR_T> ACE_INLINE typename ACE_String_Base<ACE_CHAR_T>::size_type
+ACE_String_Base<ACE_CHAR_T>::strstr (const ACE_String_Base<ACE_CHAR_T> &s) const
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::strstr");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::strstr");
   return this->find (s.rep_);
 }
 
-template <class CHAR> ACE_INLINE typename ACE_String_Base<CHAR>::iterator
-ACE_String_Base<CHAR>::begin (void)
+template <class ACE_CHAR_T> ACE_INLINE typename ACE_String_Base<ACE_CHAR_T>::iterator
+ACE_String_Base<ACE_CHAR_T>::begin (void)
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::begin");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::begin");
   return iterator (*this);
 }
 
-template <class CHAR> ACE_INLINE typename ACE_String_Base<CHAR>::const_iterator
-ACE_String_Base<CHAR>::begin (void) const
+template <class ACE_CHAR_T> ACE_INLINE typename ACE_String_Base<ACE_CHAR_T>::const_iterator
+ACE_String_Base<ACE_CHAR_T>::begin (void) const
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::begin");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::begin");
   return const_iterator (*this);
 }
 
-template <class CHAR> ACE_INLINE typename ACE_String_Base<CHAR>::iterator
-ACE_String_Base<CHAR>::end (void)
+template <class ACE_CHAR_T> ACE_INLINE typename ACE_String_Base<ACE_CHAR_T>::iterator
+ACE_String_Base<ACE_CHAR_T>::end (void)
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::end");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::end");
   return iterator (*this, 1);
 }
 
-template <class CHAR> ACE_INLINE typename ACE_String_Base<CHAR>::const_iterator
-ACE_String_Base<CHAR>::end (void) const
+template <class ACE_CHAR_T> ACE_INLINE typename ACE_String_Base<ACE_CHAR_T>::const_iterator
+ACE_String_Base<ACE_CHAR_T>::end (void) const
 {
-  ACE_TRACE ("ACE_String_Base<CHAR>::end");
+  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::end");
   return const_iterator (*this, 1);
 }
 
 // ----------------------------------------------
 
-template <class CHAR> ACE_INLINE
-ACE_String_Base_Iterator <CHAR>::
-ACE_String_Base_Iterator (ACE_String_Base <CHAR> & str, int end)
+template <class ACE_CHAR_T> ACE_INLINE
+ACE_String_Base_Iterator <ACE_CHAR_T>::
+ACE_String_Base_Iterator (ACE_String_Base <ACE_CHAR_T> & str, int end)
 : str_ (&str),
   index_ (0 == end ? 0 : str.length ())
 {
-  ACE_TRACE ("ACE_String_Base_Iterator<CHAR>::ACE_String_Base_Iterator");
+  ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::ACE_String_Base_Iterator");
 }
 
-template <class CHAR> ACE_INLINE
-ACE_String_Base_Iterator <CHAR>::
-ACE_String_Base_Iterator (const ACE_String_Base_Iterator <CHAR> & iter)
+template <class ACE_CHAR_T> ACE_INLINE
+ACE_String_Base_Iterator <ACE_CHAR_T>::
+ACE_String_Base_Iterator (const ACE_String_Base_Iterator <ACE_CHAR_T> & iter)
 : str_ (iter.str_),
   index_ (iter.index_)
 {
-  ACE_TRACE ("ACE_String_Base_Iterator<CHAR>::ACE_String_Base_Iterator");
+  ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::ACE_String_Base_Iterator");
 }
 
-template <class CHAR> ACE_INLINE
-ACE_String_Base_Iterator <CHAR>::~ACE_String_Base_Iterator (void)
+template <class ACE_CHAR_T> ACE_INLINE
+ACE_String_Base_Iterator <ACE_CHAR_T>::~ACE_String_Base_Iterator (void)
 {
-  ACE_TRACE ("ACE_String_Base_Iterator<CHAR>::~ACE_String_Base_Iterator");
+  ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::~ACE_String_Base_Iterator");
 }
 
-template <class CHAR> ACE_INLINE
-int ACE_String_Base_Iterator <CHAR>::done (void) const
+template <class ACE_CHAR_T> ACE_INLINE
+int ACE_String_Base_Iterator <ACE_CHAR_T>::done (void) const
 {
-  ACE_TRACE ("ACE_String_Base_Iterator<CHAR>::done");
+  ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::done");
 
   return this->index_ >= this->str_->length () ? 1 : 0;
 }
 
-template <class CHAR> ACE_INLINE
-CHAR & ACE_String_Base_Iterator <CHAR>::operator * (void)
+template <class ACE_CHAR_T> ACE_INLINE
+ACE_CHAR_T & ACE_String_Base_Iterator <ACE_CHAR_T>::operator * (void)
 {
-  ACE_TRACE ("ACE_String_Base_Iterator<CHAR>::operator *");
+  ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::operator *");
 
   return this->str_->rep_[this->index_];
 }
 
-template <class CHAR> ACE_INLINE
-ACE_String_Base_Iterator <CHAR> &
-ACE_String_Base_Iterator <CHAR>::operator ++ (void)
+template <class ACE_CHAR_T> ACE_INLINE
+ACE_String_Base_Iterator <ACE_CHAR_T> &
+ACE_String_Base_Iterator <ACE_CHAR_T>::operator ++ (void)
 {
-  ACE_TRACE ("ACE_String_Base_Iterator<CHAR>::operator ++");
+  ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::operator ++");
 
   if (0 == this->done ())
     ++ this->index_;
@@ -224,13 +224,13 @@ ACE_String_Base_Iterator <CHAR>::operator ++ (void)
   return *this;
 }
 
-template <class CHAR> ACE_INLINE
-ACE_String_Base_Iterator <CHAR>
-ACE_String_Base_Iterator <CHAR>::operator ++ (int)
+template <class ACE_CHAR_T> ACE_INLINE
+ACE_String_Base_Iterator <ACE_CHAR_T>
+ACE_String_Base_Iterator <ACE_CHAR_T>::operator ++ (int)
 {
-  ACE_TRACE ("ACE_String_Base_Iterator<CHAR>::operator ++ (int)");
+  ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::operator ++ (int)");
 
-  ACE_String_Base_Iterator <CHAR> temp (*this);
+  ACE_String_Base_Iterator <ACE_CHAR_T> temp (*this);
 
   if (0 == this->done ())
     ++ this->index_;
@@ -238,11 +238,11 @@ ACE_String_Base_Iterator <CHAR>::operator ++ (int)
   return temp;
 }
 
-template <class CHAR> ACE_INLINE
-ACE_String_Base_Iterator <CHAR> &
-ACE_String_Base_Iterator <CHAR>::operator -- (void)
+template <class ACE_CHAR_T> ACE_INLINE
+ACE_String_Base_Iterator <ACE_CHAR_T> &
+ACE_String_Base_Iterator <ACE_CHAR_T>::operator -- (void)
 {
-  ACE_TRACE ("ACE_String_Base_Iterator<CHAR>::operator --");
+  ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::operator --");
 
   if (0 < this->index_)
     -- this->index_;
@@ -250,13 +250,13 @@ ACE_String_Base_Iterator <CHAR>::operator -- (void)
   return *this;
 }
 
-template <class CHAR> ACE_INLINE
-ACE_String_Base_Iterator <CHAR>
-ACE_String_Base_Iterator <CHAR>::operator -- (int)
+template <class ACE_CHAR_T> ACE_INLINE
+ACE_String_Base_Iterator <ACE_CHAR_T>
+ACE_String_Base_Iterator <ACE_CHAR_T>::operator -- (int)
 {
-  ACE_TRACE ("ACE_String_Base_Iterator<CHAR>::operator -- (int)");
+  ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::operator -- (int)");
 
-  ACE_String_Base_Iterator <CHAR> temp (*this);
+  ACE_String_Base_Iterator <ACE_CHAR_T> temp (*this);
 
   if (0 < this->index_)
     -- this->index_;
@@ -264,95 +264,95 @@ ACE_String_Base_Iterator <CHAR>::operator -- (int)
   return temp;
 }
 
-template <class CHAR> ACE_INLINE bool
-ACE_String_Base_Iterator <CHAR>::
-operator == (const ACE_String_Base_Iterator <CHAR> & rhs) const
+template <class ACE_CHAR_T> ACE_INLINE bool
+ACE_String_Base_Iterator <ACE_CHAR_T>::
+operator == (const ACE_String_Base_Iterator <ACE_CHAR_T> & rhs) const
 {
   return this->index_ == rhs.index_;
 }
 
-template <class CHAR> ACE_INLINE bool
-ACE_String_Base_Iterator <CHAR>::
-operator != (const ACE_String_Base_Iterator <CHAR> & rhs) const
+template <class ACE_CHAR_T> ACE_INLINE bool
+ACE_String_Base_Iterator <ACE_CHAR_T>::
+operator != (const ACE_String_Base_Iterator <ACE_CHAR_T> & rhs) const
 {
   return this->index_ != rhs.index_;
 }
 
-template <class CHAR> ACE_INLINE bool
-ACE_String_Base_Iterator <CHAR>::
-operator < (const ACE_String_Base_Iterator <CHAR> & rhs) const
+template <class ACE_CHAR_T> ACE_INLINE bool
+ACE_String_Base_Iterator <ACE_CHAR_T>::
+operator < (const ACE_String_Base_Iterator <ACE_CHAR_T> & rhs) const
 {
   return this->index_ < rhs.index_;
 }
 
-template <class CHAR> ACE_INLINE bool
-ACE_String_Base_Iterator <CHAR>::
-operator > (const ACE_String_Base_Iterator <CHAR> & rhs) const
+template <class ACE_CHAR_T> ACE_INLINE bool
+ACE_String_Base_Iterator <ACE_CHAR_T>::
+operator > (const ACE_String_Base_Iterator <ACE_CHAR_T> & rhs) const
 {
   return this->index_ > rhs.index_;
 }
 
-template <class CHAR> ACE_INLINE bool
-ACE_String_Base_Iterator <CHAR>::
-operator >= (const ACE_String_Base_Iterator <CHAR> & rhs) const
+template <class ACE_CHAR_T> ACE_INLINE bool
+ACE_String_Base_Iterator <ACE_CHAR_T>::
+operator >= (const ACE_String_Base_Iterator <ACE_CHAR_T> & rhs) const
 {
   return this->index_ >= rhs.index_;
 }
 
-template <class CHAR> ACE_INLINE bool
-ACE_String_Base_Iterator <CHAR>::
-operator <= (const ACE_String_Base_Iterator <CHAR> & rhs) const
+template <class ACE_CHAR_T> ACE_INLINE bool
+ACE_String_Base_Iterator <ACE_CHAR_T>::
+operator <= (const ACE_String_Base_Iterator <ACE_CHAR_T> & rhs) const
 {
   return this->index_ <= rhs.index_;
 }
 
 // ----------------------------------------------
 
-template <class CHAR> ACE_INLINE
-ACE_String_Base_Const_Iterator <CHAR>::
-ACE_String_Base_Const_Iterator (const ACE_String_Base <CHAR> & str, int end)
+template <class ACE_CHAR_T> ACE_INLINE
+ACE_String_Base_Const_Iterator <ACE_CHAR_T>::
+ACE_String_Base_Const_Iterator (const ACE_String_Base <ACE_CHAR_T> & str, int end)
 : str_ (&str),
   index_ (0 == end ? 0 : str.length ())
 {
-  ACE_TRACE ("ACE_String_Base_Const_Iterator<CHAR>::ACE_String_Base_Const_Iterator");
+  ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::ACE_String_Base_Const_Iterator");
 }
 
-template <class CHAR> ACE_INLINE
-ACE_String_Base_Const_Iterator <CHAR>::
-ACE_String_Base_Const_Iterator (const ACE_String_Base_Const_Iterator <CHAR> & iter)
+template <class ACE_CHAR_T> ACE_INLINE
+ACE_String_Base_Const_Iterator <ACE_CHAR_T>::
+ACE_String_Base_Const_Iterator (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & iter)
 : str_ (iter.str_),
   index_ (iter.index_)
 {
-  ACE_TRACE ("ACE_String_Base_Const_Iterator<CHAR>::ACE_String_Base_Const_Iterator");
+  ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::ACE_String_Base_Const_Iterator");
 }
 
-template <class CHAR> ACE_INLINE
-ACE_String_Base_Const_Iterator <CHAR>::~ACE_String_Base_Const_Iterator (void)
+template <class ACE_CHAR_T> ACE_INLINE
+ACE_String_Base_Const_Iterator <ACE_CHAR_T>::~ACE_String_Base_Const_Iterator (void)
 {
-  ACE_TRACE ("ACE_String_Base_Const_Iterator<CHAR>::~ACE_String_Base_Const_Iterator");
+  ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::~ACE_String_Base_Const_Iterator");
 }
 
-template <class CHAR> ACE_INLINE
-int ACE_String_Base_Const_Iterator <CHAR>::done (void) const
+template <class ACE_CHAR_T> ACE_INLINE
+int ACE_String_Base_Const_Iterator <ACE_CHAR_T>::done (void) const
 {
-  ACE_TRACE ("ACE_String_Base_Const_Iterator<CHAR>::done");
+  ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::done");
 
   return this->index_ >= this->str_->length () ? 1 : 0;
 }
 
-template <class CHAR> ACE_INLINE
-const CHAR & ACE_String_Base_Const_Iterator <CHAR>::operator * (void)
+template <class ACE_CHAR_T> ACE_INLINE
+const ACE_CHAR_T & ACE_String_Base_Const_Iterator <ACE_CHAR_T>::operator * (void)
 {
-  ACE_TRACE ("ACE_String_Base_Const_Iterator<CHAR>::operator *");
+  ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::operator *");
 
   return this->str_->rep_[this->index_];
 }
 
-template <class CHAR> ACE_INLINE
-ACE_String_Base_Const_Iterator <CHAR> &
-ACE_String_Base_Const_Iterator <CHAR>::operator ++ (void)
+template <class ACE_CHAR_T> ACE_INLINE
+ACE_String_Base_Const_Iterator <ACE_CHAR_T> &
+ACE_String_Base_Const_Iterator <ACE_CHAR_T>::operator ++ (void)
 {
-  ACE_TRACE ("ACE_String_Base_Const_Iterator<CHAR>::operator ++");
+  ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::operator ++");
 
   if (0 == this->done ())
     ++ this->index_;
@@ -360,13 +360,13 @@ ACE_String_Base_Const_Iterator <CHAR>::operator ++ (void)
   return *this;
 }
 
-template <class CHAR> ACE_INLINE
-ACE_String_Base_Const_Iterator <CHAR>
-ACE_String_Base_Const_Iterator <CHAR>::operator ++ (int)
+template <class ACE_CHAR_T> ACE_INLINE
+ACE_String_Base_Const_Iterator <ACE_CHAR_T>
+ACE_String_Base_Const_Iterator <ACE_CHAR_T>::operator ++ (int)
 {
-  ACE_TRACE ("ACE_String_Base_Const_Iterator<CHAR>::operator ++ (int)");
+  ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::operator ++ (int)");
 
-  ACE_String_Base_Const_Iterator <CHAR> temp (*this);
+  ACE_String_Base_Const_Iterator <ACE_CHAR_T> temp (*this);
 
   if (0 == this->done ())
     ++ this->index_;
@@ -374,11 +374,11 @@ ACE_String_Base_Const_Iterator <CHAR>::operator ++ (int)
   return temp;
 }
 
-template <class CHAR> ACE_INLINE
-ACE_String_Base_Const_Iterator <CHAR> &
-ACE_String_Base_Const_Iterator <CHAR>::operator -- (void)
+template <class ACE_CHAR_T> ACE_INLINE
+ACE_String_Base_Const_Iterator <ACE_CHAR_T> &
+ACE_String_Base_Const_Iterator <ACE_CHAR_T>::operator -- (void)
 {
-  ACE_TRACE ("ACE_String_Base_Const_Iterator<CHAR>::operator --");
+  ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::operator --");
 
   if (0 < this->index_)
     -- this->index_;
@@ -386,13 +386,13 @@ ACE_String_Base_Const_Iterator <CHAR>::operator -- (void)
   return *this;
 }
 
-template <class CHAR> ACE_INLINE
-ACE_String_Base_Const_Iterator <CHAR>
-ACE_String_Base_Const_Iterator <CHAR>::operator -- (int)
+template <class ACE_CHAR_T> ACE_INLINE
+ACE_String_Base_Const_Iterator <ACE_CHAR_T>
+ACE_String_Base_Const_Iterator <ACE_CHAR_T>::operator -- (int)
 {
-  ACE_TRACE ("ACE_String_Base_Const_Iterator<CHAR>::operator -- (int)");
+  ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::operator -- (int)");
 
-  ACE_String_Base_Const_Iterator <CHAR> temp (*this);
+  ACE_String_Base_Const_Iterator <ACE_CHAR_T> temp (*this);
 
   if (0 < this->index_)
     -- this->index_;
@@ -400,60 +400,60 @@ ACE_String_Base_Const_Iterator <CHAR>::operator -- (int)
   return temp;
 }
 
-template <class CHAR> ACE_INLINE bool
-ACE_String_Base_Const_Iterator <CHAR>::
-operator == (const ACE_String_Base_Const_Iterator <CHAR> & rhs) const
+template <class ACE_CHAR_T> ACE_INLINE bool
+ACE_String_Base_Const_Iterator <ACE_CHAR_T>::
+operator == (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & rhs) const
 {
   return this->index_ == rhs.index_;
 }
 
-template <class CHAR> ACE_INLINE bool
-ACE_String_Base_Const_Iterator <CHAR>::
-operator != (const ACE_String_Base_Const_Iterator <CHAR> & rhs) const
+template <class ACE_CHAR_T> ACE_INLINE bool
+ACE_String_Base_Const_Iterator <ACE_CHAR_T>::
+operator != (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & rhs) const
 {
   return this->index_ != rhs.index_;
 }
 
-template <class CHAR> ACE_INLINE bool
-ACE_String_Base_Const_Iterator <CHAR>::
-operator < (const ACE_String_Base_Const_Iterator <CHAR> & rhs) const
+template <class ACE_CHAR_T> ACE_INLINE bool
+ACE_String_Base_Const_Iterator <ACE_CHAR_T>::
+operator < (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & rhs) const
 {
   return this->index_ < rhs.index_;
 }
 
-template <class CHAR> ACE_INLINE bool
-ACE_String_Base_Const_Iterator <CHAR>::
-operator > (const ACE_String_Base_Const_Iterator <CHAR> & rhs) const
+template <class ACE_CHAR_T> ACE_INLINE bool
+ACE_String_Base_Const_Iterator <ACE_CHAR_T>::
+operator > (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & rhs) const
 {
   return this->index_ > rhs.index_;
 }
 
-template <class CHAR> ACE_INLINE bool
-ACE_String_Base_Const_Iterator <CHAR>::
-operator >= (const ACE_String_Base_Const_Iterator <CHAR> & rhs) const
+template <class ACE_CHAR_T> ACE_INLINE bool
+ACE_String_Base_Const_Iterator <ACE_CHAR_T>::
+operator >= (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & rhs) const
 {
   return this->index_ >= rhs.index_;
 }
 
-template <class CHAR> ACE_INLINE bool
-ACE_String_Base_Const_Iterator <CHAR>::
-operator <= (const ACE_String_Base_Const_Iterator <CHAR> & rhs) const
+template <class ACE_CHAR_T> ACE_INLINE bool
+ACE_String_Base_Const_Iterator <ACE_CHAR_T>::
+operator <= (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & rhs) const
 {
   return this->index_ <= rhs.index_;
 }
 
 // ----------------------------------------------
 
-template <class CHAR> ACE_INLINE bool
-operator== (const CHAR *s,
-            const ACE_String_Base<CHAR> &t)
+template <class ACE_CHAR_T> ACE_INLINE bool
+operator== (const ACE_CHAR_T *s,
+            const ACE_String_Base<ACE_CHAR_T> &t)
 {
   return t == s;
 }
 
-template <class CHAR> ACE_INLINE bool
-operator!= (const CHAR *s,
-            const ACE_String_Base<CHAR> &t)
+template <class ACE_CHAR_T> ACE_INLINE bool
+operator!= (const ACE_CHAR_T *s,
+            const ACE_String_Base<ACE_CHAR_T> &t)
 {
   return !(t == s);
 }
diff --git a/ACE/ace/Tokenizer_T.cpp b/ACE/ace/Tokenizer_T.cpp
index a0af46e9ec0..d913a92049b 100644
--- a/ACE/ace/Tokenizer_T.cpp
+++ b/ACE/ace/Tokenizer_T.cpp
@@ -11,8 +11,8 @@
 
 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 
-template <class CHAR>
-ACE_Tokenizer_T<CHAR>::ACE_Tokenizer_T (CHAR *buffer)
+template <class ACE_CHAR_T>
+ACE_Tokenizer_T<ACE_CHAR_T>::ACE_Tokenizer_T (ACE_CHAR_T *buffer)
   : buffer_ (buffer),
     index_ (0),
     preserves_index_ (0),
@@ -20,9 +20,9 @@ ACE_Tokenizer_T<CHAR>::ACE_Tokenizer_T (CHAR *buffer)
 {
 }
 
-template <class CHAR>
+template <class ACE_CHAR_T>
 int
-ACE_Tokenizer_T<CHAR>::delimiter (CHAR d)
+ACE_Tokenizer_T<ACE_CHAR_T>::delimiter (ACE_CHAR_T d)
 {
   if (delimiter_index_ == MAX_DELIMITERS)
     return -1;
@@ -33,10 +33,10 @@ ACE_Tokenizer_T<CHAR>::delimiter (CHAR d)
   return 0;
 }
 
-template <class CHAR>
+template <class ACE_CHAR_T>
 int
-ACE_Tokenizer_T<CHAR>::delimiter_replace (CHAR d,
-                                  CHAR replacement)
+ACE_Tokenizer_T<ACE_CHAR_T>::delimiter_replace (ACE_CHAR_T d,
+                                  ACE_CHAR_T replacement)
 {
   // Make it possible to replace delimiters on-the-fly, e.g., parse
   // string until certain token count and then copy rest of the
@@ -59,10 +59,10 @@ ACE_Tokenizer_T<CHAR>::delimiter_replace (CHAR d,
   return 0;
 }
 
-template <class CHAR>
+template <class ACE_CHAR_T>
 int
-ACE_Tokenizer_T<CHAR>::preserve_designators (CHAR start,
-                                     CHAR stop,
+ACE_Tokenizer_T<ACE_CHAR_T>::preserve_designators (ACE_CHAR_T start,
+                                     ACE_CHAR_T stop,
                                      int strip)
 {
   if (preserves_index_ == MAX_PRESERVES)
@@ -75,11 +75,11 @@ ACE_Tokenizer_T<CHAR>::preserve_designators (CHAR start,
   return 0;
 }
 
-template <class CHAR>
+template <class ACE_CHAR_T>
 int
-ACE_Tokenizer_T<CHAR>::is_delimiter (CHAR d,
+ACE_Tokenizer_T<ACE_CHAR_T>::is_delimiter (ACE_CHAR_T d,
                              int &replace,
-                             CHAR &r)
+                             ACE_CHAR_T &r)
 {
   replace = 0;
 
@@ -97,10 +97,10 @@ ACE_Tokenizer_T<CHAR>::is_delimiter (CHAR d,
   return 0;
 }
 
-template <class CHAR>
+template <class ACE_CHAR_T>
 int
-ACE_Tokenizer_T<CHAR>::is_preserve_designator (CHAR start,
-                                       CHAR &stop,
+ACE_Tokenizer_T<ACE_CHAR_T>::is_preserve_designator (ACE_CHAR_T start,
+                                       ACE_CHAR_T &stop,
                                        int &strip)
 {
   for (int x = 0; x < preserves_index_; x++)
@@ -114,9 +114,9 @@ ACE_Tokenizer_T<CHAR>::is_preserve_designator (CHAR start,
   return 0;
 }
 
-template <class CHAR>
-CHAR *
-ACE_Tokenizer_T<CHAR>::next (void)
+template <class ACE_CHAR_T>
+ACE_CHAR_T *
+ACE_Tokenizer_T<ACE_CHAR_T>::next (void)
 {
   // Check if the previous pass was the last one in the buffer.
   if (index_ == -1)
@@ -124,16 +124,16 @@ ACE_Tokenizer_T<CHAR>::next (void)
       index_ = 0;
       return 0;
     }
-    
+ 
   // Check if a buffer has been passed
   if (!buffer_)
     {
       return 0;
     }
 
-  CHAR replacement = 0;
+  ACE_CHAR_T replacement = 0;
   int replace;
-  CHAR *next_token = 0;
+  ACE_CHAR_T *next_token = 0;
 
   // Skip all leading delimiters.
   for (;;)
@@ -159,7 +159,7 @@ ACE_Tokenizer_T<CHAR>::next (void)
   next_token = buffer_ + index_;
 
   // A preserved region is it's own token.
-  CHAR stop;
+  ACE_CHAR_T stop;
   int strip;
   if (this->is_preserve_designator (buffer_[index_],
                                     stop,
diff --git a/ACE/ace/Tokenizer_T.h b/ACE/ace/Tokenizer_T.h
index 0d5455d14c4..097f9cc3965 100644
--- a/ACE/ace/Tokenizer_T.h
+++ b/ACE/ace/Tokenizer_T.h
@@ -33,7 +33,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  * preserve designators.  Does not allow special characters, yet
  * (e.g., printf ("\"like a quoted string\"")).
  */
-template <class CHAR>
+template <class ACE_CHAR_T>
 class ACE_Tokenizer_T
 {
 public:
@@ -47,7 +47,7 @@ public:
    * \sa preserve_designators
    * \sa preserve_designators
    */
-  ACE_Tokenizer_T (CHAR *buffer);
+  ACE_Tokenizer_T (ACE_CHAR_T *buffer);
 
   /**
    * \a d is a delimiter.
@@ -70,7 +70,7 @@ public:
       Joseph/Hagins
       Hagins \endverbatim
    */
-  int delimiter (CHAR d);
+  int delimiter (ACE_CHAR_T d);
 
   /**
    * \a d is a delimiter and, when found, will be replaced by
@@ -94,7 +94,7 @@ public:
        Joseph
        Hagins \endverbatim
  */
-  int delimiter_replace (CHAR d, CHAR replacement);
+  int delimiter_replace (ACE_CHAR_T d, ACE_CHAR_T replacement);
 
   /**
    * Extract string between a pair of designator characters.
@@ -139,10 +139,10 @@ public:
       Joseph
       Hagins \endverbatim
    */
-  int preserve_designators (CHAR start, CHAR stop, int strip=1);
+  int preserve_designators (ACE_CHAR_T start, ACE_CHAR_T stop, int strip=1);
 
   /// Returns the next token.
-  CHAR *next (void);
+  ACE_CHAR_T *next (void);
 
   enum {
     MAX_DELIMITERS=16,
@@ -152,16 +152,16 @@ public:
 protected:
   /// Returns 1 if @a d is a delimiter, 0 otherwise.  If @a d should be
   /// replaced with @a r, @a replace is set to 1, otherwise 0.
-  int is_delimiter (CHAR d, int &replace, CHAR &r);
+  int is_delimiter (ACE_CHAR_T d, int &replace, ACE_CHAR_T &r);
 
   /**
    * If @a start is a start preserve designator, returns 1 and sets
    * @a stop to the stop designator.  Returns 0 if @a start is not a
    * preserve designator.
    */
-  int is_preserve_designator (CHAR start, CHAR &stop, int &strip);
+  int is_preserve_designator (ACE_CHAR_T start, ACE_CHAR_T &stop, int &strip);
 
-  CHAR *buffer_;
+  ACE_CHAR_T *buffer_;
   int index_;
 
   /**
@@ -184,8 +184,8 @@ protected:
      * E.g., ")".
      * Whether the designators should be removed from the token.
      */
-    CHAR start_;
-    CHAR stop_;
+    ACE_CHAR_T start_;
+    ACE_CHAR_T stop_;
     int strip_;
   };
 
@@ -212,8 +212,8 @@ protected:
      * with a technique that sets replacement_ = delimiter by
      * default.  I'll do that next iteration.
      */
-    CHAR delimiter_;
-    CHAR replacement_;
+    ACE_CHAR_T delimiter_;
+    ACE_CHAR_T replacement_;
     int replace_;
   };