Rewrite for style and clarity (esp. tclPkg.c)

1 files changed, 275 insertions, 231 deletions

diff --git a/generic/tclIO.c b/generic/tclIO.c
index 689447b..9016cef 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -10,7 +10,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclIO.c,v 1.109 2006/09/28 19:24:52 msofer Exp $
+ * RCS: @(#) $Id: tclIO.c,v 1.110 2006/11/08 11:41:44 dkf Exp $
  */
 
 #include "tclInt.h"
@@ -120,7 +120,7 @@ static int		WriteBytes(Channel *chanPtr, CONST char *src,
 			    int srcLen);
 static int		WriteChars(Channel *chanPtr, CONST char *src,
 			    int srcLen);
-static Tcl_Obj *	FixLevelCode(Tcl_Obj* msg);
+static Tcl_Obj *	FixLevelCode(Tcl_Obj *msg);
 static void		SpliceChannel(Tcl_Channel chan);
 static void		CutChannel(Tcl_Channel chan);
 
@@ -177,7 +177,7 @@ TclFinalizeIOSubsystem(void)
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
     Channel *chanPtr;		/* Iterates over open channels. */
     ChannelState *nextCSPtr;	/* Iterates over open channels. */
-    ChannelState *statePtr;	/* state of channel stack */
+    ChannelState *statePtr;	/* State of channel stack */
 
     /*
      * Walk all channel state structures known to this thread and
@@ -211,6 +211,7 @@ TclFinalizeIOSubsystem(void)
 	 * Preserve statePtr from disappearing until we can get the
 	 * nextCSPtr below.
 	 */
+
 	Tcl_Preserve(statePtr);
 	if (statePtr->refCount <= 0) {
 	    /*
@@ -248,10 +249,12 @@ TclFinalizeIOSubsystem(void)
 	    chanPtr->instanceData = NULL;
 	    statePtr->flags |= CHANNEL_DEAD;
 	}
+
 	/*
 	 * We look for the next pointer now in case we had one closed on up
 	 * during the current channel's closeproc (eg: rechan extension)
 	 */
+
 	nextCSPtr = statePtr->nextCSPtr;
 	Tcl_Release(statePtr);
     }
@@ -343,7 +346,7 @@ Tcl_GetStdChannel(
 	     */
 
 	    if (tsdPtr->stdinChannel != NULL) {
-		(void) Tcl_RegisterChannel(NULL, tsdPtr->stdinChannel);
+		Tcl_RegisterChannel(NULL, tsdPtr->stdinChannel);
 	    }
 	}
 	channel = tsdPtr->stdinChannel;
@@ -353,7 +356,7 @@ Tcl_GetStdChannel(
 	    tsdPtr->stdoutChannel = TclpGetDefaultStdChannel(TCL_STDOUT);
 	    tsdPtr->stdoutInitialized = 1;
 	    if (tsdPtr->stdoutChannel != NULL) {
-		(void) Tcl_RegisterChannel(NULL, tsdPtr->stdoutChannel);
+		Tcl_RegisterChannel(NULL, tsdPtr->stdoutChannel);
 	    }
 	}
 	channel = tsdPtr->stdoutChannel;
@@ -363,7 +366,7 @@ Tcl_GetStdChannel(
 	    tsdPtr->stderrChannel = TclpGetDefaultStdChannel(TCL_STDERR);
 	    tsdPtr->stderrInitialized = 1;
 	    if (tsdPtr->stderrChannel != NULL) {
-		(void) Tcl_RegisterChannel(NULL, tsdPtr->stderrChannel);
+		Tcl_RegisterChannel(NULL, tsdPtr->stderrChannel);
 	    }
 	}
 	channel = tsdPtr->stderrChannel;
@@ -483,14 +486,12 @@ GetChannelTable(
     Tcl_HashTable *hTblPtr;	/* Hash table of channels. */
     Tcl_Channel stdinChan, stdoutChan, stderrChan;
 
-    hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
+    hTblPtr = Tcl_GetAssocData(interp, "tclIO", NULL);
     if (hTblPtr == NULL) {
 	hTblPtr = (Tcl_HashTable *) ckalloc(sizeof(Tcl_HashTable));
 	Tcl_InitHashTable(hTblPtr, TCL_STRING_KEYS);
-
-	(void) Tcl_SetAssocData(interp, "tclIO",
-		(Tcl_InterpDeleteProc *) DeleteChannelTable,
-		(ClientData) hTblPtr);
+	Tcl_SetAssocData(interp, "tclIO",
+		(Tcl_InterpDeleteProc *) DeleteChannelTable, hTblPtr);
 
 	/*
 	 * If the interpreter is trusted (not "safe"), insert channels for
@@ -929,7 +930,7 @@ DetachChannel(
     statePtr = chanPtr->state;
 
     if (interp != NULL) {
-	hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
+	hTblPtr = Tcl_GetAssocData(interp, "tclIO", NULL);
 	if (hTblPtr == NULL) {
 	    return TCL_ERROR;
 	}
@@ -1100,6 +1101,7 @@ Tcl_CreateChannel(
 
     if (chanName != NULL) {
 	char *tmp = ckalloc((unsigned) (strlen(chanName) + 1));
+
 	statePtr->channelName = tmp;
 	strcpy(tmp, chanName);
     } else {
@@ -1332,6 +1334,7 @@ Tcl_StackChannel(
 
 	statePtr->csPtr = csPtr;
     }
+
     /*
      * Discard any input in the buffers. They are not yet read by the user of
      * the channel, so they have to go through the new transformation before
@@ -1468,6 +1471,7 @@ Tcl_UnstackChannel(
 
 	    if (Tcl_Flush((Tcl_Channel) chanPtr) != TCL_OK) {
 		statePtr->csPtr = csPtr;
+
 		/*
 		 * TIP #219, Tcl Channel Reflection API.
 		 * Move error messages put by the driver into the chan/ip
@@ -1475,6 +1479,7 @@ Tcl_UnstackChannel(
 		 * to the regular message if nothing was found in the
 		 * bypasses.
 		 */
+
 		if (!TclChanCaughtErrorBypass(interp, chan) && interp) {
 		    Tcl_AppendResult(interp, "could not flush channel \"",
 			    Tcl_GetChannelName((Tcl_Channel) chanPtr), "\"",
@@ -1627,7 +1632,8 @@ Tcl_Channel
 Tcl_GetStackedChannel(
     Tcl_Channel chan)
 {
-    Channel *chanPtr = (Channel *) chan;	/* The actual channel. */
+    Channel *chanPtr = (Channel *) chan;
+				/* The actual channel. */
 
     return (Tcl_Channel) chanPtr->downChanPtr;
 }
@@ -1654,7 +1660,8 @@ Tcl_Channel
 Tcl_GetTopChannel(
     Tcl_Channel chan)
 {
-    Channel *chanPtr = (Channel *) chan;	/* The actual channel. */
+    Channel *chanPtr = (Channel *) chan;
+				/* The actual channel. */
 
     return (Tcl_Channel) chanPtr->state->topChanPtr;
 }
@@ -1679,7 +1686,8 @@ ClientData
 Tcl_GetChannelInstanceData(
     Tcl_Channel chan)		/* Channel for which to return client data. */
 {
-    Channel *chanPtr = (Channel *) chan;	/* The actual channel. */
+    Channel *chanPtr = (Channel *) chan;
+				/* The actual channel. */
 
     return chanPtr->instanceData;
 }
@@ -1705,7 +1713,8 @@ Tcl_GetChannelThread(
     Tcl_Channel chan)		/* The channel to return the managing thread
 				 * for. */
 {
-    Channel *chanPtr = (Channel *) chan;	/* The actual channel. */
+    Channel *chanPtr = (Channel *) chan;
+				/* The actual channel. */
 
     return chanPtr->state->managingThread;
 }
@@ -2081,10 +2090,11 @@ FlushChannel(
 	 */
 
 	if (((statePtr->curOutPtr != NULL) &&
-		(statePtr->curOutPtr->nextAdded == statePtr->curOutPtr->bufLength))
+		(statePtr->curOutPtr->nextAdded
+			== statePtr->curOutPtr->bufLength))
 		|| ((statePtr->flags & BUFFER_READY) &&
 			(statePtr->outQueueHead == NULL))) {
-	    statePtr->flags &= (~(BUFFER_READY));
+	    statePtr->flags &= ~BUFFER_READY;
 	    statePtr->curOutPtr->nextPtr = NULL;
 	    if (statePtr->outQueueHead == NULL) {
 		statePtr->outQueueHead = statePtr->curOutPtr;
@@ -2175,7 +2185,7 @@ FlushChannel(
 
 		if (statePtr->unreportedError == 0) {
 		    statePtr->unreportedError = errorCode;
-		    statePtr->unreportedMsg   = msg;
+		    statePtr->unreportedMsg = msg;
 		    if (msg != NULL) {
 			Tcl_IncrRefCount(msg);
 		    }
@@ -2187,7 +2197,7 @@ FlushChannel(
 
 		    statePtr->chanMsg = NULL;
 		    if (msg != NULL) {
-			Tcl_DecrRefCount(msg);
+			TclDecrRefCount(msg);
 		    }
 		}
 	    } else {
@@ -2199,18 +2209,18 @@ FlushChannel(
 		 */
 
 		Tcl_SetErrno(errorCode);
-		if (interp != NULL) {
-		    if (!TclChanCaughtErrorBypass(interp, (Tcl_Channel) chanPtr)) {
-			/*
-			 * Casting away CONST here is safe because the
-			 * TCL_VOLATILE flag guarantees CONST treatment of the
-			 * Posix error string.
-			 */
+		if (interp != NULL && !TclChanCaughtErrorBypass(interp,
+			(Tcl_Channel) chanPtr)) {
+		    /*
+		     * Casting away CONST here is safe because the
+		     * TCL_VOLATILE flag guarantees CONST treatment of the
+		     * Posix error string.
+		     */
 
-			Tcl_SetResult(interp,
-				(char *) Tcl_PosixError(interp), TCL_VOLATILE);
-		    }
+		    Tcl_SetResult(interp, (char *) Tcl_PosixError(interp),
+			    TCL_VOLATILE);
 		}
+
 		/*
 		 * An unreportable bypassed message is kept, for the caller of
 		 * Tcl_Seek, Tcl_Write, etc.
@@ -2254,7 +2264,7 @@ FlushChannel(
 	if (wroteSome) {
 	    return errorCode;
 	} else if (statePtr->outQueueHead == NULL) {
-	    statePtr->flags &= (~(BG_FLUSH_SCHEDULED));
+	    statePtr->flags &= ~BG_FLUSH_SCHEDULED;
 	    (chanPtr->typePtr->watchProc)(chanPtr->instanceData,
 		    statePtr->interestMask);
 	}
@@ -2360,7 +2370,7 @@ CloseChannel(
 	if (interp != NULL) {
 	    Tcl_SetChannelErrorInterp(interp,statePtr->chanMsg);
 	}
-	Tcl_DecrRefCount(statePtr->chanMsg);
+	TclDecrRefCount(statePtr->chanMsg);
 	statePtr->chanMsg = NULL;
     }
 
@@ -2408,13 +2418,14 @@ CloseChannel(
     if (statePtr->unreportedError != 0) {
 	errorCode = statePtr->unreportedError;
 
-	/* TIP #219, Tcl Channel Reflection API.
+	/*
+	 * TIP #219, Tcl Channel Reflection API.
 	 * Move an error message found in the unreported area into the regular
 	 * bypass (interp). This kills any message in the channel bypass area.
 	 */
 
 	if (statePtr->chanMsg != NULL) {
-	    Tcl_DecrRefCount(statePtr->chanMsg);
+	    TclDecrRefCount(statePtr->chanMsg);
 	    statePtr->chanMsg = NULL;
 	}
 	if (interp) {
@@ -2502,7 +2513,7 @@ CutChannel(
 				 * states - used to splice a channel out of
 				 * the list on close. */
     ChannelState *statePtr = ((Channel *) chan)->state;
-				/* state of the channel stack. */
+				/* State of the channel stack. */
     Tcl_DriverThreadActionProc *threadActionProc;
 
     /*
@@ -2542,13 +2553,13 @@ Tcl_CutChannel(
     Tcl_Channel chan)		/* The channel being added. Must not be
 				 * referenced in any interpreter. */
 {
-    Channel* chanPtr = ((Channel*) chan)->state->bottomChanPtr;
+    Channel *chanPtr = ((Channel *) chan)->state->bottomChanPtr;
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
     ChannelState *prevCSPtr;	/* Preceding channel state in list of all
 				 * states - used to splice a channel out of
 				 * the list on close. */
     ChannelState *statePtr = chanPtr->state;
-				/* state of the channel stack. */
+				/* State of the channel stack. */
     Tcl_DriverThreadActionProc *threadActionProc;
 
     /*
@@ -2779,7 +2790,7 @@ Tcl_Close(
 	    if (interp != NULL) {
 		Tcl_SetChannelErrorInterp(interp,statePtr->chanMsg);
 	    }
-	    Tcl_DecrRefCount(statePtr->chanMsg);
+	    TclDecrRefCount(statePtr->chanMsg);
 	    statePtr->chanMsg = NULL;
 	}
     }
@@ -2836,7 +2847,7 @@ Tcl_Close(
      * them into the regular interpreter result.
      *
      * Notes: Due to the assertion of CHANNEL_CLOSED in the flags
-     * "FlushChannel" has called "CloseChannel" and thus freed all the channel
+     * FlushChannel() has called CloseChannel() and thus freed all the channel
      * structures. We must not try to access "chan" anymore, hence the NULL
      * argument in the call below. The only place which may still contain a
      * message is the interpreter itself, and "CloseChannel" made sure to lift
@@ -2982,7 +2993,7 @@ Tcl_Write(
      */
 
     Channel *chanPtr;
-    ChannelState *statePtr;	/* state info for channel */
+    ChannelState *statePtr;	/* State info for channel */
 
     statePtr = ((Channel *) chan)->state;
     chanPtr = statePtr->topChanPtr;
@@ -3029,7 +3040,8 @@ Tcl_WriteRaw(
 				 * strlen(). */
 {
     Channel *chanPtr = ((Channel *) chan);
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
     int errorCode, written;
 
     if (CheckChannelErrors(statePtr, TCL_WRITABLE | CHANNEL_RAW_MODE) != 0) {
@@ -3086,7 +3098,7 @@ Tcl_WriteChars(
     int len)			/* Length of string in bytes, or < 0 for
 				 * strlen(). */
 {
-    ChannelState *statePtr;	/* state info for channel */
+    ChannelState *statePtr;	/* State info for channel */
 
     statePtr = ((Channel *) chan)->state;
 
@@ -3132,7 +3144,7 @@ DoWriteChars(
      * Always use the topmost channel of the stack
      */
 
-    ChannelState *statePtr;	/* state info for channel */
+    ChannelState *statePtr;	/* State info for channel */
 
     statePtr = chanPtr->state;
     chanPtr = statePtr->topChanPtr;
@@ -3193,7 +3205,7 @@ Tcl_WriteObj(
      */
 
     Channel *chanPtr;
-    ChannelState *statePtr;	/* state info for channel */
+    ChannelState *statePtr;	/* State info for channel */
     char *src;
     int srcLen;
 
@@ -3239,7 +3251,8 @@ WriteBytes(
     CONST char *src,		/* Bytes to write. */
     int srcLen)			/* Number of bytes to write. */
 {
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
     ChannelBuffer *bufPtr;
     char *dst;
     int dstMax, sawLF, savedLF, total, dstLen, toWrite;
@@ -3328,7 +3341,8 @@ WriteChars(
     CONST char *src,		/* UTF-8 string to write. */
     int srcLen)			/* Length of UTF-8 string in bytes. */
 {
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
     ChannelBuffer *bufPtr;
     char *dst, *stage;
     int saved, savedLF, sawLF, total, dstLen, stageMax, dstWrote;
@@ -3413,7 +3427,7 @@ WriteChars(
 		 * that we need to stick at the beginning of this buffer.
 		 */
 
-		memcpy((VOID *) dst, (VOID *) safe, (size_t) saved);
+		memcpy(dst, safe, (size_t) saved);
 		bufPtr->nextAdded += saved;
 		dst += saved;
 		dstLen -= saved;
@@ -3425,7 +3439,8 @@ WriteChars(
 		    &statePtr->outputEncodingState, dst,
 		    dstLen + BUFFER_PADDING, &stageRead, &dstWrote, NULL);
 
-	    /* Fix for SF #506297, reported by Martin Forssen
+	    /*
+	     * Fix for SF #506297, reported by Martin Forssen
 	     * <ruric@users.sourceforge.net>.
 	     *
 	     * The encoding chosen in the script exposing the bug writes out
@@ -3470,7 +3485,7 @@ WriteChars(
 		 */
 
 		saved = bufPtr->nextAdded - bufPtr->bufLength;
-		memcpy((VOID *) safe, (VOID *) (dst + dstLen), (size_t) saved);
+		memcpy(safe, dst + dstLen, (size_t) saved);
 		bufPtr->nextAdded = bufPtr->bufLength;
 	    }
 	    if (CheckFlush(chanPtr, bufPtr, sawLF) != 0) {
@@ -3656,7 +3671,9 @@ CheckFlush(
     int newlineFlag)		/* Non-zero if a the channel buffer contains a
 				 * newline. */
 {
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
+
     /*
      * The current buffer is ready for output:
      * 1. if it is full.
@@ -3755,7 +3772,8 @@ Tcl_GetsObj(
 {
     GetsState gs;
     Channel *chanPtr = (Channel *) chan;
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
     ChannelBuffer *bufPtr;
     int inEofChar, skip, copiedTotal, oldLength, oldFlags, oldRemoved;
     Tcl_Encoding encoding;
@@ -3963,7 +3981,7 @@ Tcl_GetsObj(
 	     */
 
 	    dstEnd = eof;
-	    statePtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
+	    statePtr->flags |= CHANNEL_EOF | CHANNEL_STICKY_EOF;
 	    statePtr->inputEncodingFlags |= TCL_ENCODING_END;
 	}
 	if (statePtr->flags & CHANNEL_EOF) {
@@ -4091,10 +4109,10 @@ FilterInputBytes(
     Channel *chanPtr,		/* Channel to read. */
     GetsState *gsPtr)		/* Current state of gets operation. */
 {
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
     ChannelBuffer *bufPtr;
-    char *raw, *rawStart, *rawEnd;
-    char *dst;
+    char *raw, *rawStart, *rawEnd, *dst;
     int offset, toRead, dstNeeded, spaceLeft, result, rawLen, length;
     Tcl_Obj *objPtr;
 #define ENCODING_LINESIZE   20	/* Lower bound on how many bytes to convert at
@@ -4228,8 +4246,8 @@ FilterInputBytes(
 		statePtr->inQueueTail = nextPtr;
 	    }
 	    extra = rawLen - gsPtr->rawRead;
-	    memcpy((VOID *) (nextPtr->buf + BUFFER_PADDING - extra),
-		    (VOID *) (raw + gsPtr->rawRead), (size_t) extra);
+	    memcpy(nextPtr->buf + BUFFER_PADDING - extra,
+		    raw + gsPtr->rawRead, (size_t) extra);
 	    nextPtr->nextRemoved -= extra;
 	    bufPtr->nextAdded -= extra;
 	}
@@ -4268,7 +4286,8 @@ PeekAhead(
 				 * UTF-8 characters. */
     GetsState *gsPtr)		/* Current state of gets operation. */
 {
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
     ChannelBuffer *bufPtr;
     Tcl_DriverBlockModeProc *blockModeProc;
     int bytesLeft;
@@ -4345,7 +4364,8 @@ CommonGetsCleanup(
     Channel *chanPtr,
     Tcl_Encoding encoding)
 {
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
     ChannelBuffer *bufPtr, *nextPtr;
 
     bufPtr = statePtr->inQueueHead;
@@ -4375,8 +4395,8 @@ CommonGetsCleanup(
 
 	    extra = bufPtr->bufLength - bufPtr->nextAdded;
 	    if (extra > 0) {
-		memcpy((VOID *) (bufPtr->buf + bufPtr->nextAdded),
-			(VOID *) (nextPtr->buf + BUFFER_PADDING - extra),
+		memcpy(bufPtr->buf + bufPtr->nextAdded,
+			nextPtr->buf + BUFFER_PADDING - extra,
 			(size_t) extra);
 		bufPtr->nextAdded += extra;
 		nextPtr->nextRemoved = BUFFER_PADDING;
@@ -4418,7 +4438,8 @@ Tcl_Read(
     int bytesToRead)		/* Maximum number of bytes to read. */
 {
     Channel *chanPtr = (Channel *) chan;
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
 
     /*
      * This operation should occur at the top of a channel stack.
@@ -4462,9 +4483,9 @@ Tcl_ReadRaw(
     int bytesToRead)		/* Maximum number of bytes to read. */
 {
     Channel *chanPtr = (Channel *) chan;
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
-    int nread, result;
-    int copied, copiedNow;
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
+    int nread, result, copied, copiedNow;
 
     /*
      * The check below does too much because it will reject a call to this
@@ -4499,13 +4520,13 @@ Tcl_ReadRaw(
 		if (statePtr->flags & CHANNEL_NONBLOCKING) {
 		    goto done;
 		}
-		statePtr->flags &= (~(CHANNEL_BLOCKED));
+		statePtr->flags &= ~CHANNEL_BLOCKED;
 	    }
 
 #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING
 	    /*
-	     * [SF Tcl Bug 943274]. Better emulation of non-blocking channels
-	     * for channels without BlockModeProc, by keeping track of true
+	     * [Bug 943274]. Better emulation of non-blocking channels for
+	     * channels without BlockModeProc, by keeping track of true
 	     * fileevents generated by the OS == Data waiting and reading if
 	     * and only if we are sure to have data.
 	     */
@@ -4541,11 +4562,10 @@ Tcl_ReadRaw(
 
 	    if (nread > 0) {
 		/*
-		 * If we get a short read, signal up that we may be
-		 * BLOCKED. We should avoid calling the driver because
-		 * on some platforms we will block in the low level
-		 * reading code even though the channel is set into
-		 * nonblocking mode.
+		 * If we get a short read, signal up that we may be BLOCKED.
+		 * We should avoid calling the driver because on some
+		 * platforms we will block in the low level reading code even
+		 * though the channel is set into nonblocking mode.
 		 */
 
 		if (nread < (bytesToRead - copied)) {
@@ -4555,8 +4575,8 @@ Tcl_ReadRaw(
 #ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING
 		if (nread <= (bytesToRead - copied)) {
 		    /*
-		     * [SF Tcl Bug 943274] We have read the available data,
-		     * clear flag.
+		     * [Bug 943274] We have read the available data, clear
+		     * flag.
 		     */
 
 		    statePtr->flags &= ~CHANNEL_HAS_MORE_DATA;
@@ -4629,7 +4649,8 @@ Tcl_ReadChars(
 				 * of the object. */
 {
     Channel *chanPtr = (Channel *) chan;
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
 
     /*
      * This operation should occur at the top of a channel stack.
@@ -4683,7 +4704,8 @@ DoReadChars(
 				 * the data will replace the existing contents
 				 * of the object. */
 {
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
     ChannelBuffer *bufPtr;
     int offset, factor, copied, copiedNow, result;
     Tcl_Encoding encoding;
@@ -5001,40 +5023,38 @@ ReadChars(
      *   multi-byte character at the end (only the first byte of it).
      * - Encoding translation fails, asks for more data
      * - Data is read, and eof is reached, TCL_ENCODING_END (TEE) is set.
-     * - ReadChar is called again, converts the first buffer, but due
-     *   to TEE it does not check for incomplete multi-byte data, and the
-     *   character just after the end of the first buffer is a valid
-     *   completion of the multi-byte header in the actual buffer. The
-     *   conversion reads more characters from the buffer then present.
-     *   This causes nextRemoved to overshoot nextAdded and the next
-     *   reads compute a negative srcLen, cause further translations to
-     *   fail, causing copying of data into the next buffer using bad
-     *   arguments, causing the mecpy for to eventually fail.
+     * - ReadChar is called again, converts the first buffer, but due to TEE
+     *	 it does not check for incomplete multi-byte data, and the character
+     *	 just after the end of the first buffer is a valid completion of the
+     *	 multi-byte header in the actual buffer. The conversion reads more
+     *	 characters from the buffer then present. This causes nextRemoved to
+     *	 overshoot nextAdded and the next reads compute a negative srcLen,
+     *	 cause further translations to fail, causing copying of data into the
+     *	 next buffer using bad arguments, causing the mecpy for to eventually
+     *	 fail.
      *
-     * In the end it is a memory access bug spiraling out of control
-     * if the conditions are _just so_. And ultimate cause is that TEE
-     * is given to a conversion where it should not. TEE signals that
-     * this is the last buffer. Except in our case it is not.
+     * In the end it is a memory access bug spiraling out of control if the
+     * conditions are _just so_. And ultimate cause is that TEE is given to a
+     * conversion where it should not. TEE signals that this is the last
+     * buffer. Except in our case it is not.
      *
-     * My solution is to suppress TEE if the first buffer is not the
-     * last. We will eventually need it given that EOF has been
-     * reached, but not right now. This is what the new flag
-     * "endEncSuppressFlag" is for.
+     * My solution is to suppress TEE if the first buffer is not the last. We
+     * will eventually need it given that EOF has been reached, but not right
+     * now. This is what the new flag "endEncSuppressFlag" is for.
      *
-     * The bug in 'Tcl_Utf2UtfProc' where it read from memory behind
-     * the actual buffer has been fixed as well, and fixes the problem
-     * with the crash too, but this would still allow the generic
-     * layer to accidentially break a multi-byte sequence if the
-     * conditions are just right, because again the ExternalToUtf
-     * would be successful where it should not.
+     * The bug in 'Tcl_Utf2UtfProc' where it read from memory behind the
+     * actual buffer has been fixed as well, and fixes the problem with the
+     * crash too, but this would still allow the generic layer to
+     * accidentially break a multi-byte sequence if the conditions are just
+     * right, because again the ExternalToUtf would be successful where it
+     * should not.
      */
 
     if ((statePtr->inputEncodingFlags & TCL_ENCODING_END) &&
-	(bufPtr->nextPtr != NULL)) {
-
-        /* TEE is set for a buffer which is not the last. Squash it
-	 * for now, and restore it later, before yielding control to
-	 * our caller.
+	    (bufPtr->nextPtr != NULL)) {
+        /*
+	 * TEE is set for a buffer which is not the last. Squash it for now,
+	 * and restore it later, before yielding control to our caller.
 	 */
 
         statePtr->inputEncodingFlags &= ~TCL_ENCODING_END;
@@ -5096,9 +5116,7 @@ ReadChars(
 		/*
 		 * There isn't enough data in the buffers to complete the next
 		 * character, so we need to wait for more data before the next
-		 * file event can be delivered.
-		 *
-		 * SF #478856.
+		 * file event can be delivered. [Bug 478856]
 		 *
 		 * The exception to this is if the input buffer was completely
 		 * empty before we tried to convert its contents. Nothing in,
@@ -5111,25 +5129,25 @@ ReadChars(
 	    return -1;
 	}
 
-	/* Space is made at the beginning of the buffer to copy the
-	 * previous unused bytes there. Check first if the buffer we
-	 * are using actually has enough space at its beginning for
-	 * the data we are copying. Because if not we will write over the
-	 * buffer management information, especially the 'nextPtr'.
+	/*
+	 * Space is made at the beginning of the buffer to copy the previous
+	 * unused bytes there. Check first if the buffer we are using actually
+	 * has enough space at its beginning for the data we are copying.
+	 * Because if not we will write over the buffer management
+	 * information, especially the 'nextPtr'.
 	 *
-	 * Note that the BUFFER_PADDING (See AllocChannelBuffer) is
-	 * used to prevent exactly this situation. I.e. it should
-	 * never happen. Therefore it is ok to panic should it happen
-	 * despite the precautions.
+	 * Note that the BUFFER_PADDING (See AllocChannelBuffer) is used to
+	 * prevent exactly this situation. I.e. it should never happen.
+	 * Therefore it is ok to panic should it happen despite the
+	 * precautions.
 	 */
 
 	if (nextPtr->nextRemoved - srcLen < 0) {
-	    Tcl_Panic ("Buffer Underflow, BUFFER_PADDING not enough");
+	    Tcl_Panic("Buffer Underflow, BUFFER_PADDING not enough");
 	}
 
 	nextPtr->nextRemoved -= srcLen;
-	memcpy((VOID *) (nextPtr->buf + nextPtr->nextRemoved), (VOID *) src,
-		(size_t) srcLen);
+	memcpy(nextPtr->buf + nextPtr->nextRemoved, src, (size_t) srcLen);
 	RecycleBuffer(statePtr, bufPtr, 0);
 	statePtr->inQueueHead = nextPtr;
 	return ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr);
@@ -5255,7 +5273,7 @@ TranslateInputEOL(
     switch (statePtr->inputTranslation) {
     case TCL_TRANSLATE_LF:
 	if (dstStart != srcStart) {
-	    memcpy((VOID *) dstStart, (VOID *) srcStart, (size_t) dstLen);
+	    memcpy(dstStart, srcStart, (size_t) dstLen);
 	}
 	srcLen = dstLen;
 	break;
@@ -5263,7 +5281,7 @@ TranslateInputEOL(
 	char *dst, *dstEnd;
 
 	if (dstStart != srcStart) {
-	    memcpy((VOID *) dstStart, (VOID *) srcStart, (size_t) dstLen);
+	    memcpy(dstStart, srcStart, (size_t) dstLen);
 	}
 	dstEnd = dstStart + dstLen;
 	for (dst = dstStart; dst < dstEnd; dst++) {
@@ -5348,7 +5366,7 @@ TranslateInputEOL(
 	 * character in the output string.
 	 */
 
-	statePtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
+	statePtr->flags |= CHANNEL_EOF | CHANNEL_STICKY_EOF;
 	statePtr->inputEncodingFlags |= TCL_ENCODING_END;
 	statePtr->flags &= ~(INPUT_SAW_CR | INPUT_NEED_NL);
 	return 1;
@@ -5418,7 +5436,7 @@ Tcl_Ungets(
     if (statePtr->flags & CHANNEL_STICKY_EOF) {
 	goto done;
     }
-    statePtr->flags &= (~(CHANNEL_BLOCKED | CHANNEL_EOF));
+    statePtr->flags &= ~(CHANNEL_BLOCKED | CHANNEL_EOF);
 
     bufPtr = AllocChannelBuffer(len);
     for (i = 0; i < len; i++) {
@@ -5527,7 +5545,8 @@ DiscardInputQueued(
     int discardSavedBuffers)	/* If non-zero, discard all buffers including
 				 * last one. */
 {
-    ChannelBuffer *bufPtr, *nxtPtr;	/* Loop variables. */
+    ChannelBuffer *bufPtr, *nxtPtr;
+				/* Loop variables. */
 
     bufPtr = statePtr->inQueueHead;
     statePtr->inQueueHead = NULL;
@@ -5573,7 +5592,8 @@ GetInput(
     int result;			/* Of calling driver. */
     int nread;			/* How much was read from channel? */
     ChannelBuffer *bufPtr;	/* New buffer to add to input queue. */
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
 
     /*
      * Prevent reading from a dead channel -- a channel that has been closed
@@ -5628,10 +5648,9 @@ GetInput(
 	statePtr->saveInBufPtr = NULL;
 
 	/*
-	 * Check the actual buffersize against the requested
-	 * buffersize. Buffers which are smaller than requested are
-	 * squashed. This is done to honor dynamic changes of the buffersize
-	 * made by the user.
+	 * Check the actual buffersize against the requested buffersize.
+	 * Buffers which are smaller than requested are squashed. This is done
+	 * to honor dynamic changes of the buffersize made by the user.
 	 */
 
 	if ((bufPtr != NULL)
@@ -5768,8 +5787,10 @@ Tcl_Seek(
     Tcl_WideInt offset,		/* Offset to seek to. */
     int mode)			/* Relative to which location to seek? */
 {
-    Channel *chanPtr = (Channel *) chan;	/* The real IO channel. */
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    Channel *chanPtr = (Channel *) chan;
+				/* The real IO channel. */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
     int inputBuffered, outputBuffered;
 				/* # bytes held in buffers. */
     int result;			/* Of device driver operations. */
@@ -5860,9 +5881,9 @@ Tcl_Seek(
 	if (result != 0) {
 	    return Tcl_LongAsWide(-1);
 	}
-	statePtr->flags &= (~(CHANNEL_NONBLOCKING));
+	statePtr->flags &= ~CHANNEL_NONBLOCKING;
 	if (statePtr->flags & BG_FLUSH_SCHEDULED) {
-	    statePtr->flags &= (~(BG_FLUSH_SCHEDULED));
+	    statePtr->flags &= ~BG_FLUSH_SCHEDULED;
 	}
     }
 
@@ -5953,8 +5974,10 @@ Tcl_WideInt
 Tcl_Tell(
     Tcl_Channel chan)		/* The channel to return pos for. */
 {
-    Channel *chanPtr = (Channel *) chan;	/* The real IO channel. */
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    Channel *chanPtr = (Channel *) chan;
+				/* The real IO channel. */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
     int inputBuffered, outputBuffered;
 				/* # bytes held in buffers. */
     int result;			/* Of calling device driver. */
@@ -6103,6 +6126,7 @@ Tcl_TruncateChannel(
 	 * Feature not supported and it's not emulatable. Pretend it's
 	 * returned an EINVAL, a very generic error!
 	 */
+
 	Tcl_SetErrno(EINVAL);
 	return TCL_ERROR;
     }
@@ -6112,6 +6136,7 @@ Tcl_TruncateChannel(
 	 * We require that the file was opened of writing. Do that check now
 	 * so that we only flush if we think we're going to succeed.
 	 */
+
 	Tcl_SetErrno(EINVAL);
 	return TCL_ERROR;
     }
@@ -6180,7 +6205,7 @@ CheckChannelErrors(
 	 */
 
 	if (statePtr->chanMsg != NULL) {
-	    Tcl_DecrRefCount(statePtr->chanMsg);
+	    TclDecrRefCount(statePtr->chanMsg);
 	}
 	statePtr->chanMsg = statePtr->unreportedMsg;
 	statePtr->unreportedMsg = NULL;
@@ -6400,7 +6425,7 @@ Tcl_ChannelBuffered(
     Tcl_Channel chan)		/* The channel to query. */
 {
     Channel *chanPtr = (Channel *) chan;
-				/* real channel structure. */
+				/* Real channel structure. */
     ChannelBuffer *bufPtr;
     int bytesBuffered;
 
@@ -6441,10 +6466,7 @@ Tcl_SetChannelBufferSize(
      * not accept the requested size and leave the current buffer size.
      */
 
-    if (sz < 1) {
-	return;
-    }
-    if (sz > (1024 * 1024)) {
+    if (sz < 1 || sz > 1024*1024) {
 	return;
     }
 
@@ -6587,7 +6609,8 @@ Tcl_GetChannelOption(
     size_t len;			/* Length of optionName string. */
     char optionVal[128];	/* Buffer for sprintf. */
     Channel *chanPtr = (Channel *) chan;
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
     int flags;
 
     /*
@@ -6819,8 +6842,10 @@ Tcl_SetChannelOption(
     CONST char *optionName,	/* Which option to set? */
     CONST char *newValue)	/* New value for option. */
 {
-    Channel *chanPtr = (Channel *) chan;	/* The real IO channel. */
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    Channel *chanPtr = (Channel *) chan;
+				/* The real IO channel. */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
     size_t len;			/* Length of optionName string. */
     int argc;
     CONST char **argv;
@@ -6873,14 +6898,14 @@ Tcl_SetChannelOption(
 	len = strlen(newValue);
 	if ((newValue[0] == 'f') && (strncmp(newValue, "full", len) == 0)) {
 	    statePtr->flags &=
-		    (~(CHANNEL_UNBUFFERED|CHANNEL_LINEBUFFERED));
+		    ~(CHANNEL_UNBUFFERED|CHANNEL_LINEBUFFERED);
 	} else if ((newValue[0] == 'l') &&
 		(strncmp(newValue, "line", len) == 0)) {
-	    statePtr->flags &= (~(CHANNEL_UNBUFFERED));
+	    statePtr->flags &= ~CHANNEL_UNBUFFERED;
 	    statePtr->flags |= CHANNEL_LINEBUFFERED;
 	} else if ((newValue[0] == 'n') &&
 		(strncmp(newValue, "none", len) == 0)) {
-	    statePtr->flags &= (~(CHANNEL_LINEBUFFERED));
+	    statePtr->flags &= ~CHANNEL_LINEBUFFERED;
 	    statePtr->flags |= CHANNEL_UNBUFFERED;
 	} else {
 	    if (interp) {
@@ -7035,8 +7060,7 @@ Tcl_SetChannelOption(
 
 	    if (translation != statePtr->inputTranslation) {
 		statePtr->inputTranslation = translation;
-		statePtr->flags &= ~(INPUT_SAW_CR);
-		statePtr->flags &= ~(CHANNEL_NEED_MORE_DATA);
+		statePtr->flags &= ~(INPUT_SAW_CR | CHANNEL_NEED_MORE_DATA);
 		UpdateInterest(chanPtr);
 	    }
 	}
@@ -7096,14 +7120,13 @@ Tcl_SetChannelOption(
 	RecycleBuffer(statePtr, statePtr->saveInBufPtr, 1);
 	statePtr->saveInBufPtr = NULL;
     }
-    if (statePtr->inQueueHead != NULL) {
-	if ((statePtr->inQueueHead->nextPtr == NULL)
-		&& (statePtr->inQueueHead->nextAdded ==
-			statePtr->inQueueHead->nextRemoved)) {
-	    RecycleBuffer(statePtr, statePtr->inQueueHead, 1);
-	    statePtr->inQueueHead = NULL;
-	    statePtr->inQueueTail = NULL;
-	}
+    if ((statePtr->inQueueHead != NULL)
+	    && (statePtr->inQueueHead->nextPtr == NULL)
+	    && (statePtr->inQueueHead->nextAdded ==
+		    statePtr->inQueueHead->nextRemoved)) {
+	RecycleBuffer(statePtr, statePtr->inQueueHead, 1);
+	statePtr->inQueueHead = NULL;
+	statePtr->inQueueTail = NULL;
     }
 
     /*
@@ -7145,7 +7168,8 @@ CleanupChannelHandlers(
     Tcl_Interp *interp,
     Channel *chanPtr)
 {
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
     EventScriptRecord *sPtr, *prevPtr, *nextPtr;
 
     /*
@@ -7200,7 +7224,8 @@ Tcl_NotifyChannel(
 				 * which events were detected. */
 {
     Channel *chanPtr = (Channel *) channel;
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
     ChannelHandler *chPtr;
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
     NextChannelHandler nh;
@@ -7346,7 +7371,8 @@ static void
 UpdateInterest(
     Channel *chanPtr)		/* Channel to update. */
 {
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
     int mask = statePtr->interestMask;
 
     /*
@@ -7443,7 +7469,8 @@ ChannelTimerProc(
     ClientData clientData)
 {
     Channel *chanPtr = (Channel *) clientData;
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
 
     if (!(statePtr->flags & CHANNEL_NEED_MORE_DATA)
 	    && (statePtr->interestMask & TCL_READABLE)
@@ -7522,7 +7549,8 @@ Tcl_CreateChannelHandler(
 {
     ChannelHandler *chPtr;
     Channel *chanPtr = (Channel *) chan;
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
 
     /*
      * Check whether this channel handler is not already registered. If it is
@@ -7595,7 +7623,8 @@ Tcl_DeleteChannelHandler(
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
     ChannelHandler *chPtr, *prevChPtr;
     Channel *chanPtr = (Channel *) chan;
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
     NextChannelHandler *nhPtr;
 
     /*
@@ -7681,7 +7710,8 @@ DeleteScriptRecord(
     int mask)			/* Events in mask must exactly match mask of
 				 * script to delete. */
 {
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
     EventScriptRecord *esPtr, *prevEsPtr;
 
     for (esPtr = statePtr->scriptRecordPtr, prevEsPtr = NULL; esPtr != NULL;
@@ -7730,7 +7760,8 @@ CreateScriptRecord(
 				 * invoked. */
     Tcl_Obj *scriptPtr)		/* Pointer to script object. */
 {
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
     EventScriptRecord *esPtr;
 
     for (esPtr=statePtr->scriptRecordPtr; esPtr!=NULL; esPtr=esPtr->nextPtr) {
@@ -7844,7 +7875,7 @@ Tcl_FileEventObjCmd(
     Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     Channel *chanPtr;		/* The channel to create the handler for. */
-    ChannelState *statePtr;	/* state info for channel */
+    ChannelState *statePtr;	/* State info for channel */
     Tcl_Channel chan;		/* The opaque type for the channel. */
     char *chanName;
     int modeIndex;		/* Index of mode argument. */
@@ -7862,7 +7893,7 @@ Tcl_FileEventObjCmd(
     }
     mask = maskArray[modeIndex];
 
-    chanName = Tcl_GetString(objv[1]);
+    chanName = TclGetString(objv[1]);
     chan = Tcl_GetChannel(interp, chanName, NULL);
     if (chan == (Tcl_Channel) NULL) {
 	return TCL_ERROR;
@@ -7895,7 +7926,7 @@ Tcl_FileEventObjCmd(
      * If we are supposed to delete a stored script, do so.
      */
 
-    if (*(Tcl_GetString(objv[3])) == '\0') {
+    if (*(TclGetString(objv[3])) == '\0') {
 	DeleteScriptRecord(interp, chanPtr, mask);
 	return TCL_OK;
     }
@@ -8048,15 +8079,14 @@ CopyData(
     int mask)			/* Current channel event flags. */
 {
     Tcl_Interp *interp;
-    Tcl_Obj *cmdPtr, *errObj = NULL, *bufObj = NULL;
-    Tcl_Obj* msg = NULL;
+    Tcl_Obj *cmdPtr, *errObj = NULL, *bufObj = NULL, *msg = NULL;
     Tcl_Channel inChan, outChan;
     ChannelState *inStatePtr, *outStatePtr;
     int result = TCL_OK, size, total, sizeb;
     char *buffer;
-
-    int inBinary, outBinary, sameEncoding; /* Encoding control */
-    int underflow;		/* input underflow */
+    int inBinary, outBinary, sameEncoding;
+				/* Encoding control */
+    int underflow;		/* Input underflow */
 
     inChan	= (Tcl_Channel) csPtr->readPtr;
     outChan	= (Tcl_Channel) csPtr->writePtr;
@@ -8113,9 +8143,10 @@ CopyData(
 	if (inBinary || sameEncoding) {
 	    size = DoRead(inStatePtr->topChanPtr, csPtr->buffer, sizeb);
 	} else {
-	    size = DoReadChars(inStatePtr->topChanPtr, bufObj, sizeb, 0 /* No append */);
+	    size = DoReadChars(inStatePtr->topChanPtr, bufObj, sizeb,
+		    0 /* No append */);
 	}
-	underflow = (size >= 0) && (size < sizeb);	/* input underflow */
+	underflow = (size >= 0) && (size < sizeb);  /* Input underflow */
 
 	if (size < 0) {
 	readError:
@@ -8173,9 +8204,13 @@ CopyData(
 	}
 
 	if (inBinary || sameEncoding) {
-	    /* Both read and write counted bytes */
+	    /*
+	     * Both read and write counted bytes.
+	     */
+
 	    size = sizeb;
-	} /* else : Read counted characters, write counted bytes, i.e. size != sizeb */
+	} /* else: Read counted characters, write counted bytes, i.e.
+	   * size != sizeb */
 
 	if (sizeb < 0) {
 	writeError:
@@ -8329,7 +8364,8 @@ DoRead(
     char *bufPtr,		/* Where to store input read. */
     int toRead)			/* Maximum number of bytes to read. */
 {
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
     int copied;			/* How many characters were copied into the
 				 * result string? */
     int copiedNow;		/* How many characters were copied from the
@@ -8358,7 +8394,7 @@ DoRead(
 		if (statePtr->flags & CHANNEL_NONBLOCKING) {
 		    goto done;
 		}
-		statePtr->flags &= (~(CHANNEL_BLOCKED));
+		statePtr->flags &= ~CHANNEL_BLOCKED;
 	    }
 	    result = GetInput(chanPtr);
 	    if (result != 0) {
@@ -8370,7 +8406,7 @@ DoRead(
 	}
     }
 
-    statePtr->flags &= (~(CHANNEL_BLOCKED));
+    statePtr->flags &= ~CHANNEL_BLOCKED;
 
     /*
      * Update the notifier state so we don't block while there is still data
@@ -8443,8 +8479,7 @@ CopyAndTranslateBuffer(
 	if (bytesInBuffer < space) {
 	    space = bytesInBuffer;
 	}
-	memcpy((VOID *) result, (VOID *) (bufPtr->buf + bufPtr->nextRemoved),
-		(size_t) space);
+	memcpy(result, bufPtr->buf + bufPtr->nextRemoved, (size_t) space);
 	bufPtr->nextRemoved += space;
 	copied = space;
 	break;
@@ -8463,8 +8498,7 @@ CopyAndTranslateBuffer(
 	if (bytesInBuffer < space) {
 	    space = bytesInBuffer;
 	}
-	memcpy((VOID *) result, (VOID *) (bufPtr->buf + bufPtr->nextRemoved),
-		(size_t) space);
+	memcpy(result, bufPtr->buf + bufPtr->nextRemoved, (size_t) space);
 	bufPtr->nextRemoved += space;
 	copied = space;
 
@@ -8494,15 +8528,14 @@ CopyAndTranslateBuffer(
 	}
 
 	/*
-	 * Copy the current chunk and replace "\r\n" with "\n"
-	 * (but not standalone "\r"!).
+	 * Copy the current chunk and replace "\r\n" with "\n" (but not
+	 * standalone "\r"!).
 	 */
 
 	if (bytesInBuffer < space) {
 	    space = bytesInBuffer;
 	}
-	memcpy((VOID *) result, (VOID *) (bufPtr->buf + bufPtr->nextRemoved),
-		(size_t) space);
+	memcpy(result, bufPtr->buf + bufPtr->nextRemoved, (size_t) space);
 	bufPtr->nextRemoved += space;
 	copied = space;
 
@@ -8542,8 +8575,7 @@ CopyAndTranslateBuffer(
 	if (bytesInBuffer < space) {
 	    space = bytesInBuffer;
 	}
-	memcpy((VOID *) result, (VOID *) (bufPtr->buf + bufPtr->nextRemoved),
-		(size_t) space);
+	memcpy(result, bufPtr->buf + bufPtr->nextRemoved, (size_t) space);
 	bufPtr->nextRemoved += space;
 	copied = space;
 
@@ -8584,7 +8616,7 @@ CopyAndTranslateBuffer(
 		 * caller.
 		 */
 
-		statePtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
+		statePtr->flags |= CHANNEL_EOF | CHANNEL_STICKY_EOF;
 		statePtr->inputEncodingFlags |= TCL_ENCODING_END;
 		copied = i;
 		break;
@@ -8674,8 +8706,7 @@ CopyBuffer(
 	space = bytesInBuffer;
     }
 
-    memcpy((VOID *) result, (VOID *) (bufPtr->buf + bufPtr->nextRemoved),
-	    (size_t) space);
+    memcpy(result, bufPtr->buf + bufPtr->nextRemoved, (size_t) space);
     bufPtr->nextRemoved += space;
     copied = space;
 
@@ -8731,7 +8762,8 @@ DoWrite(
     CONST char *src,		/* Data to write. */
     int srcLen)			/* Number of bytes to write. */
 {
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
     ChannelBuffer *outBufPtr;	/* Current output buffer. */
     int foundNewline;		/* Did we find a newline in output? */
     char *dPtr;
@@ -8783,11 +8815,11 @@ DoWrite(
 	switch (statePtr->outputTranslation) {
 	case TCL_TRANSLATE_LF:
 	    srcCopied = destCopied;
-	    memcpy((VOID *) destPtr, (VOID *) src, (size_t) destCopied);
+	    memcpy(destPtr, src, (size_t) destCopied);
 	    break;
 	case TCL_TRANSLATE_CR:
 	    srcCopied = destCopied;
-	    memcpy((VOID *) destPtr, (VOID *) src, (size_t) destCopied);
+	    memcpy(destPtr, src, (size_t) destCopied);
 	    for (dPtr = destPtr; dPtr < destPtr + destCopied; dPtr++) {
 		if (*dPtr == '\n') {
 		    *dPtr = '\r';
@@ -9021,8 +9053,9 @@ SetBlockMode(
     int mode)			/* One of TCL_MODE_BLOCKING or
 				 * TCL_MODE_NONBLOCKING. */
 {
-    ChannelState *statePtr = chanPtr->state;	/* state info for channel */
     int result = 0;
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
 
     result = StackSetBlockMode(chanPtr, mode);
     if (result != 0) {
@@ -9055,7 +9088,7 @@ SetBlockMode(
 	return TCL_ERROR;
     }
     if (mode == TCL_MODE_BLOCKING) {
-	statePtr->flags &= (~(CHANNEL_NONBLOCKING | BG_FLUSH_SCHEDULED));
+	statePtr->flags &= ~(CHANNEL_NONBLOCKING | BG_FLUSH_SCHEDULED);
     } else {
 	statePtr->flags |= CHANNEL_NONBLOCKING;
     }
@@ -9110,8 +9143,8 @@ Tcl_GetChannelNamesEx(
 {
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
     ChannelState *statePtr;
-    CONST char *name;		/* name for channel */
-    Tcl_Obj *resultPtr;		/* pointer to result object */
+    CONST char *name;		/* Name for channel */
+    Tcl_Obj *resultPtr;		/* Pointer to result object */
     Tcl_HashTable *hTblPtr;	/* Hash table of channels. */
     Tcl_HashEntry *hPtr;	/* Search variable. */
     Tcl_HashSearch hSearch;	/* Search variable. */
@@ -9205,7 +9238,7 @@ Tcl_IsChannelRegistered(
     chanPtr = ((Channel *) chan)->state->bottomChanPtr;
     statePtr = chanPtr->state;
 
-    hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
+    hTblPtr = Tcl_GetAssocData(interp, "tclIO", NULL);
     if (hTblPtr == NULL) {
 	return 0;
     }
@@ -9336,7 +9369,8 @@ Tcl_ChannelName(
 
 Tcl_ChannelTypeVersion
 Tcl_ChannelVersion(
-    Tcl_ChannelType *chanTypePtr)	/* Pointer to channel type. */
+    Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
 {
     if (chanTypePtr->version == TCL_CHANNEL_VERSION_2) {
 	return TCL_CHANNEL_VERSION_2;
@@ -9400,7 +9434,8 @@ HaveVersion(
 
 Tcl_DriverBlockModeProc *
 Tcl_ChannelBlockModeProc(
-    Tcl_ChannelType *chanTypePtr)	/* Pointer to channel type. */
+    Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
 {
     if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_2)) {
 	return chanTypePtr->blockModeProc;
@@ -9431,7 +9466,8 @@ Tcl_ChannelBlockModeProc(
 
 Tcl_DriverCloseProc *
 Tcl_ChannelCloseProc(
-    Tcl_ChannelType *chanTypePtr)	/* Pointer to channel type. */
+    Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
 {
     return chanTypePtr->closeProc;
 }
@@ -9454,7 +9490,8 @@ Tcl_ChannelCloseProc(
 
 Tcl_DriverClose2Proc *
 Tcl_ChannelClose2Proc(
-    Tcl_ChannelType *chanTypePtr)	/* Pointer to channel type. */
+    Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
 {
     return chanTypePtr->close2Proc;
 }
@@ -9477,7 +9514,8 @@ Tcl_ChannelClose2Proc(
 
 Tcl_DriverInputProc *
 Tcl_ChannelInputProc(
-    Tcl_ChannelType *chanTypePtr)	/* Pointer to channel type. */
+    Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
 {
     return chanTypePtr->inputProc;
 }
@@ -9500,7 +9538,8 @@ Tcl_ChannelInputProc(
 
 Tcl_DriverOutputProc *
 Tcl_ChannelOutputProc(
-    Tcl_ChannelType *chanTypePtr)	/* Pointer to channel type. */
+    Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
 {
     return chanTypePtr->outputProc;
 }
@@ -9523,7 +9562,8 @@ Tcl_ChannelOutputProc(
 
 Tcl_DriverSeekProc *
 Tcl_ChannelSeekProc(
-    Tcl_ChannelType *chanTypePtr)	/* Pointer to channel type. */
+    Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
 {
     return chanTypePtr->seekProc;
 }
@@ -9546,7 +9586,8 @@ Tcl_ChannelSeekProc(
 
 Tcl_DriverSetOptionProc *
 Tcl_ChannelSetOptionProc(
-    Tcl_ChannelType *chanTypePtr)	/* Pointer to channel type. */
+    Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
 {
     return chanTypePtr->setOptionProc;
 }
@@ -9569,7 +9610,8 @@ Tcl_ChannelSetOptionProc(
 
 Tcl_DriverGetOptionProc *
 Tcl_ChannelGetOptionProc(
-    Tcl_ChannelType *chanTypePtr)	/* Pointer to channel type. */
+    Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
 {
     return chanTypePtr->getOptionProc;
 }
@@ -9592,7 +9634,8 @@ Tcl_ChannelGetOptionProc(
 
 Tcl_DriverWatchProc *
 Tcl_ChannelWatchProc(
-    Tcl_ChannelType *chanTypePtr)	/* Pointer to channel type. */
+    Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
 {
     return chanTypePtr->watchProc;
 }
@@ -9615,7 +9658,8 @@ Tcl_ChannelWatchProc(
 
 Tcl_DriverGetHandleProc *
 Tcl_ChannelGetHandleProc(
-    Tcl_ChannelType *chanTypePtr)	/* Pointer to channel type. */
+    Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
 {
     return chanTypePtr->getHandleProc;
 }
@@ -9638,7 +9682,8 @@ Tcl_ChannelGetHandleProc(
 
 Tcl_DriverFlushProc *
 Tcl_ChannelFlushProc(
-    Tcl_ChannelType *chanTypePtr)	/* Pointer to channel type. */
+    Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
 {
     if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_2)) {
 	return chanTypePtr->flushProc;
@@ -9665,7 +9710,8 @@ Tcl_ChannelFlushProc(
 
 Tcl_DriverHandlerProc *
 Tcl_ChannelHandlerProc(
-    Tcl_ChannelType *chanTypePtr)	/* Pointer to channel type. */
+    Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
 {
     if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_2)) {
 	return chanTypePtr->handlerProc;
@@ -9692,7 +9738,8 @@ Tcl_ChannelHandlerProc(
 
 Tcl_DriverWideSeekProc *
 Tcl_ChannelWideSeekProc(
-    Tcl_ChannelType *chanTypePtr)	/* Pointer to channel type. */
+    Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
 {
     if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_3)) {
 	return chanTypePtr->wideSeekProc;
@@ -9720,7 +9767,8 @@ Tcl_ChannelWideSeekProc(
 
 Tcl_DriverThreadActionProc *
 Tcl_ChannelThreadActionProc(
-    Tcl_ChannelType *chanTypePtr)	/* Pointer to channel type. */
+    Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
 {
     if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_4)) {
 	return chanTypePtr->threadActionProc;
@@ -9754,7 +9802,7 @@ Tcl_SetChannelErrorInterp(
     Interp *iPtr = (Interp *) interp;
 
     if (iPtr->chanMsg != NULL) {
-	Tcl_DecrRefCount(iPtr->chanMsg);
+	TclDecrRefCount(iPtr->chanMsg);
 	iPtr->chanMsg = NULL;
     }
 
@@ -9787,10 +9835,10 @@ Tcl_SetChannelError(
     Tcl_Channel chan,		/* Channel to store the data into. */
     Tcl_Obj *msg)		/* Error message to store. */
 {
-    ChannelState* statePtr = ((Channel*) chan)->state;
+    ChannelState *statePtr = ((Channel *) chan)->state;
 
     if (statePtr->chanMsg != NULL) {
-	Tcl_DecrRefCount(statePtr->chanMsg);
+	TclDecrRefCount(statePtr->chanMsg);
 	statePtr->chanMsg = NULL;
     }
 
@@ -9824,15 +9872,10 @@ static Tcl_Obj *
 FixLevelCode(
     Tcl_Obj *msg)
 {
-    int lc;
-    Tcl_Obj **lv;
-    int explicitResult;
-    int numOptions;
-    int lcn;
-    Tcl_Obj **lvn;
+    int explicitResult, numOptions, lc, lcn;
+    Tcl_Obj **lv, **lvn;
     int res, i, j, val, lignore, cignore;
-    Tcl_Obj *newlevel = NULL;
-    Tcl_Obj *newcode = NULL;
+    Tcl_Obj *newlevel = NULL, *newcode = NULL;
 
     /* ASSERT msg != NULL */
 
@@ -9841,9 +9884,9 @@ FixLevelCode(
      *
      * Syntax = (option value)... ?message?
      *
-     * Bad syntax causes a panic. Because the other side uses
+     * Bad message syntax causes a panic, because the other side uses
      * Tcl_GetReturnOptions and list construction functions to marshall the
-     * information.
+     * information. Hence an error means that we've got serious breakage.
      */
 
     res = Tcl_ListObjGetElements(NULL, msg, &lc, &lv);
@@ -10034,7 +10077,8 @@ Tcl_GetChannelError(
 
 Tcl_DriverTruncateProc *
 Tcl_ChannelTruncateProc(
-    Tcl_ChannelType *chanTypePtr)	/* Pointer to channel type. */
+    Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
 {
     if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_5)) {
 	return chanTypePtr->truncateProc;