MINOR: Formatting fixes, mainly to comments, so code better fits the style in

the Engineering Manual.

1 files changed, 72 insertions, 63 deletions

diff --git a/unix/tclUnixNotfy.c b/unix/tclUnixNotfy.c
index 0075d9d..7dcfc7d 100644
--- a/unix/tclUnixNotfy.c
+++ b/unix/tclUnixNotfy.c
@@ -51,13 +51,13 @@ typedef struct FileHandlerEvent {
 
 /*
  * The following structure contains a set of select() masks to track readable,
- * writable, and exceptional conditions.
+ * writable, and exception conditions.
  */
 
 typedef struct SelectMasks {
     fd_set readable;
     fd_set writable;
-    fd_set exceptional;
+    fd_set exception;
 } SelectMasks;
 
 /*
@@ -170,16 +170,16 @@ static Tcl_Condition notifierCV;
 
 static Tcl_ThreadId notifierThread;
 
-#endif
+#endif /* TCL_THREADS */
 
 /*
  * Static routines defined in this file.
  */
 
 #ifdef TCL_THREADS
-static void	NotifierThreadProc(ClientData clientData);
+static void		NotifierThreadProc(ClientData clientData);
 #endif
-static int	FileHandlerEventProc(Tcl_Event *evPtr, int flags);
+static int		FileHandlerEventProc(Tcl_Event *evPtr, int flags);
 
 /*
  *----------------------------------------------------------------------
@@ -204,6 +204,7 @@ Tcl_InitNotifier(void)
 	return tclNotifierHooks.initNotifierProc();
     } else {
 	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
 #ifdef TCL_THREADS
 	tsdPtr->eventReady = 0;
 
@@ -229,7 +230,7 @@ Tcl_InitNotifier(void)
 	}
 
 	Tcl_MutexUnlock(&notifierMutex);
-#endif
+#endif /* TCL_THREADS */
 	return tsdPtr;
     }
 }
@@ -275,7 +276,8 @@ Tcl_FinalizeNotifier(
 	    int result;
 
 	    if (triggerPipe < 0) {
-		Tcl_Panic("Tcl_FinalizeNotifier: notifier pipe not initialized");
+		Tcl_Panic("Tcl_FinalizeNotifier: %s",
+			"notifier pipe not initialized");
 	    }
 
 	    /*
@@ -290,7 +292,8 @@ Tcl_FinalizeNotifier(
 	     */
 
 	    if (write(triggerPipe, "q", 1) != 1) {
-			Tcl_Panic("Tcl_FinalizeNotifier: unable to write q to triggerPipe");
+		Tcl_Panic("Tcl_FinalizeNotifier: %s",
+			"unable to write q to triggerPipe");
 	    }
 	    close(triggerPipe);
 	    while(triggerPipe >= 0) {
@@ -299,7 +302,8 @@ Tcl_FinalizeNotifier(
 
 	    result = Tcl_JoinThread(notifierThread, NULL);
 	    if (result) {
-		Tcl_Panic("Tcl_FinalizeNotifier: unable to join notifier thread");
+		Tcl_Panic("Tcl_FinalizeNotifier: %s",
+			"unable to join notifier thread");
 	    }
 	}
 
@@ -307,10 +311,10 @@ Tcl_FinalizeNotifier(
 	 * Clean up any synchronization objects in the thread local storage.
 	 */
 
-	Tcl_ConditionFinalize(&(tsdPtr->waitCV));
+	Tcl_ConditionFinalize(&tsdPtr->waitCV);
 
 	Tcl_MutexUnlock(&notifierMutex);
-#endif
+#endif /* TCL_THREADS */
     }
 }
 
@@ -348,7 +352,7 @@ Tcl_AlertNotifier(
 	tsdPtr->eventReady = 1;
 	Tcl_ConditionNotify(&tsdPtr->waitCV);
 	Tcl_MutexUnlock(&notifierMutex);
-#endif
+#endif /* TCL_THREADS */
     }
 }
 
