Tue Oct 2 17:06:15 UTC 2007 Johnny Willemsen <jwillemsen@remedy.nl>

30 files changed, 211 insertions, 207 deletions

diff --git a/ACE/ChangeLog b/ACE/ChangeLog
index c233d46943d..72a2f66db7d 100644
--- a/ACE/ChangeLog
+++ b/ACE/ChangeLog
@@ -1,3 +1,36 @@
+Tue Oct  2 17:06:15 UTC 2007  Johnny Willemsen  <jwillemsen@remedy.nl>
+
+        * ace/Asynch_IO_Impl.h
+        * ace/config-macosx-tiger.h
+        * ace/Dev_Poll_Reactor.h
+        * ace/Message_Queue.h
+        * ace/Message_Queue.inl
+        * ace/Message_Queue_T.cpp
+        * ace/Message_Queue_T.h
+        * ace/Message_Queue_Vx.cpp
+        * ace/Message_Queue_Vx.h
+        * ace/Msg_WFMO_Reactor.h
+        * ace/Notification_Strategy.h
+        * ace/NT_Service.h
+        * ace/Object_Manager.h
+        * ace/Object_Manager_Base.h
+        * ace/POSIX_Asynch_IO.h
+        * ace/POSIX_CB_Proactor.h
+        * ace/POSIX_Proactor.h
+        * ace/Proactor.h
+        * ace/Process.cpp
+        * ace/Process.h
+        * ace/Process.inl
+        * ace/Process_Manager.cpp
+        * ace/Process_Manager.h
+        * ace/Process_Semaphore.cpp
+        * ace/Process_Semaphore.h
+        * ace/Reactor.h
+        * ace/Reactor_Impl.h
+        * ace/SOCK_Connector.h
+        * ace/WFMO_Reactor.h
+          Doxygen improvements, small cleanups and bool changes
+
 Mon Oct  1 15:06:15 UTC 2007  Johnny Willemsen  <jwillemsen@remedy.nl>
 
         * bin/make_release.py:
diff --git a/ACE/ace/Asynch_IO_Impl.h b/ACE/ace/Asynch_IO_Impl.h
index e6aa77be56c..57203429e74 100644
--- a/ACE/ace/Asynch_IO_Impl.h
+++ b/ACE/ace/Asynch_IO_Impl.h
@@ -671,8 +671,8 @@ public:
    * allowed. 0 means priority of the operation same as the process
    * priority. 1 means priority of the operation is one less than
    * process. And so forth. On Win32, <priority> is a no-op.
