Wed Feb 14 08:53:58 UTC 2007 Johnny Willemsen <jwillemsen@remedy.nl>

32 files changed, 306 insertions, 259 deletions

diff --git a/ACE/ChangeLog b/ACE/ChangeLog
index b2ad61fcd6d..2e7cdd6d35d 100644
--- a/ACE/ChangeLog
+++ b/ACE/ChangeLog
@@ -1,3 +1,38 @@
+Wed Feb 14 08:53:58 UTC 2007  Johnny Willemsen  <jwillemsen@remedy.nl>
+
+        * ace/Active_Map_Manager_T.h:
+        * ace/Cache_Map_Manager_T.h:
+        * ace/CDR_Size.h:
+        * ace/CDR_Stream.h:
+        * ace/Configuration.h:
+        * ace/Dev_Poll_Reactor.h:
+        * ace/Future.h:
+        * ace/Future_Set.h:
+        * ace/Hash_Cache_Map_Manager_T.h:
+        * ace/High_Res_Timer.h:
+        * ace/INET_Addr.h:
+        * ace/IO_SAP.h:
+        * ace/IPC_SAP.h:
+        * ace/Map_T.h:
+        * ace/MEM_SAP.h:
+        * ace/Message_Block.h:
+        * ace/Msg_WFMO_Reactor.h:
+        * ace/Multihomed_INET_Addr.h:
+        * ace/Priority_Reactor.h:
+        * ace/Reactor.h:
+        * ace/Reactor_Impl.h:
+        * ace/Recursive_Thread_Mutex.h:
+        * ace/Registry.h:
+        * ace/Semaphore.h:
+        * ace/Shared_Memory_MM.h:
+        * ace/Shared_Memory_SV.h:
+        * ace/SOCK_SEQPACK_Association.h:
+        * ace/Thread_Mutex.h:
+        * ace/Timeprobe_T.h:
+        * ace/Truncate.h:
+        * ace/WFMO_Reactor.h:
+          Doxygen improvements
+
 Tue Feb 13 20:33:58 UTC 2007  Krishnakumar B  <kitty@dre.vanderbilt.edu>
 
         * THANKS: Added gzeleniy@gmail.com to the THANKS list.
diff --git a/ACE/ace/Active_Map_Manager_T.h b/ACE/ace/Active_Map_Manager_T.h
index 2194f8194de..ddec2d1f9bc 100644
--- a/ACE/ace/Active_Map_Manager_T.h
+++ b/ACE/ace/Active_Map_Manager_T.h
@@ -56,7 +56,7 @@ public:
   /// Initialize a <Active_Map_Manager> with the <ACE_DEFAULT_MAP_SIZE>.
   ACE_Active_Map_Manager (ACE_Allocator *alloc = 0);
 
-  /// Initialize a <Active_Map_Manager> with <size> entries.
+  /// Initialize a <Active_Map_Manager> with @a size entries.
   ACE_Active_Map_Manager (size_t size,
                           ACE_Allocator *alloc = 0);
 
@@ -64,7 +64,7 @@ public:
   /// allocated resources.
   ~ACE_Active_Map_Manager (void);
 
-  /// Initialize a <Active_Map_Manager> with size <length>.
+  /// Initialize a <Active_Map_Manager> with size @a length.
   int open (size_t length = ACE_DEFAULT_MAP_SIZE,
             ACE_Allocator *alloc = 0);
 
@@ -72,18 +72,18 @@ public:
   /// allocated resources.
   int close (void);
 
-  /// Add <value> to the map, and the corresponding key produced by the
-  /// Active_Map_Manager is returned through <key>.
+  /// Add @a value to the map, and the corresponding key produced by the
+  /// Active_Map_Manager is returned through @a key.
   int bind (const T &value,
             ACE_Active_Map_Manager_Key &key);
 
-  /// Add <value> to the map.  The user does not care about the
+  /// Add @a value to the map.  The user does not care about the
   /// corresponding key produced by the Active_Map_Manager.
   int bind (const T &value);
 
   /**
    * Reserves a slot in the internal structure and returns the key and
-   * a pointer to the value.  User should place their <value> into
+   * a pointer to the value.  User should place their @a value into
    * <*internal_value>.  This method is useful in reducing the number
    * of copies required in some cases.  Note that <internal_value> is
    * only a temporary pointer and will change when the map resizes.
@@ -93,14 +93,14 @@ public:
   int bind (ACE_Active_Map_Manager_Key &key,
             T *&internal_value);
 
-  /// Reassociate <key> with <value>. The function fails if <key> is
+  /// Reassociate @a key with @a value. The function fails if @a key is
   /// not in the map.
   int rebind (const ACE_Active_Map_Manager_Key &key,
               const T &value);
 
   /**
-   * Reassociate <key> with <value>, storing the old value into the
-   * "out" parameter <old_value>.  The function fails if <key> is not
+   * Reassociate @a key with @a value, storing the old value into the
+   * "out" parameter @a old_value.  The function fails if @a key is not
    * in the map.
    */
   int rebind (const ACE_Active_Map_Manager_Key &key,
@@ -108,24 +108,24 @@ public:
               T &old_value);
 
   /**
-   * Reassociate <key> with <value>, storing the old key and value
-   * into the "out" parameter <old_key> and <old_value>.  The function
-   * fails if <key> is not in the map.
+   * Reassociate @a key with @a value, storing the old key and value
+   * into the "out" parameter @a old_key and @a old_value.  The function
+   * fails if @a key is not in the map.
    */
   int rebind (const ACE_Active_Map_Manager_Key &key,
               const T &value,
               ACE_Active_Map_Manager_Key &old_key,
               T &old_value);
 
-  /// Locate <value> associated with <key>.
+  /// Locate @a value associated with @a key.
   int find (const ACE_Active_Map_Manager_Key &key,
             T &value) const;
 
