Thu Sep 20 12:56:15 UTC 2007 Johnny Willemsen <jwillemsen@remedy.nl>

16 files changed, 517 insertions, 521 deletions

diff --git a/ACE/ChangeLog b/ACE/ChangeLog
index f8216086b53..59d911449e9 100644
--- a/ACE/ChangeLog
+++ b/ACE/ChangeLog
@@ -1,3 +1,24 @@
+Thu Sep 20 12:56:15 UTC 2007  Johnny Willemsen  <jwillemsen@remedy.nl>
+
+        * ace/Reactor.{cpp,inl}:
+          Made all non virtual single line methods inline methods to gain
+          performance and reduce footprint
+
+        * ace/Dev_Poll_Reactor.h:
+        * ace/File_Lock.h:
+        * ace/FlReactor/FlReactor.h:
+        * ace/FoxReactor/FoxReactor.h:
+        * ace/OS_NS_unistd.h:
+        * ace/Proactor.h:
+        * ace/QtReactor/QtReactor.h:
+        * ace/Reactor.h:
+        * ace/Reactor_Impl.h:
+        * ace/Select_Reactor_T.h:
+        * ace/TkReactor/TkReactor.h:
+        * ace/WFMO_Reactor.h:
+        * ace/XtReactor/XtReactor.h:
+          Fixed doxygen warnings
+
 Thu Sep 20 08:58:15 UTC 2007  Johnny Willemsen  <jwillemsen@remedy.nl>
 
         * ace/Dynamic_Message_Strategy.{h,cpp,inl}:
diff --git a/ACE/ace/Dev_Poll_Reactor.h b/ACE/ace/Dev_Poll_Reactor.h
index 8f67ddae1ad..b4cc00b7627 100644
--- a/ACE/ace/Dev_Poll_Reactor.h
+++ b/ACE/ace/Dev_Poll_Reactor.h
@@ -655,7 +655,7 @@ public:
                               ACE_Reactor_Mask mask);
 
   /**
-   * Removes <handle>.  If <mask> == <ACE_Event_Handler::DONT_CALL>
+   * Removes @a handle.  If @a mask == <ACE_Event_Handler::DONT_CALL>
    * then the <handle_close> method of the associated <event_handler>
    * is not invoked.
    */
@@ -663,7 +663,7 @@ public:
                               ACE_Reactor_Mask mask);
 
   /**
-   * Removes all handles in <handle_set>.  If <mask> ==
+   * Removes all handles in <handle_set>.  If @a mask ==
    * <ACE_Event_Handler::DONT_CALL> then the <handle_close> method of
    * the associated <event_handler>s is not invoked.
    */
@@ -777,28 +777,28 @@ public:
 
   // = High-level event handler scheduling operations
 
-  /// Add <masks_to_be_added> to the <event_handler>'s entry.
+  /// Add @a masks_to_be_added to the <event_handler>'s entry.
   /// <event_handler> must already have been registered.
   virtual int schedule_wakeup (ACE_Event_Handler *event_handler,
                                ACE_Reactor_Mask masks_to_be_added);
 
-  /// Add <masks_to_be_added> to the <handle>'s entry.  <event_handler>
-  /// associated with <handle> must already have been registered.
+  /// Add @a masks_to_be_added to the @a handle's entry.  <event_handler>
+  /// associated with @a handle must already have been registered.
   virtual int schedule_wakeup (ACE_HANDLE handle,
                                ACE_Reactor_Mask masks_to_be_added);
 
-  /// Clear <masks_to_be_cleared> from the <event_handler>'s entry.
+  /// Clear @a masks_to_be_cleared from the <event_handler>'s entry.
   virtual int cancel_wakeup (ACE_Event_Handler *event_handler,
                              ACE_Reactor_Mask masks_to_be_cleared);
 
-  /// Clear <masks_to_be_cleared> from the <handle>'s entry.
+  /// Clear @a masks_to_be_cleared from the @a handle's entry.
   virtual int cancel_wakeup (ACE_HANDLE handle,
                              ACE_Reactor_Mask masks_to_be_cleared);
 
   // = Notification methods.
 
   /**
-   * Notify <event_handler> of <mask> event.  The ACE_Time_Value
+   * Notify <event_handler> of @a mask event.  The ACE_Time_Value
    * indicates how long to blocking trying to notify.  If @a timeout ==
    * 0, the caller will block until action is possible, else will wait
    * until the relative time specified in @a timeout elapses).
@@ -836,14 +836,14 @@ public:
                                            ACE_Reactor_Mask    = ACE_Event_Handler::ALL_EVENTS_MASK);
 
   /**
-   * Return the Event_Handler associated with <handle>.  Return 0 if
-   * <handle> is not registered.
+   * Return the Event_Handler associated with @a handle.  Return 0 if
+   * @a handle is not registered.
    */
   virtual ACE_Event_Handler *find_handler (ACE_HANDLE handle);
 
   /**
-   * Check to see if <handle> is associated with a valid Event_Handler
-   * bound to <mask>.  Return the <event_handler> associated with this
+   * Check to see if @a handle is associated with a valid Event_Handler
+   * bound to @a mask.  Return the <event_handler> associated with this
    * <handler> if <event_handler> != 0.
    */
   virtual int handler (ACE_HANDLE handle,
diff --git a/ACE/ace/File_Lock.h b/ACE/ace/File_Lock.h
index 405b8c9f6e9..9a61f3bda63 100644
--- a/ACE/ace/File_Lock.h
+++ b/ACE/ace/File_Lock.h
@@ -36,10 +36,10 @@ class ACE_Export ACE_File_Lock
 {
 public:
   /**
-   * Set the <handle_> of the File_Lock to <handle>.  Note that this
-   * constructor assumes ownership of the <handle> and will close it
-   * down in <remove>.  If you want the <handle> to stay open when
-   * <remove> is called make sure to call <dup> on the <handle>.
+   * Set the <handle_> of the File_Lock to @a handle.  Note that this
+   * constructor assumes ownership of the @a handle and will close it
+   * down in <remove>.  If you want the @a handle to stay open when
+   * <remove> is called make sure to call <dup> on the @a handle.
    * If you don't want the file unlinked in the destructor pass a
    * zero value for <unlink_in_destructor>.
    */
diff --git a/ACE/ace/FlReactor/FlReactor.h b/ACE/ace/FlReactor/FlReactor.h
index e35572b99e1..64ad4c0f10e 100644
--- a/ACE/ace/FlReactor/FlReactor.h
+++ b/ACE/ace/FlReactor/FlReactor.h
@@ -78,7 +78,7 @@ protected:
                                   ACE_Event_Handler *handler,
                                   ACE_Reactor_Mask mask);
 
-  /// Remove the <handler> associated with this <handle>.
+  /// Remove the <handler> associated with this @a handle.
   virtual int remove_handler_i (ACE_HANDLE handle,
                                 ACE_Reactor_Mask mask);
 
diff --git a/ACE/ace/FoxReactor/FoxReactor.h b/ACE/ace/FoxReactor/FoxReactor.h
index cb74a0b329b..46f0d3ed427 100644
--- a/ACE/ace/FoxReactor/FoxReactor.h
+++ b/ACE/ace/FoxReactor/FoxReactor.h
@@ -82,7 +82,7 @@ protected:
                                   ACE_Event_Handler *handler,
                                   ACE_Reactor_Mask mask);
 
-  /// Remove the <handler> associated with this <handle>.
+  /// Remove the <handler> associated with this @a handle.
   virtual int remove_handler_i (ACE_HANDLE handle,
                                 ACE_Reactor_Mask mask);
 