-   * <signal_number> is the POSIX4 real-time signal number to be used
-   * for the operation. <signal_number> ranges from ACE_SIGRTMIN to
+   * @a signal_number is the POSIX4 real-time signal number to be used
+   * for the operation. @a signal_number ranges from ACE_SIGRTMIN to
    * ACE_SIGRTMAX. This argument is a no-op on non-POSIX4 systems.
    */
   virtual ssize_t recv (ACE_Message_Block *message_block,
@@ -757,8 +757,8 @@ public:
    * allowed. 0 means priority of the operation same as the process
    * priority. 1 means priority of the operation is one less than
    * process. And so forth. On Win32, this argument is a no-op.
-   * <signal_number> is the POSIX4 real-time signal number to be used
-   * for the operation. <signal_number> ranges from ACE_SIGRTMIN to
+   * @a signal_number is the POSIX4 real-time signal number to be used
+   * for the operation. @a signal_number ranges from ACE_SIGRTMIN to
    * ACE_SIGRTMAX. This argument is a no-op on non-POSIX4 systems.
    */
   virtual ssize_t send (ACE_Message_Block *message_block,
diff --git a/ACE/ace/Dev_Poll_Reactor.h b/ACE/ace/Dev_Poll_Reactor.h
index b4cc00b7627..9a0ed1f3985 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 @a handle.  If @a 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.
    */
@@ -664,7 +664,7 @@ public:
 
   /**
    * Removes all handles in <handle_set>.  If @a mask ==
-   * <ACE_Event_Handler::DONT_CALL> then the <handle_close> method of
+   * ACE_Event_Handler::DONT_CALL then the <handle_close> method of
    * the associated <event_handler>s is not invoked.
    */
   virtual int remove_handler (const ACE_Handle_Set &handle_set,
@@ -758,7 +758,7 @@ public:
                                     const ACE_Time_Value &interval);
 
   /// Cancel all Event_Handlers that match the address of
-  /// <event_handler>.  Returns number of handlers cancelled.
+  /// @a event_handler.  Returns number of handlers cancelled.
   virtual int cancel_timer (ACE_Event_Handler *event_handler,
                             int dont_call_handle_close = 1);
 
@@ -777,8 +777,8 @@ public:
 
   // = High-level event handler scheduling operations
 
-  /// Add @a masks_to_be_added to the <event_handler>'s entry.
-  /// <event_handler> must already have been registered.
+  /// Add @a masks_to_be_added to the @a event_handler's entry.
+  /// @a event_handler must already have been registered.
   virtual int schedule_wakeup (ACE_Event_Handler *event_handler,
                                ACE_Reactor_Mask masks_to_be_added);
 
@@ -787,7 +787,7 @@ public:
   virtual int schedule_wakeup (ACE_HANDLE handle,
                                ACE_Reactor_Mask masks_to_be_added);
 
-  /// Clear @a masks_to_be_cleared from the <event_handler>'s entry.
+  /// Clear @a masks_to_be_cleared from the @a event_handler's entry.
   virtual int cancel_wakeup (ACE_Event_Handler *event_handler,
                              ACE_Reactor_Mask masks_to_be_cleared);
 
@@ -798,7 +798,7 @@ public:
   // = Notification methods.
 
   /**
-   * Notify <event_handler> of @a mask event.  The ACE_Time_Value
+   * Notify @a 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).
@@ -843,8 +843,8 @@ public:
 
   /**
    * 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.
+   * bound to @a mask.  Return the @a event_handler associated with this
+   * <handler> if @a event_handler != 0.
    */
   virtual int handler (ACE_HANDLE handle,
                        ACE_Reactor_Mask mask,
@@ -852,8 +852,8 @@ public:
 
   /**
    * Check to see if @a signum is associated with a valid Event_Handler
-   * bound to a signal.  Return the <event_handler> associated with
-   * this <handler> if <event_handler> != 0.
+   * bound to a signal.  Return the @a event_handler associated with
+   * this <handler> if @a event_handler != 0.
    */
   virtual int handler (int signum,
                        ACE_Event_Handler ** = 0);
diff --git a/ACE/ace/Message_Queue.h b/ACE/ace/Message_Queue.h
index eadaadd7920..a3e81f02151 100644
--- a/ACE/ace/Message_Queue.h
+++ b/ACE/ace/Message_Queue.h
@@ -135,10 +135,10 @@ public:
 
   // = Check if queue is full/empty.
   /// True if queue is full, else false.
-  virtual int is_full (void) = 0;
+  virtual bool is_full (void) = 0;
 
   /// True if queue is empty, else false.
-  virtual int is_empty (void) = 0;
+  virtual bool is_empty (void) = 0;
 
   // = Queue statistic methods.
 
@@ -297,12 +297,12 @@ public:
    * Always return false.
    */
 
-  virtual int is_full (void);
+  virtual bool is_full (void);
   /**
    * True if queue is empty, else false.  Notice the return value is
    * only transient.
    */
-  virtual int is_empty (void);
+  virtual bool is_empty (void);
 
   // = Queue statistic methods (transient.)
   /**
diff --git a/ACE/ace/Message_Queue.inl b/ACE/ace/Message_Queue.inl
index 94354ba87a8..4952feee05a 100644
--- a/ACE/ace/Message_Queue.inl
+++ b/ACE/ace/Message_Queue.inl
@@ -31,20 +31,20 @@ ACE_Message_Queue_NT::dequeue_head (ACE_Message_Block *&first_item,
   return this->dequeue (first_item, timeout);
 }
 
-ACE_INLINE int
+ACE_INLINE bool
 ACE_Message_Queue_NT::is_full (void)
 {
   ACE_TRACE ("ACE_Message_Queue_NT::is_full");
-  return 0; // Always not full.
+  return false; // Always not full.
 }
 
-ACE_INLINE int
+ACE_INLINE bool
 ACE_Message_Queue_NT::is_empty (void)
 {
   ACE_TRACE ("ACE_Message_Queue_NT::is_empty");
-  ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->lock_, 0);
+  ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->lock_, false);
 
-  return this->cur_bytes_ > 0 || this->cur_count_ > 0 ? 0 : 1;
+  return this->cur_bytes_ > 0 || this->cur_count_ > 0 ? false : true;
 }
 
 ACE_INLINE size_t
diff --git a/ACE/ace/Message_Queue_T.cpp b/ACE/ace/Message_Queue_T.cpp
index 89ede16ac5b..82f29e8656b 100644
--- a/ACE/ace/Message_Queue_T.cpp
+++ b/ACE/ace/Message_Queue_T.cpp
@@ -468,7 +468,7 @@ ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::notification_strategy (AC
 
 // Check if queue is empty (holds locks).
 
-template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> int
+template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> bool
 ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::is_empty (void)
 {
   ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::is_empty");
@@ -478,7 +478,7 @@ ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::is_empty (void)
 
 // Check if queue is full (holds locks).
 
-template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> int
+template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> bool
 ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::is_full (void)
 {
   ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::is_full");
@@ -708,7 +708,7 @@ ACE_Message_Queue<ACE_SYNCH_USE>::notification_strategy (ACE_Notification_Strate
 
 // Check if queue is empty (does not hold locks).
 
-template <ACE_SYNCH_DECL> int
+template <ACE_SYNCH_DECL> bool
 ACE_Message_Queue<ACE_SYNCH_USE>::is_empty_i (void)
 {
   ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::is_empty_i");
@@ -717,7 +717,7 @@ ACE_Message_Queue<ACE_SYNCH_USE>::is_empty_i (void)
 
 // Check if queue is full (does not hold locks).
 
-template <ACE_SYNCH_DECL> int
+template <ACE_SYNCH_DECL> bool
 ACE_Message_Queue<ACE_SYNCH_USE>::is_full_i (void)
 {
   ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::is_full_i");
@@ -726,22 +726,22 @@ ACE_Message_Queue<ACE_SYNCH_USE>::is_full_i (void)
 
 // Check if queue is empty (holds locks).
 
-template <ACE_SYNCH_DECL> int
+template <ACE_SYNCH_DECL> bool
 ACE_Message_Queue<ACE_SYNCH_USE>::is_empty (void)
 {
   ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::is_empty");
-  ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, -1);
+  ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, false);
 
   return this->is_empty_i ();
 }
 
 // Check if queue is full (holds locks).
 
-template <ACE_SYNCH_DECL> int
+template <ACE_SYNCH_DECL> bool
 ACE_Message_Queue<ACE_SYNCH_USE>::is_full (void)
 {
   ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::is_full");
-  ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, -1);
+  ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, false);
 
   return this->is_full_i ();
 }
diff --git a/ACE/ace/Message_Queue_T.h b/ACE/ace/Message_Queue_T.h
index 346ea04e515..a893cff1147 100644
--- a/ACE/ace/Message_Queue_T.h
+++ b/ACE/ace/Message_Queue_T.h
@@ -341,9 +341,9 @@ public:
   //@{
 
   /// True if queue is full, else false.
-  virtual int is_full (void);
+  virtual bool is_full (void);
   /// True if queue is empty, else false.
-  virtual int is_empty (void);
+  virtual bool is_empty (void);
 
   /**
    * Number of total bytes on the queue, i.e., sum of the message
@@ -515,10 +515,10 @@ protected:
   // = Check the boundary conditions (assumes locks are held).
 
   /// True if queue is full, else false.
-  virtual int is_full_i (void);
+  virtual bool is_full_i (void);
 
   /// True if queue is empty, else false.
-  virtual int is_empty_i (void);
+  virtual bool is_empty_i (void);
 
   // = Implementation of the public <activate> and <deactivate> methods.
 
@@ -1223,9 +1223,10 @@ public:
   //@{
 
   /// True if queue is full, else false.
-  virtual int is_full (void);
+  virtual bool is_full (void);
+
   /// True if queue is empty, else false.
-  virtual int is_empty (void);
+  virtual bool is_empty (void);
 
   /**
    * Number of total bytes on the queue, i.e., sum of the message
diff --git a/ACE/ace/Message_Queue_Vx.cpp b/ACE/ace/Message_Queue_Vx.cpp
index a4af0a74a8d..dca82a2641d 100644
--- a/ACE/ace/Message_Queue_Vx.cpp
+++ b/ACE/ace/Message_Queue_Vx.cpp
@@ -133,15 +133,14 @@ ACE_Message_Queue_Vx::close (void)
   return ::msgQDelete (msgq ());
 }
 
-
-int
+bool
 ACE_Message_Queue_Vx::is_empty_i (void)
 {
   ACE_TRACE ("ACE_Message_Queue_Vx::is_empty_i");
   return ::msgQNumMsgs (msgq ()) == 0;
 }
 
-int
+bool
 ACE_Message_Queue_Vx::is_full_i (void)
 {
   ACE_TRACE ("ACE_Message_Queue_Vx::is_full_i");
diff --git a/ACE/ace/Message_Queue_Vx.h b/ACE/ace/Message_Queue_Vx.h
index 99b251d3871..421ebce99ea 100644
--- a/ACE/ace/Message_Queue_Vx.h
+++ b/ACE/ace/Message_Queue_Vx.h
@@ -166,10 +166,10 @@ protected:
 
   // = Check the boundary conditions (assumes locks are held).
   /// True if queue is full, else false.
-  virtual int is_full_i (void);
+  virtual bool is_full_i (void);
 
   /// True if queue is empty, else false.
-  virtual int is_empty_i (void);
+  virtual bool is_empty_i (void);
 
   // = Implementation of public <activate>/<deactivate> methods above.
 
diff --git a/ACE/ace/Msg_WFMO_Reactor.h b/ACE/ace/Msg_WFMO_Reactor.h
index d37ebfe93b3..cc6746d8a26 100644
--- a/ACE/ace/Msg_WFMO_Reactor.h
+++ b/ACE/ace/Msg_WFMO_Reactor.h
@@ -61,23 +61,23 @@ public:
   virtual ~ACE_Msg_WFMO_Reactor (void);
 
   /**
-   * This event loop driver blocks for up to <max_wait_time> before
+   * This event loop driver blocks for up to @a max_wait_time before
    * returning.  It will return earlier if timer events, I/O events,
-   * window events, or signal events occur.  Note that <max_wait_time>
+   * window events, or signal events occur.  Note that @a max_wait_time
    * can be 0, in which case this method blocks indefinitely until
    * events occur.
    *
-   * <max_wait_time> is decremented to reflect how much time this call
+   * @a max_wait_time is decremented to reflect how much time this call
    * took.  For instance, if a time value of 3 seconds is passed to
    * handle_events and an event occurs after 2 seconds,
-   * <max_wait_time> will equal 1 second.  This can be used if an
+   * @a max_wait_time will equal 1 second.  This can be used if an
    * application wishes to handle events for some fixed amount of
    * time.
    *
    * <MsgWaitForMultipleObjects> is used as the demultiplexing call
    *
    * Returns the total number of ACE_Event_Handlers that were
-   * dispatched, 0 if the <max_wait_time> elapsed without dispatching
+   * dispatched, 0 if the @a max_wait_time elapsed without dispatching
    * any handlers, or -1 if an error occurs.
    *
    * The only difference between <alertable_handle_events> and
@@ -90,7 +90,7 @@ public:
 
   /**
    * This method is just like the one above, except the
-   * <max_wait_time> value is a reference and can therefore never be
+   * @a max_wait_time value is a reference and can therefore never be
    * NULL.
    */
   virtual int handle_events (ACE_Time_Value &max_wait_time);
diff --git a/ACE/ace/NT_Service.h b/ACE/ace/NT_Service.h
index a051499fe54..4ad835badc7 100644
--- a/ACE/ace/NT_Service.h
+++ b/ACE/ace/NT_Service.h
@@ -234,8 +234,8 @@ public:
   // = Methods which control the service's execution.
 
   // These methods to start/pause/resume/stop/check the service all
-  // have the following common behavior with respect to <wait_time>
-  // and return value.  <wait_time> is a pointer to an ACE_Time_Value
+  // have the following common behavior with respect to @a wait_time
+  // and return value.  @a wait_time is a pointer to an ACE_Time_Value
   // object.  If not supplied (a zero pointer) the function will wait
   // indefinitely for the action to be finalized (service reach
   // running state, completely shut down, etc.) or get "stuck" before
@@ -243,7 +243,7 @@ public:
   // wait for the service to reach a steady state, and on return, it
   // is updated to the service's last reported wait hint.  So, if you
   // want to control the waiting yourself (for example, you want to
-  // react to UI events during the wait) specify a <wait_time> of (0,
+  // react to UI events during the wait) specify a @a wait_time of (0,
   // 0) and use the updated time to know when to check the service's
   // state again.  NOTE!!!! The wait_time things don't work yet.  The
   // calls always check status once, and do not wait for it to change.
@@ -264,7 +264,7 @@ public:
    * the time to wait for the service to reach a steady state before
    * returning.  If it is 0, the function waits as long as it takes
    * for the service to reach the 'running' state, or gets stuck in
-   * some other state, or exits.  If <wait_time> is supplied, it is
+   * some other state, or exits.  If @a wait_time is supplied, it is
    * updated on return to hold the service's last reported wait hint.
    * svc_state can be used to receive the state which the service
    * settled in.  If the value is 0, the service never ran.  argc/argv
@@ -276,7 +276,7 @@ public:
                  DWORD argc = 0, const ACE_TCHAR **argv = 0);
 
   /**
-   * Requests the service to stop.  Will wait up to <wait_time> for
+   * Requests the service to stop.  Will wait up to @a wait_time for
    * the service to actually stop.  If not specified, the function
    * waits until the service either stops or gets stuck in some other
    * state before it stops.  If <svc_state> is specified, it receives
@@ -332,7 +332,7 @@ protected:
   /**
    * Waits for the service to reach <desired_state> or get
    * (apparently) stuck before it reaches that state.  Will wait at
-   * most <wait_time> to get to the desired state.  If <wait_time> is
+   * most @a wait_time to get to the desired state.  If @a wait_time is
    * 0, then the function keeps waiting until the desired state is
    * reached or the service doesn't update its state any further.  The
    * svc_status_ class member is updated upon return.
diff --git a/ACE/ace/Notification_Strategy.h b/ACE/ace/Notification_Strategy.h
index 751868152b4..5fe5d836c05 100644
--- a/ACE/ace/Notification_Strategy.h
+++ b/ACE/ace/Notification_Strategy.h
@@ -37,15 +37,13 @@ class ACE_Export ACE_Notification_Strategy
 {
 public:
   /// Constructor.
-  ACE_Notification_Strategy (ACE_Event_Handler *eh,
-                             ACE_Reactor_Mask mask);
+  ACE_Notification_Strategy (ACE_Event_Handler *eh, ACE_Reactor_Mask mask);
 
   /// Destructor.
   virtual ~ACE_Notification_Strategy (void);
 
   virtual int notify (void) = 0;
-  virtual int notify (ACE_Event_Handler *,
-                      ACE_Reactor_Mask mask) = 0;
+  virtual int notify (ACE_Event_Handler *, ACE_Reactor_Mask mask) = 0;
 
   /// Get the event handler.
   ACE_Event_Handler *event_handler (void);
diff --git a/ACE/ace/Object_Manager.h b/ACE/ace/Object_Manager.h
index 62b3ef374ec..b330fe16e84 100644
--- a/ACE/ace/Object_Manager.h
+++ b/ACE/ace/Object_Manager.h
@@ -347,35 +347,35 @@ public:
 
   /**
    * Accesses an ACE_Null_Mutex to be used for construction of
-   * <ACE_Singletons>.  Returns 0, and the lock in the argument, on
+   * ACE_Singletons.  Returns 0, and the lock in the argument, on
    * success; returns -1 on failure.
    */
   static int get_singleton_lock (ACE_Null_Mutex *&);
 
   /**
    * Accesses a non-recursive ACE_Thread_Mutex to be used for
-   * construction of <ACE_Singletons>.  Returns 0, and the lock in the
+   * construction of ACE_Singletons.  Returns 0, and the lock in the
    * argument, on success; returns -1 on failure.
    */
   static int get_singleton_lock (ACE_Thread_Mutex *&);
 
   /**
    * Accesses a non-recursive ACE_Mutex to be used for construction
-   * of <ACE_Singletons>.  Returns 0, and the lock in the argument, on
+   * of ACE_Singletons.  Returns 0, and the lock in the argument, on
    * success; returns -1 on failure.
    */
   static int get_singleton_lock (ACE_Mutex *&);
 
   /**
    * Accesses a recursive ACE_Recursive_Thread_Mutex to be used for
-   * construction of <ACE_Singletons>.  Returns 0, and the lock in the
+   * construction of ACE_Singletons.  Returns 0, and the lock in the
    * argument, on success; returns -1 on failure.
    */
   static int get_singleton_lock (ACE_Recursive_Thread_Mutex *&);
 
   /**
    * Accesses a readers/writer ACE_RW_Thread_Mutex to be used for
-   * construction of <ACE_Singletons>.  Returns 0, and the lock in the
+   * construction of ACE_Singletons.  Returns 0, and the lock in the
    * argument, on success; returns -1 on failure.
    */
   static int get_singleton_lock (ACE_RW_Thread_Mutex *&);
diff --git a/ACE/ace/Object_Manager_Base.h b/ACE/ace/Object_Manager_Base.h
index ec9170292d5..a67c5ceeec8 100644
--- a/ACE/ace/Object_Manager_Base.h
+++ b/ACE/ace/Object_Manager_Base.h
@@ -136,13 +136,13 @@ public:
   virtual int fini (void);
 
   /**
-   * Returns 1 before the <ACE_OS_Object_Manager> has been
+   * Returns 1 before the ACE_OS_Object_Manager has been
    * constructed.  See <ACE_Object_Manager::starting_up> for more
    * information.
    */
   static int starting_up (void);
 
-  /// Returns 1 after the <ACE_OS_Object_Manager> has been destroyed.
+  /// Returns 1 after the ACE_OS_Object_Manager has been destroyed.
   /// See <ACE_Object_Manager::shutting_down> for more information.
   static int shutting_down (void);
 
@@ -171,7 +171,7 @@ public:
     };
 
   /// Accesses a default signal set used, for example, in
-  /// <ACE_Sig_Guard> methods.
+  /// ACE_Sig_Guard methods.
   static sigset_t *default_mask (void);
 
   /// Returns the current thread hook for the process.
diff --git a/ACE/ace/POSIX_Asynch_IO.h b/ACE/ace/POSIX_Asynch_IO.h
index 8ab2b084daf..85b448f44c2 100644
--- a/ACE/ace/POSIX_Asynch_IO.h
+++ b/ACE/ace/POSIX_Asynch_IO.h
@@ -1067,7 +1067,7 @@ public:
    * this is supported. Works like <nice> in Unix. Negative values are not
    * allowed. 0 means priority of the operation same as the process
    * priority. 1 means priority of the operation is one less than
-   * process.  <signal_number> argument is a no-op on non-POSIX4 systems.
+   * process.  @a signal_number argument is a no-op on non-POSIX4 systems.
    *
    * @note Unlike the Windows version of this facility, no indication of
    * immediate success can be returned, and @a number_of_bytes_read is
diff --git a/ACE/ace/POSIX_CB_Proactor.h b/ACE/ace/POSIX_CB_Proactor.h
index 238b1f5287f..a37e72e139e 100644
--- a/ACE/ace/POSIX_CB_Proactor.h
+++ b/ACE/ace/POSIX_CB_Proactor.h
@@ -56,7 +56,7 @@ public:
 protected:
 
   /**
-   * Dispatch a single set of events.  If <wait_time> elapses before
+   * Dispatch a single set of events.  If @a wait_time elapses before
    * any events occur, return 0.  Return 1 on success i.e., when a
    * completion is dispatched, non-zero (-1) on errors and errno is
    * set accordingly.
@@ -65,7 +65,7 @@ protected:
 
   /**
    * Block indefinitely until at least one event is dispatched.
-   * Dispatch a single set of events.  If <wait_time> elapses before
+   * Dispatch a single set of events.  If @a wait_time elapses before
    * any events occur, return 0.  Return 1 on success i.e., when a
    * completion is dispatched, non-zero (-1) on errors and errno is
    * set accordingly.
diff --git a/ACE/ace/POSIX_Proactor.h b/ACE/ace/POSIX_Proactor.h
index 375313f7260..5833ce47454 100644
--- a/ACE/ace/POSIX_Proactor.h
+++ b/ACE/ace/POSIX_Proactor.h
@@ -351,7 +351,7 @@ public:
   virtual int close (void);
 
   /**
-   * Dispatch a single set of events.  If <wait_time> elapses before
+   * Dispatch a single set of events.  If @a wait_time elapses before
    * any events occur, return 0.  Return 1 on success i.e., when a
    * completion is dispatched, non-zero (-1) on errors and errno is
    * set accordingly.
@@ -360,7 +360,7 @@ public:
 
   /**
    * Block indefinitely until at least one event is dispatched.
-   * Dispatch a single set of events.  If <wait_time> elapses before
+   * Dispatch a single set of events.  If @a wait_time elapses before
    * any events occur, return 0.  Return 1 on success i.e., when a
    * completion is dispatched, non-zero (-1) on errors and errno is
    * set accordingly.
@@ -538,7 +538,7 @@ public:
   virtual ~ACE_POSIX_SIG_Proactor (void);
 
   /**
-   * Dispatch a single set of events.  If <wait_time> elapses before
+   * Dispatch a single set of events.  If @a wait_time elapses before
    * any events occur, return 0.  Return 1 on success i.e., when a
    * completion is dispatched, non-zero (-1) on errors and errno is
    * set accordingly.
@@ -559,7 +559,7 @@ public:
   ///virtual int post_completion (ACE_POSIX_Asynch_Result *result);
 
   /**
-   * If <signal_number> is -1, check with the Proactor and use one of
+   * If @a signal_number is -1, check with the Proactor and use one of
    * the signals that is present in the mask set (i.e., the signals for
    * which the Proactor will be waiting) of the Proactor. If there are
    * more than one signal, the higher numbered signal will be chosen.
@@ -593,7 +593,6 @@ protected:
   /// Find free slot to store result and aiocb pointer
   virtual ssize_t allocate_aio_slot (ACE_POSIX_Asynch_Result *result);
 
-
   /// Notify queue of "post_completed" ACE_POSIX_Asynch_Results
   /// called from post_completion method
   virtual int notify_completion (int sig_num);
diff --git a/ACE/ace/Proactor.h b/ACE/ace/Proactor.h
index 5f7bde38dc4..90e01d423b0 100644
--- a/ACE/ace/Proactor.h
+++ b/ACE/ace/Proactor.h
@@ -562,7 +562,7 @@ public:
   /**
    * Create a timer result object which can be used with the Timer
    * mechanism of the Proactor.
-   * If <signal_number> is -1, <POSIX_SIG_Proactor> will create a
+   * If @a signal_number is -1, <POSIX_SIG_Proactor> will create a
    * Timer object with a meaningful signal number, choosing the
    * largest signal number from the signal mask of the Proactor.
    */
diff --git a/ACE/ace/Process.cpp b/ACE/ace/Process.cpp
index 276030bec96..d7ccb6c1d4b 100644
--- a/ACE/ace/Process.cpp
+++ b/ACE/ace/Process.cpp
@@ -690,13 +690,13 @@ ACE_Process::close_passed_handles (void)
   return;
 }
 