-  /// Is <key> in the map?
+  /// Is @a key in the map?
   int find (const ACE_Active_Map_Manager_Key &key) const;
 
   /**
-   * Locate <value> associated with <key>.  The value is returned via
+   * Locate @a value associated with @a key.  The value is returned via
    * <internal_value> and hence a copy is saved.  Note that
    * <internal_value> is only a temporary pointer and will change when
    * the map resizes.  Therefore, the user should use the pointer
@@ -134,20 +134,20 @@ public:
   int find (const ACE_Active_Map_Manager_Key &key,
             T *&internal_value) const;
 
-  // Creates a key.  User should place their <value> into
+  // Creates a key.  User should place their @a value into
   // <*internal_value>.  This method is useful in reducing the number
   // of copies required in some cases.
 
-  /// Remove <key> from the map.
+  /// Remove @a key from the map.
   int unbind (const ACE_Active_Map_Manager_Key &key);
 
-  /// Remove <key> from the map, and return the <value> associated with
-  /// <key>.
+  /// Remove @a key from the map, and return the @a value associated with
+  /// @a key.
   int unbind (const ACE_Active_Map_Manager_Key &key,
               T &value);
 
   /**
-   * Locate <value> associated with <key>.  The value is returned via
+   * Locate @a value associated with @a key.  The value is returned via
    * <internal_value> and hence a copy is saved.  Note that
    * <internal_value> is only a temporary pointer and will change when
    * the map resizes or when this slot is reused.  Therefore, the user
diff --git a/ACE/ace/CDR_Size.h b/ACE/ace/CDR_Size.h
index f2bf59ce98c..a7ff689479b 100644
--- a/ACE/ace/CDR_Size.h
+++ b/ACE/ace/CDR_Size.h
@@ -121,7 +121,7 @@ public:
                                            ACE_CDR::ULong length);
 
   ///
-  /// Adjust to <size> and count <size> octets.
+  /// Adjust to @a size and count <size> octets.
   void adjust (size_t size);
 
   /// As above, but now the size and alignment requirements may be
@@ -141,7 +141,7 @@ private:
   ACE_CDR::Boolean write_16 (const ACE_CDR::LongDouble *x);
 
   /**
-   * write an array of <length> elements, each of <size> bytes and the
+   * write an array of @a length elements, each of @a size bytes and the
    * start aligned at a multiple of <align>. The elements are assumed
    * to be packed with the right alignment restrictions.  It is mostly
    * designed for buffers of the basic types.
diff --git a/ACE/ace/CDR_Stream.h b/ACE/ace/CDR_Stream.h
index ce0d9b91e65..5e94707665e 100644
--- a/ACE/ace/CDR_Stream.h
+++ b/ACE/ace/CDR_Stream.h
@@ -94,8 +94,8 @@ public:
   friend class ACE_WChar_Codeset_Translator;
   friend class ACE_InputCDR;
 
-  /// Default constructor, allocates <size> bytes in the internal
-  /// buffer, if <size> == 0 it allocates the default size.
+  /// Default constructor, allocates @a size bytes in the internal
+  /// buffer, if @a size == 0 it allocates the default size.
   ACE_OutputCDR (size_t size = 0,
                  int byte_order = ACE_CDR_BYTE_ORDER,
                  ACE_Allocator* buffer_allocator = 0,
@@ -394,8 +394,8 @@ public:
 
   /**
    * Returns (in <buf>) the next position in the buffer aligned to
-   * <size>, it advances the Message_Block wr_ptr past the data
-   * (i.e., <buf> + <size>). If necessary it grows the Message_Block
+   * @a size, it advances the Message_Block wr_ptr past the data
+   * (i.e., <buf> + @a size). If necessary it grows the Message_Block
    * buffer.  Sets the good_bit to false and returns a -1 on failure.
    */
   int adjust (size_t size,
@@ -446,7 +446,7 @@ private:
   ACE_CDR::Boolean write_16 (const ACE_CDR::LongDouble *x);
 
   /**
-   * write an array of <length> elements, each of <size> bytes and the
+   * write an array of @a length elements, each of @a size bytes and the
    * start aligned at a multiple of <align>. The elements are assumed
    * to be packed with the right alignment restrictions.  It is mostly
    * designed for buffers of the basic types.
@@ -469,7 +469,7 @@ private:
 
   /**
    * Grow the CDR stream. When it returns <buf> contains a pointer to
-   * memory in the CDR stream, with at least <size> bytes ahead of it
+   * memory in the CDR stream, with at least @a size bytes ahead of it
    * and aligned to an <align> boundary. It moved the <wr_ptr> to <buf
    * + size>.
    */
@@ -974,7 +974,7 @@ private:
   // operations using asignment.
 
   /**
-   * Read an array of <length> elements, each of <size> bytes and the
+   * Read an array of @a length elements, each of @a size bytes and the
    * start aligned at a multiple of <align>. The elements are assumed
    * to be packed with the right alignment restrictions.  It is mostly
    * designed for buffers of the basic types.
@@ -1070,7 +1070,7 @@ protected:
   ACE_CDR::Boolean write_1 (ACE_OutputCDR& output,
                             const ACE_CDR::Octet *x);
 
-  /// Efficiently read <length> elements of size <size> each from
+  /// Efficiently read @a length elements of size @a size each from
   /// <input> into <x>; the data must be aligned to <align>.
   ACE_CDR::Boolean read_array (ACE_InputCDR& input,
                                void* x,
@@ -1079,7 +1079,7 @@ protected:
                                ACE_CDR::ULong length);
 
   /**
-   * Efficiently write <length> elements of size <size> from <x> into
+   * Efficiently write @a length elements of size @a size from <x> into
    * <output>. Before inserting the elements enough padding is added
    * to ensure that the elements will be aligned to <align> in the
    * stream.
@@ -1094,7 +1094,7 @@ protected:
    * Exposes the stream implementation of <adjust>, this is useful in
    * many cases to minimize memory allocations during marshaling.
    * On success <buf> will contain a contiguous area in the CDR stream
-   * that can hold <size> bytes aligned to <align>.
+   * that can hold @a size bytes aligned to <align>.
    * Results
    */
   int adjust (ACE_OutputCDR& out,
@@ -1163,7 +1163,7 @@ protected:
   ACE_CDR::Boolean write_4 (ACE_OutputCDR& output,
                             const ACE_CDR::ULong *x);
 
-  /// Efficiently read <length> elements of size <size> each from
+  /// Efficiently read @a length elements of size @a size each from
   /// <input> into <x>; the data must be aligned to <align>.
   ACE_CDR::Boolean read_array (ACE_InputCDR& input,
                                void* x,
@@ -1172,7 +1172,7 @@ protected:
                                ACE_CDR::ULong length);
 
   /**
-   * Efficiently write <length> elements of size <size> from <x> into
+   * Efficiently write @a length elements of size @a size from <x> into
    * <output>. Before inserting the elements enough padding is added
    * to ensure that the elements will be aligned to <align> in the
    * stream.
@@ -1187,7 +1187,7 @@ protected:
    * Exposes the stream implementation of <adjust>, this is useful in
    * many cases to minimize memory allocations during marshaling.
    * On success <buf> will contain a contiguous area in the CDR stream
-   * that can hold <size> bytes aligned to <align>.
+   * that can hold @a size bytes aligned to <align>.
    * Results
    */
   int adjust (ACE_OutputCDR& out,
diff --git a/ACE/ace/Cache_Map_Manager_T.h b/ACE/ace/Cache_Map_Manager_T.h
index 28914fd5379..c75e602fb25 100644
--- a/ACE/ace/Cache_Map_Manager_T.h
+++ b/ACE/ace/Cache_Map_Manager_T.h
@@ -96,7 +96,7 @@ public:
   // = Initialization and termination methods.
 
   /// Initialize a <Cache_Map_Manager> with <caching_strategy> and
-  /// <size> entries.
+  /// @a size entries.
   ACE_Cache_Map_Manager (CACHING_STRATEGY &caching_strategy,
                          size_t size = ACE_DEFAULT_MAP_SIZE,
                          ACE_Allocator *alloc = 0);
@@ -105,7 +105,7 @@ public:
   /// resources.
   virtual ~ACE_Cache_Map_Manager (void);
 
-  /// Initialize a cache with size <length>.
+  /// Initialize a cache with size @a length.
   int open (size_t length = ACE_DEFAULT_MAP_SIZE,
             ACE_Allocator *alloc = 0);
 
@@ -113,7 +113,7 @@ public:
   int close (void);
 
   /**
-   * Associate <key> with <value>.  If <key> is already in the CMAP_TYPE
+   * Associate @a key with @a value.  If @a key is already in the CMAP_TYPE
    * then the ENTRY is not changed.  Returns 0 if a new entry is bound
    * successfully, returns 1 if an attempt is made to bind an existing
    * entry, and returns -1 if failures occur.
@@ -123,17 +123,17 @@ public:
 
   /**
    * Lookup entry<key,value> in the cache. If it is not found, returns -1.
-   * If the <key> is located in the CMAP_TYPE object, the CACHING_STRATEGY is
+   * If the @a key is located in the CMAP_TYPE object, the CACHING_STRATEGY is
    * notified of it via notify_find (int result, ATTRIBUTES &attribute).
    * If notify_find also returns 0 (success), then this function returns
-   * 0 (success) and sets the cached value in <value>.
+   * 0 (success) and sets the cached value in @a value.
    */
   int find (const KEY &key,
             VALUE &value);
 
   /**
    * Lookup entry<key,value> in the cache. If it is not found, returns -1.
-   * If the <key> is located in the CMAP_TYPE object, the CACHING_STRATEGY is
+   * If the @a key is located in the CMAP_TYPE object, the CACHING_STRATEGY is
    * notified of it via notify_find (int result, ATTRIBUTES &attribute).
    * If notify_find also returns 0 (success), then this function returns
    * 0 (success).
@@ -141,7 +141,7 @@ public:
   int find (const KEY &key);
 
   /**
-   * Reassociate the <key> with <value>. If the <key> already exists
+   * Reassociate the @a key with @a value. If the @a key already exists
    * in the cache then returns 1, on a new bind returns 0 and returns
    * -1 in case of any failures.
    */
@@ -149,23 +149,23 @@ public:
               const VALUE &value);
 
   /**
-   * Reassociate <key> with <value>, storing the old value into the
-   * "out" parameter <old_value>.  The function fails if <key> is not
+   * Reassociate @a key with @a value, storing the old value into the
+   * "out" parameter @a old_value.  The function fails if @a key is not
    * in the cache for caches that do not allow user specified keys.
    * However, for caches that allow user specified keys, if the key is
-   * not in the cache, a new <key>/<value> association is created.
+   * not in the cache, a new @a key / @a value association is created.
    */
   int rebind (const KEY &key,
               const VALUE &value,
               VALUE &old_value);
 
   /**
-   * Reassociate <key> with <value>, storing the old key and value
-   * into the "out" parameters <old_key> and <old_value>.  The
-   * function fails if <key> is not in the cache for caches that do
+   * Reassociate @a key with @a value, storing the old key and value
+   * into the "out" parameters @a old_key and @a old_value.  The
+   * function fails if @a key is not in the cache for caches that do
    * not allow user specified keys.  However, for caches that allow
    * user specified keys, if the key is not in the cache, a new
-   * <key>/<value> association is created.
+   * @a key / @a value association is created.
    */
   int rebind (const KEY &key,
               const VALUE &value,
@@ -173,21 +173,21 @@ public:
               VALUE &old_value);
 
   /**
-   * Associate <key> with <value> if and only if <key> is not in the
-   * cache.  If <key> is already in the cache, then the <value>
+   * Associate @a key with @a value if and only if @a key is not in the
+   * cache.  If @a key is already in the cache, then the @a value
    * parameter is overwritten with the existing value in the
-   * cache. Returns 0 if a new <key>/<value> association is created.
+   * cache. Returns 0 if a new @a key / @a value association is created.
    * Returns 1 if an attempt is made to bind an existing entry.  This
    * function fails for maps that do not allow user specified keys.
    */
   int trybind (const KEY &key,
                VALUE &value);
 
-  /// Remove <key> from the cache.
+  /// Remove @a key from the cache.
   int unbind (const KEY &key);
 
-  /// Remove <key> from the cache, and return the <value> associated with
-  /// <key>.
+  /// Remove @a key from the cache, and return the @a value associated with
+  /// @a key.
   int unbind (const KEY &key,
               VALUE &value);
 
diff --git a/ACE/ace/Configuration.h b/ACE/ace/Configuration.h
index d684b4d8129..f1dcd7fe183 100644
--- a/ACE/ace/Configuration.h
+++ b/ACE/ace/Configuration.h
@@ -349,7 +349,7 @@ public:
                             const ACE_TCHAR* name) = 0;
 
   /**
-   * Expands <path_in> to <key_out> from <key>.  If create is true,
+   * Expands <path_in> to <key_out> from @a key.  If create is true,
    * the subsections are created.  Returns 0 on success, non zero on
    * error The path consists of sections separated by the backslash
    * '\' or forward slash '/'.
@@ -848,7 +848,7 @@ public:
                          const ACE_TCHAR* name,
                          VALUETYPE& type);
 
-  /// Removes the the value <name> from <key>.  returns non zero on error
+  /// Removes the the value <name> from @a key.  returns non zero on error
   virtual int remove_value (const ACE_Configuration_Section_Key& key,
                             const ACE_TCHAR* name);
 
diff --git a/ACE/ace/Dev_Poll_Reactor.h b/ACE/ace/Dev_Poll_Reactor.h
index 933de62dd94..612525c7eec 100644
--- a/ACE/ace/Dev_Poll_Reactor.h
+++ b/ACE/ace/Dev_Poll_Reactor.h
@@ -333,7 +333,7 @@ public:
   /// Constructor.
   ACE_Dev_Poll_Reactor_Handler_Repository (void);
 
-  /// Initialize a repository of the appropriate <size>.
+  /// Initialize a repository of the appropriate @a size.
   int open (size_t size);
 
   /// Close down the repository.
diff --git a/ACE/ace/Future.h b/ACE/ace/Future.h
index 607ac6e8d75..8c4d15f133b 100644
--- a/ACE/ace/Future.h
+++ b/ACE/ace/Future.h
@@ -116,7 +116,7 @@ private:
   int set (const T &r,
            ACE_Future<T> &caller);
 
-  /// Wait up to <tv> time to get the <value>.  Note that <tv> must be
+  /// Wait up to @a tv time to get the @a value.  Note that @a tv must be
   /// specified in absolute time rather than relative time.
   int get (T &value,
            ACE_Time_Value *tv) const;
diff --git a/ACE/ace/Future_Set.h b/ACE/ace/Future_Set.h
index b51d1958c8b..316a2840a19 100644
--- a/ACE/ace/Future_Set.h
+++ b/ACE/ace/Future_Set.h
@@ -74,9 +74,9 @@ public:
   int insert (ACE_Future<T> &future);
 
   /**
-   * Wait up to <tv> time to get the <value>.  Note that <tv> must be
+   * Wait up to @a tv time to get the @a value.  Note that @a tv must be
    * specified in absolute time rather than relative time.); get the
-   * next ACE_Future that is readable.  If <tv> = 0, the will block
+   * next ACE_Future that is readable.  If @a tv = 0, the will block
    * forever.
    *
    * If a readable future becomes available, then the input
diff --git a/ACE/ace/Hash_Cache_Map_Manager_T.h b/ACE/ace/Hash_Cache_Map_Manager_T.h
index 023e9d17568..66cc3b83b53 100644
--- a/ACE/ace/Hash_Cache_Map_Manager_T.h
+++ b/ACE/ace/Hash_Cache_Map_Manager_T.h
@@ -78,7 +78,7 @@ class ACE_Hash_Cache_Map_Manager : public ACE_CACHE_MAP_MANAGER
   typedef VALUE mapped_type;
 
   // = Initialization and termination methods.
-  /// Initialize a <Hash_Cache_Map_Manager> with <size> entries.
+  /// Initialize a <Hash_Cache_Map_Manager> with @a size entries.
   ACE_Hash_Cache_Map_Manager (CACHING_STRATEGY &caching_s,
                               size_t size = ACE_DEFAULT_MAP_SIZE,
                               ACE_Allocator *alloc = 0);
@@ -88,7 +88,7 @@ class ACE_Hash_Cache_Map_Manager : public ACE_CACHE_MAP_MANAGER
   ~ACE_Hash_Cache_Map_Manager (void);
 
   /**
-   * Associate <key> with <value>.  If <key> is already in the
+   * Associate @a key with @a value.  If @a key is already in the
    * MAP then the ENTRY is not changed.  Returns 0 if a new entry is
    * bound successfully, returns 1 if an attempt is made to bind an
    * existing entry, and returns -1 if failures occur.
@@ -109,7 +109,7 @@ class ACE_Hash_Cache_Map_Manager : public ACE_CACHE_MAP_MANAGER
   int find (const KEY &key,
             VALUE &value);
 
-  /// Is <key> in the cache?
+  /// Is @a key in the cache?
   int find (const KEY &key);
 
   /// Obtain the entry when the find succeeds.
@@ -117,7 +117,7 @@ class ACE_Hash_Cache_Map_Manager : public ACE_CACHE_MAP_MANAGER
             CACHE_ENTRY *&entry);
 
   /**
-   * Reassociate the <key> with <value>. If the <key> already exists
+   * Reassociate the @a key with @a value. If the @a key already exists
    * in the cache then returns 1, on a new bind returns 0 and returns
    * -1 in case of any failures.
    */
@@ -125,22 +125,22 @@ class ACE_Hash_Cache_Map_Manager : public ACE_CACHE_MAP_MANAGER
               const VALUE &value);
 
   /**
-   * Reassociate <key> with <value>, storing the old value into the
-   * "out" parameter <old_value>.  The function fails if <key> is not
+   * Reassociate @a key with @a value, storing the old value into the
+   * "out" parameter @a old_value.  The function fails if @a key is not
    * in the cache for caches that do not allow user specified keys.
    * However, for caches that allow user specified keys, if the key is
-   * not in the cache, a new <key>/<value> association is created.
+   * not in the cache, a new @a key / @a value association is created.
    */
   int rebind (const KEY &key,
               const VALUE &value,
               VALUE &old_value);
 
   /**
-   * Reassociate <key> with <value>, storing the old key and value
-   * into the "out" parameters <old_key> and <old_value>.  The
-   * function fails if <key> is not in the cache for caches that do not
+   * Reassociate @a key with @a value, storing the old key and value
+   * into the "out" parameters @a old_key and @a old_value.  The
+   * function fails if @a key is not in the cache for caches that do not
    * allow user specified keys.  However, for caches that allow user
-   * specified keys, if the key is not in the cache, a new <key>/<value>
+   * specified keys, if the key is not in the cache, a new @a key / @a value
    * association is created.
    */
   int rebind (const KEY &key,
@@ -158,10 +158,10 @@ class ACE_Hash_Cache_Map_Manager : public ACE_CACHE_MAP_MANAGER
               CACHE_ENTRY *&entry);
 
   /**
-   * Associate <key> with <value> if and only if <key> is not in the
-   * cache.  If <key> is already in the cache, then the <value> parameter
+   * Associate @a key with @a value if and only if @a key is not in the
+   * cache.  If @a key is already in the cache, then the @a value parameter
    * is overwritten with the existing value in the cache. Returns 0 if a
-   * new <key>/<value> association is created.  Returns 1 if an
+   * new @a key / @a value association is created.  Returns 1 if an
    * attempt is made to bind an existing entry.  This function fails
    * for maps that do not allow user specified keys.
    */
