*Backed out changeset 3be01fb200a5

--HG--
branch : trunk

1 files changed, 431 insertions, 0 deletions

diff --git a/dep/ACE_wrappers/ace/ACE.cpp b/dep/ACE_wrappers/ace/ACE.cpp
index 2f1fa64ba4e..7ccf15ed341 100644
--- a/dep/ACE_wrappers/ace/ACE.cpp
+++ b/dep/ACE_wrappers/ace/ACE.cpp
@@ -1,5 +1,7 @@
 // $Id: ACE.cpp 82581 2008-08-11 08:58:24Z johnnyw $
+
 #include "ace/ACE.h"
+
 #include "ace/Basic_Types.h"
 #include "ace/Handle_Set.h"
 #include "ace/Auto_Ptr.h"
@@ -22,35 +24,45 @@
 #include "ace/OS_NS_fcntl.h"
 #include "ace/OS_TLI.h"
 #include "ace/Truncate.h"
+
 #if defined (ACE_VXWORKS) && (ACE_VXWORKS < 0x620)
 extern "C" int maxFiles;
 #endif /* ACE_VXWORKS */
+
 #if !defined (__ACE_INLINE__)
 #include "ace/ACE.inl"
 #endif /* __ACE_INLINE__ */
+
 #if defined (ACE_HAS_POLL) && defined (ACE_HAS_LIMITED_SELECT)
 #  include "ace/OS_NS_poll.h"
 #endif /* ACE_HAS_POLL  && ACE_HAS_LIMITED_SELECT */
 
+
 ACE_RCSID (ace,
            ACE,
            "$Id: ACE.cpp 82581 2008-08-11 08:58:24Z johnnyw $")
 
+
 // Open versioned namespace, if enabled by the user.
   ACE_BEGIN_VERSIONED_NAMESPACE_DECL
+
 namespace ACE
 {
   // private:
   //  Used internally so not exported.
+
   // Size of allocation granularity.
   size_t allocation_granularity_ = 0;
+
   // Size of a VM page.
   size_t pagesize_ = 0;
+
   // Are we debugging ACE?
   // Keeps track of whether we're in some global debug mode.
   char debug_;
 }
 
+
 int
 ACE::out_of_handles (int error)
 {
@@ -92,21 +104,25 @@ ACE::out_of_handles (int error)
   else
     return 0;
 }
+
 u_int
 ACE::major_version (void)
 {
   return ACE_MAJOR_VERSION;
 }
+
 u_int
 ACE::minor_version (void)
 {
   return ACE_MINOR_VERSION;
 }
+
 u_int
 ACE::beta_version (void)
 {
   return ACE_BETA_VERSION;
 }
+
 const ACE_TCHAR *
 ACE::compiler_name (void)
 {
@@ -116,6 +132,7 @@ ACE::compiler_name (void)
   return ACE_TEXT ("");
 #endif
 }
+
 u_int
 ACE::compiler_major_version (void)
 {
@@ -125,6 +142,7 @@ ACE::compiler_major_version (void)
   return 0;
 #endif
 }
+
 u_int
 ACE::compiler_minor_version (void)
 {
@@ -134,6 +152,7 @@ ACE::compiler_minor_version (void)
   return 0;
 #endif
 }
+
 u_int
 ACE::compiler_beta_version (void)
 {
@@ -143,17 +162,20 @@ ACE::compiler_beta_version (void)
   return 0;
 #endif
 }
+
 bool
 ACE::debug (void)
 {
   static const char* debug = ACE_OS::getenv ("ACE_DEBUG");
   return (ACE::debug_ != 0) ? ACE::debug_ : (debug != 0 ? (*debug != '0'): false);
 }
+
 void
 ACE::debug (bool onoff)
 {
   ACE::debug_ = onoff;
 }
+
 int
 ACE::select (int width,
              ACE_Handle_Set *readfds,
@@ -180,6 +202,7 @@ ACE::select (int width,
     }
   return result;
 }
+
 int
 ACE::select (int width,
              ACE_Handle_Set &readfds,
@@ -190,12 +213,14 @@ ACE::select (int width,
                                0,
                                0,
                                timeout);
+
 #if !defined (ACE_WIN32)
   if (result > 0)
     readfds.sync ((ACE_HANDLE) width);
 #endif /* ACE_WIN32 */
   return result;
 }
+
 int
 ACE::terminate_process (pid_t pid)
 {
@@ -208,6 +233,7 @@ ACE::terminate_process (pid_t pid)
     ::OpenProcess (PROCESS_TERMINATE,
                    FALSE, // New handle is not inheritable.
                    pid);
+
   if (process_handle == ACE_INVALID_HANDLE
       || process_handle == 0)
     return -1;
@@ -224,6 +250,7 @@ ACE::terminate_process (pid_t pid)
   return ACE_OS::kill (pid, 9);
 #endif /* ACE_HAS_PHARLAP */
 }
+
 int
 ACE::process_active (pid_t pid)
 {
@@ -248,11 +275,13 @@ ACE::process_active (pid_t pid)
                                 &status) == 0
           || status != STILL_ACTIVE)
         result = 0;
+
       ::CloseHandle (process_handle);
       return result;
     }
 #endif /* !ACE_WIN32 */
 }
+
 const ACE_TCHAR *
 ACE::execname (const ACE_TCHAR *old_name)
 {
@@ -261,110 +290,142 @@ ACE::execname (const ACE_TCHAR *old_name)
   if (suffix == 0 || ACE_OS::strcasecmp (suffix, ACE_TEXT (".exe")) != 0)
     {
       ACE_TCHAR *new_name = 0;
+
       size_t size =
         ACE_OS::strlen (old_name)
         + ACE_OS::strlen (ACE_TEXT (".exe"))
         + 1;
+
       ACE_NEW_RETURN (new_name,
                       ACE_TCHAR[size],
                       0);
       ACE_TCHAR *end = new_name;
+
       end = ACE_OS::strecpy (new_name, old_name);
+
       // Concatenate the .exe suffix onto the end of the executable.
       // end points _after_ the terminating nul.
       ACE_OS::strcpy (end - 1, ACE_TEXT (".exe"));
+
       return new_name;
     }
 #endif /* ACE_WIN32 */
   return old_name;
 }
+
 u_long
 ACE::hash_pjw (const char *str, size_t len)
 {
   u_long hash = 0;
+
   for (size_t i = 0; i < len; i++)
     {
       const char temp = str[i];
       hash = (hash << 4) + (temp * 13);
+
       u_long g = hash & 0xf0000000;
+
       if (g)
         {
           hash ^= (g >> 24);
           hash ^= g;
         }
     }
+
   return hash;
 }
+
 u_long
 ACE::hash_pjw (const char *str)
 {
   return ACE::hash_pjw (str, ACE_OS::strlen (str));
 }
+
 #if defined (ACE_HAS_WCHAR)
 u_long
 ACE::hash_pjw (const wchar_t *str, size_t len)
 {
   u_long hash = 0;
+
   for (size_t i = 0; i < len; i++)
     {
       // @@ UNICODE: Does this function do the correct thing with wchar's?
+
       const wchar_t temp = str[i];
       hash = (hash << 4) + (temp * 13);
+
       u_long g = hash & 0xf0000000;
+
       if (g)
         {
           hash ^= (g >> 24);
           hash ^= g;
         }
     }
+
   return hash;
 }
+
 u_long
 ACE::hash_pjw (const wchar_t *str)
 {
   return ACE::hash_pjw (str, ACE_OS::strlen (str));
 }
 #endif /* ACE_HAS_WCHAR */
+
 #if !defined (ACE_HAS_WINCE)
 ACE_TCHAR *
 ACE::strenvdup (const ACE_TCHAR *str)
 {
   ACE_TRACE ("ACE::strenvdup");
+
   return ACE_OS::strenvdup (str);
 }
 #endif /* ACE_HAS_WINCE */
+
 /*
+
 Examples:
+
 Source               NT                    UNIX
 ==================================================================
 netsvc               netsvc.dll            libnetsvc.so
 (PATH will be         (LD_LIBRARY_PATH
 evaluated)            evaluated)
+
 libnetsvc.dll        libnetsvc.dll         libnetsvc.dll + warning
 netsvc.so            netsvc.so + warning   libnetsvc.so
+
 ..\../libs/netsvc    ..\..\libs\netsvc.dll ../../libs/netsvc.so
 (absolute path used)  (absolute path used)
+
 */
+
 const ACE_TCHAR *
 ACE::basename (const ACE_TCHAR *pathname, ACE_TCHAR delim)
 {
   ACE_TRACE ("ACE::basename");
   const ACE_TCHAR *temp = ACE_OS::strrchr (pathname, delim);
+
   if (temp == 0)
     return pathname;
   else
     return temp + 1;
 }
+
 const ACE_TCHAR *
 ACE::dirname (const ACE_TCHAR *pathname, ACE_TCHAR delim)
 {
   ACE_TRACE ("ACE::dirname");
   static ACE_TCHAR return_dirname[MAXPATHLEN + 1];
+
   const ACE_TCHAR *temp = ACE_OS::strrchr (pathname, delim);
+
   if (temp == 0)
     {
       return_dirname[0] = '.';
       return_dirname[1] = '\0';
+
       return return_dirname;
     }
   else
@@ -374,12 +435,14 @@ ACE::dirname (const ACE_TCHAR *pathname, ACE_TCHAR delim)
       size_t len = temp - pathname + 1;
       if (len > (sizeof return_dirname / sizeof (ACE_TCHAR)))
         len = sizeof return_dirname / sizeof (ACE_TCHAR);
+
       ACE_OS::strsncpy (return_dirname,
                         pathname,
                         len);
       return return_dirname;
     }
 }