-ACE_Process_Options::ACE_Process_Options (int ie,
-                                          int cobl,
-                                          int ebl,
-                                          int mea)
+ACE_Process_Options::ACE_Process_Options (bool inherit_environment,
+                                          int command_line_buf_len,
+                                          int env_buf_len,
+                                          int max_env_args)
   :
 #if !defined (ACE_HAS_WINCE)
-    inherit_environment_ (ie),
+    inherit_environment_ (inherit_environment),
 #endif /* ACE_HAS_WINCE */
     creation_flags_ (0),
     avoid_zombies_ (0),
@@ -719,26 +719,26 @@ ACE_Process_Options::ACE_Process_Options (int ie,
     environment_buf_index_ (0),
     environment_argv_index_ (0),
     environment_buf_ (0),
-    environment_buf_len_ (ebl),
-    max_environment_args_ (mea),
-    max_environ_argv_index_ (mea - 1),
+    environment_buf_len_ (env_buf_len),
+    max_environment_args_ (max_env_args),
+    max_environ_argv_index_ (max_env_args - 1),
 #endif /* !ACE_HAS_WINCE */
     command_line_argv_calculated_ (0),
     command_line_buf_ (0),
     command_line_copy_ (0),
-    command_line_buf_len_ (cobl),
+    command_line_buf_len_ (command_line_buf_len),
     process_group_ (ACE_INVALID_PID)
 {
   ACE_NEW (command_line_buf_,
-           ACE_TCHAR[cobl]);
+           ACE_TCHAR[command_line_buf_len]);
   command_line_buf_[0] = '\0';
 
 #if !defined (ACE_HAS_WINCE)
   working_directory_[0] = '\0';
   ACE_NEW (environment_buf_,
-           ACE_TCHAR[ebl]);
+           ACE_TCHAR[env_buf_len]);
   ACE_NEW (environment_argv_,
-           ACE_TCHAR *[mea]);
+           ACE_TCHAR *[max_env_args]);
   environment_buf_[0] = '\0';
   environment_argv_[0] = 0;
   process_name_[0] = '\0';