@@ -177,11 +177,11 @@ class ACE_Hash_Cache_Map_Manager : public ACE_CACHE_MAP_MANAGER
                VALUE &value,
                CACHE_ENTRY *&entry);
 
-  /// Remove <key> from the cache.
+  /// Remove @a key from the cache.
   int unbind (const KEY &key);
 
-  /// Remove <key> from the cache, and return the <value> associated with
-  /// <key>.
+  /// Remove @a key from the cache, and return the @a value associated with
+  /// @a key.
   int unbind (const KEY &key,
               VALUE &value);
 
diff --git a/ACE/ace/High_Res_Timer.h b/ACE/ace/High_Res_Timer.h
index b6cf5f45aca..831236f1642 100644
--- a/ACE/ace/High_Res_Timer.h
+++ b/ACE/ace/High_Res_Timer.h
@@ -250,7 +250,7 @@ public:
   static ACE_Time_Value gettimeofday (const ACE_OS::ACE_HRTimer_Op =
                                         ACE_OS::ACE_HRTIMER_GETTIME);
 
-  /// Converts an <hrt> to <tv> using global_scale_factor_.
+  /// Converts an <hrt> to @a tv using global_scale_factor_.
   static void hrtime_to_tv (ACE_Time_Value &tv,
                             const ACE_hrtime_t hrt);
 
diff --git a/ACE/ace/INET_Addr.h b/ACE/ace/INET_Addr.h
index 9d66e4b5418..2e9453047ef 100644
--- a/ACE/ace/INET_Addr.h
+++ b/ACE/ace/INET_Addr.h
@@ -204,7 +204,7 @@ public:
    * If <ipaddr_format> is non-0 this produces "ip-number:port-number"
    * (e.g., "128.252.166.57:1234"), whereas if <ipaddr_format> is 0
    * this produces "ip-name:port-number" (e.g.,
-   * "tango.cs.wustl.edu:1234").  Returns -1 if the <size> of the
+   * "tango.cs.wustl.edu:1234").  Returns -1 if the @a size of the
    * <buffer> is too small, else 0.
    */
   virtual int addr_to_string (ACE_TCHAR buffer[],
diff --git a/ACE/ace/IO_SAP.h b/ACE/ace/IO_SAP.h
index d6f4f1bf044..5e2e00b6e5e 100644
--- a/ACE/ace/IO_SAP.h
+++ b/ACE/ace/IO_SAP.h
@@ -51,14 +51,14 @@ public:
   /**
    * Enable asynchronous I/O (ACE_SIGIO), urgent data (ACE_SIGURG),
    * non-blocking I/O (ACE_NONBLOCK), or close-on-exec (ACE_CLOEXEC),
-   * which is passed as the <value>.
+   * which is passed as the @a value.
    */
   int enable (int value) const;
 
   /**
    * Disable asynchronous I/O (ACE_SIGIO), urgent data (ACE_SIGURG),
    * non-blocking I/O (ACE_NONBLOCK), or close-on-exec (ACE_CLOEXEC),
-   * which is passed as the <value>.
+   * which is passed as the @a value.
    */
   int disable (int value) const;
 
diff --git a/ACE/ace/IPC_SAP.h b/ACE/ace/IPC_SAP.h
index 98aa2bbf450..1fd38007e43 100644
--- a/ACE/ace/IPC_SAP.h
+++ b/ACE/ace/IPC_SAP.h
@@ -41,14 +41,14 @@ public:
   /**
    * Enable asynchronous I/O (ACE_SIGIO), urgent data (ACE_SIGURG),
    * non-blocking I/O (ACE_NONBLOCK), or close-on-exec (ACE_CLOEXEC),
-   * which is passed as the <value>.
+   * which is passed as the @a value.
    */
   int enable (int value) const;
 
   /**
    * Disable asynchronous I/O (ACE_SIGIO), urgent data (ACE_SIGURG),
    * non-blocking I/O (ACE_NONBLOCK), or close-on-exec (ACE_CLOEXEC),
-   * which is passed as the <value>.
+   * which is passed as the @a value.
    */
   int disable (int value) const;
 
diff --git a/ACE/ace/MEM_SAP.h b/ACE/ace/MEM_SAP.h
index 69e8dc9cd5a..a6c8dcb718f 100644
--- a/ACE/ace/MEM_SAP.h
+++ b/ACE/ace/MEM_SAP.h
@@ -117,7 +117,7 @@ public:
                             int flags,
                             const ACE_Time_Value *timeout) = 0;
 