diff --git a/ACE/ace/OS_NS_unistd.h b/ACE/ace/OS_NS_unistd.h
index 2965aaf31c2..aeb5b181964 100644
--- a/ACE/ace/OS_NS_unistd.h
+++ b/ACE/ace/OS_NS_unistd.h
@@ -347,7 +347,7 @@ namespace ACE_OS
                  ACE_OVERLAPPED *);
 
   /**
-   * Send @a len bytes from @a buf to <handle> (uses the <ACE_OS::write>
+   * Send @a len bytes from @a buf to @a handle (uses the <ACE_OS::write>
    * calls, which is uses the <write> system call on UNIX and the
    * <WriteFile> call on Win32).  If errors occur, -1 is returned.  If
    * EOF occurs, 0 is returned.  Whatever data has been transmitted
diff --git a/ACE/ace/Proactor.h b/ACE/ace/Proactor.h
index ddbeaec7ca5..5f7bde38dc4 100644
--- a/ACE/ace/Proactor.h
+++ b/ACE/ace/Proactor.h
@@ -298,7 +298,7 @@ public:
   int proactor_reset_event_loop (void);
 
 
-  /// This method adds the <handle> to the I/O completion port. This
+  /// This method adds the @a handle to the I/O completion port. This
   /// function is a no-op function for Unix systems and returns 0;
   int register_handle (ACE_HANDLE handle,
                        const void *completion_key);
diff --git a/ACE/ace/QtReactor/QtReactor.h b/ACE/ace/QtReactor/QtReactor.h
index 14e1b183688..3f480deff6e 100644
--- a/ACE/ace/QtReactor/QtReactor.h
+++ b/ACE/ace/QtReactor/QtReactor.h
@@ -154,7 +154,7 @@ protected:
         ACE_Reactor_Mask mask);
 
 
-    /// Remove the <handler> associated with this <handle>.
+    /// Remove the <handler> associated with this @a handle.
     virtual int remove_handler_i (ACE_HANDLE handle,
         ACE_Reactor_Mask mask);
 
diff --git a/ACE/ace/Reactor.cpp b/ACE/ace/Reactor.cpp
index 125d26909eb..30875b64d74 100644
--- a/ACE/ace/Reactor.cpp
+++ b/ACE/ace/Reactor.cpp
@@ -2,11 +2,9 @@
 
 #include "ace/Reactor.h"
 
-//#if !defined (ACE_HAS_WINCE)
-#  if !defined (ACE_LACKS_ACE_SVCCONF)
-#    include "ace/Service_Config.h"
-#  endif /* !ACE_LACKS_ACE_SVCCONF */
-//#endif /* ! ACE_HAS_WINCE */
+#if !defined (ACE_LACKS_ACE_SVCCONF)
+#  include "ace/Service_Config.h"
+#endif /* !ACE_LACKS_ACE_SVCCONF */
 
 /*
  * Hook to specialize the includes directly with the concrete
@@ -50,15 +48,13 @@
 #include "ace/Recursive_Thread_Mutex.h"
 
 #if !defined (__ACE_INLINE__)
-#include "ace/Reactor.inl"
+  #include "ace/Reactor.inl"
 #endif /* __ACE_INLINE__ */
 
-
 ACE_RCSID (ace,
            Reactor,
            "$Id$")
 
-
 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 
 ACE_ALLOC_HOOK_DEFINE(ACE_Reactor)
@@ -154,8 +150,7 @@ ACE_Reactor::instance (void)
 }
 
 ACE_Reactor *