diff --git a/ACE/ace/Process.h b/ACE/ace/Process.h
index 95915090cff..4c189be4cf4 100644
--- a/ACE/ace/Process.h
+++ b/ACE/ace/Process.h
@@ -66,7 +66,7 @@ public:
 protected:
   // = Default settings not part of public Interface.
   //
-  // @@todo These sizes should be taken from the appropriate
+  // @todo These sizes should be taken from the appropriate
   // POSIX/system header files and/or defined dynamically.
   enum
   {
@@ -77,11 +77,11 @@ protected:
 
 public:
   /**
-   * If @a inherit_environment == 1, the new process will inherit the
+   * If @a inherit_environment == true, the new process will inherit the
    * environment of the current process.  @a command_line_buf_len is the
    * max strlen for command-line arguments.
    */
-  ACE_Process_Options (int inherit_environment = 1,
+  ACE_Process_Options (bool inherit_environment = true,
                        int command_line_buf_len = DEFAULT_COMMAND_LINE_BUF_LEN,
                        int env_buf_len = ENVIRONMENT_BUFFER,
                        int max_env_args = MAX_ENVIRONMENT_ARGS);
@@ -306,12 +306,12 @@ public:
   /**
    * Get the inherit_environment flag.
    */
-  int inherit_environment (void) const;
+  bool inherit_environment (void) const;
 
   /**
    * Set the inherit_environment flag.
    */
-  void inherit_environment (int nv);
+  void inherit_environment (bool nv);
 #endif /* ACE_WIN32 */
 protected:
 
@@ -322,7 +322,7 @@ protected:
 
   /// Whether the child process inherits the current process
   /// environment.
-  int inherit_environment_;
+  bool inherit_environment_;
 #endif /* !ACE_HAS_WINCE */
 
   /// Default 0.
diff --git a/ACE/ace/Process.inl b/ACE/ace/Process.inl
index 87dfc3994ee..228874778ce 100644
--- a/ACE/ace/Process.inl
+++ b/ACE/ace/Process.inl
@@ -234,14 +234,14 @@ ACE_Process_Options::get_stderr (void) const
   return stderr_;
 }
 
-ACE_INLINE int
+ACE_INLINE bool
 ACE_Process_Options::inherit_environment (void) const
 {
   return inherit_environment_;
 }
 
 ACE_INLINE void
-ACE_Process_Options::inherit_environment (int nv)
+ACE_Process_Options::inherit_environment (bool nv)
 {
   inherit_environment_ = nv;
 }
diff --git a/ACE/ace/Process_Manager.cpp b/ACE/ace/Process_Manager.cpp
index 8f120b1135f..11ff975a59c 100644
--- a/ACE/ace/Process_Manager.cpp
+++ b/ACE/ace/Process_Manager.cpp
@@ -59,7 +59,7 @@ ACE_Process_Manager *ACE_Process_Manager::instance_ = 0;
 
 // Controls whether the <Process_Manager> is deleted when we shut down
 // (we can only delete it safely if we created it!)
-int ACE_Process_Manager::delete_instance_ = 0;
+bool ACE_Process_Manager::delete_instance_ = false;
 
 ACE_Process_Manager::Process_Descriptor::~Process_Descriptor (void)
 {
@@ -121,7 +121,7 @@ ACE_Process_Manager::instance (void)
           ACE_NEW_RETURN (ACE_Process_Manager::instance_,
                           ACE_Process_Manager,
                           0);
-          ACE_Process_Manager::delete_instance_ = 1;
+          ACE_Process_Manager::delete_instance_ = true;
 
           // Register with the Object_Manager so that the wrapper to
           // delete the proactor will be called when Object_Manager is
@@ -152,20 +152,20 @@ ACE_Process_Manager::instance (ACE_Process_Manager *tm)
 
   ACE_Process_Manager *t = ACE_Process_Manager::instance_;
   // We can't safely delete it since we don't know who created it!
-  ACE_Process_Manager::delete_instance_ = 0;
+  ACE_Process_Manager::delete_instance_ = false;
 
-          // Register with the Object_Manager so that the wrapper to
-          // delete the proactor will be called when Object_Manager is
-          // being terminated.
+  // Register with the Object_Manager so that the wrapper to
+  // delete the proactor will be called when Object_Manager is
+  // being terminated.
 
 #if defined ACE_HAS_SIG_C_FUNC
-          ACE_Object_Manager::at_exit (ACE_Process_Manager::instance_,
-                                       ACE_Process_Manager_cleanup,
-                                       0);
+  ACE_Object_Manager::at_exit (ACE_Process_Manager::instance_,
+                                ACE_Process_Manager_cleanup,
+                                0);
 #else
-          ACE_Object_Manager::at_exit (ACE_Process_Manager::instance_,
-                                       ACE_Process_Manager::cleanup,
-                                       0);
+  ACE_Object_Manager::at_exit (ACE_Process_Manager::instance_,
+                                ACE_Process_Manager::cleanup,
+                                0);
 #endif /* ACE_HAS_SIG_C_FUNC */
 
   ACE_Process_Manager::instance_ = tm;
@@ -184,7 +184,7 @@ ACE_Process_Manager::close_singleton( void )
     {
       delete ACE_Process_Manager::instance_;
       ACE_Process_Manager::instance_ = 0;
-      ACE_Process_Manager::delete_instance_ = 0;
+      ACE_Process_Manager::delete_instance_ = false;
     }
 }
 
@@ -219,8 +219,7 @@ ACE_Process_Manager::resize (size_t size)
 // Create and initialize the table to keep track of the process pool.
 
 int
-ACE_Process_Manager::open (size_t size,
-                           ACE_Reactor *r)
+ACE_Process_Manager::open (size_t size, ACE_Reactor *r)
 {
   ACE_TRACE ("ACE_Process_Manager::open");
 
diff --git a/ACE/ace/Process_Manager.h b/ACE/ace/Process_Manager.h
index 163c440bf46..cd9e2009eca 100644
--- a/ACE/ace/Process_Manager.h
+++ b/ACE/ace/Process_Manager.h
@@ -223,8 +223,7 @@ public:
    *
    * @retval 0 on success and -1 on failure.
    */
-  int terminate (pid_t pid,
-                 int sig);
+  int terminate (pid_t pid, int sig);
 
   /**
    * Block until there are no more child processes running that were
@@ -409,8 +408,8 @@ private:
   /// Resize the pool of Process_Descriptors.
   int resize (size_t);
 
-  /// Locate the index of the table slot occupied by <process_id>.
-  /// Returns -1 if <process_id> is not in the <process_table_>
+  /// Locate the index of the table slot occupied by @a process_id.
+  /// Returns -1 if @a process_id is not in the <process_table_>
   ssize_t find_proc (pid_t process_id);
 
 #if defined (ACE_WIN32)
@@ -440,8 +439,7 @@ private:
 
   /// If there's a specific handler for the Process at index @a n in the
   /// table, or there's a default handler, call it.
-  int notify_proc_handler (size_t n,
-                           ACE_exitcode status);
+  int notify_proc_handler (size_t n, ACE_exitcode status);
 
   /// Vector that describes process state within the Process_Manager.
   Process_Descriptor *process_table_;
@@ -462,7 +460,7 @@ private:
 
   /// Controls whether the <Process_Manager> is deleted when we shut
   /// down (we can only delete it safely if we created it!)
-  static int delete_instance_;
+  static bool delete_instance_;
 
 #if defined (ACE_HAS_THREADS)
   /// This lock protects access/ops on <process_table_>.
diff --git a/ACE/ace/Process_Semaphore.cpp b/ACE/ace/Process_Semaphore.cpp
index cf180f92258..ab2012b6a39 100644
--- a/ACE/ace/Process_Semaphore.cpp
+++ b/ACE/ace/Process_Semaphore.cpp
@@ -42,11 +42,6 @@ ACE_Process_Semaphore::ACE_Process_Semaphore (u_int count,
 // ACE_TRACE ("ACE_Process_Semaphore::ACE_Process_Semaphore");
 }
 
-// ACE_Process_Semaphore::~ACE_Process_Semaphore (void)
-// {
-//   // ACE_TRACE ("ACE_Process_Semaphore::~ACE_Process_Semaphore");
-// }
-
 // Explicitly destroy the semaphore.
 
 int
diff --git a/ACE/ace/Process_Semaphore.h b/ACE/ace/Process_Semaphore.h
index 1b95d497445..61665207d82 100644
--- a/ACE/ace/Process_Semaphore.h
+++ b/ACE/ace/Process_Semaphore.h
@@ -49,13 +49,6 @@ public:
                          int max = 0x7FFFFFFF);
 
   /**
-   * This method is a no-op, i.e., it doesn't remove the semaphore.
-   * If you want to remove the semaphore, you must call the <remove>
-   * method explicitly.
-   */
-  // ~ACE_Process_Semaphore (void);
-
-  /**
    * Explicitly destroy the semaphore.  Note that only one thread
    * should call this method since it doesn't protect against race
    * conditions.
@@ -79,21 +72,21 @@ public:
 
   /**
    * Acquire semaphore ownership.  This calls <acquire> and is only
-   * here to make the <ACE_Process_Semaphore> interface consistent
+   * here to make the ACE_Process_Semaphore interface consistent
    * with the other synchronization APIs.
    */
   int acquire_read (void);
 
   /**
    * Acquire semaphore ownership.  This calls <acquire> and is only
-   * here to make the <ACE_Process_Semaphore> interface consistent
+   * here to make the ACE_Process_Semaphore interface consistent
    * with the other synchronization APIs.
    */
   int acquire_write (void);
 
   /**
    * Conditionally acquire semaphore (i.e., won't block).  This calls
-   * <tryacquire> and is only here to make the <ACE_Process_Semaphore>
+   * <tryacquire> and is only here to make the ACE_Process_Semaphore
    * interface consistent with the other synchronization APIs.
    * Returns -1 on failure.  If we "failed" because someone else
    * already had the lock, @c errno is set to @c EBUSY.
diff --git a/ACE/ace/Reactor.h b/ACE/ace/Reactor.h
index fe8995f18c5..1dff34d0a93 100644
--- a/ACE/ace/Reactor.h
+++ b/ACE/ace/Reactor.h
@@ -263,20 +263,20 @@ public:
   int work_pending (const ACE_Time_Value &max_wait_time =  ACE_Time_Value::zero);
 
   /**
-   * This event loop driver blocks for up to <max_wait_time> before
+   * This event loop driver blocks for up to @a max_wait_time before
    * returning.  It will return earlier if events occur.  Note that
-   * <max_wait_time> can be 0, in which case this method blocks
+   * @a max_wait_time can be 0, in which case this method blocks
    * indefinitely until events occur.
    *
-   * <max_wait_time> is decremented to reflect how much time this call
+   * @a max_wait_time is decremented to reflect how much time this call
    * took.  For instance, if a time value of 3 seconds is passed to
    * handle_events and an event occurs after 2 seconds,
-   * <max_wait_time> will equal 1 second.  This can be used if an
+   * @a max_wait_time will equal 1 second.  This can be used if an
    * application wishes to handle events for some fixed amount of
    * time.
    *
    * Returns the total number of timers and I/O ACE_Event_Handlers
-   * that were dispatched, 0 if the <max_wait_time> elapsed without
+   * that were dispatched, 0 if the @a max_wait_time elapsed without
    * dispatching any handlers, or -1 if an error occurs.
    *
    * The only difference between <alertable_handle_events> and
@@ -289,7 +289,7 @@ public:
 
   /**
    * This method is just like the one above, except the
-   * <max_wait_time> value is a reference and can therefore never be
+   * @a max_wait_time value is a reference and can therefore never be
    * NULL.
    *
    * The only difference between <alertable_handle_events> and
@@ -340,7 +340,7 @@ public:
   /**
    * Register handler for OS events.
    *
-   * Register an <event_handler> that will be notified when
+   * Register an @a event_handler that will be notified when
    * <event_handle> is signaled.  This will call back its
    * <handle_signal> hook method.
    *
@@ -377,7 +377,7 @@ public:
    *
    * Shorthand for calling
    * register_handler(ACE_HANDLE,ACE_Event_Handler*,ACE_Reactor_Mask),
-   * multiple times for the same <event_handler> and <masks> but
+   * multiple times for the same @a event_handler and @a masks but
    * different <handles>.
    */
   int register_handler (const ACE_Handle_Set &handles,
@@ -405,7 +405,7 @@ public:
    *
    * Shorthand for calling
    * register_handler(int,ACE_Event_Handler*,ACE_Sig_Action*,ACE_Event_Handler**,ACE_Sig_Action*)
-   * multiple times for the same <event_handler> and <sig_action> but
+   * multiple times for the same @a event_handler and <sig_action> but
    * different <signals>.
    */
   int register_handler (const ACE_Sig_Set &sigset,
@@ -413,25 +413,25 @@ public:
                         ACE_Sig_Action *sig_action = 0);
 
   /**
-   * Remove <masks> from @a handle registration.
+   * Remove @a masks from @a handle registration.
    *
-   * For I/O handles, <masks> are removed from the Reactor.  Unless
-   * <masks> includes <ACE_Event_Handler::DONT_CALL>,
-   * ACE_Event_Handler::handle_close() will be called with the <masks>
+   * For I/O handles, @a masks are removed from the Reactor.  Unless
+   * @a masks includes ACE_Event_Handler::DONT_CALL,
+   * ACE_Event_Handler::handle_close() will be called with the @a masks
    * that have been removed.  If all masks have been removed,
    * ACE_Event_Handler::remove_reference() will be called.
    *
    * For OS handles, the @a handle is removed from the Reactor.  Unless
-   * <masks> includes <ACE_Event_Handler::DONT_CALL>,
+   * @a masks includes ACE_Event_Handler::DONT_CALL,
    * ACE_Event_Handler::handle_close() will be called with
-   * <ACE_Event_Handler::NULL_MASK>.
+   * ACE_Event_Handler::NULL_MASK.
    * ACE_Event_Handler::remove_reference() will also be called.
    */
   int remove_handler (ACE_HANDLE handle,
                       ACE_Reactor_Mask masks);
 
   /**
-   * Remove <masks> from <event_handler> registration.
+   * Remove @a masks from @a event_handler registration.
    *
    * Same as remove_handler(ACE_HANDLE,ACE_Reactor_Mask), except
    * @a handle comes from ACE_Event_Handler::get_handle().
@@ -440,10 +440,10 @@ public:
                       ACE_Reactor_Mask masks);
 
   /**
-   * Remove <masks> from multiple <handle> registrations.
+   * Remove @a masks from multiple <handle> registrations.
    *
    * Shorthand for calling remove_handler(ACE_HANDLE,ACE_Reactor_Mask)
-   * multiple times for the same <masks> but different <handles>.
+   * multiple times for the same @a masks but different @a handles.
    */
   int remove_handler (const ACE_Handle_Set &handles,
                       ACE_Reactor_Mask masks);
@@ -538,7 +538,7 @@ public:
    *
    * Schedule a timer event that will expire after an <delay> amount
    * of time.  The return value of this method, a timer_id value,
-   * uniquely identifies the <event_handler> in the ACE_Reactor's
+   * uniquely identifies the @a event_handler in the ACE_Reactor's
    * internal list of timers.  This timer_id value can be used to
    * cancel the timer with the cancel_timer() call.
    *
@@ -601,7 +601,7 @@ public:
    * Cancel all timers associated with event handler.
    *
    * Shorthand for calling cancel_timer(long,const void **,int)
-   * multiple times for all timer associated with <event_handler>.
+   * multiple times for all timer associated with @a event_handler.
    *
    * ACE_Event_Handler::handle_close() will be called with
    * <ACE_Event_Handler::TIMER_MASK> only once irrespective of the
@@ -638,7 +638,7 @@ public:
   int schedule_wakeup (ACE_HANDLE handle,
                        ACE_Reactor_Mask masks_to_be_added);
 
-  /// Clear @a masks_to_be_cleared from the <event_handler>'s entry.
+  /// Clear @a masks_to_be_cleared from the @a 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
@@ -751,7 +751,7 @@ public:
 
   /**
    * Check to see if @a signum is associated with a valid Event_Handler
-   * bound to a signal.  Return the <event_handler> associated with
+   * bound to a signal.  Return the @a event_handler associated with
    * this <handler> if @a event_handler != 0.
    */
   int handler (int signum,
@@ -805,7 +805,7 @@ public:
                 int ops);
 
   // = Low-level ready_set mask manipulation methods.
-  /// GET/SET/ADD/CLR the ready "bit" bound with the <event_handler>
+  /// GET/SET/ADD/CLR the ready "bit" bound with the @a event_handler
   /// and @a mask.
   int ready_ops (ACE_Event_Handler *event_handler,
                  ACE_Reactor_Mask mask,
diff --git a/ACE/ace/Reactor_Impl.h b/ACE/ace/Reactor_Impl.h
index b60e26273ae..390737b8b07 100644
--- a/ACE/ace/Reactor_Impl.h
+++ b/ACE/ace/Reactor_Impl.h
@@ -167,20 +167,20 @@ public:
   virtual int work_pending (const ACE_Time_Value &max_wait_time =  ACE_Time_Value::zero)  = 0;
 
   /**
-   * This event loop driver blocks for up to <max_wait_time> before
+   * This event loop driver blocks for up to @a max_wait_time before
    * returning.  It will return earlier if events occur.  Note that
-   * <max_wait_time> can be 0, in which case this method blocks
+   * @a max_wait_time can be 0, in which case this method blocks
    * indefinitely until events occur.
    *
-   * <max_wait_time> is decremented to reflect how much time this call
+   * @a max_wait_time is decremented to reflect how much time this call
    * took.  For instance, if a time value of 3 seconds is passed to
    * handle_events and an event occurs after 2 seconds,
-   * <max_wait_time> will equal 1 second.  This can be used if an
+   * @a max_wait_time will equal 1 second.  This can be used if an
    * application wishes to handle events for some fixed amount of
    * time.
    *
    * Returns the total number of ACE_Event_Handlers that were
-   * dispatched, 0 if the <max_wait_time> elapsed without dispatching
+   * dispatched, 0 if the @a max_wait_time elapsed without dispatching
    * any handlers, or -1 if an error occurs.
    *
    * The only difference between <alertable_handle_events> and
@@ -193,7 +193,7 @@ public:
 
   /**
    * This method is just like the one above, except the
-   * <max_wait_time> value is a reference and can therefore never be
+   * @a max_wait_time value is a reference and can therefore never be
    * NULL.
    *
    * The only difference between <alertable_handle_events> and
@@ -223,11 +223,11 @@ public:
   // = Register and remove Handlers.
 
   /// Register @a event_handler with @a mask.  The I/O handle will always
-  /// come from <get_handle> on the <event_handler>.
+  /// come from <get_handle> on the @a event_handler.
   virtual int register_handler (ACE_Event_Handler *event_handler,
                                 ACE_Reactor_Mask mask) = 0;
 
-  /// Register <event_handler> with @a mask.  The I/O handle is provided
+  /// Register @a 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,
@@ -243,7 +243,7 @@ public:
   // have restricted this method to Win32 only.
 
   /**
-   * Register an <event_handler> that will be notified when
+   * Register an @a event_handler that will be notified when
    * <event_handle> is signaled.  Since no event mask is passed
    * through this interface, it is assumed that the <event_handle>
    * being passed in is an event handle and not an I/O handle.
@@ -254,16 +254,16 @@ public:
 #endif /* ACE_WIN32 */
 
   /**
-   * Register an <event_handler> that will be notified when
+   * Register an @a event_handler that will be notified when
    * <event_handle> is signaled.  @a mask specifies the network events
-   * that the <event_handler> is interested in.
+   * that the @a event_handler is interested in.
    */
   virtual int register_handler (ACE_HANDLE event_handle,
                                 ACE_HANDLE io_handle,
                                 ACE_Event_Handler *event_handler,
                                 ACE_Reactor_Mask mask) = 0;
 
-  /// Register <event_handler> with all the <handles> in the <Handle_Set>.
+  /// Register @a event_handler with all the <handles> in the <Handle_Set>.
   virtual int register_handler (const ACE_Handle_Set &handles,
                                 ACE_Event_Handler *event_handler,
                                 ACE_Reactor_Mask mask) = 0;
@@ -286,16 +286,16 @@ public:
                                 ACE_Sig_Action *new_disp = 0) = 0;
 
   /**
-   * Removes <event_handler>.  Note that the I/O handle will be
-   * obtained using <get_handle> method of <event_handler> .  If
-   * @a mask == <ACE_Event_Handler::DONT_CALL> then the <handle_close>
-   * method of the <event_handler> is not invoked.
+   * Removes @a event_handler.  Note that the I/O handle will be
+   * obtained using <get_handle> method of @a event_handler .  If
+   * @a mask == ACE_Event_Handler::DONT_CALL then the <handle_close>
+   * method of the @a event_handler is not invoked.
    */
   virtual int remove_handler (ACE_Event_Handler *event_handler,
                               ACE_Reactor_Mask mask) = 0;
 
   /**
-   * Removes <handle>.  If @a 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.
    */
@@ -304,7 +304,7 @@ public:
 
   /**
    * Removes all handles in <handle_set>.  If @a mask ==
-   * <ACE_Event_Handler::DONT_CALL> then the <handle_close> method of
+   * ACE_Event_Handler::DONT_CALL then the <handle_close> method of
    * the associated <event_handler>s is not invoked.
    */
   virtual int remove_handler (const ACE_Handle_Set &handle_set,
@@ -326,7 +326,7 @@ public:
 
   // = Suspend and resume Handlers.
 
-  /// Suspend <event_handler> temporarily.  Use
+  /// Suspend @a event_handler temporarily.  Use
   /// <ACE_Event_Handler::get_handle> to get the handle.
   virtual int suspend_handler (ACE_Event_Handler *event_handler) = 0;
 
@@ -339,7 +339,7 @@ public:
   /// Suspend all <handles> temporarily.
   virtual int suspend_handlers (void) = 0;
 
-  /// Resume <event_handler>. Use <ACE_Event_Handler::get_handle> to
+  /// Resume @a event_handler. Use <ACE_Event_Handler::get_handle> to
   /// get the handle.
   virtual int resume_handler (ACE_Event_Handler *event_handler) = 0;
 
@@ -398,7 +398,7 @@ public:
                                     const ACE_Time_Value &interval) = 0;
 
   /// Cancel all Event_Handlers that match the address of
-  /// <event_handler>.  Returns number of handlers cancelled.
+  /// @a event_handler.  Returns number of handlers cancelled.
   virtual int cancel_timer (ACE_Event_Handler *event_handler,
                             int dont_call_handle_close = 1) = 0;
 
@@ -417,8 +417,8 @@ public:
 
   // = High-level Event_Handler scheduling operations
 
-  /// Add @a masks_to_be_added to the <event_handler>'s entry.
-  /// <event_handler> must already have been registered.
+  /// Add @a masks_to_be_added to the @a event_handler's entry.
+  /// @a event_handler must already have been registered.
   virtual int schedule_wakeup (ACE_Event_Handler *event_handler,
                                ACE_Reactor_Mask masks_to_be_added) = 0;
 
@@ -438,7 +438,7 @@ public:
   // = Notification methods.
 
   /**
-   * Notify <event_handler> of @a mask event.  The ACE_Time_Value
+   * Notify @a 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,8 +483,8 @@ public:
 
   /**
    * Check to see if <handle> is associated with a valid Event_Handler
-   * bound to @a mask.  Return the <event_handler> associated with this
-   * <handler> if <event_handler> != 0.
+   * bound to @a mask.  Return the @a event_handler associated with this
+   * <handler> if @a event_handler != 0.
    */
   virtual int handler (ACE_HANDLE handle,
                        ACE_Reactor_Mask mask,
@@ -492,8 +492,8 @@ public:
 
   /**
    * Check to see if @a signum is associated with a valid Event_Handler
-   * bound to a signal.  Return the <event_handler> associated with
-   * this <handler> if <event_handler> != 0.
+   * bound to a signal.  Return the @a event_handler associated with
+   * this <handler> if @a event_handler != 0.
    */
   virtual int handler (int signum,
                        ACE_Event_Handler ** = 0) = 0;
@@ -533,7 +533,7 @@ public:
   // = Low-level wait_set mask manipulation methods.
 
   /// GET/SET/ADD/CLR the dispatch mask "bit" bound with the
-  /// <event_handler> and @a mask.
+  /// @a event_handler and @a mask.
   virtual int mask_ops (ACE_Event_Handler *event_handler,
                         ACE_Reactor_Mask mask,
                         int ops) = 0;
@@ -545,7 +545,7 @@ public:
                         int ops) = 0;
 
   // = Low-level ready_set mask manipulation methods.
-  /// GET/SET/ADD/CLR the ready "bit" bound with the <event_handler>
+  /// GET/SET/ADD/CLR the ready "bit" bound with the @a event_handler
   /// and @a mask.
   virtual int ready_ops (ACE_Event_Handler *event_handler,
                          ACE_Reactor_Mask mask,
diff --git a/ACE/ace/SOCK_Connector.h b/ACE/ace/SOCK_Connector.h
index a829634f6fc..3873d7c95d4 100644
--- a/ACE/ace/SOCK_Connector.h
+++ b/ACE/ace/SOCK_Connector.h
@@ -83,10 +83,6 @@ public:
    * @param perms       Ignored.
    * @param protocol    (optional) If value is 0, default SOCK_STREAM
    *                    protocol is selected by kernel (typically TCP).
-   *
-   * @return            Returns 0 if the connection succeeds. If it fails,
-   *                    -1 is returned and errno contains a specific error
-   *                    code.
    */
   ACE_SOCK_Connector (ACE_SOCK_Stream &new_stream,
                       const ACE_Addr &remote_sap,
@@ -135,10 +131,6 @@ public:
    *                    cleaned up yet.
    * @param flags       Ignored.
    * @param perms       Ignored.
-   *
-   * @return            Returns 0 if the connection succeeds. If it fails,
-   *                    -1 is returned and errno contains a specific error
-   *                    code.
    */
   ACE_SOCK_Connector (ACE_SOCK_Stream &new_stream,
                       const ACE_Addr &remote_sap,
diff --git a/ACE/ace/WFMO_Reactor.h b/ACE/ace/WFMO_Reactor.h
index dca4bb0cf19..a31950ff03f 100644
--- a/ACE/ace/WFMO_Reactor.h
+++ b/ACE/ace/WFMO_Reactor.h
@@ -724,22 +724,22 @@ public:
   virtual int work_pending (const ACE_Time_Value &max_wait_time =  ACE_Time_Value::zero);
 
   /**
-   * This event loop driver blocks for up to <max_wait_time> before
+   * This event loop driver blocks for up to @a max_wait_time before
    * returning.  It will return earlier if timer events, I/O events,
-   * or signal events occur.  Note that <max_wait_time> can be 0, in
+   * or signal events occur.  Note that @a max_wait_time can be 0, in
    * which case this method blocks indefinitely until events occur.
    *
-   * <max_wait_time> is decremented to reflect how much time this call
+   * @a max_wait_time is decremented to reflect how much time this call
    * took.  For instance, if a time value of 3 seconds is passed to
    * handle_events and an event occurs after 2 seconds,
-   * <max_wait_time> will equal 1 second.  This can be used if an
+   * @a max_wait_time will equal 1 second.  This can be used if an
    * application wishes to handle events for some fixed amount of
    * time.
    *
    * <WaitForMultipleObjects> is used as the demultiplexing call
    *
    * Returns the total number of I/O and timer ACE_Event_Handlers
-   * that were dispatched, 0 if the <max_wait_time> elapsed without
+   * that were dispatched, 0 if the @a max_wait_time elapsed without
    * dispatching any handlers, or -1 if an error occurs.
    *
    * The only difference between <alertable_handle_events> and
@@ -751,7 +751,7 @@ public:
 
   /**
    * This method is just like the one above, except the
-   * <max_wait_time> value is a reference and can therefore never be
+   * @a max_wait_time value is a reference and can therefore never be
    * NULL.
    *
    * The only difference between <alertable_handle_events> and
@@ -853,7 +853,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 @a mask ==
-   * <ACE_Event_Handler::DONT_CALL> then the <handle_close> method of
+   * 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>
    */
@@ -862,7 +862,7 @@ public:
 
   /**
    * Removes <handle> from the <ACE_WFMO_Reactor>.  If @a mask ==
-   * <ACE_Event_Handler::DONT_CALL> then the <handle_close> method of
+   * 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>
    *
@@ -1136,7 +1136,7 @@ public:
   // = Low-level wait_set mask manipulation methods.
 
   /**
-   * Modify <masks> of the <event_handler>'s entry in WFMO_Reactor
+   * Modify @a masks of the <event_handler>'s entry in WFMO_Reactor
    * depending upon <operation>.  <event_handler> must already have
    * been registered with WFMO_Reactor.
    */
@@ -1145,7 +1145,7 @@ public:
                         int operation);
 
   /**
-   * Modify <masks> of the <handle>'s entry in WFMO_Reactor depending
+   * Modify @a masks of the <handle>'s entry in WFMO_Reactor depending
    * upon <operation>.  <handle> must already have been registered
    * with WFMO_Reactor.
    */
diff --git a/ACE/ace/config-macosx-tiger.h b/ACE/ace/config-macosx-tiger.h
index bfa4524cda1..5655e9d0675 100644
--- a/ACE/ace/config-macosx-tiger.h
+++ b/ACE/ace/config-macosx-tiger.h
@@ -125,9 +125,6 @@
 // Compiler/platform correctly calls init()/fini() for shared libraries.
 #define ACE_HAS_AUTOMATIC_INIT_FINI
 
-// Explicit dynamic linking permits "lazy" symbol resolution
-//#define ACE_HAS_RTLD_LAZY_V
-
 // platform supports POSIX O_NONBLOCK semantics
 #define ACE_HAS_POSIX_NONBLOCK