-  /// request a buffer of size <size>.  Return 0 if the <shm_malloc_> is
+  /// request a buffer of size @a size.  Return 0 if the <shm_malloc_> is
   /// not initialized.
   ACE_MEM_SAP_Node *acquire_buffer (const ssize_t size);
 
diff --git a/ACE/ace/Map_T.h b/ACE/ace/Map_T.h
index 3f4e14cf70d..6582644135b 100644
--- a/ACE/ace/Map_T.h
+++ b/ACE/ace/Map_T.h
@@ -283,7 +283,7 @@ public:
   /// Close down and release dynamically allocated resources.
   virtual ~ACE_Map (void);
 
-  /// Initialize a <Map> with size <length>.
+  /// Initialize a map with size @a length.
   virtual int open (size_t length = ACE_DEFAULT_MAP_SIZE,
                     ACE_Allocator *alloc = 0) = 0;
 
@@ -291,16 +291,16 @@ public:
   virtual int close (void) = 0;
 
   /**
-   * Add <key>/<value> pair to the map.  If <key> is already in the
+   * Add @a key / @a value pair to the map.  If @a key is already in the
    * map then no changes are made and 1 is returned.  Returns 0 on a
    * successful addition.  This function fails for maps that do not
-   * allow user specified keys. <key> is an "in" parameter.
+   * allow user specified keys. @a key is an "in" parameter.
    */
   virtual int bind (const KEY &key,
                     const VALUE &value) = 0;
 
   /**
-   * Add <key>/<value> pair to the map.  <key> is an "inout" parameter
+   * Add @a key / @a value pair to the map.  @a key is an "inout" parameter
    * and maybe modified/extended by the map to add additional
    * information.  To recover original key, call the <recover_key>
    * method.
@@ -309,9 +309,9 @@ public:
                                KEY &key) = 0;
 
   /**
-   * Produce a key and return it through <key> which is an "out"
+   * Produce a key and return it through @a key which is an "out"
    * parameter.  For maps that do not naturally produce keys, the map
-   * adapters will use the <KEY_GENERATOR> class to produce a key.
+   * adapters will use the @c KEY_GENERATOR class to produce a key.
    * However, the users are responsible for not jeopardizing this key
    * production scheme by using user specified keys with keys produced
    * by the key generator.
@@ -319,10 +319,10 @@ public:
   virtual int create_key (KEY &key) = 0;
 
   /**
-   * Add <value> to the map, and the corresponding key produced by the
-   * Map is returned through <key> which is an "out" parameter.  For
+   * Add @a value to the map, and the corresponding key produced by the
+   * Map is returned through @a key which is an "out" parameter.  For
    * maps that do not naturally produce keys, the map adapters will
-   * use the <KEY_GENERATOR> class to produce a key.  However, the
+   * use the @c KEY_GENERATOR class to produce a key.  However, the
    * users are responsible for not jeopardizing this key production
    * scheme by using user specified keys with keys produced by the key
    * generator.
@@ -331,10 +331,10 @@ public:
                                KEY &key) = 0;
 
   /**
-   * Add <value> to the map.  The user does not care about the
+   * Add @a value to the map.  The user does not care about the
    * corresponding key produced by the Map. For maps that do not
    * naturally produce keys, the map adapters will use the
-   * <KEY_GENERATOR> class to produce a key.  However, the users are
+   * @c KEY_GENERATOR class to produce a key.  However, the users are
    * responsible for not jeopardizing this key production scheme by
    * using user specified keys with keys produced by the key
    * generator.
@@ -347,31 +347,31 @@ public:
                            KEY &original_key) = 0;
 
   /**
-   * Reassociate <key> with <value>. The function fails if <key> is
+   * Reassociate @a key with @a value. The function fails if @a key is
    * not in the map for maps that do not allow user specified keys.
    * However, for maps that allow user specified keys, if the key is
-   * not in the map, a new <key>/<value> association is created.
+   * not in the map, a new @a key / @a value association is created.
    */
   virtual int rebind (const KEY &key,
                       const VALUE &value) = 0;
 
   /**
-   * Reassociate <key> with <value>, storing the old value into the
-   * "out" parameter <old_value>.  The function fails if <key> is not
+   * Reassociate @a key with @a value, storing the old value into the
+   * "out" parameter @a old_value.  The function fails if @a key is not
    * in the map for maps that do not allow user specified keys.
    * However, for maps that allow user specified keys, if the key is
-   * not in the map, a new <key>/<value> association is created.
+   * not in the map, a new @a key / @a value association is created.
    */
   virtual int rebind (const KEY &key,
                       const VALUE &value,
                       VALUE &old_value) = 0;
 
   /**
-   * Reassociate <key> with <value>, storing the old key and value
-   * into the "out" parameters <old_key> and <old_value>.  The
-   * function fails if <key> is not in the map for maps that do not
+   * Reassociate @a key with @a value, storing the old key and value
+   * into the "out" parameters @a old_key and @a old_value.  The
+   * function fails if @a key is not in the map for maps that do not
    * allow user specified keys.  However, for maps that allow user
-   * specified keys, if the key is not in the map, a new <key>/<value>
+   * specified keys, if the key is not in the map, a new @a key / @a value
    * association is created.
    */
   virtual int rebind (const KEY &key,
@@ -380,28 +380,28 @@ public:
                       VALUE &old_value) = 0;
 
   /**
-   * Associate <key> with <value> if and only if <key> is not in the
-   * map.  If <key> is already in the map, then the <value> parameter
+   * Associate @a key with @a value if and only if @a key is not in the
+   * map.  If @a key is already in the map, then the @a value parameter
    * is overwritten with the existing value in the map. Returns 0 if a
-   * new <key>/<value> association is created.  Returns 1 if an
+   * new @a key / @a value association is created.  Returns 1 if an
    * attempt is made to bind an existing entry.  This function fails
    * for maps that do not allow user specified keys.
    */
   virtual int trybind (const KEY &key,
                        VALUE &value) = 0;
 
-  /// Locate <value> associated with <key>.
+  /// Locate @a value associated with @a key.
   virtual int find (const KEY &key,
                     VALUE &value) = 0;
 
-  /// Is <key> in the map?
+  /// Is @a key in the map?
   virtual int find (const KEY &key) = 0;
 
-  /// Remove <key> from the map.
+  /// Remove @a key from the map.
   virtual int unbind (const KEY &key) = 0;
 
-  /// Remove <key> from the map, and return the <value> associated with
-  /// <key>.
+  /// Remove @a key from the map, and return the @a value associated with
+  /// @a key.
   virtual int unbind (const KEY &key,
                       VALUE &value) = 0;
 
@@ -561,7 +561,7 @@ public:
   /// Initialize with the <ACE_DEFAULT_MAP_SIZE>.
   ACE_Map_Impl (ACE_Allocator *alloc = 0);
 
-  /// Initialize with <size> entries.  The <size> parameter is ignored
+  /// Initialize with @a size entries.  The @a size parameter is ignored
   /// by maps for which an initialize size does not make sense.
   ACE_Map_Impl (size_t size,
                 ACE_Allocator *alloc = 0);
@@ -569,7 +569,7 @@ public:
   /// Close down and release dynamically allocated resources.
   virtual ~ACE_Map_Impl (void);
 
-  /// Initialize a <Map> with size <length>.
+  /// Initialize a <Map> with size @a length.
   virtual int open (size_t length = ACE_DEFAULT_MAP_SIZE,
                     ACE_Allocator *alloc = 0);
 