-ACE_Reactor::instance (ACE_Reactor *r,
-                       int delete_reactor)
+ACE_Reactor::instance (ACE_Reactor *r, int delete_reactor)
 {
   ACE_TRACE ("ACE_Reactor::instance");
 
@@ -331,115 +326,6 @@ ACE_Reactor::run_alertable_reactor_event_loop (ACE_Time_Value &tv,
 }
 
 int
-ACE_Reactor::end_reactor_event_loop (void)
-{
-  ACE_TRACE ("ACE_Reactor::end_reactor_event_loop");
-
-  this->implementation_->deactivate (1);
-
-  return 0;
-}
-
-void
-ACE_Reactor::reset_reactor_event_loop (void)
-{
-  ACE_TRACE ("ACE_Reactor::reset_reactor_event_loop");
-
-  this->implementation_->deactivate (0);
-}
-
-int
-ACE_Reactor::resumable_handler (void)
-{
-  return this->implementation ()->resumable_handler ();
-}
-
-ACE_Reactor_Impl *
-ACE_Reactor::implementation (void) const
-{
-  return this->implementation_;
-}
-
-void
-ACE_Reactor::implementation (ACE_Reactor_Impl *impl)
-{
-  this->implementation_ = impl;
-}
-
-int
-ACE_Reactor::current_info (ACE_HANDLE handle,
-                           size_t &size)
-{
-  return this->implementation ()->current_info (handle, size);
-}
-
-int
-ACE_Reactor::open (size_t size,
-                   int restart,
-                   ACE_Sig_Handler *signal_handler,
-                   ACE_Timer_Queue *timer_queue)
-{
-  return this->implementation ()->open (size,
-                                        restart,
-                                        signal_handler,
-                                        timer_queue);
-}
-int
-ACE_Reactor::set_sig_handler (ACE_Sig_Handler *signal_handler)
-{
-  return this->implementation ()->set_sig_handler (signal_handler);
-}
-
-int
-ACE_Reactor::timer_queue (ACE_Timer_Queue *tq)
-{
-  return this->implementation ()->timer_queue (tq);
-}
-
-ACE_Timer_Queue *
-ACE_Reactor::timer_queue (void) const
-{
-  return this->implementation ()->timer_queue ();
-}
-
-int
-ACE_Reactor::close (void)
-{
-  return this->implementation ()->close ();
-}
-
-int
-ACE_Reactor::work_pending (const ACE_Time_Value &max_wait_time)
-{
-  return this->implementation ()->work_pending (max_wait_time);
-}
-
-int
-ACE_Reactor::handle_events (ACE_Time_Value *max_wait_time)
-{
-  return this->implementation ()->handle_events (max_wait_time);
-}
-
-int
-ACE_Reactor::alertable_handle_events (ACE_Time_Value *max_wait_time)
-{
-  return this->implementation ()->alertable_handle_events (max_wait_time);
-}
-
-int
-ACE_Reactor::handle_events (ACE_Time_Value &max_wait_time)
-{
-  return this->implementation ()->handle_events (max_wait_time);
-}
-
-int
-ACE_Reactor::alertable_handle_events (ACE_Time_Value &max_wait_time)
-{
-  return this->implementation ()->alertable_handle_events (max_wait_time);
-}
-
-
-int
 ACE_Reactor::register_handler (ACE_Event_Handler *event_handler,
                                ACE_Reactor_Mask mask)
 {
@@ -545,134 +431,6 @@ ACE_Reactor::register_handler (const ACE_Handle_Set &handles,
   return result;
 }
 
-int
-ACE_Reactor::register_handler (int signum,
-                               ACE_Event_Handler *new_sh,
-                               ACE_Sig_Action *new_disp,
-                               ACE_Event_Handler **old_sh,
-                               ACE_Sig_Action *old_disp)
-{
-  return this->implementation ()->register_handler (signum,
-                                                    new_sh,
-                                                    new_disp,
-                                                    old_sh,
-                                                    old_disp);
-}
-
-int
-ACE_Reactor::register_handler (const ACE_Sig_Set &sigset,
-                               ACE_Event_Handler *new_sh,
-                               ACE_Sig_Action *new_disp)
-{
-  return this->implementation ()->register_handler (sigset,
-                                                    new_sh,
-                                                    new_disp);
-}
-
-int
-ACE_Reactor::remove_handler (ACE_Event_Handler *event_handler,
-                             ACE_Reactor_Mask mask)
-{
-  return this->implementation ()->remove_handler (event_handler,
-                                                  mask);
-}
-
-int
-ACE_Reactor::remove_handler (ACE_HANDLE handle,
-                             ACE_Reactor_Mask mask)
-{
-  return this->implementation ()->remove_handler (handle,
-                                                  mask);
-}
-
-int
-ACE_Reactor::remove_handler (const ACE_Handle_Set &handle_set,
-                             ACE_Reactor_Mask mask)
-{
-  return this->implementation ()->remove_handler (handle_set,
-                                                  mask);
-}
-
-int
-ACE_Reactor::remove_handler (int signum,
-                             ACE_Sig_Action *new_disp,
-                             ACE_Sig_Action *old_disp,
-                             int sigkey)
-{
-  return this->implementation ()->remove_handler (signum,
-                                                  new_disp,
-                                                  old_disp,
-                                                  sigkey);
-}
-
-int
-ACE_Reactor::remove_handler (const ACE_Sig_Set &sigset)
-{
-  return this->implementation ()->remove_handler (sigset);
-}
-
-
-int
-ACE_Reactor::suspend_handler (ACE_Event_Handler *event_handler)
-{
-  return this->implementation ()->suspend_handler (event_handler);
-}
-
-int
-ACE_Reactor::suspend_handler (ACE_HANDLE handle)
-{
-  return this->implementation ()->suspend_handler (handle);
-}
-
-int
-ACE_Reactor::suspend_handler (const ACE_Handle_Set &handles)
-{
-  return this->implementation ()->suspend_handler (handles);
-}
-
-int
-ACE_Reactor::suspend_handlers (void)
-{
-  return this->implementation ()->suspend_handlers ();
-}
-
-int
-ACE_Reactor::resume_handler (ACE_Event_Handler *event_handler)
-{
-  return this->implementation ()->resume_handler (event_handler);
-}
-
-int
-ACE_Reactor::resume_handler (ACE_HANDLE handle)
-{
-  return this->implementation ()->resume_handler (handle);
-}
-
-int
-ACE_Reactor::resume_handler (const ACE_Handle_Set &handles)
-{
-  return this->implementation ()->resume_handler (handles);
-}
-
-int
-ACE_Reactor::resume_handlers (void)
-{
-  return this->implementation ()->resume_handlers ();
-}
-
-
-int
-ACE_Reactor::reset_timer_interval
-  (long timer_id,
-   const ACE_Time_Value &interval)
-{
-  ACE_TRACE ("ACE_Reactor::reset_timer_interval");
-
-  return this->implementation ()->reset_timer_interval
-    (timer_id,
-     interval);
-}
-
 long
 ACE_Reactor::schedule_timer (ACE_Event_Handler *event_handler,
                              const void *arg,
@@ -697,24 +455,6 @@ ACE_Reactor::schedule_timer (ACE_Event_Handler *event_handler,
 }
 
 int
-ACE_Reactor::cancel_timer (ACE_Event_Handler *event_handler,
-                           int dont_call_handle_close)
-{
-  return this->implementation ()->cancel_timer (event_handler,
-                                                dont_call_handle_close);
-}
-
-int
-ACE_Reactor::cancel_timer (long timer_id,
-                           const void **arg,
-                           int dont_call_handle_close)
-{
-  return this->implementation ()->cancel_timer (timer_id,
-                                                arg,
-                                                dont_call_handle_close);
-}
-
-int
 ACE_Reactor::schedule_wakeup (ACE_Event_Handler *event_handler,
                               ACE_Reactor_Mask masks_to_be_added)
 {
@@ -734,31 +474,6 @@ ACE_Reactor::schedule_wakeup (ACE_Event_Handler *event_handler,
 }
 
 int
-ACE_Reactor::schedule_wakeup (ACE_HANDLE handle,
-                              ACE_Reactor_Mask masks_to_be_added)
-{
-  return implementation ()->schedule_wakeup (handle,
-                                             masks_to_be_added);
-}
-
-int
-ACE_Reactor::cancel_wakeup (ACE_Event_Handler *event_handler,
-                            ACE_Reactor_Mask masks_to_be_cleared)
-{
-  return this->implementation ()->cancel_wakeup (event_handler,
-                                                 masks_to_be_cleared);
-}
-
-int
-ACE_Reactor::cancel_wakeup (ACE_HANDLE handle,
-                            ACE_Reactor_Mask masks_to_be_cleared)
-{
-  return this->implementation ()->cancel_wakeup (handle,
-                                                 masks_to_be_cleared);
-}
-
-
-int
 ACE_Reactor::notify (ACE_Event_Handler *event_handler,
                      ACE_Reactor_Mask mask,
                      ACE_Time_Value *tv)
@@ -767,172 +482,35 @@ ACE_Reactor::notify (ACE_Event_Handler *event_handler,
   // the event handler goes away before the notification is delivered.
   if (event_handler != 0 && event_handler->reactor () == 0)
     event_handler->reactor (this);
-  return this->implementation ()->notify (event_handler,
-                                          mask,
-                                          tv);
-}
-
-void
-ACE_Reactor::max_notify_iterations (int iterations)
-{
-  this->implementation ()->max_notify_iterations (iterations);
-}
-
-int
-ACE_Reactor::max_notify_iterations (void)
-{
-  return this->implementation ()->max_notify_iterations ();
+  return this->implementation ()->notify (event_handler, mask, tv);
 }
 
 int
-ACE_Reactor::purge_pending_notifications (ACE_Event_Handler *eh,
-                                          ACE_Reactor_Mask   mask)
-{
-  return this->implementation ()->purge_pending_notifications (eh, mask);
-}
-
-ACE_Event_Handler *
-ACE_Reactor::find_handler (ACE_HANDLE handle)
-{
-  return this->implementation ()->find_handler (handle);
-}
-
-int
-ACE_Reactor::handler (ACE_HANDLE handle,
-                      ACE_Reactor_Mask mask,
-                      ACE_Event_Handler **event_handler)
-{
-  return this->implementation ()->handler (handle,
-                                           mask,
-                                           event_handler);
-}
-
-int
-ACE_Reactor::handler (int signum,
-                      ACE_Event_Handler **event_handler)
-{
-  return this->implementation ()->handler (signum,
-                                           event_handler);
-}
-
-int
-ACE_Reactor::initialized (void)
-{
-  return this->implementation ()->initialized ();
-}
-
-ACE_Lock &
-ACE_Reactor::lock (void)
-{
-  return this->implementation ()->lock ();
-}
-
-void
-ACE_Reactor::wakeup_all_threads (void)
-{
-  this->implementation ()->wakeup_all_threads ();
-}
-
-int
-ACE_Reactor::owner (ACE_thread_t new_owner,
-                    ACE_thread_t *old_owner)
-{
-  return this->implementation ()->owner (new_owner,
-                                         old_owner);
-}
-
-int
-ACE_Reactor::owner (ACE_thread_t *owner)
-{
-  return this->implementation ()->owner (owner);
-}
-
-int
-ACE_Reactor::restart (void)
-{
-  return this->implementation ()->restart ();
-}
-
-int
-ACE_Reactor::restart (int r)
-{
-  return this->implementation ()->restart (r);
-}
-
-void
-ACE_Reactor::requeue_position (int position)
-{
-  this->implementation ()->requeue_position (position);
-}
-
-int
-ACE_Reactor::requeue_position (void)
-{
-  return this->implementation ()->requeue_position ();
-}
-
-
-int
-ACE_Reactor::mask_ops (ACE_Event_Handler *event_handler,
-                       ACE_Reactor_Mask mask,
-                       int ops)
-{
-  return this->implementation ()->mask_ops (event_handler,
-                                            mask,
-                                            ops);
-}
-
-int
-ACE_Reactor::mask_ops (ACE_HANDLE handle,
-                       ACE_Reactor_Mask mask,
-                       int ops)
-{
-  return this->implementation ()->mask_ops (handle, mask, ops);
-}
-
-int
-ACE_Reactor::ready_ops (ACE_Event_Handler *event_handler,
-                        ACE_Reactor_Mask mask,
-                        int ops)
+ACE_Reactor::reset_timer_interval
+  (long timer_id,
+   const ACE_Time_Value &interval)
 {
-  return this->implementation ()->ready_ops (event_handler, mask, ops);
-}
+  ACE_TRACE ("ACE_Reactor::reset_timer_interval");
 
-int
-ACE_Reactor::ready_ops (ACE_HANDLE handle,
-                        ACE_Reactor_Mask mask,
-                        int ops)
-{
-  return this->implementation ()->ready_ops (handle, mask, ops);
+  return this->implementation ()->reset_timer_interval (timer_id, interval);
 }
 
 int
-ACE_Reactor::reactor_event_loop_done (void)
-{
-  ACE_TRACE ("ACE_Reactor::reactor_event_loop_done");
-  return this->implementation_->deactivated ();
-}
-
-size_t
-ACE_Reactor::size (void) const
+ACE_Reactor::cancel_timer (ACE_Event_Handler *event_handler,
+                           int dont_call_handle_close)
 {
-  return this->implementation ()->size ();
+  return this->implementation ()->cancel_timer (event_handler,
+                                                dont_call_handle_close);
 }
 
 int
-ACE_Reactor::uses_event_associations (void)
-{
-  return this->implementation ()->uses_event_associations ();
-}
-
-void
-ACE_Reactor::dump (void) const
+ACE_Reactor::cancel_timer (long timer_id,
+                           const void **arg,
+                           int dont_call_handle_close)
 {
-#if defined (ACE_HAS_DUMP)
-  ACE_TRACE ("ACE_Reactor::dump");
-
-  implementation_->dump ();
-#endif /* ACE_HAS_DUMP */
+  return this->implementation ()->cancel_timer (timer_id,
+                                                arg,
+                                                dont_call_handle_close);
 }
 
 ACE_END_VERSIONED_NAMESPACE_DECL
diff --git a/ACE/ace/Reactor.h b/ACE/ace/Reactor.h
index 9b18ce64ad6..671516f88d2 100644
--- a/ACE/ace/Reactor.h
+++ b/ACE/ace/Reactor.h
@@ -413,7 +413,7 @@ public:
                         ACE_Sig_Action *sig_action = 0);
 
   /**
-   * Remove <masks> from <handle> registration.
+   * Remove <masks> from @a handle registration.
    *
    * For I/O handles, <masks> are removed from the Reactor.  Unless
    * <masks> includes <ACE_Event_Handler::DONT_CALL>,
@@ -421,7 +421,7 @@ public:
    * that have been removed.  If all masks have been removed,
    * ACE_Event_Handler::remove_reference() will be called.
    *
-   * For OS handles, the <handle> is removed from the Reactor.  Unless
+   * For OS handles, the @a handle is removed from the Reactor.  Unless
    * <masks> includes <ACE_Event_Handler::DONT_CALL>,
    * ACE_Event_Handler::handle_close() will be called with
    * <ACE_Event_Handler::NULL_MASK>.
@@ -434,7 +434,7 @@ public:
    * Remove <masks> from <event_handler> registration.
    *
    * Same as remove_handler(ACE_HANDLE,ACE_Reactor_Mask), except
-   * <handle> comes from ACE_Event_Handler::get_handle().
+   * @a handle comes from ACE_Event_Handler::get_handle().
    */
   int remove_handler (ACE_Event_Handler *event_handler,
                       ACE_Reactor_Mask masks);
@@ -616,7 +616,7 @@ public:
 
   // = High-level Event_Handler scheduling operations
 
-  /// Add <masks_to_be_added> to the <event_handler>'s entry.
+  /// Add @a masks_to_be_added to the <event_handler>'s entry.
   /// <event_handler> must already have been registered.
   /// Note that this call does not cause the Reactor to re-examine
   /// its set of handlers - the new masks will be noticed the next
@@ -638,7 +638,7 @@ public:
   int schedule_wakeup (ACE_HANDLE handle,
                        ACE_Reactor_Mask masks_to_be_added);
 
-  /// Clear <masks_to_be_cleared> from the <event_handler>'s entry.
+  /// Clear @a masks_to_be_cleared from the <event_handler>'s entry.
   /// Note that this call does not cause the Reactor to re-examine
   /// its set of handlers - the new masks will be noticed the next
   /// time the Reactor waits for activity. If there is no other
@@ -648,7 +648,7 @@ public:
   int cancel_wakeup (ACE_Event_Handler *event_handler,
                      ACE_Reactor_Mask masks_to_be_cleared);
 
-  /// Clear <masks_to_be_cleared> from the <handle>'s entry.
+  /// Clear @a masks_to_be_cleared from the <handle>'s entry.
   /// Note that this call does not cause the Reactor to re-examine
   /// its set of handlers - the new masks will be noticed the next
   /// time the Reactor waits for activity. If there is no other
@@ -806,12 +806,12 @@ public:
 
   // = Low-level ready_set mask manipulation methods.
   /// GET/SET/ADD/CLR the ready "bit" bound with the <event_handler>
-  /// and <mask>.
+  /// and @a mask.
   int ready_ops (ACE_Event_Handler *event_handler,
                  ACE_Reactor_Mask mask,
                  int ops);
 
-  /// GET/SET/ADD/CLR the ready "bit" bound with the <handle> and <mask>.
+  /// GET/SET/ADD/CLR the ready "bit" bound with the <handle> and @a mask.
   int ready_ops (ACE_HANDLE handle,
                  ACE_Reactor_Mask mask,
                  int ops);
diff --git a/ACE/ace/Reactor.inl b/ACE/ace/Reactor.inl
index 9b1344465ba..b381a1738c2 100644
--- a/ACE/ace/Reactor.inl
+++ b/ACE/ace/Reactor.inl
@@ -2,8 +2,7 @@
 //
 // $Id$
 
-// Run the event loop until the <ACE_Reactor::handle_events> method
-// returns -1 or the <end_event_loop> method is invoked.
+#include "ace/Reactor_Impl.h"
 
 /*
  * Hook to specialize the Reactor with the concrete implementation
@@ -13,6 +12,8 @@
 
 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 
+// Run the event loop until the <ACE_Reactor::handle_events> method
+// returns -1 or the <end_event_loop> method is invoked.
 ACE_INLINE int
 ACE_Reactor::run_event_loop (void)
 {
@@ -98,4 +99,400 @@ ACE_Reactor::event_loop_done (void)
   return ACE_Reactor::instance ()->reactor_event_loop_done ();
 }
 
+ACE_INLINE int
+ACE_Reactor::end_reactor_event_loop (void)
+{
+  ACE_TRACE ("ACE_Reactor::end_reactor_event_loop");
+
+  this->implementation_->deactivate (1);
+
+  return 0;
+}
+
+ACE_INLINE void
+ACE_Reactor::reset_reactor_event_loop (void)
+{
+  ACE_TRACE ("ACE_Reactor::reset_reactor_event_loop");
+
+  this->implementation_->deactivate (0);
+}
+
+ACE_INLINE int
+ACE_Reactor::resumable_handler (void)
+{
+  return this->implementation ()->resumable_handler ();
+}
+
+ACE_INLINE ACE_Reactor_Impl *
+ACE_Reactor::implementation (void) const
+{
+  return this->implementation_;
+}
+
+ACE_INLINE void
+ACE_Reactor::implementation (ACE_Reactor_Impl *impl)
+{
+  this->implementation_ = impl;
+}
+
+ACE_INLINE int
+ACE_Reactor::current_info (ACE_HANDLE handle, size_t &size)
+{
+  return this->implementation ()->current_info (handle, size);
+}
+
+ACE_INLINE int
+ACE_Reactor::open (size_t size,
+                   int restart,
+                   ACE_Sig_Handler *signal_handler,
+                   ACE_Timer_Queue *timer_queue)
+{
+  return this->implementation ()->open (size,
+                                        restart,
+                                        signal_handler,
+                                        timer_queue);
+}
+ACE_INLINE int
+ACE_Reactor::set_sig_handler (ACE_Sig_Handler *signal_handler)
+{
+  return this->implementation ()->set_sig_handler (signal_handler);
+}
+
+ACE_INLINE int
+ACE_Reactor::timer_queue (ACE_Timer_Queue *tq)
+{
+  return this->implementation ()->timer_queue (tq);
+}
+
+ACE_INLINE ACE_Timer_Queue *
+ACE_Reactor::timer_queue (void) const
+{
+  return this->implementation ()->timer_queue ();
+}
+
+ACE_INLINE int
+ACE_Reactor::close (void)
+{
+  return this->implementation ()->close ();
+}
+
+ACE_INLINE int
+ACE_Reactor::work_pending (const ACE_Time_Value &max_wait_time)
+{
+  return this->implementation ()->work_pending (max_wait_time);
+}
+
+ACE_INLINE int
+ACE_Reactor::handle_events (ACE_Time_Value *max_wait_time)
+{
+  return this->implementation ()->handle_events (max_wait_time);
+}
+
+ACE_INLINE int
+ACE_Reactor::alertable_handle_events (ACE_Time_Value *max_wait_time)
+{
+  return this->implementation ()->alertable_handle_events (max_wait_time);
+}
+
+ACE_INLINE int
+ACE_Reactor::handle_events (ACE_Time_Value &max_wait_time)
+{
+  return this->implementation ()->handle_events (max_wait_time);
+}
+
+ACE_INLINE int
+ACE_Reactor::alertable_handle_events (ACE_Time_Value &max_wait_time)
+{
+  return this->implementation ()->alertable_handle_events (max_wait_time);
+}
+
+ACE_INLINE int
+ACE_Reactor::register_handler (int signum,
+                               ACE_Event_Handler *new_sh,
+                               ACE_Sig_Action *new_disp,
+                               ACE_Event_Handler **old_sh,
+                               ACE_Sig_Action *old_disp)
+{
+  return this->implementation ()->register_handler (signum,
+                                                    new_sh,
+                                                    new_disp,
+                                                    old_sh,
+                                                    old_disp);
+}
+
+ACE_INLINE int
+ACE_Reactor::register_handler (const ACE_Sig_Set &sigset,
+                               ACE_Event_Handler *new_sh,
+                               ACE_Sig_Action *new_disp)
+{
+  return this->implementation ()->register_handler (sigset,
+                                                    new_sh,
+                                                    new_disp);
+}
+
+ACE_INLINE int
+ACE_Reactor::remove_handler (ACE_Event_Handler *event_handler,
+                             ACE_Reactor_Mask mask)
+{
+  return this->implementation ()->remove_handler (event_handler, mask);
+}
+
+ACE_INLINE int
+ACE_Reactor::remove_handler (ACE_HANDLE handle,
+                             ACE_Reactor_Mask mask)
+{
+  return this->implementation ()->remove_handler (handle, mask);
+}
+
+ACE_INLINE int
+ACE_Reactor::remove_handler (const ACE_Handle_Set &handle_set,
+                             ACE_Reactor_Mask mask)
+{
+  return this->implementation ()->remove_handler (handle_set, mask);
+}
+
+ACE_INLINE int
+ACE_Reactor::remove_handler (int signum,
+                             ACE_Sig_Action *new_disp,
+                             ACE_Sig_Action *old_disp,
+                             int sigkey)
+{
+  return this->implementation ()->remove_handler (signum,
+                                                  new_disp,
+                                                  old_disp,
+                                                  sigkey);
+}
+
+ACE_INLINE int
+ACE_Reactor::remove_handler (const ACE_Sig_Set &sigset)
+{
+  return this->implementation ()->remove_handler (sigset);
+}
+
+ACE_INLINE int
+ACE_Reactor::suspend_handler (ACE_Event_Handler *event_handler)
+{
+  return this->implementation ()->suspend_handler (event_handler);
+}
+
+ACE_INLINE int
+ACE_Reactor::suspend_handler (ACE_HANDLE handle)
+{
+  return this->implementation ()->suspend_handler (handle);
+}
+
+ACE_INLINE int
+ACE_Reactor::suspend_handler (const ACE_Handle_Set &handles)
+{
+  return this->implementation ()->suspend_handler (handles);
+}
+
+ACE_INLINE int
+ACE_Reactor::suspend_handlers (void)
+{
+  return this->implementation ()->suspend_handlers ();
+}
+
+ACE_INLINE int
+ACE_Reactor::resume_handler (ACE_Event_Handler *event_handler)
+{
+  return this->implementation ()->resume_handler (event_handler);
+}
+
+ACE_INLINE int
+ACE_Reactor::resume_handler (ACE_HANDLE handle)
+{
+  return this->implementation ()->resume_handler (handle);
+}
+
+ACE_INLINE int
+ACE_Reactor::resume_handler (const ACE_Handle_Set &handles)
+{
+  return this->implementation ()->resume_handler (handles);
+}
+
+ACE_INLINE int
+ACE_Reactor::resume_handlers (void)
+{
+  return this->implementation ()->resume_handlers ();
+}
+
+ACE_INLINE int
+ACE_Reactor::schedule_wakeup (ACE_HANDLE handle,
+                              ACE_Reactor_Mask masks_to_be_added)
+{
+  return implementation ()->schedule_wakeup (handle, masks_to_be_added);
+}
+
+ACE_INLINE int
+ACE_Reactor::cancel_wakeup (ACE_Event_Handler *event_handler,
+                            ACE_Reactor_Mask masks_to_be_cleared)
+{
+  return this->implementation ()->cancel_wakeup (event_handler,
+                                                 masks_to_be_cleared);
+}
+
+ACE_INLINE int
+ACE_Reactor::cancel_wakeup (ACE_HANDLE handle,
+                            ACE_Reactor_Mask masks_to_be_cleared)
+{
+  return this->implementation ()->cancel_wakeup (handle,
+                                                 masks_to_be_cleared);
+}
+
+ACE_INLINE void
+ACE_Reactor::max_notify_iterations (int iterations)
+{
+  this->implementation ()->max_notify_iterations (iterations);
+}
+
+ACE_INLINE int
+ACE_Reactor::max_notify_iterations (void)
+{
+  return this->implementation ()->max_notify_iterations ();
+}
+
+ACE_INLINE int
+ACE_Reactor::purge_pending_notifications (ACE_Event_Handler *eh,
+                                          ACE_Reactor_Mask   mask)
+{
+  return this->implementation ()->purge_pending_notifications (eh, mask);
+}
+
+ACE_INLINE ACE_Event_Handler *
+ACE_Reactor::find_handler (ACE_HANDLE handle)
+{
+  return this->implementation ()->find_handler (handle);
+}
+
+ACE_INLINE int
+ACE_Reactor::handler (ACE_HANDLE handle,
+                      ACE_Reactor_Mask mask,
+                      ACE_Event_Handler **event_handler)
+{
+  return this->implementation ()->handler (handle, mask, event_handler);
+}
+
+ACE_INLINE int
+ACE_Reactor::handler (int signum,
+                      ACE_Event_Handler **event_handler)
+{
+  return this->implementation ()->handler (signum, event_handler);
+}
+
+ACE_INLINE int
+ACE_Reactor::initialized (void)
+{
+  return this->implementation ()->initialized ();
+}
+
+ACE_INLINE ACE_Lock &
+ACE_Reactor::lock (void)
+{
+  return this->implementation ()->lock ();
+}
+
+ACE_INLINE void
+ACE_Reactor::wakeup_all_threads (void)
+{
+  this->implementation ()->wakeup_all_threads ();
+}
+
+ACE_INLINE int
+ACE_Reactor::owner (ACE_thread_t new_owner, ACE_thread_t *old_owner)
+{
+  return this->implementation ()->owner (new_owner,  old_owner);
+}
+
+ACE_INLINE int
+ACE_Reactor::owner (ACE_thread_t *owner)
+{
+  return this->implementation ()->owner (owner);
+}
+
+ACE_INLINE int
+ACE_Reactor::restart (void)
+{
+  return this->implementation ()->restart ();
+}
+
+ACE_INLINE int
+ACE_Reactor::restart (int r)
+{
+  return this->implementation ()->restart (r);
+}
+
+ACE_INLINE void
+ACE_Reactor::requeue_position (int position)
+{
+  this->implementation ()->requeue_position (position);
+}
+
+ACE_INLINE int
+ACE_Reactor::requeue_position (void)
+{
+  return this->implementation ()->requeue_position ();
+}
+
+ACE_INLINE int
+ACE_Reactor::mask_ops (ACE_Event_Handler *event_handler,
+                       ACE_Reactor_Mask mask,
+                       int ops)
+{
+  return this->implementation ()->mask_ops (event_handler, mask, ops);
+}
+
+ACE_INLINE int
+ACE_Reactor::mask_ops (ACE_HANDLE handle,
+                       ACE_Reactor_Mask mask,
+                       int ops)
+{
+  return this->implementation ()->mask_ops (handle, mask, ops);
+}
+
+ACE_INLINE int
+ACE_Reactor::ready_ops (ACE_Event_Handler *event_handler,
+                        ACE_Reactor_Mask mask,
+                        int ops)
+{
+  return this->implementation ()->ready_ops (event_handler, mask, ops);
+}
+
+ACE_INLINE int
+ACE_Reactor::ready_ops (ACE_HANDLE handle,
+                        ACE_Reactor_Mask mask,
+                        int ops)
+{
+  return this->implementation ()->ready_ops (handle, mask, ops);
+}
+
+ACE_INLINE int
+ACE_Reactor::reactor_event_loop_done (void)
+{
+  ACE_TRACE ("ACE_Reactor::reactor_event_loop_done");
+  return this->implementation_->deactivated ();
+}
+
+ACE_INLINE size_t
+ACE_Reactor::size (void) const
+{
+  return this->implementation ()->size ();
+}
+
+ACE_INLINE int
+ACE_Reactor::uses_event_associations (void)
+{
+  return this->implementation ()->uses_event_associations ();
+}
+
+ACE_INLINE void
+ACE_Reactor::dump (void) const
+{
+#if defined (ACE_HAS_DUMP)
+  ACE_TRACE ("ACE_Reactor::dump");
+
+  implementation_->dump ();
+#endif /* ACE_HAS_DUMP */
+}
+
 ACE_END_VERSIONED_NAMESPACE_DECL
diff --git a/ACE/ace/Reactor_Impl.h b/ACE/ace/Reactor_Impl.h
index f3c32ae7734..b60e26273ae 100644
--- a/ACE/ace/Reactor_Impl.h
+++ b/ACE/ace/Reactor_Impl.h
@@ -56,7 +56,7 @@ public:
   /**
    * Called by a thread when it wants to unblock the <Reactor_Impl>.
    * This wakeups the <Reactor_Impl> if currently blocked.  Pass over
-   * both the <Event_Handler> *and* the <mask> to allow the caller to
+   * both the <Event_Handler> *and* the @a mask to allow the caller to
    * dictate which <Event_Handler> method the <Reactor_Impl> will
    * invoke.  The ACE_Time_Value indicates how long to blocking
    * trying to notify the <Reactor_Impl>.  If @a timeout == 0, the
@@ -215,19 +215,19 @@ public:
 
   /**
    * Control whether the Reactor will handle any more incoming events or not.
-   * If <do_stop> == 1, the Reactor will be disabled.  By default, a reactor
+   * If @a do_stop == 1, the Reactor will be disabled.  By default, a reactor
    * is in active state and can be deactivated/reactived as wish.
    */
   virtual void deactivate (int do_stop) = 0;
 
   // = Register and remove Handlers.
 
-  /// Register <event_handler> with <mask>.  The I/O handle will always
+  /// Register @a event_handler with @a mask.  The I/O handle will always
   /// come from <get_handle> on the <event_handler>.
   virtual int register_handler (ACE_Event_Handler *event_handler,
                                 ACE_Reactor_Mask mask) = 0;
 
-  /// Register <event_handler> with <mask>.  The I/O handle is provided
+  /// Register <event_handler> with @a mask.  The I/O handle is provided
   /// through the <io_handle> parameter.
   virtual int register_handler (ACE_HANDLE io_handle,
                                 ACE_Event_Handler *event_handler,
@@ -255,7 +255,7 @@ public:
 
   /**
    * Register an <event_handler> that will be notified when
-   * <event_handle> is signaled.  <mask> specifies the network events
+   * <event_handle> is signaled.  @a mask specifies the network events
    * that the <event_handler> is interested in.
    */
   virtual int register_handler (ACE_HANDLE event_handle,
@@ -288,14 +288,14 @@ public:
   /**
    * Removes <event_handler>.  Note that the I/O handle will be
    * obtained using <get_handle> method of <event_handler> .  If
-   * <mask> == <ACE_Event_Handler::DONT_CALL> then the <handle_close>
+   * @a mask == <ACE_Event_Handler::DONT_CALL> then the <handle_close>
    * method of the <event_handler> is not invoked.
    */
   virtual int remove_handler (ACE_Event_Handler *event_handler,
                               ACE_Reactor_Mask mask) = 0;
 
   /**
-   * Removes <handle>.  If <mask> == <ACE_Event_Handler::DONT_CALL>
+   * Removes <handle>.  If @a mask == <ACE_Event_Handler::DONT_CALL>
    * then the <handle_close> method of the associated <event_handler>
    * is not invoked.
    */
@@ -303,7 +303,7 @@ public:
                               ACE_Reactor_Mask mask) = 0;
 
   /**
-   * Removes all handles in <handle_set>.  If <mask> ==
+   * Removes all handles in <handle_set>.  If @a mask ==
    * <ACE_Event_Handler::DONT_CALL> then the <handle_close> method of
    * the associated <event_handler>s is not invoked.
    */
@@ -417,28 +417,28 @@ public:
 
   // = High-level Event_Handler scheduling operations
 
-  /// Add <masks_to_be_added> to the <event_handler>'s entry.
+  /// Add @a masks_to_be_added to the <event_handler>'s entry.
   /// <event_handler> must already have been registered.
   virtual int schedule_wakeup (ACE_Event_Handler *event_handler,
                                ACE_Reactor_Mask masks_to_be_added) = 0;
 
-  /// Add <masks_to_be_added> to the <handle>'s entry.  <event_handler>
+  /// Add @a masks_to_be_added to the <handle>'s entry.  <event_handler>
   /// associated with <handle> must already have been registered.
   virtual int schedule_wakeup (ACE_HANDLE handle,
                                ACE_Reactor_Mask masks_to_be_added) = 0;
 
-  /// Clear <masks_to_be_cleared> from the <event_handler>'s entry.
+  /// Clear @a masks_to_be_cleared from the <event_handler>'s entry.
   virtual int cancel_wakeup (ACE_Event_Handler *event_handler,
                              ACE_Reactor_Mask masks_to_be_cleared) = 0;
 
-  /// Clear <masks_to_be_cleared> from the <handle>'s entry.
+  /// Clear @a masks_to_be_cleared from the <handle>'s entry.
   virtual int cancel_wakeup (ACE_HANDLE handle,
                              ACE_Reactor_Mask masks_to_be_cleared) = 0;
 
   // = Notification methods.
 
   /**
-   * Notify <event_handler> of <mask> event.  The ACE_Time_Value
+   * Notify <event_handler> of @a mask event.  The ACE_Time_Value
    * indicates how long to blocking trying to notify.  If @a timeout ==
    * 0, the caller will block until action is possible, else will wait
    * until the relative time specified in @a timeout elapses).
@@ -483,7 +483,7 @@ public:
 
   /**
    * Check to see if <handle> is associated with a valid Event_Handler
-   * bound to <mask>.  Return the <event_handler> associated with this
+   * bound to @a mask.  Return the <event_handler> associated with this
    * <handler> if <event_handler> != 0.
    */
   virtual int handler (ACE_HANDLE handle,
@@ -533,25 +533,25 @@ public:
   // = Low-level wait_set mask manipulation methods.
 
   /// GET/SET/ADD/CLR the dispatch mask "bit" bound with the
-  /// <event_handler> and <mask>.
+  /// <event_handler> and @a mask.
   virtual int mask_ops (ACE_Event_Handler *event_handler,
                         ACE_Reactor_Mask mask,
                         int ops) = 0;
 
   /// GET/SET/ADD/CLR the dispatch MASK "bit" bound with the <handle>
-  /// and <mask>.
+  /// and @a mask.
   virtual int mask_ops (ACE_HANDLE handle,
                         ACE_Reactor_Mask mask,
                         int ops) = 0;
 
   // = Low-level ready_set mask manipulation methods.
   /// GET/SET/ADD/CLR the ready "bit" bound with the <event_handler>
-  /// and <mask>.
+  /// and @a mask.
   virtual int ready_ops (ACE_Event_Handler *event_handler,
                          ACE_Reactor_Mask mask,
                          int ops) = 0;
 
-  /// GET/SET/ADD/CLR the ready "bit" bound with the <handle> and <mask>.
+  /// GET/SET/ADD/CLR the ready "bit" bound with the <handle> and @a mask.
   virtual int ready_ops (ACE_HANDLE handle,
                          ACE_Reactor_Mask,
                          int ops) = 0;
diff --git a/ACE/ace/Select_Reactor_T.h b/ACE/ace/Select_Reactor_T.h
index fdedc5e88a1..da0bc0071c0 100644
--- a/ACE/ace/Select_Reactor_T.h
+++ b/ACE/ace/Select_Reactor_T.h
@@ -261,7 +261,7 @@ public:
                                 ACE_Sig_Action *new_disp = 0);
 
   /**
-   * Removes the <mask> binding of <eh> from the Select_Reactor.  If
+   * Removes the @a mask binding of <eh> from the Select_Reactor.  If
    * there are no more bindings for this <eh> then it is removed from
    * the Select_Reactor.  Note that the Select_Reactor will call
    * <ACE_Event_Handler::get_handle> to extract the underlying I/O
@@ -271,7 +271,7 @@ public:
                               ACE_Reactor_Mask mask);
 
   /**
-   * Removes the <mask> bind of <Event_Handler> whose handle is
+   * Removes the @a mask bind of <Event_Handler> whose handle is
    * <handle> from the Select_Reactor.  If there are no more bindings
    * for this <eh> then it is removed from the Select_Reactor.
    */
@@ -279,7 +279,7 @@ public:
                               ACE_Reactor_Mask);
 
   /**
-   * Removes all the <mask> bindings for handles in the <handle_set>
+   * Removes all the @a mask bindings for handles in the <handle_set>
    * bind of <Event_Handler>.  If there are no more bindings for any
    * of these handlers then they are removed from the Select_Reactor.
    */
@@ -396,19 +396,19 @@ public:
 
   // = High-level Event_Handler scheduling operations
 
-  /// ADD the dispatch MASK "bit" bound with the <eh> and the <mask>.
+  /// ADD the dispatch MASK "bit" bound with the <eh> and the @a mask.
   virtual int schedule_wakeup (ACE_Event_Handler *eh,
                                ACE_Reactor_Mask mask);
 
-  /// ADD the dispatch MASK "bit" bound with the <handle> and the <mask>.
+  /// ADD the dispatch MASK "bit" bound with the <handle> and the @a mask.
   virtual int schedule_wakeup (ACE_HANDLE handle,
                                ACE_Reactor_Mask mask);
 
-  /// CLR the dispatch MASK "bit" bound with the <eh> and the <mask>.
+  /// CLR the dispatch MASK "bit" bound with the <eh> and the @a mask.
   virtual int cancel_wakeup (ACE_Event_Handler *eh,
                              ACE_Reactor_Mask mask);
 
-  /// CLR the dispatch MASK "bit" bound with the <handle> and the <mask>.
+  /// CLR the dispatch MASK "bit" bound with the <handle> and the @a mask.
   virtual int cancel_wakeup (ACE_HANDLE handle,
                              ACE_Reactor_Mask mask);
 
@@ -417,7 +417,7 @@ public:
    * Called by a thread when it wants to unblock the Select_Reactor.
    * This wakeups the <ACE_Select_Reactor> if currently blocked in
    * <select>/<poll>.  Pass over both the <Event_Handler> *and* the
-   * <mask> to allow the caller to dictate which <Event_Handler>
+   * @a mask to allow the caller to dictate which <Event_Handler>
    * method the <Select_Reactor> will invoke.  The ACE_Time_Value
    * indicates how long to blocking trying to notify the
    * <Select_Reactor>.  If @a timeout == 0, the caller will block until
@@ -464,24 +464,24 @@ public:
 
   // = Low-level wait_set mask manipulation methods.
   /// GET/SET/ADD/CLR the dispatch mask "bit" bound with the <eh> and
-  /// <mask>.
+  /// @a mask.
   virtual int mask_ops (ACE_Event_Handler *eh,
                         ACE_Reactor_Mask mask,
                         int ops);
 
   /// GET/SET/ADD/CLR the dispatch MASK "bit" bound with the <handle>
-  /// and <mask>.
+  /// and @a mask.
   virtual int mask_ops (ACE_HANDLE handle,
                         ACE_Reactor_Mask mask,
                         int ops);
 
   // = Low-level ready_set mask manipulation methods.
-  /// GET/SET/ADD/CLR the ready "bit" bound with the <eh> and <mask>.
+  /// GET/SET/ADD/CLR the ready "bit" bound with the <eh> and @a mask.
   virtual int ready_ops (ACE_Event_Handler *eh,
                          ACE_Reactor_Mask mask,
                          int ops);
 
-  /// GET/SET/ADD/CLR the ready "bit" bound with the <handle> and <mask>.
+  /// GET/SET/ADD/CLR the ready "bit" bound with the <handle> and @a mask.
   virtual int ready_ops (ACE_HANDLE handle,
                          ACE_Reactor_Mask,
                          int ops);
@@ -507,7 +507,7 @@ public:
 
   /**
    * Check to see if <handle> is associated with a valid Event_Handler
-   * bound to <mask>.  Return the <eh> associated with this <handler>
+   * bound to @a mask.  Return the <eh> associated with this <handler>
    * if <eh> != 0.
    */
   virtual int handler (ACE_HANDLE handle,
@@ -551,7 +551,7 @@ protected:
   // lock is held by the public methods that call down to them.
 
   /// Do the work of actually binding the <handle> and <eh> with the
-  /// <mask>.
+  /// @a mask.
   virtual int register_handler_i (ACE_HANDLE handle,
                                   ACE_Event_Handler *eh,
                                   ACE_Reactor_Mask mask);
@@ -562,7 +562,7 @@ protected:
                                   ACE_Reactor_Mask mask);
 
   /// Do the work of actually unbinding the <handle> and <eh> with the
-  /// <mask>.
+  /// @a mask.
   virtual int remove_handler_i (ACE_HANDLE handle,
                                 ACE_Reactor_Mask);
 
@@ -655,7 +655,7 @@ protected:
    * Factors the dispatching of an io handle set (each WRITE, EXCEPT
    * or READ set of handles).  It updates the
    * <number_of_handlers_dispatched> and invokes this->notify_handle
-   * for all the handles in <dispatch_set> using the <mask>,
+   * for all the handles in <dispatch_set> using the @a mask,
    * <ready_set> and <callback> parameters.  Must return -1 if
    * this->state_changed otherwise it must return 0.
    */
diff --git a/ACE/ace/TkReactor/TkReactor.h b/ACE/ace/TkReactor/TkReactor.h
index 80583bb8999..fba5ea15389 100644
--- a/ACE/ace/TkReactor/TkReactor.h
+++ b/ACE/ace/TkReactor/TkReactor.h
@@ -93,7 +93,7 @@ protected:
                                   ACE_Event_Handler *handler,
                                   ACE_Reactor_Mask mask);
 
-  /// Remove the <handler> associated with this <handle>.
+  /// Remove the <handler> associated with this @a handle.
   virtual int remove_handler_i (ACE_HANDLE handle,
                                 ACE_Reactor_Mask mask);
 
diff --git a/ACE/ace/WFMO_Reactor.h b/ACE/ace/WFMO_Reactor.h
index 5856af11c2f..dca4bb0cf19 100644
--- a/ACE/ace/WFMO_Reactor.h
+++ b/ACE/ace/WFMO_Reactor.h
@@ -323,7 +323,7 @@ public:
               ACE_HANDLE event_handle,
               int delete_event);
 
