*** empty log message ***

166 files changed, 1001 insertions, 1031 deletions

diff --git a/ChangeLog-98a b/ChangeLog-98a
index 56c715b2577..1c1af10b5a3 100644
--- a/ChangeLog-98a
+++ b/ChangeLog-98a
@@ -1,3 +1,16 @@
+Sun Dec 21 12:39:38 1997  Douglas C. Schmidt  <schmidt@flamenco.cs.wustl.edu>
+
+	* ace: Changed all ACE class documentation so that it puts the
+ 	  =TITLE and =DESCRIPTION comments *after* the opening '{' rather
+ 	  than before.  I did this since (1) it makes emacs C++ mode
+ 	  happier and (2) it makes Rational Rose reverse-engineering tool
+ 	  happier too.  Thanks to Thomas Jordan
+ 	  <Thomas_Jordan@deluxedata.com> for suggesting this.
+
+	* ace/LOCK_SOCK_Acceptor.h: The accept() method of class
+ 	  ACE_LOCK_SOCK_Acceptor is no longer a virtual.  I don't know why
+ 	  this was made virtual in the first place, but it was a mistake.
+
 Sat Dec 20 11:05:45 1997  Douglas C. Schmidt  <schmidt@flamenco.cs.wustl.edu>
 
 	* tests/test_config.h (ACE_INIT_LOG): Added (%P|%t) to an
diff --git a/README b/README
index e4c93ea30c2..70eff58ab4b 100644
--- a/README
+++ b/README
@@ -495,6 +495,7 @@ Lori Anderson <lori@probita.com>
 Erik Margraf <erik@asgard.gud.siemens.co.at>
 Bryan Doerr <Bryan.S.Doerr@boeing.com>
 Adam Miller <adam@royalblueny.com>
+Thomas Jordan <Thomas_Jordan@deluxedata.com>
 
 I would particularly like to thank Paul Stephenson, who worked with me
 at Ericsson and is now at ObjectSpace.  Paul devised the recursive
diff --git a/TAO/tao/Makefile b/TAO/tao/Makefile
index 7f9efca16c5..a54b9e1e17c 100644
--- a/TAO/tao/Makefile
+++ b/TAO/tao/Makefile
@@ -9,7 +9,6 @@ LIBNAME  = libTAO
 LIB      = $(LIBNAME).a
 SHLIB    = $(LIBNAME).$(SOEXT)
 
-# @@ Need to clean up this makefile...it's a MESS!!!! (cjc)
 # These are components that are only headers and must be installed
 CORBA_HDRS = orb sequence stub orbconf objtable optable $(CORBA_SRCS)
 CORBA_SRCS = any corbacom except nvlist object orbobj poa \
diff --git a/ace/ACE.h b/ace/ACE.h
index 50e50c1bc5f..1846356c384 100644
--- a/ace/ACE.h
+++ b/ace/ACE.h
@@ -28,6 +28,7 @@ class ACE_Event_Handler;
 class ACE_INET_Addr;
 
 class ACE_Export ACE