@@ -577,16 +577,16 @@ public:
   virtual int close (void);
 
   /**
-   * Add <key>/<value> pair to the map.  If <key> is already in the
+   * Add @a key / @a value pair to the map.  If @a key is already in the
    * map then no changes are made and 1 is returned.  Returns 0 on a
    * successful addition.  This function fails for maps that do not
-   * allow user specified keys. <key> is an "in" parameter.
+   * allow user specified keys. @a key is an "in" parameter.
    */
   virtual int bind (const KEY &key,
                     const VALUE &value);
 
   /**
-   * Add <key>/<value> pair to the map.  <key> is an "inout" parameter
+   * Add @a key / @a value pair to the map.  @a key is an "inout" parameter
    * and maybe modified/extended by the map to add additional
    * information.  To recover original key, call the <recover_key>
    * method.
@@ -595,9 +595,9 @@ public:
                                KEY &key);
 
   /**
-   * Produce a key and return it through <key> which is an "out"
+   * Produce a key and return it through @a key which is an "out"
    * parameter.  For maps that do not naturally produce keys, the map
-   * adapters will use the <KEY_GENERATOR> class to produce a key.
+   * adapters will use the @c KEY_GENERATOR class to produce a key.
    * However, the users are responsible for not jeopardizing this key
    * production scheme by using user specified keys with keys produced
    * by the key generator.
@@ -605,10 +605,10 @@ public:
   virtual int create_key (KEY &key);
 
   /**
-   * Add <value> to the map, and the corresponding key produced by the
-   * Map is returned through <key> which is an "out" parameter.  For
+   * Add @a value to the map, and the corresponding key produced by the
+   * Map is returned through @a key which is an "out" parameter.  For
    * maps that do not naturally produce keys, the map adapters will
-   * use the <KEY_GENERATOR> class to produce a key.  However, the
+   * use the @c KEY_GENERATOR class to produce a key.  However, the
    * users are responsible for not jeopardizing this key production
    * scheme by using user specified keys with keys produced by the key
    * generator.
@@ -617,10 +617,10 @@ public:
                                KEY &key);
 
   /**
-   * Add <value> to the map.  The user does not care about the
+   * Add @a value to the map.  The user does not care about the
    * corresponding key produced by the Map. For maps that do not
    * naturally produce keys, the map adapters will use the
-   * <KEY_GENERATOR> class to produce a key.  However, the users are
+   * @c KEY_GENERATOR class to produce a key.  However, the users are
    * responsible for not jeopardizing this key production scheme by
    * using user specified keys with keys produced by the key
    * generator.
@@ -633,31 +633,31 @@ public:
                            KEY &original_key);
 
   /**
-   * Reassociate <key> with <value>. The function fails if <key> is
+   * Reassociate @a key with @a value. The function fails if @a key is
    * not in the map for maps that do not allow user specified keys.
    * However, for maps that allow user specified keys, if the key is
-   * not in the map, a new <key>/<value> association is created.
+   * not in the map, a new @a key / @a value association is created.
    */
   virtual int rebind (const KEY &key,
                       const VALUE &value);
 
   /**
-   * Reassociate <key> with <value>, storing the old value into the
-   * "out" parameter <old_value>.  The function fails if <key> is not
+   * Reassociate @a key with @a value, storing the old value into the
+   * "out" parameter @a old_value.  The function fails if @a key is not
    * in the map for maps that do not allow user specified keys.
    * However, for maps that allow user specified keys, if the key is
-   * not in the map, a new <key>/<value> association is created.
+   * not in the map, a new @a key / @a value association is created.
    */
   virtual int rebind (const KEY &key,
                       const VALUE &value,
                       VALUE &old_value);
 
   /**
-   * Reassociate <key> with <value>, storing the old key and value
-   * into the "out" parameters <old_key> and <old_value>.  The
-   * function fails if <key> is not in the map for maps that do not
+   * Reassociate @a key with @a value, storing the old key and value
+   * into the "out" parameters @a old_key and @a old_value.  The
+   * function fails if @a key is not in the map for maps that do not
    * allow user specified keys.  However, for maps that allow user
-   * specified keys, if the key is not in the map, a new <key>/<value>
+   * specified keys, if the key is not in the map, a new @a key / @a value
    * association is created.
    */
   virtual int rebind (const KEY &key,
@@ -666,28 +666,28 @@ public:
                       VALUE &old_value);
 
   /**
-   * Associate <key> with <value> if and only if <key> is not in the
-   * map.  If <key> is already in the map, then the <value> parameter
+   * Associate @a key with @a value if and only if @a key is not in the
+   * map.  If @a key is already in the map, then the @a value parameter
    * is overwritten with the existing value in the map. Returns 0 if a
-   * new <key>/<value> association is created.  Returns 1 if an
+   * new @a key / @a value association is created.  Returns 1 if an
    * attempt is made to bind an existing entry.  This function fails
    * for maps that do not allow user specified keys.
    */
   virtual int trybind (const KEY &key,
                        VALUE &value);
 
-  /// Locate <value> associated with <key>.
+  /// Locate @a value associated with @a key.
   virtual int find (const KEY &key,
                     VALUE &value);
 
-  /// Is <key> in the map?
+  /// Is @a key in the map?
   virtual int find (const KEY &key);
 
-  /// Remove <key> from the map.
+  /// Remove @a key from the map.
   virtual int unbind (const KEY &key);
 
-  /// Remove <key> from the map, and return the <value> associated with
-  /// <key>.
+  /// Remove @a key from the map, and return the @a value associated with
+  /// @a key.
   virtual int unbind (const KEY &key,
                       VALUE &value);
 
@@ -738,7 +738,7 @@ class ACE_Active_Map_Manager_Iterator_Adapter : public ACE_Iterator_Impl<T>
 public:
 
   // = Traits.
-  typedef typename ACE_Active_Map_Manager<VALUE>::iterator
+  typedef typename ACE_Active_Map_Manager@a value::iterator
           implementation;
 
   /// Constructor.
@@ -784,7 +784,7 @@ class ACE_Active_Map_Manager_Reverse_Iterator_Adapter : public ACE_Reverse_Itera
 public:
 
   // = Traits.
-  typedef typename ACE_Active_Map_Manager<VALUE>::reverse_iterator
+  typedef typename ACE_Active_Map_Manager@a value::reverse_iterator
           implementation;
 
   /// Constructor.
@@ -843,7 +843,7 @@ public:
   /// Initialize with the <ACE_DEFAULT_MAP_SIZE>.
   ACE_Active_Map_Manager_Adapter (ACE_Allocator *alloc = 0);
 
-  /// Initialize with <size> entries.  The <size> parameter is ignored
+  /// Initialize with @a size entries.  The @a size parameter is ignored
   /// by maps for which an initialize size does not make sense.
   ACE_Active_Map_Manager_Adapter (size_t size,
                                   ACE_Allocator *alloc = 0);
@@ -851,7 +851,7 @@ public:
   /// Close down and release dynamically allocated resources.
   virtual ~ACE_Active_Map_Manager_Adapter (void);
 
-  /// Initialize a <Map> with size <length>.
+  /// Initialize a <Map> with size @a length.
   virtual int open (size_t length = ACE_DEFAULT_MAP_SIZE,
                     ACE_Allocator *alloc = 0);
 
@@ -859,16 +859,16 @@ public:
   virtual int close (void);
 
   /**
-   * Add <key>/<value> pair to the map.  If <key> is already in the
+   * Add @a key / @a value pair to the map.  If @a key is already in the
    * map then no changes are made and 1 is returned.  Returns 0 on a
    * successful addition.  This function fails for maps that do not
-   * allow user specified keys. <key> is an "in" parameter.
+   * allow user specified keys. @a key is an "in" parameter.
    */
   virtual int bind (const KEY &key,
                     const VALUE &value);
 
   /**
-   * Add <key>/<value> pair to the map.  <key> is an "inout" parameter
+   * Add @a key / @a value pair to the map.  @a key is an "inout" parameter
    * and maybe modified/extended by the map to add additional
    * information.  To recover original key, call the <recover_key>
    * method.
@@ -877,9 +877,9 @@ public:
                                KEY &key);
 
   /**
-   * Produce a key and return it through <key> which is an "out"
+   * Produce a key and return it through @a key which is an "out"
    * parameter.  For maps that do not naturally produce keys, the map
-   * adapters will use the <KEY_GENERATOR> class to produce a key.
+   * adapters will use the @c KEY_GENERATOR class to produce a key.
    * However, the users are responsible for not jeopardizing this key
    * production scheme by using user specified keys with keys produced
    * by the key generator.
@@ -887,10 +887,10 @@ public:
   virtual int create_key (KEY &key);
 
   /**
-   * Add <value> to the map, and the corresponding key produced by the
-   * Map is returned through <key> which is an "out" parameter.  For
+   * Add @a value to the map, and the corresponding key produced by the
+   * Map is returned through @a key which is an "out" parameter.  For
    * maps that do not naturally produce keys, the map adapters will
-   * use the <KEY_GENERATOR> class to produce a key.  However, the
+   * use the @c KEY_GENERATOR class to produce a key.  However, the
    * users are responsible for not jeopardizing this key production
    * scheme by using user specified keys with keys produced by the key
    * generator.
@@ -899,10 +899,10 @@ public:
                                KEY &key);
 
   /**
-   * Add <value> to the map.  The user does not care about the
+   * Add @a value to the map.  The user does not care about the
    * corresponding key produced by the Map. For maps that do not
    * naturally produce keys, the map adapters will use the
-   * <KEY_GENERATOR> class to produce a key.  However, the users are
+   * @c KEY_GENERATOR class to produce a key.  However, the users are
    * responsible for not jeopardizing this key production scheme by
    * using user specified keys with keys produced by the key
    * generator.
@@ -915,31 +915,31 @@ public:
                            KEY &original_key);
 
   /**
-   * Reassociate <key> with <value>. The function fails if <key> is
+   * Reassociate @a key with @a value. The function fails if @a key is
    * not in the map for maps that do not allow user specified keys.
    * However, for maps that allow user specified keys, if the key is
-   * not in the map, a new <key>/<value> association is created.
+   * not in the map, a new @a key / @a value association is created.
    */
   virtual int rebind (const KEY &key,
                       const VALUE &value);
 
   /**
-   * Reassociate <key> with <value>, storing the old value into the
-   * "out" parameter <old_value>.  The function fails if <key> is not
+   * Reassociate @a key with @a value, storing the old value into the
+   * "out" parameter @a old_value.  The function fails if @a key is not
    * in the map for maps that do not allow user specified keys.
    * However, for maps that allow user specified keys, if the key is
-   * not in the map, a new <key>/<value> association is created.
+   * not in the map, a new @a key / @a value association is created.
    */
   virtual int rebind (const KEY &key,
                       const VALUE &value,
                       VALUE &old_value);
 
   /**
-   * Reassociate <key> with <value>, storing the old key and value
-   * into the "out" parameters <old_key> and <old_value>.  The
-   * function fails if <key> is not in the map for maps that do not
+   * Reassociate @a key with @a value, storing the old key and value
+   * into the "out" parameters @a old_key and @a old_value.  The
+   * function fails if @a key is not in the map for maps that do not
    * allow user specified keys.  However, for maps that allow user
-   * specified keys, if the key is not in the map, a new <key>/<value>
+   * specified keys, if the key is not in the map, a new @a key / @a value
    * association is created.
    */
   virtual int rebind (const KEY &key,
@@ -948,28 +948,28 @@ public:
                       VALUE &old_value);
 
   /**
-   * Associate <key> with <value> if and only if <key> is not in the
-   * map.  If <key> is already in the map, then the <value> parameter
+   * Associate @a key with @a value if and only if @a key is not in the
+   * map.  If @a key is already in the map, then the @a value parameter
    * is overwritten with the existing value in the map. Returns 0 if a
-   * new <key>/<value> association is created.  Returns 1 if an
+   * new @a key / @a value association is created.  Returns 1 if an
    * attempt is made to bind an existing entry.  This function fails
    * for maps that do not allow user specified keys.
    */
   virtual int trybind (const KEY &key,
                        VALUE &value);
 