-  /// Remove the binding of ACE_HANDLE in accordance with the <mask>.
+  /// Remove the binding of ACE_HANDLE in accordance with the @a mask.
   int unbind (ACE_HANDLE,
               ACE_Reactor_Mask mask);
 
@@ -419,7 +419,7 @@ public:
 
   /**
    * Check to see if <handle> is associated with a valid Event_Handler
-   * bound to <mask>.  Return the <event_handler> associated with this
+   * bound to @a mask.  Return the <event_handler> associated with this
    * <handler> if <event_handler> != 0.
    */
   int handler (ACE_HANDLE handle,
@@ -510,7 +510,7 @@ public:
 
   /**
    * Special trick to unblock <WaitForMultipleObjects> when updates
-   * occur.  All we do is enqueue <event_handler> and <mask> onto the
+   * occur.  All we do is enqueue <event_handler> and @a mask onto the
    * ACE_Message_Queue and wakeup the <WFMO_Reactor> by signaling
    * its <ACE_Event> handle.  The ACE_Time_Value indicates how long
    * to blocking trying to notify the <WFMO_Reactor>.  If @a timeout ==
@@ -793,7 +793,7 @@ public:
                                 ACE_HANDLE event_handle = ACE_INVALID_HANDLE);
 
   /**
-   * Register an ACE_Event_Handler <event_handle>.  <mask> specifies
+   * Register an ACE_Event_Handler <event_handle>.  @a mask specifies
    * the network events that the <event_handler> is interested in.  If
    * <io_handle> == <ACE_INVALID_HANDLE> the <ACE_WFMO_Reactor> will
    * call the <get_handle> method of <event_handler> to extract the
@@ -852,7 +852,7 @@ public:
   /**
    * Removes <event_handler> from the <ACE_WFMO_Reactor>.  Note that
    * the <ACE_WFMO_Reactor> will call the <get_handle> method of
-   * <event_handler> to extract the underlying handle.  If <mask> ==
+   * <event_handler> to extract the underlying handle.  If @a mask ==
    * <ACE_Event_Handler::DONT_CALL> then the <handle_close> method of
    * the <event_handler> is not invoked. Note that the <handle> can
    * either be the <event_handle> or the <io_handle>
@@ -861,12 +861,12 @@ public:
                               ACE_Reactor_Mask mask);
 
   /**
-   * Removes <handle> from the <ACE_WFMO_Reactor>.  If <mask> ==
+   * Removes <handle> from the <ACE_WFMO_Reactor>.  If @a mask ==
    * <ACE_Event_Handler::DONT_CALL> then the <handle_close> method of
    * the <event_handler> is not invoked. Note that the <handle> can
    * either be the <event_handle> or the <io_handle>
    *
-   * For the case of I/O entries, this removes the <mask> binding of
+   * For the case of I/O entries, this removes the @a mask binding of
    * <Event_Handler> whose handle is <handle> from <WFMO_Reactor>.  If
    * there are no more bindings for this <event_handler> then it is
    * removed from the WFMO_Reactor.  For simple event entries, mask is
@@ -877,7 +877,7 @@ public:
                               ACE_Reactor_Mask mask);
 
   /**
-   * Removes all the <mask> bindings for handles in the <handle_set>
+   * Removes all the @a mask bindings for handles in the <handle_set>
    * bind of <Event_Handler>.  If there are no more bindings for any
    * of these handles then they are removed from WFMO_Reactor.
    */
@@ -996,7 +996,7 @@ public:
   // = High-level Event_Handler scheduling operations
 
   /**
-   * Add <masks_to_be_added> to the <event_handler>'s entry in
+   * Add @a masks_to_be_added to the <event_handler>'s entry in
    * WFMO_Reactor.  <event_handler> must already have been registered
    * with WFMO_Reactor.
    */
@@ -1004,7 +1004,7 @@ public:
                                ACE_Reactor_Mask masks_to_be_added);
 
   /**
-   * Add <masks_to_be_added> to the <handle>'s entry in WFMO_Reactor.
+   * Add @a masks_to_be_added to the <handle>'s entry in WFMO_Reactor.
    * The Event_Handler associated with <handle> must already have been
    * registered with WFMO_Reactor.
    */
@@ -1081,7 +1081,7 @@ public:
 
   /**
    * Check to see if <handle> is associated with a valid Event_Handler
-   * bound to <mask>.  Return the <event_handler> associated with this
+   * bound to @a mask.  Return the <event_handler> associated with this
    * <handler> if <event_handler> != 0.
    */
   virtual int handler (ACE_HANDLE handle,
diff --git a/ACE/ace/XtReactor/XtReactor.h b/ACE/ace/XtReactor/XtReactor.h
index 22fb39ceeed..43e8b166ba7 100644
--- a/ACE/ace/XtReactor/XtReactor.h
+++ b/ACE/ace/XtReactor/XtReactor.h
@@ -93,7 +93,7 @@ protected:
                                   ACE_Event_Handler *handler,
                                   ACE_Reactor_Mask mask);
 
-  /// Remove the <handler> associated with this <handle>.
+  /// Remove the <handler> associated with this @a handle.
   virtual int remove_handler_i (ACE_HANDLE handle,
                                 ACE_Reactor_Mask mask);