+{
   // = TITLE
   //     Contains value added ACE methods that extend the behavior
   //     of the UNIX and Win32 OS calls.
@@ -37,10 +38,9 @@ class ACE_Export ACE
   //     single place in order to manage the namespace better.  These
   //     methods are put here rather than in ACE_OS in order to
   //     separate concerns.
-{
+public:
   ACE_CLASS_IS_NAMESPACE (ACE);
   
-public:
   // = ACE version information.
   static u_int major_version (void);
   // E.g., the "4" in ACE 4.3.19.
diff --git a/ace/ARGV.h b/ace/ARGV.h
index e148159af2d..d64263ec960 100644
--- a/ace/ARGV.h
+++ b/ace/ARGV.h
@@ -22,11 +22,11 @@
 #include "ace/Containers.h"
 
 class ACE_Export ACE_ARGV
+{
   // = TITLE
   //     Transforms a string <buf> into an <argv> style vector of
   //     strings or an <argv> style vector of string <buf>, performing
   //     environment variable substitutions if necessary.
-{
 public:
   // = Initialization and termination.
   ACE_ARGV (const char buf[], int substitute_env_args = 1);
diff --git a/ace/Acceptor.h b/ace/Acceptor.h
index 123aead77a8..d9498b5340a 100644
--- a/ace/Acceptor.h
+++ b/ace/Acceptor.h
@@ -24,6 +24,7 @@
 
 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
 class ACE_Acceptor : public ACE_Service_Object
+{
   // = TITLE
   //     Abstract factory for creating a service handler
   //     (SVC_HANDLER), accepting into the SVC_HANDLER, and
@@ -45,7 +46,6 @@ class ACE_Acceptor : public ACE_Service_Object
   //     establishment, and service activation strategies.  These
   //     strategies can be overridden by subclasses individually or as
   //     a group.
-{
 public:
   // = Initialization and termination methods.
   ACE_Acceptor (ACE_Reactor * = 0);
@@ -161,6 +161,7 @@ private:
 
 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
 class ACE_Strategy_Acceptor : public ACE_Acceptor <SVC_HANDLER, ACE_PEER_ACCEPTOR_2>
+{
   // = TITLE
   //     Abstract factory for creating a service handler
   //     (SVC_HANDLER), accepting into the SVC_HANDLER, and activating
@@ -173,7 +174,6 @@ class ACE_Strategy_Acceptor : public ACE_Acceptor <SVC_HANDLER, ACE_PEER_ACCEPTO
   //     passively accepting a new connection from a client into the
   //     SVC_HANDLER, and (3) activating the SVC_HANDLER with a
   //     particular concurrency mechanism.
-{
 public:
   // = Initialization and termination methods.
   ACE_Strategy_Acceptor (const char service_name[] = 0,
@@ -336,6 +336,7 @@ protected:
 
 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
 class ACE_Oneshot_Acceptor : public ACE_Service_Object
+{
   // = TITLE
   //     Generic factory for passively connecting clients and creating
   //     exactly one service handler (SVC_HANDLER).
@@ -346,7 +347,6 @@ class ACE_Oneshot_Acceptor : public ACE_Service_Object
   //     user supplies the SVC_HANDLER) or an Accept_Strategy (since
   //     this class only accepts one connection and then removes all
   //     traces (e.g., from the ACE_Reactor).
-{
 public:
   // = Initialization and termination methods.
   ACE_Oneshot_Acceptor (void);
diff --git a/ace/Activation_Queue.h b/ace/Activation_Queue.h
index 17fbc3fbc5a..547ad62a4bd 100644
--- a/ace/Activation_Queue.h
+++ b/ace/Activation_Queue.h
@@ -23,6 +23,7 @@
 #include "ace/Method_Object.h"
 
 class ACE_Export ACE_Activation_Queue
+{
   // = TITLE
   //     Reifies a method into an object.  Subclasses typically
   //     represent necessary state and behavior.
@@ -30,7 +31,6 @@ class ACE_Export ACE_Activation_Queue
   // = DESCRIPTION
   //     A <Method_Object> is inserted in the <Activation_Queue>, where
   //     it is subsequently removed by the <Scheduler> and invoked.
-{
 public:
   // = Initialization and termination methods.
   ACE_Activation_Queue (ACE_Message_Queue<ACE_SYNCH> *new_queue = 0);
diff --git a/ace/Addr.h b/ace/Addr.h
index 732910527e6..0d96f65cd3d 100644
--- a/ace/Addr.h
+++ b/ace/Addr.h
@@ -20,10 +20,10 @@
 #include "ace/ACE.h"
 
 class ACE_Export ACE_Addr 
+{
   //  = TITLE
   //     Defines the base class for the "address family independent"
   //     address format.
-{
 public:
   // = Initialization method.
 
diff --git a/ace/Array.h b/ace/Array.h
index aaca6e1659d..b39d2dc37ed 100644
--- a/ace/Array.h
+++ b/ace/Array.h
@@ -25,6 +25,8 @@ template <class T> class ACE_Array_Iterator;
 template <class T>
 class ACE_Array
 {
+  // = TITLE
+  //     Implement a dynamic array class.
 public:
   // Define a "trait"
   typedef T TYPE;
@@ -112,13 +114,15 @@ private:
 
 template <class T>
 class ACE_Array_Iterator
-  // = TITLE
-  //     Implement an iterator over an ACE_Array.  This iterator is
-  //     safe in the face of array element deletions.  But it is NOT
-  //     safe if the array is resized (via the ACE_Array assignment
-  //     operator) during iteration.  That would be very odd, and
-  //     dangerous.
 {
+  // = TITLE
+  //     Implement an iterator over an ACE_Array.
+  //
+  // = DESCRIPTION
+  //     This iterator is safe in the face of array element deletions.
+  //     But it is NOT safe if the array is resized (via the ACE_Array
+  //     assignment operator) during iteration.  That would be very
+  //     odd, and dangerous.
 public:
   // = Initialization method.
   ACE_Array_Iterator (ACE_Array<T> &);
diff --git a/ace/Asynch_Acceptor.h b/ace/Asynch_Acceptor.h
index fe6813ccb75..8dc06e20b2e 100644
--- a/ace/Asynch_Acceptor.h
+++ b/ace/Asynch_Acceptor.h
@@ -30,16 +30,15 @@ class ACE_INET_Addr;
 
 template <class HANDLER>
 class ACE_Asynch_Acceptor : public ACE_Handler 
-  //     
+{
   // = TITLE
-  //
   //     This class is an example of the Acceptor Pattern.  This class
   //     will accept new connections and create new HANDLER to handle
   //     the new connections.
-  // 
+  //
   // = DESCRIPTION
-  //     
-{
+  //     Unlike the <ACE_Acceptor>, however, this class is designed to
+  //     be used asynchronously.  
 public:
   ACE_Asynch_Acceptor (void);
   // A do nothing constructor.
diff --git a/ace/Asynch_IO.h b/ace/Asynch_IO.h
index ad9c0b80b9f..81f96c591af 100644
--- a/ace/Asynch_IO.h
+++ b/ace/Asynch_IO.h
@@ -9,6 +9,13 @@
 // = FILENAME
 //    Asynch_IO.h
 //
+// = DESCRIPTION
+//    This only works on Win32 platforms. 
+//
+//    The implementation of <ACE_Asynch_Transmit_File> and
+//    <ACE_Asynch_Accept> are only supported if ACE_HAS_WINSOCK2 is
+//    defined or you are on WinNT 4.0 or higher
+//
 // = AUTHOR
 //    Irfan Pyarali (irfan@cs.wustl.edu)
 //    Tim Harrison (harrison@cs.wustl.edu)
@@ -21,11 +28,6 @@
 #include "ace/OS.h"
 
 #if defined (ACE_WIN32)
-// This only works on Win32 platforms. 
-//
-// The implementation of ACE_Asynch_Transmit_File and
-// ACE_Asynch_Accept are only supported if ACE_HAS_WINSOCK2 is defined
-// or you are on WinNT 4.0 or higher
 
 // Forward declarations
 class ACE_Proactor;
@@ -34,27 +36,23 @@ class ACE_Message_Block;
 class ACE_INET_Addr;
 
 class ACE_Export ACE_Asynch_Result : protected OVERLAPPED
-  //     
+{
   // = TITLE
-  //
   //     An abstract class which adds information to the OVERLAPPED
   //     structure to make it more useful.
   // 
   // = DESCRIPTION
-  //     
   //     An abstract base class from which you can obtain some basic
   //     information like the number of bytes transferred, the ACT
   //     associated with the asynchronous operation, indication of
   //     success or failure, etc.  Subclasses may want to store more
   //     information that is particular to the asynchronous operation
   //     it represents.
-{
-
+public:
   // Proactor is the only class which is allowed to call the
   // <complete> method.
   friend class ACE_Proactor;
 
-public:
   u_long bytes_transferred (void) const;
   // Number of bytes transferred by the operation.
   
@@ -120,21 +118,14 @@ protected:
 // ************************************************************
 
 class ACE_Export ACE_Asynch_Operation
-  //     
+{
   // = TITLE
-  //     
   //     This is a base class for all asynch operations.
   //
   // = DESCRIPTION
-  //     
   //     There are some attributes and functionality which is common
   //     to all asychronous operations.  This abstract class will
   //     factor out this code.
-{
-protected:
-  ACE_Asynch_Operation (void);
-  // A do nothing constructor.
-  
 public:
   int open (ACE_Handler &handler,
 	    ACE_HANDLE handle = ACE_INVALID_HANDLE,
@@ -151,8 +142,11 @@ public:
   // operations issued by other threads.
 
 protected:
-  // Proactor that this Asynch IO will be registered with
+  ACE_Asynch_Operation (void);
+  // A no-op constructor.
+  
   ACE_Proactor *proactor_;
+  // Proactor that this Asynch IO will be registered with.
   
   ACE_Handler *handler_;
   // Handler that will receive the callback.
@@ -161,23 +155,18 @@ protected:
   // I/O handle used for reading.
 };
 
-// ************************************************************
-
 class ACE_Export ACE_Asynch_Read_Stream : public ACE_Asynch_Operation
-  //     
+{
   // = TITLE
-  //     
   //     This class is a factory for starting off asynchronous reads
   //     on a stream.
   //
   // = DESCRIPTION
-  //     
   //     Once <open> is called, multiple asynchronous <read>s can
   //     started using this class.  An ACE_Asynch_Read_Stream::Result
   //     will be passed back to the <handler> when the asynchronous
   //     reads completes through the <ACE_Handler::handle_read_stream>
   //     callback.
-{
 public:
   class Result;
   // Forward declaration of the Result class.
@@ -198,18 +187,15 @@ protected:
 
 public:
   class ACE_Export Result : public ACE_Asynch_Result
-    //     
+  {
     // = TITLE
-    //     
     //     This is that class which will be passed back to the
     //     <handler> when the asynchronous read completes.  
     //
     // = DESCRIPTION
-    //     
     //     This class has all the information necessary for the
     //     <handler> to uniquiely identify the completion of the
     //     asynchronous read. 
-  {
     friend class ACE_Asynch_Read_Stream;
     // The factory has special privileges.
     
@@ -255,23 +241,18 @@ public:
   };  
 };
 
-// ************************************************************
-
 class ACE_Export ACE_Asynch_Write_Stream : public ACE_Asynch_Operation
-  //     
+{
   // = TITLE
-  //     
   //     This class is a factory for starting off asynchronous writes
   //     on a stream.
   //
   // = DESCRIPTION
-  //     
   //     Once <open> is called, multiple asynchronous <writes>s can
   //     started using this class.  A ACE_Asynch_Write_Stream::Result
   //     will be passed back to the <handler> when the asynchronous
   //     write completes through the
   //     <ACE_Handler::handle_write_stream> callback.
-{
 public:
   class Result;
   // Forward declaration of the Result class.
@@ -292,22 +273,19 @@ protected:
 
 public:
   class ACE_Export Result : public ACE_Asynch_Result
-    //     
+  {
     // = TITLE
-    //     
     //     This is that class which will be passed back to the
     //     <handler> when the asynchronous write completes.  
     //
     // = DESCRIPTION
-    //     
     //     This class has all the information necessary for the
     //     <handler> to uniquiely identify the completion of the
     //     asynchronous write. 
-  {
+  public:
     friend class ACE_Asynch_Write_Stream;
     // The factory has special privileges.
 
-  public:
     u_long bytes_to_write (void) const;
     // The number of bytes which were requested at the start of the
     // asynchronous write.
@@ -350,17 +328,13 @@ public:
   };  
 };
 
-// ************************************************************
-
 class ACE_Export ACE_Asynch_Read_File : public ACE_Asynch_Read_Stream
-  //     
+{
   // = TITLE
-  //     
   //     This class is a factory for starting off asynchronous reads
   //     on a file.
   //
   // = DESCRIPTION
-  //     
   //     Once <open> is called, multiple asynchronous <read>s can
   //     started using this class.  A ACE_Asynch_Read_File::Result
   //     will be passed back to the <handler> when the asynchronous
@@ -369,7 +343,6 @@ class ACE_Export ACE_Asynch_Read_File : public ACE_Asynch_Read_Stream
   // 
   //     This class differs slightly from ACE_Asynch_Read_Stream as it
   //     allows the user to specify an offset for the read. 
-{
 public:
   int read (ACE_Message_Block &message_block,
 	    u_long bytes_to_read,
@@ -382,14 +355,12 @@ public:
 
 public:
   class ACE_Export Result : public ACE_Asynch_Read_Stream::Result
-    //     
+  {
     // = TITLE
-    //     
     //     This is that class which will be passed back to the
     //     <handler> when the asynchronous read completes.  
     //
     // = DESCRIPTION
-    //     
     //     This class has all the information necessary for the
     //     <handler> to uniquiely identify the completion of the
     //     asynchronous read. 
@@ -400,7 +371,7 @@ public:
     //     <ACE_Handler::handle_read_stream>.  No additional state is
     //     required by this class as ACE_Asynch_Result can store the
     //     <offset>. 
-  {
+
     friend class ACE_Asynch_Read_File;
     // The factory has special privileges.
     
@@ -427,17 +398,14 @@ public:
   };  
 };
 
-// ************************************************************
-
 class ACE_Export ACE_Asynch_Write_File : public ACE_Asynch_Write_Stream
-  //     
+{
+public:
   // = TITLE
-  //     
   //     This class is a factory for starting off asynchronous writes
   //     on a file.
   //
   // = DESCRIPTION
-  //     
   //     Once <open> is called, multiple asynchronous <write>s can
   //     started using this class.  A ACE_Asynch_Write_File::Result
   //     will be passed back to the <handler> when the asynchronous
@@ -446,8 +414,6 @@ class ACE_Export ACE_Asynch_Write_File : public ACE_Asynch_Write_Stream
   // 
   //     This class differs slightly from ACE_Asynch_Write_Stream as
   //     it allows the user to specify an offset for the write.
-{
-public:
   int write (ACE_Message_Block &message_block,
 	     u_long bytes_to_write,
 	     u_long offset = 0,
@@ -459,14 +425,12 @@ public:
 
 public:
   class ACE_Export Result : public ACE_Asynch_Write_Stream::Result
-    //     
+  {
     // = TITLE
-    //     
     //     This is that class which will be passed back to the
     //     <handler> when the asynchronous write completes.
     //
     // = DESCRIPTION
-    //     
     //     This class has all the information necessary for the
     //     <handler> to uniquiely identify the completion of the
     //     asynchronous write.
@@ -477,7 +441,7 @@ public:
     //     of <ACE_Handler::handle_write_stream>.  No additional state
     //     is required by this class as ACE_Asynch_Result can store
     //     the <offset>.
-  {
+
     friend class ACE_Asynch_Write_File;
     // The factory has special privileges.
     
@@ -504,23 +468,18 @@ public:
   };  
 };
 
-// ************************************************************
-
 class ACE_Export ACE_Asynch_Accept : public ACE_Asynch_Operation
-  //     
+{
   // = TITLE
-  //     
   //     This class is a factory for starting off asynchronous accepts
   //     on a listen handle.
   //
   // = DESCRIPTION
-  //     
   //     Once <open> is called, multiple asynchronous <accept>s can
   //     started using this class.  A ACE_Asynch_Accept::Result will
   //     be passed back to the <handler> when the asynchronous accept
   //     completes through the <ACE_Handler::handle_accept>
   //     callback.
-{
 public:
   ACE_Asynch_Accept (void);
   // A do nothing constructor.
@@ -541,22 +500,19 @@ public:
   
 public:
   class ACE_Export Result : public ACE_Asynch_Result
-    //     
+  {
     // = TITLE
-    //     
     //     This is that class which will be passed back to the
     //     <handler> when the asynchronous accept completes.  
     //
     // = DESCRIPTION
-    //     
     //     This class has all the information necessary for the
     //     <handler> to uniquiely identify the completion of the
     //     asynchronous accept. 
-  {
+  public:
     friend class ACE_Asynch_Accept;
     // The factory has special privileges.
     
-  public:
     u_long bytes_to_read (void) const;
     // The number of bytes which were requested at the start of the
     // asynchronous accept.
@@ -605,17 +561,13 @@ public:
   };  
 };
 
-// ************************************************************
-
 class ACE_Export ACE_Asynch_Transmit_File : public ACE_Asynch_Operation
-  //     
+{
   // = TITLE
-  //     
   //     This class is a factory for starting off asynchronous
   //     transmit files on a stream.
   //
   // = DESCRIPTION
-  //     
   //     Once <open> is called, multiple asynchronous <transmit_file>s
   //     can started using this class.  A
   //     ACE_Asynch_Transmit_File::Result will be passed back to the
@@ -628,7 +580,6 @@ class ACE_Export ACE_Asynch_Transmit_File : public ACE_Asynch_Operation
   //     function provides high-performance file data transfer over
   //     network connections.  This function would be of great use in
   //     a Web Server, Image Server, etc.
-{
 public:
   class Header_And_Trailer;
   // Forward declaration.
@@ -656,22 +607,19 @@ public:
 
 public:
   class ACE_Export Result : public ACE_Asynch_Result
-    //     
+  {
     // = TITLE
-    //     
     //     This is that class which will be passed back to the
     //     <handler> when the asynchronous transmit file completes.
     //
     // = DESCRIPTION
-    //     
     //     This class has all the information necessary for the
     //     <handler> to uniquiely identify the completion of the
     //     asynchronous transmit file. 
-  {
+  public:
     friend class ACE_Asynch_Transmit_File;
     // The factory has special privileges.
-    
-  public:
+
     ACE_HANDLE socket (void) const;
     // Socket used for transmitting the file.
 
@@ -739,17 +687,14 @@ public:
   };
   
   class ACE_Export Header_And_Trailer
-    // 
+  {
     // = TITLE
-    //     
     //     The class defines a data structure that contains pointers
     //     to data to send before and after the file data is sent.
     //
     // = DESCRIPTION
-    //     
     //     This class provides a wrapper over TRANSMIT_FILE_BUFFERS
     //     and provided a consistent use of ACE_Message_Blocks.
-  {
   public:
     Header_And_Trailer (ACE_Message_Block *header = 0,
 			u_long header_bytes = 0,
@@ -800,19 +745,14 @@ public:
   };
 };
 
-// ************************************************************
-
 class ACE_Export ACE_Handler
-  //
+{
   // = TITLE
-  //     
   //     This base class defines the interface for receiving the
   //     results of asynchronous operations. 
   //
   // = DESCRIPTION
-  //     
   //     Subclasses of this class will fill in appropriate methods.
-{
 public:
   ACE_Handler (void);
   // A do nothing constructor.
@@ -824,31 +764,31 @@ public:
   // Virtual destruction.
 
   virtual void handle_read_stream (const ACE_Asynch_Read_Stream::Result &result);
-  // This method will be called when an asynchronous read completes on a stream. 
+  // This method will be called when an asynchronous read completes on
+  // a stream.
 
   virtual void handle_write_stream (const ACE_Asynch_Write_Stream::Result &result);
-  // This method will be called when an asynchronous write completes on a strea_m. 
+  // This method will be called when an asynchronous write completes
+  // on a strea_m.
 
   virtual void handle_read_file (const ACE_Asynch_Read_File::Result &result);
-  // This method will be called when an asynchronous read completes on a file. 
+  // This method will be called when an asynchronous read completes on
+  // a file.
 
   virtual void handle_write_file (const ACE_Asynch_Write_File::Result &result);
-  // This method will be called when an asynchronous write completes on a file. 
+  // This method will be called when an asynchronous write completes
+  // on a file.
 
   virtual void handle_accept (const ACE_Asynch_Accept::Result &result);
-  // This method will be called when an asynchronous accept completes. 
+  // This method will be called when an asynchronous accept completes.
 
   virtual void handle_transmit_file (const ACE_Asynch_Transmit_File::Result &result);
-  // This method will be called when an asynchronous transmit file completes. 
-
-  /*
-    virtual void handle_notify (const ACE_Asynch_Notify::Result &result);
-  */
+  // This method will be called when an asynchronous transmit file
+  // completes.
 
   virtual void handle_time_out (const ACE_Time_Value &tv,
 				const void *act = 0);
-  // Called when timer expires.
-  // <tv> was the requested time value and
+  // Called when timer expires.  <tv> was the requested time value and
   // <act> is the ACT passed when scheduling the timer
 
   ACE_Proactor *proactor (void);
@@ -867,13 +807,12 @@ protected:
   // The proactor associated with this handler.
 };
 
-// ************************************************************
-
 // Forward declartion
 template <class HANDLER>
 class ACE_Asynch_Acceptor;
 
 class ACE_Export ACE_Service_Handler : public ACE_Handler
+{
   // = TITLE
   //     This base class defines the interface for the
   //     ACE_Asynch_Acceptor to call into when new connection are
@@ -882,12 +821,11 @@ class ACE_Export ACE_Service_Handler : public ACE_Handler
   // = DESCRIPTION
   //     Subclasses of this class will fill in appropriate methods to
   //     define application specific behavior.
-{
+public:
   friend class ACE_Asynch_Acceptor<ACE_Service_Handler>;
   // The Acceptor is the factory and therefore should have special
   // privileges.
 
-public:
   ACE_Service_Handler (void);
   // A do nothing constructor.
 
diff --git a/ace/Auto_Ptr.h b/ace/Auto_Ptr.h
index 14a4730d622..5ac032a2fb7 100644
--- a/ace/Auto_Ptr.h
+++ b/ace/Auto_Ptr.h
@@ -22,10 +22,10 @@
 
 template <class X>
 class ACE_Auto_Basic_Ptr 
+{
   // = TITLE
   //     Implements the draft C++ standard auto_ptr abstraction.
   //     This class allows one to work on non-object (basic) types
-{
 public:
   // = Initialization and termination methods
   /* explicit */ ACE_Auto_Basic_Ptr (X *p = 0);
@@ -59,9 +59,9 @@ using std::auto_ptr;
 
 template <class X>
 class auto_ptr : public ACE_Auto_Basic_Ptr <X>
+{
   // = TITLE
   //     Implements the draft C++ standard auto_ptr abstraction.
-{
 public:
   // = Initialization and termination methods
   /* explicit */ auto_ptr (X *p = 0);
@@ -73,11 +73,11 @@ public:
 
 template<class X>
 class ACE_Auto_Basic_Array_Ptr 
+{
   // = TITLE
   //     Implements an extension to the draft C++ standard auto_ptr
   //     abstraction.  This class allows one to work on non-object
   //     (basic) types
-{
 public:
   // = Initialization and termination methods.
   /* explicit */ ACE_Auto_Basic_Array_Ptr (X *p = 0);
@@ -103,10 +103,10 @@ protected:
 
 template<class X>
 class ACE_Auto_Array_Ptr : public ACE_Auto_Basic_Array_Ptr<X>
+{
   // = TITLE
   //     Implements an extension to the draft C++ standard auto_ptr
   //     abstraction.
-{
 public:
   // = Initialization and termination methods.
   /* explicit */ ACE_Auto_Array_Ptr (X *p = 0);
diff --git a/ace/CORBA_Handler.h b/ace/CORBA_Handler.h
index 19791d6deac..bd49aa2b1c6 100644
--- a/ace/CORBA_Handler.h
+++ b/ace/CORBA_Handler.h
@@ -31,6 +31,7 @@
 #undef WANT_ORBIX_FDS
 
 class ACE_Export ACE_CORBA_Handler : public ACE_Service_Object
+{
   // = TITLE
   //     Handle CORBA requests in conjunction with ACE.
   //
@@ -38,7 +39,6 @@ class ACE_Export ACE_CORBA_Handler : public ACE_Service_Object
   //     Note, do *NOT* inherit from this class!  Instead, use the
   //     <ACE_MT_CORBA_HAndler> and <ACE_ST_CORBA_Handler> as
   //     Singletons.
-{
 public:
   // = Activation and deactivation methods.
 
@@ -152,10 +152,10 @@ protected:
 #if defined (ACE_HAS_MT_ORBIX) && (ACE_HAS_MT_ORBIX != 0)
 
 class ACE_Export ACE_MT_CORBA_Handler : public ACE_CORBA_Handler, public ACE_CORBA_1 (ThreadFilter)
+{
   // = TITLE
   //     Handle multi-threaded CORBA requests in conjunction with the
   //     <ACE_Reactor>.
-{
 public:
   // = Singleton access point.
   static ACE_CORBA_Handler *instance (void);
diff --git a/ace/CORBA_Ref.h b/ace/CORBA_Ref.h
index f0778ecfaf4..1fff80d896d 100644
--- a/ace/CORBA_Ref.h
+++ b/ace/CORBA_Ref.h
@@ -24,6 +24,7 @@
 
 template <class CORBA_REF>
 class ACE_CORBA_Ref
+{
   // = TITLE
   //    A wrapper for helping with orbix object references.
   //
@@ -33,7 +34,6 @@ class ACE_CORBA_Ref
   //    destructor of ACE_CORBA_Ref perform implicit duplicates and
   //    releases in order to help make the use of orbix object
   //    references transparent.
-{
 public:
   ACE_CORBA_Ref (void);
   // Null construction.
diff --git a/ace/Connector.h b/ace/Connector.h
index 21a833bcab2..af2c3884d9b 100644
--- a/ace/Connector.h
+++ b/ace/Connector.h
@@ -25,13 +25,13 @@
 
 template <class SVC_HANDLER>
 class ACE_Svc_Tuple
+{
   // = TITLE
   //    Holds the ACE_Svc_Handler and its argument and
   //    <ACE_Timer_Handle> until an asynchronous connection completes. 
   //
   // = DESCRIPTION
   //    This is a no-brainer...
-{
 public:
   // = Initialization methods.
   ACE_Svc_Tuple (SVC_HANDLER *, 
@@ -82,6 +82,7 @@ private:
 
 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1>
 class ACE_Connector : public ACE_Service_Object
+{
   // = TITLE
   //     Generic factory for actively connecting clients and creating
   //     service handlers (SVC_HANDLERs).
@@ -100,7 +101,6 @@ class ACE_Connector : public ACE_Service_Object
   //     complete asynchronously.  The handle_output method performs
   //     the connector's active connection establishment and service
   //     activation strategy.
-{
 public:
   // = Initialization and termination methods.
 
@@ -286,6 +286,7 @@ private:
 
 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1>
 class ACE_Strategy_Connector : public ACE_Connector <SVC_HANDLER, ACE_PEER_CONNECTOR_2>
+{
   // = TITLE
   //     Abstract factory for creating a service handler
   //     (SVC_HANDLER), connecting the SVC_HANDLER, and activating the
@@ -298,7 +299,6 @@ class ACE_Strategy_Connector : public ACE_Connector <SVC_HANDLER, ACE_PEER_CONNE
   //     actively connecting a new connection from a client into the
   //     SVC_HANDLER, and (3) activating the SVC_HANDLER with a
   //     particular concurrency mechanism.
-{
 public:
   ACE_Strategy_Connector (ACE_Reactor *r = ACE_Reactor::instance (),
 			  ACE_Creation_Strategy<SVC_HANDLER> * = 0,
diff --git a/ace/Containers.h b/ace/Containers.h
index 58ed4beac43..07bbd2fb543 100644
--- a/ace/Containers.h
+++ b/ace/Containers.h
@@ -23,13 +23,13 @@ class ACE_Allocator;
 
 template <class T>
 class ACE_Bounded_Stack
+{
   // = TITLE
   //     Implement a generic LIFO abstract data type.
   //
   // = DESCRIPTION
   //     This implementation of a Stack uses a bounded array
   //     that is allocated dynamically.
-{
 public:
   // = Initialization, assignemnt, and termination methods.
 
@@ -94,13 +94,13 @@ private:
 
 template <class T, size_t SIZE>
 class ACE_Fixed_Stack
+{
   // = TITLE
   //     Implement a generic LIFO abstract data type.
   //
   // = DESCRIPTION
   //     This implementation of a Stack uses a fixed array
   //     with the size fixed at instantiation time.
-{
 public:
   // = Initialization, assignemnt, and termination methods.
   ACE_Fixed_Stack (void);
@@ -172,9 +172,9 @@ template <class T> class ACE_Unbounded_Stack_Iterator;
 
 template<class T>
 class ACE_Node
+{
   // = TITLE
   //     Implementation element in a Queue.
-{
   friend class ACE_Unbounded_Queue<T>;
   friend class ACE_Unbounded_Queue_Iterator<T>;
   friend class ACE_Unbounded_Set<T>;
@@ -206,13 +206,14 @@ template <class T> class ACE_Double_Linked_List_Iterator;
 
 template <class T>
 class ACE_DNode
+{
 // = TITLE
 //     Implementation element in a Double-linked List.
-{
+public:
   friend class ACE_Double_Linked_List<T>;
   friend class ACE_Double_Linked_List_Iterator<T>;
-public:
-  T* item ();
+
+  T *item (void);
 protected:
   ACE_DNode (const T &i, ACE_DNode<T> *n = 0, ACE_DNode<T> *p = 0);
   ACE_DNode (const ACE_DNode<T> &i);
@@ -231,14 +232,15 @@ protected:
 
 template <class T>
 class ACE_Unbounded_Stack
+{
   // = TITLE
   //     Implement a generic LIFO abstract data type.
   //
   // = DESCRIPTION
   //     This implementation of an unbounded Stack uses a linked list.
-{
-  friend class ACE_Unbounded_Stack_Iterator<T>;
 public:
+  friend class ACE_Unbounded_Stack_Iterator<T>;
+
   // = Initialization, assignemnt, and termination methods.
   ACE_Unbounded_Stack (ACE_Allocator *alloc = 0);
   // Initialize a new stack so that it is empty.  Use user defined
@@ -320,9 +322,9 @@ private:
 
 template <class T>
 class ACE_Unbounded_Stack_Iterator
+{
   // = TITLE
   //     Implement an iterator over an unbounded Stack.
-{
 public:
   // = Initialization method.
   ACE_Unbounded_Stack_Iterator (ACE_Unbounded_Stack<T> &);
@@ -359,9 +361,9 @@ class ACE_Unbounded_Queue;
 
 template <class T>
 class ACE_Unbounded_Queue_Iterator
+{
   // = TITLE
   //     Implement an iterator over an unbounded queue.
-{
 public:
   // = Initialization method.
   ACE_Unbounded_Queue_Iterator (ACE_Unbounded_Queue<T> &);
@@ -395,15 +397,16 @@ private:
 
 template <class T>
 class ACE_Unbounded_Queue
+{
   // = TITLE
   //     A Queue of "infinite" length.
   //
   // = DESCRIPTION
   //     This implementation of an unbounded queue uses a circular
   //     linked list with a dummy node.
-{
-  friend class ACE_Unbounded_Queue_Iterator<T>;
 public:
+  friend class ACE_Unbounded_Queue_Iterator<T>;
+
   // = Initialization and termination methods.
   ACE_Unbounded_Queue (ACE_Allocator *alloc = 0);
   // construction.  Use user specified allocation strategy
@@ -486,6 +489,7 @@ class ACE_Double_Linked_List;
 
 template <class T>
 class ACE_Double_Linked_List_Iterator
+{
   // = TITLE
   //     Implement an iterator over a container double-linked list
   //
@@ -496,7 +500,6 @@ class ACE_Double_Linked_List_Iterator
   //     encasulation.  Notice <class T> must delcare
   //     ACE_Double_Linked_List<T> and
   //     ACE_Double_Linked_List_Iterator as friend classes.
-{
 public:
   // = Initialization method.
   ACE_Double_Linked_List_Iterator (ACE_Double_Linked_List<T> &);
@@ -537,9 +540,9 @@ protected:
   ACE_Double_Linked_List<T> &dllist_;
 };
 
-
 template <class T>
 class ACE_Double_Linked_List
+{
   // = TITLE
   //     A double-linked list implementation.
   //
@@ -548,9 +551,9 @@ class ACE_Double_Linked_List
   //     circular linked list with a dummy node.  It is pretty much
   //     like the ACE_Unbounded_Queue except that it allows removing
   //     of a specific element from a specific location.
-{
-  friend class ACE_Double_Linked_List_Iterator<T>;
 public:
+  friend class ACE_Double_Linked_List_Iterator<T>;
+
   // = Initialization and termination methods.
   ACE_Double_Linked_List (ACE_Allocator *alloc = 0);
   // construction.  Use user specified allocation strategy
@@ -664,9 +667,9 @@ protected:
 
 template <class T>
 class ACE_Unbounded_Set_Iterator
+{
   // = TITLE
   //     Implement an iterator over an unbounded set.
-{
 public:
   // = Initialization method.
   ACE_Unbounded_Set_Iterator (ACE_Unbounded_Set<T> &s);
@@ -700,6 +703,7 @@ private:
 
 template <class T>
 class ACE_Unbounded_Set
+{
   // = TITLE
   //     Implement a simple unordered set of <T> of unbounded size.
   //
@@ -707,9 +711,9 @@ class ACE_Unbounded_Set
   //     This implementation of an unordered set uses a circular
   //     linked list with a dummy node.  This implementation does not
   //     allow duplicates, but it maintains FIFO ordering of insertions.
-{
-friend class ACE_Unbounded_Set_Iterator<T>;
 public:
+  friend class ACE_Unbounded_Set_Iterator<T>;
+
   // = Initialization and termination methods.
   ACE_Unbounded_Set (ACE_Allocator *alloc = 0);
   // Constructor.  Use user specified allocation strategy
@@ -787,13 +791,13 @@ class ACE_Fixed_Set;
 
 template <class T, size_t SIZE>
 class ACE_Fixed_Set_Iterator
+{
   // = TITLE
   //     Interates through an unordered set.
   //
   // = DESCRIPTION
   //     This implementation of an unordered set uses a fixed array.
   //     Allows deletions while iteration is occurring.
-{
 public:
   // = Initialization method.
   ACE_Fixed_Set_Iterator (ACE_Fixed_Set<T, SIZE> &s);
@@ -827,15 +831,16 @@ private:
 
 template <class T, size_t SIZE>
 class ACE_Fixed_Set
+{
   // = TITLE
   //     Implement a simple unordered set of <T> with maximum <SIZE>.
   //
   // = DESCRIPTION
   //     This implementation of an unordered set uses a fixed array.
   //     This implementation does not allow duplicates...
-{
-friend class ACE_Fixed_Set_Iterator<T, SIZE>;
 public:
+  friend class ACE_Fixed_Set_Iterator<T, SIZE>;
+
   // = Initialization and termination methods.
   ACE_Fixed_Set (void);
   // Constructor.
@@ -905,13 +910,13 @@ class ACE_Bounded_Set;
 
 template <class T>
 class ACE_Bounded_Set_Iterator
+{
   // = TITLE
   //     Interates through an unordered set.
   //
   // = DESCRIPTION
   //     This implementation of an unordered set uses a Bounded array.
   //     Allows deletions while iteration is occurring.
-{
 public:
   // = Initialization method.
   ACE_Bounded_Set_Iterator (ACE_Bounded_Set<T> &s);
@@ -945,6 +950,7 @@ private:
 
 template <class T>
 class ACE_Bounded_Set
+{
   // = TITLE
   //     Implement a simple unordered set of <T> with maximum
   //     set at creation time.
@@ -952,9 +958,9 @@ class ACE_Bounded_Set
   // = DESCRIPTION
   //     This implementation of an unordered set uses a Bounded array.
   //     This implementation does not allow duplicates...
-{
-friend class ACE_Bounded_Set_Iterator<T>;
 public:
+  friend class ACE_Bounded_Set_Iterator<T>;
+
   enum
   {
     DEFAULT_SIZE = 10
diff --git a/ace/DEV.h b/ace/DEV.h
index ce2ae7f25d8..73be717d46c 100644
--- a/ace/DEV.h
+++ b/ace/DEV.h
@@ -35,10 +35,10 @@
 #endif /* ACE_TEMPLATE_TYPEDEFS */
 
 class ACE_Export ACE_DEV : public ACE_IO_SAP
+{
   // = TITLE
   //     Defines the member functions for the base class of the
   //     ACE_DEV abstraction. 
-{
 public:
   int close (void);
   // Close down the DEVICE
diff --git a/ace/DEV_Addr.h b/ace/DEV_Addr.h
index 4ea35c1115a..02bf6fa565d 100644
--- a/ace/DEV_Addr.h
+++ b/ace/DEV_Addr.h
@@ -22,9 +22,9 @@
 #include "ace/ACE.h"
 
 class ACE_Export ACE_DEV_Addr : public ACE_Addr
+{
   // = TITLE
   //    Defines device address family address format. 
-{
 public:
   // = Initialization methods.
   ACE_DEV_Addr (void);
diff --git a/ace/DEV_Connector.h b/ace/DEV_Connector.h
index b5567271efc..edf62216bbb 100644
--- a/ace/DEV_Connector.h
+++ b/ace/DEV_Connector.h
@@ -20,9 +20,9 @@
 #include "ace/DEV_IO.h"
 
 class ACE_Export ACE_DEV_Connector : public ACE_DEV
+{
   // = TITLE
   //     Defines an active connection factory for the ACE_DEV wrappers. 
-{
 public:
   ACE_DEV_Connector (void);
   // Default constructor.
diff --git a/ace/DEV_IO.h b/ace/DEV_IO.h
index 19e19fa374c..42f26b1bb2a 100644
--- a/ace/DEV_IO.h
+++ b/ace/DEV_IO.h
@@ -21,11 +21,12 @@
 #include "ace/DEV_Addr.h"
 
 class ACE_Export ACE_DEV_IO : public ACE_DEV
+{
   // = TITLE
   //     Read/Write operations on Devices.
-{
-friend class ACE_DEV_Connector;
 public:
+  friend class ACE_DEV_Connector;
+
   ACE_DEV_IO (void);
   // Default constructor.
 
diff --git a/ace/Date_Time.h b/ace/Date_Time.h
index 7f7dcbd33ad..faa1c508e84 100644
--- a/ace/Date_Time.h
+++ b/ace/Date_Time.h
@@ -1,7 +1,6 @@
 /* -*- C++ -*- */
 // $Id$
 
-
 // ============================================================================
 //
 // = LIBRARY
@@ -21,9 +20,9 @@
 #include "ace/ACE.h"
 
 class ACE_Export ACE_Date_Time
+{
   // = TITLE
   //     System independent representation of date and time.
-{
 public:
   // constructor with init values, no check for validy
   ACE_Date_Time (long day = 0,
diff --git a/ace/Dump.h b/ace/Dump.h
index 4e857a90c87..dba4b03965d 100644
--- a/ace/Dump.h
+++ b/ace/Dump.h
@@ -54,14 +54,16 @@
 #include "ace/Synch.h"
 
 class ACE_Export ACE_Dumpable
+{
   // = TITLE
   //   Base class that defines a uniform interface for all object
   //   dumping.
-{
-friend class ACE_ODB;
-friend class ACE_Dumpable_Ptr;
 public:
+  friend class ACE_ODB;
+  friend class ACE_Dumpable_Ptr;
+
   ACE_Dumpable (const void *);
+  // Constructor.
 
   virtual void dump (void) const = 0;
   // This pure virtual method must be filled in by a subclass.
@@ -75,10 +77,10 @@ private:
 };
 
 class ACE_Export ACE_Dumpable_Ptr 
+{
   // = TITLE
   //    A smart pointer stored in the in-memory object database
   //    ACE_ODB.  The pointee (if any) is deleted when reassigned.
-{
 public:
   ACE_Dumpable_Ptr (const ACE_Dumpable *dumper = 0);
   const ACE_Dumpable *operator->() const;
@@ -91,10 +93,10 @@ private:
 };
 
 class ACE_Export ACE_ODB
+{
   // = TITLE
   //     This is the object database (ODB) that keeps track of all
   //     live ACE objects.
-{
 public:
   enum {MAX_TABLE_SIZE = 100000}; // This is clearly inadequate and should be dynamic...
 
diff --git a/ace/Dump_T.h b/ace/Dump_T.h
index dd32b5623cf..2aadc9892b8 100644
--- a/ace/Dump_T.h
+++ b/ace/Dump_T.h
@@ -22,6 +22,7 @@
 
 template <class Concrete>
 class ACE_Dumpable_Adapter : public ACE_Dumpable
+{
   // = TITLE
   //    This class inherits the interface of the abstract ACE_Dumpable
   //    class and is instantiated with the implementation of the
@@ -32,7 +33,6 @@ class ACE_Dumpable_Adapter : public ACE_Dumpable
   //    from the ``Gang of Four'' book.  Note that <class Concrete>
   //    need not inherit from a common class since ACE_Dumpable
   //    provides the uniform virtual interface!
-{
 public:
   // = Initialization and termination methods.
   ACE_Dumpable_Adapter (const Concrete *t);
diff --git a/ace/Dynamic.h b/ace/Dynamic.h
index b105a4b6955..90e4b426882 100644
--- a/ace/Dynamic.h
+++ b/ace/Dynamic.h
@@ -21,13 +21,13 @@
 #include "ace/ACE.h"
 
 class ACE_Export ACE_Dynamic
+{
   // = TITLE
   //     Checks to see if an object was dynamically allocated.
   //
   // = DESCRIPTION
   //     This class holds the pointer in a thread-safe manner between
   //     the call to operator new and the call to the constructor.
-{
 public:
   ACE_Dynamic (void);
 
diff --git a/ace/Dynamic_Service.h b/ace/Dynamic_Service.h
index 35ac1d94c25..1f305f00a96 100644
--- a/ace/Dynamic_Service.h
+++ b/ace/Dynamic_Service.h
@@ -20,6 +20,7 @@
 
 template <class SERVICE>
 class ACE_Dynamic_Service
+{
   // = TITLE
   //     Provides a general interface to retrieve arbitrary objects
   //     from the ACE service repository.
@@ -27,7 +28,6 @@ class ACE_Dynamic_Service
   // = DESCRIPTION
   //     Uses "name" for lookup in the ACE service repository. Obtains
   //	 the object and returns it as the appropriate type.
-{
 public:
   static SERVICE *instance (const char *name);
   // Return instance using <name> to search the Service_Repository.
diff --git a/ace/Event_Handler.h b/ace/Event_Handler.h
index c4396dd8713..4eab2c20423 100644
--- a/ace/Event_Handler.h
+++ b/ace/Event_Handler.h
@@ -26,6 +26,7 @@ class ACE_Reactor;
 typedef u_long ACE_Reactor_Mask;
 
 class ACE_Export ACE_Event_Handler 
+{
   // = TITLE
   //     Provides an abstract interface for handling various types of
   //     I/O, timer, and signal events.
@@ -34,7 +35,6 @@ class ACE_Export ACE_Event_Handler
   //       Subclasses read/write input/output on an I/O descriptor,
   //       handle an exception raised on an I/O descriptor, handle a
   //       timer's expiration, or handle a signal.
-{
 public:
   enum 
   {
@@ -126,11 +126,12 @@ protected:
   ACE_Reactor *reactor_;
 };
 
-struct ACE_Export ACE_Notification_Buffer
+class ACE_Export ACE_Notification_Buffer
+{
   // = TITLE
   //     Simple wrapper for passing <ACE_Event_Handler *>s and
   //     <ACE_Reactor_Mask>s between threads.
-{
+public:
   ACE_Notification_Buffer (void);
 
   ACE_Notification_Buffer (ACE_Event_Handler *eh,
diff --git a/ace/Event_Handler_T.h b/ace/Event_Handler_T.h
index c78ace07609..2f71ebcfea3 100644
--- a/ace/Event_Handler_T.h
+++ b/ace/Event_Handler_T.h
@@ -1,7 +1,6 @@
 /* -*- C++ -*- */
 // $Id$
 
-
 // ============================================================================
 //
 // = LIBRARY
@@ -24,6 +23,7 @@
 
 template <class T> 
 class ACE_Export ACE_Event_Handler_T : public ACE_Event_Handler 
+{
   // = TITLE
   //     Enable a class that doesn't inherit from the
   //     ACE_Event_Handler to be incorporated into the ACE_Reactor
@@ -32,33 +32,34 @@ class ACE_Export ACE_Event_Handler_T : public ACE_Event_Handler
   //
   // = DESCRIPTION
   //     It is sometimes the case that an application has a hierarchy
-  //     of operation dispatcher classes that have their own inheritance
-  //     hierarchy but also would like to integrate with the ACE_Reactor.
-  //     Rather than adopt a "mixin" approach, it is often cleaner to 
-  //	 define a template as a subclass of ACE_Event_Handler and paramterize it 
-  //	 with an operation dispatcher type.
+  //     of operation dispatcher classes that have their own
+  //     inheritance hierarchy but also would like to integrate with
+  //     the ACE_Reactor.  Rather than adopt a "mixin" approach, it is
+  //     often cleaner to define a template as a subclass of
+  //     ACE_Event_Handler and paramterize it with an operation
+  //     dispatcher type.
   //
-  //     When constructing an instantiation of the ACE_Event_Handler_T object,
-  //	 a set of pointers to member functions must be provided so that 
-  //     when one of the handle_* methods is called by the ACE_Reactor,
-  //     the appropriate method is called on the underlying operations
-  //     object.  This is done since in some cases it is useful to 
-  //	 map any event that happens to the same method on an object.
+  //     When constructing an instantiation of the ACE_Event_Handler_T
+  //     object, a set of pointers to member functions must be
+  //     provided so that when one of the handle_* methods is called
+  //     by the ACE_Reactor, the appropriate method is called on the
+  //     underlying operations object.  This is done since in some
+  //     cases it is useful to map any event that happens to the same
+  //     method on an object.
   //
-  //     The ACE_Event_Handler_T template is instantiated by an operations
-  //     object and registered with the ACE_Reactor, and it then calls the
-  //     appropriate op_handler.  So, it's basically just another
-  //     level of indirection in event dispatching. The coupling
-  //     betweent the ultimate handler of the event and the
+  //     The ACE_Event_Handler_T template is instantiated by an
+  //     operations object and registered with the ACE_Reactor, and it
+  //     then calls the appropriate op_handler.  So, it's basically
+  //     just another level of indirection in event dispatching. The
+  //     coupling betweent the ultimate handler of the event and the
   //     ACE_Event_Handler class is relaxed a bit by have this
-  //     intermediate <op_handler_> object of type <T> around. The client
-  //     object can then dynamically change the bindings for the
-  //     various handlers so that during the life of one of the
+  //     intermediate <op_handler_> object of type <T> around. The
+  //     client object can then dynamically change the bindings for
+  //     the various handlers so that during the life of one of the
   //     operation objects, it can change how it wants events to be
   //     handled. It just instantiates a new instance of the template
   //     with different bindings and reregisters this new object with
   //     the ACE_Reactor.
-{
 public:
   // = Typedefs to simplify pointer-to-member-function registration.
 
@@ -83,15 +84,15 @@ public:
   // = Initialization and termination methods.
 
   ACE_Event_Handler_T (T *op_handler, 
-		   int delete_handler,
+                   int delete_handler,
                    GET_HANDLE get_handle = 0,
-		   IO_HANDLER input = 0,
-		   CL_HANDLER close = 0,
-		   SIG_HANDLER sig = 0,
-		   TO_HANDLER timeout = 0,
-		   IO_HANDLER output = 0,
+                   IO_HANDLER input = 0,
+                   CL_HANDLER close = 0,
+                   SIG_HANDLER sig = 0,
+                   TO_HANDLER timeout = 0,
+                   IO_HANDLER output = 0,
                    SET_HANDLE set_handle = 0,
-		   IO_HANDLER except = 0);
+                   IO_HANDLER except = 0);
   // Initialize the op_handler.
 
   ~ACE_Event_Handler_T (void);
diff --git a/ace/FIFO.h b/ace/FIFO.h
index 4d4ba938932..eacf6f54fa2 100644
--- a/ace/FIFO.h
+++ b/ace/FIFO.h
@@ -21,9 +21,9 @@
 #include "ace/IPC_SAP.h"
 
 class ACE_Export ACE_FIFO : public ACE_IPC_SAP
+{
   // = TITLE
   //    Abstract base class for UNIX FIFOs (a.k.a. Named Pipes).
-{
 public:
   int open (const char *rendezvous, int flags, int perms,
             LPSECURITY_ATTRIBUTES sa = 0);
diff --git a/ace/FIFO_Recv.h b/ace/FIFO_Recv.h
index a404d1e3b81..2cd3d8c14c2 100644
--- a/ace/FIFO_Recv.h
+++ b/ace/FIFO_Recv.h
@@ -20,10 +20,10 @@
 #include "ace/FIFO.h"
 
 class ACE_Export ACE_FIFO_Recv : public ACE_FIFO
+{
   // = TITLE
   //    Receiver side of the bytestream C++ wrapper for UNIX
   //    FIFOs.  
-{
 public:
   // = Initialization methods.
   ACE_FIFO_Recv (void);
diff --git a/ace/FIFO_Recv_Msg.h b/ace/FIFO_Recv_Msg.h
index 2626cceca7f..9c6ff057448 100644
--- a/ace/FIFO_Recv_Msg.h
+++ b/ace/FIFO_Recv_Msg.h
@@ -20,9 +20,9 @@
 #include "ace/FIFO_Recv.h"
 
 class ACE_Export ACE_FIFO_Recv_Msg : public ACE_FIFO_Recv
+{
   // = TITLE
   //     Receiver side for the record oriented C++ wrapper for UNIX FIFOs.
-{
 public:
   // = Initialization methods.
   ACE_FIFO_Recv_Msg (void);
diff --git a/ace/FIFO_Send.h b/ace/FIFO_Send.h
index 8b3ee6a8052..757846d292e 100644
--- a/ace/FIFO_Send.h
+++ b/ace/FIFO_Send.h
@@ -21,9 +21,9 @@
 #include "ace/FIFO.h"
 
 class ACE_Export ACE_FIFO_Send : public ACE_FIFO
+{
   // = TITLE
   //     Sender side for the bytestream C++ wrapper for UNIX FIFOs 
-{
 public:
   // = Initialization methods.
   ACE_FIFO_Send (void);
diff --git a/ace/FIFO_Send_Msg.h b/ace/FIFO_Send_Msg.h
index 94a8a4cabe9..cc55b9188fa 100644
--- a/ace/FIFO_Send_Msg.h
+++ b/ace/FIFO_Send_Msg.h
@@ -21,10 +21,10 @@
 #include "ace/FIFO_Send.h"
 
 class ACE_Export ACE_FIFO_Send_Msg : public ACE_FIFO_Send
+{
   // = TITLE
   //     Sender side for the Record oriented C++ wrapper for UNIX
   //     FIFOs. 
-{
 public:
   // = Initialization methods.
   ACE_FIFO_Send_Msg (void);
diff --git a/ace/FILE.h b/ace/FILE.h
index 7222ae28770..7819d333c5c 100644
--- a/ace/FILE.h
+++ b/ace/FILE.h
@@ -33,10 +33,11 @@
 #define ACE_FILE_STREAM ACE_FILE_IO, ACE_FILE_Addr
 #endif /* ACE_TEMPLATE_TYPEDEFS */
 
-struct ACE_FILE_Info
+class ACE_FILE_Info
+{
   // = TITLE
   //     Abstracts basic OS FILE information.
-{
+public:
   mode_t mode_;	
   // mode of file
 
@@ -48,10 +49,10 @@ struct ACE_FILE_Info
 };
 
 class ACE_Export ACE_FILE : public ACE_IO_SAP
+{
   // = TITLE
   //     Defines the member functions for the base class of the
   //     ACE_FILE abstraction. 
-{
 public:
   int close (void);
   // Close down the ACE_FILE
diff --git a/ace/FILE_Addr.h b/ace/FILE_Addr.h
index 30bfda9ab3a..d926a6a61d0 100644
--- a/ace/FILE_Addr.h
+++ b/ace/FILE_Addr.h
@@ -22,9 +22,9 @@
 #include "ace/ACE.h"
 
 class ACE_Export ACE_FILE_Addr : public ACE_Addr
+{
   // = TITLE
   //    Defines the FILE address family address format. 
-{
 public:
   // = Initialization methods.
   ACE_FILE_Addr (void);
diff --git a/ace/FILE_Connector.h b/ace/FILE_Connector.h
index eb366da6c45..a3ef60a8422 100644
--- a/ace/FILE_Connector.h
+++ b/ace/FILE_Connector.h
@@ -21,9 +21,9 @@
 #include "ace/FILE_IO.h"
 
 class ACE_Export ACE_FILE_Connector : public ACE_FILE
+{
   // = TITLE
   //     Defines an active connection factory for the ACE_FILE wrappers. 
-{
 public:
   // = Initialization methods.
   ACE_FILE_Connector (void);
diff --git a/ace/FILE_IO.h b/ace/FILE_IO.h
index dceacaf12e1..4867da1663e 100644
--- a/ace/FILE_IO.h
+++ b/ace/FILE_IO.h
@@ -21,11 +21,12 @@
 #include "ace/FILE_Addr.h"
 
 class ACE_Export ACE_FILE_IO : public ACE_FILE
+{
   // = TITLE
   //     Read/Write operations on Files
-{
-friend class ACE_FILE_Connector;
 public:
+  friend class ACE_FILE_Connector;
+
   // = Initialization method.
   ACE_FILE_IO (void);
   // Default constructor.
diff --git a/ace/Filecache.h b/ace/Filecache.h
index b35b99637f4..259c8131f6a 100644
--- a/ace/Filecache.h
+++ b/ace/Filecache.h
@@ -28,8 +28,8 @@ ACE_DECLARE_EXPORT(class, ACE_Filecache);
 ACE_DECLARE_EXPORT(class, ACE_Filecache_Handle);
 class ACE_Filecache_Object;
 
-
 class ACE_Filecache_Handle
+{
   // = TITLE
   //     Abstraction over a real file.  This is meant to be the entry
   //     point into the Cached Virtual Filesystem.
@@ -82,7 +82,6 @@ class ACE_Filecache_Handle
   // rather conservative, but for some reason it still ran into problems.
   // Since this design should be simpler, problems should be easier to spot.
   //
-{
 public:
 
   ACE_Filecache_Handle (const char *filename, int mapit = 1);
@@ -155,12 +154,12 @@ typedef ACE_Hash_Map_Manager<ACE_CString, ACE_Filecache_Object *, ACE_Null_Mutex
 #endif /* ACE_HAS_TEMPLATE_SPECIALIZATION */
 
 class ACE_Filecache
+{
   // = TITLE
   //     A hash table holding the information about entry point into
   //     the Cached Virtual Filesystem. On insertion, the reference
   //     count is incremented. On destruction, reference count is
   //     decremented.
-{
 public:
   static ACE_Filecache *instance (void);
   // Singleton pattern.
@@ -226,15 +225,15 @@ private:
 };
 
 class ACE_Filecache_Object
+{
   // = TITLE
   //     Abstraction over a real file.  This is what the Virtual
   //     Filesystem contains.  This class is not intended for general
   //     consumption.  Please consult a physician before attempting to
   //     use this class.
-{
+public:
   friend class ACE_Filecache;
 
-public:
   ACE_Filecache_Object (const char *filename,
                         ACE_SYNCH_RW_MUTEX &lock,
                         int mapit = 1,
diff --git a/ace/Free_List.h b/ace/Free_List.h
index 61724fa3eea..959ede733a0 100644
--- a/ace/Free_List.h
+++ b/ace/Free_List.h
@@ -21,12 +21,12 @@
 
 template <class T>
 class ACE_Free_List  
+{
   // = TITLE
   //      Implements a free list.
   //
   // = DESCRIPTION
   //      This class maintains a free list of nodes of type T.
-{
 public:
   virtual ~ACE_Free_List (void);
   // Destructor - removes all the elements from the free_list.
@@ -48,6 +48,7 @@ public:
 
 template <class T, class ACE_LOCK>
 class ACE_Locked_Free_List : public ACE_Free_List<T> 
+{
   // = TITLE
   //      Implements a free list.
   //
@@ -55,7 +56,6 @@ class ACE_Locked_Free_List : public ACE_Free_List<T>
   //      This class maintains a free list of nodes of type T.  It depends on
   //      the type T having a get_next () and set_next () method.  It maintains
   //      a mutex so the freelist can be used in a multithreaded program .
-{
 public:
   // = Initialization and termination.
   ACE_Locked_Free_List (int mode = ACE_FREE_LIST_WITH_POOL,
diff --git a/ace/Future.h b/ace/Future.h
index 09d08f5fdcd..4f628074773 100644
--- a/ace/Future.h
+++ b/ace/Future.h
@@ -27,6 +27,7 @@
 template <class T> class ACE_Future;
 
 template <class T> class ACE_Future_Rep
+{
   // = TITLE
   //     ACE_Future_Rep<T>
   //
@@ -35,12 +36,10 @@ template <class T> class ACE_Future_Rep
   //     object of class T which is the result of an asynchronous
   //     method invocation. It is pointed to by ACE_Future<T> object[s]
   //     and only accessible through them.
-{
-  friend class ACE_Future<T>;
-
 private:
+  friend class ACE_Future<T>;
   
-  // Create, attach, detach and assign encapsulates the reference 
+  // Create, attach, detach and assign encapsulates the reference
   // count handling and the object lifetime of ACE_Future_Rep<T>
   // instances.
   
@@ -105,14 +104,11 @@ private:
 };
 
 template <class T> class ACE_Future 
+{
   // = TITLE
   //     This class implements a ``single write, multiple read''
   //     pattern that can be used to return results from asynchronous
   //     method invocations.
-  //
-  // = DESCRIPTION
-  //    @@ Please update me...
-{
 public:
   // = Initialization and termination methods.
   ACE_Future (void);
diff --git a/ace/Get_Opt.h b/ace/Get_Opt.h
index 405a666d09f..56a715ebc87 100644
--- a/ace/Get_Opt.h
+++ b/ace/Get_Opt.h
@@ -20,12 +20,12 @@
 #include "ace/ACE.h"
 
 class ACE_Export ACE_Get_Opt
+{
   // = TITLE
   //   Iterator for parsing command-line arguments.
   //
   // = DESCRIPTION
   //    This is a C++ wrapper for getopt(3c).
-{
 public:
   ACE_Get_Opt (int argc, 
 	       char **argv, 
diff --git a/ace/Handle_Set.h b/ace/Handle_Set.h
index 46ace888b92..0dc7a1cf72d 100644
--- a/ace/Handle_Set.h
+++ b/ace/Handle_Set.h
@@ -23,8 +23,9 @@ class ACE_Export ACE_Handle_Set
 {
   // = TITLE
   //     C++ wrapper for the socket <FD_SET> abstraction.
-friend class ACE_Handle_Set_Iterator;
 public:
+  friend class ACE_Handle_Set_Iterator;
+
   // = Initialization and termination. 
 
   enum 
@@ -116,9 +117,9 @@ private:
 };
 
 class ACE_Export ACE_Handle_Set_Iterator
+{
   // = TITLE
   //     Iterator for the <ACE_Handle_Set> abstraction. 
-{
 public:
   ACE_Handle_Set_Iterator (const ACE_Handle_Set &hs);
   // Constructor.
diff --git a/ace/Hash_Map_Manager.h b/ace/Hash_Map_Manager.h
index feb1005b910..44493eba795 100644
--- a/ace/Hash_Map_Manager.h
+++ b/ace/Hash_Map_Manager.h
@@ -23,9 +23,9 @@ class ACE_Allocator;
 
 template <class EXT_ID, class INT_ID>
 class ACE_Hash_Map_Entry
+{
   // = TITLE
   //     Define an entry in the hash table.
-{
 public:
   // = Initialization and termination methods.
   ACE_Hash_Map_Entry (const EXT_ID &ext_id,
@@ -67,6 +67,7 @@ class ACE_Hash_Map_Reverse_Iterator;
 
 template <class EXT_ID, class INT_ID, class ACE_LOCK>
 class ACE_Hash_Map_Manager 
+{
   // = TITLE
   //     Define a map abstraction that associates <EXT_ID>s with
   //     <INT_ID>s.  
@@ -79,10 +80,10 @@ class ACE_Hash_Map_Manager
   //     specialization).  This class uses an ACE_Allocator to
   //     allocate memory The user can make this a persistant class by
   //     providing an ACE_Allocator with a persistable memory pool
-{
+public:
   friend class ACE_Hash_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>;
   friend class ACE_Hash_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>;
-public:
+
   typedef EXT_ID KEY;
   typedef INT_ID VALUE;
   typedef ACE_Hash_Map_Entry<EXT_ID, INT_ID> ENTRY;
@@ -297,11 +298,11 @@ private:
 
 template <class EXT_ID, class INT_ID, class ACE_LOCK>
 class ACE_Hash_Map_Iterator
+{
   // = TITLE
   //     Iterator for the ACE_Hash_Map_Manager.
   //
   // = DESCRIPTION
-{
 public:
   // = Initialization method.
   ACE_Hash_Map_Iterator (ACE_Hash_Map_Manager<EXT_ID, INT_ID, ACE_LOCK> &mm);
@@ -339,11 +340,11 @@ private:
 
 template <class EXT_ID, class INT_ID, class ACE_LOCK>
 class ACE_Hash_Map_Reverse_Iterator
+{
   // = TITLE
   //     Iterator for the ACE_Hash_Map_Manager.
   //
   // = DESCRIPTION
-{
 public:
   // = Initialization method.
   ACE_Hash_Map_Reverse_Iterator (ACE_Hash_Map_Manager<EXT_ID, INT_ID, ACE_LOCK> &mm);
diff --git a/ace/High_Res_Timer.h b/ace/High_Res_Timer.h
index 2ccbaff96de..c040e221da5 100644
--- a/ace/High_Res_Timer.h
+++ b/ace/High_Res_Timer.h
@@ -20,9 +20,11 @@
 #include "ace/ACE.h"
 
 class ACE_Export ACE_High_Res_Timer
-  // = TITLE A high resolution timer class wrapper that encapsulates
-  // OS-specific high-resolution timers, such as those found on
-  // Solaris, AIX, Win32/Pentium, and VxWorks.
+{
+  // = TITLE 
+  //     A high resolution timer class wrapper that encapsulates
+  //     OS-specific high-resolution timers, such as those found on
+  //     Solaris, AIX, Win32/Pentium, and VxWorks.
   //
   // = DESCRIPTION
   //     Most of the member functions don't return values.  The only
@@ -60,7 +62,6 @@ class ACE_Export ACE_High_Res_Timer
   //
   //     This issue is not mentioned in the Solaris 2.5.1 gethrtime man
   //     page.
-{
 public:
   // = Initialization method.
 
diff --git a/ace/INET_Addr.h b/ace/INET_Addr.h
index 7016d2a10d9..b8fdc3af618 100644
--- a/ace/INET_Addr.h
+++ b/ace/INET_Addr.h
@@ -21,9 +21,9 @@
 #include "ace/Addr.h"
 
 class ACE_Export ACE_INET_Addr : public ACE_Addr
+{
   // = TITLE
   //    Defines the Internet domain address family address format.
-{
 public:
   // = Initialization methods.
   ACE_INET_Addr (void);
diff --git a/ace/IOStream.h b/ace/IOStream.h
index 3ad09d2522c..80834742fd8 100644
--- a/ace/IOStream.h
+++ b/ace/IOStream.h
@@ -74,6 +74,7 @@ public:
 #endif /* ACE_HAS_STRING_CLASS */
 
 class ACE_Export ACE_Streambuf : public streambuf
+{
   // = TITLE
   //     Create your custom streambuf by providing and ACE_*_Stream
   //     object to this template.  I have tested it with
@@ -134,7 +135,6 @@ class ACE_Export ACE_Streambuf : public streambuf
   //     be no method for "syncing" the input.  However, since we
   //     maintain separate read/write buffers, no data is lost by
   //     "syncing" the input.  It simply remains buffered.
-{
 public:
 
   virtual ~ACE_Streambuf (void);
diff --git a/ace/IOStream_T.h b/ace/IOStream_T.h
index 298e34b67b2..2a35aa27697 100644
--- a/ace/IOStream_T.h
+++ b/ace/IOStream_T.h
@@ -68,6 +68,7 @@ protected:
 
 template <class STREAM>
 class ACE_IOStream : public iostream, public STREAM
+{
   // = TITLE
   //     A template adapter for creating an iostream-like object using
   //     an ACE IPC Stream for the actual I/O.  Iostreams use an
@@ -99,7 +100,6 @@ class ACE_IOStream : public iostream, public STREAM
   //     In the iostream.cpp file is an example of why it is necessary
   //     to overload all of the get/put operators when you want to
   //     customize only one or two.
-{
 public:
   // = Initialization and termination methods.
   ACE_IOStream (STREAM &stream,
@@ -224,6 +224,7 @@ private:
 
 template <class STREAM>
 class ACE_SOCK_Dgram_SC : public STREAM
+{
   // = TITLE
   //   "Dgram_SC" is short for "Datagram Self-Contained."
   //
@@ -235,7 +236,6 @@ class ACE_SOCK_Dgram_SC : public STREAM
   //   what this class is for.  Here, we keep an address object so
   //   that we can remember who last sent us data.  When we write
   //   back, we're then able to write back to that same address.
-{
 public:
   ACE_SOCK_Dgram_SC (void);
   ACE_SOCK_Dgram_SC (STREAM &source,
diff --git a/ace/IO_Cntl_Msg.h b/ace/IO_Cntl_Msg.h
index 7a0fb272cc7..894eb34c746 100644
--- a/ace/IO_Cntl_Msg.h
+++ b/ace/IO_Cntl_Msg.h
@@ -18,9 +18,9 @@
 #define ACE_IO_CNTL_MSG_H
 
 class ACE_Export ACE_IO_Cntl_Msg
+{
   // = TITLE
   //     Data format for IOCTL messages 
-{
 public:
   enum ACE_IO_Cntl_Cmds
   {
diff --git a/ace/IO_SAP.h b/ace/IO_SAP.h
index a57d501c03d..1d94073fcc0 100644
--- a/ace/IO_SAP.h
+++ b/ace/IO_SAP.h
@@ -21,10 +21,10 @@
 #include "ace/ACE.h"
 
 class ACE_Export ACE_IO_SAP
+{
   // = TITLE
   //     Defines the member functions for the base class of the ACE_IO_SAP
   //     abstraction.  
-{
 public:
   enum
   {
diff --git a/ace/IPC_SAP.h b/ace/IPC_SAP.h
index 4b6849d22ff..5149810cf4c 100644
--- a/ace/IPC_SAP.h
+++ b/ace/IPC_SAP.h
@@ -20,16 +20,15 @@
 #include "ace/ACE.h"
 
 class ACE_Export ACE_IPC_SAP
+{
   // = TITLE
   //     Defines the member functions for the base class of the
   //     ACE_IPC_SAP abstraction.
-{
 public:
   int control (int cmd, void *) const;
   // Interface for ioctl. 
 
-  // = Methods for manipulating common I/O descriptor options related
-  // to sockets.
+  // = Common I/O descriptor options related to sockets.
   int enable (int signum) const;
   // Enable signal <signum>.
 
diff --git a/ace/LOCK_SOCK_Acceptor.h b/ace/LOCK_SOCK_Acceptor.h
index 6930c166318..8517992c600 100644
--- a/ace/LOCK_SOCK_Acceptor.h
+++ b/ace/LOCK_SOCK_Acceptor.h
@@ -20,8 +20,9 @@
 
 template <class ACE_LOCK>
 class ACE_LOCK_SOCK_Acceptor : public ACE_SOCK_Acceptor
+{
   // = TITLE
-  //     Specialize ACE_SOCK_Acceptor to lock around <accept>;
+  //     Specialize <ACE_SOCK_Acceptor> to lock around <accept>;
   // 
   // = DESCRIPTION
   //     This class is necessary since some OS platforms (e.g.,
@@ -29,14 +30,13 @@ class ACE_LOCK_SOCK_Acceptor : public ACE_SOCK_Acceptor
   //     simultaneously call <accept> on the same listen-mode
   //     port/socket.  Thus, we need to protect against multiple
   //     concurrent accesses by using the appropriate type of lock.
-{
 public:
-  virtual int accept (ACE_SOCK_Stream &new_stream,
-                      ACE_Addr *remote_addr = 0,
-                      ACE_Time_Value *timeout = 0,
-                      int restart = 1,
-                      int reset_new_handle = 0) const;
-  // Accept the connection under the control of the <ACE_LOCK>. 
+  int accept (ACE_SOCK_Stream &new_stream,
+              ACE_Addr *remote_addr = 0,
+              ACE_Time_Value *timeout = 0,
+              int restart = 1,
+              int reset_new_handle = 0) const;
+  // Accept the connection under the control of the <ACE_LOCK>.
 
   ACE_LOCK &lock (void);
   // Return a reference to the lock.
diff --git a/ace/LSOCK.h b/ace/LSOCK.h
index 4aa734a4da1..9d5999f5426 100644
--- a/ace/LSOCK.h
+++ b/ace/LSOCK.h
@@ -22,10 +22,10 @@
 #if !defined (ACE_LACKS_UNIX_DOMAIN_SOCKETS)
 
 class ACE_Export ACE_LSOCK
+{
   // = TITLE
   //     Create a Local ACE_SOCK, which is used for passing file
   //     descriptors.  
-{
 public:
 #if defined (ACE_HAS_MSG)
   int send_handle (const ACE_HANDLE handle) const;	
diff --git a/ace/LSOCK_Acceptor.h b/ace/LSOCK_Acceptor.h
index e576b6b9a49..a4ec2a9d5e2 100644
--- a/ace/LSOCK_Acceptor.h
+++ b/ace/LSOCK_Acceptor.h
@@ -25,10 +25,10 @@
 #if !defined (ACE_LACKS_UNIX_DOMAIN_SOCKETS)
 
 class ACE_Export ACE_LSOCK_Acceptor : public ACE_SOCK_Acceptor
+{
   // = TITLE
   //     Defines the format and interface for the acceptor side of the
   //     local ACE_SOCK ACE_Stream.
-{
 public:
   // = Initialization methods.
   ACE_LSOCK_Acceptor (void);
diff --git a/ace/LSOCK_CODgram.h b/ace/LSOCK_CODgram.h
index 360148cbbf7..22003a3dc2e 100644
--- a/ace/LSOCK_CODgram.h
+++ b/ace/LSOCK_CODgram.h
@@ -25,10 +25,10 @@
 #if !defined (ACE_LACKS_UNIX_DOMAIN_SOCKETS)
 
 class ACE_Export ACE_LSOCK_CODgram : public ACE_SOCK_CODgram, public ACE_LSOCK
-  // = TITLE
-  //     Defines the member functions for the ACE_LSOCK 
-  //     connected datagram abstraction. 
 {
+  // = TITLE
+  //     Defines the member functions for the <ACE_LSOCK> connected
+  //     datagram abstraction.
 public:
   // = Initialization methods.
   ACE_LSOCK_CODgram (void);
diff --git a/ace/LSOCK_Connector.h b/ace/LSOCK_Connector.h
index 0a319f9ce07..8ce18b2b0e2 100644
--- a/ace/LSOCK_Connector.h
+++ b/ace/LSOCK_Connector.h
@@ -24,10 +24,10 @@
 #if !defined (ACE_LACKS_UNIX_DOMAIN_SOCKETS)
 
 class ACE_Export ACE_LSOCK_Connector : public ACE_SOCK_Connector
-  // = TITLE
-  //     Defines the format and interface for the connector side of the 
-  //     local ACE_SOCK ACE_Stream. 
 {
+  // = TITLE
+  //     Defines the format and interface for the connector side of
+  //     the <ACE_LSOCK_Stream>.
 public:
   // = Initialization methods.
   ACE_LSOCK_Connector (void);
diff --git a/ace/LSOCK_Dgram.h b/ace/LSOCK_Dgram.h
index ec63e15a34e..953213b3b85 100644
--- a/ace/LSOCK_Dgram.h
+++ b/ace/LSOCK_Dgram.h
@@ -24,9 +24,9 @@
 #if !defined (ACE_LACKS_UNIX_DOMAIN_SOCKETS)
 
 class ACE_Export ACE_LSOCK_Dgram : public ACE_SOCK_Dgram, public ACE_LSOCK
+{
   // = TITLE
   //     Create a Local ACE_SOCK datagram. 
-{
 public:
   // = Initialization methods.
   ACE_LSOCK_Dgram (void);
diff --git a/ace/LSOCK_Stream.h b/ace/LSOCK_Stream.h
index 13bda9b8b8b..3957df2415a 100644
--- a/ace/LSOCK_Stream.h
+++ b/ace/LSOCK_Stream.h
@@ -25,15 +25,19 @@
 #if !defined (ACE_LACKS_UNIX_DOMAIN_SOCKETS)
 
 class ACE_Export ACE_LSOCK_Stream : public ACE_SOCK_Stream, public ACE_LSOCK
+{
   // = TITLE
   //     Create a Local ACE_SOCK stream. 
-{
 public:
   // = Send/recv methods.
-  ssize_t send_msg (const iovec iov[], size_t n, ACE_HANDLE handle);
+  ssize_t send_msg (const iovec iov[],
+                    size_t n,
+                    ACE_HANDLE handle);
   // Send iovecs via <::writev>.
 
-  ssize_t recv_msg (iovec iov[], size_t n, ACE_HANDLE &handle);
+  ssize_t recv_msg (iovec iov[],
+                    size_t n,
+                    ACE_HANDLE &handle);
   // Send iovecs via <::writev>.
 
   ACE_HANDLE get_handle (void) const;
diff --git a/ace/Local_Name_Space.h b/ace/Local_Name_Space.h
index 3f1dfc07630..2ffdcfe1d09 100644
--- a/ace/Local_Name_Space.h
+++ b/ace/Local_Name_Space.h
@@ -25,6 +25,7 @@
 #include "ace/Synch.h"
 
 class ACE_Export ACE_NS_String
+{
   // = TITLE
   //     This class and ACE_NS_Internal are used as Adapters to work
   //     with the Map_Manager.
@@ -34,7 +35,6 @@ class ACE_Export ACE_NS_String
   //     convert back and forth with ACE_WStrings.  Note that this
   //     class must not have a destructor since otherwise we'll have
   //     problems...
-{
 public:
   // = Initialization.
   ACE_NS_String (void);
@@ -81,10 +81,10 @@ private:
 };
 
 class ACE_Export ACE_NS_Internal
+{
   // = TITLE
   //     This class and ACE_NS_String are used as Adapters to work
   //     with the Map_Manager.
-{
 public:
   ACE_NS_Internal (void);
   // No-op constructor.
diff --git a/ace/Local_Name_Space_T.h b/ace/Local_Name_Space_T.h
index fccd5f8bd5d..9d65682f3b1 100644
--- a/ace/Local_Name_Space_T.h
+++ b/ace/Local_Name_Space_T.h
@@ -65,22 +65,22 @@ public:
   // acquire the lock, set the allocator to the one specific to this
   // process, and then call down to perform the intended operation.
   int bind (const ACE_NS_String &,
-	    const ACE_NS_Internal &,
-	    ALLOCATOR *alloc);
+            const ACE_NS_Internal &,
+            ALLOCATOR *alloc);
 
   int unbind (const ACE_NS_String &,
-	      ACE_NS_Internal &,
-	      ALLOCATOR *alloc);
+              ACE_NS_Internal &,
+              ALLOCATOR *alloc);
 
   int rebind (const ACE_NS_String &,
-	      const ACE_NS_Internal &,
-	      ACE_NS_String &,
-	      ACE_NS_Internal &,
-	      ALLOCATOR *alloc);
+              const ACE_NS_Internal &,
+              ACE_NS_String &,
+              ACE_NS_Internal &,
+              ALLOCATOR *alloc);
 
   int find (const ACE_NS_String &,
-	    ACE_NS_Internal &,
-	    ALLOCATOR *alloc);
+            ACE_NS_Internal &,
+            ALLOCATOR *alloc);
 
   int close (ALLOCATOR *alloc);
 
@@ -89,25 +89,25 @@ private:
 
 template <ACE_MEM_POOL_1, class ACE_LOCK>
 class ACE_Local_Name_Space : public ACE_Name_Space
+{
   // = TITLE
   //     Maintaining accesses Local Name Server Database.  Allows to
   //     add NameBindings, change them, remove them and resolve
   //     NameBindings.
   //
   // = DESCRIPTION
-  //     Manages a Naming Service for a local name space which includes
-  //	 bindings for node_local and host_local naming contexts.
-  //	 All strings are stored in wide character format.
+  //     Manages a Naming Service for a local name space which
+  //     includes bindings for node_local and host_local naming
+  //     contexts.  All strings are stored in wide character format.
   //     A Name Binding consists of a name (that's the key), a value
-  //	 string and an optional type string (no wide chars).
-{
+  //     string and an optional type string (no wide chars).
 public:
   // = Initialization and termination methods.
   ACE_Local_Name_Space (void);
   // "Do-nothing" constructor.
 
   ACE_Local_Name_Space (ACE_Naming_Context::Context_Scope_Type scope_in,
-			ACE_Name_Options *name_options);
+                        ACE_Name_Options *name_options);
   // Specifies the scope of this namespace, opens and memory-maps the
   // associated file (if accessible) or contacts the dedicated name
   // server process for NET_LOCAL namespace.
@@ -122,13 +122,13 @@ public:
   // file
 
   virtual int bind (const ACE_WString &name,
-		    const ACE_WString &value,
-		    const char *type = "");
+                    const ACE_WString &value,
+                    const char *type = "");
   // Bind a new name to a naming context (Wide character strings).
 
   virtual int rebind (const ACE_WString &name,
-		      const ACE_WString &value,
-		      const char *type = "");
+                      const ACE_WString &value,
+                      const char *type = "");
   // Overwrite the value or type of an existing name in a
   // ACE_Local_Name_Space or bind a new name to the context, if it
   // didn't exist yet. (Wide charcter strings interface).
@@ -139,55 +139,55 @@ public:
   // Interface).
 
   virtual int resolve (const ACE_WString &name,
-		       ACE_WString &value,
-		       char *&type);
+                       ACE_WString &value,
+                       char *&type);
   virtual int resolve_i (const ACE_WString &name,
-			 ACE_WString &value,
-			 char *&type);
+                         ACE_WString &value,
+                         char *&type);
   // Get value and type of a given name binding (Wide chars).  The
   // caller is responsible for deleting <type>!
 
   virtual int list_names (ACE_WSTRING_SET &set,
-			  const ACE_WString &pattern);
+                          const ACE_WString &pattern);
   virtual int list_names_i (ACE_WSTRING_SET &set,
-			  const ACE_WString &pattern);
+                          const ACE_WString &pattern);
   // Get a set of names matching a specified pattern (wchars). Matching
   // means the names must begin with the pattern string.
 
   virtual int list_values (ACE_WSTRING_SET &set,
-			   const ACE_WString &pattern);
+                           const ACE_WString &pattern);
   virtual int list_values_i (ACE_WSTRING_SET &set,
-			     const ACE_WString &pattern);
+                             const ACE_WString &pattern);
   // Get a set of values matching a specified pattern (wchars). Matching
   // means the values must begin with the pattern string.
 
   virtual int list_types (ACE_WSTRING_SET &set,
-			  const ACE_WString &pattern);
+                          const ACE_WString &pattern);
   virtual int list_types_i (ACE_WSTRING_SET &set,
-			    const ACE_WString &pattern);
+                            const ACE_WString &pattern);
   // Get a set of types matching a specified pattern (wchars). Matching
   // means the types must begin with the pattern string.
 
   virtual int list_name_entries (ACE_BINDING_SET &set,
-				 const ACE_WString &pattern);
+                                 const ACE_WString &pattern);
   virtual int list_name_entries_i (ACE_BINDING_SET &set,
-				   const ACE_WString &pattern);
+                                   const ACE_WString &pattern);
   // Get a set of names matching a specified pattern (wchars). Matching
   // means the names must begin with the pattern string. Returns the
   // complete binding associated each pattern match.
 
   virtual int list_value_entries (ACE_BINDING_SET &set,
-				  const ACE_WString &pattern);
+                                  const ACE_WString &pattern);
   virtual int list_value_entries_i (ACE_BINDING_SET &set,
-				    const ACE_WString &pattern);
+                                    const ACE_WString &pattern);
   // Get a set of values matching a specified pattern (wchars). Matching
   // means the values must begin with the pattern string. Returns the
   // complete binding associated each pattern match.
 
   virtual int list_type_entries (ACE_BINDING_SET &set,
-				 const ACE_WString &pattern);
+                                 const ACE_WString &pattern);
   virtual int list_type_entries_i (ACE_BINDING_SET &set,
-				   const ACE_WString &pattern);
+                                   const ACE_WString &pattern);
   // Get a set of types matching a specified pattern (wchars). Matching
   // means the types must begin with the pattern string. Returns the
   // complete binding associated each pattern match.
@@ -206,9 +206,9 @@ private:
 #endif /* ACE_WIN32 */
 
   int shared_bind (const ACE_WString &name, const ACE_WString &value,
-		   const char *type, int rebind);
+                   const char *type, int rebind);
   int shared_bind_i (const ACE_WString &name, const ACE_WString &value,
-		     const char *type, int rebind);
+                     const char *type, int rebind);
   // Factor out code from bind() and rebind().
 
   int create_manager (void);
diff --git a/ace/Local_Tokens.h b/ace/Local_Tokens.h
index ff9e7435738..40536b09396 100644
--- a/ace/Local_Tokens.h
+++ b/ace/Local_Tokens.h
@@ -72,13 +72,12 @@ class ACE_Token_Proxy;
 
 // 3..
 class ACE_Export ACE_TPQ_Entry
+{
   // = TITLE
-  //   Not a public interface.
+  //     Token Proxy Queue entry.  Used in the ACE_Token_Proxy_Queue
   //
   // = DESCRIPTION
-  //   Token Proxy Queue entry.
-  //   Used in the ACE_Token_Proxy_Queue
-{
+  //     Not a public interface.
 friend class ACE_Token_Manager;
 public:
   typedef void (*PTVF) (void *);
@@ -168,11 +167,12 @@ typedef ACE_TSS<ACE_TPQ_Entry> ACE_TPQ_ENTRY;
 #endif /* ACE_NO_TSS_TOKENS */
 
 class ACE_Export ACE_TSS_TPQ_Entry : public ACE_TPQ_ENTRY
+{
   // = TITLE
-  //    Not a public interface.
+  //     ACE_TSS_TPQ_Entry
+  // 
   // = DESCRIPTION
-  //    ACE_TSS_TPQ_Entry
-{
+  //     Not a public interface.
 public:
   ACE_TSS_TPQ_Entry (const ACE_Token_Proxy *proxy,
 		     const char *client_id);
@@ -214,12 +214,12 @@ class ACE_Token_Proxy_Queue;
 
 // c..
 class ACE_Export ACE_TPQ_Iterator
+{
   // = TITLE
-  //   Not a public interface.
+  //     Iterates through ACE_Token_Proxy_Queues.
   //
   // = DESCRIPTION
-  //   Iterates through ACE_Token_Proxy_Queues.
-{
+  //     Not a public interface.
 public:
   ACE_TPQ_Iterator (ACE_Token_Proxy_Queue &q);
   // Construction.
@@ -242,21 +242,23 @@ private:
 
 // 4..
 class ACE_Export ACE_Token_Proxy_Queue
+{
   // = TITLE
-  //   Not a public interface.
+  //     Token waiter list.
   //
   // = DESCRIPTION
-  //   Token waiter list.
-  //   This queue holds all the token proxies waiting for ownership of
-  //   a token.  Along with the proxy reference, it also stores the
-  //   nesting level, client id, and a magic cookie from the proxy.
-  //   This queue stores the ACE_TPQ_Entries by pointer values.  It
-  //   DOES NOT make copies.  Thus, the user is responsible to ensure
-  //   that the TPQ's stick around.  This is motivated by the need to
-  //   reduce dynamic memory allocation.
-{
-  friend class ACE_TPQ_Iterator;
+  //     Not a public interface.
+  //
+  //     This queue holds all the token proxies waiting for ownership
+  //     of a token.  Along with the proxy reference, it also stores
+  //     the nesting level, client id, and a magic cookie from the
+  //     proxy.  This queue stores the ACE_TPQ_Entries by pointer
+  //     values.  It DOES NOT make copies.  Thus, the user is
+  //     responsible to ensure that the TPQ's stick around.  This is
+  //     motivated by the need to reduce dynamic memory allocation.
 public:
+  friend class ACE_TPQ_Iterator;
+
   ACE_Token_Proxy_Queue (void);
   // Construction.
 
@@ -295,25 +297,25 @@ protected:
 
 // 5..
 class ACE_Export ACE_Tokens
+{
   // = TITLE
-  //   Not a public interface.
+  //     Abstract representation of ACE tokens.
   //
   // = DESCRIPTION
-  //   Abstract representation of ACE tokens.
-  //   Currently, I don't see a reason for providing an abstract
-  //   interface at this level of the library.  As of yet, no one uses
-  //   ACE_Tokens derivatives through this abstract interface except
-  //   for Token_Manager.  It only uses the statistical methods which
-  //   are shared by all Tokens.  For that reason, it still makes
-  //   since to have a common base class.  However, acquire, renew,
-  //   and release do not need to have matching interfaces throughout
-  //   all Tokens.
-
-  // = EXTENDING TOKENS
-  //   To add a new type of token (e.g. semaphore), this class must be
-  //   subtyped to define the new semantics.  See ACE_Token_Manager
-  //   for details.
-{
+  //     Not a public interface.
+  //
+  //     Currently, I don't see a reason for providing an abstract
+  //     interface at this level of the library.  As of yet, no one
+  //     uses <ACE_Tokens< derivatives through this abstract interface
+  //     except for <ACE_Token_Manager>.  It only uses the statistical
+  //     methods which are shared by all Tokens.  For that reason, it
+  //     still makes since to have a common base class.  However,
+  //     acquire, renew, and release do not need to have matching
+  //     interfaces throughout all Tokens.
+  //
+  //     To add a new type of token (e.g. semaphore), this class must
+  //     be subtyped to define the new semantics.  See
+  //     <ACE_Token_Manager> for details.
 public:
 
   ACE_Tokens (void);
@@ -418,20 +420,21 @@ class ACE_Local_Mutex;
 
 // 6..
 class ACE_Export ACE_Mutex_Token : public ACE_Tokens
+{
   // = TITLE
-  //    Not a public interface.
-  //
-  // = DESCRIPTION
   //    Class that acquires, renews, and releases a process-local
   //    synchronization token.
+  //
+  // = DESCRIPTION
+  //    Not a public interface.
+  //
   //    This class is a more general-purpose synchronization mechanism
   //    than SunOS 5.x mutexes.  For example, it implements "recursive
   //    mutex" semantics, where a thread that owns the token can
-  //    reacquire it without deadlocking.  In addition, threads that are
-  //    blocked awaiting the token are serviced in strict FIFO order as
-  //    other threads release the token (SunOS 5.x mutexes don't strictly
-  //    enforce an acquisition order).
-{
+  //    reacquire it without deadlocking.  In addition, threads that
+  //    are blocked awaiting the token are serviced in strict FIFO
+  //    order as other threads release the token (SunOS 5.x mutexes
+  //    don't strictly enforce an acquisition order).
 public:
   ACE_Mutex_Token (const char* name);
   // life
@@ -505,12 +508,14 @@ private:
 
 // 12..
 class ACE_Export ACE_RW_Token : public ACE_Tokens
+{
   // = TITLE
-  //    Not a public interface.
-  //
-  // = DESCRIPTION
   //    Class that acquires, renews, and releases a process-local
   //    synchronization token.
+  //
+  // = DESCRIPTION
+  //    Not a public interface.
+  //
   //    This class is a more general-purpose synchronization mechanism
   //    than SunOS 5.x mutexes.  For example, it implements "recursive
   //    mutex" semantics, where a thread that owns the token can
@@ -518,7 +523,6 @@ class ACE_Export ACE_RW_Token : public ACE_Tokens
   //    blocked awaiting the token are serviced in strict FIFO order as
   //    other threads release the token (SunOS 5.x mutexes don't strictly
   //    enforce an acquisition order).
-{
 public:
   ACE_RW_Token (const char* name);
   // Life.
@@ -601,16 +605,16 @@ protected:
 
 // a..
 class ACE_Token_Name
+{
   // = TITLE
-  //   Allows Token_Manger to identify tokens.
+  //     Allows Token_Manger to identify tokens.
   //
   // = DESCRIPTION
-  //   For now, this is just a string.  We need a string class anyway
-  //   to use in ACE_Map_Manager.  Having this class (instead of
-  //   SString) allows us to easily change if needed.  For instance,
-  //   we may choose to identify tokens by name and *type* in the
-  //   future.
-{
+  //     For now, this is just a string.  We need a string class
+  //     anyway to use in <ACE_Map_Manager>.  Having this class
+  //     (instead of <ACE_SString>) allows us to easily change if
+  //     needed.  For instance, we may choose to identify tokens by
+  //     name and *type* in the future.
 public:
   ACE_Token_Name (const char *token_name = 0);
   // Construction.
@@ -643,6 +647,7 @@ private:
 
 // 7..
 class ACE_Export ACE_Token_Proxy
+{
   // = TITLE
   //   Abstract representation of ACE tokens.
   //
@@ -656,12 +661,10 @@ class ACE_Export ACE_Token_Proxy
   //   ACE_Token_Proxy by passing the proper values at construction.
   //   Alternatively, there are class definitions which "know" how to
   //   do this (ACE_Local_Mutex, ACE_Local_RLock, ACE_Local_WLock).
-
-  // = EXTENDING TOKENS
+  //
   //   To add a new type of token (e.g. semaphore), this class is not
   //   changed.  See ACE_Token_Manager for details.
-
-  // = RESTRICTIONS
+  //
   //   Tokens (e.g. ACE_Mutex_Token) assume that it can always call
   //   ACE_Token_Proxy::token_acquired () on a new token owner.  This
   //   is not a problem for synchronous use of token proxies (that is,
@@ -670,10 +673,9 @@ class ACE_Export ACE_Token_Proxy
   //   operations, the proxy can not go away after an acquire until
   //   the token is acquired.  This is not really a problem, but
   //   should be understood.
-{
-friend class ACE_Token_Manager;
-friend class ACE_Token_Invariant_Manager; // For testing.
 public:
+  friend class ACE_Token_Manager;
+  friend class ACE_Token_Invariant_Manager; // For testing.
 
   // Initialization and termination methods.
   ACE_Token_Proxy (void);
@@ -813,9 +815,9 @@ protected:
 
 // 8..
 class ACE_Export ACE_Null_Token : public ACE_Token_Proxy
+{
   // = TITLE
   //   No op class for nonthreaded platform protocols.
-{
 public:
   ACE_Null_Token (void) {};
   // Construction.
@@ -854,6 +856,7 @@ public:
 
 // 9..
 class ACE_Export ACE_Local_Mutex : public ACE_Token_Proxy
+{
   // = TITLE
   //    Class that acquires, renews, and releases a synchronization
   //    token local to the process.
@@ -868,11 +871,9 @@ class ACE_Export ACE_Local_Mutex : public ACE_Token_Proxy
   //    don't strictly enforce an acquisition order).  Lastly,
   //    ACE_Local_Mutex performs deadlock detection on acquire calls.
   //
-  // = Synchronization operations.
   //   The interfaces for acquire, tryacquire, renew, release,
   //   etc. are defined in ACE_Token_Proxy.  The semantics for
   //   ACE_Local_Mutex are that of a mutex.
-{
 public:
   ACE_Local_Mutex (const char *token_name = 0,
 		   int ignore_deadlock = 0,
@@ -894,31 +895,30 @@ protected:
 
 // *.
 class ACE_Export ACE_Local_RLock : public ACE_Token_Proxy
-// = TITLE
-//    Class that acquires, renews, and releases a readers lock that
-//    is local to the process.
-//
-// = DESCRIPTION
-//    This class implements the reader interface to canonical
-//    readers/writer locks.  Multiple readers can hold the lock
-//    simultaneously when no writers have the lock.  Alternatively,
-//    when a writer holds the lock, no other participants (readers or
-//    writers) may hold the lock.  This class is a more
-//    general-purpose synchronization mechanism than SunOS 5.x RLocks.
-//    For example, it implements "recursive RLock" semantics, where a
-//    thread that owns the token can reacquire it without deadlocking.
-//    In addition, threads that are blocked awaiting the token are
-//    serviced in strict FIFO order as other threads release the token
-//    (SunOS 5.x RLockes don't strictly enforce an acquisition
-//    order).
-//
-// = Synchronization operations.
-//    The interfaces for acquire, tryacquire, renew, release, etc. are
-//    defined in ACE_Token_Proxy.  The semantics for ACE_Local_RLock
-//    are that of a readers/writers lock.  Acquire for this class
-//    implies a reader acquisition.  That is, multiple clients may
-//    acquire a lock for read only.
 {
+  // = TITLE
+  //    Class that acquires, renews, and releases a readers lock that
+  //    is local to the process.
+  //
+  // = DESCRIPTION
+  //    This class implements the reader interface to canonical
+  //    readers/writer locks.  Multiple readers can hold the lock
+  //    simultaneously when no writers have the lock.  Alternatively,
+  //    when a writer holds the lock, no other participants (readers
+  //    or writers) may hold the lock.  This class is a more
+  //    general-purpose synchronization mechanism than SunOS 5.x
+  //    RLocks.  For example, it implements "recursive RLock"
+  //    semantics, where a thread that owns the token can reacquire it
+  //    without deadlocking.  In addition, threads that are blocked
+  //    awaiting the token are serviced in strict FIFO order as other
+  //    threads release the token (SunOS 5.x RLockes don't strictly
+  //    enforce an acquisition order).
+  //
+  //    The interfaces for acquire, tryacquire, renew, release,
+  //    etc. are defined in ACE_Token_Proxy.  The semantics for
+  //    ACE_Local_RLock are that of a readers/writers lock.  Acquire
+  //    for this class implies a reader acquisition.  That is,
+  //    multiple clients may acquire a lock for read only.
 public:
   // = Initialization and termination.
 
@@ -945,30 +945,30 @@ protected:
 
 // *.
 class ACE_Export ACE_Local_WLock : public ACE_Token_Proxy
-// = TITLE
-//    Class that acquires, renews, and releases a writer lock that
-//    is local to the process.
-//
-// = DESCRIPTION
-//    This class implements the writer interface to canonical
-//    readers/writer locks. Multiple readers can hold the lock
-//    simultaneously when no writers have the lock.  Alternatively,
-//    when a writer holds the lock, no other participants (readers or
-//    writers) may hold the lock.  This class is a more
-//    general-purpose synchronization mechanism than SunOS 5.x WLock.
-//    For example, it implements "recursive WLock" semantics, where a
-//    thread that owns the token can reacquire it without deadlocking.
-//    In addition, threads that are blocked awaiting the token are
-//    serviced in strict FIFO order as other threads release the token
-//    (SunOS 5.x WLocks don't strictly enforce an acquisition order).
-//
-// = Synchronization operations.
-//   The interfaces for acquire, tryacquire, renew, release,
-//   etc. are defined in ACE_Token_Proxy.  The semantics for
-//   ACE_Local_WLock are that of a readers/writers lock.  Acquire
-//   for this class implies a writer acquisition.  That is, only one
-//   client may hold the lock for writing.
 {
+  // = TITLE
+  //    Class that acquires, renews, and releases a writer lock that
+  //    is local to the process.
+  //
+  // = DESCRIPTION
+  //    This class implements the writer interface to canonical
+  //    readers/writer locks. Multiple readers can hold the lock
+  //    simultaneously when no writers have the lock.  Alternatively,
+  //    when a writer holds the lock, no other participants (readers
+  //    or writers) may hold the lock.  This class is a more
+  //    general-purpose synchronization mechanism than SunOS 5.x
+  //    WLock.  For example, it implements "recursive WLock"
+  //    semantics, where a thread that owns the token can reacquire it
+  //    without deadlocking.  In addition, threads that are blocked
+  //    awaiting the token are serviced in strict FIFO order as other
+  //    threads release the token (SunOS 5.x WLocks don't strictly
+  //    enforce an acquisition order).
+  //
+  //    The interfaces for acquire, tryacquire, renew, release,
+  //    etc. are defined in ACE_Token_Proxy.  The semantics for
+  //    ACE_Local_WLock are that of a readers/writers lock.  Acquire
+  //    for this class implies a writer acquisition.  That is, only
+  //    one client may hold the lock for writing.
 public:
   // = Initialization and termination.
 
diff --git a/ace/Log_Msg.h b/ace/Log_Msg.h
index eed5ea2e791..4e87df1cb14 100644
--- a/ace/Log_Msg.h
+++ b/ace/Log_Msg.h
@@ -100,6 +100,7 @@
 class ACE_Thread_Descriptor;
 
 class ACE_Export ACE_Log_Msg
+{
   // = TITLE
   //     Provides a variable length argument message logging
   //     abstraction.
@@ -110,7 +111,6 @@ class ACE_Export ACE_Log_Msg
   //     distributed logger.  Moreover, the message is kept in a
   //     thread-specific storage location, which can be used to
   //     communicate errors between framework methods and callers.
-{
 public:
   // Logger Flags.
   enum
diff --git a/ace/Log_Priority.h b/ace/Log_Priority.h
index dc05f6df1b3..76040e7cc6b 100644
--- a/ace/Log_Priority.h
+++ b/ace/Log_Priority.h
@@ -18,6 +18,7 @@
 #define ACE_LOG_PRIORITY_H
 
 enum ACE_Log_Priority
+{
   // = TITLE
   //     This data type indicates the relative priorities of the
   //     logging messages, from lowest to highest priority.
@@ -25,7 +26,7 @@ enum ACE_Log_Priority
   // = DESCRIPTION
   //     These values are defined using powers of two so that it's
   //     possible to form a mask to turn them on or off dynamically.
-{
+
   // = Note, this first argument *must* start at 1! 
 
   LM_SHUTDOWN = 01,
diff --git a/ace/Log_Record.h b/ace/Log_Record.h
index 2e8ad1e4524..e5061fe2acb 100644
--- a/ace/Log_Record.h
+++ b/ace/Log_Record.h
@@ -24,9 +24,10 @@
 
 class ACE_Export ACE_Log_Record
 {
+public:
   // = TITLE
   //     Defines the structure of an ACE logging record.
-public:
+
   enum 
   {
     MAXLOGMSGLEN = ACE_MAXLOGMSGLEN,
diff --git a/ace/Malloc.h b/ace/Malloc.h
index 23f10c6e68d..1c2c27c0859 100644
--- a/ace/Malloc.h
+++ b/ace/Malloc.h
@@ -20,11 +20,11 @@
 #include "ace/ACE.h"
 
 class ACE_Export ACE_Allocator
+{
   // = TITLE
   //    Interface for a dynamic memory allocator that uses inheritance
   //    and dynamic binding to provide extensible mechanisms for
   //    allocating and deallocating memory.
-{
 public:
   // = Memory Management
   
@@ -194,10 +194,10 @@ union ACE_Export ACE_Malloc_Header
 };
 
 class ACE_Export ACE_Name_Node 
+{
   // = TITLE
   //    This is stored as a linked list within the Memory_Pool  
   //    to allow "named memory chunks."
-{
 public:
   // = Initialization methods.
   ACE_Name_Node (const char *name, void *, ACE_Name_Node *);
@@ -217,13 +217,13 @@ public:
 };
 
 class ACE_Export ACE_Control_Block
+{
   // = TITLE
   //    This information is stored in memory allocated by the MEMORY_POOL.
   //
   // = DESCRIPTION
   //    This class should be local to class ACE_Malloc, but cfront and
   //    G++ don't like nested classes in templates...
-{
 public:
   ACE_Name_Node *name_head_;
   // Head of the linked list of Name Nodes.
@@ -263,6 +263,7 @@ public:
 };
 
 class ACE_Export ACE_New_Allocator : public ACE_Allocator
+{
   // = TITLE
   //     Defines a class that provided a simple implementation of
   //     memory allocation.
@@ -275,7 +276,6 @@ class ACE_Export ACE_New_Allocator : public ACE_Allocator
   //     ACE_Allocator_Adapter <ACE_Malloc <ACE_LOCAL_MEMORY_POOL, MUTEX>>
   //     This will allow you to use the added functionality of
   //     bind/find/etc. while using the new/delete operators.
-{
 public:
   virtual void *malloc (size_t nbytes); 
   virtual void *calloc (size_t nbytes, char initial_value = '\0');
diff --git a/ace/Malloc_T.h b/ace/Malloc_T.h
index 65203da9df3..0a561873138 100644
--- a/ace/Malloc_T.h
+++ b/ace/Malloc_T.h
@@ -24,6 +24,7 @@
 
 template <class T>
 class ACE_Cached_Mem_Pool_Node
+{
   // = TITLE
   //    <ACE_Cached_Mem_Pool_Node> keeps unused memory within a free
   //    list.
@@ -35,7 +36,6 @@ class ACE_Cached_Mem_Pool_Node
   //    This class should really be placed within the next class
   //    <ACE_Cached_Allocator>.  But this can't be done due to C++
   //    compiler portability problems.
-{
 public:
   T *addr (void);
   // return the address of free memory.
@@ -83,10 +83,10 @@ private:
 
 template <class MALLOC>
 class ACE_Allocator_Adapter : public ACE_Allocator
+{
   // = TITLE
   //    This class is an Adapter that allows the <ACE_Allocator> to
   //    use the <Malloc> class below.
-{
 public:
   // Trait.
   typedef MALLOC ALLOCATOR;
@@ -206,6 +206,7 @@ class ACE_Malloc_Iterator;
 
 template <ACE_MEM_POOL_1, class ACE_LOCK>
 class ACE_Malloc
+{
   // = TITLE
   //     Define a C++ class that uses parameterized types to provide
   //     an extensible mechanism for encapsulating various of dynamic
@@ -215,9 +216,8 @@ class ACE_Malloc
   //     This class can be configured flexibly with different
   //     MEMORY_POOL strategies and different types of ACE_LOCK
   //     strategies.
-{
-friend class ACE_Malloc_Iterator<ACE_MEM_POOL_2, ACE_LOCK>;
 public:
+  friend class ACE_Malloc_Iterator<ACE_MEM_POOL_2, ACE_LOCK>;
   typedef ACE_MEM_POOL MEMORY_POOL;
   typedef ACE_MEM_POOL_OPTIONS MEMORY_POOL_OPTIONS;
 
@@ -378,17 +378,18 @@ private:
 
 template <ACE_MEM_POOL_1, class ACE_LOCK>
 class ACE_Malloc_Iterator
+{
   // = TITLE
   //     Iterator for names stored in Malloc'd memory.
   //
   // = DESCRIPTION
   //     Does not allows deletions while iteration is occurring.
-{
 public:
   // = Initialization method.
-  ACE_Malloc_Iterator (ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK> &malloc, const char *name = 0);
+  ACE_Malloc_Iterator (ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK> &malloc,
+                       const char *name = 0);
   // if <name> = 0 it will iterate through everything else only
-  // through those entries whose <name> match
+  // through those entries whose <name> match.
 
   ~ACE_Malloc_Iterator (void);
 
diff --git a/ace/Managed_Object.h b/ace/Managed_Object.h
index 186702efa02..0566718159f 100644
--- a/ace/Managed_Object.h
+++ b/ace/Managed_Object.h
@@ -22,6 +22,7 @@
 
 template <class TYPE>
 class ACE_Cleanup_Adapter : public ACE_Cleanup
+{
   // = TITLE
   //     Adapter for ACE_Cleanup objects that allows them to be readily
   //     managed by the ACE_Object_Manager.
@@ -33,7 +34,6 @@ class ACE_Cleanup_Adapter : public ACE_Cleanup
   //     typically used to replace a cast; but, it's a bit cleaner and
   //     allows insertion of, say, run-time type identification
   //     internally if desired.
-{
 public:
   ACE_Cleanup_Adapter (void);
   // Default constructor.
@@ -51,6 +51,7 @@ private:
 
 template <class TYPE>
 class ACE_Managed_Object
+{
   // = TITLE
   //     Wrapper for interface to allocate an object managed by the
   //     ACE_Object_Manager.
@@ -64,15 +65,15 @@ class ACE_Managed_Object
   //
   //     This interface is typically used to replace a static object
   //     with one that is dynamically allocated.  It helps to avoid
-  //     problems with order of static object construction/destruction.
-  //     Managed objects won't be allocated until needed, but should
-  //     be allocated when first needed.  And they are destroyed in
-  //     the reverse order of construction.
+  //     problems with order of static object
+  //     construction/destruction.  Managed objects won't be allocated
+  //     until needed, but should be allocated when first needed.  And
+  //     they are destroyed in the reverse order of construction.
   //
   //     get_preallocated_object () accesses a "preallocated" object,
   //     i.e., one that is identified by a value in the
-  //     ACE_Object_Manager::  Preallocated_Object enum.  These
-  //     objects are used internally by the ACE library.
+  //     ACE_Object_Manager:: Preallocated_Object enum.  These objects
+  //     are used internally by the ACE library.
   //
   //     Hooks are provided for the application to preallocate objects
   //     via the same mechanism.
@@ -80,10 +81,10 @@ class ACE_Managed_Object
   //     to define enum values;
   //     ACE_APPLICATION_PREALLOCATED_OBJECT_DEFINITIONS can be used
   //     to define the corresponding objects.  The format of the ACE
-  //     internal library definitions should be followed.  And similarly,
-  //     ACE_APPLICATION_PREALLOCATED_ARRAY_DECLARATIONS and
-  //     ACE_APPLICATION_PREALLOCATED_ARRAY_DEFINITIONS can be used to
-  //     preallocate arrays.
+  //     internal library definitions should be followed.  And
+  //     similarly, ACE_APPLICATION_PREALLOCATED_ARRAY_DECLARATIONS
+  //     and ACE_APPLICATION_PREALLOCATED_ARRAY_DEFINITIONS can be
+  //     used to preallocate arrays.
   //
   //     By default, preallocation uses dynamic allocation.  The
   //     preallocated objects and arrays are allocated off the heap in
@@ -91,10 +92,8 @@ class ACE_Managed_Object
   //     preallocated objects in program global data instead of on the
   //     heap, #define ACE_HAS_STATIC_PREALLOCATION prior to building
   //     the ACE library.
-{
 public:
-  static TYPE *
-  get_preallocated_object (ACE_Object_Manager::Preallocated_Object id)
+  static TYPE *get_preallocated_object (ACE_Object_Manager::Preallocated_Object id)
   {
     // The preallocated objects are in a separate, "read-only" array so
     // that this function doesn't need a lock.  Also, because it is
@@ -112,8 +111,7 @@ public:
   // Note: the function definition is inlined here so that it compiles
   // on AIX 4.1 w/xlC v. 3.01.
 
-  static TYPE *
-  get_preallocated_array (ACE_Object_Manager::Preallocated_Array id)
+  static TYPE *get_preallocated_array (ACE_Object_Manager::Preallocated_Array id)
   {
     // The preallocated array are in a separate, "read-only" array so
     // that this function doesn't need a lock.  Also, because it is
diff --git a/ace/Map_Manager.h b/ace/Map_Manager.h
index 312a67b2cd6..fe8595ac7d1 100644
--- a/ace/Map_Manager.h
+++ b/ace/Map_Manager.h
@@ -23,10 +23,11 @@
 class ACE_Allocator;
 
 template <class EXT_ID, class INT_ID>
-struct ACE_Map_Entry
+class ACE_Map_Entry
+{
   // = TITLE
   //     An entry in the Map.
-{
+public:
   EXT_ID ext_id_;
   // Key used to look up an entry.
 
@@ -57,6 +58,7 @@ class ACE_Map_Reverse_Iterator;
 
 template <class EXT_ID, class INT_ID, class ACE_LOCK>
 class ACE_Map_Manager
+{
   // = TITLE
   //     Define a map abstraction that associates <EXT_ID>s with
   //     <INT_ID>s.
@@ -71,11 +73,10 @@ class ACE_Map_Manager
   //     This implementation of a map uses an array, which is searched
   //     linearly.  For more efficient searching you should use the
   //     <ACE_Hash_Map_Manager>.
-
-{
-friend class ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>;
-friend class ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>;
 public:
+  friend class ACE_Map_Iterator<EXT_ID, INT_ID, ACE_LOCK>;
+  friend class ACE_Map_Reverse_Iterator<EXT_ID, INT_ID, ACE_LOCK>;
+
   // = Traits.
   typedef EXT_ID KEY;
   typedef INT_ID VALUE;
@@ -252,11 +253,9 @@ private:
 
 template <class EXT_ID, class INT_ID, class ACE_LOCK>
 class ACE_Map_Iterator
+{
   // = TITLE
   //     Iterator for the ACE_Map_Manager.
-  //
-  // = DESCRIPTION
-{
 public:
   // = Initialization method.
   ACE_Map_Iterator (ACE_Map_Manager <EXT_ID, INT_ID, ACE_LOCK> &mm);
@@ -290,11 +289,9 @@ private:
 
 template <class EXT_ID, class INT_ID, class ACE_LOCK>
 class ACE_Map_Reverse_Iterator
+{
   // = TITLE
   //     Reverse Iterator for the ACE_Map_Manager.
-  //
-  // = DESCRIPTION
-{
 public:
   // = Initialization method.
   ACE_Map_Reverse_Iterator (ACE_Map_Manager <EXT_ID, INT_ID, ACE_LOCK> &mm);
diff --git a/ace/Mem_Map.h b/ace/Mem_Map.h
index c60790f8fdb..48900f59f80 100644
--- a/ace/Mem_Map.h
+++ b/ace/Mem_Map.h
@@ -20,9 +20,13 @@
 #include "ace/ACE.h"
 
 class ACE_Export ACE_Mem_Map
-  // = TITLE
-  //     C++ interface to the mmap(2) UNIX system call.
 {
+  // = TITLE
+  //     C++ interface OS memory mapping system call.
+  //
+  // = DESCRIPTION
+  //     This class works with both the mmap(2) UNIX system and the
+  //     Win32 family of memory mapping system calls.
 public:
   // = Initialization and termination methods.
 
diff --git a/ace/Memory_Pool.h b/ace/Memory_Pool.h
index 277d79adeda..85b3d25cadd 100644
--- a/ace/Memory_Pool.h
+++ b/ace/Memory_Pool.h
@@ -27,19 +27,19 @@
 
 #if !defined (ACE_LACKS_SBRK)
 class ACE_Export ACE_Sbrk_Memory_Pool_Options
+{
   // = TITLE
   //     Helper class for constructor options.
   //
   // = DESCRIPTION
   //     This should be a nested class, but that breaks too many 
   //     compilers.
-{
 };
 
 class ACE_Export ACE_Sbrk_Memory_Pool
+{
   // = TITLE
   //     Make a memory pool that is based on <sbrk(2)>.
-{
 public:
   typedef ACE_Sbrk_Memory_Pool_Options OPTIONS;
 
@@ -95,13 +95,13 @@ protected:
 #if !defined (ACE_LACKS_SYSV_SHMEM)
 
 class ACE_Export ACE_Shared_Memory_Pool_Options
+{
   // = TITLE
   //     Helper class for constructor options.
   //
   // = DESCRIPTION
   //     This should be a nested class, but that breaks too many 
   //     compilers.
-{
 public:
   // = Initialization method.
   ACE_Shared_Memory_Pool_Options (char *base_addr = ACE_DEFAULT_BASE_ADDR,
@@ -123,11 +123,11 @@ public:
 };
 
 class ACE_Export ACE_Shared_Memory_Pool : public ACE_Event_Handler
+{
   // = TITLE
   //     Make a memory pool that is based on System V shared memory
   //     (shmget(2) etc.).  This implementation allows memory to be
   //     shared between processes.
-{
 public:
   typedef ACE_Shared_Memory_Pool_Options OPTIONS;
 
@@ -231,20 +231,21 @@ protected:
 #endif /* !ACE_LACKS_SYSV_SHMEM */
 
 class ACE_Export ACE_Local_Memory_Pool_Options
+{
   // = TITLE
   //     Helper class for constructor options.
   //
   // = DESCRIPTION
   //     This should be a nested class, but that breaks too many 
   //     compilers.
-{};
+};
 
 class ACE_Export ACE_Local_Memory_Pool
+{
   // = TITLE
   //   Make a memory pool that is based on C++ new/delete.  This is
   //   useful for integrating existing components that use new/delete
   //   into the ACE Malloc scheme...
-{
 public:
   typedef ACE_Local_Memory_Pool_Options OPTIONS;
 
@@ -297,13 +298,13 @@ protected:
 };
 
 class ACE_Export ACE_MMAP_Memory_Pool_Options
+{
   // = TITLE
   //     Helper class for constructor options.
   //
   // = DESCRIPTION
   //     This should be a nested class, but that breaks too many 
   //     compilers.
-{
 public:
   // = Initialization method.
   ACE_MMAP_Memory_Pool_Options (void *base_addr = ACE_DEFAULT_BASE_ADDR,
@@ -340,10 +341,10 @@ public:
 };
 
 class ACE_Export ACE_MMAP_Memory_Pool : public ACE_Event_Handler
+{
   // = TITLE
   //     Make a memory pool that is based on <mmap(2)>.  This
   //     implementation allows memory to be shared between processes.
-{
 public:
   typedef ACE_MMAP_Memory_Pool_Options OPTIONS;
 
@@ -451,6 +452,7 @@ protected:
 };
 
 class ACE_Export ACE_Lite_MMAP_Memory_Pool : public ACE_MMAP_Memory_Pool
+{
   // = TITLE
   //     Make a ``lighter-weight'' memory pool based <ACE_Mem_Map>.  
   // 
@@ -461,7 +463,6 @@ class ACE_Export ACE_Lite_MMAP_Memory_Pool : public ACE_MMAP_Memory_Pool
   //     for the price of flushing the memory to the backing store on
   //     every update.  Naturally, this trades off increased
   //     performance for less reliability if the machine crashes.
-{
 public:
   // = Initialization and termination methods.
 
diff --git a/ace/Message_Block.h b/ace/Message_Block.h
index 590925d76e2..28482bfc851 100644
--- a/ace/Message_Block.h
+++ b/ace/Message_Block.h
@@ -26,6 +26,7 @@ class ACE_Data_Block;
 class ACE_Lock;
 
 class ACE_Export ACE_Message_Block
+{
   // = TITLE
   //     Stores messages for use throughout ACE (particularly
   //     <ACE_Message_Queue>).
@@ -48,9 +49,9 @@ class ACE_Export ACE_Message_Block
   //     3. <ACE_Message_Blocks> can be linked together by <prev_> and
   //     <next_> pointers to form a queue of messages (e.g., this is how
   //     <ACE_Message_Queue> works).
-{
-  friend class ACE_Data_Block;
 public:
+  friend class ACE_Data_Block;
+
   enum ACE_Message_Type
   {
     // = Data and protocol messages (regular and priority)
@@ -359,6 +360,7 @@ private:
 };
 
 class ACE_Export ACE_Data_Block
+{
   // = TITLE
   //     Stores the data payload that is accessed via one or more
   //     <ACE_Message_Block>s.
@@ -369,7 +371,6 @@ class ACE_Export ACE_Data_Block
   //     protects the reference count from race conditions in
   //     concurrent programs) and the <allocation_strategy_> (which
   //     determines what memory pool is used to allocate the memory).
-{
 public:
   // = Initialization and termination methods.
   ACE_Data_Block (void);
diff --git a/ace/Message_Queue.h b/ace/Message_Queue.h
index 6a3c26aedb5..567d4e54c81 100644
--- a/ace/Message_Queue.h
+++ b/ace/Message_Queue.h
@@ -27,6 +27,7 @@ template <ACE_SYNCH_DECL> class ACE_Message_Queue_Reverse_Iterator;
 
 template <ACE_SYNCH_DECL>
 class ACE_Message_Queue
+{
   // = TITLE
   //     A threaded message queueing facility, modeled after the
   //     queueing facilities in System V STREAMs.
@@ -36,10 +37,9 @@ class ACE_Message_Queue
   //     messages in the ASX framework.  If <ACE_SYNCH_DECL> is
   //     ACE_MT_SYNCH then all operations are thread-safe.  Otherwise,
   //     if it's <ACE_NULL_SYNCH> then there's no locking overhead.
-{
-friend class ACE_Message_Queue_Iterator<ACE_SYNCH_USE>;
-friend class ACE_Message_Queue_Reverse_Iterator<ACE_SYNCH_USE>;
 public:
+  friend class ACE_Message_Queue_Iterator<ACE_SYNCH_USE>;
+  friend class ACE_Message_Queue_Reverse_Iterator<ACE_SYNCH_USE>;
 
   // = Traits
   typedef ACE_Message_Queue_Iterator<ACE_SYNCH_USE> ITERATOR;
@@ -284,9 +284,9 @@ private:
 
 template <ACE_SYNCH_DECL>
 class ACE_Message_Queue_Iterator
+{
   // = TITLE
   //     Iterator for the <ACE_Message_Queue>.
-{
 public:
   // = Initialization method.
   ACE_Message_Queue_Iterator (ACE_Message_Queue <ACE_SYNCH_USE> &queue);
@@ -319,9 +319,9 @@ private:
 
 template <ACE_SYNCH_DECL>
 class ACE_Message_Queue_Reverse_Iterator
+{
   // = TITLE
   //     Reverse Iterator for the <ACE_Message_Queue>.
-{
 public:
   // = Initialization method.
   ACE_Message_Queue_Reverse_Iterator (ACE_Message_Queue <ACE_SYNCH_USE> &queue);
diff --git a/ace/Method_Object.h b/ace/Method_Object.h
index 49daaff39d5..23c5b3a303c 100644
--- a/ace/Method_Object.h
+++ b/ace/Method_Object.h
@@ -22,6 +22,7 @@
 #include "ace/OS.h"
 
 class ACE_Export ACE_Method_Object 
+{
   // = TITLE
   //     Reifies a method into an object.  Subclasses typically
   //     represent necessary state and behavior.
@@ -29,7 +30,6 @@ class ACE_Export ACE_Method_Object
   // = DESCRIPTION
   //     A <Method_Object> is inserted in the <Activation_Queue>, where
   //     it is subsequently removed by the <Scheduler> and invoked.
-{
 public:
   // = Initialization and termination methods.
   ACE_Method_Object (void);
diff --git a/ace/Module.h b/ace/Module.h
index 7a1b34da082..f0a667e6d4f 100644
--- a/ace/Module.h
+++ b/ace/Module.h
@@ -25,6 +25,7 @@
 
 template <ACE_SYNCH_DECL>
 class ACE_Module
+{
   // = TITLE
   //     An abstraction for managing a bi-directional flow of messages.
   // 
@@ -32,9 +33,9 @@ class ACE_Module
   //     This is based on the Module concept in System V Streams,
   //     which contains a pair of Tasks, one for handling upstream
   //     processing, one for handling downstream processing.
-{
-  friend class ACE_Shutup_GPlusPlus;  // Turn off g++ warning
 public:
+  friend class ACE_Shutup_GPlusPlus;  // Turn off g++ warning
+
   enum
   {
     M_DELETE_NONE = 0,
diff --git a/ace/Multiplexor.h b/ace/Multiplexor.h
index 960d67e371e..074601f1890 100644
--- a/ace/Multiplexor.h
+++ b/ace/Multiplexor.h
@@ -10,7 +10,10 @@
 // = FILENAME
 //    Multiplexor.h
 //
-// Define the Driver and ACE_Multiplexor container classes.
+// = DESCRIPTION
+//     Define the ACE_Driver and ACE_Multiplexor container classes.
+//     Note that these classes have never been implemented due to lack
+//     of need.
 //
 // = AUTHOR
 //    Doug Schmidt 
@@ -27,41 +30,40 @@
 #if defined (ACE_HAS_THREADS)
 
 #if 0
-class Driver
+class ACE_Export ACE_Driver
+{
   // = TITLE
   //
   //
   // = DESCRIPTION
   //
-{
 public:
-  Driver (void);
-  ~Driver (void);
+  ACE_Driver (void);
+  ~ACE_Driver (void);
   
   virtual int link_from_below (ACE_Module *mod);
-  virtual ACE_Module *alloc_module (Driver *) = 0;
+  virtual ACE_Module *alloc_module (ACE_Driver *) = 0;
   virtual int unlink_from_below (ACE_Module *);
 };
 
 class ACE_Export ACE_Multiplexor
+{
   // = TITLE
   //
-  //
   // = DESCRIPTION
   //
-{
 public:
   // = Constructors and destructors 
   ACE_Multiplexor (void);
   ~ACE_Multiplexor (void);
 
-  virtual int link_from_above (Driver &ld);
+  virtual int link_from_above (ACE_Driver &ld);
   virtual int link_from_above (ACE_Multiplexor &lm);
   virtual int link_from_below (ACE_Module *mod);
   virtual ACE_Module *alloc_lower_module (ACE_Multiplexor *) = 0;
   virtual ACE_Module *alloc_upper_module (ACE_Multiplexor *) = 0;
 
-  virtual int unlink_from_above (Driver &ld);
+  virtual int unlink_from_above (ACE_Driver &ld);
   virtual int unlink_from_above (ACE_Multiplexor &lm);
   virtual int unlink_from_below (ACE_Module *mod);
 };
diff --git a/ace/Name_Proxy.h b/ace/Name_Proxy.h
index d41d456e4ef..3227b081f15 100644
--- a/ace/Name_Proxy.h
+++ b/ace/Name_Proxy.h
@@ -30,12 +30,14 @@
 #include "ace/Name_Request_Reply.h"
 
 class ACE_Export ACE_Name_Proxy : public ACE_Event_Handler
+{
   // = TITLE
-  //   Proxy for dealing with remote server process managing NET_LOCAL NameBindings
+  //   Proxy for dealing with remote server process managing NET_LOCAL
+  //   NameBindings.
   //
   // = DESCRIPTION
-  //   Shields applications from details of interacting with the ACE_Name Server.
-{
+  //   Shields applications from details of interacting with the
+  //   ACE_Name Server.
 public:
   ACE_Name_Proxy (void);
   // Default constructor.
diff --git a/ace/Name_Request_Reply.h b/ace/Name_Request_Reply.h
index 7ff3f066b89..2541ae721a2 100644
--- a/ace/Name_Request_Reply.h
+++ b/ace/Name_Request_Reply.h
@@ -26,13 +26,13 @@
 #include "ace/SString.h"
 
 class ACE_Export ACE_Name_Request
+{
   // = TITLE
-  //   Message format for delivering requests to the ACE_Name Server.
+  //     Message format for delivering requests to the ACE_Name Server.
   //
   // = DESCRIPTION
-  //   This class is implemented to minimize data copying.
-  //   In particular, all marshaling is done in situ...
-{
+  //     This class is implemented to minimize data copying.  In
+  //     particular, all marshaling is done in situ...
 public:
   enum Constants
   {
@@ -176,13 +176,13 @@ private:
 };
 
 class ACE_Export ACE_Name_Reply
+{
   // = TITLE
   //     Message format for delivering replies from the ACE_Name Server.
   //
   // = DESCRIPTION
-  //   This class is implemented to minimize data copying.
-  //   In particular, all marshaling is done in situ...
-{
+  //     This class is implemented to minimize data copying.  In
+  //     particular, all marshaling is done in situ...
 public:
   enum Constants
   {
diff --git a/ace/Name_Space.h b/ace/Name_Space.h
index 2328b4d3c41..1b3b0abd887 100644
--- a/ace/Name_Space.h
+++ b/ace/Name_Space.h
@@ -1,8 +1,6 @@
 /* -*- C++ -*- */
 // $Id$
 
-/*-*- C++ -*- */
-
 // ============================================================================
 //
 // = LIBRARY
@@ -28,6 +26,8 @@ typedef ACE_Unbounded_Set<ACE_WString> ACE_WSTRING_SET;
 
 class ACE_Export ACE_Name_Binding
 {
+  // = TITLE
+  //     Maintains a mapping from name to value and type.
 public:
   // = Initialization and termination.
   ACE_Name_Binding (const ACE_WString &n,
@@ -67,6 +67,7 @@ typedef ACE_Unbounded_Set<ACE_WString> ACE_PWSTRING_SET;
 typedef ACE_Unbounded_Set_Iterator<ACE_WString> ACE_PWSTRING_ITERATOR;
 
 class ACE_Export ACE_Name_Space
+{
   // = TITLE
   //     Abstract base class that provides an abstract interface to
   //	 the database without exposing any implemenation details.
@@ -74,7 +75,6 @@ class ACE_Export ACE_Name_Space
   // = DESCRIPTION
   //     Manages a Naming Service Name Space. Provides the basic
   //	 methods -- bind, unbind, rebind, find, and listnames.
-{
 public:
 
   virtual ~ACE_Name_Space (void);
diff --git a/ace/Naming_Context.h b/ace/Naming_Context.h
index eb465e684a7..8ffc7e0f066 100644
--- a/ace/Naming_Context.h
+++ b/ace/Naming_Context.h
@@ -30,6 +30,7 @@
 class ACE_Name_Options;
 
 class ACE_Export ACE_Naming_Context : public ACE_Service_Object
+{
   // = TITLE
   //     Maintaining accesses Name Server Databases.  Allows to add
   //     NameBindings, change them, remove them and resolve
@@ -48,7 +49,6 @@ class ACE_Export ACE_Naming_Context : public ACE_Service_Object
   //     character strings. A Name Binding consists of a name string
   //     (that's the key), a value string and an optional type string
   //     (no wide chars).
-{
 public:
   enum Context_Scope_Type
     {
@@ -243,9 +243,9 @@ private:
 };
 
 class ACE_Export ACE_Name_Options
+{
   // = TITLE
   //     Manages the options for the ACE Name_Server.
-{
 public:
   // = Initialization and termination methods.
   ACE_Name_Options (void);
diff --git a/ace/OS.h b/ace/OS.h
index c4ec6a28fb0..d6efa48de50 100644
--- a/ace/OS.h
+++ b/ace/OS.h
@@ -961,6 +961,7 @@ typedef int clockid_t;
 #endif /* ! ACE_HAS_CLOCK_GETTIME && ! _CLOCKID_T */
 
 class ACE_Export ACE_Time_Value
+{
   // = TITLE
   //     Operations on "timeval" structures.
   //
@@ -970,7 +971,6 @@ class ACE_Export ACE_Time_Value
   //     lower-level OS mechanisms like <select>, <poll>, or
   //     <cond_timedwait>.  ACE_Time_Value help make the use of these
   //     mechanisms portable across OS platforms,
-{
 public:
   // = Useful constants.
   static const ACE_Time_Value zero;
@@ -1104,6 +1104,7 @@ private:
 };
 
 class ACE_Export ACE_Countdown_Time
+{
   // = TITLE
   //     Keeps track of the amount of elapsed time.
   //
@@ -1111,7 +1112,6 @@ class ACE_Export ACE_Countdown_Time
   //     This class has a side-effect on the <max_wait_time> -- every
   //     time the <stop> method is called the <max_wait_time> is
   //     updated.
-{
 public:
   // = Initialization and termination methods.
   ACE_Countdown_Time (ACE_Time_Value *max_wait_time);
@@ -1992,6 +1992,7 @@ typedef HANDLE ACE_sema_t;
 
 #if defined (ACE_LACKS_COND_T)
 class ACE_Export ACE_cond_t
+{
   // = TITLE
   //     This structure is used to implement condition variables on
   //     VxWorks and Win32.
@@ -1999,9 +2000,9 @@ class ACE_Export ACE_cond_t
   // = DESCRIPTION
   //     At the current time, this stuff only works for threads
   //     within the same process.
-{
-  friend class ACE_OS;
 public:
+  friend class ACE_OS;
+
   long waiters (void) const;
   // Returns the number of waiters.
 
@@ -2036,6 +2037,7 @@ protected:
 
 #if defined (ACE_LACKS_RWLOCK_T)
 struct ACE_Export ACE_rwlock_t
+{
   // = TITLE
   //     This is used to implement readers/writer locks on NT,
   //     VxWorks, and POSIX pthreads.
@@ -2043,9 +2045,9 @@ struct ACE_Export ACE_rwlock_t
   // = DESCRIPTION
   //     At the current time, this stuff only works for threads
   //     within the same process.
-{
-friend class ACE_OS;
 protected:
+  friend class ACE_OS;
+
   ACE_mutex_t lock_;
   // Serialize access to internal state.
 
@@ -3500,9 +3502,9 @@ typedef int ucontext_t;
 #endif /* ACE_HAS_BROKEN_T_ERRNO */
 
 class ACE_Export ACE_Thread_ID
+{
   // = TITLE
   //     Defines a platform-independent thread ID.
-{
 public:
   // = Initialization method.
   ACE_Thread_ID (ACE_thread_t, ACE_hthread_t);
@@ -3585,10 +3587,11 @@ struct strbuf
 };
 #endif /* ACE_HAS_STRBUF_T */
 
-struct ACE_Export ACE_Str_Buf : public strbuf
+class ACE_Export ACE_Str_Buf : public strbuf
+{
   // = TITLE
   //     Simple wrapper for STREAM pipes strbuf.
-{
+public:
   // = Initialization method
   ACE_Str_Buf (void *b = 0, int l = 0, int max = 0);
   // Constructor.
@@ -3623,9 +3626,9 @@ typedef void (*ACE_CLEANUP_FUNC)(void *object, void *param) /* throw () */;
 #endif /* ACE_HAS_SIG_C_FUNC */
 
 class ACE_Export ACE_Cleanup
+{
   // = TITLE
   //    Base class for objects that are cleaned by ACE_Object_Manager.
-{
 public:
   virtual ~ACE_Cleanup ();
   // Destructor.
@@ -3638,10 +3641,11 @@ public:
 extern "C" ACE_Export
 void ace_cleanup_destroyer (ACE_Cleanup *, void *param = 0);
 
-struct ACE_Cleanup_Info
+class ACE_Cleanup_Info
+{
   // = TITLE
   //     Hold cleanup information for thread/process
-{
+public:
   ACE_Cleanup_Info (void);
   // Default constructor.
 
@@ -3670,6 +3674,7 @@ class ACE_Thread_Manager;
 class ACE_Thread_Descriptor;
 
 class ACE_Thread_Adapter
+{
   // = TITLE
   //     Converts a C++ function into a function <ace_thread_adapter>
   //     function that can be called from a thread creation routine
@@ -3680,7 +3685,6 @@ class ACE_Thread_Adapter
   //
   // = DESCRIPTION
   //     This class is used in <ACE_OS::thr_create>.
-{
 public:
   ACE_Thread_Adapter (ACE_THR_FUNC user_func,
                       void *arg,
@@ -3748,6 +3752,7 @@ private:
 };
 
 class ACE_Export ACE_OS
+{
   // = TITLE
   //     This class defines an operating system independent
   //     programming API that shields developers from non-portable
@@ -3765,14 +3770,14 @@ class ACE_Export ACE_OS
   //     The methods in this class also automatically restart when
   //     interrupts occur during system calls (assuming that the
   //     <ACE_Log_Msg::restart> flag is enabled).
-{
+public:
   ACE_CLASS_IS_NAMESPACE (ACE_OS);
 
-public:
-  struct ace_flock_t
+  class ace_flock_t
+  {
     // = TITLE
     //     OS file locking structure.
-  {
+  public:
     void dump (void) const;
   // Dump state of the object.
 
@@ -4820,6 +4825,7 @@ extern "C" ssize_t writev_timedwait (ACE_HANDLE handle,
 #   endif /* ! ACE_DEFAULT_THREAD_KEYS */
 
 class ACE_TSS_Emulation
+{
   // = TITLE
   //     Thread-specific storage emulation.
   //
@@ -4828,7 +4834,6 @@ class ACE_TSS_Emulation
   //     It is intended for use on platforms that don't have a
   //     native TSS, or have a TSS with limitations such as the
   //     number of keys or lack of support for removing keys.
-{
 public:
   typedef void (*ACE_TSS_DESTRUCTOR)(void *value) /* throw () */;
 
diff --git a/ace/Object_Manager.h b/ace/Object_Manager.h
index fad9669bb14..9f05c5e744d 100644
--- a/ace/Object_Manager.h
+++ b/ace/Object_Manager.h
@@ -44,6 +44,7 @@ template <class T> class ACE_Unbounded_Queue;
 #endif /* ! ACE_APPLICATION_PREALLOCATED_ARRAY_DECLARATIONS */
 
 class ACE_Export ACE_Object_Manager
+{
   // = TITLE
   //     Manager for ACE library services and singleton cleanup.
   //
@@ -142,7 +143,6 @@ class ACE_Export ACE_Object_Manager
   //        cleaned up by the Object_Manager, they'll get cleaned up too
   //        late.  The ACE tests do not violate this requirement.
   //        However, applications may have trouble with it.
-{
 public:
   static int at_exit (ACE_Cleanup *object, void *param = 0);
   // Register an ACE_Cleanup object for cleanup at process termination.
@@ -357,6 +357,7 @@ private:
 class ACE_Recursive_Thread_Mutex;
 
 class ACE_Export ACE_Static_Object_Lock
+{
   // = TITLE
   //     Provide an interface to access a global lock.
   //
@@ -365,7 +366,6 @@ class ACE_Export ACE_Static_Object_Lock
   //     singleton objects.  It really isn't needed any more, because
   //     anyone can access ACE_STATIC_OBJECT_LOCK directly.  But, it
   //     is retained for backward compatibility.
-{
 public:
   static ACE_Recursive_Thread_Mutex *instance (void);
   // Static lock access point.
diff --git a/ace/Obstack.h b/ace/Obstack.h
index 91540994bc2..d44ef43fa13 100644
--- a/ace/Obstack.h
+++ b/ace/Obstack.h
@@ -21,10 +21,10 @@
 #include "ace/ACE.h"
 
 class ACE_Export ACE_Obchunk
+{
   // = TITLE
   //     A "chunk" of memory.  This should be a nested class but some
   //     compilers don't like them yet. 
-{
 friend class ACE_Obstack;
   
 public:
@@ -42,10 +42,10 @@ private:
 };
 
 class ACE_Export ACE_Obstack
+{
   // = TITLE
   //    Define a simple "mark and release" memory allocation utility.
   //    This class is based on the GNU obstack utility.
-{
 public:
   // = Initialization and termination methods.
   ACE_Obstack (int size = 4080);
diff --git a/ace/Parse_Node.h b/ace/Parse_Node.h
index b982d487f7f..2e70c91e9f9 100644
--- a/ace/Parse_Node.h
+++ b/ace/Parse_Node.h
@@ -20,10 +20,10 @@
 #include "ace/Service_Types.h"
 
 class ACE_Export ACE_Parse_Node
+{
   // = TITLE
   //    Provide the base of the object hierarchy that defines the parse
   //    tree of Service Nodes.
-{
 public:
   ACE_Parse_Node (void);
   ACE_Parse_Node (const char *name);
@@ -48,9 +48,9 @@ private:
 };
 
 class ACE_Export ACE_Suspend_Node : public ACE_Parse_Node
+{
   // = TITLE
   //     Suspend a Service Node.
-{
 public:
   ACE_Suspend_Node (const char *name);
 
@@ -64,9 +64,9 @@ public:
 };
 
 class ACE_Export ACE_Resume_Node : public ACE_Parse_Node
+{
   // = TITLE
   //     Resume a Service Node.
-{
 public:
   ACE_Resume_Node (const char *name);
 
@@ -80,9 +80,9 @@ public:
 };
 
 class ACE_Export ACE_Remove_Node : public ACE_Parse_Node
+{
   // = TITLE
   //     Remove a Service Node.
-{
 public:
   ACE_Remove_Node (const char *name);
 
@@ -96,9 +96,9 @@ public:
 };
 
 class ACE_Export ACE_Static_Node : public ACE_Parse_Node
+{
   // = TITLE
   //     Handle a statically linked node.
-{
 public:
   ACE_Static_Node (const char *name, char *params = 0);
   virtual ~ACE_Static_Node (void);
@@ -118,9 +118,9 @@ private:
 };
 
 class ACE_Export ACE_Dynamic_Node : public ACE_Static_Node
+{
   // = TITLE
   //     Handle a dynamically linked node.
-{
 public:
   ACE_Dynamic_Node (const ACE_Service_Type *, char *params);
   virtual ~ACE_Dynamic_Node (void);
@@ -139,9 +139,9 @@ private:
 };
 
 class ACE_Export ACE_Stream_Node : public ACE_Parse_Node
+{
   // = TITLE
   //     Handle a Stream.
-{
 public:
   ACE_Stream_Node (const ACE_Static_Node *, const ACE_Parse_Node *);
   virtual ~ACE_Stream_Node (void);
@@ -160,9 +160,9 @@ private:
 };
 
 class ACE_Export ACE_Location_Node
+{
   // = TITLE
   //     Keep track of where a shared library is located.
-{
 public:
   ACE_Location_Node (void);
   virtual const void *symbol (void) = 0;
@@ -191,9 +191,9 @@ protected:
 };
 
 class ACE_Export ACE_Object_Node : public ACE_Location_Node
+{
   // = TITLE
   //   Keeps track of the symbol name for a shared object.
-{
 public:
   ACE_Object_Node (const char *pathname, const char *obj_name);
   virtual const void *symbol (void);
@@ -210,9 +210,9 @@ private:
 };
 
 class ACE_Export ACE_Function_Node : public ACE_Location_Node
+{
   // = TITLE
   //     Keeps track of the symbol name of for a shared function.
-{
 public:
   ACE_Function_Node (const char *pathname, const char *func_name);
   virtual const void *symbol (void);
@@ -229,9 +229,9 @@ private:
 };
 
 class ACE_Export ACE_Dummy_Node : public ACE_Parse_Node
+{
   // = TITLE
   //     I forget why this is here... ;-)
-{
 public:
   ACE_Dummy_Node (const ACE_Static_Node *, const ACE_Parse_Node *);
   ~ACE_Dummy_Node (void);
@@ -249,11 +249,11 @@ private:
 };
 
 class ACE_Export ACE_Static_Function_Node : public ACE_Location_Node
+{
   // = TITLE
   //     Keeps track of the symbol name for a function that is not
   //     linked in from a DLL, but is statically linked with the
   //     application. 
-{
 public:
   ACE_Static_Function_Node (const char *func_name);
   virtual const void *symbol (void);
diff --git a/ace/Pipe.h b/ace/Pipe.h
index ae42112d542..94b1f678f1f 100644
--- a/ace/Pipe.h
+++ b/ace/Pipe.h
@@ -21,6 +21,7 @@
 #include "ace/ACE.h"
 
 class ACE_Export ACE_Pipe
+{
   // = TITLE
   //     Provides a bidirectional "pipe" abstraction that is portable
   //     to Windows NT, SVR4 UNIX, and BSD UNIX.
@@ -28,7 +29,6 @@ class ACE_Export ACE_Pipe
   // = DESCRIPTION
   //     Uses "name" for lookup in the ACE service repository. Obtains
   //	 the object and returns it as the appropriate type.
-{
 public:
   // = Initialization and termination.
   ACE_Pipe (void);
diff --git a/ace/Priority_Reactor.h b/ace/Priority_Reactor.h
index 7285a0ded59..9b1d32f58ac 100644
--- a/ace/Priority_Reactor.h
+++ b/ace/Priority_Reactor.h
@@ -21,16 +21,14 @@
 #include "ace/Select_Reactor.h"
 
 class ACE_Export ACE_Priority_Reactor : public ACE_Select_Reactor
+{
   // = TITLE
-  //
   //     Implements priority based dispatching.
   //
   // = DESCRIPTION
-  //
   //     This class refines the dispatching mechanism for the
   //     Select_Reactor by taking advantage of the priority method on
   //     ACE_Event_Handler.
-{
 public:
   // = Initialization and termination methods.
 
diff --git a/ace/Proactor.h b/ace/Proactor.h
index 996beceaa57..c785aa2b3a8 100644
--- a/ace/Proactor.h
+++ b/ace/Proactor.h
@@ -36,19 +36,18 @@ class ACE_Proactor_Timer_Handler;
 class ACE_Proactor;
 
 class ACE_Export ACE_Proactor_Handle_Timeout_Upcall
+{
   // = TITLE 
   //      Functor for Timer_Queues.
   //
   // = DESCRIPTION
-  //
   //      This class implements the functor required by the Timer
   //      Queue to call <handle_timeout> on ACE_Handlers.
-{
+public:
   friend class ACE_Proactor;
   // Proactor has special privileges
   // Access needed to: proactor ()
 
-public:
   typedef ACE_Timer_Queue_T<ACE_Handler *, 
                             ACE_Proactor_Handle_Timeout_Upcall, 
                             ACE_SYNCH_RECURSIVE_MUTEX> TIMER_QUEUE;
@@ -81,15 +80,13 @@ protected:
 };
 
 class ACE_Export ACE_Proactor : public ACE_Event_Handler
-  //     
+{
   // = TITLE
-  //
   //     A Proactor for asynchronous I/O events.
   // 
   // = DESCRIPTION
-  //     
   //     A manager for the I/O completion port.
-{
+public:
   friend class ACE_Proactor_Timer_Handler;
   // Timer Handler has special privileges because
   // Access needed to: thr_mgr_
@@ -97,11 +94,7 @@ class ACE_Export ACE_Proactor : public ACE_Event_Handler
   friend class ACE_Proactor_Handle_Timeout_Upcall;  
   // Access needed to: Asynch_Timer, and completion_port_
 
-public:
-
-  // Here are the typedef for Timer_Queue, Timer_List, and Timer_Heap
-  // for the Proactor (add to the ease of use of these template
-  // classes).
+  // = Here are the typedefs that the <ACE_Proactor> uses.
 
   typedef ACE_Timer_Queue_T<ACE_Handler *, 
                             ACE_Proactor_Handle_Timeout_Upcall, 
@@ -266,19 +259,17 @@ protected:
   // before any events occur, return.
   
   class ACE_Export Asynch_Timer : protected ACE_Asynch_Result
-    //     
-    // = TITLE
-    //
-    //     This class is posted to the completion port when a timer
-    //     expires. When the complete method of this object is called,
-    //     the <handler>'s handle_timeout method will be called.
-    // 
     {
+      // = TITLE
+      //     This class is posted to the completion port when a timer
+      //     expires. When the complete method of this object is
+      //     called, the <handler>'s handle_timeout method will be
+      //     called.
+    public:
       friend class ACE_Proactor_Handle_Timeout_Upcall;
       // Timer Handler has special privileges
       // Access needed to: convert Asynch_Timer into an OVERLAPPED
 
-    public:
       Asynch_Timer (ACE_Handler &handler,
 		    const void *act,
 		    const ACE_Time_Value &tv, 
diff --git a/ace/Process.h b/ace/Process.h
index 42413c4ee83..d29fe9a491c 100644
--- a/ace/Process.h
+++ b/ace/Process.h
@@ -20,13 +20,13 @@
 #include "ace/OS.h"
 
 class ACE_Export ACE_Process_Options
+{
   // = TITLE
   //    Process Options
   //
   // = DESCRIPTION
   //    This class controls the options passed to <CreateProcess> (or <fork>
   //    and <exec>).
-{
 public:
   enum 
   { 
@@ -234,12 +234,12 @@ protected:
 // ************************************************************
 
 class ACE_Export ACE_Process
+{
   // = TITLE
   //     Process
   //
   // = DESCRIPTION
   //     A Portable encapsulation for creating new processes.
-{
 public:
   ACE_Process (void);
   // Default construction.  Must use ACE_Process::start.
@@ -283,6 +283,7 @@ protected:
 // ************************************************************
 
 class ACE_Export ACE_Tokenizer
+{
   // = TITLE
   //    Tokenizer
   //
@@ -290,7 +291,6 @@ class ACE_Export ACE_Tokenizer
   //    Tokenizes a buffer.  Allows application to set delimiters and
   //    preserve designators.  Does not allow special characters, yet
   //    (e.g., printf ("\"like a quoted string\"").
-{
 public:
   ACE_Tokenizer (LPTSTR buffer);
   // <buffer> will be parsed.
@@ -331,9 +331,11 @@ private:
   LPTSTR buffer_;
   int index_;
 
-  struct Preserve_Entry
+  class Preserve_Entry
+  {
     // = TITLE
     //    Preserve Entry
+    //
     // = DESCRIPTION
     //    Defines a set of characters that designate an area that
     //    should not be parsed, but should be treated as a complete
@@ -341,7 +343,7 @@ private:
     //    would be a left paren -(- and stop would be a right paren
     //    -)-.  The strip determines whether the designators should be
     //    removed from the token.
-  {
+  public:
     TCHAR start_;
     // E.g., "(".
     TCHAR stop_;
@@ -356,12 +358,14 @@ private:
   int preserves_index_;
   // Pointer to the next free spot in preserves_.
 
-  struct Delimiter_Entry
+  class Delimiter_Entry
+  {
     // = TITLE
     //    Delimiter Entry
+    //
     // = DESCRIPTION
     //    Describes a delimiter for the tokenizer.
-  {
+  public:
     TCHAR delimiter_;
     // Most commonly a space ' '.
     TCHAR replacement_;
diff --git a/ace/Process_Manager.h b/ace/Process_Manager.h
index a16abbb3eac..d4d8c3f48db 100644
--- a/ace/Process_Manager.h
+++ b/ace/Process_Manager.h
@@ -21,11 +21,11 @@
 #include "ace/Process.h"
 
 class ACE_Export ACE_Process_Descriptor
-  // = Title
-  //    Information for controlling groups of processs.
 {
-friend class ACE_Process_Manager;
+  // = TITLE
+  //    Information for controlling groups of processs.
 private:
+  friend class ACE_Process_Manager;
 
   ACE_Process_Descriptor (void);
 
@@ -40,14 +40,15 @@ private:
 };
 
 class ACE_Export ACE_Process_Manager
+{
   // = TITLE
   //    Manages a pool of processs.
   //
   // = DESCRIPTION
   //    This class allows operations on groups of processs atomically. 
-{
-friend class ACE_Process_Control;
 public:
+  friend class ACE_Process_Control;
+
   enum
   {
     DEFAULT_SIZE = 100
diff --git a/ace/Profile_Timer.h b/ace/Profile_Timer.h
index 29add308f84..6776f629771 100644
--- a/ace/Profile_Timer.h
+++ b/ace/Profile_Timer.h
@@ -45,9 +45,9 @@ private:
 };
 #else
 class ACE_Export ACE_Profile_Timer
+{
   // = TITLE
   //     A C++ wrapper for UNIX interval timers.
-{
 public:
   struct ACE_Elapsed_Time
     {
diff --git a/ace/Reactor.h b/ace/Reactor.h
index baf1cce568d..ad9d8f7d9d0 100644
--- a/ace/Reactor.h
+++ b/ace/Reactor.h
@@ -37,13 +37,12 @@ class ACE_Reactor_Impl;
 #include "ace/Signal.h"
 
 class ACE_Export ACE_Reactor
+{
   // = TITLE
-  //
   //     The resposiblility of this class is to forward all methods to
-  //     its delegation/implementation class
-{
+  //     its delegation/implementation class, e.g.,
+  //     <ACE_Select_Reactor> or <ACE_WFMO_Reactor>.
 public:
-
   enum
   {
     // = Operations on the "ready" mask and the "dispatch" mask.
diff --git a/ace/Reactor_Impl.h b/ace/Reactor_Impl.h
index 11da1faf67f..d3a9c18a701 100644
--- a/ace/Reactor_Impl.h
+++ b/ace/Reactor_Impl.h
@@ -33,12 +33,10 @@ class ACE_Handle_Set;
 #include "ace/Signal.h"
 
 class ACE_Export ACE_Reactor_Impl
+{
   // = TITLE
-  //
   //     An abstract class for implementing the Reactor Pattern.
-{
 public:
-
   virtual ~ACE_Reactor_Impl (void) {};
   // Close down and release all resources.
   
diff --git a/ace/Read_Buffer.h b/ace/Read_Buffer.h
index 49f3acc99e0..d1b9f9d93b1 100644
--- a/ace/Read_Buffer.h
+++ b/ace/Read_Buffer.h
@@ -22,6 +22,7 @@
 #include "ace/Malloc.h"
 
 class ACE_Export ACE_Read_Buffer
+{
   // = TITLE
   //     Efficiently reads an artibrarily large buffer from an input
   //     stream up to an including a termination character.  Also
@@ -34,7 +35,6 @@ class ACE_Export ACE_Read_Buffer
   //     allocation and make only one copy of the data.  It uses
   //     recursion and the run-time stack to accomplish this
   //     efficiently.
-{
 public:
   // = Initialization and termination methods.
   ACE_Read_Buffer (FILE *fp, int close_on_delete = 0, ACE_Allocator * = 0);
diff --git a/ace/Registry.h b/ace/Registry.h
index 917759fed1a..2889e71489c 100644
--- a/ace/Registry.h
+++ b/ace/Registry.h
@@ -34,6 +34,7 @@
 // You must configure the STL components in order to use this wrapper.
 
 class ACE_Export ACE_Registry
+{
   // = TITLE
   //     A Name Server implementation
   //
@@ -44,7 +45,6 @@ class ACE_Export ACE_Registry
   //     Other than providing an OO wrapper for the Win32 Reg*()
   //     functions, ACE_Registry provides an abstraction for iteration
   //     over the elements of the Registry.
-{
 public:
 
 // International string
@@ -158,56 +158,57 @@ public:
   // Forward declaration of iterator
 
   class ACE_Export Object
+  {
     // = TITLE
     //     An object representation
+    //
     // = DESCRIPTION
     //     In CORBA, all objects inherit from (CORBA::Object).
     //     For the registry, this is used as a wrapper for an
     //     instance of a built-in data type.
     //     Think about an object as being similar to a file
     //     in a file system.
-    {
-    public:
-      Object (void *data = 0,
-	      u_long size = 0,
-	      u_long type = REG_NONE);
-      // Default constructor
+  public:
+    Object (void *data = 0,
+            u_long size = 0,
+            u_long type = REG_NONE);
+    // Default constructor
 
-      void data (void *data);
-      void *data (void) const;
-      // Set/Get data
+    void data (void *data);
+    void *data (void) const;
+    // Set/Get data
 
-      void size (u_long size);
-      u_long size (void) const;
-      // Set/Get size
+    void size (u_long size);
+    u_long size (void) const;
+    // Set/Get size
 
-      void type (u_long type);
-      u_long type (void) const;
-      // Set/Get type
+    void type (u_long type);
+    u_long type (void) const;
+    // Set/Get type
 
-    private:
-      void *data_;
-      // Pointer to data
+  private:
+    void *data_;
+    // Pointer to data
 
-      u_long size_;
-      // Size of the data
+    u_long size_;
+    // Size of the data
 
-      u_long type_;
-      // Type of data
-    };
+    u_long type_;
+    // Type of data
+  };
 
   class ACE_Export Naming_Context
+  {
     // = TITLE
     //     An context representation
+    //
     // = DESCRIPTION
     //     Think about a context as being similar to a directory
     //     in a file system.
-    {
+  public:
     friend class ACE_Predefined_Naming_Contexts;
     // Friend factory
 
-  public:
-
     enum { MAX_OBJECT_NAME_SIZE = BUFSIZ,
 	   MAX_CONTEXT_NAME_SIZE = MAXPATHLEN + 1 };
     // Max sizes of names
@@ -419,15 +420,16 @@ public:
   };
 
   class ACE_Export Binding_Iterator
+  {
     // = TITLE
     //     An iterator
+    //
     // = DESCRIPTION
     //     Useful when iteratorating over a few entries at a time
-  {
+  public:
     friend class Naming_Context;
     // Friend factory
 
-  public:
     Binding_Iterator ();
     // Default constructor
 
@@ -531,13 +533,14 @@ public:
 };
 
 class ACE_Export ACE_Predefined_Naming_Contexts
+{
   // = TITLE
   //     A factory for predefined registries, which exist by default
   //     on Win32 platforms
+  //
   // = DESCRIPTION
   //     This factory can connect to both local and remote
   //     predefined registries.
-{
 public:
   static int connect (ACE_Registry::Naming_Context &naming_context,
 		      HKEY predefined = HKEY_LOCAL_MACHINE,
diff --git a/ace/Registry_Name_Space.h b/ace/Registry_Name_Space.h
index 033d74a4bd0..29af81695e6 100644
--- a/ace/Registry_Name_Space.h
+++ b/ace/Registry_Name_Space.h
@@ -27,17 +27,18 @@
 #include "ace/Name_Space.h"
 
 class ACE_Export ACE_Registry_Name_Space : public ACE_Name_Space
+{
   // = TITLE
-  //     Interface to a Name Server Database which is maintained
-  //     by the Win32 Registry.  Allows to add, change, remove and
+  //     Interface to a Name Server Database which is maintained by
+  //     the Win32 Registry.  Allows to add, change, remove and
   //     resolve NameBindings.
   //
   // = DESCRIPTION
-  //     Manages a Naming Service for a registry name space which includes
-  //	 bindings for all contexts. All strings are stored in wide character format.
-  //     A Name Binding consists of a name (that's the key), a value
-  //     string. There is no type string support in this Name Space.
-{
+  //     Manages a Naming Service for a registry name space which
+  //     includes bindings for all contexts. All strings are stored in
+  //     wide character format.  A Name Binding consists of a name
+  //     (that's the key), a value string. There is no type string
+  //     support in this Name Space.
 public:
 
   ACE_Registry_Name_Space (void);
@@ -53,13 +54,13 @@ public:
   // Contacts and opens the registry on the specified server
 
   int bind (const ACE_WString &name_in,
-	    const ACE_WString &value_in,
-	    const char *type_in = "");
+            const ACE_WString &value_in,
+            const char *type_in = "");
   // Bind a new name to a naming context (Wide character strings).
 
   int rebind (const ACE_WString &name_in,
-	      const ACE_WString &value_in,
-	      const char *type_in = "");
+              const ACE_WString &value_in,
+              const char *type_in = "");
   // Overwrite the value or type of an existing name in a
   // ACE_Name_Space or bind a new name to the context, if it didn't
   // exist yet. (Wide charcter strings interface).
@@ -69,40 +70,40 @@ public:
   // Interface).
 
   int resolve (const ACE_WString &name_in,
-	       ACE_WString &value_out,
-	       char *&type_out);
+               ACE_WString &value_out,
+               char *&type_out);
   // Get value and type of a given name binding (Wide chars).  The
   // caller is responsible for deleting both <value_out> and <type_out>!
 
   int list_names (ACE_WSTRING_SET &set_out,
-		  const ACE_WString &pattern_in);
+                  const ACE_WString &pattern_in);
   // Get a set of names matching a specified pattern (wchars). Matching
   // means the names must begin with the pattern string.
 
   int list_values (ACE_WSTRING_SET &set_out,
-		   const ACE_WString &pattern_in);
+                   const ACE_WString &pattern_in);
   // Get a set of values matching a specified pattern (wchars). Matching
   // means the values must begin with the pattern string.
 
   int list_types (ACE_WSTRING_SET &set_out,
-		  const ACE_WString &pattern_in);
+                  const ACE_WString &pattern_in);
   // Get a set of types matching a specified pattern (wchars). Matching
   // means the types must begin with the pattern string.
 
   int list_name_entries (ACE_BINDING_SET &set,
-			 const ACE_WString &pattern);
+                         const ACE_WString &pattern);
   // Get a set of names matching a specified pattern (wchars). Matching
   // means the names must begin with the pattern string. Returns the
   // complete binding associated each pattern match.
 
   int list_value_entries (ACE_BINDING_SET &set,
-			  const ACE_WString &pattern);
+                          const ACE_WString &pattern);
   // Get a set of values matching a specified pattern (wchars). Matching
   // means the values must begin with the pattern string. Returns the
   // complete binding associated each pattern match.
 
   int list_type_entries (ACE_BINDING_SET &set,
-			 const ACE_WString &pattern);
+                         const ACE_WString &pattern);
   // Get a set of types matching a specified pattern (wchars). Matching
   // means the types must begin with the pattern string. Returns the
   // complete binding associated each pattern match.
diff --git a/ace/Remote_Name_Space.h b/ace/Remote_Name_Space.h
index 9230781c3db..0131411670c 100644
--- a/ace/Remote_Name_Space.h
+++ b/ace/Remote_Name_Space.h
@@ -28,18 +28,18 @@
 typedef ACE_Unbounded_Set<ACE_WString> ACE_WSTRING_SET;
 
 class ACE_Export ACE_Remote_Name_Space : public ACE_Name_Space
+{
   // = TITLE
   //     Maintaining accesses Remote Name Server Database.  Allows to
   //     add NameBindings, change them, remove them and resolve
   //     NameBindings.
   //
   // = DESCRIPTION
-  //     Manages a Naming Service for a remote name space which includes
-  //	 bindings for net_local naming context.
-  //	 All strings are stored in wide character format.
-  //     A Name Binding consists of a name (that's the key), a value
-  //	 string and an optional type string (no wide chars).
-{
+  //     Manages a Naming Service for a remote name space which
+  //     includes bindings for net_local naming context.  All strings
+  //     are stored in wide character format.  A Name Binding consists
+  //     of a name (that's the key), a value string and an optional
+  //     type string (no wide chars).
 public:
   // = Initialization and termination methods.
   ACE_Remote_Name_Space (void);
@@ -60,13 +60,13 @@ public:
   // file
 
   virtual int bind (const ACE_WString &name_in,
-		    const ACE_WString &value_in,
-		    const char *type_in = "");
+                    const ACE_WString &value_in,
+                    const char *type_in = "");
   // Bind a new name to a naming context (Wide character strings).
 
   virtual int rebind (const ACE_WString &name_in,
-		      const ACE_WString &value_in,
-		      const char *type_in = "");
+                      const ACE_WString &value_in,
+                      const char *type_in = "");
   // Overwrite the value or type of an existing name in a
   // ACE_Remote_Name_Space or bind a new name to the context, if it
   // didn't exist yet. (Wide charcter strings interface).
@@ -76,40 +76,40 @@ public:
   // Interface).
 
   virtual int resolve (const ACE_WString &name_in,
-		       ACE_WString &value_out,
-		       char *&type_out);
+                       ACE_WString &value_out,
+                       char *&type_out);
   // Get value and type of a given name binding (Wide chars).  The
   // caller is responsible for deleting both <value_out> and <type_out>!
 
   virtual int list_names (ACE_WSTRING_SET &set_out,
-			  const ACE_WString &pattern_in);
+                          const ACE_WString &pattern_in);
   // Get a set of names matching a specified pattern (wchars). Matching
   // means the names must begin with the pattern string.
 
   virtual int list_values (ACE_WSTRING_SET &set_out,
-			   const ACE_WString &pattern_in);
+                           const ACE_WString &pattern_in);
   // Get a set of values matching a specified pattern (wchars). Matching
   // means the values must begin with the pattern string.
 
   virtual int list_types (ACE_WSTRING_SET &set_out,
-			  const ACE_WString &pattern_in);
+                          const ACE_WString &pattern_in);
   // Get a set of types matching a specified pattern (wchars). Matching
   // means the types must begin with the pattern string.
 
   virtual int list_name_entries (ACE_BINDING_SET &set,
-				 const ACE_WString &pattern);
+                                 const ACE_WString &pattern);
   // Get a set of names matching a specified pattern (wchars). Matching
   // means the names must begin with the pattern string. Returns the
   // complete binding associated each pattern match.
 
   virtual int list_value_entries (ACE_BINDING_SET &set,
-				  const ACE_WString &pattern);
+                                  const ACE_WString &pattern);
   // Get a set of values matching a specified pattern (wchars). Matching
   // means the values must begin with the pattern string. Returns the
   // complete binding associated each pattern match.
 
   virtual int list_type_entries (ACE_BINDING_SET &set,
-				 const ACE_WString &pattern);
+                                 const ACE_WString &pattern);
   // Get a set of types matching a specified pattern (wchars). Matching
   // means the types must begin with the pattern string. Returns the
   // complete binding associated each pattern match.
diff --git a/ace/Remote_Tokens.h b/ace/Remote_Tokens.h
index 6630219ece1..4a2dd9a4450 100644
--- a/ace/Remote_Tokens.h
+++ b/ace/Remote_Tokens.h
@@ -27,6 +27,7 @@
 #include "ace/Token_Request_Reply.h"
 
 class ACE_Export ACE_Remote_Token_Proxy : public ACE_Token_Proxy
+{
   // = TITLE
   //    Proxy for acquiring, renewing, and releasing a distributed
   //    synchronization token.
@@ -39,7 +40,6 @@ class ACE_Export ACE_Remote_Token_Proxy : public ACE_Token_Proxy
   // = BUGS
   //   Distributed sleep_hooks have not been implemented.  owner_id ()
   //   is not implemented.
-{
 public:
   ACE_Remote_Token_Proxy (void);
   // Null construction.
@@ -132,19 +132,19 @@ protected:
 };
 
 class ACE_Export ACE_Remote_Mutex : public ACE_Remote_Token_Proxy
-// = TITLE
-//    Proxy for acquiring, renewing, and releasing a distributed
-//    mutex.
-//
-// = DESCRIPTION
-//    This is the remote equivalent to ACE_Local_Mutex.  The
-//    Remote_Mutex class offers methods for acquiring, renewing, and
-//    releasing a distributed synchronization mutex.  Similar to
-//    ACE_Local_Mutex, ACE_Remote_Token_Proxy offers recursive
-//    acquisition, FIFO waiter ordering, and deadlock detection.  It
-//    depends on the Token Server for its distributed synchronization
-//    semantics.
 {
+  // = TITLE
+  //    Proxy for acquiring, renewing, and releasing a distributed
+  //    mutex.
+  //
+  // = DESCRIPTION
+  //    This is the remote equivalent to ACE_Local_Mutex.  The
+  //    Remote_Mutex class offers methods for acquiring, renewing, and
+  //    releasing a distributed synchronization mutex.  Similar to
+  //    ACE_Local_Mutex, ACE_Remote_Token_Proxy offers recursive
+  //    acquisition, FIFO waiter ordering, and deadlock detection.  It
+  //    depends on the Token Server for its distributed synchronization
+  //    semantics.
 public:
   ACE_Remote_Mutex (void);
   // Null creation.  Remote_Token_Proxy::open must be called.
@@ -167,18 +167,18 @@ protected:
 };
 
 class ACE_Export ACE_Remote_RLock : public ACE_Remote_Token_Proxy
-// = TITLE
-//   Proxy for acquiring, renewing, and releasing a distributed
-//   readers lock.
-//
-// = DESCRIPTION
-//    This is the remote equivalent to ACE_Local_RLock. Multiple
-//    readers can hold the lock simultaneously when no writers have
-//    the lock.  Alternatively, when a writer holds the lock, no other
-//    participants (readers or writers) may hold the lock.
-//    ACE_Remote_RLock depends on the ACE Token Server for its
-//    distributed synchronization semantics.
 {
+  // = TITLE
+  //   Proxy for acquiring, renewing, and releasing a distributed
+  //   readers lock.
+  //
+  // = DESCRIPTION
+  //    This is the remote equivalent to ACE_Local_RLock. Multiple
+  //    readers can hold the lock simultaneously when no writers have
+  //    the lock.  Alternatively, when a writer holds the lock, no other
+  //    participants (readers or writers) may hold the lock.
+  //    ACE_Remote_RLock depends on the ACE Token Server for its
+  //    distributed synchronization semantics.
 public:
   ACE_Remote_RLock (void);
 
@@ -204,6 +204,7 @@ protected:
 };
 
 class ACE_Export ACE_Remote_WLock : public ACE_Remote_Token_Proxy
+{
   // = TITLE
   //   Proxy for acquiring, renewing, and releasing a distributed
   //   writers lock.
@@ -214,7 +215,6 @@ class ACE_Export ACE_Remote_WLock : public ACE_Remote_Token_Proxy
   //   Token Server uses to identify the token.  The client_id_ (also
   //   used by the Token Server,) identifies the owner of the token and
   //   is used for deadlock detection.
-{
 public:
   ACE_Remote_WLock (void);
 
@@ -240,6 +240,7 @@ protected:
 };
 
 class ACE_Export ACE_TSS_Connection : public ACE_TSS<ACE_SOCK_Stream>
+{
   // = TITLE
   //    Class for providing a connection per thread.
   //
@@ -247,7 +248,6 @@ class ACE_Export ACE_TSS_Connection : public ACE_TSS<ACE_SOCK_Stream>
   //    ACE_TSS_Connection provides a single access point for all
   //    threads to access thread-specific connections.  This prevents
   //    resource-sharing problems such as thread serialization.
-{
 public:
   // Necessary to make some compilers work...
   ACE_TSS_Connection (void);
diff --git a/ace/SOCK.h b/ace/SOCK.h
index 12fee7ccdc9..63583971950 100644
--- a/ace/SOCK.h
+++ b/ace/SOCK.h
@@ -22,17 +22,17 @@
 #include "ace/IPC_SAP.h"
 
 class ACE_Export ACE_SOCK : public ACE_IPC_SAP
+{
   // = TITLE
   //     An abstract class which forms the basis for more specific
   //     classes (such as ACE_SOCK_Acceptor and ACE_SOCK_Connector).
   //     Do not instantiate this class.
-  
-  // =  This class provides functions that are common to all of the
-  //    SOCK-type classes. ACE_SOCK provides the ability to get and set
-  //    socket options, get the local and remote addresses, and close 
-  //    the socket.
-  
-{
+  //  
+  // = DESCRIPTION
+  //    This class provides functions that are common to all of the
+  //    SOCK-type classes. ACE_SOCK provides the ability to get and
+  //    set socket options, get the local and remote addresses, and
+  //    close the socket.
 public:
   int set_option (int level, 
                   int option, 
diff --git a/ace/SOCK_Acceptor.h b/ace/SOCK_Acceptor.h
index a57164e46a5..d5253ab109b 100644
--- a/ace/SOCK_Acceptor.h
+++ b/ace/SOCK_Acceptor.h
@@ -21,9 +21,10 @@
 #include "ace/Time_Value.h"
 
 class ACE_Export ACE_SOCK_Acceptor : public ACE_SOCK
-  // = TITLE
-  //     Defines the format and interface for an ACE_SOCK ACE_Stream acceptor. 
 {
+  // = TITLE
+  //     Defines the format and interface for an <ACE_Stream>
+  //     acceptor.
 public:
   // = Initialization methods.
   ACE_SOCK_Acceptor (void);
diff --git a/ace/SOCK_CODgram.h b/ace/SOCK_CODgram.h
index 0b79aa61e84..8751a707270 100644
--- a/ace/SOCK_CODgram.h
+++ b/ace/SOCK_CODgram.h
@@ -22,10 +22,10 @@
 #include "ace/Addr.h"
 
 class ACE_Export ACE_SOCK_CODgram : public ACE_SOCK_IO
+{
   // = TITLE
   //     Defines the member functions for the ACE_SOCK connected
-  // datagram abstraction. 
-{
+  //     datagram abstraction.
 public:
   // = Initialization methods.
   ACE_SOCK_CODgram (void);
diff --git a/ace/SOCK_Connector.h b/ace/SOCK_Connector.h
index af9c3d03a67..aef86b427d8 100644
--- a/ace/SOCK_Connector.h
+++ b/ace/SOCK_Connector.h
@@ -21,13 +21,13 @@
 #include "ace/Time_Value.h"
 
 class ACE_Export ACE_SOCK_Connector
+{
   // = TITLE
   //     Defines an active connection factory for the socket wrappers.
   //
   // = DESCRIPTION
   //     Objects of this class do not store state so they can be used
   //     reentrantly in multi-threaded programs...
-{
 public:
   // = Initialization routines.
   ACE_SOCK_Connector (void);
diff --git a/ace/SOCK_Dgram.h b/ace/SOCK_Dgram.h
index 94b3e245eb1..b3531ed9ff8 100644
--- a/ace/SOCK_Dgram.h
+++ b/ace/SOCK_Dgram.h
@@ -21,10 +21,10 @@
 #include "ace/Addr.h"
 
 class ACE_Export ACE_SOCK_Dgram : public ACE_SOCK
+{
   // = TITLE
   //     Defines the member functions for the ACE_SOCK datagram
   //     abstraction. 
-{
 public:
   // = Initialization routines.
   ACE_SOCK_Dgram (void);
diff --git a/ace/SOCK_Dgram_Bcast.h b/ace/SOCK_Dgram_Bcast.h
index 64fe168f830..ed91935a05c 100644
--- a/ace/SOCK_Dgram_Bcast.h
+++ b/ace/SOCK_Dgram_Bcast.h
@@ -19,8 +19,9 @@
 #include "ace/INET_Addr.h"
 #include "ace/SOCK_Dgram.h"
 
-struct ACE_Bcast_Node 
+class ACE_Bcast_Node 
 {
+public:
   ACE_Bcast_Node (ACE_INET_Addr &, ACE_Bcast_Node *);
 
   ACE_INET_Addr bcast_addr_;
@@ -31,10 +32,10 @@ struct ACE_Bcast_Node
 };
 
 class ACE_Export ACE_SOCK_Dgram_Bcast : public ACE_SOCK_Dgram
+{
   // = TITLE
   //     Defines the member functions for the ACE_SOCK datagram
   //     abstraction. 
-{
 public:
   // = Initialization and termination methods.
   ACE_SOCK_Dgram_Bcast (void);
diff --git a/ace/SOCK_Dgram_Mcast.h b/ace/SOCK_Dgram_Mcast.h
index 56fd5ea655a..15ebcf27994 100644
--- a/ace/SOCK_Dgram_Mcast.h
+++ b/ace/SOCK_Dgram_Mcast.h
@@ -22,10 +22,10 @@
 #include "ace/INET_Addr.h"
 
 class ACE_Export ACE_SOCK_Dgram_Mcast : public ACE_SOCK_Dgram
+{
   // = TITLE
   //     Defines the member functions for the ACE SOCK wrapper
   //     multicast abstraction. 
-{
 public:
   // = Initialization routine.
   ACE_SOCK_Dgram_Mcast (void);
diff --git a/ace/SOCK_IO.h b/ace/SOCK_IO.h
index 9c582d97e88..d7f65601b7f 100644
--- a/ace/SOCK_IO.h
+++ b/ace/SOCK_IO.h
@@ -21,10 +21,10 @@
 #include "ace/SOCK.h"
 
 class ACE_Export ACE_SOCK_IO : public ACE_SOCK
+{
   // = TITLE
   //     Defines the methods for the ACE socket wrapper I/O routines
   //     (e.g., send/recv).
-{
 public:
   ssize_t send (const void *buf,
                 size_t n,
diff --git a/ace/SOCK_Stream.h b/ace/SOCK_Stream.h
index 287e897a968..f8fc16ee3c7 100644
--- a/ace/SOCK_Stream.h
+++ b/ace/SOCK_Stream.h
@@ -22,13 +22,13 @@
 #include "ace/INET_Addr.h"
 
 class ACE_Export ACE_SOCK_Stream : public ACE_SOCK_IO
+{
   // = TITLE
   //     Defines the methods in the <ACE_SOCK_Stream> abstraction.
   //     
   // = DESCRIPTION
   //     This adds additional wrapper methods atop the <ACE_SOCK_IO>
   //     class.
-{
 public:
   //= The following two methods use write and read system calls.
   ssize_t send_n (const void *buf, int n) const;
diff --git a/ace/SPIPE.h b/ace/SPIPE.h
index 14b45efd23f..2ab84a55acd 100644
--- a/ace/SPIPE.h
+++ b/ace/SPIPE.h
@@ -21,10 +21,10 @@
 #include "ace/SPIPE_Addr.h"
 
 class ACE_Export ACE_SPIPE : public ACE_IPC_SAP
+{
   // = TITLE
   //     Defines the member functions for the base class of the
   //     ACE_SPIPE abstraction. 
-{
 public:
   int close (void);
   // Close down the STREAM pipe without removing the rendezvous point.
diff --git a/ace/SPIPE_Acceptor.h b/ace/SPIPE_Acceptor.h
index c7771a6afa0..0d86e85e91d 100644
--- a/ace/SPIPE_Acceptor.h
+++ b/ace/SPIPE_Acceptor.h
@@ -20,10 +20,10 @@
 #include "ace/SPIPE_Stream.h"
 
 class ACE_Export ACE_SPIPE_Acceptor : public ACE_SPIPE
+{
   // = TITLE
   //     Defines the format and interface for the listener side of the
   //     ACE_SPIPE_Stream. 
-{
 public:
 #if defined (ACE_WIN32)
   // = Maximum number of attempts to accept a connection
diff --git a/ace/SPIPE_Addr.h b/ace/SPIPE_Addr.h
index 85d7b5289bd..d6277404f37 100644
--- a/ace/SPIPE_Addr.h
+++ b/ace/SPIPE_Addr.h
@@ -21,9 +21,9 @@
 #include "ace/ACE.h"
 
 class ACE_Export ACE_SPIPE_Addr : public ACE_Addr
+{
   // = TITLE
   //    Defines the SVR4 STREAM pipe address family address format. 
-{
 public:
   // = Initialization methods.
   ACE_SPIPE_Addr (void);
diff --git a/ace/SPIPE_Connector.h b/ace/SPIPE_Connector.h
index b3416f7cfd6..78e7f0ad0ef 100644
--- a/ace/SPIPE_Connector.h
+++ b/ace/SPIPE_Connector.h
@@ -21,10 +21,10 @@
 #include "ace/SPIPE_Stream.h"
 
 class ACE_Export ACE_SPIPE_Connector : public ACE_SPIPE
+{
   // = TITLE
   //     Defines an active connection factory for the STREAM pipe
   //     wrappers. 
-{
 public:
   // = Initialization method.
   ACE_SPIPE_Connector (void);
diff --git a/ace/SPIPE_Stream.h b/ace/SPIPE_Stream.h
index 54b40bf71df..e7e74d8f91d 100644
--- a/ace/SPIPE_Stream.h
+++ b/ace/SPIPE_Stream.h
@@ -21,12 +21,13 @@
 #include "ace/SPIPE_Addr.h"
 
 class ACE_Export ACE_SPIPE_Stream : public ACE_SPIPE
+{
   // = TITLE
   //     Define an ACE_SPIPE_Stream.
-{
-friend class ACE_SPIPE_Acceptor;
-friend class ACE_SPIPE_Connector;
 public:
+  friend class ACE_SPIPE_Acceptor;
+  friend class ACE_SPIPE_Connector;
+
   // = Initialization method.
   ACE_SPIPE_Stream (void);
   // Default constructor.
diff --git a/ace/SString.h b/ace/SString.h
index 3c22d2fb3c4..ca171353fb6 100644
--- a/ace/SString.h
+++ b/ace/SString.h
@@ -23,6 +23,7 @@
 class ACE_Allocator;
 
 class ACE_Export ACE_CString
+{
   // = TITLE
   //   A simple "C String" (ACE_CString) class.
   //
@@ -30,18 +31,18 @@ class ACE_Export ACE_CString
   //   This is a place holder until all compilers implement the
   //   ANSI/ISO C++ standard String class.  Note that we need to use
   //   this class since the ACE ACE_Map_Manager requires an object
-  //   that supports the operator== and operator!=.
-  //   This class uses an ACE_Allocator to allocate memory.
-  //   The user can make this a persistant class by providing an 
-  //   ACE_Allocator with a persistable memory pool.
-  //   NOTE: if an instance of this class is constructed from or assigned
-  //   an empty string (with first element of '\0'), then it is _not_
-  //   allocated new space.  Instead, its internal representation is set
-  //   equal to a global empty string.
-{
+  //   that supports the operator== and operator!=.  This class uses
+  //   an ACE_Allocator to allocate memory.  The user can make this a
+  //   persistant class by providing an ACE_Allocator with a
+  //   persistable memory pool.  NOTE: if an instance of this class is
+  //   constructed from or assigned an empty string (with first
+  //   element of '\0'), then it is _not_ allocated new space.
+  //   Instead, its internal representation is set equal to a global
+  //   empty string.
+public:
   friend ACE_CString operator+ (const ACE_CString &, const ACE_CString &);
   friend ostream &operator << (ostream &, const ACE_CString &);
-public:
+
   ACE_CString (ACE_Allocator *alloc = 0);
   // Default constructor.
 
diff --git a/ace/SV_Message.h b/ace/SV_Message.h
index 7ee965520ae..8939ac8634a 100644
--- a/ace/SV_Message.h
+++ b/ace/SV_Message.h
@@ -21,9 +21,9 @@
 #include "ace/ACE.h"
 
 class ACE_Export ACE_SV_Message
+{
   // = TITLE
   //     Defines the header file for the C++ wrapper for message queues. */
-{
 public:
   // = Initialization and termination methods.
   ACE_SV_Message (long type = 0);
diff --git a/ace/SV_Message_Queue.h b/ace/SV_Message_Queue.h
index eeb3cf42b6d..4bab2c4f742 100644
--- a/ace/SV_Message_Queue.h
+++ b/ace/SV_Message_Queue.h
@@ -21,10 +21,10 @@
 #include "ace/SV_Message.h"
 
 class ACE_Export ACE_SV_Message_Queue
+{
   // = TITLE
   //     Defines the header file for the C++ wrapper for System V IPC
   //     message queues.  
-{
 public: 
   // = Useful symbolic constants.
   enum 
diff --git a/ace/SV_Semaphore_Complex.h b/ace/SV_Semaphore_Complex.h
index 94da59acfda..3837909a47a 100644
--- a/ace/SV_Semaphore_Complex.h
+++ b/ace/SV_Semaphore_Complex.h
@@ -20,6 +20,7 @@
 #include "ace/SV_Semaphore_Simple.h"
 
 class ACE_Export ACE_SV_Semaphore_Complex : private ACE_SV_Semaphore_Simple
+{
   // = TITLE
   //     This is a more complex semaphore wrapper that handles race
   //     conditions for initialization correctly...
@@ -49,7 +50,6 @@ class ACE_Export ACE_SV_Semaphore_Complex : private ACE_SV_Semaphore_Simple
   //      The members beyond [1] are actual ACE_SV_Semaphore values in
   //      the array of SV_Semaphores (which may be sized by the user
   //      in the constructor).
-{
 public:
   enum 
   {
diff --git a/ace/SV_Semaphore_Simple.h b/ace/SV_Semaphore_Simple.h
index 998006b34cf..a426ade6845 100644
--- a/ace/SV_Semaphore_Simple.h
+++ b/ace/SV_Semaphore_Simple.h
@@ -20,11 +20,11 @@
 #include "ace/ACE.h"
 
 class ACE_Export ACE_SV_Semaphore_Simple
+{
   // = TITLE
   //     This is a simple semaphore package that assumes there are
   //     no race conditions for initialization (i.e., the order of
   //     process startup must be well defined).
-{
 public:
   enum 
   {
diff --git a/ace/SV_Shared_Memory.h b/ace/SV_Shared_Memory.h
index f2ed6030c53..4ebda2b9c6a 100644
--- a/ace/SV_Shared_Memory.h
+++ b/ace/SV_Shared_Memory.h
@@ -21,9 +21,9 @@
 #include "ace/ACE.h"
 
 class ACE_Export ACE_SV_Shared_Memory
+{
   // = TITLE
   //     This is a wrapper for System V shared memory.
-{
 public:
   enum 
   {
diff --git a/ace/Sched_Params.h b/ace/Sched_Params.h
index 4be60222164..679c3c40d8b 100644
--- a/ace/Sched_Params.h
+++ b/ace/Sched_Params.h
@@ -23,6 +23,7 @@
 #include "ace/OS.h"
 
 class ACE_Export ACE_Sched_Params
+{
   // = TITLE
   //    Container for scheduling-related parameters.
   //
@@ -60,7 +61,6 @@ class ACE_Export ACE_Sched_Params
   //    careful review of this class design, thoughtful comments, and
   //    assistance with implementation, especially for PTHREADS platforms.
   //    Please send any comments or corrections to the ACE developers.
-{
 public:
   typedef int Policy;
 
diff --git a/ace/Select_Reactor.h b/ace/Select_Reactor.h
index 3674838639f..ca3d914e43b 100644
--- a/ace/Select_Reactor.h
+++ b/ace/Select_Reactor.h
@@ -33,9 +33,9 @@ typedef int (ACE_Event_Handler::*ACE_EH_PTMF) (ACE_HANDLE);
 class ACE_Select_Reactor;
 
 class ACE_Export ACE_Select_Reactor_Handle_Set
+{
   // = TITLE
   //      Track handles we are interested for various events.
-{
 public:
   ACE_Handle_Set rd_mask_;
   // Read events (e.g., input pending, accept pending).
@@ -58,11 +58,11 @@ typedef ACE_Token ACE_SELECT_REACTOR_MUTEX;
 #endif /* ACE_SELECT_REACTOR_HAS_DEADLOCK_DETECTION */
 
 class ACE_Export ACE_Select_Reactor_Token : public ACE_SELECT_REACTOR_MUTEX
+{
   // = TITLE
   //
   //     Used as a synchronization mechanism to coordinate concurrent
   //     access to a Select_Reactor object.
-{
 public:
   ACE_Select_Reactor_Token (ACE_Select_Reactor &r);
   ACE_Select_Reactor_Token (void);
@@ -89,18 +89,17 @@ private:
 typedef ACE_Null_Mutex ACE_Select_Reactor_Token;
 #endif /* ACE_MT_SAFE */
 
-struct ACE_Event_Tuple
+class ACE_Event_Tuple
+{
   // = TITLE
-  //
   //     An ACE_Event_Handler and its associated ACE_HANDLE.
   //
   // = DESCRIPTION
-  //
   //     One ACE_Event_Handler is registered for one or more
   //     ACE_HANDLE, in some points this information must be stored
   //     explicitly. This structure provides a lightweight mechanism
   //     to do so.
-{
+public:
   ACE_Event_Tuple (void);
   ACE_Event_Tuple (ACE_Event_Handler* eh, ACE_HANDLE h);
 
@@ -118,12 +117,11 @@ struct ACE_Event_Tuple
 // C++ compiler happy (it doesn't like nested classes).
 
 class ACE_Export ACE_Select_Reactor_Notify : public ACE_Event_Handler
+{
   // = TITLE
-  //
   //     Unblock the <ACE_Select_Reactor> from its event loop.
   //
   // = DESCRIPTION
-  //
   //     This implementation is necessary for cases where the
   //     <ACE_Select_Reactor> is run in a multi-threaded program.  In
   //     this case, we need to be able to unblock select() or poll()
@@ -133,7 +131,6 @@ class ACE_Export ACE_Select_Reactor_Notify : public ACE_Event_Handler
   //     If an <ACE_Event_Handler> and <ACE_Select_Reactor_Mask> is
   //     passed to <notify>, the appropriate <handle_*> method is
   //     dispatched in the context of the <ACE_Select_Reactor> thread.
-{
 public:
   // = Initialization and termination methods.
   int open (ACE_Select_Reactor *);
@@ -177,19 +174,17 @@ private:
 };
 
 class ACE_Export ACE_Select_Reactor_Handler_Repository
+{
   // = TITLE
-  //
   //     Used to map <ACE_HANDLE>s onto the appropriate
   //     <ACE_Event_Handler> *.
   //
   // = DESCRIPTION
-  //
   //     This class is necessary to shield differences between UNIX
   //     and Win32.  In UNIX, <ACE_HANDLE> is an int, whereas in Win32
   //     it's a void *.  This class hides all these details from the
   //     bulk of the <ACE_Select_Reactor> code.  All of these methods
   //     are called with the main <Select_Reactor> token lock held.
-{
 public:
   friend class ACE_Select_Reactor_Handler_Repository_Iterator;
 
@@ -276,10 +271,9 @@ private:
 };
 
 class ACE_Export ACE_Select_Reactor_Handler_Repository_Iterator
+{
   // = TITLE
-  //
   //     Iterate through the <ACE_Select_Reactor_Handler_Repository>.
-{
 public:
   // = Initialization method.
   ACE_Select_Reactor_Handler_Repository_Iterator (const ACE_Select_Reactor_Handler_Repository *s);
@@ -312,6 +306,7 @@ private:
 };
 
 class ACE_Export ACE_Select_Reactor : public ACE_Reactor_Impl
+{
   // = TITLE
   //     An object oriented event demultiplexor and event handler
   //     dispatcher.
@@ -324,7 +319,6 @@ class ACE_Export ACE_Select_Reactor : public ACE_Reactor_Impl
   //     methods acquire the main <Select_Reactor> token lock and call
   //     down to private or protected methods, which assume that the
   //     lock is held and so therefore don't (re)acquire the lock.
-{
 public:
   enum
   {
diff --git a/ace/Service_Config.h b/ace/Service_Config.h
index 9029d7233ed..9b5b0af7466 100644
--- a/ace/Service_Config.h
+++ b/ace/Service_Config.h
@@ -69,6 +69,7 @@ typedef ACE_Unbounded_Set_Iterator<ACE_Static_Svc_Descriptor *>
         ACE_STATIC_SVCS_ITERATOR;
 
 class ACE_Export ACE_Service_Config
+{
   // = TITLE
   //     Supplies common server operations for dynamic and static
   //     configuration of services.
@@ -80,7 +81,6 @@ class ACE_Export ACE_Service_Config
   //     ACE_Service_Config objects, there might be initialization
   //     order problems.  They can be minimized, but not eliminated,
   //     by _not_ #defining ACE_HAS_NONSTATIC_OBJECT_MANAGER.
-{
 public:
   enum {MAX_SERVICES = ACE_DEFAULT_SELECT_REACTOR_SIZE};
 
diff --git a/ace/Service_Manager.h b/ace/Service_Manager.h
index c35b207e759..f91e225b442 100644
--- a/ace/Service_Manager.h
+++ b/ace/Service_Manager.h
@@ -24,13 +24,10 @@
 #include "ace/Service_Object.h"
 
 class ACE_Export ACE_Service_Manager : public ACE_Service_Object
-  // = TITLE
-  //     Provide a standard service that returns a list of all services in the
-  //  Service Repository. 
-  //
-  // = DESCRIPTION
-  //
 {
+  // = TITLE
+  //     Provide a standard service that returns a list of all
+  //     services in the Service Repository.
 public:
   ACE_Service_Manager (void);
   virtual int list_services (void);
diff --git a/ace/Service_Object.h b/ace/Service_Object.h
index 0c83733f1e5..7dff02543e6 100644
--- a/ace/Service_Object.h
+++ b/ace/Service_Object.h
@@ -21,6 +21,7 @@
 #include "ace/Event_Handler.h"
 
 class ACE_Export ACE_Service_Object : public ACE_Event_Handler, public ACE_Shared_Object
+{
   // = TITLE
   //     Provide the abstract base class common to all service
   //     implementations.  
@@ -30,7 +31,6 @@ class ACE_Export ACE_Service_Object : public ACE_Event_Handler, public ACE_Share
   //     of being registered with the <ACE_Reactor> (due to the
   //     <ACE_Event_Handler>, as well as being dynamically linked by
   //     the <ACE_Service_Config> (due to the <ACE_Shared_Object>).
-{
 public:
   // = Initialization and termination methods.
   ACE_Service_Object (void);
@@ -47,13 +47,13 @@ public:
 class ACE_Service_Type_Impl;
 
 class ACE_Export ACE_Service_Type
+{
   // = TITLE
   //      Keeps track of information related to the various
   //      <ACE_Service_Type_Impl> subclasses.  
   //
   // = DESCRIPTION
   //      This class acts as the interface of the "Bridge" pattern.
-{
 public:
   enum
   {
@@ -107,6 +107,7 @@ private:
 };
 
 class ACE_Export ACE_Service_Object_Ptr
+{
   // = TITLE 
   //     This is a smart pointer that holds onto the associated
   //     <ACE_Service_Object> * until the current scope is left, at
@@ -117,7 +118,6 @@ class ACE_Export ACE_Service_Object_Ptr
   //     <auto_ptr>.  It is used in conjunction with statically linked
   //     <ACE_Service_Objects>, as shown in the
   //     ./netsvcs/server/main.cpp example.
-{
 public:
   // = Initialization and termination methods.
   ACE_Service_Object_Ptr (ACE_Service_Object *so);
diff --git a/ace/Service_Repository.h b/ace/Service_Repository.h
index 168755c620f..91af367e9d3 100644
--- a/ace/Service_Repository.h
+++ b/ace/Service_Repository.h
@@ -20,6 +20,7 @@
 #include "ace/Service_Types.h"
 
 class ACE_Export ACE_Service_Repository
+{
   // = TITLE
   //     A container for all services offered by a Service
   //     Configurator-based application.  This allows an
@@ -28,9 +29,9 @@ class ACE_Export ACE_Service_Repository
   //
   // = DESCRIPTION
   //     This class contains a vector of <ACE_Service_Types> *'s.
-{
-  friend class ACE_Service_Repository_Iterator;
 public:
+  friend class ACE_Service_Repository_Iterator;
+
   enum {DEFAULT_SIZE = 50};
   // = Initialization and termination methods.
   ACE_Service_Repository (void);
@@ -125,10 +126,11 @@ private:
 };
 
 class ACE_Export ACE_Service_Repository_Iterator
-  // = TITLE
-  //     Iterate through the <ACE_Service_Repository>.
 {
 public:
+  // = TITLE
+  //     Iterate through the <ACE_Service_Repository>.
+
   // = Initialization method.
   ACE_Service_Repository_Iterator (ACE_Service_Repository &sr, 
 				   int ignored_suspended = 1);
diff --git a/ace/Service_Types.h b/ace/Service_Types.h
index 2b5255d0687..2c9392ecf96 100644
--- a/ace/Service_Types.h
+++ b/ace/Service_Types.h
@@ -21,6 +21,7 @@
 #include "ace/Synch.h"
 
 class ACE_Export ACE_Service_Type_Impl
+{
   // = TITLE
   //     The abstract base class of the hierarchy that defines the
   //     contents of the <ACE_Service_Repository>.  The subclasses of
@@ -32,7 +33,6 @@ class ACE_Export ACE_Service_Type_Impl
   //     of the "Bridge" pattern.  It maintains a pointer to the
   //     appropriate type of service implementation, i.e.,
   //     <ACE_Service_Object>, <ACE_Module>, or <ACE_Stream>.
-{
 public:
   // = Initialization and termination methods.
   ACE_Service_Type_Impl (const void *object, 
@@ -75,10 +75,10 @@ protected:
 };
 
 class ACE_Export ACE_Service_Object_Type : public ACE_Service_Type_Impl
+{
   // = TITLE
   //     Define the methods for handling the configuration of
   //     <ACE_Service_Objects>. 
-{
 public:
   // = Initialization method.
   ACE_Service_Object_Type (const void *so,
@@ -94,10 +94,10 @@ public:
 };
 
 class ACE_Export ACE_Module_Type : public ACE_Service_Type_Impl
+{
   // = TITLE
   //     Define the methods for handling the configuration of
   //     <ACE_Modules>. 
-{
 public:
   // = Initialization method.
   ACE_Module_Type (const void *m, // Really an <ACE_Module> *.
@@ -127,10 +127,10 @@ private:
 };
 
 class ACE_Export ACE_Stream_Type : public ACE_Service_Type_Impl
+{
   // = TITLE
   //     Define the methods for handling the configuration of
   //     <ACE_Streams>. 
-{
 public:
   // = Initialization method.
   ACE_Stream_Type (const void *s, // Really an <ACE_Stream> *.
diff --git a/ace/Shared_Memory.h b/ace/Shared_Memory.h
index b175cbde497..43c9248fc0f 100644
--- a/ace/Shared_Memory.h
+++ b/ace/Shared_Memory.h
@@ -21,6 +21,7 @@
 #include "ace/ACE.h"
 
 class ACE_Export ACE_Shared_Memory
+{
   // = TITLE
   //     This base class adapts both System V shared memory and "BSD"
   //     mmap to a common API.
@@ -30,7 +31,6 @@ class ACE_Export ACE_Shared_Memory
   //     useful for allocating large contiguous chunks of shared
   //     memory.  For a much more sophisticated version, please check
   //     out the <ACE_Malloc> class.
-{
 public:
   // = Note that all methods are pure virtual.
   virtual int close (void) = 0;
diff --git a/ace/Shared_Memory_MM.h b/ace/Shared_Memory_MM.h
index daa54737036..f6f58376e96 100644
--- a/ace/Shared_Memory_MM.h
+++ b/ace/Shared_Memory_MM.h
@@ -22,9 +22,9 @@
 #include "ace/Mem_Map.h"
 
 class ACE_Export ACE_Shared_Memory_MM : public ACE_Shared_Memory
+{
   // = TITLE
   //     Shared memory wrapper based on MMAP.
-{
 public:
   // = Initialization and termination methods.
   ACE_Shared_Memory_MM (void);
diff --git a/ace/Shared_Memory_SV.h b/ace/Shared_Memory_SV.h
index 7ec1c9c8816..d30f622b9f4 100644
--- a/ace/Shared_Memory_SV.h
+++ b/ace/Shared_Memory_SV.h
@@ -22,9 +22,9 @@
 #include "ace/SV_Shared_Memory.h"
 
 class ACE_Export ACE_Shared_Memory_SV : public ACE_Shared_Memory
+{
   // = TITLE
   //     Shared memory wrapper based on System V shared memory.
-{
 public:
   enum 
     {
diff --git a/ace/Shared_Object.h b/ace/Shared_Object.h
index 7298a53b9a6..9e2a58bb8d8 100644
--- a/ace/Shared_Object.h
+++ b/ace/Shared_Object.h
@@ -21,10 +21,10 @@
 #include "ace/ACE.h"
 
 class ACE_Export ACE_Shared_Object
-  // = TITLE
-  //     Provide the abstract base class used to access dynamic linking 
-  // facilities 
 {
+  // = TITLE
+  //     Provide the abstract base class used to access dynamic
+  //     linking facilities.
 public:
   virtual int init (int argc, char *argv[]);
   // Initializes object when dynamic linking occurs.
diff --git a/ace/Signal.h b/ace/Signal.h
index 4624394272e..cac53eca0d6 100644
--- a/ace/Signal.h
+++ b/ace/Signal.h
@@ -24,6 +24,7 @@
 typedef struct sigaction ACE_SIGACTION;
 
 class ACE_Export ACE_Sig_Set
+{
   // = TITLE
   //     Provide a C++ wrapper for the C sigset_t interface.
   // 
@@ -31,7 +32,6 @@ class ACE_Export ACE_Sig_Set
   //     Handle signals via a more elegant C++ interface (e.g.,
   //     doesn't require the use of global variables or global
   //     functions in an application).
-{
 public:
   // = Initialization and termination methods.
   ACE_Sig_Set (sigset_t *sigset);
@@ -80,9 +80,9 @@ private:
 };
 
 class ACE_Export ACE_Sig_Action
+{
   // = TITLE
   //     C++ wrapper around struct sigaction.
-{
 public:
   // = Initialization methods.
   ACE_Sig_Action (void);
@@ -152,10 +152,10 @@ private:
 };
 
 class ACE_Export ACE_Sig_Guard
+{
   // = TITLE
   //     Hold signals in MASK for duration of a C++ statement block.
   //     Note that a "0" for mask causes all signals to be held.
-{
 public:
   // = Initialization and termination methods.
   ACE_Sig_Guard (ACE_Sig_Set *mask = 0);
@@ -176,6 +176,7 @@ private:
 };
 
 class ACE_Export ACE_Sig_Handler
+{
   // = TITLE
   //    This is the main dispatcher of signals for ACE.  It improves
   //    the existing UNIX signal handling mechanism by allowing C++
@@ -188,7 +189,6 @@ class ACE_Export ACE_Sig_Handler
   //    <signum>.  When a signal occurs that corresponds to this
   //    <signum>, the <handle_signal> method of the registered
   //    <ACE_Event_Handler> is invoked automatically.
-{
 public:
   // = Registration and removal methods.
   virtual int register_handler (int signum, 
@@ -255,11 +255,10 @@ private:
 };
 
 class ACE_Export ACE_Sig_Adapter : public ACE_Event_Handler
+{
   // = TITLE
   //     Provide an adapter that transforms various types of signal
   //     handlers into the scheme used by the <ACE_Reactor>.
-
-{
 public:
   ACE_Sig_Adapter (ACE_Sig_Action &, int sigkey);
   ACE_Sig_Adapter (ACE_Event_Handler *, int sigkey);
@@ -298,6 +297,7 @@ private:
 
 #if !defined (ACE_HAS_BROKEN_HPUX_TEMPLATES)
 class ACE_Export ACE_Sig_Handlers : public ACE_Sig_Handler
+{
   // = TITLE
   //    This is an alternative signal handling dispatcher for ACE.  It
   //    allows a list of signal handlers to be registered for each
@@ -310,7 +310,6 @@ class ACE_Export ACE_Sig_Handlers : public ACE_Sig_Handler
   //    corresponds to this <signum>, the <handle_signal> methods of
   //    all the registered ACE_Event_Handlers are invoked
   //    automatically.
-{
 public:
   // = Registration and removal methods.
   virtual int register_handler (int signum, 
diff --git a/ace/Singleton.h b/ace/Singleton.h
index 55ceb31f2d2..f8bfa8ef8de 100644
--- a/ace/Singleton.h
+++ b/ace/Singleton.h
@@ -24,6 +24,7 @@
 
 template <class TYPE, class ACE_LOCK>
 class ACE_Singleton : public ACE_Cleanup
+{
   // = TITLE
   //     A Singleton Adapter the uses the Adapter pattern to turn
   //     ordinary classes into Singletons optimized with the
@@ -51,7 +52,6 @@ class ACE_Singleton : public ACE_Cleanup
   //     and ACE_Null_Mutex instances are used for all ACE_Singleton
   //     instantiations.  However, other types of locks are allocated
   //     per ACE_Singleton instantiation.
-{
 public:
   static TYPE *instance (void);
   // Global access point to the Singleton.
@@ -81,6 +81,7 @@ protected:
 
 template <class TYPE, class ACE_LOCK>
 class ACE_TSS_Singleton : public ACE_Cleanup
+{
   // = TITLE
   //     This class uses the Adapter pattern to turn ordinary classes
   //     into Thread-specific Singletons optimized with the
@@ -97,7 +98,6 @@ class ACE_TSS_Singleton : public ACE_Cleanup
   //     scheme to work, a (static) <cleanup> function must be
   //     provided.  <ACE_Singleton> provides one so that TYPE doesn't
   //     need to.
-{
 public:
   static TYPE *instance (void);
   // Global access point to the Singleton.
diff --git a/ace/Strategies.h b/ace/Strategies.h
index a907bb16aad..be64ce20e9e 100644
--- a/ace/Strategies.h
+++ b/ace/Strategies.h
@@ -23,6 +23,7 @@
 class ACE_Reactor;
 
 class ACE_Export ACE_Notification_Strategy
+{
   // = TITLE
   //     Abstract class used for notifing an interested party
   //
@@ -30,7 +31,6 @@ class ACE_Export ACE_Notification_Strategy
   //     A vehicle for extending the behavior of ACE_Message_Queue wrt
   //     notification *without subclassing*.  Thus, it's an example of
   //     the Bridge/Strategy patterns.
-{
 public:
   ACE_Notification_Strategy (ACE_Event_Handler *eh,
 			     ACE_Reactor_Mask mask);
@@ -54,13 +54,13 @@ protected:
 };
 
 class ACE_Export ACE_Reactor_Notification_Strategy : public ACE_Notification_Strategy
+{
   // = TITLE
   //     Used to notify an ACE_Reactor
   //
   // = DESCRIPTION
   //     Integrates the ACE_Message_Queue notification into the
   //     ACE_Reactor::notify() method.
-{
 public:
   ACE_Reactor_Notification_Strategy (ACE_Reactor *reactor,
 				     ACE_Event_Handler *eh,
@@ -80,13 +80,10 @@ protected:
 };
 
 class ACE_Export ACE_Connection_Recycling_Strategy
+{
   // = TITLE
-  //
   //     Defines the interface for a connection recycler.
-  //
-{
 public:
-
   virtual ~ACE_Connection_Recycling_Strategy (void);
   // Virtual Destructor
 
diff --git a/ace/Strategies_T.h b/ace/Strategies_T.h
index 4079b62d202..20eda65663a 100644
--- a/ace/Strategies_T.h
+++ b/ace/Strategies_T.h
@@ -25,6 +25,7 @@
 
 template<class SVC_HANDLER> 
 class ACE_Recycling_Strategy
+{
   // = TITLE
   //     Defines the interface (and default implementation) for
   //     specifying a recycling strategy for a SVC_HANDLER.
@@ -32,7 +33,6 @@ class ACE_Recycling_Strategy
   // = DESCRIPTION
   //      Acts as a consular to the Svc_Handler, preparing it for the
   //      tough times ahead when the Svc_Handler will be recycled.
-{
 public:
   virtual ~ACE_Recycling_Strategy (void);
   // Virtual Destructor
@@ -49,6 +49,7 @@ public:
 
 template <class SVC_HANDLER>
 class ACE_Creation_Strategy
+{
   // = TITLE
   //     Defines the interface for specifying a creation strategy for
   //     a SVC_HANDLER.
@@ -59,7 +60,6 @@ class ACE_Creation_Strategy
   //     creation in any way that they like (such as creating subclass
   //     instances of SVC_HANDLER, using a singleton, dynamically
   //     linking the handler, etc.).
-{
 public:
   // = Initialization and termination methods.
 
@@ -91,6 +91,7 @@ protected:
 
 template <class SVC_HANDLER>
 class ACE_Singleton_Strategy : public ACE_Creation_Strategy<SVC_HANDLER>
+{
   // = TITLE
   //     Defines the interface for specifying a creation strategy for
   //     a <SVC_HANDLER> that always returns the same <SVC_HANDLER> (i.e.,
@@ -100,7 +101,6 @@ class ACE_Singleton_Strategy : public ACE_Creation_Strategy<SVC_HANDLER>
   //     Note that this class takes over the ownership of the
   //     SVC_HANDLER passed into it as a parameter and it becomes
   //     responsible for deleting this object.
-{
 public:
   // = Initialization and termination methods.
   ACE_Singleton_Strategy (SVC_HANDLER * = 0,
@@ -127,10 +127,10 @@ protected:
 
 template <class SVC_HANDLER>
 class ACE_DLL_Strategy : public ACE_Creation_Strategy<SVC_HANDLER>
+{
   // = TITLE
   //     Defines the interface for specifying a creation strategy for
   //     a SVC_HANDLER based on dynamic linking of the SVC_HANDLER.
-{
 public:
   // = Intialization and termination methods.
 
@@ -183,6 +183,7 @@ protected:
 
 template <class SVC_HANDLER>
 class ACE_Concurrency_Strategy
+{
   // = TITLE
   //     Defines the interface for specifying a concurrency strategy
   //     for a SVC_HANDLER.
@@ -194,7 +195,6 @@ class ACE_Concurrency_Strategy
   //     this default strategy to do more sophisticated concurrency
   //     activations (such as creating the SVC_HANDLER as an active
   //     object via multi-threading or multi-processing).
-{
 public:
   ACE_Concurrency_Strategy (int flags = 0);
   // Constructor
@@ -224,6 +224,7 @@ protected:
 
 template <class SVC_HANDLER>
 class ACE_Reactive_Strategy : public ACE_Concurrency_Strategy <SVC_HANDLER>
+{
   // = TITLE
   //     Defines the interface for specifying a Reactive concurrency
   //     strategy for a SVC_HANDLER.
@@ -231,7 +232,6 @@ class ACE_Reactive_Strategy : public ACE_Concurrency_Strategy <SVC_HANDLER>
   // = DESCRIPTION
   //     This class provides a strategy that registers the
   //     <SVC_HANDLER> with a <Reactor>.
-{
 public:
   // = Intialization and termination methods.
   ACE_Reactive_Strategy (int flags = 0);
@@ -275,6 +275,7 @@ protected:
 
 template <class SVC_HANDLER>
 class ACE_Thread_Strategy : public ACE_Concurrency_Strategy<SVC_HANDLER>
+{
   // = TITLE
   //     Defines the interface for specifying a concurrency strategy
   //     for a <SVC_HANDLER> based on multithreading.
@@ -285,7 +286,6 @@ class ACE_Thread_Strategy : public ACE_Concurrency_Strategy<SVC_HANDLER>
   //     behaves as a "thread factory", spawning threads "on-demand"
   //     to run the service specified by a user-supplied
   //     <SVC_HANDLER>.
-{
 public:
   // = Intialization and termination methods.
   ACE_Thread_Strategy (int flags = 0);
@@ -334,6 +334,7 @@ protected:
 
 template <class SVC_HANDLER>
 class ACE_Process_Strategy : public ACE_Concurrency_Strategy<SVC_HANDLER>
+{
   // = TITLE
   //     Defines the interface for specifying a concurrency strategy
   //     for a <SVC_HANDLER> based on multiprocessing.
@@ -344,7 +345,6 @@ class ACE_Process_Strategy : public ACE_Concurrency_Strategy<SVC_HANDLER>
   //     behaves as a "process factory", forking threads "on-demand"
   //     to run the service specified by a user-supplied
   //     <SVC_HANDLER>.
-{
 public:
   // = Intialization and termination methods.
 
@@ -395,6 +395,7 @@ protected:
 
 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
 class ACE_Accept_Strategy
+{
   // = TITLE
   //     Defines the interface for specifying a passive connection
   //     acceptance strategy for a SVC_HANDLER.
@@ -402,7 +403,6 @@ class ACE_Accept_Strategy
   // = DESCRIPTION
   //     This class provides a strategy that manages passive
   //     connection acceptance of a client.
-{
 public:
   // = Initialization and termination methods.
   ACE_Accept_Strategy (ACE_Reactor *reactor = ACE_Reactor::instance ());
@@ -446,6 +446,7 @@ protected:
 
 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1>
 class ACE_Connect_Strategy
+{
   // = TITLE
   //     Defines the interface for specifying an active
   //     connection establishment strategy for a SVC_HANDLER.
@@ -453,7 +454,6 @@ class ACE_Connect_Strategy
   // = DESCRIPTION
   //     This class provides a strategy that manages active
   //     connection establishment to a server.
-{
 public:
   // = Initialization and termination methods.
   ACE_Connect_Strategy (void);
@@ -488,6 +488,7 @@ protected:
 
 template <class SVC_HANDLER>
 class ACE_Scheduling_Strategy
+{
   // = TITLE
   //     Defines the interface for specifying how to suspend and
   //     resume a service .
@@ -496,7 +497,6 @@ class ACE_Scheduling_Strategy
   //     This class provides a strategy that allows arbitrarily
   //     sophisticated service suspension and resumption.  The default
   //     behavior is to do nothing...
-{
 public:
   // = Initialization and termination methods.
 
@@ -527,8 +527,8 @@ protected:
 
 template <class SVC_HANDLER>
 class ACE_NOOP_Creation_Strategy : public ACE_Creation_Strategy<SVC_HANDLER>
+{
   // = TITLE
-  //
   //     Implements a no-op creation strategy in order to defer
   //     decisions regarding creation to some later point in time, such
   //     as in connect or accept strategy.
@@ -537,7 +537,6 @@ class ACE_NOOP_Creation_Strategy : public ACE_Creation_Strategy<SVC_HANDLER>
   //     An example of the use of this is in the
   //     <ACE_Cached_Connect_Strategy>, which only returns a single
   //     connection for a given endpoint.
-{
 public:
   virtual int make_svc_handler (SVC_HANDLER *&);
   // This is a no-op.
@@ -545,18 +544,16 @@ public:
 
 template <class SVC_HANDLER>
 class ACE_NOOP_Concurrency_Strategy : public ACE_Concurrency_Strategy<SVC_HANDLER>
+{
   // = TITLE
-  //
   //     Implements a no-op activation strategy in order to avoid
   //     calling open on a svc_handler multiple times.
   //
   // = DESCRIPTION
-  //
   //     An example of the use of this is in the
   //     <ACE_Cached_Connect_Strategy>, which reuses svc_handlers.
   //     Therefore we don't want to call open on the recycled
   //     svc_handler more than once.
-{
 public:
   // = Factory method.
   virtual int activate_svc_handler (SVC_HANDLER *svc_handler,
@@ -566,16 +563,15 @@ public:
 
 template <class ADDR_T>
 class ACE_Hash_Addr
+{
   // = TITLE
   //     Internal class to compute hash values on addresses in
   //     <ACE_Cached_Connect_Strategy>.
   //
   // = DESCRIPTION
-  //
   //     Intended to be used as a key to an <ACE_Hash_Map_Manager>.
   //     <ADDR_T> parameter/subclass is typically <ACE_INET_Addr>.  It
   //     is expected to implement operator==().
-{
 public:
   // = Initialization methods.
   ACE_Hash_Addr (void);
@@ -615,9 +611,8 @@ private:
 };
 
 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX>
-class ACE_Cached_Connect_Strategy
-  : public ACE_Connection_Recycling_Strategy,
-    public ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>
+class ACE_Cached_Connect_Strategy : public ACE_Connection_Recycling_Strategy, public ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>
+{
   // = TITLE
   //     A connection strategy which caches connections to peers
   //     (represented by <SVC_HANDLER> instances), thereby allowing
@@ -646,7 +641,6 @@ class ACE_Cached_Connect_Strategy
   //
   // = SEE ALSO
   //     <ACE_Hash_Addr>.
-{
 public:
 
   ACE_Cached_Connect_Strategy (ACE_Creation_Strategy<SVC_HANDLER> *cre_s = 0,
@@ -752,6 +746,7 @@ private:
 
 template <class SVC_HANDLER>
 class ACE_Schedule_All_Reactive_Strategy : public ACE_Scheduling_Strategy<SVC_HANDLER>
+{
   // = TITLE
   //     Defines the interface for specifying how to suspend and
   //     resume a single-threaded reactive service .
@@ -759,7 +754,6 @@ class ACE_Schedule_All_Reactive_Strategy : public ACE_Scheduling_Strategy<SVC_HA
   // = DESCRIPTION
   //     This class provides a strategy that suspends and resumes all
   //     the Event_Handlers in a Reactor in one fell swoop.
-{
 public:
   // = Initialization and termination methods.
   ACE_Schedule_All_Reactive_Strategy (SVC_HANDLER * = 0);
@@ -779,6 +773,7 @@ public:
 
 template <class SVC_HANDLER>
 class ACE_Schedule_All_Threaded_Strategy : public ACE_Scheduling_Strategy<SVC_HANDLER>
+{
   // = TITLE
   //     Defines the interface for specifying how to suspend and
   //     resume a multithreaded service .
@@ -786,7 +781,6 @@ class ACE_Schedule_All_Threaded_Strategy : public ACE_Scheduling_Strategy<SVC_HA
   // = DESCRIPTION
   //     This class provides a strategy that suspends and resumes all
   //     the Event_Handlers controlled by a Thread_Manager in one fell swoop.
-{
 public:
   // = Initialization and termination methods.
   ACE_Schedule_All_Threaded_Strategy (SVC_HANDLER * = 0);
diff --git a/ace/Stream.h b/ace/Stream.h
index a3803293072..cf4e7f3f81a 100644
--- a/ace/Stream.h
+++ b/ace/Stream.h
@@ -31,6 +31,7 @@ template<ACE_SYNCH_DECL> class ACE_Stream_Iterator;
 
 template <ACE_SYNCH_DECL>
 class ACE_Stream
+{
   // = TITLE
   //    This class is the primary abstraction for the ASX framework.
   //    It is moduled after System V Stream.
@@ -38,9 +39,9 @@ class ACE_Stream
   // = DESCRIPTION
   //    A Stream consists of a stack of <ACE_Modules>, each of which
   //    contains two <ACE_Tasks>.
-{
-friend class ACE_Stream_Iterator<ACE_SYNCH_USE>;
 public:
+  friend class ACE_Stream_Iterator<ACE_SYNCH_USE>;
+
   enum
   {
     M_DELETE = 3
@@ -160,9 +161,9 @@ private:
 
 template <ACE_SYNCH_DECL>
 class ACE_Stream_Iterator
+{
   // = TITLE
   //     Iterate through an <ACE_Stream>.
-{
 public:
   // = Initialization method.
   ACE_Stream_Iterator (const ACE_Stream<ACE_SYNCH_USE> &sr);
diff --git a/ace/Stream_Modules.h b/ace/Stream_Modules.h
index e4864ae6d3a..1ad9aaab381 100644
--- a/ace/Stream_Modules.h
+++ b/ace/Stream_Modules.h
@@ -21,14 +21,14 @@
 
 template <ACE_SYNCH_DECL>
 class ACE_Stream_Head : public ACE_Task<ACE_SYNCH_USE>
+{
   // = TITLE
   //    Standard module that acts as the head of a ustream.
-{
 public:
-  ACE_Stream_Head ();
+  ACE_Stream_Head (void);
   // Construction 
 
-  ~ACE_Stream_Head ();
+  ~ACE_Stream_Head (void);
   // Destruction
 
   // = ACE_Task hooks
@@ -56,14 +56,14 @@ private:
 
 template <ACE_SYNCH_DECL>
 class ACE_Stream_Tail : public ACE_Task<ACE_SYNCH_USE>
+{
   // = TITLE
   //    Standard module that acts as the head of a ustream.
-{
 public:
-  ACE_Stream_Tail ();
+  ACE_Stream_Tail (void);
   // Construction 
 
-  ~ACE_Stream_Tail ();
+  ~ACE_Stream_Tail (void);
   // Destruction
 
   // = ACE_Task hooks
@@ -91,15 +91,15 @@ private:
 
 template <ACE_SYNCH_DECL>
 class ACE_Thru_Task : public ACE_Task<ACE_SYNCH_USE>
+{
   // = TITLE
   //    Standard module that acts as a "no op", simply passing on all
   //    data to its adjacent neighbor.
-{
 public:
-  ACE_Thru_Task ();
+  ACE_Thru_Task (void);
   // Construction 
 
-  ~ACE_Thru_Task ();
+  ~ACE_Thru_Task (void);
   // Destruction
 
   // = ACE_Task hooks
diff --git a/ace/Svc_Handler.h b/ace/Svc_Handler.h
index e038e7f0d52..bf5709125f8 100644
--- a/ace/Svc_Handler.h
+++ b/ace/Svc_Handler.h
@@ -29,6 +29,7 @@ class ACE_Connection_Recycling_Strategy;
 
 template <ACE_PEER_STREAM_1, ACE_SYNCH_DECL>
 class ACE_Svc_Handler : public ACE_Task<ACE_SYNCH_USE>
+{
   // = TITLE
   //     Defines the interface for a service that exchanges data with
   //     its connected peer.
@@ -43,7 +44,6 @@ class ACE_Svc_Handler : public ACE_Task<ACE_SYNCH_USE>
   //     ACE_Connector when a connection is established successfully.
   //     This endpoint is used to exchange data between a
   //     ACE_Svc_Handler and the peer it is connected with.
-{
 public:
   // = Initialization and termination methods.
   ACE_Svc_Handler (ACE_Thread_Manager * = 0, 
diff --git a/ace/Synch.h b/ace/Synch.h
index 4c21728b502..ff2c766e843 100644
--- a/ace/Synch.h
+++ b/ace/Synch.h
@@ -30,6 +30,7 @@ class ACE_Time_Value;
 // template <class ACE_COND_MUTEX> class ACE_Condition;
 
 class ACE_Lock
+{
   // = TITLE
   //     This is the abstract base class that contains the uniform
   //     locking API that is supported by all the ACE synchronization
@@ -44,7 +45,6 @@ class ACE_Lock
   //     that (1) they add ~20% extra overhead for virtual function
   //     calls and (2) objects with virtual functions can't be placed
   //     into shared memory.
-{
 public:
   virtual int remove (void) = 0;
   // Explicitly destroy the lock.
@@ -85,13 +85,13 @@ public:
 };
 
 class ACE_Export ACE_File_Lock
+{
   // = TITLE
   //     A wrapper around the UNIX file locking mechanism.
   //
   // = DESCRIPTION
   //     Allows us to "adapt" the UNIX file locking mechanisms to work
   //     with all of our Guard stuff...
-{
 public:
   ACE_File_Lock (ACE_HANDLE handle = ACE_INVALID_HANDLE);
   // Set the <handle_> of the File_Lock to <handle>.  Note that this
@@ -176,9 +176,9 @@ private:
 };
 
 class ACE_Export ACE_Semaphore
+{
   // = TITLE
   //     Wrapper for Dijkstra style general semaphores.
-{
 public:
   // = Initialization and termination.
   ACE_Semaphore (u_int count = 1, // By default make this unlocked.
@@ -262,10 +262,10 @@ private:
 };
 
 class ACE_Export ACE_Process_Semaphore
+{
   // = TITLE
   //     Wrapper for Dijkstra style general semaphores that work
   //     across processes.
-{
 public:
   ACE_Process_Semaphore (u_int count = 1, // By default make this unlocked.
 			 LPCTSTR name = 0,
@@ -338,13 +338,13 @@ protected:
 };
 
 class ACE_Export ACE_RW_Mutex
+{
   // = TITLE
   //     Wrapper for readers/writer locks.
   //
   // = DESCRIPTION
   //     These are most useful for applications that have many more
   //     parallel readers than writers...
-{
 public:
   ACE_RW_Mutex (int type = USYNC_THREAD,
 		LPCTSTR name = 0,
@@ -407,10 +407,10 @@ private:
 };
 
 class ACE_Export ACE_Mutex
+{
   // = TITLE
   //     <ACE_Mutex> wrapper (valid in same process or across
   //     processes (depending on TYPE flag)).
-{
 public:
   ACE_Mutex (int type = USYNC_THREAD,
 	     LPCTSTR name = 0,
@@ -478,11 +478,11 @@ private:
 };
 
 class ACE_Export ACE_Process_Mutex
+{
   // = TITLE
   //     A wrapper for mutexes that can be used across processes on
   //     the same host machine, as well as within a process, of
   //     course.
-{
 public:
   ACE_Process_Mutex (LPCTSTR name = 0,
 		     void *arg = 0);
@@ -540,9 +540,9 @@ public:
 };
 
 class ACE_Export ACE_RW_Process_Mutex : public ACE_Process_Mutex
+{
   // = TITLE
   //     Wrapper for readers/writer locks that exist across processes.
-{
 public:
   ACE_RW_Process_Mutex (LPCTSTR name = 0,
                         int flags = O_CREAT|O_RDWR);
@@ -596,9 +596,9 @@ private:
 };
 
 class ACE_Null_Barrier
+{
   // = TITLE
   //     Implements "NULL barrier synchronization".
-{
 public:
   ACE_Null_Barrier (u_int,
 		    const char * = 0,
@@ -622,10 +622,10 @@ private:
 };
 
 class ACE_Export ACE_Null_Mutex
+{
   // = TITLE
   //     Implement a do nothing <ACE_Mutex>, i.e., all the methods are
   //     no ops.
-{
 public:
   ACE_Null_Mutex (LPCTSTR = 0) {}
   ~ACE_Null_Mutex (void) {}
@@ -647,11 +647,11 @@ public:
 };
 
 class ACE_Export ACE_Null_Condition
+{
   // = TITLE
   //     Implement a do nothing <ACE_Condition> variable wrapper, i.e.,
   //     all methods are no ops.  This class is necessary since some
   //     C++ compilers are *very* lame...
-{
 public:
   ACE_Null_Condition (ACE_Null_Mutex &m, int = 0,
 			    LPCTSTR = 0, void * = 0): mutex_ (m) {}
@@ -678,6 +678,7 @@ private:
 };
 
 class ACE_Export ACE_Null_Mutex_Guard
+{
   // = TITLE
   //     This data structure is meant to be used within a method or
   //     function...  It performs automatic aquisition and release of
@@ -686,7 +687,6 @@ class ACE_Export ACE_Null_Mutex_Guard
   // = DESCRIPTION
   //     This should be a specialization of ACE_Guard, but compiler
   //     bugs preclude this...
-{
 public:
   ACE_Null_Mutex_Guard (ACE_Null_Mutex &) {}
   ~ACE_Null_Mutex_Guard (void) {}
@@ -704,6 +704,7 @@ private:
 };
 
 class ACE_TSS_Adapter
+{
   // = TITLE
   //     This class encapsulates a TSS object and its associated
   //     C++ destructor function.  It is used by the ACE_TSS...
@@ -716,7 +717,6 @@ class ACE_TSS_Adapter
   //     storage. ts_obj_ points to the "real" object and
   //     func_ is a pointer to the C++ cleanup function for ts_obj_.
   //
-{
 public:
   ACE_TSS_Adapter (void *object, ACE_THR_DEST f);
   // Initialize the adapter.
@@ -734,13 +734,13 @@ public:
 };
 
 class ACE_Export ACE_Event
+{
   // = TITLE
   //     A wrapper around the Win32 event locking mechanism.
   //
   // = DESCRIPTION
   //     Portable implementation of an Event mechanism, which is
   //     native to Win32, but must be emulated on UNIX.
-{
 public:
   ACE_Event (int manual_reset = 0,
 	     int initial_state = 0,
@@ -815,14 +815,13 @@ private:
 };
 
 class ACE_Export ACE_Manual_Event : public ACE_Event
+{
   // = TITLE
   //     Manual Events.
   //
   // = DESCRIPTION
-  //
   //     Specialization of Event mechanism which wakes up all waiting
   //     threads on signal()
-{
 public:
   ACE_Manual_Event (int initial_state = 0,
 		    int type = USYNC_THREAD,
@@ -838,14 +837,13 @@ public:
 };
 
 class ACE_Export ACE_Auto_Event : public ACE_Event
+{
   // = TITLE
   //     Auto Events.
   //
   // = DESCRIPTION
-  //
   //     Specialization of Event mechanism which wakes up one waiting
   //     thread on signal()
-{
 public:
   ACE_Auto_Event (int initial_state = 0,
 		  int type = USYNC_THREAD,
@@ -864,12 +862,12 @@ public:
 #if defined (ACE_HAS_THREADS)
 
 class ACE_Export ACE_Thread_Mutex
+{
   // = TITLE
   //     ACE_Thread_Mutex wrapper (only valid for threads in the same
   //     process).
   //
   // = DESCRIPTION
-  //
   //     This implementation is optimized for locking threads that are
   //     in the same process.  It maps to <CRITICAL_SECTION>s on NT
   //     and <ACE_mutex_t> with <type> set to <USYNC_THREAD> on UNIX.
@@ -879,7 +877,6 @@ class ACE_Export ACE_Thread_Mutex
   //     recursive.  To be totally safe and portable, developers
   //     should use ACE_Recursive_Thread_Mutex when they need a
   //     recursive mutex.
-{
 public:
   ACE_Thread_Mutex (LPCTSTR name = 0, void *arg = 0);
 
@@ -944,6 +941,7 @@ private:
 };
 
 class ACE_Export ACE_Thread_Mutex_Guard
+{
   // = TITLE
   //     This data structure is meant to be used within a method or
   //     function...  It performs automatic aquisition and release of
@@ -952,7 +950,6 @@ class ACE_Export ACE_Thread_Mutex_Guard
   // = DESCRIPTION
   //     This should be a specialization of <ACE_Guard>, but compiler
   //     bugs in older C++ compilers preclude this...
-{
 public:
   ACE_Thread_Mutex_Guard (ACE_Thread_Mutex &m, int block = 1);
   // Implicitly and automatically acquire the lock.
@@ -998,6 +995,7 @@ private:
 };
 
 class ACE_Export ACE_Condition_Thread_Mutex
+{
   // = TITLE
   //     ACE_Condition variable wrapper written using ACE_Mutexes This
   //     allows threads to block until shared data changes state.
@@ -1017,7 +1015,6 @@ class ACE_Export ACE_Condition_Thread_Mutex
   // = DESCRIPTION
   //     This should be an instantiation of ACE_Condition but problems
   //     with compilers precludes this...
-{
 public:
   ACE_Condition_Thread_Mutex (const ACE_Thread_Mutex &m,
 			      LPCTSTR name = 0,
@@ -1076,6 +1073,7 @@ private:
 };
 
 class ACE_Export ACE_Recursive_Thread_Mutex
+{
   // = TITLE
   //     Implement a C++ wrapper that allows calls to class
   //     <ACE_Thread_Mutex> to be nested for a nested acquire() that
@@ -1087,7 +1085,6 @@ class ACE_Export ACE_Recursive_Thread_Mutex
   //     compilers preclude this.  This implementation is based
   //     on an algorithm sketched by Dave Butenhof  <butenhof@zko.dec.com>.
   //     Naturally, I take the credit for any mistakes ;-)
-{
   // friend class ACE_Condition<class ACE_COND_MUTEX>;
 public:
   ACE_Recursive_Thread_Mutex (LPCTSTR name = 0,
@@ -1180,9 +1177,9 @@ private:
 };
 
 class ACE_Export ACE_RW_Thread_Mutex : public ACE_RW_Mutex
+{
   // = TITLE
   //     Wrapper for readers/writer locks that exist within a process.
-{
 public:
   ACE_RW_Thread_Mutex (LPCTSTR name = 0,
 		       void *arg = 0);
@@ -1195,10 +1192,10 @@ public:
 };
 
 class ACE_Export ACE_Thread_Semaphore : public ACE_Semaphore
+{
   // = TITLE
   //     Wrapper for Dijkstra style general semaphores that work
   //     only within one process.
-{
 public:
   ACE_Thread_Semaphore (u_int count = 1, // By default make this unlocked.
 			LPCTSTR name = 0,
@@ -1236,6 +1233,7 @@ struct ACE_Export ACE_Sub_Barrier
 };
 
 class ACE_Export ACE_Barrier
+{
   // = TITLE
   //     Implements "barrier synchronization".
   //
@@ -1248,7 +1246,6 @@ class ACE_Export ACE_Barrier
   //     correct.  This code is based on an article from SunOpsis
   //     Vol. 4, No. 1 by Richard Marejka
   //     (Richard.Marejka@canada.sun.com).
-{
 public:
   ACE_Barrier (u_int count,
 	       LPCTSTR name = 0,
@@ -1293,10 +1290,14 @@ private:
 };
 
 #if 0
+// The following two classes are commented out since there doesn't
+// appear to be a portable and robust means of implementing this
+// functionality across platforms. 
+
 class ACE_Process_Condition
+{
   // = TITLE
   //     ACE_Condition variable wrapper that works across processes.
-{
 public:
   ACE_Process_Condition (MUTEX &m, LPCTSTR name = 0, void *arg = 0);
 
@@ -1310,13 +1311,13 @@ public:
 
 #if 0
 class ACE_Export ACE_Process_Barrier : public ACE_Barrier
+{
   // = TITLE
   //     Implements "barrier synchronization" using ACE_Process_Mutexes!
   //
   // = DESCRIPTION
   //     This class is just a simple wrapper for ACE_Barrier that
   //     selects the USYNC_PROCESS variant for the locks.
-{
 public:
   ACE_Process_Barrier (u_int count, LPCTSTR name = 0);
   // Create a Process_Barrier, passing in the optional <name>.
@@ -1330,13 +1331,13 @@ public:
 #endif /* 0 */
 
 class ACE_Export ACE_Thread_Barrier : public ACE_Barrier
+{
   // = TITLE
   //     Implements "barrier synchronization" using ACE_Thread_Mutexes!
   //
   // = DESCRIPTION
   //     This class is just a simple wrapper for ACE_Barrier that
   //     selects the USYNC_THREAD variant for the locks.
-{
 public:
   ACE_Thread_Barrier (u_int count, LPCTSTR name = 0);
   // Create a Thread_Barrier, passing in the optional <name>.
diff --git a/ace/Synch_Options.h b/ace/Synch_Options.h
index ebabb224d7e..d9492f55768 100644
--- a/ace/Synch_Options.h
+++ b/ace/Synch_Options.h
@@ -20,6 +20,7 @@
 #include "ace/ACE.h"
 
 class ACE_Export ACE_Synch_Options
+{
   // = TITLE
   //     Contains the values of options used to determine the
   //     synchronous and asynchronous behavior.
@@ -51,7 +52,6 @@ class ACE_Export ACE_Synch_Options
   //          0,0  | no       | poll; but do not initiate a
   //               |          | nonblocking transaction
   //               |          | (don't use ACE_Reactor)    
-{
 public:
   // = Options flags for controlling synchronization.  Note that these
   // flags can be bit-wise "or'd" together if both options are
diff --git a/ace/Synch_T.h b/ace/Synch_T.h
index b97ce1cbb2f..9c74702c973 100644
--- a/ace/Synch_T.h
+++ b/ace/Synch_T.h
@@ -25,8 +25,8 @@ class ACE_Time_Value;
 
 template <class ACE_LOCKING_MECHANISM>
 class ACE_Lock_Adapter : public ACE_Lock
+{
   // = TITLE
-
   //     This is an adapter that allows applications to transparently
   //     combine the <ACE_Lock> abstract base class (which contains
   //     pure virtual methods) with any of the other concrete ACE
@@ -35,7 +35,6 @@ class ACE_Lock_Adapter : public ACE_Lock
   //
   // = DESCRIPTION
   //     This class uses a form of the Adapter pattern.
-{
 public:
   typedef ACE_LOCKING_MECHANISM ACE_LOCK;
 
@@ -95,6 +94,7 @@ private:
 template <class ACE_LOCK, class TYPE>
 class ACE_Test_and_Set : public ACE_Event_Handler
 {
+public:
   // = TITLE
   //     Implements the classic ``test and set'' operation.
   //
@@ -105,7 +105,6 @@ class ACE_Test_and_Set : public ACE_Event_Handler
   //     that it can be "signaled" by a Reactor when a signal occurs.
   //     We assume that <TYPE> is a data type that can be assigned the
   //     value 0 or 1.
-public:
   ACE_Test_and_Set (TYPE initial_value = 0);
 
   TYPE is_set (void) const;
@@ -131,6 +130,7 @@ private:
 
 template <class ACE_LOCK, class TYPE>
 class ACE_Atomic_Op
+{
   // = TITLE
   //     Transparently parameterizes synchronization into basic
   //     arithmetic operations.
@@ -139,7 +139,6 @@ class ACE_Atomic_Op
   //     This class is described in an article in the July/August 1994
   //     issue of the C++ Report magazine.  It implements a
   //     templatized version of the Decorator pattern from the GoF book.
-{
 public:
   // = Initialization methods.
 
@@ -228,6 +227,7 @@ private:
 
 template <class TYPE>
 class ACE_TSS
+{
   // = TITLE
   //     Allows objects that are "physically" in thread specific
   //     storage (i.e., private to a thread) to be accessed as though
@@ -238,7 +238,6 @@ class ACE_TSS
   //     thread-specific functions.  It uses the C++ operator->() to
   //     shield applications from the details of accessing
   //     thread-specific storage.
-{
 public:
   // = Initialization and termination methods.
 
@@ -311,6 +310,7 @@ protected:
 
 template <class ACE_LOCK>
 class ACE_Guard
+{
   // = TITLE
   //     This data structure is meant to be used within a method or
   //     function...  It performs automatic aquisition and release of
@@ -320,7 +320,6 @@ class ACE_Guard
   //     The <ACE_LOCK> class given as an actual parameter must provide at
   //     the very least the <acquire>, <tryacquire>, <release>, and
   //     <remove> methods.
-{
 public:
   // = Initialization and termination methods.
   ACE_Guard (ACE_LOCK &l): lock_ (&l) { this->owner_ = this->acquire(); }
@@ -390,12 +389,12 @@ private:
 
 template <class ACE_LOCK>
 class ACE_Write_Guard : public ACE_Guard<ACE_LOCK>
+{
   // = TITLE
   //     This class is similar to class <ACE_Guard>, though it
   //     acquires/releases a write lock automatically (naturally, the
   //     <ACE_LOCK> it is instantiated with must support the appropriate
   //     API).
-{
 public:
   // = Initialization method.
 
@@ -434,12 +433,12 @@ public:
 
 template <class ACE_LOCK>
 class ACE_Read_Guard : public ACE_Guard<ACE_LOCK>
+{
   // = TITLE
   //     This class is similar to class <ACE_Guard>, though it
   //     acquires/releases a read lock automatically (naturally, the
   //     <ACE_LOCK> it is instantiated with must support the appropriate
   //     API).
-{
 public:
   // = Initialization methods.
 
@@ -487,12 +486,12 @@ public:
 
 template <class ACE_LOCK>
 class ACE_TSS_Guard
+{
   // = TITLE
   //     This data structure is meant to be used within a method or
   //     function...  It performs automatic aquisition and release of
   //     a synchronization object.  Moreover, it ensures that the lock
   //     is released even if a thread exits via "thr_exit()"!
-{
 public:
   // = Initialization and termination methods.
 
@@ -545,12 +544,12 @@ private:
 
 template <class ACE_LOCK>
 class ACE_TSS_Write_Guard : public ACE_TSS_Guard<ACE_LOCK>
+{
   // = TITLE
   //     This class is similar to class ACE_TSS_Guard, though it
   //     acquires/releases a write-lock automatically (naturally, the
   //     ACE_LOCK it is instantiated with must support the appropriate
   //     API).
-{
 public:
   // = Initialization method.
 
@@ -582,12 +581,12 @@ public:
 
 template <class ACE_LOCK>
 class ACE_TSS_Read_Guard : public ACE_TSS_Guard<ACE_LOCK>
+{
   // = TITLE
   //     This class is similar to class <ACE_TSS_Guard>, though it
   //     acquires/releases a read lock automatically (naturally, the
   //     <ACE_LOCK> it is instantiated with must support the
   //     appropriate API).
-{
 public:
   // = Initialization method.
   ACE_TSS_Read_Guard (ACE_LOCK &lock, int block = 1);
@@ -621,6 +620,7 @@ public:
 
 template <class MUTEX>
 class ACE_Condition
+{
   // = TITLE
   //     ACE_Condition variable wrapper, which allows threads to block
   //     until shared data changes state.
@@ -637,7 +637,6 @@ class ACE_Condition
   //     variable.  The waiting threads, upon awakening, reacquire the
   //     mutex and re-evaluate the condition.
   //
-{
 public:
   // = Initialiation and termination methods.
   ACE_Condition (MUTEX &m, int type = USYNC_THREAD,
@@ -699,6 +698,7 @@ private:
 
 template <class MUTEX>
 class ACE_Thread_Condition : public ACE_Condition<MUTEX>
+{
   // = TITLE
   //     ACE_Condition variable wrapper that works within processes.
   //
@@ -714,7 +714,6 @@ class ACE_Thread_Condition : public ACE_Condition<MUTEX>
   //     up waiting threads by signaling the associated condition
   //     variable.  The waiting threads, upon awakening, reacquire the
   //     mutex and re-evaluate the condition.
-{
 public:
   // = Initialization method.
   ACE_Thread_Condition (MUTEX &m, LPCTSTR name = 0, void *arg = 0);
@@ -731,10 +730,10 @@ public:
 #if defined (ACE_HAS_TEMPLATE_TYPEDEFS)
 
 class ACE_NULL_SYNCH
+{
   // = TITLE
   //     Implement a do nothing Synchronization wrapper that
   //     typedefs the <ACE_Condition> and <ACE_Mutex> to the Null* versions.
-{
 public:
   typedef ACE_Null_Mutex MUTEX;
   typedef ACE_Null_Mutex NULL_MUTEX;
@@ -749,13 +748,13 @@ public:
 #if defined (ACE_HAS_THREADS)
 
 class ACE_MT_SYNCH
+{
   // = TITLE
   //     Implement a default thread safe synchronization wrapper that
   //     typedefs the <ACE_Condition> and <ACE_Mutex> to the
   //     <ACE_Condition> and <ACE_Mutex> versions.  Note that this
   //     should be a template, but SunC++ 4.0.1 complains about
   //     this...
-{
 public:
   typedef ACE_Thread_Mutex MUTEX;
   typedef ACE_Null_Mutex NULL_MUTEX;
diff --git a/ace/System_Time.h b/ace/System_Time.h
index b7607829c48..a84a22fd8de 100644
--- a/ace/System_Time.h
+++ b/ace/System_Time.h
@@ -23,19 +23,19 @@
 #include "ace/Malloc_T.h"
 
 class ACE_Export ACE_Date_Time
-  // TITLE
+{
+  // = TITLE
   //    This class holds internally date and time and has interfaces
   //    for getting month or compares of times and dates, etc.
-{
 public:
 };
 
 class ACE_Export ACE_System_Time
+{
   // = TITLE
   //     Defines the timer services of the OS interface to access the
   //     system time either on the local host or on the central time
   //     server in the network.
-{
 public:
   enum Sync_Mode { Jump, Adjust };
   // enumeration types to specify mode of synchronization with master
diff --git a/ace/TLI.h b/ace/TLI.h
index 6e87c3e256b..7756ac14753 100644
--- a/ace/TLI.h
+++ b/ace/TLI.h
@@ -31,10 +31,10 @@
 #endif
 
 class ACE_Export ACE_TLI : public ACE_IPC_SAP
+{
   // = TITLE
   //     Defines the member functions for the base class of the
   //     ACE_TLI  abstraction. 
-{
 public:
   // = Initialization and termination methods.
   ACE_HANDLE open (const char device[], 
diff --git a/ace/TLI_Acceptor.h b/ace/TLI_Acceptor.h
index d3ef9c42598..5250a0cef70 100644
--- a/ace/TLI_Acceptor.h
+++ b/ace/TLI_Acceptor.h
@@ -24,12 +24,11 @@
 
 #if defined (ACE_HAS_TLI)
 
-/* Oh what I wouldn't do for namespaces... */
-
 // Forward reference...
 class ACE_TLI_Request_Queue;
 
 class ACE_Export ACE_TLI_Acceptor : public ACE_TLI
+{
   // = TITLE
   //     Defines the member functions for ACE_TLI_Acceptor abstraction. 
   // 
@@ -38,9 +37,9 @@ class ACE_Export ACE_TLI_Acceptor : public ACE_TLI
   //     book on System V UNIX network programming.  It basically
   //     makes TLI look like the C++ SOCK_SAP socket wrappers with
   //     respect to establishing passive-mode listener endpoints.
-{
-friend class ACE_Request_Queue;
 public:
+  friend class ACE_Request_Queue;
+
   // = Initialization and termination methods.
   ACE_TLI_Acceptor (void);
   // Default constructor.
diff --git a/ace/TLI_Connector.h b/ace/TLI_Connector.h
index 7723132e8e0..065aee6a791 100644
--- a/ace/TLI_Connector.h
+++ b/ace/TLI_Connector.h
@@ -22,9 +22,10 @@
 #if defined (ACE_HAS_TLI)
 
 class ACE_Export ACE_TLI_Connector : public ACE_TLI
-  // = TITLE
-  //     Defines an active connection factory for the ACE_TLI C++ wrappers. 
 {
+  // = TITLE
+  //     Defines an active connection factory for the ACE_TLI C++
+  //     wrappers.
 public:
   // = Initialization methods.
   ACE_TLI_Connector (void);
diff --git a/ace/TLI_Stream.h b/ace/TLI_Stream.h
index e001958b91e..9799e500c9b 100644
--- a/ace/TLI_Stream.h
+++ b/ace/TLI_Stream.h
@@ -24,12 +24,13 @@
 #if defined (ACE_HAS_TLI)
 
 class ACE_Export ACE_TLI_Stream : public ACE_TLI
+{
   // = TITLE
   //     Defines the member functions for ACE_TLI_Stream abstraction. 
-{
-friend class ACE_TLI_Acceptor;
-friend class ACE_TLI_Connector;
 public:
+  friend class ACE_TLI_Acceptor;
+  friend class ACE_TLI_Connector;
+
   // = Initialization and termination methods.
   ACE_TLI_Stream (void);
   // Default constructor.
diff --git a/ace/TTY_IO.h b/ace/TTY_IO.h
index fba33fdc797..678f1ce0ff7 100644
--- a/ace/TTY_IO.h
+++ b/ace/TTY_IO.h
@@ -25,6 +25,7 @@
 #include "ace/DEV_IO.h"
 
 class ACE_Export ACE_TTY_IO : public ACE_DEV_IO
+{
   // = TITLE
   //     Class definitions for platform specific TTY features.
   //   
@@ -35,7 +36,6 @@ class ACE_Export ACE_TTY_IO : public ACE_DEV_IO
   //     a special structure (Serial_Params) as argument to allow a
   //     comfortable user interface (away from that annoying termios
   //     structure, which is very specific to UNIX).
-{
 public:
   enum Control_Mode
   {
diff --git a/ace/Task.h b/ace/Task.h
index 4e1cab43b08..dbf562b830d 100644
--- a/ace/Task.h
+++ b/ace/Task.h
@@ -21,6 +21,8 @@
 #include "ace/Thread_Manager.h"
 
 class ACE_Export ACE_Task_Flags
+{
+public:
   // = TITLE
   //    These flags are used within the ACE_Task.
   //
@@ -29,8 +31,6 @@ class ACE_Export ACE_Task_Flags
   //    HP/UX C++ compiler can't grok this...  Fortunately, there's no
   //    code defined here, so we don't have to worry about multiple
   //    definitions.
-{
-public:
   enum
   {
     ACE_READER     = 01,  // Identifies a Task as being the "reader" in a Module.
@@ -43,6 +43,7 @@ public:
 };
 
 class ACE_Export ACE_Task_Base : public ACE_Service_Object
+{
   // = TITLE
   //    Direct base class for the ACE_Task template.
   //
@@ -51,12 +52,14 @@ class ACE_Export ACE_Task_Base : public ACE_Service_Object
   //    reduce template bloat, as well as to make it possible for the
   //    <ACE_Thread_Manager> to store <ACE_Task_Base> *'s
   //    polymorphically.
-{
 public:
   // = Initialization method.
   ACE_Task_Base (ACE_Thread_Manager *);
 
-  // = Initialization and termination hooks (note that these *must* be defined by subclasses).
+  // = Initialization and termination hooks 
+
+  // Note that these methods *must* be defined by subclasses.
+
   virtual int open (void *args = 0);
   // Hook called to open a Task.  <args> can be used to pass arbitrary
   // information into <open>.
diff --git a/ace/Task_T.h b/ace/Task_T.h
index 4ac79cdc5da..68f92de669d 100644
--- a/ace/Task_T.h
+++ b/ace/Task_T.h
@@ -26,6 +26,7 @@ template <ACE_SYNCH_DECL> class ACE_Module;
 
 template <ACE_SYNCH_DECL>
 class ACE_Task : public ACE_Task_Base
+{
   // = TITLE
   //    Primary interface for application message processing, as well
   //    as input and output message queueing.
@@ -33,10 +34,10 @@ class ACE_Task : public ACE_Task_Base
   // = DESCRIPTION
   //    This class serves as the basis for passive and active objects
   //    in ACE.
-{
-friend class ACE_Module<ACE_SYNCH_USE>;
-friend class ACE_Module_Type;
 public:
+  friend class ACE_Module<ACE_SYNCH_USE>;
+  friend class ACE_Module_Type;
+
   // = Initialization/termination methods.
   ACE_Task (ACE_Thread_Manager *thr_mgr = 0,
 	    ACE_Message_Queue<ACE_SYNCH_USE> *mq = 0);
diff --git a/ace/Thread.h b/ace/Thread.h
index ab3cfdb6bf0..45d7514d4e2 100644
--- a/ace/Thread.h
+++ b/ace/Thread.h
@@ -26,8 +26,11 @@ class ACE_Export ACE_Thread
   //
   // = DESCRIPTION
   //     This class provides a common interface that is mapped onto
-  //     either POSIX Pthreads, Solaris threads, or Win32 threads.
-
+  //     POSIX Pthreads, Solaris threads, Win32 threads, VxWorks
+  //     threads, or pSoS threads.  Note, however, that it is
+  //     generally a better idea to use the <ACE_Thread_Manager>
+  //     programming API rather than the <ACE_Thread> API since the
+  //     thread manager is more powerful. 
 public:
   static int spawn (ACE_THR_FUNC func, 
 		    void *arg = 0,
diff --git a/ace/Thread_Manager.h b/ace/Thread_Manager.h
index 71c4b2d56a1..3971880fb76 100644
--- a/ace/Thread_Manager.h
+++ b/ace/Thread_Manager.h
@@ -128,11 +128,11 @@ typedef int (ACE_Thread_Manager::*ACE_THR_MEMBER_FUNC)(ACE_Thread_Descriptor *,
 #endif /* __GNUG__ */
 
 class ACE_Export ACE_Thread_Manager
+{
   // = TITLE
   //    Manages a pool of threads.
   //
   // = DESCRIPTION
-
   //    This class allows operations on groups of threads atomically.
   //    The default behavior behavior of thread manager is to wait on
   //    all threads under it's management when it gets destructed.
@@ -147,9 +147,9 @@ class ACE_Export ACE_Thread_Manager
   //    you are sure to have resource leaks in your program.  Remember
   //    to wait on threads before exiting main() if that could happen
   //    in your programs.
-{
-friend class ACE_Thread_Control;
 public:
+  friend class ACE_Thread_Control;
+
 #if !defined (__GNUG__)
   typedef int (ACE_Thread_Manager::*ACE_THR_MEMBER_FUNC)(ACE_Thread_Descriptor *, int);
 #endif /* !__GNUG__ */
@@ -544,6 +544,7 @@ private:
 };
 
 class ACE_Export ACE_Thread_Control
+{
   // = TITLE
   //     Used to keep track of a thread's activities within its entry
   //     point function.
@@ -558,7 +559,6 @@ class ACE_Export ACE_Thread_Control
   //     <ACE_TSS::cleanup> function deletes this object, thereby
   //     ensuring that it gets removed from its associated
   //     <ACE_Thread_Manager>.
-{
 public:
   ACE_Thread_Control (ACE_Thread_Manager *tm = 0,
 		      int insert = 0);
@@ -606,6 +606,7 @@ private:
 };
 
 class ACE_Export ACE_Thread_Exit
+{
   // = TITLE
   //    Keep exit information for a Thread in thread specific storage.
   //    so that the thread-specific exit hooks will get called no
@@ -618,7 +619,6 @@ class ACE_Export ACE_Thread_Exit
   //    storage using the <ACE_TSS> wrapper.  When a thread exits the
   //    <ACE_TSS::cleanup> function deletes this object, thereby
   //    closing it down gracefully.
-{
 public:
   ACE_Thread_Exit (void);
   // Capture the Thread that will be cleaned up automatically.
diff --git a/ace/Time_Request_Reply.h b/ace/Time_Request_Reply.h
index ce78fe3b0cc..0f648fb9751 100644
--- a/ace/Time_Request_Reply.h
+++ b/ace/Time_Request_Reply.h
@@ -26,13 +26,13 @@
 #include "ace/SString.h"
 
 class ACE_Export ACE_Time_Request
+{
   // = TITLE
   //   Message format for delivering requests to the ACE_Time Server.
   //
   // = DESCRIPTION
   //   This class is implemented to minimize data copying.  
   //   In particular, all marshaling is done in situ...
-{
 public:
   enum Constants
   {
diff --git a/ace/Timer_Hash_T.h b/ace/Timer_Hash_T.h
index 8bebc77f86c..e4fa98a62b3 100644
--- a/ace/Timer_Hash_T.h
+++ b/ace/Timer_Hash_T.h
@@ -27,13 +27,13 @@ class ACE_Timer_Hash_T;
 
 template <class TYPE, class FUNCTOR, class ACE_LOCK>
 class ACE_Timer_Hash_Upcall
+{
   // = TITLE 
   //      Functor for Timer_Hash
   //
   // = DESCRIPTION
   //      This class calls up to the Timer Hash's functor from the 
   //      timer queues in the hash table
-{
 public:
   typedef ACE_Timer_Queue_T<ACE_Event_Handler *, 
                             ACE_Timer_Hash_Upcall<TYPE, FUNCTOR, ACE_LOCK>, 
@@ -74,6 +74,7 @@ private:
 
 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET>
 class ACE_Timer_Hash_Iterator_T : public ACE_Timer_Queue_Iterator_T <TYPE, FUNCTOR, ACE_LOCK>
+{
   // = TITLE
   //     Iterates over an <ACE_Timer_Hash>.
   //
@@ -81,7 +82,6 @@ class ACE_Timer_Hash_Iterator_T : public ACE_Timer_Queue_Iterator_T <TYPE, FUNCT
   //     This is a generic iterator that can be used to visit every
   //     node of a timer queue.  Be aware that it doesn't transverse
   //     in the order of timeout values.  
-{
 public:
   ACE_Timer_Hash_Iterator_T (ACE_Timer_Hash_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET> &);
   // Constructor.
@@ -111,6 +111,7 @@ protected:
 
 template <class TYPE, class FUNCTOR, class ACE_LOCK, class BUCKET>
 class ACE_Timer_Hash_T : public ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK>
+{
   // = TITLE 
   //      Provides a hash table of <BUCKET>s as an implementation for
   //      a timer queue.
@@ -119,15 +120,16 @@ class ACE_Timer_Hash_T : public ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK>
   //      This implementation uses a hash table of BUCKETs.  The hash 
   //      is based on the time_value of the event.  Unlike other Timer 
   //      Queues, ACE_Timer_Hash does not expire events in order.  
-{
 public: 
-  typedef ACE_Timer_Hash_Iterator_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET> HASH_ITERATOR;
+  typedef ACE_Timer_Hash_Iterator_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET> 
+          HASH_ITERATOR;
   // Type of iterator
 
   friend class ACE_Timer_Hash_Iterator_T<TYPE, FUNCTOR, ACE_LOCK, BUCKET>;
   // Iterator is a friend
 
-  typedef ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK> INHERITED;
+  typedef ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK> 
+          INHERITED;
   // Type inherited from 
 
   // = Initialization and termination methods.
diff --git a/ace/Timer_Heap_T.h b/ace/Timer_Heap_T.h
index 6fac478a7c5..47c9d4c4d20 100644
--- a/ace/Timer_Heap_T.h
+++ b/ace/Timer_Heap_T.h
@@ -27,6 +27,7 @@ class ACE_Timer_Heap_T;
 
 template <class TYPE, class FUNCTOR, class ACE_LOCK>
 class ACE_Timer_Heap_Iterator_T : public ACE_Timer_Queue_Iterator_T<TYPE, FUNCTOR, ACE_LOCK> 
+{
   // = TITLE
   //     Iterates over an <ACE_Timer_Heap_T>.
   //
@@ -34,7 +35,6 @@ class ACE_Timer_Heap_Iterator_T : public ACE_Timer_Queue_Iterator_T<TYPE, FUNCTO
   //     This is a generic iterator that can be used to visit every
   //     node of a timer queue.  Be aware that it doesn't transverse
   //     in the order of timeout values.  
-{
 public:
   ACE_Timer_Heap_Iterator_T (ACE_Timer_Heap_T<TYPE, FUNCTOR, ACE_LOCK> &);
   // Constructor.
@@ -61,11 +61,11 @@ protected:
 
 template <class TYPE, class FUNCTOR, class ACE_LOCK>
 class ACE_Timer_Heap_T : public ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK>
+{
   // = TITLE 
   //      Provides a very fast and predictable timer implementation.
   //
   // = DESCRIPTION
-  //
   //      This implementation uses a heap-based callout queue of
   //      absolute times.  Therefore, in the average and worst case,
   //      scheduling, canceling, and expiring timers is O(log N) (where
@@ -74,7 +74,6 @@ class ACE_Timer_Heap_T : public ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK>
   //      the heap.  This allows us to completely remove the need for
   //      dynamic memory allocation, which is important for real-time
   //      systems.
-{
 public:
   typedef ACE_Timer_Heap_Iterator_T<TYPE, FUNCTOR, ACE_LOCK> HEAP_ITERATOR;
   friend class ACE_Timer_Heap_Iterator_T<TYPE, FUNCTOR, ACE_LOCK>;
diff --git a/ace/Timer_List_T.h b/ace/Timer_List_T.h
index eaec91b52e3..55c32bd2195 100644
--- a/ace/Timer_List_T.h
+++ b/ace/Timer_List_T.h
@@ -25,13 +25,13 @@ class ACE_Timer_List_T;
 
 template <class TYPE, class FUNCTOR, class ACE_LOCK>
 class ACE_Timer_List_Iterator_T : public ACE_Timer_Queue_Iterator_T <TYPE, FUNCTOR, ACE_LOCK>
+{
   // = TITLE
   //     Iterates over an <ACE_Timer_List>.
   //
   // = DESCRIPTION
   //     This is a generic iterator that can be used to visit every
   //     node of a timer queue.  
-{
 public:
   ACE_Timer_List_Iterator_T (ACE_Timer_List_T<TYPE, FUNCTOR, ACE_LOCK> &);
   // Constructor.
@@ -57,11 +57,11 @@ protected:
 
 template <class TYPE, class FUNCTOR, class ACE_LOCK>
 class ACE_Timer_List_T : public ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK>
+{
   // = TITLE 
   //      Provides a simple implementation of timers.
   //
   // = DESCRIPTION
-  //
   //      This implementation uses a linked list of absolute times.
   //      Therefore, in the average case, scheduling and canceling
   //      timers is O(N) (where N is the total number of timers) and
@@ -74,7 +74,6 @@ class ACE_Timer_List_T : public ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK>
   //      heap-based callout queue.  For most applications, the
   //      <ACE_Timer_Heap> will perform substantially faster than the
   //      <ACE_Timer_List>.
-{
 public: 
   typedef ACE_Timer_List_Iterator_T<TYPE, FUNCTOR, ACE_LOCK> LIST_ITERATOR;
   // Type of iterator
diff --git a/ace/Timer_Queue_Adapters.h b/ace/Timer_Queue_Adapters.h
index 13f7ab5198a..836ebe307bb 100644
--- a/ace/Timer_Queue_Adapters.h
+++ b/ace/Timer_Queue_Adapters.h
@@ -23,13 +23,13 @@
 
 template <class TQ>
 class ACE_Export ACE_Async_Timer_Queue_Adapter : public ACE_Event_Handler
+{
   // = TITLE
   //     Adapts a <TQ> to be run asynchronously.
   //
   // = DESCRIPTION
   //     This implementation uses the <ualarm> call, which generates
   //     the SIGARLM signal that is caught by this class.
-{
 public:
   typedef TQ TIMER_QUEUE;
 
@@ -78,6 +78,7 @@ private:
 
 template <class TQ>
 class ACE_Export ACE_Thread_Timer_Queue_Adapter : public ACE_Task_Base
+{
   // = TITLE
   //   Adapts a Timer_Queue using a separate thread for dispatching.
   //
@@ -90,7 +91,6 @@ class ACE_Export ACE_Thread_Timer_Queue_Adapter : public ACE_Task_Base
   //   This is a case were template parameters will be useful, but
   //   (IMHO) the effort and portability problems discourage their
   //   use.
-{
 public:
   typedef TQ TIMER_QUEUE;
 
diff --git a/ace/Timer_Queue_T.h b/ace/Timer_Queue_T.h
index b4079123eae..d29a4ffb04e 100644
--- a/ace/Timer_Queue_T.h
+++ b/ace/Timer_Queue_T.h
@@ -25,9 +25,9 @@
 
 template <class TYPE>
 class ACE_Timer_Node_T
+{
   // = TITLE
   //     Maintains the state associated with a Timer entry.
-{
 public:
   ACE_Timer_Node_T (void);
   // Default constructor
@@ -122,6 +122,7 @@ private:
 
 template <class TYPE, class FUNCTOR, class ACE_LOCK>
 class ACE_Timer_Queue_Iterator_T
+{
   // = TITLE
   //     Generic interface for iterating over a subclass of
   //     <ACE_Timer_Queue>.
@@ -130,7 +131,6 @@ class ACE_Timer_Queue_Iterator_T
   //     This is a generic iterator that can be used to visit every
   //     node of a timer queue.  Be aware that it isn't guaranteed
   //     that the transversal will be in order of timeout values.  
-{
 public:
 
   // = Initialization and termination methods.
@@ -155,6 +155,7 @@ public:
 
 template <class TYPE, class FUNCTOR, class ACE_LOCK>
 class ACE_Timer_Queue_T
+{
   // = TITLE 
   //      Provides an interface to timers.
   //
@@ -162,7 +163,6 @@ class ACE_Timer_Queue_T
   //      This is an abstract base class that provides hook for
   //      implementing specialized policies such as <ACE_Timer_List>
   //      and <ACE_Timer_Heap>.
-{
 public: 
 
   typedef ACE_Timer_Queue_Iterator_T<TYPE, FUNCTOR, ACE_LOCK> ITERATOR;
@@ -319,13 +319,13 @@ private:
 
 template <class ACE_LOCK>
 class ACE_Event_Handler_Handle_Timeout_Upcall
+{
   // = TITLE 
   //      Functor for Timer_Queues.
   //
   // = DESCRIPTION
   //      This class implements the functor required by the Timer
   //      Queue to call <handle_timeout> on ACE_Event_Handlers.
-{
 public:
   typedef ACE_Timer_Queue_T<ACE_Event_Handler *, 
                             ACE_Event_Handler_Handle_Timeout_Upcall<ACE_LOCK>, 
diff --git a/ace/Timer_Wheel_T.h b/ace/Timer_Wheel_T.h
index 4407a341ee3..7d8bb1855bf 100644
--- a/ace/Timer_Wheel_T.h
+++ b/ace/Timer_Wheel_T.h
@@ -26,6 +26,7 @@ class ACE_Timer_Wheel_T;
 
 template <class TYPE, class FUNCTOR, class ACE_LOCK>
 class ACE_Timer_Wheel_Iterator_T : public ACE_Timer_Queue_Iterator_T <TYPE, FUNCTOR, ACE_LOCK>
+{
   // = TITLE
   //     Iterates over an <ACE_Timer_Wheel>.
   //
@@ -33,7 +34,6 @@ class ACE_Timer_Wheel_Iterator_T : public ACE_Timer_Queue_Iterator_T <TYPE, FUNC
   //     This is a generic iterator that can be used to visit every
   //     node of a timer queue.  Be aware that it doesn't transverse
   //     in the order of timeout values.  
-{
 public:
   ACE_Timer_Wheel_Iterator_T (ACE_Timer_Wheel_T<TYPE, FUNCTOR, ACE_LOCK> &);
   // Constructor
@@ -63,6 +63,7 @@ protected:
 
 template <class TYPE, class FUNCTOR, class ACE_LOCK>
 class ACE_Timer_Wheel_T : public ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK>
+{
   // = TITLE 
   //      Provides a Timing Wheel version of Timer Queue
   //
@@ -76,8 +77,6 @@ class ACE_Timer_Wheel_T : public ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK>
   //      George Varghese's paper "Redesigning the BSD Callout and
   //      Timer Facilities" 
   //      (http://dworkin.wustl.edu/~varghese/PAPERS/newbsd.ps.Z)
-  //        
-{
 public: 
   typedef ACE_Timer_Wheel_Iterator_T<TYPE, FUNCTOR, ACE_LOCK> WHEEL_ITERATOR;
   // Type of iterator
diff --git a/ace/Token.h b/ace/Token.h
index 095582b8ffb..0364eaf4082 100644
--- a/ace/Token.h
+++ b/ace/Token.h
@@ -23,6 +23,7 @@
 #if defined (ACE_HAS_THREADS)
 
 class ACE_Export ACE_Token
+{
   // = TITLE
   //    Class that acquires, renews, and releases a synchronization
   //    token that is serviced in strict FIFO ordering.
@@ -35,7 +36,6 @@ class ACE_Export ACE_Token
   //    blocked awaiting the token are serviced in strict FIFO order as
   //    other threads release the token (Solaris and Pthread mutexes don't 
   //    strictly enforce an acquisition order).
-{
 public:
   // = Initialization and termination.
 
diff --git a/ace/Token_Collection.h b/ace/Token_Collection.h
index d54d2799407..a5103152f46 100644
--- a/ace/Token_Collection.h
+++ b/ace/Token_Collection.h
@@ -33,6 +33,7 @@
 #include "ace/SString.h"
 
 class ACE_Export ACE_Token_Collection : public ACE_Token_Proxy
+{
   // = TITLE
   //   Allows atomic token group operations AND
   //   provides a ACE_Token manager interface.
@@ -48,14 +49,11 @@ class ACE_Export ACE_Token_Collection : public ACE_Token_Proxy
   //   members of a collection of Token_Proxies.  This provides a
   //   single access point for operations on multiple tokens.
 
-  // = Bugs
+  // = BUGS
   //   Although ACE_Token_Collection inherits from ACE_Token_Proxy, it
   //   can not be including in a collection.  This is because clone()
   //   returns zero for now.
-
-{
 public:
-
   ACE_Token_Collection (int debug = 0,
 			const char *name = 0);
   // <debug> print out verbose debugging messages. <name> will give a
diff --git a/ace/Token_Invariants.h b/ace/Token_Invariants.h
index e818b219155..2df4de69e51 100644
--- a/ace/Token_Invariants.h
+++ b/ace/Token_Invariants.h
@@ -27,14 +27,13 @@
 #include "ace/Map_Manager.h"
 #include "ace/Local_Tokens.h"
 
-
 class ACE_Mutex_Invariants
+{
   // = TITLE
   //     Mutex Invariants
   //
   // = INVARIANTS
   //     1. Only one owner at a time.
-{
 public:
   ACE_Mutex_Invariants (void);
   // Default construction.
@@ -63,13 +62,13 @@ private:
 };
 
 class ACE_RWLock_Invariants
+{
   // = TITLE
   //     RWLock Invariants
   //
   // = INVARIANTS
   //     1. Only one writer at a time.
   //     2. If there is an owning writer, there are no owning readers.
-{
 public:
   ACE_RWLock_Invariants (void);
   // Default construction.
@@ -105,6 +104,7 @@ private:
 };
 
 class ACE_Export ACE_Token_Invariant_Manager : public ACE_Cleanup
+{
   // = TITLE
   //     Token Invariants
   //
@@ -116,7 +116,6 @@ class ACE_Export ACE_Token_Invariant_Manager : public ACE_Cleanup
   //
   //     Note that this class does not ever clean its database.  Until
   //     destroyed, it's size will forever increase.
-{
 public:
 
   static ACE_Token_Invariant_Manager *instance (void);
diff --git a/ace/Token_Manager.h b/ace/Token_Manager.h
index 1da3f962104..dd3cb0c30ba 100644
--- a/ace/Token_Manager.h
+++ b/ace/Token_Manager.h
@@ -25,92 +25,92 @@ class ACE_Local_Mutex;
 class ACE_Mutex_Token;
 
 class ACE_Export ACE_Token_Manager : public ACE_Cleanup
-// = TITLE
-//   Manages all tokens in a process space.
-//
-// = DESCRIPTION
-//   Factory:  Proxies use the token manager to obtain token
-//   references.  This allows multiple proxies to reference the same
-//   logical token.
-//   Deadlock detection:  Tokens use the manager to check for
-//   deadlock situations during acquires.
-// = EXTENDING TOKENS
-//   To add a new type of token (e.g. semaphore), do the following
-//   steps:  1. Create a new derivation of ACE_Token.  This class
-//   defines the semantics of the new Token.  2.  Create a
-//   derivation of ACE_Token_Manager.  You will only need to
-//   redefine make_mutex.
 {
+  // = TITLE
+  //   Manages all tokens in a process space.
+  //
+  // = DESCRIPTION
+  //   Factory:  Proxies use the token manager to obtain token
+  //   references.  This allows multiple proxies to reference the same
+  //   logical token.
+  //   Deadlock detection:  Tokens use the manager to check for
+  //   deadlock situations during acquires.
+
+  //   To add a new type of token (e.g. semaphore), do the following
+  //   steps: 1. Create a new derivation of ACE_Token.  This class
+  //   defines the semantics of the new Token.  2.  Create a
+  //   derivation of ACE_Token_Manager.  You will only need to
+  //   redefine make_mutex.
 public:
-    ACE_Token_Manager (void);
-    virtual ~ACE_Token_Manager (void);
-
-    // Set/get a pointer to token manager singleton.
-    static ACE_Token_Manager *instance (void);
-    void instance (ACE_Token_Manager *);
-
-    void get_token (ACE_Token_Proxy *, const char *token_name);
-    // The Token manager uses ACE_Token_Proxy::token_id_ to look for
-    // an existing token.  If none is found, the Token Manager calls
-    // ACE_Token_Proxy::create_token to create a new one.  When
-    // finished, sets ACE_Token_Proxy::token_.  <token_name> uniquely
-    // id's the token name.
-
-    int check_deadlock (ACE_Token_Proxy *proxy);
-    int check_deadlock (ACE_Tokens *token, ACE_Token_Proxy *proxy);
-    // returns 1 if the acquire will _not_ cause deadlock.
-    // returns 0 if the acquire _will_ cause deadlock.
-    // this method ignores recursive acquisition.  That is, it will not
-    // report deadlock if the client holding the token requests the
-    // token again.  Thus, it assumes recursive mutexes.
-
-    void release_token (ACE_Tokens *&token);
-    // notify the token manager that a token has been released.  If as a
-    // result, there is no owner of the token, the token is deleted.
-
-    ACE_TOKEN_CONST::MUTEX &mutex (void);
-    // This is to allow Tokens to perform atomic transactions.  The
-    // typical usage is to acquire this mutex, check for a safe_acquire,
-    // perform some queueing (if need be) and then release the lock.
-    // This is necessary since safe_acquire is implemented in terms of
-    // the Token queues.
-
-    void dump (void) const;
-    // Dump the state of the class.
-
-    void debug (int d);
-    // Turn debug mode on/off.
+  ACE_Token_Manager (void);
+  virtual ~ACE_Token_Manager (void);
+
+  // Set/get a pointer to token manager singleton.
+  static ACE_Token_Manager *instance (void);
+  void instance (ACE_Token_Manager *);
+
+  void get_token (ACE_Token_Proxy *, const char *token_name);
+  // The Token manager uses ACE_Token_Proxy::token_id_ to look for
+  // an existing token.  If none is found, the Token Manager calls
+  // ACE_Token_Proxy::create_token to create a new one.  When
+  // finished, sets ACE_Token_Proxy::token_.  <token_name> uniquely
+  // id's the token name.
+
+  int check_deadlock (ACE_Token_Proxy *proxy);
+  int check_deadlock (ACE_Tokens *token, ACE_Token_Proxy *proxy);
+  // returns 1 if the acquire will _not_ cause deadlock.
+  // returns 0 if the acquire _will_ cause deadlock.
+  // this method ignores recursive acquisition.  That is, it will not
+  // report deadlock if the client holding the token requests the
+  // token again.  Thus, it assumes recursive mutexes.
+
+  void release_token (ACE_Tokens *&token);
+  // notify the token manager that a token has been released.  If as a
+  // result, there is no owner of the token, the token is deleted.
+
+  ACE_TOKEN_CONST::MUTEX &mutex (void);
+  // This is to allow Tokens to perform atomic transactions.  The
+  // typical usage is to acquire this mutex, check for a safe_acquire,
+  // perform some queueing (if need be) and then release the lock.
+  // This is necessary since safe_acquire is implemented in terms of
+  // the Token queues.
+
+  void dump (void) const;
+  // Dump the state of the class.
+
+  void debug (int d);
+  // Turn debug mode on/off.
 
 private:
-    int debug_;
-    // Whether to print debug messages or not.
+  int debug_;
+  // Whether to print debug messages or not.
 
-    static ACE_Token_Manager *token_manager_;
-    // pointer to singleton token manager.
+  static ACE_Token_Manager *token_manager_;
+  // pointer to singleton token manager.
 
-    ACE_Tokens *token_waiting_for (const char *client_id);
-    // return the token that the given client_id is waiting for, if any
+  ACE_Tokens *token_waiting_for (const char *client_id);
+  // return the token that the given client_id is waiting for, if any
 
-    ACE_TOKEN_CONST::MUTEX lock_;
-    // ACE_Mutex_Token used to lock internal data structures.
+  ACE_TOKEN_CONST::MUTEX lock_;
+  // ACE_Mutex_Token used to lock internal data structures.
 
-    typedef ACE_Token_Name TOKEN_NAME;
-    // This may be changed to a template type.
+  typedef ACE_Token_Name TOKEN_NAME;
+  // This may be changed to a template type.
 
-    typedef ACE_Map_Manager<TOKEN_NAME, ACE_Tokens *, ACE_Null_Mutex>
-    COLLECTION;
-    // COLLECTION maintains a mapping from token names to ACE_Tokens*
+  typedef ACE_Map_Manager<TOKEN_NAME, ACE_Tokens *, ACE_Null_Mutex>
+  COLLECTION;
+  // COLLECTION maintains a mapping from token names to ACE_Tokens*
 
-    typedef ACE_Map_Iterator<TOKEN_NAME, ACE_Tokens *, ACE_Null_Mutex>
-    COLLECTION_ITERATOR;
-    // Allows iterations through collection_
+  typedef ACE_Map_Iterator<TOKEN_NAME, ACE_Tokens *, ACE_Null_Mutex>
+  COLLECTION_ITERATOR;
+  // Allows iterations through collection_
 
-    typedef ACE_Map_Entry<TOKEN_NAME, ACE_Tokens *>
-    COLLECTION_ENTRY;
-    // Allows iterations through collection_
+  typedef ACE_Map_Entry<TOKEN_NAME, ACE_Tokens *>
+  COLLECTION_ENTRY;
+  // Allows iterations through collection_
 
-    COLLECTION collection_;
-    // COLLECTION maintains a mapping from token names to ACE_Tokens*.
+  COLLECTION collection_;
+  // COLLECTION maintains a mapping from token names to ACE_Tokens*.
 };
 
 #if defined (__ACE_INLINE__)
diff --git a/ace/Token_Request_Reply.h b/ace/Token_Request_Reply.h
index 526a308e1e5..0161668b08e 100644
--- a/ace/Token_Request_Reply.h
+++ b/ace/Token_Request_Reply.h
@@ -27,13 +27,13 @@
 #include "ace/Time_Value.h"
 
 class ACE_Export ACE_Token_Request
+{
   // = TITLE
   //   Message format for delivering requests to the ACE_Token Server.
   //
   // = DESCRIPTION
   //   This class is implemented to minimize data copying.  
   //   In particular, all marshaling is done in situ...
-{
 public:
   enum OPERATION
   {
@@ -164,13 +164,13 @@ private:
 };
 
 class ACE_Export ACE_Token_Reply
+{
   // = TITLE
   //     Message format for delivering replies from the ACE_Token Server.
   //
   // = DESCRIPTION
   //   This class is implemented to minimize data copying.  
   //   In particular, all marshaling is done in situ...
-{
 public:
   enum Constants
   {
diff --git a/ace/Trace.h b/ace/Trace.h
index 82925cb8640..cb01b036819 100644
--- a/ace/Trace.h
+++ b/ace/Trace.h
@@ -19,6 +19,7 @@
 #define ACE_TRACE_H
 
 class ACE_Export ACE_Trace
+{
   // = TITLE
   //     A C++ trace facility that keeps track of which methods are
   //     entered and exited.
@@ -27,7 +28,6 @@ class ACE_Export ACE_Trace
   //     This class uses C++ constructors and destructors to automate
   //     the ACE_Trace nesting.  In addition, thread-specific storage
   //     is used to enable multiple threads to work correctly.
-{
 public:
   // = Initialization and termination methods.
 
diff --git a/ace/Typed_SV_Message.h b/ace/Typed_SV_Message.h
index 08e5ffc70dc..5dd44314bb7 100644
--- a/ace/Typed_SV_Message.h
+++ b/ace/Typed_SV_Message.h
@@ -22,10 +22,10 @@
 
 template <class T>
 class ACE_Typed_SV_Message
+{
   // = TITLE
   //     Defines the header file for the C++ wrapper for System V
   //     message queues.
-{
 public:
   // = Initialization and termination methods.
   ACE_Typed_SV_Message (long type = 0, 
diff --git a/ace/Typed_SV_Message_Queue.h b/ace/Typed_SV_Message_Queue.h
index 938a689c2e4..a59b3320152 100644
--- a/ace/Typed_SV_Message_Queue.h
+++ b/ace/Typed_SV_Message_Queue.h
@@ -23,9 +23,9 @@
 
 template <class T>
 class ACE_Typed_SV_Message_Queue 
+{
   // = TITLE
   //    Defines the header file for the C++ wrapper for message queues.
-{
 public: 
   enum 
   {
diff --git a/ace/UNIX_Addr.h b/ace/UNIX_Addr.h
index 75b66b70b86..ac39c4aa9a7 100644
--- a/ace/UNIX_Addr.h
+++ b/ace/UNIX_Addr.h
@@ -21,9 +21,9 @@
 #if !defined (ACE_LACKS_UNIX_DOMAIN_SOCKETS)
 
 class ACE_Export ACE_UNIX_Addr : public ACE_Addr
+{
   // = TITLE
   //    Defines the ``UNIX domain address family'' address format. 
-{
 public:
   // = Initialization methods.
   ACE_UNIX_Addr (void);
diff --git a/ace/UPIPE_Acceptor.h b/ace/UPIPE_Acceptor.h
index 6e27aa476d7..6c2664c3721 100644
--- a/ace/UPIPE_Acceptor.h
+++ b/ace/UPIPE_Acceptor.h
@@ -26,10 +26,10 @@
 #if defined (ACE_HAS_THREADS)
 
 class ACE_Export ACE_UPIPE_Acceptor : public ACE_SPIPE_Acceptor
+{
   // = TITLE
   //     Defines the format and interface for the listener side of the
   //     ACE_UPIPE_Stream.
-{
 public:
   // = Initialization and termination.
   ACE_UPIPE_Acceptor (void);
diff --git a/ace/UPIPE_Connector.h b/ace/UPIPE_Connector.h
index 38b0562ecb0..6dfdb7df9de 100644
--- a/ace/UPIPE_Connector.h
+++ b/ace/UPIPE_Connector.h
@@ -24,10 +24,10 @@
 #if defined (ACE_HAS_THREADS)
 
 class ACE_Export ACE_UPIPE_Connector : public ACE_SPIPE
+{
   // = TITLE
   //     Defines an active connection factory for the
   //     <ACE_UPIPE_STREAM> wrappers.
-{
 public:
   // = Initialization methods.
   ACE_UPIPE_Connector (void);
diff --git a/ace/UPIPE_Stream.h b/ace/UPIPE_Stream.h
index d3891067b1e..d6a9726bf40 100644
--- a/ace/UPIPE_Stream.h
+++ b/ace/UPIPE_Stream.h
@@ -29,12 +29,12 @@
 typedef ACE_Stream<ACE_SYNCH> MT_Stream;
 
 class ACE_Export ACE_UPIPE_Stream : public ACE_SPIPE
+{
   // = TITLE
   //     Defines the method that transfer data on a UPIPE.
-{
+public:
   friend class ACE_UPIPE_Acceptor;
   friend class ACE_UPIPE_Connector;
-public:
 
   // = Initialization and Termination.
 
diff --git a/ace/WFMO_Reactor.h b/ace/WFMO_Reactor.h
index 055011abff0..208d57f584b 100644
--- a/ace/WFMO_Reactor.h
+++ b/ace/WFMO_Reactor.h
@@ -29,35 +29,33 @@ class ACE_WFMO_Reactor;
 class ACE_Handle_Set;
 
 class ACE_Export ACE_Wakeup_All_Threads_Handler : public ACE_Event_Handler
+{
   // = TITLE
   //     This is a helper class whose sole purpose is to handle events
   //     on <ACE_WFMO_Reactor->wakeup_all_threads_>
-{
 public:
   virtual int handle_signal (int signum, siginfo_t * = 0, ucontext_t * = 0);
   // Called when the <ACE_WFMO_Reactor->wakeup_all_threads_>
-
-private:
 };
 
 class ACE_Export ACE_WFMO_Reactor_Handler_Repository
+{
   // = TITLE
   //     Used to map <ACE_HANDLE>s onto the appropriate
   //     <ACE_Event_Handler> * and other information.
   //
-{
-  friend class ACE_WFMO_Reactor;
-
 public:
+  friend class ACE_WFMO_Reactor;
 
-  struct Common_Info
+  class Common_Info
+  {
     // = TITLE
     //     This struct contains the necessary information for every
     //     <Event_Handler> entry. The reason the event is not in this
     //     structure is because we need to pass an event array into
     //     WaitForMultipleObjects and therefore keeping the events
     //     seperate makes sense.
-  {
+  public:
     int io_entry_;
     // This indicates whether this entry is for I/O or for a regular
     // event
@@ -96,11 +94,12 @@ public:
     // Set the structure to these new values
   };
 
-  struct Current_Info : public Common_Info
+  class Current_Info : public Common_Info
+  {
     // = TITLE
     //     This structure inherits from the common structure to add
     //     information for current entries.
-  {
+  public:
     int delete_entry_;
     // This is set when the entry needed to be deleted.
 
@@ -133,11 +132,12 @@ public:
     // Set the structure to these new values
   };
 
-  struct To_Be_Added_Info : public Common_Info
+  class To_Be_Added_Info : public Common_Info
+  {
     // = TITLE
     //     This structure inherits from the common structure to add
     //     information for <to_be_added> entries.
-  {
+  public:
     ACE_HANDLE event_handle_;
     // Handle for the event
 
@@ -160,11 +160,12 @@ public:
     // Set the structure to these new values
   };
 
-  struct Suspended_Info : public Common_Info
+  class Suspended_Info : public Common_Info
+  {
     // = TITLE
     //     This structure inherits from the common structure to add
     //     information for suspended entries.
-  {
+  public:
     ACE_HANDLE event_handle_;
     // Handle for the event
 
@@ -344,6 +345,7 @@ protected:
 };
 
 class ACE_Export ACE_WFMO_Reactor_Notify : public ACE_Event_Handler
+{
   // = TITLE
   //     Unblock the <ACE_WFMO_Reactor> from its event loop, passing it an
   //     optional <ACE_Event_Handler> to dispatch.
@@ -357,7 +359,6 @@ class ACE_Export ACE_WFMO_Reactor_Notify : public ACE_Event_Handler
   //     <ACE_WFMO_Reactor> is listening on.  If an <ACE_Event_Handler>
   //     and <ACE_Reactor_Mask> is passed to <notify>, the appropriate
   //     <handle_*> method is dispatched.
-{
 public:
   ACE_WFMO_Reactor_Notify (void);
   // Constructor
@@ -429,6 +430,7 @@ private:
 
 #if defined (ACE_WIN32)
 class ACE_Export ACE_WFMO_Reactor : public ACE_Reactor_Impl
+{
   // = TITLE
   //     An object oriented event demultiplexor and event handler
   //     WFMO_Reactor for Win32 WaitForMultipleObjects
@@ -439,10 +441,10 @@ class ACE_Export ACE_WFMO_Reactor : public ACE_Reactor_Impl
   //     ACE_WFMO_Reactor waits for and dispatches includes I/O events,
   //     general Win32 synchronization events (such as mutexes,
   //     semaphores, threads, etc.) and timer events.
-{
+public:
   friend class ACE_WFMO_Reactor_Handler_Repository;
   friend class ACE_WFMO_Reactor_Test;
-public:
+
   enum
   {
     DEFAULT_SIZE = MAXIMUM_WAIT_OBJECTS - 2
diff --git a/ace/XtReactor.h b/ace/XtReactor.h
index 1d9924870c5..2eefbd25873 100644
--- a/ace/XtReactor.h
+++ b/ace/XtReactor.h
@@ -29,10 +29,10 @@
 struct ACE_XtReactorID;
 
 class ACE_XtReactor : public ACE_Select_Reactor
+{
   // = TITLE
   //     An object oriented event demultiplexor and event handler
   //     dispatcher that uses the X Toolkit functions.
-{
 public:
   // = Initialization and termination methods.
   ACE_XtReactor (XtAppContext context,