-  /// Locate <value> associated with <key>.
+  /// Locate @a value associated with @a key.
   virtual int find (const KEY &key,
                     VALUE &value);
 
-  /// Is <key> in the map?
+  /// Is @a key in the map?
   virtual int find (const KEY &key);
 
-  /// Remove <key> from the map.
+  /// Remove @a key from the map.
   virtual int unbind (const KEY &key);
 
-  /// Remove <key> from the map, and return the <value> associated with
-  /// <key>.
+  /// Remove @a key from the map, and return the @a value associated with
+  /// @a key.
   virtual int unbind (const KEY &key,
                       VALUE &value);
 
@@ -1137,7 +1137,7 @@ public:
   /// Initialize with the <ACE_DEFAULT_MAP_SIZE>.
   ACE_Hash_Map_Manager_Ex_Adapter (ACE_Allocator *alloc = 0);
 
-  /// Initialize with <size> entries.  The <size> parameter is ignored
+  /// Initialize with @a size entries.  The @a size parameter is ignored
   /// by maps for which an initialize size does not make sense.
   ACE_Hash_Map_Manager_Ex_Adapter (size_t size,
                                    ACE_Allocator *alloc = 0);
@@ -1145,7 +1145,7 @@ public:
   /// Close down and release dynamically allocated resources.
   virtual ~ACE_Hash_Map_Manager_Ex_Adapter (void);
 
-  /// Initialize a <Map> with size <length>.
+  /// Initialize a <Map> with size @a length.
   virtual int open (size_t length = ACE_DEFAULT_MAP_SIZE,
                     ACE_Allocator *alloc = 0);
 
@@ -1153,16 +1153,16 @@ public:
   virtual int close (void);
 
   /**
-   * Add <key>/<value> pair to the map.  If <key> is already in the
+   * Add @a key / @a value pair to the map.  If @a key is already in the
    * map then no changes are made and 1 is returned.  Returns 0 on a
    * successful addition.  This function fails for maps that do not
-   * allow user specified keys. <key> is an "in" parameter.
+   * allow user specified keys. @a key is an "in" parameter.
    */
   virtual int bind (const KEY &key,
                     const VALUE &value);
 
   /**
-   * Add <key>/<value> pair to the map.  <key> is an "inout" parameter
+   * Add @a key / @a value pair to the map.  @a key is an "inout" parameter
    * and maybe modified/extended by the map to add additional
    * information.  To recover original key, call the <recover_key>
    * method.
@@ -1171,9 +1171,9 @@ public:
                                KEY &key);
 
   /**
-   * Produce a key and return it through <key> which is an "out"
+   * Produce a key and return it through @a key which is an "out"
    * parameter.  For maps that do not naturally produce keys, the map
-   * adapters will use the <KEY_GENERATOR> class to produce a key.
+   * adapters will use the @c KEY_GENERATOR class to produce a key.
    * However, the users are responsible for not jeopardizing this key
    * production scheme by using user specified keys with keys produced
    * by the key generator.
@@ -1181,10 +1181,10 @@ public:
   virtual int create_key (KEY &key);
 
   /**
-   * Add <value> to the map, and the corresponding key produced by the
-   * Map is returned through <key> which is an "out" parameter.  For
+   * Add @a value to the map, and the corresponding key produced by the
+   * Map is returned through @a key which is an "out" parameter.  For
    * maps that do not naturally produce keys, the map adapters will
-   * use the <KEY_GENERATOR> class to produce a key.  However, the
+   * use the @c KEY_GENERATOR class to produce a key.  However, the
    * users are responsible for not jeopardizing this key production
    * scheme by using user specified keys with keys produced by the key
    * generator.
@@ -1193,10 +1193,10 @@ public:
                                KEY &key);
 
   /**
-   * Add <value> to the map.  The user does not care about the
+   * Add @a value to the map.  The user does not care about the
    * corresponding key produced by the Map. For maps that do not
    * naturally produce keys, the map adapters will use the
-   * <KEY_GENERATOR> class to produce a key.  However, the users are
+   * @c KEY_GENERATOR class to produce a key.  However, the users are
    * responsible for not jeopardizing this key production scheme by
    * using user specified keys with keys produced by the key
    * generator.
@@ -1209,31 +1209,31 @@ public:
                            KEY &original_key);
 
   /**
-   * Reassociate <key> with <value>. The function fails if <key> is
+   * Reassociate @a key with @a value. The function fails if @a key is
    * not in the map for maps that do not allow user specified keys.
    * However, for maps that allow user specified keys, if the key is
-   * not in the map, a new <key>/<value> association is created.
+   * not in the map, a new @a key / @a value association is created.
    */
   virtual int rebind (const KEY &key,
                       const VALUE &value);
 
   /**
-   * Reassociate <key> with <value>, storing the old value into the
-   * "out" parameter <old_value>.  The function fails if <key> is not
+   * Reassociate @a key with @a value, storing the old value into the
+   * "out" parameter @a old_value.  The function fails if @a key is not
    * in the map for maps that do not allow user specified keys.
    * However, for maps that allow user specified keys, if the key is
-   * not in the map, a new <key>/<value> association is created.
+   * not in the map, a new @a key / @a value association is created.
    */
   virtual int rebind (const KEY &key,
                       const VALUE &value,
                       VALUE &old_value);
 
   /**
-   * Reassociate <key> with <value>, storing the old key and value
-   * into the "out" parameters <old_key> and <old_value>.  The
-   * function fails if <key> is not in the map for maps that do not
+   * Reassociate @a key with @a value, storing the old key and value
+   * into the "out" parameters @a old_key and @a old_value.  The
+   * function fails if @a key is not in the map for maps that do not
    * allow user specified keys.  However, for maps that allow user
-   * specified keys, if the key is not in the map, a new <key>/<value>
+   * specified keys, if the key is not in the map, a new @a key / @a value
    * association is created.
    */
   virtual int rebind (const KEY &key,
@@ -1242,28 +1242,28 @@ public:
                       VALUE &old_value);
 
   /**
-   * Associate <key> with <value> if and only if <key> is not in the
-   * map.  If <key> is already in the map, then the <value> parameter
+   * Associate @a key with @a value if and only if @a key is not in the
+   * map.  If @a key is already in the map, then the @a value parameter
    * is overwritten with the existing value in the map. Returns 0 if a
-   * new <key>/<value> association is created.  Returns 1 if an
+   * new @a key / @a value association is created.  Returns 1 if an
    * attempt is made to bind an existing entry.  This function fails
    * for maps that do not allow user specified keys.
    */
   virtual int trybind (const KEY &key,
                        VALUE &value);
 
-  /// Locate <value> associated with <key>.
+  /// Locate @a value associated with @a key.
   virtual int find (const KEY &key,
                     VALUE &value);
 
-  /// Is <key> in the map?
+  /// Is @a key in the map?
   virtual int find (const KEY &key);
 
-  /// Remove <key> from the map.
+  /// Remove @a key from the map.
   virtual int unbind (const KEY &key);
 
-  /// Remove <key> from the map, and return the <value> associated with
-  /// <key>.
+  /// Remove @a key from the map, and return the @a value associated with
+  /// @a key.
   virtual int unbind (const KEY &key,
                       VALUE &value);
 
@@ -1423,7 +1423,7 @@ public:
   /// Initialize with the <ACE_DEFAULT_MAP_SIZE>.
   ACE_Map_Manager_Adapter (ACE_Allocator *alloc = 0);
 
-  /// Initialize with <size> entries.  The <size> parameter is ignored
+  /// Initialize with @a size entries.  The @a size parameter is ignored
   /// by maps for which an initialize size does not make sense.
   ACE_Map_Manager_Adapter (size_t size,
                            ACE_Allocator *alloc = 0);
@@ -1431,7 +1431,7 @@ public:
   /// Close down and release dynamically allocated resources.
   virtual ~ACE_Map_Manager_Adapter (void);
 
-  /// Initialize a <Map> with size <length>.
+  /// Initialize a <Map> with size @a length.
   virtual int open (size_t length = ACE_DEFAULT_MAP_SIZE,
                     ACE_Allocator *alloc = 0);
 