@@ -456,7 +460,7 @@ Tcl_CreateFileHandler(
 	    }
 	}
 	if (filePtr == NULL) {
-	    filePtr = (FileHandler*) ckalloc(sizeof(FileHandler));
+	    filePtr = (FileHandler *) ckalloc(sizeof(FileHandler));
 	    filePtr->fd = fd;
 	    filePtr->readyMask = 0;
 	    filePtr->nextPtr = tsdPtr->firstFileHandlerPtr;
@@ -471,19 +475,19 @@ Tcl_CreateFileHandler(
 	 */
 
 	if (mask & TCL_READABLE) {
-	    FD_SET(fd, &(tsdPtr->checkMasks.readable));
+	    FD_SET(fd, &tsdPtr->checkMasks.readable);
 	} else {
-	    FD_CLR(fd, &(tsdPtr->checkMasks.readable));
+	    FD_CLR(fd, &tsdPtr->checkMasks.readable);
 	}
 	if (mask & TCL_WRITABLE) {
-	    FD_SET(fd, &(tsdPtr->checkMasks.writable));
+	    FD_SET(fd, &tsdPtr->checkMasks.writable);
 	} else {
-	    FD_CLR(fd, &(tsdPtr->checkMasks.writable));
+	    FD_CLR(fd, &tsdPtr->checkMasks.writable);
 	}
 	if (mask & TCL_EXCEPTION) {
-	    FD_SET(fd, &(tsdPtr->checkMasks.exceptional));
+	    FD_SET(fd, &tsdPtr->checkMasks.exception);
 	} else {
-	    FD_CLR(fd, &(tsdPtr->checkMasks.exceptional));
+	    FD_CLR(fd, &tsdPtr->checkMasks.exception);
 	}
 	if (tsdPtr->numFdBits <= fd) {
 	    tsdPtr->numFdBits = fd+1;
@@ -525,7 +529,7 @@ Tcl_DeleteFileHandler(
 	 */
 
 	for (prevPtr = NULL, filePtr = tsdPtr->firstFileHandlerPtr; ;
-	     prevPtr = filePtr, filePtr = filePtr->nextPtr) {
+		prevPtr = filePtr, filePtr = filePtr->nextPtr) {
 	    if (filePtr == NULL) {
 		return;
 	    }
@@ -539,13 +543,13 @@ Tcl_DeleteFileHandler(
 	 */
 
 	if (filePtr->mask & TCL_READABLE) {
-	    FD_CLR(fd, &(tsdPtr->checkMasks.readable));
+	    FD_CLR(fd, &tsdPtr->checkMasks.readable);
 	}
 	if (filePtr->mask & TCL_WRITABLE) {
-	    FD_CLR(fd, &(tsdPtr->checkMasks.writable));
+	    FD_CLR(fd, &tsdPtr->checkMasks.writable);
 	}
 	if (filePtr->mask & TCL_EXCEPTION) {
-	    FD_CLR(fd, &(tsdPtr->checkMasks.exceptional));
+	    FD_CLR(fd, &tsdPtr->checkMasks.exception);
 	}
 
 	/*
@@ -556,9 +560,9 @@ Tcl_DeleteFileHandler(
 	    int numFdBits = 0;
 
 	    for (i = fd-1; i >= 0; i--) {
-		if (FD_ISSET(i, &(tsdPtr->checkMasks.readable))
-			|| FD_ISSET(i, &(tsdPtr->checkMasks.writable))
-			|| FD_ISSET(i, &(tsdPtr->checkMasks.exceptional))) {
+		if (FD_ISSET(i, &tsdPtr->checkMasks.readable)
+			|| FD_ISSET(i, &tsdPtr->checkMasks.writable)
+			|| FD_ISSET(i, &tsdPtr->checkMasks.exception)) {
 		    numFdBits = i+1;
 		    break;
 		}
@@ -678,7 +682,6 @@ Tcl_WaitForEvent(
 	return tclNotifierHooks.waitForEventProc(timePtr);
     } else {
 	FileHandler *filePtr;
-	FileHandlerEvent *fileEvPtr;
 	int mask;
 	Tcl_Time vTime;
 #ifdef TCL_THREADS
@@ -750,7 +753,7 @@ Tcl_WaitForEvent(
 		 * poll. [Bug 1457797]
 		 */
 		|| timePtr->usec < 10
-#endif
+#endif /* __APPLE__ && __LP64__ */
 		)) {
 	    /*
 	     * Cannot emulate a polling select with a polling condition
@@ -784,13 +787,14 @@ Tcl_WaitForEvent(
 	    tsdPtr->onList = 1;
 
 	    if (write(triggerPipe, "", 1) != 1) {
-			Tcl_Panic("Tcl_WaitForEvent: unable to write to triggerPipe");
+		Tcl_Panic("Tcl_WaitForEvent: %s",
+			"unable to write to triggerPipe");
 	    }
 	}
 
-	FD_ZERO(&(tsdPtr->readyMasks.readable));
-	FD_ZERO(&(tsdPtr->readyMasks.writable));
-	FD_ZERO(&(tsdPtr->readyMasks.exceptional));
+	FD_ZERO(&tsdPtr->readyMasks.readable);
+	FD_ZERO(&tsdPtr->readyMasks.writable);
+	FD_ZERO(&tsdPtr->readyMasks.exception);
 
 	if (!tsdPtr->eventReady) {
 	    Tcl_ConditionWait(&tsdPtr->waitCV, &notifierMutex, timePtr);
@@ -816,15 +820,16 @@ Tcl_WaitForEvent(
 	    tsdPtr->nextPtr = tsdPtr->prevPtr = NULL;
 	    tsdPtr->onList = 0;
 	    if (write(triggerPipe, "", 1) != 1) {
-			Tcl_Panic("Tcl_WaitForEvent: unable to write to triggerPipe");
+		Tcl_Panic("Tcl_WaitForEvent: %s",
+			"unable to write to triggerPipe");
 	    }
 	}
 
 #else
 	tsdPtr->readyMasks = tsdPtr->checkMasks;
-	numFound = select(tsdPtr->numFdBits, &(tsdPtr->readyMasks.readable),
-		&(tsdPtr->readyMasks.writable),
-		&(tsdPtr->readyMasks.exceptional), timeoutPtr);
+	numFound = select(tsdPtr->numFdBits, &tsdPtr->readyMasks.readable,
+		&tsdPtr->readyMasks.writable, &tsdPtr->readyMasks.exception,
+		timeoutPtr);
 
 	/*
 	 * Some systems don't clear the masks after an error, so we have to do
@@ -832,9 +837,9 @@ Tcl_WaitForEvent(
 	 */
 
 	if (numFound == -1) {
-	    FD_ZERO(&(tsdPtr->readyMasks.readable));
-	    FD_ZERO(&(tsdPtr->readyMasks.writable));
-	    FD_ZERO(&(tsdPtr->readyMasks.exceptional));
+	    FD_ZERO(&tsdPtr->readyMasks.readable);
+	    FD_ZERO(&tsdPtr->readyMasks.writable);
+	    FD_ZERO(&tsdPtr->readyMasks.exception);
 	}
 #endif /* TCL_THREADS */
 
@@ -844,15 +849,14 @@ Tcl_WaitForEvent(
 
 	for (filePtr = tsdPtr->firstFileHandlerPtr; (filePtr != NULL);
 		filePtr = filePtr->nextPtr) {
-
 	    mask = 0;
-	    if (FD_ISSET(filePtr->fd, &(tsdPtr->readyMasks.readable))) {
+	    if (FD_ISSET(filePtr->fd, &tsdPtr->readyMasks.readable)) {
 		mask |= TCL_READABLE;
 	    }
-	    if (FD_ISSET(filePtr->fd, &(tsdPtr->readyMasks.writable))) {
+	    if (FD_ISSET(filePtr->fd, &tsdPtr->readyMasks.writable)) {
 		mask |= TCL_WRITABLE;
 	    }
-	    if (FD_ISSET(filePtr->fd, &(tsdPtr->readyMasks.exceptional))) {
+	    if (FD_ISSET(filePtr->fd, &tsdPtr->readyMasks.exception)) {
 		mask |= TCL_EXCEPTION;
 	    }
 
@@ -866,8 +870,9 @@ Tcl_WaitForEvent(
 	     */
 
 	    if (filePtr->readyMask == 0) {
-		fileEvPtr = (FileHandlerEvent *)
+		FileHandlerEvent *fileEvPtr = (FileHandlerEvent *)
 			ckalloc(sizeof(FileHandlerEvent));
+
 		fileEvPtr->header.proc = FileHandlerEventProc;
 		fileEvPtr->fd = filePtr->fd;
 		Tcl_QueueEvent((Tcl_Event *) fileEvPtr, TCL_QUEUE_TAIL);
@@ -913,7 +918,7 @@ NotifierThreadProc(
     ThreadSpecificData *tsdPtr;
     fd_set readableMask;
     fd_set writableMask;
-    fd_set exceptionalMask;
+    fd_set exceptionMask;
     int fds[2];
     int i, numFdBits = 0, receivePipe;
     long found;
@@ -921,22 +926,26 @@ NotifierThreadProc(
     char buf[2];
 
     if (pipe(fds) != 0) {
-	Tcl_Panic("NotifierThreadProc: could not create trigger pipe");
+	Tcl_Panic("NotifierThreadProc: %s", "could not create trigger pipe");
     }
 
     receivePipe = fds[0];
 
     if (TclUnixSetBlockingMode(receivePipe, TCL_MODE_NONBLOCKING) < 0) {
-	Tcl_Panic("NotifierThreadProc: could not make receive pipe non blocking");
+	Tcl_Panic("NotifierThreadProc: %s",
+		"could not make receive pipe non blocking");
     }
     if (TclUnixSetBlockingMode(fds[1], TCL_MODE_NONBLOCKING) < 0) {
-	Tcl_Panic("NotifierThreadProc: could not make trigger pipe non blocking");
+	Tcl_Panic("NotifierThreadProc: %s",
+		"could not make trigger pipe non blocking");
     }
     if (fcntl(receivePipe, F_SETFD, FD_CLOEXEC) < 0) {
-	Tcl_Panic("NotifierThreadProc: could not make receive pipe close-on-exec");
+	Tcl_Panic("NotifierThreadProc: %s",
+		"could not make receive pipe close-on-exec");
     }
     if (fcntl(fds[1], F_SETFD, FD_CLOEXEC) < 0) {
-	Tcl_Panic("NotifierThreadProc: could not make trigger pipe close-on-exec");
+	Tcl_Panic("NotifierThreadProc: %s",
+		"could not make trigger pipe close-on-exec");
     }
 
     /*
@@ -960,7 +969,7 @@ NotifierThreadProc(
     while (1) {
 	FD_ZERO(&readableMask);
 	FD_ZERO(&writableMask);
-	FD_ZERO(&exceptionalMask);
+	FD_ZERO(&exceptionMask);
 
 	/*
 	 * Compute the logical OR of the select masks from all the waiting
@@ -971,14 +980,14 @@ NotifierThreadProc(
 	timePtr = NULL;
 	for (tsdPtr = waitingListPtr; tsdPtr; tsdPtr = tsdPtr->nextPtr) {
 	    for (i = tsdPtr->numFdBits-1; i >= 0; --i) {
-		if (FD_ISSET(i, &(tsdPtr->checkMasks.readable))) {
+		if (FD_ISSET(i, &tsdPtr->checkMasks.readable)) {
 		    FD_SET(i, &readableMask);
 		}
-		if (FD_ISSET(i, &(tsdPtr->checkMasks.writable))) {
+		if (FD_ISSET(i, &tsdPtr->checkMasks.writable)) {
 		    FD_SET(i, &writableMask);
 		}
-		if (FD_ISSET(i, &(tsdPtr->checkMasks.exceptional))) {
-		    FD_SET(i, &exceptionalMask);
+		if (FD_ISSET(i, &tsdPtr->checkMasks.exception)) {
+		    FD_SET(i, &exceptionMask);
 		}
 	    }
 	    if (tsdPtr->numFdBits > numFdBits) {
@@ -1005,7 +1014,7 @@ NotifierThreadProc(
 	}
 	FD_SET(receivePipe, &readableMask);
 
-	if (select(numFdBits, &readableMask, &writableMask, &exceptionalMask,
+	if (select(numFdBits, &readableMask, &writableMask, &exceptionMask,
 		timePtr) == -1) {
 	    /*
 	     * Try again immediately on an error.
@@ -1023,19 +1032,19 @@ NotifierThreadProc(
 	    found = 0;
 
 	    for (i = tsdPtr->numFdBits-1; i >= 0; --i) {
-		if (FD_ISSET(i, &(tsdPtr->checkMasks.readable))
+		if (FD_ISSET(i, &tsdPtr->checkMasks.readable)
 			&& FD_ISSET(i, &readableMask)) {
-		    FD_SET(i, &(tsdPtr->readyMasks.readable));
+		    FD_SET(i, &tsdPtr->readyMasks.readable);
 		    found = 1;
 		}
-		if (FD_ISSET(i, &(tsdPtr->checkMasks.writable))
+		if (FD_ISSET(i, &tsdPtr->checkMasks.writable)
 			&& FD_ISSET(i, &writableMask)) {
-		    FD_SET(i, &(tsdPtr->readyMasks.writable));
+		    FD_SET(i, &tsdPtr->readyMasks.writable);
 		    found = 1;
 		}
-		if (FD_ISSET(i, &(tsdPtr->checkMasks.exceptional))
+		if (FD_ISSET(i, &tsdPtr->checkMasks.exception)
 			&& FD_ISSET(i, &exceptionalMask)) {
-		    FD_SET(i, &(tsdPtr->readyMasks.exceptional));
+		    FD_SET(i, &tsdPtr->readyMasks.exception);
 		    found = 1;
 		}
 	    }
@@ -1099,7 +1108,7 @@ NotifierThreadProc(
     Tcl_ConditionNotify(&notifierCV);
     Tcl_MutexUnlock(&notifierMutex);
 
-    TclpThreadExit (0);
+    TclpThreadExit(0);
 }
 #endif /* TCL_THREADS */