+
 ssize_t
 ACE::recv (ACE_HANDLE handle,
            void *buf,
@@ -403,7 +466,9 @@ ACE::recv (ACE_HANDLE handle,
         }
     }
 }
+
 #if defined (ACE_HAS_TLI)
+
 ssize_t
 ACE::t_rcv (ACE_HANDLE handle,
             void *buf,
@@ -427,7 +492,9 @@ ACE::t_rcv (ACE_HANDLE handle,
         }
     }
 }
+
 #endif /* ACE_HAS_TLI */
+
 ssize_t
 ACE::recv (ACE_HANDLE handle,
            void *buf,
@@ -449,6 +516,7 @@ ACE::recv (ACE_HANDLE handle,
         }
     }
 }
+
 ssize_t
 ACE::recvmsg (ACE_HANDLE handle,
               struct msghdr *msg,
@@ -470,6 +538,7 @@ ACE::recvmsg (ACE_HANDLE handle,
         }
     }
 }
+
 ssize_t
 ACE::recvfrom (ACE_HANDLE handle,
                char *buf,
@@ -495,6 +564,7 @@ ACE::recvfrom (ACE_HANDLE handle,
         }
     }
 }
+
 ssize_t
 ACE::recv_n_i (ACE_HANDLE handle,
                void *buf,
@@ -505,6 +575,7 @@ ACE::recv_n_i (ACE_HANDLE handle,
   size_t temp;
   size_t &bytes_transferred = bt == 0 ? temp : *bt;
   ssize_t n;
+
   for (bytes_transferred = 0;
        bytes_transferred < len;
        bytes_transferred += n)
@@ -517,6 +588,7 @@ ACE::recv_n_i (ACE_HANDLE handle,
       // Check EOF.
       if (n == 0)
         return 0;
+
       // Check for other errors.
       if (n == -1)
         {
@@ -525,6 +597,7 @@ ACE::recv_n_i (ACE_HANDLE handle,
             {
               // Wait for the blocking to subside.
               int const result = ACE::handle_read_ready (handle, 0);
+
               // Did select() succeed?
               if (result != -1)
                 {
@@ -533,12 +606,15 @@ ACE::recv_n_i (ACE_HANDLE handle,
                   continue;
                 }
             }
+
           // Other data transfer or select() failures.
           return -1;
         }
     }
+
   return static_cast<ssize_t> (bytes_transferred);
 }
+
 ssize_t
 ACE::recv_n_i (ACE_HANDLE handle,
                void *buf,
@@ -552,8 +628,10 @@ ACE::recv_n_i (ACE_HANDLE handle,
   ssize_t n;
   ssize_t result = 0;
   int error = 0;
+
   int val = 0;
   ACE::record_and_set_non_blocking_mode (handle, val);
+
   for (bytes_transferred = 0;
        bytes_transferred < len;
        bytes_transferred += n)
@@ -565,6 +643,7 @@ ACE::recv_n_i (ACE_HANDLE handle,
                         static_cast <char *> (buf) + bytes_transferred,
                         len - bytes_transferred,
                         flags);
+
       // Check for errors.
       if (n == 0 ||
           n == -1)
@@ -576,6 +655,7 @@ ACE::recv_n_i (ACE_HANDLE handle,
               // Wait upto <timeout> for the blocking to subside.
               int rtn = ACE::handle_read_ready (handle,
                                                 timeout);
+
               // Did select() succeed?
               if (rtn != -1)
                 {
@@ -585,6 +665,7 @@ ACE::recv_n_i (ACE_HANDLE handle,
                   continue;
                 }
             }
+
           // Wait in select() timed out or other data transfer or
           // select() failures.
           error = 1;
@@ -592,13 +673,17 @@ ACE::recv_n_i (ACE_HANDLE handle,
           break;
         }
     }
+
   ACE::restore_non_blocking_mode (handle, val);
+
   if (error)
     return result;
   else
     return static_cast<ssize_t> (bytes_transferred);
 }
+
 #if defined (ACE_HAS_TLI)
+
 ssize_t
 ACE::t_rcv_n_i (ACE_HANDLE handle,
                 void *buf,
@@ -609,6 +694,7 @@ ACE::t_rcv_n_i (ACE_HANDLE handle,
   size_t temp;
   size_t &bytes_transferred = bt == 0 ? temp : *bt;
   ssize_t n;
+
   for (bytes_transferred = 0;
        bytes_transferred < len;
        bytes_transferred += n)
@@ -621,6 +707,7 @@ ACE::t_rcv_n_i (ACE_HANDLE handle,
       // Check EOF.
       if (n == 0)
         return 0;
+
       // Check for other errors.
       if (n == -1)
         {
@@ -630,6 +717,7 @@ ACE::t_rcv_n_i (ACE_HANDLE handle,
               // Wait for the blocking to subside.
               int result = ACE::handle_read_ready (handle,
                                                    0);
+
               // Did select() succeed?
               if (result != -1)
                 {
@@ -638,12 +726,15 @@ ACE::t_rcv_n_i (ACE_HANDLE handle,
                   continue;
                 }
             }
+
           // Other data transfer or select() failures.
           return -1;
         }
     }
+
   return bytes_transferred;
 }
+
 ssize_t
 ACE::t_rcv_n_i (ACE_HANDLE handle,
                 void *buf,
@@ -657,8 +748,10 @@ ACE::t_rcv_n_i (ACE_HANDLE handle,
   ssize_t n;
   ssize_t result = 0;
   int error = 0;
+
   int val = 0;
   ACE::record_and_set_non_blocking_mode (handle, val);
+
   for (bytes_transferred = 0;
        bytes_transferred < len;
        bytes_transferred += n)
@@ -670,6 +763,7 @@ ACE::t_rcv_n_i (ACE_HANDLE handle,
                          (char *) buf + bytes_transferred,
                          len - bytes_transferred,
                          flags);
+
       // Check for errors.
       if (n == 0 ||
           n == -1)
@@ -681,6 +775,7 @@ ACE::t_rcv_n_i (ACE_HANDLE handle,
               // Wait upto <timeout> for the blocking to subside.
               int rtn = ACE::handle_read_ready (handle,
                                                 timeout);
+
               // Did select() succeed?
               if (rtn != -1)
                 {
@@ -690,6 +785,7 @@ ACE::t_rcv_n_i (ACE_HANDLE handle,
                   continue;
                 }
             }
+
           // Wait in select() timed out or other data transfer or
           // select() failures.
           error = 1;
@@ -697,13 +793,17 @@ ACE::t_rcv_n_i (ACE_HANDLE handle,
           break;
         }
     }
+
   ACE::restore_non_blocking_mode (handle, val);
+
   if (error)
     return result;
   else
     return bytes_transferred;
 }
+
 #endif /* ACE_HAS_TLI */
+
 ssize_t
 ACE::recv_n_i (ACE_HANDLE handle,
                void *buf,
@@ -713,6 +813,7 @@ ACE::recv_n_i (ACE_HANDLE handle,
   size_t temp;
   size_t &bytes_transferred = bt == 0 ? temp : *bt;
   ssize_t n;
+
   for (bytes_transferred = 0;
        bytes_transferred < len;
        bytes_transferred += n)
@@ -735,6 +836,7 @@ ACE::recv_n_i (ACE_HANDLE handle,
               // Wait for the blocking to subside.
               int result = ACE::handle_read_ready (handle,
                                                    0);
+
               // Did select() succeed?
               if (result != -1)
                 {
@@ -743,12 +845,15 @@ ACE::recv_n_i (ACE_HANDLE handle,
                   continue;
                 }
             }
+
           // Other data transfer or select() failures.
           return -1;
         }
     }
+
   return static_cast<ssize_t> (bytes_transferred);
 }
+
 ssize_t
 ACE::recv_n_i (ACE_HANDLE handle,
                void *buf,
@@ -761,8 +866,10 @@ ACE::recv_n_i (ACE_HANDLE handle,
   ssize_t n;
   ssize_t result = 0;
   int error = 0;
+
   int val = 0;
   ACE::record_and_set_non_blocking_mode (handle, val);
+
   for (bytes_transferred = 0;
        bytes_transferred < len;
        bytes_transferred += n)
@@ -773,6 +880,7 @@ ACE::recv_n_i (ACE_HANDLE handle,
       n = ACE::recv_i (handle,
                        static_cast <char *> (buf) + bytes_transferred,
                        len - bytes_transferred);
+
       // Check for errors.
       if (n == 0 ||
           n == -1)
@@ -784,6 +892,7 @@ ACE::recv_n_i (ACE_HANDLE handle,
               // Wait upto <timeout> for the blocking to subside.
               int rtn = ACE::handle_read_ready (handle,
                                                 timeout);
+
               // Did select() succeed?
               if (rtn != -1)
                 {
@@ -793,6 +902,7 @@ ACE::recv_n_i (ACE_HANDLE handle,
                   continue;
                 }
             }
+
           // Wait in select() timed out or other data transfer or
           // select() failures.
           error = 1;
@@ -800,17 +910,21 @@ ACE::recv_n_i (ACE_HANDLE handle,
           break;
         }
     }
+
   ACE::restore_non_blocking_mode (handle, val);
+
   if (error)
     return result;
   else
     return static_cast<ssize_t> (bytes_transferred);
 }
+
 // This is basically an interface to ACE_OS::readv, that doesn't use
 // the struct iovec explicitly.  The ... can be passed as an arbitrary
 // number of (char *ptr, int len) tuples.  However, the count N is the
 // *total* number of trailing arguments, *not* a couple of the number
 // of tuple pairs!
+
 ssize_t
 ACE::recv (ACE_HANDLE handle, size_t n, ...)
 {
@@ -824,12 +938,15 @@ ACE::recv (ACE_HANDLE handle, size_t n, ...)
                   iovec[total_tuples],
                   -1);
 #endif /* !defined (ACE_HAS_ALLOCA) */
+
   va_start (argp, n);
+
   for (int i = 0; i < total_tuples; i++)
     {
       iovp[i].iov_base = va_arg (argp, char *);
       iovp[i].iov_len = va_arg (argp, int);
     }
+
   ssize_t result = ACE_OS::recvv (handle, iovp, total_tuples);
 #if !defined (ACE_HAS_ALLOCA)
   delete [] iovp;
@@ -837,6 +954,7 @@ ACE::recv (ACE_HANDLE handle, size_t n, ...)
   va_end (argp);
   return result;
 }
+
 ssize_t
 ACE::recvv (ACE_HANDLE handle,
             iovec *iov,
@@ -858,6 +976,7 @@ ACE::recvv (ACE_HANDLE handle,
         }
     }
 }
+
 ssize_t
 ACE::recvv_n_i (ACE_HANDLE handle,
                 iovec *iov,
@@ -867,6 +986,7 @@ ACE::recvv_n_i (ACE_HANDLE handle,
   size_t temp;
   size_t &bytes_transferred = bt == 0 ? temp : *bt;
   bytes_transferred = 0;
+
   for (int s = 0;
        s < iovcnt;
        )
@@ -878,6 +998,7 @@ ACE::recvv_n_i (ACE_HANDLE handle,
       // Check EOF.
       if (n == 0)
         return 0;
+
       // Check for other errors.
       if (n == -1)
         {
@@ -887,6 +1008,7 @@ ACE::recvv_n_i (ACE_HANDLE handle,
               // Wait for the blocking to subside.
               int result = ACE::handle_read_ready (handle,
                                                    0);
+
               // Did select() succeed?
               if (result != -1)
                 {
@@ -895,14 +1017,17 @@ ACE::recvv_n_i (ACE_HANDLE handle,
                   continue;
                 }
             }
+
           // Other data transfer or select() failures.
           return -1;
         }
+
       for (bytes_transferred += n;
            s < iovcnt
              && n >= static_cast<ssize_t> (iov[s].iov_len);
            s++)
         n -= iov[s].iov_len;
+
       if (n != 0)
         {
           char *base = static_cast<char *> (iov[s].iov_base);
@@ -910,8 +1035,10 @@ ACE::recvv_n_i (ACE_HANDLE handle,
           iov[s].iov_len = iov[s].iov_len - n;
         }
     }
+
   return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
 }
+
 ssize_t
 ACE::recvv_n_i (ACE_HANDLE handle,
                 iovec *iov,
@@ -924,8 +1051,10 @@ ACE::recvv_n_i (ACE_HANDLE handle,
   bytes_transferred = 0;
   ssize_t result = 0;
   int error = 0;
+
   int val = 0;
   ACE::record_and_set_non_blocking_mode (handle, val);
+
   for (int s = 0;
        s < iovcnt;
        )
@@ -936,6 +1065,7 @@ ACE::recvv_n_i (ACE_HANDLE handle,
       ssize_t n = ACE_OS::recvv (handle,
                                  iov + s,
                                  iovcnt - s);
+
       // Check for errors.
       if (n == 0 ||
           n == -1)
@@ -947,6 +1077,7 @@ ACE::recvv_n_i (ACE_HANDLE handle,
               // Wait upto <timeout> for the blocking to subside.
               int rtn = ACE::handle_read_ready (handle,
                                                 timeout);
+
               // Did select() succeed?
               if (rtn != -1)
                 {
@@ -956,17 +1087,20 @@ ACE::recvv_n_i (ACE_HANDLE handle,
                   continue;
                 }
             }
+
           // Wait in select() timed out or other data transfer or
           // select() failures.
           error = 1;
           result = n;
           break;
         }
+
       for (bytes_transferred += n;
            s < iovcnt
              && n >= static_cast<ssize_t> (iov[s].iov_len);
            s++)
         n -= iov[s].iov_len;
+
       if (n != 0)
         {
           char *base = reinterpret_cast<char *> (iov[s].iov_base);
@@ -974,7 +1108,9 @@ ACE::recvv_n_i (ACE_HANDLE handle,
           iov[s].iov_len = iov[s].iov_len - n;
         }
     }
+
   ACE::restore_non_blocking_mode (handle, val);
+
   if (error)
     {
       return result;
@@ -984,6 +1120,7 @@ ACE::recvv_n_i (ACE_HANDLE handle,
       return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
     }
 }
+
 ssize_t
 ACE::recv_n (ACE_HANDLE handle,
              ACE_Message_Block *message_block,
@@ -993,30 +1130,37 @@ ACE::recv_n (ACE_HANDLE handle,
   size_t temp;
   size_t &bytes_transferred = bt == 0 ? temp : *bt;
   bytes_transferred = 0;
+
   iovec iov[ACE_IOV_MAX];
   int iovcnt = 0;
+
   while (message_block != 0)
     {
       // Our current message block chain.
       const ACE_Message_Block *current_message_block = message_block;
+
       while (current_message_block != 0)
         {
           size_t current_message_block_length =
             current_message_block->length ();
           char *this_rd_ptr = current_message_block->rd_ptr ();
+
           // Check if this block has any space for incoming data.
           while (current_message_block_length > 0)
             {
               u_long const this_chunk_length =
                 ACE_Utils::truncate_cast<u_long> (
                   current_message_block_length);
+
               // Collect the data in the iovec.
               iov[iovcnt].iov_base = this_rd_ptr;
               iov[iovcnt].iov_len  = this_chunk_length;
               current_message_block_length -= this_chunk_length;
               this_rd_ptr += this_chunk_length;
+
               // Increment iovec counter.
               ++iovcnt;
+
               // The buffer is full make a OS call.  @@ TODO find a way to
               // find ACE_IOV_MAX for platforms that do not define it rather
               // than simply setting ACE_IOV_MAX to some arbitrary value such
@@ -1024,47 +1168,59 @@ ACE::recv_n (ACE_HANDLE handle,
               if (iovcnt == ACE_IOV_MAX)
                 {
                   size_t current_transfer = 0;
+
                   ssize_t const result = ACE::recvv_n (handle,
                                                        iov,
                                                        iovcnt,
                                                        timeout,
                                                        &current_transfer);
+
                   // Add to total bytes transferred.
                   bytes_transferred += current_transfer;
+
                   // Errors.
                   if (result == -1 || result == 0)
                     return result;
+
                   // Reset iovec counter.
                   iovcnt = 0;
                 }
             }
+
           // Select the next message block in the chain.
           current_message_block = current_message_block->cont ();
         }
+
       // Selection of the next message block chain.
       message_block = message_block->next ();
     }
+
   // Check for remaining buffers to be sent.  This will happen when
   // ACE_IOV_MAX is not a multiple of the number of message blocks.
   if (iovcnt != 0)
     {
       size_t current_transfer = 0;
+
       ssize_t const result = ACE::recvv_n (handle,
                                            iov,
                                            iovcnt,
                                            timeout,
                                            &current_transfer);
+
       // Add to total bytes transferred.
       bytes_transferred += current_transfer;
+
       // Errors.
       if (result == -1 || result == 0)
         {
           return result;
         }
     }
+
   // Return total bytes transferred.
   return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
 }
+
 ssize_t
 ACE::send (ACE_HANDLE handle,
            const void *buf,
@@ -1087,7 +1243,9 @@ ACE::send (ACE_HANDLE handle,
         }
     }
 }
+
 #if defined (ACE_HAS_TLI)
+
 ssize_t
 ACE::t_snd (ACE_HANDLE handle,
             const void *buf,
@@ -1110,7 +1268,9 @@ ACE::t_snd (ACE_HANDLE handle,
         }
     }
 }
+
 #endif /* ACE_HAS_TLI */
+
 ssize_t
 ACE::send (ACE_HANDLE handle,
            const void *buf,
@@ -1132,6 +1292,7 @@ ACE::send (ACE_HANDLE handle,
         }
     }
 }
+
 ssize_t
 ACE::sendmsg (ACE_HANDLE handle,
               const struct msghdr *msg,
@@ -1153,6 +1314,7 @@ ACE::sendmsg (ACE_HANDLE handle,
         }
     }
 }
+
 ssize_t
 ACE::sendto (ACE_HANDLE handle,
              const char *buf,
@@ -1178,6 +1340,7 @@ ACE::sendto (ACE_HANDLE handle,
         }
     }
 }
+
 ssize_t
 ACE::send_n_i (ACE_HANDLE handle,
                const void *buf,
@@ -1188,6 +1351,7 @@ ACE::send_n_i (ACE_HANDLE handle,
   size_t temp;
   size_t &bytes_transferred = bt == 0 ? temp : *bt;
   ssize_t n;
+
   for (bytes_transferred = 0;
        bytes_transferred < len;
        bytes_transferred += n)
@@ -1200,6 +1364,7 @@ ACE::send_n_i (ACE_HANDLE handle,
       // Check EOF.
       if (n == 0)
         return 0;
+
       // Check for other errors.
       if (n == -1)
         {
@@ -1213,6 +1378,7 @@ ACE::send_n_i (ACE_HANDLE handle,
               // Wait for the blocking to subside.
               int result = ACE::handle_write_ready (handle,
                                                     0);
+
               // Did select() succeed?
               if (result != -1)
                 {
@@ -1221,12 +1387,15 @@ ACE::send_n_i (ACE_HANDLE handle,
                   continue;
                 }
             }
+
           // Other data transfer or select() failures.
           return -1;
         }
     }
+
   return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
 }
+
 ssize_t
 ACE::send_n_i (ACE_HANDLE handle,
                const void *buf,
@@ -1240,8 +1409,10 @@ ACE::send_n_i (ACE_HANDLE handle,
   ssize_t n;
   ssize_t result = 0;
   int error = 0;
+
   int val = 0;
   ACE::record_and_set_non_blocking_mode (handle, val);
+
   for (bytes_transferred = 0;
        bytes_transferred < len;
        bytes_transferred += n)
@@ -1253,6 +1424,7 @@ ACE::send_n_i (ACE_HANDLE handle,
                         (char *) buf + bytes_transferred,
                         len - bytes_transferred,
                         flags);
+
       // Check for errors.
       if (n == 0 ||
           n == -1)
@@ -1264,6 +1436,7 @@ ACE::send_n_i (ACE_HANDLE handle,
               // Wait upto <timeout> for the blocking to subside.
               int rtn = ACE::handle_write_ready (handle,
                                                  timeout);
+
               // Did select() succeed?
               if (rtn != -1)
                 {
@@ -1273,6 +1446,7 @@ ACE::send_n_i (ACE_HANDLE handle,
                   continue;
                 }
             }
+
           // Wait in select() timed out or other data transfer or
           // select() failures.
           error = 1;
@@ -1280,7 +1454,9 @@ ACE::send_n_i (ACE_HANDLE handle,
           break;
         }
     }
+
   ACE::restore_non_blocking_mode (handle, val);
+
   if (error)
     {
       return result;
@@ -1290,7 +1466,9 @@ ACE::send_n_i (ACE_HANDLE handle,
       return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
     }
 }
+
 #if defined (ACE_HAS_TLI)
+
 ssize_t
 ACE::t_snd_n_i (ACE_HANDLE handle,
                 const void *buf,
@@ -1301,6 +1479,7 @@ ACE::t_snd_n_i (ACE_HANDLE handle,
   size_t temp;
   size_t &bytes_transferred = bt == 0 ? temp : *bt;
   ssize_t n;
+
   for (bytes_transferred = 0;
        bytes_transferred < len;
        bytes_transferred += n)
@@ -1313,6 +1492,7 @@ ACE::t_snd_n_i (ACE_HANDLE handle,
       // Check EOF.
       if (n == 0)
         return 0;
+
       // Check for other errors.
       if (n == -1)
         {
@@ -1322,6 +1502,7 @@ ACE::t_snd_n_i (ACE_HANDLE handle,
               // Wait for the blocking to subside.
               int result = ACE::handle_write_ready (handle,
                                                     0);
+
               // Did select() succeed?
               if (result != -1)
                 {
@@ -1330,12 +1511,15 @@ ACE::t_snd_n_i (ACE_HANDLE handle,
                   continue;
                 }
             }
+
           // Other data transfer or select() failures.
           return -1;
         }
     }
+
   return bytes_transferred;
 }
+
 ssize_t
 ACE::t_snd_n_i (ACE_HANDLE handle,
                 const void *buf,
@@ -1349,8 +1533,10 @@ ACE::t_snd_n_i (ACE_HANDLE handle,
   ssize_t n;
   ssize_t result = 0;
   int error = 0;
+
   int val = 0;
   ACE::record_and_set_non_blocking_mode (handle, val);
+
   for (bytes_transferred = 0;
        bytes_transferred < len;
        bytes_transferred += n)
@@ -1362,6 +1548,7 @@ ACE::t_snd_n_i (ACE_HANDLE handle,
                          (char *) buf + bytes_transferred,
                          len - bytes_transferred,
                          flags);
+
       // Check for errors.
       if (n == 0 ||
           n == -1)
@@ -1373,6 +1560,7 @@ ACE::t_snd_n_i (ACE_HANDLE handle,
               // Wait upto <timeout> for the blocking to subside.
               int rtn = ACE::handle_write_ready (handle,
                                                  timeout);
+
               // Did select() succeed?
               if (rtn != -1)
                 {
@@ -1382,6 +1570,7 @@ ACE::t_snd_n_i (ACE_HANDLE handle,
                   continue;
                 }
             }
+
           // Wait in select() timed out or other data transfer or
           // select() failures.
           error = 1;
@@ -1389,13 +1578,17 @@ ACE::t_snd_n_i (ACE_HANDLE handle,
           break;
         }
     }
+
   ACE::restore_non_blocking_mode (handle, val);
+
   if (error)
     return result;
   else
     return bytes_transferred;
 }
+
 #endif /* ACE_HAS_TLI */
+
 ssize_t
 ACE::send_n_i (ACE_HANDLE handle,
                const void *buf,
@@ -1405,6 +1598,7 @@ ACE::send_n_i (ACE_HANDLE handle,
   size_t temp;
   size_t &bytes_transferred = bt == 0 ? temp : *bt;
   ssize_t n;
+
   for (bytes_transferred = 0;
        bytes_transferred < len;
        bytes_transferred += n)
@@ -1418,6 +1612,7 @@ ACE::send_n_i (ACE_HANDLE handle,
         {
           return 0;
         }
+
       // Check for other errors.
       if (n == -1)
         {
@@ -1427,6 +1622,7 @@ ACE::send_n_i (ACE_HANDLE handle,
               // Wait for the blocking to subside.
               int result = ACE::handle_write_ready (handle,
                                                     0);
+
               // Did select() succeed?
               if (result != -1)
                 {
@@ -1435,12 +1631,15 @@ ACE::send_n_i (ACE_HANDLE handle,
                   continue;
                 }
             }
+
           // Other data transfer or select() failures.
           return -1;
         }
     }
+
   return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
 }
+
 ssize_t
 ACE::send_n_i (ACE_HANDLE handle,
                const void *buf,
@@ -1453,8 +1652,10 @@ ACE::send_n_i (ACE_HANDLE handle,
   ssize_t n;
   ssize_t result = 0;
   int error = 0;
+
   int val = 0;
   ACE::record_and_set_non_blocking_mode (handle, val);
+
   for (bytes_transferred = 0;
        bytes_transferred < len;
        bytes_transferred += n)
@@ -1465,6 +1666,7 @@ ACE::send_n_i (ACE_HANDLE handle,
       n = ACE::send_i (handle,
                        (char *) buf + bytes_transferred,
                        len - bytes_transferred);
+
       // Check for errors.
       if (n == 0 ||
           n == -1)
@@ -1476,6 +1678,7 @@ ACE::send_n_i (ACE_HANDLE handle,
               // Wait upto <timeout> for the blocking to subside.
               int rtn = ACE::handle_write_ready (handle,
                                                  timeout);
+
               // Did select() succeed?
               if (rtn != -1)
                 {
@@ -1485,6 +1688,7 @@ ACE::send_n_i (ACE_HANDLE handle,
                   continue;
                 }
             }
+
           // Wait in select() timed out or other data transfer or
           // select() failures.
           error = 1;
@@ -1492,7 +1696,9 @@ ACE::send_n_i (ACE_HANDLE handle,
           break;
         }
     }
+
   ACE::restore_non_blocking_mode (handle, val);
+
   if (error)
     {
       return result;
@@ -1502,10 +1708,12 @@ ACE::send_n_i (ACE_HANDLE handle,
       return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
     }
 }
+
 // Send N char *ptrs and int lengths.  Note that the char *'s precede
 // the ints (basically, an varargs version of writev).  The count N is
 // the *total* number of trailing arguments, *not* a couple of the
 // number of tuple pairs!
+
 ssize_t
 ACE::send (ACE_HANDLE handle, size_t n, ...)
 {
@@ -1519,12 +1727,15 @@ ACE::send (ACE_HANDLE handle, size_t n, ...)
                   iovec[total_tuples],
                   -1);
 #endif /* !defined (ACE_HAS_ALLOCA) */
+
   va_start (argp, n);
+
   for (int i = 0; i < total_tuples; i++)
     {
       iovp[i].iov_base = va_arg (argp, char *);
       iovp[i].iov_len = va_arg (argp, int);
     }
+
   ssize_t result = ACE_OS::sendv (handle, iovp, total_tuples);
 #if !defined (ACE_HAS_ALLOCA)
   delete [] iovp;
@@ -1532,6 +1743,7 @@ ACE::send (ACE_HANDLE handle, size_t n, ...)
   va_end (argp);
   return result;
 }
+
 ssize_t
 ACE::sendv (ACE_HANDLE handle,
             const iovec *iov,
@@ -1553,6 +1765,7 @@ ACE::sendv (ACE_HANDLE handle,
         }
     }
 }
+
 ssize_t
 ACE::sendv_n_i (ACE_HANDLE handle,
                 const iovec *i,
@@ -1562,7 +1775,9 @@ ACE::sendv_n_i (ACE_HANDLE handle,
   size_t temp;
   size_t &bytes_transferred = bt == 0 ? temp : *bt;
   bytes_transferred = 0;
+
   iovec *iov = const_cast<iovec *> (i);
+
   for (int s = 0;
        s < iovcnt;
        )
@@ -1574,6 +1789,7 @@ ACE::sendv_n_i (ACE_HANDLE handle,
       // Check EOF.
       if (n == 0)
         return 0;
+
       // Check for other errors.
       if (n == -1)
         {
@@ -1583,6 +1799,7 @@ ACE::sendv_n_i (ACE_HANDLE handle,
               // Wait for the blocking to subside.
               int result = ACE::handle_write_ready (handle,
                                                     0);
+
               // Did select() succeed?
               if (result != -1)
                 {
@@ -1591,14 +1808,17 @@ ACE::sendv_n_i (ACE_HANDLE handle,
                   continue;
                 }
             }
+
           // Other data transfer or select() failures.
           return -1;
         }
+
       for (bytes_transferred += n;
            s < iovcnt
              && n >= static_cast<ssize_t> (iov[s].iov_len);
            s++)
         n -= iov[s].iov_len;
+
       if (n != 0)
         {
           char *base = reinterpret_cast<char *> (iov[s].iov_base);
@@ -1606,8 +1826,10 @@ ACE::sendv_n_i (ACE_HANDLE handle,
           iov[s].iov_len = iov[s].iov_len - n;
         }
     }
+
   return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
 }
+
 ssize_t
 ACE::sendv_n_i (ACE_HANDLE handle,
                 const iovec *i,
@@ -1620,9 +1842,12 @@ ACE::sendv_n_i (ACE_HANDLE handle,
   bytes_transferred = 0;
   ssize_t result = 0;
   int error = 0;
+
   int val = 0;
   ACE::record_and_set_non_blocking_mode (handle, val);
+
   iovec *iov = const_cast<iovec *> (i);
+
   for (int s = 0;
        s < iovcnt;
        )
@@ -1633,6 +1858,7 @@ ACE::sendv_n_i (ACE_HANDLE handle,
       ssize_t n = ACE_OS::sendv (handle,
                                  iov + s,
                                  iovcnt - s);
+
       // Check for errors.
       if (n == 0 ||
           n == -1)
@@ -1644,6 +1870,7 @@ ACE::sendv_n_i (ACE_HANDLE handle,
               // Wait upto <timeout> for the blocking to subside.
               int rtn = ACE::handle_write_ready (handle,
                                                  timeout);
+
               // Did select() succeed?
               if (rtn != -1)
                 {
@@ -1653,17 +1880,20 @@ ACE::sendv_n_i (ACE_HANDLE handle,
                   continue;
                 }
             }
+
           // Wait in select() timed out or other data transfer or
           // select() failures.
           error = 1;
           result = n;
           break;
         }
+
       for (bytes_transferred += n;
            s < iovcnt
              && n >= static_cast<ssize_t> (iov[s].iov_len);
            s++)
         n -= iov[s].iov_len;
+
       if (n != 0)
         {
           char *base = reinterpret_cast<char *> (iov[s].iov_base);
@@ -1671,7 +1901,9 @@ ACE::sendv_n_i (ACE_HANDLE handle,
           iov[s].iov_len = iov[s].iov_len - n;
         }
     }
+
   ACE::restore_non_blocking_mode (handle, val);
+
   if (error)
     {
       return result;
@@ -1681,6 +1913,7 @@ ACE::sendv_n_i (ACE_HANDLE handle,
       return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
     }
 }
+
 ssize_t
 ACE::write_n (ACE_HANDLE handle,
               const ACE_Message_Block *message_block,
@@ -1689,30 +1922,37 @@ ACE::write_n (ACE_HANDLE handle,
   size_t temp;
   size_t &bytes_transferred = bt == 0 ? temp : *bt;
   bytes_transferred = 0;
+
   iovec iov[ACE_IOV_MAX];
   int iovcnt = 0;
+
   while (message_block != 0)
     {
       // Our current message block chain.
       const ACE_Message_Block *current_message_block = message_block;
+
       while (current_message_block != 0)
         {
           size_t current_message_block_length =
             current_message_block->length ();
           char *this_block_ptr = current_message_block->rd_ptr ();
+
           // Check if this block has any data to be sent.
           while (current_message_block_length > 0)
             {
               u_long const this_chunk_length =
                 ACE_Utils::truncate_cast<u_long> (
                   current_message_block_length);
+
               // Collect the data in the iovec.
               iov[iovcnt].iov_base = this_block_ptr;
               iov[iovcnt].iov_len  = this_chunk_length;
               current_message_block_length -= this_chunk_length;
               this_block_ptr += this_chunk_length;
+
               // Increment iovec counter.
               ++iovcnt;
+
               // The buffer is full make a OS call.  @@ TODO find a way to
               // find ACE_IOV_MAX for platforms that do not define it rather
               // than simply setting ACE_IOV_MAX to some arbitrary value such
@@ -1720,43 +1960,55 @@ ACE::write_n (ACE_HANDLE handle,
               if (iovcnt == ACE_IOV_MAX)
                 {
                   size_t current_transfer = 0;
+
                   ssize_t const result = ACE::writev_n (handle,
                                                         iov,
                                                         iovcnt,
                                                         &current_transfer);
+
                   // Add to total bytes transferred.
                   bytes_transferred += current_transfer;
+
                   // Errors.
                   if (result == -1 || result == 0)
                     return result;
+
                   // Reset iovec counter.
                   iovcnt = 0;
                 }
             }
+
           // Select the next message block in the chain.
           current_message_block = current_message_block->cont ();
         }
+
       // Selection of the next message block chain.
       message_block = message_block->next ();
     }
+
   // Check for remaining buffers to be sent.  This will happen when
   // ACE_IOV_MAX is not a multiple of the number of message blocks.
   if (iovcnt != 0)
     {
       size_t current_transfer = 0;
+
       ssize_t const result = ACE::writev_n (handle,
                                             iov,
                                             iovcnt,
                                             &current_transfer);
+
       // Add to total bytes transferred.
       bytes_transferred += current_transfer;
+
       // Errors.
       if (result == -1 || result == 0)
         return result;
     }
+
   // Return total bytes transferred.
   return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
 }
+
 ssize_t
 ACE::send_n (ACE_HANDLE handle,
              const ACE_Message_Block *message_block,
@@ -1766,30 +2018,37 @@ ACE::send_n (ACE_HANDLE handle,
   size_t temp;
   size_t &bytes_transferred = bt == 0 ? temp : *bt;
   bytes_transferred = 0;
+
   iovec iov[ACE_IOV_MAX];
   int iovcnt = 0;
+
   while (message_block != 0)
     {
       // Our current message block chain.
       const ACE_Message_Block *current_message_block = message_block;
+
       while (current_message_block != 0)
         {
           char *this_block_ptr = current_message_block->rd_ptr ();
           size_t current_message_block_length =
             current_message_block->length ();
+
           // Check if this block has any data to be sent.
           while (current_message_block_length > 0)
             {
               u_long const this_chunk_length =
                 ACE_Utils::truncate_cast<u_long> (
                   current_message_block_length);
+
               // Collect the data in the iovec.
               iov[iovcnt].iov_base = this_block_ptr;
               iov[iovcnt].iov_len  = this_chunk_length;
               current_message_block_length -= this_chunk_length;
               this_block_ptr += this_chunk_length;
+
               // Increment iovec counter.
               ++iovcnt;
+
               // The buffer is full make a OS call.  @@ TODO find a way to
               // find ACE_IOV_MAX for platforms that do not define it rather
               // than simply setting ACE_IOV_MAX to some arbitrary value such
@@ -1797,47 +2056,59 @@ ACE::send_n (ACE_HANDLE handle,
               if (iovcnt == ACE_IOV_MAX)
                 {
                   size_t current_transfer = 0;
+
                   ssize_t const result = ACE::sendv_n (handle,
                                                        iov,
                                                        iovcnt,
                                                        timeout,
                                                        &current_transfer);
+
                   // Add to total bytes transferred.
                   bytes_transferred += current_transfer;
+
                   // Errors.
                   if (result == -1 || result == 0)
                     return result;
+
                   // Reset iovec counter.
                   iovcnt = 0;
                 }
             }
+
           // Select the next message block in the chain.
           current_message_block = current_message_block->cont ();
         }
+
       // Selection of the next message block chain.
       message_block = message_block->next ();
     }
+
   // Check for remaining buffers to be sent.  This will happen when
   // ACE_IOV_MAX is not a multiple of the number of message blocks.
   if (iovcnt != 0)
     {
       size_t current_transfer = 0;
+
       ssize_t const result = ACE::sendv_n (handle,
                                            iov,
                                            iovcnt,
                                            timeout,
                                            &current_transfer);
+
       // Add to total bytes transferred.
       bytes_transferred += current_transfer;
+
       // Errors.
       if (result == -1 || result == 0)
         {
           return result;
         }
     }
+
   // Return total bytes transferred.
   return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
 }
+
 ssize_t
 ACE::readv_n (ACE_HANDLE handle,
               iovec *iov,
@@ -1847,6 +2118,7 @@ ACE::readv_n (ACE_HANDLE handle,
   size_t temp;
   size_t &bytes_transferred = bt == 0 ? temp : *bt;
   bytes_transferred = 0;
+
   for (int s = 0;
        s < iovcnt;
        )
@@ -1854,13 +2126,16 @@ ACE::readv_n (ACE_HANDLE handle,
       ssize_t n = ACE_OS::readv (handle,
                                  iov + s,
                                  iovcnt - s);
+
       if (n == -1 || n == 0)
         return n;
+
       for (bytes_transferred += n;
            s < iovcnt
              && n >= static_cast<ssize_t> (iov[s].iov_len);
            s++)
         n -= iov[s].iov_len;
+
       if (n != 0)
         {
           char *base = reinterpret_cast<char *> (iov[s].iov_base);
@@ -1868,8 +2143,10 @@ ACE::readv_n (ACE_HANDLE handle,
           iov[s].iov_len = iov[s].iov_len - n;
         }
     }
+
   return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
 }
+
 ssize_t
 ACE::writev_n (ACE_HANDLE handle,
                const iovec *i,
@@ -1879,7 +2156,9 @@ ACE::writev_n (ACE_HANDLE handle,
   size_t temp;
   size_t &bytes_transferred = bt == 0 ? temp : *bt;
   bytes_transferred = 0;
+
   iovec *iov = const_cast<iovec *> (i);
+
   for (int s = 0;
        s < iovcnt;
        )
@@ -1887,15 +2166,18 @@ ACE::writev_n (ACE_HANDLE handle,
       ssize_t n = ACE_OS::writev (handle,
                                   iov + s,
                                   iovcnt - s);
+
       if (n == -1 || n == 0)
         {
           return n;
         }
+
       for (bytes_transferred += n;
            s < iovcnt
              && n >= static_cast<ssize_t> (iov[s].iov_len);
            s++)
         n -= iov[s].iov_len;
+
       if (n != 0)
         {
           char *base = reinterpret_cast<char *> (iov[s].iov_base);
@@ -1903,8 +2185,10 @@ ACE::writev_n (ACE_HANDLE handle,
           iov[s].iov_len = iov[s].iov_len - n;
         }
     }
+
   return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
 }
+
 int
 ACE::handle_ready (ACE_HANDLE handle,
                    const ACE_Time_Value *timeout,
@@ -1915,14 +2199,18 @@ ACE::handle_ready (ACE_HANDLE handle,
 #if defined (ACE_HAS_POLL) && defined (ACE_HAS_LIMITED_SELECT)
   ACE_UNUSED_ARG (write_ready);
   ACE_UNUSED_ARG (exception_ready);
+
   struct pollfd fds;
+
   fds.fd = handle;
   fds.events = read_ready ? POLLIN : POLLOUT;
   fds.revents = 0;
+
   int result = ACE_OS::poll (&fds, 1, timeout);
 #else
   ACE_Handle_Set handle_set;
   handle_set.set_bit (handle);
+
   // Wait for data or for the timeout to elapse.
   int select_width;
 #  if defined (ACE_WIN32)
@@ -1937,7 +2225,9 @@ ACE::handle_ready (ACE_HANDLE handle,
                                write_ready ? handle_set.fdset () : 0, // write_fds.
                                exception_ready ? handle_set.fdset () : 0, // exception_fds.
                                timeout);
+
 #endif /* ACE_HAS_POLL && ACE_HAS_LIMITED_SELECT */
+
   switch (result)
     {
     case 0:  // Timer expired.
@@ -1952,6 +2242,7 @@ ACE::handle_ready (ACE_HANDLE handle,
       return result;
     }
 }
+
 int
 ACE::enter_recv_timedwait (ACE_HANDLE handle,
                            const ACE_Time_Value *timeout,
@@ -1959,12 +2250,16 @@ ACE::enter_recv_timedwait (ACE_HANDLE handle,
 {
   int result = ACE::handle_read_ready (handle,
                                        timeout);
+
   if (result == -1)
     return -1;
+
   ACE::record_and_set_non_blocking_mode (handle,
                                          val);
+
   return result;
 }
+
 int
 ACE::enter_send_timedwait (ACE_HANDLE handle,
                            const ACE_Time_Value *timeout,
@@ -1972,12 +2267,16 @@ ACE::enter_send_timedwait (ACE_HANDLE handle,
 {
   int result = ACE::handle_write_ready (handle,
                                         timeout);
+
   if (result == -1)
     return -1;
+
   ACE::record_and_set_non_blocking_mode (handle,
                                          val);
+
   return result;
 }
+
 void
 ACE::record_and_set_non_blocking_mode (ACE_HANDLE handle,
                                        int &val)
@@ -1985,11 +2284,13 @@ ACE::record_and_set_non_blocking_mode (ACE_HANDLE handle,
   // We need to record whether we are already *in* nonblocking mode,
   // so that we can correctly reset the state when we're done.
   val = ACE::get_flags (handle);
+
   if (ACE_BIT_DISABLED (val, ACE_NONBLOCK))
     // Set the handle into non-blocking mode if it's not already in
     // it.
     ACE::set_flags (handle, ACE_NONBLOCK);
 }
+
 void
 ACE::restore_non_blocking_mode (ACE_HANDLE handle,
                                 int val)
@@ -2005,9 +2306,11 @@ ACE::restore_non_blocking_mode (ACE_HANDLE handle,
     }
 }
 
+
 // Format buffer into printable format.  This is useful for debugging.
 // Portions taken from mdump by J.P. Knight (J.P.Knight@lut.ac.uk)
 // Modifications by Todd Montgomery.
+
 size_t
 ACE::format_hexdump (const char *buffer,
                      size_t size,
@@ -2015,17 +2318,23 @@ ACE::format_hexdump (const char *buffer,
                      size_t obuf_sz)
 {
   ACE_TRACE ("ACE::format_hexdump");
+
   u_char c;
   ACE_TCHAR textver[16 + 1];
+
   // We can fit 16 bytes output in text mode per line, 4 chars per byte.
   size_t maxlen = (obuf_sz / 68) * 16;
+
   if (size > maxlen)
     size = maxlen;
+
   size_t i;
+
   size_t lines = size / 16;
   for (i = 0; i < lines; i++)
     {
       size_t j;
+
       for (j = 0 ; j < 16; j++)
         {
           c = (u_char) buffer[(i << 4) + j];    // or, buffer[i*16+j]
@@ -2041,13 +2350,17 @@ ACE::format_hexdump (const char *buffer,
             }
           textver[j] = ACE_OS::ace_isprint (c) ? c : '.';
         }
+
       textver[j] = 0;
+
       ACE_OS::sprintf (obuf,
                        ACE_TEXT ("  %s\n"),
                        textver);
+
       while (*obuf != '\0')
         ++obuf;
     }
+
   if (size % 16)
     {
       for (i = 0 ; i < size % 16; i++)
@@ -2065,6 +2378,7 @@ ACE::format_hexdump (const char *buffer,
             }
           textver[i] = ACE_OS::ace_isprint (c) ? c : '.';
         }
+
       for (i = size % 16; i < 16; i++)
         {
           ACE_OS::sprintf (obuf,
@@ -2078,6 +2392,7 @@ ACE::format_hexdump (const char *buffer,
             }
           textver[i] = ' ';
         }
+
       textver[i] = 0;
       ACE_OS::sprintf (obuf,
                        ACE_TEXT ("  %s\n"),
@@ -2085,20 +2400,24 @@ ACE::format_hexdump (const char *buffer,
     }
   return size;
 }
+
 // Returns the current timestamp in the form
 // "hour:minute:second:microsecond."  The month, day, and year are
 // also stored in the beginning of the date_and_time array.
+
 ACE_TCHAR *
 ACE::timestamp (ACE_TCHAR date_and_time[],
                 size_t date_and_timelen,
                 bool return_pointer_to_first_digit)
 {
   //ACE_TRACE ("ACE::timestamp");
+
   if (date_and_timelen < 35)
     {
       errno = EINVAL;
       return 0;
     }
+
 #if defined (WIN32)
   // Emulate Unix.  Win32 does NOT support all the UNIX versions
   // below, so DO we need this ifdef.
@@ -2112,6 +2431,7 @@ ACE::timestamp (ACE_TCHAR date_and_time[],
       ACE_TEXT ("Fri"),
       ACE_TEXT ("Sat")
     };
+
   static const ACE_TCHAR *month_name[] =
     {
       ACE_TEXT ("Jan"),
@@ -2127,8 +2447,10 @@ ACE::timestamp (ACE_TCHAR date_and_time[],
       ACE_TEXT ("Nov"),
       ACE_TEXT ("Dec")
     };
+
   SYSTEMTIME local;
   ::GetLocalTime (&local);
+
   ACE_OS::sprintf (date_and_time,
                    ACE_TEXT ("%3s %3s %2d %04d %02d:%02d:%02d.%06d"),
                    day_of_week_name[local.wDayOfWeek],
@@ -2144,6 +2466,7 @@ ACE::timestamp (ACE_TCHAR date_and_time[],
   ACE_TCHAR timebuf[26]; // This magic number is based on the ctime(3c) man page.
   ACE_Time_Value cur_time = ACE_OS::gettimeofday ();
   time_t secs = cur_time.sec ();
+
   ACE_OS::ctime_r (&secs,
                    timebuf,
                    sizeof timebuf / sizeof (ACE_TCHAR));
@@ -2172,48 +2495,64 @@ ACE::timestamp (ACE_TCHAR date_and_time[],
   return &date_and_time[15 + (return_pointer_to_first_digit != 0)];
 #endif /* WIN32 */
 }
+
 // This function rounds the request to a multiple of the page size.
+
 size_t
 ACE::round_to_pagesize (size_t len)
 {
   ACE_TRACE ("ACE::round_to_pagesize");
+
   if (ACE::pagesize_ == 0)
     ACE::pagesize_ = ACE_OS::getpagesize ();
+
   return (len + (ACE::pagesize_ - 1)) & ~(ACE::pagesize_ - 1);
 }
+
 size_t
 ACE::round_to_allocation_granularity (size_t len)
 {
   ACE_TRACE ("ACE::round_to_allocation_granularity");
+
   if (ACE::allocation_granularity_ == 0)
     ACE::allocation_granularity_ = ACE_OS::allocation_granularity ();
+
   return (len + (ACE::allocation_granularity_ - 1)) & ~(ACE::allocation_granularity_ - 1);
 }
+
 ACE_HANDLE
 ACE::handle_timed_complete (ACE_HANDLE h,
                             const ACE_Time_Value *timeout,
                             int is_tli)
 {
   ACE_TRACE ("ACE::handle_timed_complete");
+
 #if !defined (ACE_WIN32) && defined (ACE_HAS_POLL) && defined (ACE_HAS_LIMITED_SELECT)
+
   struct pollfd fds;
+
   fds.fd = h;
   fds.events = POLLIN | POLLOUT;
   fds.revents = 0;
+
 #else
   ACE_Handle_Set rd_handles;
   ACE_Handle_Set wr_handles;
+
   rd_handles.set_bit (h);
   wr_handles.set_bit (h);
 #endif /* !ACE_WIN32 && ACE_HAS_POLL && ACE_HAS_LIMITED_SELECT */
+
 #if defined (ACE_WIN32)
   // Winsock is different - it sets the exception bit for failed connect,
   // unlike other platforms, where the read bit is set.
   ACE_Handle_Set ex_handles;
   ex_handles.set_bit (h);
 #endif /* ACE_WIN32 */
+
   bool need_to_check = false;
   bool known_failure = false;
+
 #if defined (ACE_WIN32)
   int n = ACE_OS::select (0,    // Ignored on Windows: int (h) + 1,
                           0,
@@ -2222,7 +2561,9 @@ ACE::handle_timed_complete (ACE_HANDLE h,
                           timeout);
 #else
 # if defined (ACE_HAS_POLL) && defined (ACE_HAS_LIMITED_SELECT)
+
   int n = ACE_OS::poll (&fds, 1, timeout);
+
 # else
   int n = ACE_OS::select (int (h) + 1,
                           rd_handles,
@@ -2231,6 +2572,7 @@ ACE::handle_timed_complete (ACE_HANDLE h,
                           timeout);
 # endif /* ACE_HAS_POLL && ACE_HAS_LIMITED_SELECT */
 #endif /* ACE_WIN32 */
+
   // If we failed to connect within the time period allocated by the
   // caller, then we fail (e.g., the remote host might have been too
   // busy to accept our call).
@@ -2240,6 +2582,7 @@ ACE::handle_timed_complete (ACE_HANDLE h,
         errno = ETIME;
       return ACE_INVALID_HANDLE;
     }
+
   // Usually, a ready-for-write handle is successfully connected, and
   // ready-for-read (exception on Win32) is a failure. On fails, we
   // need to grab the error code via getsockopt. On possible success for
@@ -2247,6 +2590,7 @@ ACE::handle_timed_complete (ACE_HANDLE h,
   // we also need to check for success/fail.
 #if defined (ACE_WIN32)
   ACE_UNUSED_ARG (is_tli);
+
   // On Win32, ex_handle set indicates a failure. We'll do the check
   // to try and get an errno value, but the connect failed regardless of
   // what getsockopt says about the error.
@@ -2257,17 +2601,20 @@ ACE::handle_timed_complete (ACE_HANDLE h,
     }
 #elif defined (ACE_VXWORKS)
   ACE_UNUSED_ARG (is_tli);
+
   // Force the check on VxWorks.  The read handle for "h" is not set,
   // so "need_to_check" is false at this point.  The write handle is
   // set, for what it's worth.
   need_to_check = true;
 #else
   if (is_tli)
+
 # if defined (ACE_HAS_POLL) && defined (ACE_HAS_LIMITED_SELECT)
     need_to_check = (fds.revents & POLLIN) && !(fds.revents & POLLOUT);
 # else
   need_to_check = rd_handles.is_set (h) && !wr_handles.is_set (h);
 # endif /* ACE_HAS_POLL && ACE_HAS_LIMITED_SELECT */
+
   else
 #if defined(AIX)
     // AIX is broken... both success and failed connect will set the
@@ -2281,6 +2628,7 @@ ACE::handle_timed_complete (ACE_HANDLE h,
 # endif /* ACE_HAS_POLL && ACE_HAS_LIMITED_SELECT */
 #endif /* AIX */
 #endif /* ACE_WIN32 */
+
   if (need_to_check)
     {
 #if defined (SOL_SOCKET) && defined (SO_ERROR)
@@ -2292,6 +2640,7 @@ ACE::handle_timed_complete (ACE_HANDLE h,
         {
           h = ACE_INVALID_HANDLE;
         }
+
       if (sock_err != 0 || known_failure)
         {
           h = ACE_INVALID_HANDLE;
@@ -2299,9 +2648,11 @@ ACE::handle_timed_complete (ACE_HANDLE h,
         }
 #else
       char dummy;
+
       // The following recv() won't block provided that the
       // ACE_NONBLOCK flag has not been turned off .
       n = ACE::recv (h, &dummy, 1, MSG_PEEK);
+
       // If no data was read/peeked at, check to see if it's because
       // of a non-connected socket (and therefore an error) or there's
       // just no data yet.
@@ -2317,13 +2668,16 @@ ACE::handle_timed_complete (ACE_HANDLE h,
         }
 #endif
     }
+
   // 1. The HANDLE is ready for writing and doesn't need to be checked or
   // 2. recv() returned an indication of the state of the socket - if there is
   // either data present, or a recv is legit but there's no data yet,
   // the connection was successfully established.
   return h;
 }
+
 // Wait up to <timeout> amount of time to accept a connection.
+
 int
 ACE::handle_timed_accept (ACE_HANDLE listener,
                           ACE_Time_Value *timeout,
@@ -2333,21 +2687,29 @@ ACE::handle_timed_accept (ACE_HANDLE listener,
   // Make sure we don't bomb out on erroneous values.
   if (listener == ACE_INVALID_HANDLE)
     return -1;
+
 #if defined (ACE_HAS_POLL) && defined (ACE_HAS_LIMITED_SELECT)
+
   struct pollfd fds;
+
   fds.fd = listener;
   fds.events = POLLIN;
   fds.revents = 0;
+
 #else
   // Use the select() implementation rather than poll().
   ACE_Handle_Set rd_handle;
   rd_handle.set_bit (listener);
 #endif /* ACE_HAS_POLL && ACE_HAS_LIMITED_SELECT */
+
   // We need a loop here if <restart> is enabled.
+
   for (;;)
     {
 #if defined (ACE_HAS_POLL) && defined (ACE_HAS_LIMITED_SELECT)
+
       int n = ACE_OS::poll (&fds, 1, timeout);
+
 #else
       int select_width;
 #  if defined (ACE_WIN32)
@@ -2361,6 +2723,7 @@ ACE::handle_timed_accept (ACE_HANDLE listener,
                               rd_handle, 0, 0,
                               timeout);
 #endif /* ACE_HAS_POLL && ACE_HAS_LIMITED_SELECT */
+
       switch (n)
         {
         case -1:
@@ -2388,8 +2751,10 @@ ACE::handle_timed_accept (ACE_HANDLE listener,
         }
     }
 }
+
 // Make the current process a UNIX daemon.  This is based on Stevens
 // code from APUE.
+
 int
 ACE::daemonize (const ACE_TCHAR pathname[],
                 bool close_all_handles,
@@ -2398,44 +2763,58 @@ ACE::daemonize (const ACE_TCHAR pathname[],
   ACE_TRACE ("ACE::daemonize");
 #if !defined (ACE_LACKS_FORK)
   pid_t pid = ACE_OS::fork ();
+
   if (pid == -1)
     return -1;
   else if (pid != 0)
     ACE_OS::exit (0); // Parent exits.
+
   // 1st child continues.
   ACE_OS::setsid (); // Become session leader.
+
   ACE_OS::signal (SIGHUP, SIG_IGN);
+
   pid = ACE_OS::fork (program_name);
+
   if (pid != 0)
     ACE_OS::exit (0); // First child terminates.
+
   // Second child continues.
+
   if (pathname != 0)
     // change working directory.
     ACE_OS::chdir (pathname);
+
   ACE_OS::umask (0); // clear our file mode creation mask.
+
   // Close down the I/O handles.
   if (close_all_handles)
     {
       for (int i = ACE::max_handles () - 1; i >= 0; i--)
         ACE_OS::close (i);
+
       int fd = ACE_OS::open ("/dev/null", O_RDWR, 0);
       if (fd != -1)
         {
           ACE_OS::dup2 (fd, ACE_STDIN);
           ACE_OS::dup2 (fd, ACE_STDOUT);
           ACE_OS::dup2 (fd, ACE_STDERR);
+
           if (fd > ACE_STDERR)
             ACE_OS::close (fd);
         }
     }
+
   return 0;
 #else
   ACE_UNUSED_ARG (pathname);
   ACE_UNUSED_ARG (close_all_handles);
   ACE_UNUSED_ARG (program_name);
+
   ACE_NOTSUP_RETURN (-1);
 #endif /* ACE_LACKS_FORK */
 }
+
 pid_t
 ACE::fork (const ACE_TCHAR *program_name,
            int avoid_zombies)
@@ -2452,6 +2831,7 @@ ACE::fork (const ACE_TCHAR *program_name,
       //
       // Another way to avoid zombies is to ignore or catch the
       // SIGCHLD signal; we don't use that approach here.
+
       pid_t pid = ACE_OS::fork ();
       if (pid == 0)
         {
@@ -2466,10 +2846,12 @@ ACE::fork (const ACE_TCHAR *program_name,
               ACE_OS::_exit (0);
             }
         }
+
       // Parent process waits for child to terminate.
       ACE_exitcode status;
       if (pid < 0 || ACE_OS::waitpid (pid, &status, 0) < 0)
         return -1;
+
       // child terminated by calling exit()?
       if (WIFEXITED ((status)))
         {
@@ -2482,9 +2864,11 @@ ACE::fork (const ACE_TCHAR *program_name,
       else
         // child didn't call exit(); perhaps it received a signal?
         errno = EINTR;
+
       return -1;
     }
 }
+
 int
 ACE::max_handles (void)
 {
@@ -2501,6 +2885,7 @@ ACE::max_handles (void)
   // If == RLIM_INFINITY, fall through to the ACE_LACKS_RLIMIT sections
 # endif /* RLIM_INFINITY */
 #endif /* RLIMIT_NOFILE && !ACE_LACKS_RLIMIT */
+
 #if defined (_SC_OPEN_MAX)
   return ACE_OS::sysconf (_SC_OPEN_MAX);
 #elif defined (ACE_VXWORKS) && (ACE_VXWORKS < 0x620)
@@ -2511,10 +2896,12 @@ ACE::max_handles (void)
   ACE_NOTSUP_RETURN (-1);
 #endif /* _SC_OPEN_MAX */
 }
+
 // Set the number of currently open handles in the process.
 //
 // If NEW_LIMIT == -1 set the limit to the maximum allowable.
 // Otherwise, set it to be the value of NEW_LIMIT.
+
 int
 ACE::set_handle_limit (int new_limit,
                        int increase_limit_only)
@@ -2522,17 +2909,22 @@ ACE::set_handle_limit (int new_limit,
   ACE_TRACE ("ACE::set_handle_limit");
   int cur_limit = ACE::max_handles ();
   int max_limit = cur_limit;
+
   if (cur_limit == -1)
     return -1;
+
 #if !defined (ACE_LACKS_RLIMIT) && defined (RLIMIT_NOFILE)
   struct rlimit rl;
+
   ACE_OS::memset ((void *) &rl, 0, sizeof rl);
   int r = ACE_OS::getrlimit (RLIMIT_NOFILE, &rl);
   if (r == 0)
     max_limit = rl.rlim_max;
 #endif /* ACE_LACKS_RLIMIT */
+
   if (new_limit == -1)
     new_limit = max_limit;
+
   if (new_limit < 0)
     {
       errno = EINVAL;
@@ -2564,8 +2956,10 @@ ACE::set_handle_limit (int new_limit,
       return 0;
 #endif /* ACE_LACKS_RLIMIT */
     }
+
   return 0;
 }
+
 // Euclid's greatest common divisor algorithm.
 u_long
 ACE::gcd (u_long x, u_long y)
@@ -2576,9 +2970,11 @@ ACE::gcd (u_long x, u_long y)
       x = y;
       y = r;
     }
+
   return x;
 }
 
+
 // Calculates the minimum enclosing frame size for the given values.
 u_long
 ACE::minimum_frame_size (u_long period1, u_long period2)
@@ -2593,8 +2989,10 @@ ACE::minimum_frame_size (u_long period1, u_long period2)
     {
       return period1;
     }
+
   // if neither is zero, find the greatest common divisor of the two periods
   u_long greatest_common_divisor = ACE::gcd (period1, period2);
+
   // explicitly consider cases to reduce risk of possible overflow errors
   if (greatest_common_divisor == 1)
     {
@@ -2620,6 +3018,7 @@ ACE::minimum_frame_size (u_long period1, u_long period2)
     }
 }
 
+
 u_long
 ACE::is_prime (const u_long n,
                const u_long min_factor,
@@ -2631,13 +3030,16 @@ ACE::is_prime (const u_long n,
          ++factor)
       if (n / factor * factor == n)
         return factor;
+
   return 0;
 }
+
 const ACE_TCHAR *
 ACE::sock_error (int error)
 {
 #if defined (ACE_WIN32)
   static ACE_TCHAR unknown_msg[64];
+
   switch (error)
     {
     case WSAVERNOTSUPPORTED:
@@ -2783,6 +3185,7 @@ ACE::sock_error (int error)
   ACE_NOTSUP_RETURN (0);
 #endif /* ACE_WIN32 */
 }
+
 bool
 ACE::is_sock_error (int error)
 {
@@ -2841,35 +3244,43 @@ ACE::is_sock_error (int error)
 #endif /* ACE_WIN32 */
   return false;
 }
+
 char *
 ACE::strndup (const char *str, size_t n)
 {
   const char *t = str;
   size_t len;
+
   // Figure out how long this string is (remember, it might not be
   // NUL-terminated).
+
   for (len = 0;
        len < n && *t++ != '\0';
        len++)
     continue;
+
   char *s;
   ACE_ALLOCATOR_RETURN (s,
                         (char *) ACE_OS::malloc (len + 1),
                         0);
   return ACE_OS::strsncpy (s, str, len + 1);
 }
+
 #if defined (ACE_HAS_WCHAR)
 wchar_t *
 ACE::strndup (const wchar_t *str, size_t n)
 {
   const wchar_t *t = str;
   size_t len;
+
   // Figure out how long this string is (remember, it might not be
   // NUL-terminated).
+
   for (len = 0;
        len < n && *t++ != '\0';
        len++)
     continue;
+
   wchar_t *s;
   ACE_ALLOCATOR_RETURN (s,
                         static_cast<wchar_t *> (
@@ -2878,35 +3289,43 @@ ACE::strndup (const wchar_t *str, size_t n)
   return ACE_OS::strsncpy (s, str, len + 1);
 }
 #endif /* ACE_HAS_WCHAR */
+
 char *
 ACE::strnnew (const char *str, size_t n)
 {
   const char *t = str;
   size_t len;
+
   // Figure out how long this string is (remember, it might not be
   // NUL-terminated).
+
   for (len = 0;
        len < n && *t++ != L'\0';
        len++)
     continue;
+
   char *s;
   ACE_NEW_RETURN (s,
                   char[len + 1],
                   0);
   return ACE_OS::strsncpy (s, str, len + 1);
 }
+
 #if defined (ACE_HAS_WCHAR)
 wchar_t *
 ACE::strnnew (const wchar_t *str, size_t n)
 {
   const wchar_t *t = str;
   size_t len;
+
   // Figure out how long this string is (remember, it might not be
   // NUL-terminated).
+
   for (len = 0;
        len < n && *t++ != ACE_TEXT_WIDE ('\0');
        len++)
     continue;
+
   wchar_t *s;
   ACE_NEW_RETURN (s,
                   wchar_t[len + 1],
@@ -2914,22 +3333,27 @@ ACE::strnnew (const wchar_t *str, size_t n)
   return ACE_OS::strsncpy (s, str, len + 1);
 }
 #endif /* ACE_HAS_WCHAR */
+
 const char *
 ACE::strend (const char *s)
 {
   while (*s++ != '\0')
     continue;
+
   return s;
 }
+
 #if defined ACE_HAS_WCHAR
 const wchar_t *
 ACE::strend (const wchar_t *s)
 {
   while (*s++ != ACE_TEXT_WIDE ('\0'))
     continue;
+
   return s;
 }
 #endif
+
 char *
 ACE::strnew (const char *s)
 {
@@ -2944,6 +3368,7 @@ ACE::strnew (const char *s)
   else
     return ACE_OS::strcpy (t, s);
 }
+
 #if defined (ACE_HAS_WCHAR)
 wchar_t *
 ACE::strnew (const wchar_t *s)
@@ -2960,12 +3385,14 @@ ACE::strnew (const wchar_t *s)
     return ACE_OS::strcpy (t, s);
 }
 #endif /* ACE_HAS_WCHAR */
+
 inline static bool equal_char(char a, char b, bool case_sensitive)
 {
   if (case_sensitive)
     return a == b;
   return ACE_OS::ace_tolower(a) == ACE_OS::ace_tolower(b);
 }
+
 bool
 ACE::wild_match(const char* str, const char* pat, bool case_sensitive)
 {
@@ -2973,6 +3400,7 @@ ACE::wild_match(const char* str, const char* pat, bool case_sensitive)
     return true;
   if (pat == 0 || str == 0)
     return false;
+
   bool star = false;
   const char* s = str;
   const char* p = pat;
@@ -2983,6 +3411,7 @@ ACE::wild_match(const char* str, const char* pat, bool case_sensitive)
           star = true;
           pat = p;
           while (*++pat == '*') {}
+
           if (*pat == '\0')
             return true;
           p = pat;
@@ -3007,8 +3436,10 @@ ACE::wild_match(const char* str, const char* pat, bool case_sensitive)
     }
   if (*p == '*')
     while (*++p == '*') {}
+
   return *p == '\0';
 }
+
 // Close versioned namespace, if enabled by the user.
 ACE_END_VERSIONED_NAMESPACE_DECL