@@ -1439,16 +1439,16 @@ public:
   virtual int close (void);
 
   /**
-   * Add <key>/<value> pair to the map.  If <key> is already in the
+   * Add @a key / @a value pair to the map.  If @a key is already in the
    * map then no changes are made and 1 is returned.  Returns 0 on a
    * successful addition.  This function fails for maps that do not
-   * allow user specified keys. <key> is an "in" parameter.
+   * allow user specified keys. @a key is an "in" parameter.
    */
   virtual int bind (const KEY &key,
                     const VALUE &value);
 
   /**
-   * Add <key>/<value> pair to the map.  <key> is an "inout" parameter
+   * Add @a key / @a value pair to the map.  @a key is an "inout" parameter
    * and maybe modified/extended by the map to add additional
    * information.  To recover original key, call the <recover_key>
    * method.
@@ -1457,9 +1457,9 @@ public:
                                KEY &key);
 
   /**
-   * Produce a key and return it through <key> which is an "out"
+   * Produce a key and return it through @a key which is an "out"
    * parameter.  For maps that do not naturally produce keys, the map
-   * adapters will use the <KEY_GENERATOR> class to produce a key.
+   * adapters will use the @c KEY_GENERATOR class to produce a key.
    * However, the users are responsible for not jeopardizing this key
    * production scheme by using user specified keys with keys produced
    * by the key generator.
@@ -1467,10 +1467,10 @@ public:
   virtual int create_key (KEY &key);
 
   /**
-   * Add <value> to the map, and the corresponding key produced by the
-   * Map is returned through <key> which is an "out" parameter.  For
+   * Add @a value to the map, and the corresponding key produced by the
+   * Map is returned through @a key which is an "out" parameter.  For
    * maps that do not naturally produce keys, the map adapters will
-   * use the <KEY_GENERATOR> class to produce a key.  However, the
+   * use the @c KEY_GENERATOR class to produce a key.  However, the
    * users are responsible for not jeopardizing this key production
    * scheme by using user specified keys with keys produced by the key
    * generator.
@@ -1479,10 +1479,10 @@ public:
                                KEY &key);
 
   /**
-   * Add <value> to the map.  The user does not care about the
+   * Add @a value to the map.  The user does not care about the
    * corresponding key produced by the Map. For maps that do not
    * naturally produce keys, the map adapters will use the
-   * <KEY_GENERATOR> class to produce a key.  However, the users are
+   * @c KEY_GENERATOR class to produce a key.  However, the users are
    * responsible for not jeopardizing this key production scheme by
    * using user specified keys with keys produced by the key
    * generator.
@@ -1495,31 +1495,31 @@ public:
                            KEY &original_key);
 
   /**
-   * Reassociate <key> with <value>. The function fails if <key> is
+   * Reassociate @a key with @a value. The function fails if @a key is
    * not in the map for maps that do not allow user specified keys.
    * However, for maps that allow user specified keys, if the key is
-   * not in the map, a new <key>/<value> association is created.
+   * not in the map, a new @a key / @a value association is created.
    */
   virtual int rebind (const KEY &key,
                       const VALUE &value);
 
   /**
-   * Reassociate <key> with <value>, storing the old value into the
-   * "out" parameter <old_value>.  The function fails if <key> is not
+   * Reassociate @a key with @a value, storing the old value into the
+   * "out" parameter @a old_value.  The function fails if @a key is not
    * in the map for maps that do not allow user specified keys.
    * However, for maps that allow user specified keys, if the key is
-   * not in the map, a new <key>/<value> association is created.
+   * not in the map, a new @a key / @a value association is created.
    */
   virtual int rebind (const KEY &key,
                       const VALUE &value,
                       VALUE &old_value);
 
   /**
-   * Reassociate <key> with <value>, storing the old key and value
-   * into the "out" parameters <old_key> and <old_value>.  The
-   * function fails if <key> is not in the map for maps that do not
+   * Reassociate @a key with @a value, storing the old key and value
+   * into the "out" parameters @a old_key and @a old_value.  The
+   * function fails if @a key is not in the map for maps that do not
    * allow user specified keys.  However, for maps that allow user
-   * specified keys, if the key is not in the map, a new <key>/<value>
+   * specified keys, if the key is not in the map, a new @a key / @a value
    * association is created.
    */
   virtual int rebind (const KEY &key,
@@ -1528,28 +1528,28 @@ public:
                       VALUE &old_value);
 
   /**
-   * Associate <key> with <value> if and only if <key> is not in the
-   * map.  If <key> is already in the map, then the <value> parameter
+   * Associate @a key with @a value if and only if @a key is not in the
+   * map.  If @a key is already in the map, then the @a value parameter
    * is overwritten with the existing value in the map. Returns 0 if a
-   * new <key>/<value> association is created.  Returns 1 if an
+   * new @a key / @a value association is created.  Returns 1 if an
    * attempt is made to bind an existing entry.  This function fails
    * for maps that do not allow user specified keys.
    */
   virtual int trybind (const KEY &key,
                        VALUE &value);
 
-  /// Locate <value> associated with <key>.
+  /// Locate @a value associated with @a key.
   virtual int find (const KEY &key,
                     VALUE &value);
 
-  /// Is <key> in the map?
+  /// Is @a key in the map?
   virtual int find (const KEY &key);
 
-  /// Remove <key> from the map.
+  /// Remove @a key from the map.
   virtual int unbind (const KEY &key);
 
-  /// Remove <key> from the map, and return the <value> associated with
-  /// <key>.
+  /// Remove @a key from the map, and return the @a value associated with
+  /// @a key.
   virtual int unbind (const KEY &key,
                       VALUE &value);
 
diff --git a/ACE/ace/Message_Block.h b/ACE/ace/Message_Block.h
index 755e2f839cc..4b0a73846e5 100644
--- a/ACE/ace/Message_Block.h
+++ b/ACE/ace/Message_Block.h
@@ -206,7 +206,7 @@ public:
    * Create a Message Block that assumes it has ownership of @a data,
    * but in reality it doesnt (i.e., cannot delete it since it didn't
    * malloc it!).  Note that the @c size of the Message_Block will
-   * be @a size, but the <length>  will be 0 until <wr_ptr> is set.
+   * be @a size, but the @a length  will be 0 until <wr_ptr> is set.
    */
   int init (const char *data,
             size_t size = 0);
@@ -220,8 +220,8 @@ public:
    * this object ceases to exist  (and don't delete it during
    * destruction).  If @a locking_strategy is non-0 then this is used
    * to protect regions of code that access shared state (e.g.,
-   * reference counting) from race conditions.  Note that the <size>
-   * of the <Message_Block> will be @a size, but the <length> will be 0
+   * reference counting) from race conditions.  Note that the @a size
+   * of the <Message_Block> will be @a size, but the @a length will be 0
    * until  <wr_ptr> is set. The @a data_block_allocator is use to
    * allocate the data blocks while the @a allocator_strategy is used
    * to allocate the buffers contained by those.
