Minor style issues through the socket implementation code.

1 files changed, 367 insertions, 211 deletions

diff --git a/win/tclWinSock.c b/win/tclWinSock.c
index 81a5449..d6aca1b 100644
--- a/win/tclWinSock.c
+++ b/win/tclWinSock.c
@@ -297,17 +297,25 @@ static ProcessGlobalValue hostName =
  * Address print debug functions
  */
 #if 0
-void printaddrinfo(struct addrinfo *ai, char *prefix)
+void
+printaddrinfo(
+    struct addrinfo *ai,
+    char *prefix)
 {
     char host[NI_MAXHOST], port[NI_MAXSERV];
+
     getnameinfo(ai->ai_addr, ai->ai_addrlen,
-		host, sizeof(host),
-		port, sizeof(port),
-		NI_NUMERICHOST|NI_NUMERICSERV);
+	    host, sizeof(host), port, sizeof(port),
+	    NI_NUMERICHOST|NI_NUMERICSERV);
 }
-void printaddrinfolist(struct addrinfo *addrlist, char *prefix)
+
+void
+printaddrinfolist(
+    struct addrinfo *addrlist,
+    char *prefix)
 {
     struct addrinfo *ai;
+
     for (ai = addrlist; ai != NULL; ai = ai->ai_next) {
 	printaddrinfo(ai, prefix);
     }
@@ -524,9 +532,9 @@ TcpBlockModeProc(
     TcpState *statePtr = instanceData;
 
     if (mode == TCL_MODE_NONBLOCKING) {
-	statePtr->flags |= TCP_NONBLOCKING;
+	SET_BITS(statePtr->flags, TCP_NONBLOCKING);
     } else {
-	statePtr->flags &= ~(TCP_NONBLOCKING);
+        CLEAR_BITS(statePtr->flags, TCP_NONBLOCKING);
     }
     return 0;
 }
@@ -536,29 +544,28 @@ TcpBlockModeProc(
  *
  * WaitForConnect --
  *
- *	Check the state of an async connect process. If a connection
- *	attempt terminated, process it, which may finalize it or may
- *	start the next attempt. If a connect error occures, it is saved
- *	in statePtr->connectError to be reported by 'fconfigure -error'.
+ *	Check the state of an async connect process. If a connection attempt
+ *	terminated, process it, which may finalize it or may start the next
+ *	attempt. If a connect error occures, it is saved in
+ *	statePtr->connectError to be reported by 'fconfigure -error'.
  *
  *	There are two modes of operation, defined by errorCodePtr:
- *	 *  non-NULL: Called by explicite read/write command. block if
- *	    socket is blocking.
+ *	 *  non-NULL: Called by explicite read/write command. Block if socket
+ *	    is blocking.
  *	    May return two error codes:
  *	     *	EWOULDBLOCK: if connect is still in progress
- *	     *	ENOTCONN: if connect failed. This would be the error
- *		message of a rect or sendto syscall so this is
- *		emulated here.
- *	 *  Null: Called by a backround operation. Do not block and
- *	    don't return any error code.
+ *	     *	ENOTCONN: if connect failed. This would be the error message
+ *		of a rect or sendto syscall so this is emulated here.
+ *	 *  Null: Called by a backround operation. Do not block and don't
+ *	    return any error code.
  *
  * Results:
- * 	0 if the connection has completed, -1 if still in progress
- * 	or there is an error.
+ * 	0 if the connection has completed, -1 if still in progress or there is
+ * 	an error.
  *
  * Side effects:
- *	Processes socket events off the system queue.
- *	May process asynchroneous connect.
+ *	Processes socket events off the system queue. May process
+ *	asynchroneous connect.
  *
  *----------------------------------------------------------------------
  */
@@ -566,17 +573,16 @@ TcpBlockModeProc(
 static int
 WaitForConnect(
     TcpState *statePtr,		/* State of the socket. */
-    int *errorCodePtr)		/* Where to store errors?
-				 * A passed null-pointer activates background mode.
-				 */
+    int *errorCodePtr)		/* Where to store errors? A passed
+				 * null-pointer activates background mode. */
 {
     int result;
     int oldMode;
     ThreadSpecificData *tsdPtr;
 
     /*
-     * Check if an async connect failed already and error reporting is demanded,
-     * return the error ENOTCONN
+     * Check if an async connect failed already and error reporting is
+     * demanded, return the error ENOTCONN.
      */
 
     if (errorCodePtr != NULL && (statePtr->flags & TCP_ASYNC_FAILED)) {
@@ -603,36 +609,51 @@ WaitForConnect(
      */
 
     while (1) {
+	/*
+         * Get the statePtr lock.
+         */
 
-	/* get statePtr lock */
         tsdPtr = TclThreadDataKeyGet(&dataKey);
 	WaitForSingleObject(tsdPtr->socketListLock, INFINITE);
 
-	/* Check for connect event */
+	/*
+         * Check for connect event.
+         */
+
 	if (statePtr->readyEvents & FD_CONNECT) {
+	    /*
+             * Consume the connect event.
+             */
 
-	    /* Consume the connect event */
-	    statePtr->readyEvents &= ~(FD_CONNECT);
+	    CLEAR_BITS(statePtr->readyEvents, FD_CONNECT);
 
 	    /*
-	     * For blocking sockets and foreground processing
-	     * disable async connect as we continue now synchoneously
+	     * For blocking sockets and foreground processing, disable async
+	     * connect as we continue now synchoneously.
 	     */
-	    if ( errorCodePtr != NULL &&
-		    ! (statePtr->flags & TCP_NONBLOCKING) ) {
+
+	    if (errorCodePtr != NULL &&
+		    !(statePtr->flags & TCP_NONBLOCKING)) {
 		CLEAR_BITS(statePtr->flags, TCP_ASYNC_CONNECT);
 	    }
 
-	    /* Free list lock */
+	    /*
+             * Free list lock.
+             */
+
 	    SetEvent(tsdPtr->socketListLock);
 
 	    /*
-	     * Continue connect.
-	     * If switched to synchroneous connect, the connect is terminated.
+	     * Continue connect. If switched to synchroneous connect, the
+	     * connect is terminated.
 	     */
+
 	    result = TcpConnect(NULL, statePtr);
 
-	    /* Restore event service mode */
+	    /*
+             * Restore event service mode.
+             */
+
 	    (void) Tcl_SetServiceMode(oldMode);
 
 	    /*
@@ -641,10 +662,11 @@ WaitForConnect(
 
 	    if (result == TCL_OK) {
 		/*
-		 * Check for async connect restart
-		 * (not possible for foreground blocking operation)
+		 * Check for async connect restart (not possible for
+		 * foreground blocking operation)
 		 */
-		if ( statePtr->flags & TCP_ASYNC_PENDING ) {
+
+		if (statePtr->flags & TCP_ASYNC_PENDING) {
 		    if (errorCodePtr != NULL) {
 			*errorCodePtr = EWOULDBLOCK;
 		    }
@@ -654,8 +676,8 @@ WaitForConnect(
 	    }
 
 	    /*
-	     * Connect finally failed.
-	     * For foreground operation return ENOTCONN.
+	     * Connect finally failed. For foreground operation return
+	     * ENOTCONN.
 	     */
 
 	    if (errorCodePtr != NULL) {
@@ -664,7 +686,10 @@ WaitForConnect(
 	    return -1;
 	}
 
-        /* Free list lock */
+        /*
+         * Free list lock.
+         */
+
         SetEvent(tsdPtr->socketListLock);
 
 	/*
@@ -672,13 +697,13 @@ WaitForConnect(
 	 * event
 	 */
 
-	if ( errorCodePtr == NULL ) {
+	if (errorCodePtr == NULL) {
 	    return -1;
 	}
 
 	/*
-	 * A non blocking socket waiting for an asyncronous connect
-	 * returns directly the error EWOULDBLOCK
+	 * A non blocking socket waiting for an asyncronous connect returns
+	 * directly the error EWOULDBLOCK.
 	 */
 
 	if (statePtr->flags & TCP_NONBLOCKING) {
@@ -770,16 +795,20 @@ TcpInputProc(
     while (1) {
 	SendMessage(tsdPtr->hwnd, SOCKET_SELECT,
 		(WPARAM) UNSELECT, (LPARAM) statePtr);
-	/* single fd operation: this proc is only called for a connected socket. */
+	/*
+         * Single fd operation: this proc is only called for a connected
+         * socket.
+         */
+
 	bytesRead = recv(statePtr->sockets->fd, buf, bufSize, 0);
-	statePtr->readyEvents &= ~(FD_READ);
+	CLEAR_BITS(statePtr->readyEvents, FD_READ);
 
 	/*
 	 * Check for end-of-file condition or successful read.
 	 */
 
 	if (bytesRead == 0) {
-	    statePtr->flags |= SOCKET_EOF;
+	    SET_BITS(statePtr->flags, SOCKET_EOF);
 	}
 	if (bytesRead != SOCKET_ERROR) {
 	    break;
@@ -791,7 +820,7 @@ TcpInputProc(
 	 */
 
 	if (statePtr->readyEvents & FD_CLOSE) {
-	    statePtr->flags |= SOCKET_EOF;
+	    SET_BITS(statePtr->flags, SOCKET_EOF);
 	    bytesRead = 0;
 	    break;
 	}
@@ -804,7 +833,7 @@ TcpInputProc(
 	 */
 
 	if (error == WSAECONNRESET) {
-	    statePtr->flags |= SOCKET_EOF;
+	    SET_BITS(statePtr->flags, SOCKET_EOF);
 	    bytesRead = 0;
 	    break;
 	}
@@ -892,7 +921,11 @@ TcpOutputProc(
 	SendMessage(tsdPtr->hwnd, SOCKET_SELECT,
 		(WPARAM) UNSELECT, (LPARAM) statePtr);
 
-	/* single fd operation: this proc is only called for a connected socket. */
+	/*
+         * Single fd operation: this proc is only called for a connected
+         * socket.
+         */
+
 	written = send(statePtr->sockets->fd, buf, toWrite, 0);
 	if (written != SOCKET_ERROR) {
 	    /*
@@ -917,7 +950,7 @@ TcpOutputProc(
 
 	error = WSAGetLastError();
 	if (error == WSAEWOULDBLOCK) {
-	    statePtr->readyEvents &= ~(FD_WRITE);
+	    CLEAR_BITS(statePtr->readyEvents, FD_WRITE);
 	    if (statePtr->flags & TCP_NONBLOCKING) {
 		*errorCodePtr = EWOULDBLOCK;
 		written = -1;
@@ -941,7 +974,8 @@ TcpOutputProc(
 	}
     }
 
-    SendMessage(tsdPtr->hwnd, SOCKET_SELECT, (WPARAM)SELECT, (LPARAM)statePtr);
+    SendMessage(tsdPtr->hwnd, SOCKET_SELECT, (WPARAM)SELECT,
+            (LPARAM)statePtr);
 
     return written;
 }
@@ -988,10 +1022,10 @@ TcpCloseProc(
 	 * background.
 	 */
 
-	while ( statePtr->sockets != NULL ) {
+	while (statePtr->sockets != NULL) {
 	    TcpFdList *thisfd = statePtr->sockets;
-	    statePtr->sockets = thisfd->next;
 
+	    statePtr->sockets = thisfd->next;
 	    if (closesocket(thisfd->fd) == SOCKET_ERROR) {
 		TclWinConvertError((DWORD) WSAGetLastError());
 		errorCode = Tcl_GetErrno();
@@ -1009,18 +1043,25 @@ TcpCloseProc(
 
     /*
      * Clear an eventual tsd info list pointer.
+     *
      * This may be called, if an async socket connect fails or is closed
      * between connect and thread action callback.
      */
+
     if (tsdPtr->pendingTcpState != NULL
 	    && tsdPtr->pendingTcpState == statePtr) {
+	/*
+         * Get infoPtr lock, because this concerns the notifier thread.
+         */
 
-	/* get infoPtr lock, because this concerns the notifier thread */
 	WaitForSingleObject(tsdPtr->socketListLock, INFINITE);
 
 	tsdPtr->pendingTcpState = NULL;
 
-	/* Free list lock */
+	/*
+         * Free list lock.
+         */
+
 	SetEvent(tsdPtr->socketListLock);
     }
 
@@ -1081,8 +1122,11 @@ TcpClose2Proc(
 	return TCL_ERROR;
     }
 
-    /* single fd operation: Tcl_OpenTcpServer() does not set TCL_READABLE or
-     * TCL_WRITABLE so this should never be called for a server socket. */
+    /*
+     * Single fd operation: Tcl_OpenTcpServer() does not set TCL_READABLE or
+     * TCL_WRITABLE so this should never be called for a server socket.
+     */
+
     if (shutdown(statePtr->sockets->fd, sd) == SOCKET_ERROR) {
 	TclWinConvertError((DWORD) WSAGetLastError());
 	errorCode = Tcl_GetErrno();
@@ -1134,7 +1178,7 @@ TcpSetOptionProc(
     }
 
 #ifdef TCL_FEATURE_KEEPALIVE_NAGLE
-    #error "TCL_FEATURE_KEEPALIVE_NAGLE not reviewed for whether to treat statePtr->sockets as single fd or list"
+#error "TCL_FEATURE_KEEPALIVE_NAGLE not reviewed for whether to treat statePtr->sockets as single fd or list"
     sock = statePtr->sockets->fd;
 
     if (!strcasecmp(optionName, "-keepalive")) {
@@ -1243,8 +1287,11 @@ TcpGetOptionProc(
 
     /*
      * Go one step in async connect
-     * If any error is thrown save it as backround error to report eventually below
+     *
+     * If any error is thrown save it as backround error to report eventually
+     * below.
      */
+
     WaitForConnect(statePtr, NULL);
 
     sock = statePtr->sockets->fd;
@@ -1254,31 +1301,26 @@ TcpGetOptionProc(
 
     if ((len > 1) && (optionName[1] == 'e') &&
 	    (strncmp(optionName, "-error", len) == 0)) {
-
 	/*
-	* Do not return any errors if async connect is running
-	*/
-	if ( ! (statePtr->flags & TCP_ASYNC_PENDING) ) {
-
-
-	    if ( statePtr->flags & TCP_ASYNC_FAILED ) {
+         * Do not return any errors if async connect is running.
+         */
 
+	if (!(statePtr->flags & TCP_ASYNC_PENDING)) {
+	    if (statePtr->flags & TCP_ASYNC_FAILED) {
 		/*
 		 * In case of a failed async connect, eventually report the
-		 * connect error only once.
-		 * Do not report the system error, as this comes again and again.
+		 * connect error only once.  Do not report the system error,
+		 * as this comes again and again.
 		 */
 
-		if ( statePtr->connectError != 0 ) {
+		if (statePtr->connectError != 0) {
 		    Tcl_DStringAppend(dsPtr,
 			    Tcl_ErrnoMsg(statePtr->connectError), -1);
 		    statePtr->connectError = 0;
 		}
-
 	    } else {
-
 		/*
-		 * Report an eventual last error of the socket system
+		 * Report an eventual last error of the socket system.
 		 */
 
 		int optlen;
@@ -1286,24 +1328,30 @@ TcpGetOptionProc(
 		DWORD err;
 
 		/*
-		 * Populater the err Variable with a possix error
+		 * Populate the err variable with a POSIX error
 		 */
+
 		optlen = sizeof(int);
 		ret = getsockopt(sock, SOL_SOCKET, SO_ERROR,
 			(char *)&err, &optlen);
+
 		/*
-		 * The error was not returned directly but should be
-		 * taken from WSA
+		 * The error was not returned directly but should be taken
+		 * from WSA.
 		 */
+
 		if (ret == SOCKET_ERROR) {
 		    err = WSAGetLastError();
 		}
+
 		/*
-		 * Return error message
+		 * Return error message.
 		 */
+
 		if (err) {
 		    TclWinConvertError(err);
-		    Tcl_DStringAppend(dsPtr, Tcl_ErrnoMsg(Tcl_GetErrno()), -1);
+		    Tcl_DStringAppend(dsPtr, Tcl_ErrnoMsg(Tcl_GetErrno()),
+                            -1);
 		}
 	    }
 	}
@@ -1312,14 +1360,14 @@ TcpGetOptionProc(
 
     if ((len > 1) && (optionName[1] == 'c') &&
 	    (strncmp(optionName, "-connecting", len) == 0)) {
-
 	Tcl_DStringAppend(dsPtr,
 		(statePtr->flags & TCP_ASYNC_PENDING)
 		? "1" : "0", -1);
         return TCL_OK;
     }
 
-    if (interp != NULL && Tcl_GetVar2(interp, SUPPRESS_RDNS_VAR, NULL, 0) != NULL) {
+    if (interp != NULL
+            && Tcl_GetVar2(interp, SUPPRESS_RDNS_VAR, NULL, 0) != NULL) {
 	reverseDNS = NI_NUMERICHOST;
     }
 
@@ -1328,20 +1376,23 @@ TcpGetOptionProc(
 	address peername;
 	socklen_t size = sizeof(peername);
 
-	if ( (statePtr->flags & TCP_ASYNC_PENDING) ) {
+	if (statePtr->flags & TCP_ASYNC_PENDING) {
 	    /*
 	     * In async connect output an empty string
 	     */
+
 	    if (len == 0) {
 		Tcl_DStringAppendElement(dsPtr, "-peername");
 		Tcl_DStringAppendElement(dsPtr, "");
 	    } else {
 		return TCL_OK;
 	    }
-	} else if ( getpeername(sock, (LPSOCKADDR) &(peername.sa), &size) == 0) {
+	} else if (getpeername(sock, (LPSOCKADDR) &(peername.sa),
+                &size) == 0) {
 	    /*
 	     * Peername fetch succeeded - output list
 	     */
+
 	    if (len == 0) {
 		Tcl_DStringAppendElement(dsPtr, "-peername");
 		Tcl_DStringStartSublist(dsPtr);
@@ -1390,11 +1441,12 @@ TcpGetOptionProc(
 	    Tcl_DStringAppendElement(dsPtr, "-sockname");
 	    Tcl_DStringStartSublist(dsPtr);
 	}
-	if ( (statePtr->flags & TCP_ASYNC_PENDING ) ) {
+	if (statePtr->flags & TCP_ASYNC_PENDING) {
 	    /*
 	     * In async connect output an empty string
 	     */
-	     found = 1;
+
+            found = 1;
 	} else {
 	    for (fds = statePtr->sockets; fds != NULL; fds = fds->next) {
 		sock = fds->fd;
@@ -1408,9 +1460,11 @@ TcpGetOptionProc(
 		    Tcl_DStringAppendElement(dsPtr, host);
 
 		    /*
-		     * We don't want to resolve INADDR_ANY and sin6addr_any; they
-		     * can sometimes cause problems (and never have a name).
+		     * We don't want to resolve INADDR_ANY and sin6addr_any;
+		     * they can sometimes cause problems (and never have a
+		     * name).
 		     */
+
 		    flags |= NI_NUMERICSERV;
 		    if (sockname.sa.sa_family == AF_INET) {
 			if (sockname.sa4.sin_addr.s_addr == INADDR_ANY) {
@@ -1494,7 +1548,8 @@ TcpGetOptionProc(
 	return Tcl_BadChannelOption(interp, optionName,
 		"connecting peername sockname keepalive nagle");
 #else
-	return Tcl_BadChannelOption(interp, optionName, "connecting peername sockname");
+	return Tcl_BadChannelOption(interp, optionName,
+                "connecting peername sockname");
 #endif /*TCL_FEATURE_KEEPALIVE_NAGLE*/
     }
 
@@ -1536,10 +1591,10 @@ TcpWatchProc(
     if (!statePtr->acceptProc) {
 	statePtr->watchEvents = 0;
 	if (mask & TCL_READABLE) {
-	    statePtr->watchEvents |= (FD_READ|FD_CLOSE);
+	    SET_BITS(statePtr->watchEvents, FD_READ | FD_CLOSE);
 	}
 	if (mask & TCL_WRITABLE) {
-	    statePtr->watchEvents |= (FD_WRITE|FD_CLOSE);
+	    SET_BITS(statePtr->watchEvents, FD_WRITE | FD_CLOSE);
 	}
 
 	/*
@@ -1630,13 +1685,13 @@ TcpConnect(
     TcpState *statePtr)
 {
     DWORD error;
-    /*
-     * We are started with async connect and the connect notification
-     * was not jet received
-     */
     int async_connect = statePtr->flags & TCP_ASYNC_CONNECT;
-    /* We were called by the event procedure and continue our loop */
+                                /* We are started with async connect and the
+                                 * connect notification was not yet
+                                 * received. */
     int async_callback = statePtr->flags & TCP_ASYNC_PENDING;
+                                /* We were called by the event procedure and
+                                 * continue our loop. */
     ThreadSpecificData *tsdPtr = TclThreadDataKeyGet(&dataKey);
 
     if (async_callback) {
@@ -1644,11 +1699,10 @@ TcpConnect(
     }
 
     for (statePtr->addr = statePtr->addrlist; statePtr->addr != NULL;
-	 statePtr->addr = statePtr->addr->ai_next) {
-
-        for (statePtr->myaddr = statePtr->myaddrlist; statePtr->myaddr != NULL;
-	     statePtr->myaddr = statePtr->myaddr->ai_next) {
-
+	    statePtr->addr = statePtr->addr->ai_next) {
+        for (statePtr->myaddr = statePtr->myaddrlist;
+                statePtr->myaddr != NULL;
+                statePtr->myaddr = statePtr->myaddr->ai_next) {
 	    /*
 	     * No need to try combinations of local and remote addresses
 	     * of different families.
@@ -1662,25 +1716,37 @@ TcpConnect(
              * Close the socket if it is still open from the last unsuccessful
              * iteration.
              */
+
 	    if (statePtr->sockets->fd != INVALID_SOCKET) {
 		closesocket(statePtr->sockets->fd);
 	    }
 
-	    /* get statePtr lock */
+	    /*
+             * Get statePtr lock.
+             */
+
 	    WaitForSingleObject(tsdPtr->socketListLock, INFINITE);
 
 	    /*
 	     * Reset last error from last try
 	     */
+
 	    statePtr->notifierConnectError = 0;
 	    Tcl_SetErrno(0);
 
-	    statePtr->sockets->fd = socket(statePtr->myaddr->ai_family, SOCK_STREAM, 0);
+	    statePtr->sockets->fd = socket(statePtr->myaddr->ai_family,
+                    SOCK_STREAM, 0);
+
+	    /*
+             * Free list lock.
+             */
 
-	    /* Free list lock */
 	    SetEvent(tsdPtr->socketListLock);
 
-	    /* continue on socket creation error */
+	    /*
+             * Continue on socket creation error.
+             */
+
 	    if (statePtr->sockets->fd == INVALID_SOCKET) {
 		TclWinConvertError((DWORD) WSAGetLastError());
 		continue;
@@ -1691,31 +1757,39 @@ TcpConnect(
 	     * processes by default. Turn off the inherit bit.
 	     */
 
-	    SetHandleInformation((HANDLE) statePtr->sockets->fd, HANDLE_FLAG_INHERIT, 0);
+	    SetHandleInformation((HANDLE) statePtr->sockets->fd,
+                    HANDLE_FLAG_INHERIT, 0);
 
 	    /*
 	     * Set kernel space buffering
 	     */
 
-	    TclSockMinimumBuffers((void *) statePtr->sockets->fd, TCP_BUFFER_SIZE);
+	    TclSockMinimumBuffers((void *) statePtr->sockets->fd,
+                    TCP_BUFFER_SIZE);
 
 	    /*
 	     * Try to bind to a local port.
 	     */
 
 	    if (bind(statePtr->sockets->fd, statePtr->myaddr->ai_addr,
-			statePtr->myaddr->ai_addrlen) == SOCKET_ERROR) {
+		    statePtr->myaddr->ai_addrlen) == SOCKET_ERROR) {
 		TclWinConvertError((DWORD) WSAGetLastError());
 		continue;
 	    }
+
 	    /*
 	     * For asyncroneous connect set the socket in nonblocking mode
 	     * and activate connect notification
 	     */
+
 	    if (async_connect) {
 		TcpState *statePtr2;
 		int in_socket_list = 0;
-		/* get statePtr lock */
+
+		/*
+                 * Get statePtr lock.
+                 */
+
 		WaitForSingleObject(tsdPtr->socketListLock, INFINITE);
 
 		/*
@@ -1725,8 +1799,8 @@ TcpConnect(
 		 * It is set after this call by TcpThreadActionProc and is set
 		 * on a second round.
 		 *
-		 * If not, we buffer my statePtr in the tsd memory so it is not
-		 * lost by the event procedure
+		 * If not, we buffer my statePtr in the tsd memory so it is
+		 * not lost by the event procedure
 		 */
 
 		for (statePtr2 = tsdPtr->socketList; statePtr2 != NULL;
@@ -1739,19 +1813,26 @@ TcpConnect(
 		if (!in_socket_list) {
 		    tsdPtr->pendingTcpState = statePtr;
 		}
+
 		/*
 		 * Set connect mask to connect events
-		 * This is activated by a SOCKET_SELECT message to the notifier
-		 * thread.
+                 *
+		 * This is activated by a SOCKET_SELECT message to the
+		 * notifier thread.
 		 */
-		statePtr->selectEvents |= FD_CONNECT;
+
+		SET_BITS(statePtr->selectEvents, FD_CONNECT);
 
 		/*
-		 * Free list lock
+		 * Free list lock.
 		 */
+
 		SetEvent(tsdPtr->socketListLock);
 
-    		/* activate accept notification */
+    		/*
+                 * Activate accept notification.
+                 */
+
 		SendMessage(tsdPtr->hwnd, SOCKET_SELECT, (WPARAM) SELECT,
 			(LPARAM) statePtr);
 	    }
@@ -1769,12 +1850,11 @@ TcpConnect(
 	    if (async_connect && error == WSAEWOULDBLOCK) {
 		/*
 		 * Asynchroneous connect
-		 */
-
-		/*
+		 *
 		 * Remember that we jump back behind this next round
 		 */
-		statePtr->flags |= TCP_ASYNC_PENDING;
+
+		SET_BITS(statePtr->flags, TCP_ASYNC_PENDING);
 		return TCL_OK;
 
 	    reenter:
@@ -1784,21 +1864,39 @@ TcpConnect(
 		 *
 		 * Clear the reenter flag
 		 */
-		statePtr->flags &= ~(TCP_ASYNC_PENDING);
-		/* get statePtr lock */
+
+		CLEAR_BITS(statePtr->flags, TCP_ASYNC_PENDING);
+
+		/*
+                 * Get statePtr lock.
+                 */
+
 		WaitForSingleObject(tsdPtr->socketListLock, INFINITE);
-		/* Get signaled connect error */
+
+		/*
+                 * Get signaled connect error.
+                 */
+
 		TclWinConvertError((DWORD) statePtr->notifierConnectError);
-		/* Clear eventual connect flag */
-		statePtr->selectEvents &= ~(FD_CONNECT);
-		/* Free list lock */
+
+		/*
+                 * Clear eventual connect flag.
+                 */
+
+		CLEAR_BITS(statePtr->selectEvents, FD_CONNECT);
+
+		/*
+                 * Free list lock.
+                 */
+
 		SetEvent(tsdPtr->socketListLock);
 	    }
 
 	    /*
-	     * Clear the tsd socket list pointer if we did not wait for
-	     * the FD_CONNECT asyncroneously
+	     * Clear the tsd socket list pointer if we did not wait for the
+	     * FD_CONNECT asynchronously.
 	     */
+
 	    tsdPtr->pendingTcpState = NULL;
 
 	    if (Tcl_GetErrno() == 0) {
@@ -1807,7 +1905,7 @@ TcpConnect(
 	}
     }
 
-out:
+  out:
     /*
      * Socket connected or connection failed
      */
@@ -1818,13 +1916,13 @@ out:
 
     CLEAR_BITS(statePtr->flags, TCP_ASYNC_CONNECT);
 
-    if ( Tcl_GetErrno() == 0 ) {
+    if (Tcl_GetErrno() == 0) {
 	/*
 	 * Succesfully connected
-	 */
-	/*
+	 *
 	 * Set up the select mask for read/write events.
 	 */
+
 	statePtr->selectEvents = FD_READ | FD_WRITE | FD_CLOSE;
 
 	/*
@@ -1837,30 +1935,52 @@ out:
     } else {
 	/*
 	 * Connect failed
-	 */
-
-	/*
+	 *
 	 * For async connect schedule a writable event to report the fail.
 	 */
+
 	if (async_callback) {
 	    /*
 	     * Set up the select mask for read/write events.
 	     */
+
 	    statePtr->selectEvents = FD_WRITE|FD_READ;
-	    /* get statePtr lock */
+
+	    /*
+             * Get statePtr lock.
+             */
+
 	    WaitForSingleObject(tsdPtr->socketListLock, INFINITE);
-	    /* Signal ready readable and writable events */
-	    statePtr->readyEvents |= FD_WRITE | FD_READ;
-	    /* Flag error to event routine */
-	    statePtr->flags |= TCP_ASYNC_FAILED;
-	    /* Save connect error to be reported by 'fconfigure -error' */
+
+	    /*
+             * Signal ready readable and writable events.
+             */
+
+	    SET_BITS(statePtr->readyEvents, FD_WRITE | FD_READ);
+
+	    /*
+             * Flag error to event routine.
+             */
+
+	    SET_BITS(statePtr->flags, TCP_ASYNC_FAILED);
+
+	    /*
+             * Save connect error to be reported by 'fconfigure -error'.
+             */
+
 	    statePtr->connectError = Tcl_GetErrno();
-	    /* Free list lock */
+
+	    /*
+             * Free list lock.
+             */
+
 	    SetEvent(tsdPtr->socketListLock);
 	}
+
 	/*
 	 * Error message on syncroneous connect
 	 */
+
 	if (interp != NULL) {
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		    "couldn't open socket: %s", Tcl_PosixError(interp)));
@@ -1938,7 +2058,7 @@ Tcl_OpenTcpClient(
     statePtr->addrlist = addrlist;
     statePtr->myaddrlist = myaddrlist;
     if (async) {
-	statePtr->flags |= TCP_ASYNC_CONNECT;
+	SET_BITS(statePtr->flags, TCP_ASYNC_CONNECT);
     }
 
     /*
@@ -2008,7 +2128,8 @@ Tcl_MakeTcpClientChannel(
      */
 
     statePtr->selectEvents = FD_READ | FD_CLOSE | FD_WRITE;
-    SendMessage(tsdPtr->hwnd, SOCKET_SELECT, (WPARAM)SELECT, (LPARAM)statePtr);
+    SendMessage(tsdPtr->hwnd, SOCKET_SELECT, (WPARAM)SELECT,
+            (LPARAM)statePtr);
 
     sprintf(channelName, SOCK_TEMPLATE, statePtr);
     statePtr->channel = Tcl_CreateChannel(&tcpChannelType, channelName,
@@ -2078,7 +2199,8 @@ Tcl_OpenTcpServerEx(
 	goto error;
     }
 
-    if (!TclCreateSocketAddress(interp, &addrlist, myHost, port, 1, &errorMsg)) {
+    if (!TclCreateSocketAddress(interp, &addrlist, myHost, port, 1,
+            &errorMsg)) {
 	goto error;
     }
 
@@ -2117,13 +2239,14 @@ Tcl_OpenTcpServerEx(
 	}
 
 	/*
-	 * The SO_REUSEADDR option on Windows behaves like SO_REUSEPORT on unix
-	 * systems.
+	 * The SO_REUSEADDR option on Windows behaves like SO_REUSEPORT on
+	 * unix systems.
 	 */
+
 	if (flags & TCL_TCPSERVER_REUSEPORT) {
 	    optvalue = 1;
 	    (void) setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
-			      (char *) &optvalue, sizeof(optvalue));
+		    (char *) &optvalue, sizeof(optvalue));
 	}
 
 	/*
@@ -2134,8 +2257,8 @@ Tcl_OpenTcpServerEx(
 	 * place to look for bugs.
 	 */
 
-	if (bind(sock, addrPtr->ai_addr, addrPtr->ai_addrlen)
-	    == SOCKET_ERROR) {
+	if (bind(sock, addrPtr->ai_addr,
+                addrPtr->ai_addrlen) == SOCKET_ERROR) {
 	    TclWinConvertError((DWORD) WSAGetLastError());
 	    closesocket(sock);
 	    continue;
@@ -2170,13 +2293,14 @@ Tcl_OpenTcpServerEx(
 	    /*
 	     * Add this socket to the global list of sockets.
 	     */
+
 	    statePtr = NewSocketInfo(sock);
 	} else {
-	    AddSocketInfoFd( statePtr, sock );
+	    AddSocketInfoFd(statePtr, sock);
 	}
     }
 
-error:
+  error:
     if (addrlist != NULL) {
 	freeaddrinfo(addrlist);
     }
@@ -2202,7 +2326,7 @@ error:
 
 	ioctlsocket(sock, (long) FIONBIO, &flag);
 	SendMessage(tsdPtr->hwnd, SOCKET_SELECT, (WPARAM) SELECT,
-		    (LPARAM) statePtr);
+		(LPARAM) statePtr);
 	if (Tcl_SetChannelOption(interp, statePtr->channel, "-eofchar", "")
 	    == TCL_ERROR) {
 	    Tcl_Close(NULL, statePtr->channel);
@@ -2564,9 +2688,8 @@ SocketCheckProc(
 	    statePtr = statePtr->nextPtr) {
 	if ((statePtr->readyEvents &
 		(statePtr->watchEvents | FD_CONNECT | FD_ACCEPT))
-	    && !(statePtr->flags & SOCKET_PENDING)
-	) {
-	    statePtr->flags |= SOCKET_PENDING;
+                && !(statePtr->flags & SOCKET_PENDING)) {
+	    SET_BITS(statePtr->flags, SOCKET_PENDING);
 	    evPtr = ckalloc(sizeof(SocketEvent));
 	    evPtr->header.proc = SocketEventProc;
 	    evPtr->socket = statePtr->sockets->fd;
@@ -2641,29 +2764,26 @@ SocketEventProc(
      * Clear flag that (this) event is pending
      */
 
-    statePtr->flags &= ~SOCKET_PENDING;
+    CLEAR_BITS(statePtr->flags, SOCKET_PENDING);
 
     /*
      * Continue async connect if pending and ready
      */
 
-    if ( statePtr->readyEvents & FD_CONNECT ) {
-	if ( statePtr->flags & TCP_ASYNC_PENDING ) {
-
+    if (statePtr->readyEvents & FD_CONNECT) {
+	if (statePtr->flags & TCP_ASYNC_PENDING) {
 	    /*
 	     * Do one step and save eventual connect error
 	     */
 
 	    SetEvent(tsdPtr->socketListLock);
 	    WaitForConnect(statePtr,NULL);
-
 	} else {
-
 	    /*
 	     * No async connect reenter pending. Just clear event.
 	     */
 
-	    statePtr->readyEvents &= ~(FD_CONNECT);
+	    CLEAR_BITS(statePtr->readyEvents, FD_CONNECT);
 	    SetEvent(tsdPtr->socketListLock);
 	}
 	return 1;
@@ -2672,20 +2792,23 @@ SocketEventProc(
     /*
      * Handle connection requests directly.
      */
+
     if (statePtr->readyEvents & FD_ACCEPT) {
 	for (fds = statePtr->sockets; fds != NULL; fds = fds->next) {
-
 	    /*
-	    * Accept the incoming connection request.
-	    */
-	    len = sizeof(address);
+             * Accept the incoming connection request.
+             */
 
+	    len = sizeof(address);
 	    newSocket = accept(fds->fd, &(addr.sa), &len);
 
-	    /* On Tcl server sockets with multiple OS fds we loop over the fds trying
-	     * an accept() on each, so we expect INVALID_SOCKET.  There are also other
-	     * network stack conditions that can result in FD_ACCEPT but a subsequent
-	     * failure on accept() by the time we get around to it.
+	    /*
+             * On Tcl server sockets with multiple OS fds we loop over the fds
+	     * trying an accept() on each, so we expect INVALID_SOCKET.  There
+	     * are also other network stack conditions that can result in
+	     * FD_ACCEPT but a subsequent failure on accept() by the time we
+	     * get around to it.
+             *
 	     * Access to sockets (acceptEventCount, readyEvents) in socketList
 	     * is still protected by the lock (prevents reintroduction of
 	     * SF Tcl Bug 3056775.
@@ -2697,35 +2820,40 @@ SocketEventProc(
 	    }
 
 	    /*
-	     * It is possible that more than one FD_ACCEPT has been sent, so an extra
-	     * count must be kept. Decrement the count, and reset the readyEvent bit
-	     * if the count is no longer > 0.
+	     * It is possible that more than one FD_ACCEPT has been sent, so
+	     * an extra count must be kept. Decrement the count, and reset the
+	     * readyEvent bit if the count is no longer > 0.
 	     */
+
 	    statePtr->acceptEventCount--;
 
 	    if (statePtr->acceptEventCount <= 0) {
-		statePtr->readyEvents &= ~(FD_ACCEPT);
+		CLEAR_BITS(statePtr->readyEvents, FD_ACCEPT);
 	    }
 
 	    SetEvent(tsdPtr->socketListLock);
 
-	    /* Caution: TcpAccept() has the side-effect of evaluating the server
-	     * accept script (via AcceptCallbackProc() in tclIOCmd.c), which can
-	     * close the server socket and invalidate statePtr and fds.
-	     * If TcpAccept() accepts a socket we must return immediately and let
-	     * SocketCheckProc queue additional FD_ACCEPT events.
+	    /*
+             * Caution: TcpAccept() has the side-effect of evaluating the
+	     * server accept script (via AcceptCallbackProc() in tclIOCmd.c),
+	     * which can close the server socket and invalidate statePtr and
+	     * fds. If TcpAccept() accepts a socket we must return immediately
+	     * and let SocketCheckProc queue additional FD_ACCEPT events.
 	     */
+
 	    TcpAccept(fds, newSocket, addr);
 	    return 1;
 	}
 
-	/* Loop terminated with no sockets accepted; clear the ready mask so
+	/*
+         * Loop terminated with no sockets accepted; clear the ready mask so
 	 * we can detect the next connection request. Note that connection
 	 * requests are level triggered, so if there is a request already
 	 * pending, a new event will be generated.
 	 */
+
 	statePtr->acceptEventCount = 0;
-	statePtr->readyEvents &= ~(FD_ACCEPT);
+	CLEAR_BITS(statePtr->readyEvents, FD_ACCEPT);
 
 	SetEvent(tsdPtr->socketListLock);
 	return 1;
@@ -2754,16 +2882,15 @@ SocketEventProc(
 	Tcl_Time blockTime = { 0, 0 };
 
 	Tcl_SetMaxBlockTime(&blockTime);
-	mask |= TCL_READABLE|TCL_WRITABLE;
+	SET_BITS(mask, TCL_READABLE | TCL_WRITABLE);
     } else if (events & FD_READ) {
 
 	/*
 	 * Throw the readable event if an async connect failed.
 	 */
 
-	if ( statePtr->flags & TCP_ASYNC_FAILED ) {
-
-	    mask |= TCL_READABLE;
+	if (statePtr->flags & TCP_ASYNC_FAILED) {
+	    SET_BITS(mask, TCL_READABLE);
 
 	} else {
 	    fd_set readFds;
@@ -2786,9 +2913,9 @@ SocketEventProc(
 	    timeout.tv_sec = 0;
 
 	    if (select(0, &readFds, NULL, NULL, &timeout) != 0) {
-		mask |= TCL_READABLE;
+		SET_BITS(mask, TCL_READABLE);
 	    } else {
-		statePtr->readyEvents &= ~(FD_READ);
+		CLEAR_BITS(statePtr->readyEvents, FD_READ);
 		SendMessage(tsdPtr->hwnd, SOCKET_SELECT,
 			(WPARAM) SELECT, (LPARAM) statePtr);
 	    }
@@ -2800,7 +2927,7 @@ SocketEventProc(
      */
 
     if (events & FD_WRITE) {
-	mask |= TCL_WRITABLE;
+	SET_BITS(mask, TCL_WRITABLE);
     }
 
     /*
@@ -2837,13 +2964,19 @@ AddSocketInfoFd(
 {
     TcpFdList *fds = statePtr->sockets;
 
-    if ( fds == NULL ) {
-	/* Add the first FD */
+    if (fds == NULL) {
+	/*
+         * Add the first FD.
+         */
+
 	statePtr->sockets = ckalloc(sizeof(TcpFdList));
 	fds = statePtr->sockets;
     } else {
-	/* Find end of list and append FD */
-	while ( fds->next != NULL ) {
+	/*
+         * Find end of list and append FD.
+         */
+
+	while (fds->next != NULL) {
 	    fds = fds->next;
 	}
 
@@ -2851,7 +2984,10 @@ AddSocketInfoFd(
 	fds = fds->next;
     }
 
-    /* Populate new FD */
+    /*
+     * Populate new FD.
+     */
+
     fds->fd = socket;
     fds->statePtr = statePtr;
     fds->next = NULL;
@@ -2921,6 +3057,7 @@ WaitForSocketEvent(
     int result = 1;
     int oldMode;
     ThreadSpecificData *tsdPtr = TclThreadDataKeyGet(&dataKey);
+
     /*
      * Be sure to disable event servicing so we are truly modal.
      */
@@ -2939,21 +3076,36 @@ WaitForSocketEvent(
     while (1) {
 	int event_found;
 
-	/* get statePtr lock */
+	/*
+         * Get statePtr lock.
+         */
+
 	WaitForSingleObject(tsdPtr->socketListLock, INFINITE);
 
-	/* Check if event occured */
+	/*
+         * Check if event occured.
+         */
+
 	event_found = (statePtr->readyEvents & events);
 
-	/* Free list lock */
+	/*
+         * Free list lock.
+         */
+
 	SetEvent(tsdPtr->socketListLock);
 
-	/* exit loop if event occured */
+	/*
+         * Exit loop if event occured.
+         */
+
 	if (event_found) {
 	    break;
 	}
 
-	/* Exit loop if event did not occur but this is a non-blocking channel */
+	/*
+         * Exit loop if event did not occur but this is a non-blocking channel
+         */
+
 	if (statePtr->flags & TCP_NONBLOCKING) {
 	    *errorCodePtr = EWOULDBLOCK;
 	    result = 0;
@@ -3110,34 +3262,34 @@ SocketProc(
 
 	for (statePtr = tsdPtr->socketList; statePtr != NULL;
 		statePtr = statePtr->nextPtr) {
-	    if ( FindFDInList(statePtr,socket) ) {
+	    if (FindFDInList(statePtr, socket)) {
 		info_found = 1;
 		break;
 	    }
 	}
+
 	/*
-	 * Check if there is a pending info structure not jet in the
-	 * list
+	 * Check if there is a pending info structure not jet in the list.
 	 */
-	if ( !info_found
+
+	if (!info_found
 		&& tsdPtr->pendingTcpState != NULL
-		&& FindFDInList(tsdPtr->pendingTcpState,socket) ) {
+		&& FindFDInList(tsdPtr->pendingTcpState, socket)) {
 	    statePtr = tsdPtr->pendingTcpState;
 	    info_found = 1;
 	}
 	if (info_found) {
-
 	    /*
 	     * Update the socket state.
 	     *
 	     * A count of FD_ACCEPTS is stored, so if an FD_CLOSE event
-	     * happens, then clear the FD_ACCEPT count. Otherwise,
-	     * increment the count if the current event is an FD_ACCEPT.
+	     * happens, then clear the FD_ACCEPT count. Otherwise, increment
+	     * the count if the current event is an FD_ACCEPT.
 	     */
 
 	    if (event & FD_CLOSE) {
 		statePtr->acceptEventCount = 0;
-		statePtr->readyEvents &= ~(FD_WRITE|FD_ACCEPT);
+		CLEAR_BITS(statePtr->readyEvents, FD_WRITE | FD_ACCEPT);
 	    } else if (event & FD_ACCEPT) {
 		statePtr->acceptEventCount++;
 	    }
@@ -3147,18 +3299,22 @@ SocketProc(
 		 * Remember any error that occurred so we can report
 		 * connection failures.
 		 */
+
 		if (error != ERROR_SUCCESS) {
 		    statePtr->notifierConnectError = error;
 		}
 	    }
+
 	    /*
 	     * Inform main thread about signaled events
 	     */
-	    statePtr->readyEvents |= event;
+
+	    SET_BITS(statePtr->readyEvents, event);
 
 	    /*
 	     * Wake up the Main Thread.
 	     */
+
 	    SetEvent(tsdPtr->readyEvent);
 	    Tcl_ThreadAlert(tsdPtr->threadId);
 	}