diff --git a/ACE/ace/Msg_WFMO_Reactor.h b/ACE/ace/Msg_WFMO_Reactor.h
index dd969675b1b..d37ebfe93b3 100644
--- a/ACE/ace/Msg_WFMO_Reactor.h
+++ b/ACE/ace/Msg_WFMO_Reactor.h
@@ -48,8 +48,8 @@ public:
                         ACE_Timer_Queue * = 0);
 
   /**
-   * Initialize <ACE_Msg_WFMO_Reactor> with size <size>.  Two slots will be
-   * added to the <size> parameter which will store handles used for
+   * Initialize <ACE_Msg_WFMO_Reactor> with size @a size.  Two slots will be
+   * added to the @a size parameter which will store handles used for
    * internal management purposes.
    */
   ACE_Msg_WFMO_Reactor (size_t size,
diff --git a/ACE/ace/Multihomed_INET_Addr.h b/ACE/ace/Multihomed_INET_Addr.h
index f74beb3ff9d..f256e1401bb 100644
--- a/ACE/ace/Multihomed_INET_Addr.h
+++ b/ACE/ace/Multihomed_INET_Addr.h
@@ -52,7 +52,7 @@ public:
   /**
    * Constructs an <ACE_Multihomed_INET_Addr> from a <port_number>, a
    * <primary_host_name>, and an array of <secondary_host_names>.
-   * <size> is taken to be the length of the array.  If <encode> is
+   * @a size is taken to be the length of the array.  If <encode> is
    * non-zero, then <port_number> is converted into network byte
    * order; otherwise it is assumed to be in network byte order
    * already and is passed straight through.  <address_family> can be
@@ -114,7 +114,7 @@ public:
   /**
    * Initializes an <ACE_Multihomed_INET_Addr> from a <port_number>, a
    * <primary_host_name>, and an array of <secondary_host_names>.
-   * <size> is taken to be the length of the array.  If <encode> is
+   * @a size is taken to be the length of the array.  If <encode> is
    * non-zero, then <port_number> is converted into network byte
    * order; otherwise it is assumed to be in network byte order
    * already and is passed straight through.  <address_family> can be
@@ -163,14 +163,14 @@ public:
 
   /**
    * Initialize user-supplied array <secondary_addrs> with the current
-   * secondary addresses.  <size> is taken as the size of this array.
+   * secondary addresses.  @a size is taken as the size of this array.
    */
   int get_secondary_addresses(ACE_INET_Addr *secondary_addrs,
                               size_t size) const;
 
   /**
    * Initialize user-supplied array <addrs> with the the current
-   * primary and secondary addresses.  <size> is taken as the size of
+   * primary and secondary addresses.  @a size is taken as the size of
    * this array.
    */
   void get_addresses(sockaddr_in *addrs,
diff --git a/ACE/ace/Priority_Reactor.h b/ACE/ace/Priority_Reactor.h
index 6c84ade0e64..9ecfb9d4d26 100644
--- a/ACE/ace/Priority_Reactor.h
+++ b/ACE/ace/Priority_Reactor.h
@@ -43,7 +43,7 @@ public:
   ACE_Priority_Reactor (ACE_Sig_Handler * = 0,
                         ACE_Timer_Queue * = 0);
 
-  /// Initialize <ACE_Priority_Reactor> with size <size>.
+  /// Initialize <ACE_Priority_Reactor> with size @a size.
   ACE_Priority_Reactor (size_t size,
                         int restart = 0,
                         ACE_Sig_Handler * = 0,
diff --git a/ACE/ace/Reactor.h b/ACE/ace/Reactor.h
index ce07fc9d556..195a9437ae9 100644
--- a/ACE/ace/Reactor.h
+++ b/ACE/ace/Reactor.h
@@ -820,7 +820,7 @@ public:
 
   /**
    * Returns 0, if the size of the current message has been put in
-   * <size> returns -1, if not.  ACE_HANDLE allows the reactor to
+   * @a size returns -1, if not.  ACE_HANDLE allows the reactor to
    * check if the caller is valid.  Used for CLASSIX Reactor
    * implementation.
    */
diff --git a/ACE/ace/Reactor_Impl.h b/ACE/ace/Reactor_Impl.h
index 47800975214..68fa8b2c501 100644
--- a/ACE/ace/Reactor_Impl.h
+++ b/ACE/ace/Reactor_Impl.h
@@ -141,7 +141,7 @@ public:
 
   /**
    * Returns 0, if the size of the current message has been put in
-   * <size> Returns -1, if not.  ACE_HANDLE allows the reactor to
+   * @a size Returns -1, if not.  ACE_HANDLE allows the reactor to
    * check if the caller is valid.
    */
   virtual int current_info (ACE_HANDLE, size_t & /* size */) = 0;
diff --git a/ACE/ace/Recursive_Thread_Mutex.h b/ACE/ace/Recursive_Thread_Mutex.h
index c24e4425b64..5ce635cac12 100644
--- a/ACE/ace/Recursive_Thread_Mutex.h
+++ b/ACE/ace/Recursive_Thread_Mutex.h
@@ -72,8 +72,8 @@ public:
   int acquire (ACE_Time_Value &tv);
 
   /**
-   * If <tv> == 0 the call <acquire()> directly.  Otherwise, Block the
-   * thread until we acquire the mutex or until <tv> times out, in
+   * If @a tv == 0 the call <acquire()> directly.  Otherwise, Block the
+   * thread until we acquire the mutex or until @a tv times out, in
    * which case -1 is returned with <errno> == <ETIME>.  Note that
    * <*tv> is assumed to be in "absolute" rather than "relative" time.
    * The value of <*tv> is updated upon return to show the actual
diff --git a/ACE/ace/Registry.h b/ACE/ace/Registry.h
index a0c1e65a443..8385df282ee 100644
--- a/ACE/ace/Registry.h
+++ b/ACE/ace/Registry.h
@@ -193,7 +193,7 @@ public:
     /// Empty constructor: keys will be NULL
     Naming_Context (void);
 
-    /// Constructor: key_ will be set to <key>
+    /// Constructor: key_ will be set to @a key
     Naming_Context (const HKEY &key);
 
     /// Destructor will call <Naming_Context::close>.
diff --git a/ACE/ace/SOCK_SEQPACK_Association.h b/ACE/ace/SOCK_SEQPACK_Association.h
index f279d2899d6..481f71a260b 100644
--- a/ACE/ace/SOCK_SEQPACK_Association.h
+++ b/ACE/ace/SOCK_SEQPACK_Association.h
@@ -90,18 +90,18 @@ public:
 
   /**
    * Return local endpoint addresses in the referenced array of
-   * ACE_INET_Addr, which should have the specified <size>.  If the
-   * number of local endpoint addresses is less than <size>, then
-   * <size> will be set to this number.  If successful, the method
+   * ACE_INET_Addr, which should have the specified @a size.  If the
+   * number of local endpoint addresses is less than @a size, then
+   * @a size will be set to this number.  If successful, the method
    * returns 0, otherwise returns -1.
    */
   int get_local_addrs (ACE_INET_Addr *addrs, size_t &size) const;
 
   /**
    * Return remote endpoint addresses in the referenced array of
-   * ACE_INET_Addr, which should have the specified <size>.  If the
-   * number of remote endpoint addresses is less than <size>, then
-   * <size> will be set to this number.  If successful, the method
+   * ACE_INET_Addr, which should have the specified @a size.  If the
+   * number of remote endpoint addresses is less than @a size, then
+   * @a size will be set to this number.  If successful, the method
    * returns 0, otherwise returns -1.
    */
   int get_remote_addrs (ACE_INET_Addr *addrs, size_t &size) const;
diff --git a/ACE/ace/Semaphore.h b/ACE/ace/Semaphore.h
index 18924d21543..d0bcc2324a0 100644
--- a/ACE/ace/Semaphore.h
+++ b/ACE/ace/Semaphore.h
@@ -76,9 +76,9 @@ public:
   int acquire (ACE_Time_Value &tv);
 
   /**
-   * If <tv> == 0 then call <acquire()> directly.  Otherwise, Block
+   * If @a tv == 0 then call <acquire()> directly.  Otherwise, Block
    * the thread until the semaphore count becomes greater than 0
-   * (at which point it is decremented) or until <tv> times out (in
+   * (at which point it is decremented) or until @a tv times out (in
    * which case -1 is returned and <errno> == <ETIME>).  Note that
    * <*tv> is assumed to be in "absolute" rather than "relative" time.
    * The value of <*tv> is updated upon return to show the actual
diff --git a/ACE/ace/Shared_Memory_MM.h b/ACE/ace/Shared_Memory_MM.h
index ff0d066120d..25f173a2afe 100644
--- a/ACE/ace/Shared_Memory_MM.h
+++ b/ACE/ace/Shared_Memory_MM.h
@@ -86,7 +86,7 @@ public:
   virtual int remove (void);
 
   // = Allocation and deallocation methods.
-  /// Create a new chuck of memory containing <size> bytes.
+  /// Create a new chuck of memory containing @a size bytes.
   virtual void *malloc (size_t size = 0);
 
   /// Free a chuck of memory allocated by
diff --git a/ACE/ace/Shared_Memory_SV.h b/ACE/ace/Shared_Memory_SV.h
index 565d69c14cb..f9097f0b4eb 100644
--- a/ACE/ace/Shared_Memory_SV.h
+++ b/ACE/ace/Shared_Memory_SV.h
@@ -66,7 +66,7 @@ public:
   virtual int remove (void);
 
   // = Allocation and deallocation methods.
-  /// Create a new chuck of memory containing <size> bytes.
+  /// Create a new chuck of memory containing @a size bytes.
   virtual void *malloc (size_t = 0);
 
   /// Free a chuck of memory allocated by <ACE_Shared_Memory_SV::malloc>.
diff --git a/ACE/ace/Thread_Mutex.h b/ACE/ace/Thread_Mutex.h
index b923f905093..9e70cdd3d82 100644
--- a/ACE/ace/Thread_Mutex.h
+++ b/ACE/ace/Thread_Mutex.h
@@ -79,7 +79,7 @@ public:
 
   /**
    * If @a tv == 0 the call <acquire()> directly.  Otherwise, Block the
-   * thread until we acquire the mutex or until <tv> times out, in
+   * thread until we acquire the mutex or until @a tv times out, in
    * which case -1 is returned with <errno> == <ETIME>.  Note that
    * <*tv> is assumed to be in "absolute" rather than "relative" time.
    * The value of <*tv> is updated upon return to show the actual
diff --git a/ACE/ace/Timeprobe_T.h b/ACE/ace/Timeprobe_T.h
index 359f1456d39..a7f530b4889 100644
--- a/ACE/ace/Timeprobe_T.h
+++ b/ACE/ace/Timeprobe_T.h
@@ -177,7 +177,7 @@ private:
 //   // Initialize a ACE_Timeprobe with default size
 //   ACE_Timeprobe (ACE_Allocator *allocator = ACE_Allocator::instance());
 
-//   /// Create Timeprobes with <size> slots
+//   /// Create Timeprobes with @a size slots
 //   ACE_Timeprobe (ACE_Allocator *allocator = ACE_Allocator::instance(),
 //                  u_long size = ACE_DEFAULT_TIMEPROBE_TABLE_SIZE);
 // };
diff --git a/ACE/ace/Truncate.h b/ACE/ace/Truncate.h
index efae24177d6..6fc36f57145 100644
--- a/ACE/ace/Truncate.h
+++ b/ACE/ace/Truncate.h
@@ -592,6 +592,18 @@ namespace ACE_Utils
     }
   };
 
+  template<>
+  struct Truncator<const ACE_UINT64, signed long>
+  {
+    signed long operator() (const ACE_UINT64 val)
+    {
+      return
+        (val > static_cast<ACE_UINT64> (ACE_Numeric_Limits<signed long>::max ())
+         ? ACE_Numeric_Limits<signed long>::max ()
+         : static_cast<signed long> (val));
+    }
+  };
+
 #endif  /* ACE_SIZEOF_LONG < 8 */
 
 #if defined (ACE_SIZEOF_INT) && ACE_SIZEOF_INT < 8
diff --git a/ACE/ace/WFMO_Reactor.h b/ACE/ace/WFMO_Reactor.h
index e6d7c67e55e..a65b28cb691 100644
--- a/ACE/ace/WFMO_Reactor.h
+++ b/ACE/ace/WFMO_Reactor.h
@@ -300,7 +300,7 @@ public:
   /// Destructor.
   virtual ~ACE_WFMO_Reactor_Handler_Repository (void);
 
-  /// Initialize the repository of the approriate <size>.
+  /// Initialize the repository of the approriate @a size.
   int open (size_t size);
 
   /// Close down the handler repository.