merge trunkinitsubsystems

1 files changed, 476 insertions, 500 deletions

diff --git a/generic/tclIO.c b/generic/tclIO.c
index d154c77..1460392 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -102,30 +102,11 @@ typedef struct CopyState {
     Tcl_WideInt total;		/* Total bytes transferred (written). */
     Tcl_Interp *interp;		/* Interp that started the copy. */
     Tcl_Obj *cmdPtr;		/* Command to be invoked at completion. */
-    int refCount;		/* Claim count on the struct */
-    int bufInUse;		/* Flag to govern access to buffer */
     int bufSize;		/* Size of appended buffer. */
     char buffer[1];		/* Copy buffer, this must be the last
                                  * field. */
 } CopyState;
 
-static void
-PreserveCopyState(
-    CopyState *csPtr)
-{
-    csPtr->refCount++;
-}
-
-static void
-ReleaseCopyState(
-    CopyState *csPtr)
-{
-    if (--csPtr->refCount) {
-	return;
-    }
-    ckfree(csPtr);
-}
-
 /*
  * All static variables used in this file are collected into a single instance
  * of the following structure. For multi-threaded implementations, there is
@@ -135,7 +116,7 @@ ReleaseCopyState(
  * The structure defined below is used in this file only.
  */
 
-typedef struct ThreadSpecificData {
+typedef struct {
     NextChannelHandler *nestedHandlerPtr;
 				/* This variable holds the list of nested
 				 * Tcl_NotifyChannel invocations. */
@@ -332,15 +313,20 @@ static int              WillRead(Channel *chanPtr);
 		&& (strncmp(optionName, (nameString), len) == 0))
 
 /*
- * The ChannelObjType type.  We actually store the ChannelState structure
- * as that lives longest and we want to return the bottomChanPtr when
- * requested (consistent with Tcl_GetChannel).  The setFromAny and
- * updateString can be NULL as they should not be called.
+ * The ChannelObjType type.  Used to store the result of looking up
+ * a channel name in the context of an interp.  Saves the lookup
+ * result and values needed to check its continued validity.
  */
 
+typedef struct ResolvedChanName {
+    ChannelState *statePtr;	/* The saved lookup result */
+    Tcl_Interp *interp;		/* The interp in which the lookup was done. */
+    size_t epoch;		/* The epoch of the channel when the lookup
+				 * was done. Use to verify validity. */
+    size_t refCount;		/* Share this struct among many Tcl_Obj. */
+} ResolvedChanName;
+
 static void		DupChannelIntRep(Tcl_Obj *objPtr, Tcl_Obj *copyPtr);
-static int		SetChannelFromAny(Tcl_Interp *interp,
-			    Tcl_Obj *objPtr);
 static void		FreeChannelIntRep(Tcl_Obj *objPtr);
 
 static const Tcl_ObjType chanObjType = {
@@ -348,18 +334,9 @@ static const Tcl_ObjType chanObjType = {
     FreeChannelIntRep,		/* freeIntRepProc */
     DupChannelIntRep,		/* dupIntRepProc */
     NULL,			/* updateStringProc */
-    NULL			/* setFromAnyProc SetChannelFromAny */
+    NULL			/* setFromAnyProc */
 };
 
-#define GET_CHANNELSTATE(objPtr) \
-    ((ChannelState *) (objPtr)->internalRep.twoPtrValue.ptr1)
-#define SET_CHANNELSTATE(objPtr, storePtr) \
-    ((objPtr)->internalRep.twoPtrValue.ptr1 = (void *) (storePtr))
-#define GET_CHANNELINTERP(objPtr) \
-    ((Tcl_Interp *) (objPtr)->internalRep.twoPtrValue.ptr2)
-#define SET_CHANNELINTERP(objPtr, storePtr) \
-    ((objPtr)->internalRep.twoPtrValue.ptr2 = (void *) (storePtr))
-
 #define BUSY_STATE(st, fl) \
      ((((st)->csPtrR) && ((fl) & TCL_READABLE)) || \
       (((st)->csPtrW) && ((fl) & TCL_WRITABLE)))
@@ -404,20 +381,20 @@ ChanCloseHalf(
  *
  * ChanRead --
  *
- *	Read up to dstSize bytes using the inputProc of chanPtr, store
- *	them at dst, and return the number of bytes stored.
+ *	Read up to dstSize bytes using the inputProc of chanPtr, store them at
+ *	dst, and return the number of bytes stored.
  *
  * Results:
  *	The return value of the driver inputProc,
  *	  - number of bytes stored at dst, ot
- *	  - -1 on error, with a Posix error code available to the
- *	    caller by calling Tcl_GetErrno().
+ *	  - -1 on error, with a Posix error code available to the caller by
+ *	    calling Tcl_GetErrno().
  *
  * Side effects:
- *	The CHANNEL_BLOCKED and CHANNEL_EOF flags of the channel state are
- *	set as appropriate.
- *	On EOF, the inputEncodingFlags are set to perform ending operations
- *	on decoding.
+ *	The CHANNEL_BLOCKED and CHANNEL_EOF flags of the channel state are set
+ *	as appropriate.  On EOF, the inputEncodingFlags are set to perform
+ *	ending operations on decoding.
+ *
  *	TODO - Is this really the right place for that?
  *
  *---------------------------------------------------------------------------
@@ -431,15 +408,17 @@ ChanRead(
     int bytesRead, result;
 
     /*
-     * If the caller asked for zero bytes, we'd force the inputProc
-     * to return zero bytes, and then misinterpret that as EOF.
+     * If the caller asked for zero bytes, we'd force the inputProc to return
+     * zero bytes, and then misinterpret that as EOF.
      */
+
     assert(dstSize > 0);
 
     /*
      * Each read op must set the blocked and eof states anew, not let
      * the effect of prior reads leak through.
      */
+
     if (GotFlag(chanPtr->state, CHANNEL_EOF)) {
         chanPtr->state->inputEncodingFlags |= TCL_ENCODING_START;
     }
@@ -452,7 +431,10 @@ ChanRead(
     bytesRead = chanPtr->typePtr->inputProc(chanPtr->instanceData,
 	    dst, dstSize, &result);
 
-    /* Stop any flag leakage through stacked channel levels */
+    /*
+     * Stop any flag leakage through stacked channel levels.
+     */
+
     if (GotFlag(chanPtr->state, CHANNEL_EOF)) {
         chanPtr->state->inputEncodingFlags |= TCL_ENCODING_START;
     }
@@ -460,10 +442,10 @@ ChanRead(
     chanPtr->state->inputEncodingFlags &= ~TCL_ENCODING_END;
     if (bytesRead > 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 (bytesRead < dstSize) {
@@ -597,7 +579,10 @@ TclFinalizeIOSubsystem(void)
     int active = 1;		/* Flag == 1 while there's still work to do */
     int doflushnb;
 
-    /* Fetch the pre-TIP#398 compatibility flag */
+    /*
+     * Fetch the pre-TIP#398 compatibility flag.
+     */
+
     {
         const char *s;
         Tcl_DString ds;
@@ -642,18 +627,20 @@ TclFinalizeIOSubsystem(void)
 	 */
 
 	if (active) {
-
 	    TclChannelPreserve((Tcl_Channel)chanPtr);
+
 	    /*
-	     * TIP #398:  by default, we no  longer set the  channel back into
-             * blocking  mode.  To  restore  the old  blocking  behavior,  the
-             * environment variable  TCL_FLUSH_NONBLOCKING_ON_EXIT must be set
+	     * TIP #398: by default, we no longer set the channel back into
+             * blocking mode.  To restore the old blocking behavior, the
+             * environment variable TCL_FLUSH_NONBLOCKING_ON_EXIT must be set
              * and not be "0".
 	     */
+
             if (doflushnb) {
-                    /* Set the channel back into blocking mode to ensure that we wait
-                     * for all data to flush out.
-                     */
+                /*
+                 * Set the channel back into blocking mode to ensure that we
+                 * wait for all data to flush out.
+                 */
 
                 (void) Tcl_SetChannelOption(NULL, (Tcl_Channel) chanPtr,
                                             "-blocking", "on");
@@ -1040,7 +1027,7 @@ DeleteChannelTable(
 	 */
 
 	Tcl_DeleteHashEntry(hPtr);
-	SetFlag(statePtr, CHANNEL_TAINTED);
+	statePtr->epoch++;
 	if (statePtr->refCount-- <= 1) {
 	    if (!GotFlag(statePtr, BG_FLUSH_SCHEDULED)) {
 		(void) Tcl_Close(interp, (Tcl_Channel) chanPtr);
@@ -1384,7 +1371,7 @@ DetachChannel(
 	    return TCL_ERROR;
 	}
 	Tcl_DeleteHashEntry(hPtr);
-	SetFlag(statePtr, CHANNEL_TAINTED);
+	statePtr->epoch++;
 
 	/*
 	 * Remove channel handlers that refer to this interpreter, so that
@@ -1517,12 +1504,62 @@ TclGetChannelFromObj(
     int flags)
 {
     ChannelState *statePtr;
+    ResolvedChanName *resPtr = NULL;
+    Tcl_Channel chan;
 
-    if (SetChannelFromAny(interp, objPtr) != TCL_OK) {
+    if (interp == NULL) {
+	return TCL_ERROR;
+    }
+
+    if (objPtr->typePtr == &chanObjType) {
+	/*
+ 	 * Confirm validity of saved lookup results.
+ 	 */
+
+	resPtr = (ResolvedChanName *) objPtr->internalRep.twoPtrValue.ptr1;
+	statePtr = resPtr->statePtr;
+	if ((resPtr->interp == interp)		/* Same interp context */
+			/* No epoch change in channel since lookup */
+		&& (resPtr->epoch == statePtr->epoch)) {
+	    /*
+             * Have a valid saved lookup. Jump to end to return it.
+             */
+
+	    goto valid;
+	}
+    }
+
+    chan = Tcl_GetChannel(interp, TclGetString(objPtr), NULL);
+
+    if (chan == NULL) {
+	if (resPtr) {
+	    FreeChannelIntRep(objPtr);
+	}
 	return TCL_ERROR;
     }
 
-    statePtr = GET_CHANNELSTATE(objPtr);
+    if (resPtr && resPtr->refCount == 1) {
+	/*
+         * Re-use the ResolvedCmdName struct.
+         */
+
+	Tcl_Release((ClientData) resPtr->statePtr);
+
+    } else {
+	TclFreeIntRep(objPtr);
+
+	resPtr = (ResolvedChanName *) ckalloc(sizeof(ResolvedChanName));
+	resPtr->refCount = 1;
+	objPtr->internalRep.twoPtrValue.ptr1 = (ClientData) resPtr;
+	objPtr->typePtr = &chanObjType;
+    }
+    statePtr = ((Channel *)chan)->state;
+    resPtr->statePtr = statePtr;
+    Tcl_Preserve((ClientData) statePtr);
+    resPtr->interp = interp;
+    resPtr->epoch = statePtr->epoch;
+
+  valid:
     *channelPtr = (Tcl_Channel) statePtr->bottomChanPtr;
 
     if (modePtr != NULL) {
@@ -1649,7 +1686,7 @@ Tcl_CreateChannel(
      * Set the channel up initially in AUTO input translation mode to accept
      * "\n", "\r" and "\r\n". Output translation mode is set to a platform
      * specific default value. The eofChar is set to 0 for both input and
-     * output, so that Tcl does not look for an in-file EOF indicator (e.g.
+     * output, so that Tcl does not look for an in-file EOF indicator (e.g.,
      * ^Z) and does not append an EOF indicator to files.
      */
 
@@ -1695,6 +1732,8 @@ Tcl_CreateChannel(
     statePtr->chanMsg		= NULL;
     statePtr->unreportedMsg	= NULL;
 
+    statePtr->epoch		= 0;
+
     /*
      * Link the channel into the list of all channels; create an on-exit
      * handler if there is not one already, to close off all the channels in
@@ -1875,7 +1914,6 @@ Tcl_StackChannel(
      */
 
     if (((mask & TCL_READABLE) != 0) && (statePtr->inQueueHead != NULL)) {
-
 	/*
 	 * When statePtr->inQueueHead is not NULL, we know
 	 * prevChanPtr->inQueueHead must be NULL.
@@ -2007,9 +2045,7 @@ Tcl_UnstackChannel(
 	 * of registered channels we wind down the state of the
 	 * transformation, and then restore the state of underlying channel
 	 * into the old structure.
-	 */
-
-	/*
+	 *
 	 * TODO: Figure out how to handle the situation where the chan
 	 * operations called below by this unstacking operation cause
 	 * another unstacking recursively.  In that case the downChanPtr
@@ -2487,6 +2523,7 @@ RecycleBuffer(
     /*
      * Do we have to free the buffer to the OS?
      */
+
     if (IsShared(bufPtr)) {
 	mustDiscard = 1;
     }
@@ -2497,9 +2534,8 @@ RecycleBuffer(
     }
 
     /*
-     * Only save buffers which have the requested buffersize for the
-     * channel. This is to honor dynamic changes of the buffersize
-     * made by the user.
+     * Only save buffers which have the requested buffersize for the channel.
+     * This is to honor dynamic changes of the buffersize made by the user.
      */
 
     if ((bufPtr->bufLength - BUFFER_PADDING) != statePtr->bufSize) {
@@ -2669,14 +2705,18 @@ FlushChannel(
     /*
      * Should we shift the current output buffer over to the output queue?
      * First check that there are bytes in it.  If so then...
-     * If the output queue is empty, then yes, trusting the caller called
-     * us only when written bytes ought to be flushed.
-     * If the current output buffer is full, then yes, so we can meet
-     * the post-condition that on a successful return to caller we've
-     * left space in the current output buffer for more writing (the flush
-     * call was to make new room).
-     * If the channel is blocking, then yes, so we guarantee that
-     * blocking flushes actually flush all pending data.
+     *
+     * If the output queue is empty, then yes, trusting the caller called us
+     * only when written bytes ought to be flushed.
+     *
+     * If the current output buffer is full, then yes, so we can meet the
+     * post-condition that on a successful return to caller we've left space
+     * in the current output buffer for more writing (the flush call was to
+     * make new room).
+     *
+     * If the channel is blocking, then yes, so we guarantee that blocking
+     * flushes actually flush all pending data.
+     *
      * Otherwise, no.  Keep the current output buffer where it is so more
      * can be written to it, possibly filling it, to promote more efficient
      * buffer usage.
@@ -2770,8 +2810,8 @@ FlushChannel(
 		/*
 		 * TIP #219, Tcl Channel Reflection API.
 		 * When defering the error copy a message from the bypass into
-		 * the unreported area. Or discard it if the new error is to be
-		 * ignored in favor of an earlier defered error.
+		 * the unreported area. Or discard it if the new error is to
+		 * be ignored in favor of an earlier defered error.
 		 */
 
 		Tcl_Obj *msg = statePtr->chanMsg;
@@ -2823,8 +2863,11 @@ FlushChannel(
 	    ReleaseChannelBuffer(bufPtr);
 	    break;
 	} else {
-	    /* TODO: Consider detecting and reacting to short writes
-	     * on blocking channels.  Ought not happen.  See iocmd-24.2. */
+	    /*
+             * TODO: Consider detecting and reacting to short writes on
+	     * blocking channels.  Ought not happen.  See iocmd-24.2.
+             */
+
 	    wroteSome = 1;
 	}
 
@@ -2858,7 +2901,6 @@ FlushChannel(
 	    ResetFlag(statePtr, BG_FLUSH_SCHEDULED);
 	    ChanWatch(chanPtr, statePtr->interestMask);
 	} else {
-
 	    /*
 	     * When we are calledFromAsyncFlush, that means a writable
 	     * state on the channel triggered the call, so we should be
@@ -2903,7 +2945,8 @@ FlushChannel(
 	    (statePtr->outQueueHead == NULL) &&
 	    ((statePtr->curOutPtr == NULL) ||
 	    IsBufferEmpty(statePtr->curOutPtr))) {
-	errorCode = CloseChannelPart(interp, chanPtr, errorCode, TCL_CLOSE_WRITE);
+	errorCode = CloseChannelPart(interp, chanPtr, errorCode,
+                TCL_CLOSE_WRITE);
 	goto done;
     }
 
@@ -3374,7 +3417,6 @@ Tcl_Close(
 
     if (GotFlag(statePtr, TCL_WRITABLE) && (statePtr->encoding != NULL)
 	    && !(statePtr->outputEncodingFlags & TCL_ENCODING_START)) {
-
 	int code = CheckChannelErrors(statePtr, TCL_WRITABLE);
 
 	if (code == 0) {
@@ -3464,12 +3506,14 @@ Tcl_Close(
 	}
 	return TCL_ERROR;
     }
+
     /*
      * Bug 97069ea11a: set error message if a flush code is set and no error
      * message set up to now.
      */
+
     if (flushcode != 0 && interp != NULL
-	    && 0 == Tcl_GetCharLength(Tcl_GetObjResult(interp)) ) {
+	    && 0 == Tcl_GetCharLength(Tcl_GetObjResult(interp))) {
 	Tcl_SetErrno(flushcode);
 	Tcl_SetObjResult(interp,
 		Tcl_NewStringObj(Tcl_PosixError(interp), -1));
@@ -3564,8 +3608,8 @@ Tcl_CloseEx(
     }
 
     /*
-     * A user may try to call half-close from within a channel close
-     * handler. That won't do.
+     * A user may try to call half-close from within a channel close handler.
+     * That won't do.
      */
 
     if (statePtr->flags & CHANNEL_INCLOSE) {
@@ -3636,9 +3680,12 @@ CloseWrite(
                                  * closed. May still be used by some
                                  * interpreter */
 {
-    /* Notes: clear-channel-handlers - write side only ? or keep around, just
-     * not called. */
-    /* No close cllbacks are run - channel is still open (read side) */
+    /*
+     * Notes: clear-channel-handlers - write side only ? or keep around, just
+     * not called.
+     *
+     * No close callbacks are run - channel is still open (read side)
+     */
 
     ChannelState *statePtr = chanPtr->state;
                                 /* State of real IO channel. */
@@ -3663,9 +3710,9 @@ CloseWrite(
      * Notes: Due to the assertion of CHANNEL_CLOSEDWRITE in the flags
      * FlushChannel() has called CloseChannelPart(). While we can still access
      * "chan" (no structures were freed), the only place which may still
-     * contain a message is the interpreter itself, and "CloseChannelPart" made
-     * sure to lift any channel message it generated into it. Hence the NULL
-     * argument in the call below.
+     * contain a message is the interpreter itself, and "CloseChannelPart"
+     * made sure to lift any channel message it generated into it. Hence the
+     * NULL argument in the call below.
      */
 
     if (TclChanCaughtErrorBypass(interp, NULL)) {
@@ -3889,10 +3936,10 @@ Tcl_ClearChannelHandlers(
     StopCopy(statePtr->csPtrW);
 
     /*
-     * Must set the interest mask now to 0, otherwise infinite loops
-     * will occur if Tcl_DoOneEvent is called before the channel is
-     * finally deleted in FlushChannel. This can happen if the channel
-     * has a background flush active.
+     * Must set the interest mask now to 0, otherwise infinite loops will
+     * occur if Tcl_DoOneEvent is called before the channel is finally deleted
+     * in FlushChannel. This can happen if the channel has a background flush
+     * active.
      */
 
     statePtr->interestMask = 0;
@@ -4161,22 +4208,24 @@ WillRead(
     Channel *chanPtr)
 {
     if (chanPtr->typePtr == NULL) {
-	/* Prevent read attempts on a closed channel */
+	/*
+         * Prevent read attempts on a closed channel.
+         */
+
         DiscardInputQueued(chanPtr->state, 0);
 	Tcl_SetErrno(EINVAL);
 	return -1;
     }
     if ((chanPtr->typePtr->seekProc != NULL)
             && (Tcl_OutputBuffered((Tcl_Channel) chanPtr) > 0)) {
-
 	/*
-	 * CAVEAT - The assumption here is that FlushChannel() will
-	 * push out the bytes of any writes that are in progress.
-	 * Since this is a seekable channel, we assume it is not one
-	 * that can block and force bg flushing.  Channels we know that
-	 * can do that -- sockets, pipes -- are not seekable.  If the
-	 * assumption is wrong, more drastic measures may be required here
-	 * like temporarily setting the channel into blocking mode.
+	 * CAVEAT - The assumption here is that FlushChannel() will push out
+	 * the bytes of any writes that are in progress.  Since this is a
+	 * seekable channel, we assume it is not one that can block and force
+	 * bg flushing.  Channels we know that can do that - sockets, pipes -
+	 * are not seekable. If the assumption is wrong, more drastic measures
+	 * may be required here like temporarily setting the channel into
+	 * blocking mode.
 	 */
 
         if (FlushChannel(NULL, chanPtr, 0) != 0) {
@@ -4268,11 +4317,17 @@ Write(
 		&statePtr->outputEncodingState, dst,
 		dstLen + BUFFER_PADDING, &srcRead, &dstWrote, NULL);
 
-	/* See chan-io-1.[89]. Tcl Bug 506297. */
+	/*
+         * See chan-io-1.[89]. Tcl Bug 506297.
+         */
+
 	statePtr->outputEncodingFlags &= ~TCL_ENCODING_START;
 
 	if ((result != TCL_OK) && (srcRead + dstWrote == 0)) {
-	    /* We're reading from invalid/incomplete UTF-8 */
+	    /*
+             * We're reading from invalid/incomplete UTF-8.
+             */
+
 	    ReleaseChannelBuffer(bufPtr);
 	    if (total == 0) {
 		Tcl_SetErrno(EINVAL);
@@ -4312,11 +4367,10 @@ Write(
 	    }
 
 	    result |= Tcl_UtfToExternal(NULL, encoding, nl, nlLen,
-		statePtr->outputEncodingFlags,
-		&statePtr->outputEncodingState, dst,
-		dstLen + BUFFER_PADDING, &srcRead, &dstWrote, NULL);
-
-	    assert (srcRead == nlLen);
+		    statePtr->outputEncodingFlags,
+		    &statePtr->outputEncodingState, dst,
+		    dstLen + BUFFER_PADDING, &srcRead, &dstWrote, NULL);
+	    assert(srcRead == nlLen);
 
 	    bufPtr->nextAdded += dstWrote;
 	    src++;
@@ -4330,11 +4384,11 @@ Write(
 
 	if (IsBufferOverflowing(bufPtr)) {
 	    /*
-	     * When translating from UTF-8 to external encoding, we
-	     * allowed the translation to produce a character that crossed
-	     * the end of the output buffer, so that we would get a
-	     * completely full buffer before flushing it. The extra bytes
-	     * will be moved to the beginning of the next buffer.
+	     * When translating from UTF-8 to external encoding, we allowed
+	     * the translation to produce a character that crossed the end of
+	     * the output buffer, so that we would get a completely full
+	     * buffer before flushing it. The extra bytes will be moved to the
+	     * beginning of the next buffer.
 	     */
 
 	    saved = -SpaceLeft(bufPtr);
@@ -4354,15 +4408,16 @@ Write(
 	    flushed += statePtr->bufSize;
 
 	    /*
- 	     * We just flushed.  So if we have needNlFlush set to record
- 	     * that we need to flush because theres a (translated) newline
- 	     * in the buffer, that's likely not true any more.  But there
- 	     * is a tricky exception.  If we have saved bytes that did not
- 	     * really get flushed and those bytes came from a translation
- 	     * of a newline as the last thing taken from the src array,
- 	     * then needNlFlush needs to remain set to flag that the
- 	     * next buffer still needs a newline flush.
+ 	     * We just flushed.  So if we have needNlFlush set to record that
+ 	     * we need to flush because theres a (translated) newline in the
+ 	     * buffer, that's likely not true any more.  But there is a tricky
+ 	     * exception.  If we have saved bytes that did not really get
+ 	     * flushed and those bytes came from a translation of a newline as
+ 	     * the last thing taken from the src array, then needNlFlush needs
+ 	     * to remain set to flag that the next buffer still needs a
+ 	     * newline flush.
  	     */
+
 	    if (needNlFlush && (saved == 0 || src[-1] != '\n')) {
 		needNlFlush = 0;
 	    }
@@ -4468,8 +4523,8 @@ Tcl_GetsObj(
 
     if (GotFlag(statePtr, CHANNEL_STICKY_EOF)) {
 	SetFlag(statePtr, CHANNEL_EOF);
-	assert( statePtr->inputEncodingFlags & TCL_ENCODING_END );
-	assert( !GotFlag(statePtr, CHANNEL_BLOCKED|INPUT_SAW_CR) );
+	assert(statePtr->inputEncodingFlags & TCL_ENCODING_END);
+	assert(!GotFlag(statePtr, CHANNEL_BLOCKED|INPUT_SAW_CR));
 
 	/* TODO: Do we need this? */
 	UpdateInterest(chanPtr);
@@ -4809,17 +4864,17 @@ Tcl_GetsObj(
      */
 
   done:
-	assert(!GotFlag(statePtr, CHANNEL_EOF)
-		|| GotFlag(statePtr, CHANNEL_STICKY_EOF)
-		|| Tcl_InputBuffered((Tcl_Channel)chanPtr) == 0);
-
-	assert( !(GotFlag(statePtr, CHANNEL_EOF|CHANNEL_BLOCKED)
-		== (CHANNEL_EOF|CHANNEL_BLOCKED)) );
+    assert(!GotFlag(statePtr, CHANNEL_EOF)
+	    || GotFlag(statePtr, CHANNEL_STICKY_EOF)
+	    || Tcl_InputBuffered((Tcl_Channel)chanPtr) == 0);
+    assert(!(GotFlag(statePtr, CHANNEL_EOF|CHANNEL_BLOCKED)
+	    == (CHANNEL_EOF|CHANNEL_BLOCKED)));
 
     /*
      * Regenerate the top channel, in case it was changed due to
      * self-modifying reflected transforms.
      */
+
     if (chanPtr != statePtr->topChanPtr) {
 	TclChannelRelease((Tcl_Channel)chanPtr);
 	chanPtr = statePtr->topChanPtr;
@@ -4839,10 +4894,9 @@ Tcl_GetsObj(
  *	end-of-line or end-of-file has been seen. Bytes read from the input
  *	channel return as a ByteArray obj.
  *
- *	WARNING!  The notion of "binary" used here is different from
- *	notions of "binary" used in other places.  In particular, this
- *	"binary" routine may be called when an -eofchar is set on the
- * 	channel.
+ *	WARNING!  The notion of "binary" used here is different from notions
+ *	of "binary" used in other places. In particular, this "binary" routine
+ *	may be called when an -eofchar is set on the channel.
  *
  * Results:
  *	Number of characters accumulated in the object or -1 if error,
@@ -4908,8 +4962,8 @@ TclGetsObjBinary(
     ResetFlag(statePtr, CHANNEL_BLOCKED);
     while (1) {
 	/*
-	 * Subtract the number of bytes that were removed from channel
-	 * buffer during last call.
+	 * Subtract the number of bytes that were removed from channel buffer
+	 * during last call.
 	 */
 
 	if (bufPtr != NULL) {
@@ -4921,10 +4975,11 @@ TclGetsObjBinary(
 
 	if ((bufPtr == NULL) || (bufPtr->nextAdded == BUFFER_PADDING)) {
 	    /*
-	     * All channel buffers were exhausted and the caller still
-	     * hasn't seen EOL. Need to read more bytes from the channel
-	     * device. Side effect is to allocate another channel buffer.
+	     * All channel buffers were exhausted and the caller still hasn't
+	     * seen EOL. Need to read more bytes from the channel device. Side
+	     * effect is to allocate another channel buffer.
 	     */
+
 	    if (GetInput(chanPtr) != 0) {
 		goto restore;
 	    }
@@ -4934,15 +4989,15 @@ TclGetsObjBinary(
 	    }
 	} else {
 	    /*
-	     * Incoming CHANNEL_STICKY_EOF is filtered out on entry.
-	     * A new CHANNEL_STICKY_EOF set in this routine leads to
-	     * return before coming back here.  When we are not dealing
-	     * with CHANNEL_STICKY_EOF, a CHANNEL_EOF implies an
-	     * empty buffer.  Here the buffer is non-empty so we know
-	     * we're a non-EOF */
+	     * Incoming CHANNEL_STICKY_EOF is filtered out on entry.  A new
+	     * CHANNEL_STICKY_EOF set in this routine leads to return before
+	     * coming back here.  When we are not dealing with
+	     * CHANNEL_STICKY_EOF, a CHANNEL_EOF implies an empty buffer.
+	     * Here the buffer is non-empty so we know we're a non-EOF.
+             */
 
-	    assert ( !GotFlag(statePtr, CHANNEL_STICKY_EOF) );
-	    assert ( !GotFlag(statePtr, CHANNEL_EOF) );
+	    assert(!GotFlag(statePtr, CHANNEL_STICKY_EOF));
+	    assert(!GotFlag(statePtr, CHANNEL_EOF));
 	}
 
 	dst = (unsigned char *) RemovePoint(bufPtr);
@@ -5009,8 +5064,8 @@ TclGetsObjBinary(
 	}
 
 	/*
-	 * Copy bytes from the channel buffer to the ByteArray.
-	 * This may realloc space, so keep track of result.
+	 * Copy bytes from the channel buffer to the ByteArray. This may
+	 * realloc space, so keep track of result.
 	 */
 
 	rawLen = dstEnd - dst;
@@ -5094,11 +5149,11 @@ TclGetsObjBinary(
      */
 
   done:
-	assert(!GotFlag(statePtr, CHANNEL_EOF)
-		|| GotFlag(statePtr, CHANNEL_STICKY_EOF)
-		|| Tcl_InputBuffered((Tcl_Channel)chanPtr) == 0);
-	assert( !(GotFlag(statePtr, CHANNEL_EOF|CHANNEL_BLOCKED)
-		== (CHANNEL_EOF|CHANNEL_BLOCKED)) );
+    assert(!GotFlag(statePtr, CHANNEL_EOF)
+	    || GotFlag(statePtr, CHANNEL_STICKY_EOF)
+	    || Tcl_InputBuffered((Tcl_Channel)chanPtr) == 0);
+    assert(!(GotFlag(statePtr, CHANNEL_EOF|CHANNEL_BLOCKED)
+	    == (CHANNEL_EOF|CHANNEL_BLOCKED)));
     UpdateInterest(chanPtr);
     TclChannelRelease((Tcl_Channel)chanPtr);
     return copiedTotal;
@@ -5231,15 +5286,15 @@ FilterInputBytes(
 	}
     } else {
 	/*
-	 * Incoming CHANNEL_STICKY_EOF is filtered out on entry.
-	 * A new CHANNEL_STICKY_EOF set in this routine leads to
-	 * return before coming back here.  When we are not dealing
-	 * with CHANNEL_STICKY_EOF, a CHANNEL_EOF implies an
-	 * empty buffer.  Here the buffer is non-empty so we know
-	 * we're a non-EOF */
+	 * Incoming CHANNEL_STICKY_EOF is filtered out on entry.  A new
+	 * CHANNEL_STICKY_EOF set in this routine leads to return before
+	 * coming back here.  When we are not dealing with CHANNEL_STICKY_EOF,
+	 * a CHANNEL_EOF implies an empty buffer.  Here the buffer is
+	 * non-empty so we know we're a non-EOF.
+         */
 
-	assert ( !GotFlag(statePtr, CHANNEL_STICKY_EOF) );
-	assert ( !GotFlag(statePtr, CHANNEL_EOF) );
+	assert(!GotFlag(statePtr, CHANNEL_STICKY_EOF));
+	assert(!GotFlag(statePtr, CHANNEL_EOF));
     }
 
     /*
@@ -5569,7 +5624,9 @@ Tcl_ReadRaw(
 	return -1;
     }
 
-    /* First read bytes from the push-back buffers. */
+    /*
+     * First read bytes from the push-back buffers.
+     */
 
     while (chanPtr->inQueueHead && bytesToRead > 0) {
 	ChannelBuffer *bufPtr = chanPtr->inQueueHead;
@@ -5577,7 +5634,9 @@ Tcl_ReadRaw(
 	int toCopy = (bytesInBuffer < bytesToRead) ? bytesInBuffer
 		: bytesToRead;
 
-	/* Copy the current chunk into the read buffer. */
+	/*
+         * Copy the current chunk into the read buffer.
+         */
 
 	memcpy(readBuf, RemovePoint(bufPtr), (size_t) toCopy);
 	bufPtr->nextRemoved += toCopy;
@@ -5585,7 +5644,9 @@ Tcl_ReadRaw(
 	readBuf += toCopy;
 	bytesToRead -= toCopy;
 
-	/* If the current buffer is empty recycle it. */
+	/*
+         * If the current buffer is empty recycle it.
+         */
 
 	if (IsBufferEmpty(bufPtr)) {
 	    chanPtr->inQueueHead = bufPtr->nextPtr;
@@ -5597,37 +5658,40 @@ Tcl_ReadRaw(
     }
 
     /*
-     * Go to the driver only if we got nothing from pushback.
-     * Have to do it this way to avoid EOF mis-timings when we
-     * consider the ability that EOF may not be a permanent
-     * condition in the driver, and in that case we have to
-     * synchronize.
+     * Go to the driver only if we got nothing from pushback.  Have to do it
+     * this way to avoid EOF mis-timings when we consider the ability that EOF
+     * may not be a permanent condition in the driver, and in that case we
+     * have to synchronize.
      */
 
     if (copied) {
 	return copied;
     }
 
-    /* This test not needed. */
-    if (bytesToRead > 0) {
+    /*
+     * This test not needed.
+     */
 
+    if (bytesToRead > 0) {
 	int nread = ChanRead(chanPtr, readBuf, bytesToRead);
 
 	if (nread > 0) {
-	    /* Successful read (short is OK) - add to bytes copied */
+	    /*
+             * Successful read (short is OK) - add to bytes copied.
+             */
+
 	    copied += nread;
 	} else if (nread < 0) {
 	    /*
-	     * An error signaled.  If CHANNEL_BLOCKED, then the error
-	     * is not real, but an indication of blocked state.  In
-	     * that case, retain the flag and let caller receive the
-	     * short read of copied bytes from the pushback.
-	     * HOWEVER, if copied==0 bytes from pushback then repeat
-	     * signalling the blocked state as an error to caller so
-	     * there is no false report of an EOF.
-	     * When !CHANNEL_BLOCKED, the error is real and passes on
-	     * to caller.
+	     * An error signaled.  If CHANNEL_BLOCKED, then the error is not
+	     * real, but an indication of blocked state.  In that case, retain
+	     * the flag and let caller receive the short read of copied bytes
+	     * from the pushback.  HOWEVER, if copied==0 bytes from pushback
+	     * then repeat signalling the blocked state as an error to caller
+	     * so there is no false report of an EOF.  When !CHANNEL_BLOCKED,
+	     * the error is real and passes on to caller.
 	     */
+
 	    if (!GotFlag(statePtr, CHANNEL_BLOCKED) || copied == 0) {
 		copied = -1;
 	    }
@@ -5764,21 +5828,23 @@ DoReadChars(
     /*
      * Early out when next read will see eofchar.
      *
-     * NOTE: See DoRead for argument that it's a bug (one we're keeping)
-     * to have this escape before the one for zero-char read request.
+     * NOTE: See DoRead for argument that it's a bug (one we're keeping) to
+     * have this escape before the one for zero-char read request.
      */
 
     if (GotFlag(statePtr, CHANNEL_STICKY_EOF)) {
 	SetFlag(statePtr, CHANNEL_EOF);
-	assert( statePtr->inputEncodingFlags & TCL_ENCODING_END );
-	assert( !GotFlag(statePtr, CHANNEL_BLOCKED|INPUT_SAW_CR) );
+	assert(statePtr->inputEncodingFlags & TCL_ENCODING_END);
+	assert(!GotFlag(statePtr, CHANNEL_BLOCKED|INPUT_SAW_CR));
 
 	/* TODO: We don't need this call? */
 	UpdateInterest(chanPtr);
 	return 0;
     }
 
-    /* Special handling for zero-char read request. */
+    /*
+     * Special handling for zero-char read request.
+     */
     if (toRead == 0) {
 	if (GotFlag(statePtr, CHANNEL_EOF)) {
 	    statePtr->inputEncodingFlags |= TCL_ENCODING_START;
@@ -5797,7 +5863,10 @@ DoReadChars(
     chanPtr = statePtr->topChanPtr;
     TclChannelPreserve((Tcl_Channel)chanPtr);
 
-    /* Must clear the BLOCKED|EOF flags here since we check before reading */
+    /*
+     * Must clear the BLOCKED|EOF flags here since we check before reading.
+     */
+
     if (GotFlag(statePtr, CHANNEL_EOF)) {
 	statePtr->inputEncodingFlags |= TCL_ENCODING_START;
     }
@@ -5855,10 +5924,11 @@ DoReadChars(
     }
 
     /*
-     * Failure to fill a channel buffer may have left channel reporting
-     * a "blocked" state, but so long as we fulfilled the request here,
-     * the caller does not consider us blocked.
+     * Failure to fill a channel buffer may have left channel reporting a
+     * "blocked" state, but so long as we fulfilled the request here, the
+     * caller does not consider us blocked.
      */
+
     if (toRead == 0) {
 	ResetFlag(statePtr, CHANNEL_BLOCKED);
     }
@@ -5867,6 +5937,7 @@ DoReadChars(
      * Regenerate the top channel, in case it was changed due to
      * self-modifying reflected transforms.
      */
+
     if (chanPtr != statePtr->topChanPtr) {
 	TclChannelRelease((Tcl_Channel)chanPtr);
 	chanPtr = statePtr->topChanPtr;
@@ -5877,11 +5948,12 @@ DoReadChars(
      * Update the notifier state so we don't block while there is still data
      * in the buffers.
      */
-	assert(!GotFlag(statePtr, CHANNEL_EOF)
-		|| GotFlag(statePtr, CHANNEL_STICKY_EOF)
-		|| Tcl_InputBuffered((Tcl_Channel)chanPtr) == 0);
-	assert( !(GotFlag(statePtr, CHANNEL_EOF|CHANNEL_BLOCKED)
-		== (CHANNEL_EOF|CHANNEL_BLOCKED)) );
+
+    assert(!GotFlag(statePtr, CHANNEL_EOF)
+	    || GotFlag(statePtr, CHANNEL_STICKY_EOF)
+	    || Tcl_InputBuffered((Tcl_Channel)chanPtr) == 0);
+    assert(!(GotFlag(statePtr, CHANNEL_EOF|CHANNEL_BLOCKED)
+            == (CHANNEL_EOF|CHANNEL_BLOCKED)));
     UpdateInterest(chanPtr);
     TclChannelRelease((Tcl_Channel)chanPtr);
     return copied;
@@ -5998,11 +6070,10 @@ ReadChars(
     int numBytes, srcLen = BytesLeft(bufPtr);
 
     /*
-     * One src byte can yield at most one character.  So when the
-     * number of src bytes we plan to read is less than the limit on
-     * character count to be read, clearly we will remain within that
-     * limit, and we can use the value of "srcLen" as a tighter limit
-     * for sizing receiving buffers.
+     * One src byte can yield at most one character.  So when the number of
+     * src bytes we plan to read is less than the limit on character count to
+     * be read, clearly we will remain within that limit, and we can use the
+     * value of "srcLen" as a tighter limit for sizing receiving buffers.
      */
 
     int toRead = ((charsToRead<0)||(charsToRead > srcLen)) ? srcLen : charsToRead;
@@ -6020,6 +6091,7 @@ ReadChars(
     Tcl_AppendToObj(objPtr, NULL, dstLimit);
     if (toRead == srcLen) {
 	unsigned int size;
+
 	dst = TclGetStringStorage(objPtr, &size) + numBytes;
 	dstLimit = size - numBytes;
     } else {
@@ -6027,19 +6099,18 @@ ReadChars(
     }
 
     /*
-     * This routine is burdened with satisfying several constraints.
-     * It cannot append more than 'charsToRead` chars onto objPtr.
-     * This is measured after encoding and translation transformations
-     * are completed.  There is no precise number of src bytes that can
-     * be associated with the limit.  Yet, when we are done, we must know
-     * precisely the number of src bytes that were consumed to produce
-     * the appended chars, so that all subsequent bytes are left in
-     * the buffers for future read operations.
+     * This routine is burdened with satisfying several constraints. It cannot
+     * append more than 'charsToRead` chars onto objPtr. This is measured
+     * after encoding and translation transformations are completed. There is
+     * no precise number of src bytes that can be associated with the limit.
+     * Yet, when we are done, we must know precisely the number of src bytes
+     * that were consumed to produce the appended chars, so that all
+     * subsequent bytes are left in the buffers for future read operations.
      *
-     * The consequence is that we have no choice but to implement a
-     * "trial and error" approach, where in general we may need to
-     * perform transformations and copies multiple times to achieve
-     * a consistent set of results.  This takes the shape of a loop.
+     * The consequence is that we have no choice but to implement a "trial and
+     * error" approach, where in general we may need to perform
+     * transformations and copies multiple times to achieve a consistent set
+     * of results.  This takes the shape of a loop.
      */
 
     while (1) {
@@ -6052,18 +6123,17 @@ ReadChars(
 	}
 
 	/*
-	 * Perform the encoding transformation.  Read no more than
-	 * srcLen bytes, write no more than dstLimit bytes.
+	 * Perform the encoding transformation.  Read no more than srcLen
+	 * bytes, write no more than dstLimit bytes.
 	 *
-	 * Some trickiness with encoding flags here.  We do not want
-	 * the end of a buffer to be treated as the end of all input
-	 * when the presence of bytes in a next buffer are already
-	 * known to exist.  This is checked with an assert() because
-	 * so far no test case causing the assertion to be false has
-	 * been created.  The normal operations of channel reading
-	 * appear to cause EOF and TCL_ENCODING_END setting to appear
-	 * only in situations where there are no further bytes in
-	 * any buffers.
+	 * Some trickiness with encoding flags here.  We do not want the end
+	 * of a buffer to be treated as the end of all input when the presence
+	 * of bytes in a next buffer are already known to exist.  This is
+	 * checked with an assert() because so far no test case causing the
+	 * assertion to be false has been created.  The normal operations of
+	 * channel reading appear to cause EOF and TCL_ENCODING_END setting to
+	 * appear only in situations where there are no further bytes in any
+	 * buffers.
 	 */
 
 	assert(bufPtr->nextPtr == NULL || BytesLeft(bufPtr->nextPtr) == 0
@@ -6074,10 +6144,10 @@ ReadChars(
 		dst, dstLimit, &srcRead, &dstDecoded, &numChars);
 
 	/*
-	 * Perform the translation transformation in place.  Read no more
-	 * than the dstDecoded bytes the encoding transformation actually
-	 * produced.  Capture the number of bytes written in dstWrote.
-	 * Capture the number of bytes actually consumed in dstRead.
+	 * Perform the translation transformation in place.  Read no more than
+	 * the dstDecoded bytes the encoding transformation actually produced.
+	 * Capture the number of bytes written in dstWrote. Capture the number
+	 * of bytes actually consumed in dstRead.
 	 */
 
 	dstWrote = dstLimit;
@@ -6085,11 +6155,9 @@ ReadChars(
 	TranslateInputEOL(statePtr, dst, dst, &dstWrote, &dstRead);
 
 	if (dstRead < dstDecoded) {
-
 	    /*
-	     * The encoding transformation produced bytes that the
-	     * translation transformation did not consume.  Why did
-	     * this happen?
+	     * The encoding transformation produced bytes that the translation
+	     * transformation did not consume.  Why did this happen?
 	     */
 
 	    if (statePtr->inEofChar && dst[dstRead] == statePtr->inEofChar) {
@@ -6098,40 +6166,38 @@ ReadChars(
 		 *    we saw it and stopped translating at that point.
 		 *
 		 * NOTE the bizarre spec of TranslateInputEOL in this case.
-		 * Clearly the eof char had to be read in order to account
-		 * for the stopping, but the value of dstRead does not
-		 * include it.
+		 * Clearly the eof char had to be read in order to account for
+		 * the stopping, but the value of dstRead does not include it.
 		 *
-		 * Also rather bizarre, our caller can only notice an
-		 * EOF condition if we return the value -1 as the number
-		 * of chars read.  This forces us to perform a 2-call
-		 * dance where the first call can read all the chars
-		 * up to the eof char, and the second call is solely
-		 * for consuming the encoded eof char then pointed at
-		 * by src so that we can return that magic -1 value.
-		 * This seems really wasteful, especially since
-		 * the first decoding pass of each call is likely to
-		 * decode many bytes beyond that eof char that's all we
-		 * care about.
+		 * Also rather bizarre, our caller can only notice an EOF
+		 * condition if we return the value -1 as the number of chars
+		 * read.  This forces us to perform a 2-call dance where the
+		 * first call can read all the chars up to the eof char, and
+		 * the second call is solely for consuming the encoded eof
+		 * char then pointed at by src so that we can return that
+		 * magic -1 value.  This seems really wasteful, especially
+		 * since the first decoding pass of each call is likely to
+		 * decode many bytes beyond that eof char that's all we care
+		 * about.
 		 */
 
 		if (dstRead == 0) {
 		    /*
-		     * Curious choice in the eof char handling.  We leave
-		     * the eof char in the buffer.  So, no need to compute
-		     * a proper srcRead value.  At this point, there
-		     * are no chars before the eof char in the buffer.
+		     * Curious choice in the eof char handling.  We leave the
+		     * eof char in the buffer. So, no need to compute a proper
+		     * srcRead value. At this point, there are no chars before
+		     * the eof char in the buffer.
 		     */
+
 		    Tcl_SetObjLength(objPtr, numBytes);
 		    return -1;
 		}
 
 		{
 		    /*
-		     * There are chars leading the buffer before the eof
-		     * char.  Adjust the dstLimit so we go back and read
-		     * only those and do not encounter the eof char this
-		     * time.
+		     * There are chars leading the buffer before the eof char.
+		     * Adjust the dstLimit so we go back and read only those
+		     * and do not encounter the eof char this time.
 		     */
 
 		    dstLimit = dstRead - 1 + TCL_UTF_MAX;
@@ -6143,10 +6209,9 @@ ReadChars(
 	    }
 
 	    /*
-	     * 2) The other way to read fewer bytes than are decoded
-	     *    is when the final byte is \r and we're in a CRLF
-	     *    translation mode so we cannot decide whether to
-	     *	  record \r or \n yet.
+	     * 2) The other way to read fewer bytes than are decoded is when
+	     *    the final byte is \r and we're in a CRLF translation mode so
+	     *    we cannot decide whether to record \r or \n yet.
 	     */
 
 	    assert(dst[dstRead] == '\r');
@@ -6154,10 +6219,10 @@ ReadChars(
 
 	    if (dstWrote > 0) {
 		/*
-		 * There are chars we can read before we hit the bare cr.
-		 * Go back with a smaller dstLimit so we get them in the
-		 * next pass, compute a matching srcRead, and don't end
-		 * up back here in this call.
+		 * There are chars we can read before we hit the bare CR.  Go
+		 * back with a smaller dstLimit so we get them in the next
+		 * pass, compute a matching srcRead, and don't end up back
+		 * here in this call.
 		 */
 
 		dstLimit = dstRead - 1 + TCL_UTF_MAX;
@@ -6171,9 +6236,9 @@ ReadChars(
 	    assert(dstRead == 0);
 
 	    /*
-	     * We decoded only the bare cr, and we cannot read a
-	     * translated char from that alone.  We have to know what's
-	     * next.  So why do we only have the one decoded char?
+	     * We decoded only the bare CR, and we cannot read a translated
+	     * char from that alone. We have to know what's next.  So why do
+	     * we only have the one decoded char?
 	     */
 
 	    if (code != TCL_OK) {
@@ -6214,10 +6279,9 @@ ReadChars(
 		}
 
 	    } else if (statePtr->flags & CHANNEL_EOF) {
-
 		/*
-		 * The bare \r is the only char and we will never read
-		 * a subsequent char to make the determination.
+		 * The bare \r is the only char and we will never read a
+		 * subsequent char to make the determination.
 		 */
 
 		dst[0] = '\r';
@@ -6227,8 +6291,8 @@ ReadChars(
 	    }
 
 	    /*
-	     * Revise the dstRead value so that the numChars calc
-	     * below correctly computes zero characters read.
+	     * Revise the dstRead value so that the numChars calc below
+	     * correctly computes zero characters read.
 	     */
 
 	    dstRead = numChars;
@@ -6237,9 +6301,9 @@ ReadChars(
 	}
 
 	/*
-	 * The translation transformation can only reduce the number
-	 * of chars when it converts \r\n into \n.  The reduction in
-	 * the number of chars is the difference in bytes read and written.
+	 * The translation transformation can only reduce the number of chars
+	 * when it converts \r\n into \n. The reduction in the number of chars
+	 * is the difference in bytes read and written.
 	 */
 
 	numChars -= (dstRead - dstWrote);
@@ -6249,10 +6313,9 @@ ReadChars(
 	    /*
 	     * TODO: This cannot happen anymore.
 	     *
-	     * We read more chars than allowed.  Reset limits to
-	     * prevent that and try again.  Don't forget the extra
-	     * padding of TCL_UTF_MAX bytes demanded by the
-	     * Tcl_ExternalToUtf() call!
+	     * We read more chars than allowed.  Reset limits to prevent that
+	     * and try again.  Don't forget the extra padding of TCL_UTF_MAX
+	     * bytes demanded by the Tcl_ExternalToUtf() call!
 	     */
 
 	    dstLimit = Tcl_UtfAtIndex(dst, charsToRead) - 1 + TCL_UTF_MAX - dst;
@@ -6265,18 +6328,19 @@ ReadChars(
 	if (dstWrote == 0) {
 	    ChannelBuffer *nextPtr;
 
-	    /* We were not able to read any chars. */
+	    /*
+             * We were not able to read any chars.
+             */
 
-	    assert (numChars == 0);
+	    assert(numChars == 0);
 
 	    /*
-	     * There is one situation where this is the correct final
-	     * result.  If the src buffer contains only a single \n
-	     * byte, and we are in TCL_TRANSLATE_AUTO mode, and
-	     * when the translation pass was made the INPUT_SAW_CR
-	     * flag was set on the channel.  In that case, the
-	     * correct behavior is to consume that \n and produce the
-	     * empty string.
+	     * There is one situation where this is the correct final result.
+	     * If the src buffer contains only a single \n byte, and we are in
+	     * TCL_TRANSLATE_AUTO mode, and when the translation pass was made
+	     * the INPUT_SAW_CR flag was set on the channel. In that case, the
+	     * correct behavior is to consume that \n and produce the empty
+	     * string.
 	     */
 
 	    if (dstRead == 1 && dst[0] == '\n') {
@@ -6285,12 +6349,13 @@ ReadChars(
 		goto consume;
 	    }
 
-	    /* Otherwise, reading zero characters indicates there's
-	     * something incomplete at the end of the src buffer.
-	     * Maybe there were not enough src bytes to decode into
-	     * a char.  Maybe a lone \r could not be translated (crlf
-	     * mode).  Need to combine any unused src bytes we have
-	     * in the first buffer with subsequent bytes to try again.
+	    /*
+             * Otherwise, reading zero characters indicates there's something
+	     * incomplete at the end of the src buffer.  Maybe there were not
+	     * enough src bytes to decode into a char.  Maybe a lone \r could
+	     * not be translated (crlf mode).  Need to combine any unused src
+	     * bytes we have in the first buffer with subsequent bytes to try
+	     * again.
 	     */
 
 	    nextPtr = bufPtr->nextPtr;
@@ -6305,15 +6370,15 @@ ReadChars(
 
 	    /*
 	     * 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'.
+	     * 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) {
@@ -6332,10 +6397,12 @@ ReadChars(
 
     consume:
 	bufPtr->nextRemoved += srcRead;
+
 	/*
-	 * If this read contained multibyte characters, revise factorPtr
-	 * so the next read will allocate bigger buffers.
+	 * If this read contained multibyte characters, revise factorPtr so
+	 * the next read will allocate bigger buffers.
 	 */
+
 	if (numChars && numChars < srcRead) {
 	    *factorPtr = srcRead * UTF_EXPANSION_FACTOR / numChars;
 	}
@@ -6383,23 +6450,28 @@ TranslateInputEOL(
     int inEofChar = statePtr->inEofChar;
 
     /*
-     * Depending on the translation mode in use, there's no need
-     * to scan more srcLen bytes at srcStart than can possibly transform
-     * to dstLen bytes.  This keeps the scan for eof char below from
-     * being pointlessly long.
+     * Depending on the translation mode in use, there's no need to scan more
+     * srcLen bytes at srcStart than can possibly transform to dstLen bytes.
+     * This keeps the scan for eof char below from being pointlessly long.
      */
 
     switch (statePtr->inputTranslation) {
     case TCL_TRANSLATE_LF:
     case TCL_TRANSLATE_CR:
 	if (srcLen > dstLen) {
-	/* In these modes, each src byte become a dst byte. */
+            /*
+             * In these modes, each src byte become a dst byte.
+             */
+
 	    srcLen = dstLen;
 	}
 	break;
     default:
-	/* In other modes, at most 2 src bytes become a dst byte. */
-	if (srcLen > 2 * dstLen) {
+	/*
+         * In other modes, at most 2 src bytes become a dst byte.
+         */
+
+	if (srcLen/2 > dstLen) {
 	    srcLen = 2 * dstLen;
 	}
 	break;
@@ -6731,7 +6803,7 @@ GetInput(
      * eofchar.
      */
 
-    assert( !GotFlag(statePtr, CHANNEL_STICKY_EOF) );
+    assert(!GotFlag(statePtr, CHANNEL_STICKY_EOF));
 
     /*
      * Prevent reading from a dead channel -- a channel that has been closed
@@ -6745,24 +6817,21 @@ GetInput(
     }
 
     /*
-     * WARNING: There was once a comment here claiming that it was
-     * a bad idea to make another call to the inputproc of a channel
-     * driver when EOF has already been detected on the channel.  Through
-     * much of Tcl's history, this warning was then completely negated
-     * by having all (most?) read paths clear the EOF setting before
-     * reaching here.  So we had a guard that was never triggered.
+     * WARNING: There was once a comment here claiming that it was a bad idea
+     * to make another call to the inputproc of a channel driver when EOF has
+     * already been detected on the channel.  Through much of Tcl's history,
+     * this warning was then completely negated by having all (most?) read
+     * paths clear the EOF setting before reaching here.  So we had a guard
+     * that was never triggered.
+     *
+     * Don't be tempted to restore the guard.  Even if EOF is set on the
+     * channel, continue through and call the inputproc again.  This is the
+     * way to enable the ability to [read] again beyond the EOF, which seems a
+     * strange thing to do, but for which use cases exist [Tcl Bug 5adc350683]
+     * and which may even be essential for channels representing things like
+     * ttys or other devices where the stream might take the logical form of a
+     * series of 'files' separated by an EOF condition.
      *
-     * Don't be tempted to restore the guard.  Even if EOF is set on
-     * the channel, continue through and call the inputproc again.  This
-     * is the way to enable the ability to [read] again beyond the EOF,
-     * which seems a strange thing to do, but for which use cases exist
-     * [Tcl Bug 5adc350683] and which may even be essential for channels
-     * representing things like ttys or other devices where the stream
-     * might take the logical form of a series of 'files' separated by
-     * an EOF condition.
-     */
-
-    /*
      * First check for more buffers in the pushback area of the topmost
      * channel in the stack and use them. They can be the result of a
      * transformation which went away without reading all the information
@@ -6770,7 +6839,6 @@ GetInput(
      */
 
     if (chanPtr->inQueueHead != NULL) {
-
 	/* TODO: Tests to cover this. */
 	assert(statePtr->inQueueHead == NULL);
 
@@ -6800,8 +6868,9 @@ GetInput(
 
 	/*
 	 * Check the actual buffersize against the requested buffersize.
-	 * Saved buffers of the wrong size are squashed. This is done
-	 * to honor dynamic changes of the buffersize made by the user.
+	 * Saved buffers of the wrong size are squashed. This is done to honor
+	 * dynamic changes of the buffersize made by the user.
+         *
 	 * TODO: Tests to cover this.
 	 */
 
@@ -7103,53 +7172,12 @@ Tcl_Tell(
 /*
  *---------------------------------------------------------------------------
  *
- * Tcl_SeekOld, Tcl_TellOld --
- *
- *	Backward-compatability versions of the seek/tell interface that do not
- *	support 64-bit offsets. This interface is not documented or expected
- *	to be supported indefinitely.
- *
- * Results:
- *	As for Tcl_Seek and Tcl_Tell respectively, except truncated to
- *	whatever value will fit in an 'int'.
- *
- * Side effects:
- *	As for Tcl_Seek and Tcl_Tell respectively.
- *
- *---------------------------------------------------------------------------
- */
-
-int
-Tcl_SeekOld(
-    Tcl_Channel chan,		/* The channel on which to seek. */
-    int offset,			/* Offset to seek to. */
-    int mode)			/* Relative to which location to seek? */
-{
-    Tcl_WideInt wOffset, wResult;
-
-    wOffset = Tcl_LongAsWide((long) offset);
-    wResult = Tcl_Seek(chan, wOffset, mode);
-    return (int) Tcl_WideAsLong(wResult);
-}
-
-int
-Tcl_TellOld(
-    Tcl_Channel chan)		/* The channel to return pos for. */
-{
-    Tcl_WideInt wResult = Tcl_Tell(chan);
-
-    return (int) Tcl_WideAsLong(wResult);
-}
-
-/*
- *---------------------------------------------------------------------------
- *
  * Tcl_TruncateChannel --
  *
  *	Truncate a channel to the given length.
  *
  * Results:
- *	TCL_OK on success, TCL_ERROR if the operation failed (e.g. is not
+ *	TCL_OK on success, TCL_ERROR if the operation failed (e.g., is not
  *	supported by the type of channel, or the underlying OS operation
  *	failed in some way).
  *
@@ -9111,13 +9139,9 @@ TclCopyChannel(
 	Tcl_IncrRefCount(cmdPtr);
     }
     csPtr->cmdPtr = cmdPtr;
-    csPtr->refCount = 1;
-    csPtr->bufInUse = 0;
 
     inStatePtr->csPtrR  = csPtr;
-    PreserveCopyState(csPtr);
     outStatePtr->csPtrW = csPtr;
-    PreserveCopyState(csPtr);
 
     if (moveBytes) {
 	return MoveBytes(csPtr);
@@ -9297,7 +9321,7 @@ MBWrite(
          * then the calculations involving extra must be made wide too.
          *
          * Noted with Win32/MSVC debug build treating the warning (possible of
-         * data in int64 to int conversion) as error.
+         * data in __int64 to int conversion) as error.
          */
 
 	bufPtr = AllocChannelBuffer(extra);
@@ -9403,11 +9427,6 @@ CopyData(
 				/* Encoding control */
     int underflow;		/* Input underflow */
 
-    if (csPtr->bufInUse) {
-	return TCL_OK;
-    }
-    PreserveCopyState(csPtr);
-
     inChan	= (Tcl_Channel) csPtr->readPtr;
     outChan	= (Tcl_Channel) csPtr->writePtr;
     inStatePtr	= csPtr->readPtr->state;
@@ -9470,7 +9489,6 @@ CopyData(
 		sizeb = (int) csPtr->toRead;
 	    }
 
-	    csPtr->bufInUse = 1;
 	    if (inBinary || sameEncoding) {
 		size = DoRead(inStatePtr->topChanPtr, csPtr->buffer, sizeb,
                               !GotFlag(inStatePtr, CHANNEL_NONBLOCKING));
@@ -9519,14 +9537,16 @@ CopyData(
 	    }
 	    if (size == 0) {
 		if (!GotFlag(inStatePtr, CHANNEL_NONBLOCKING)) {
-		    /* We allowed a short read.  Keep trying. */
+		    /*
+                     * We allowed a short read.  Keep trying.
+                     */
+
 		    continue;
 		}
 		if (bufObj != NULL) {
 		    TclDecrRefCount(bufObj);
 		    bufObj = NULL;
 		}
-		ReleaseCopyState(csPtr);
 		return TCL_OK;
 	    }
 	}
@@ -9547,7 +9567,6 @@ CopyData(
 	} else {
 	    sizeb = WriteChars(outStatePtr->topChanPtr, buffer, sizeb);
 	}
-	csPtr->bufInUse = 0;
 
 	/*
 	 * [Bug 2895565]. At this point 'size' still contains the number of
@@ -9619,7 +9638,6 @@ CopyData(
 		TclDecrRefCount(bufObj);
 		bufObj = NULL;
 	    }
-	    ReleaseCopyState(csPtr);
 	    return TCL_OK;
 	}
 
@@ -9642,7 +9660,6 @@ CopyData(
 		TclDecrRefCount(bufObj);
 		bufObj = NULL;
 	    }
-	    ReleaseCopyState(csPtr);
 	    return TCL_OK;
 	}
     } /* while */
@@ -9658,7 +9675,7 @@ CopyData(
      */
 
     total = csPtr->total;
-    if (cmdPtr && interp && csPtr->cmdPtr) {
+    if (cmdPtr && interp) {
 	int code;
 
 	/*
@@ -9666,7 +9683,8 @@ CopyData(
 	 * arguments. Note that StopCopy frees our saved reference to the
 	 * original command obj.
 	 */
-	cmdPtr = Tcl_DuplicateObj(csPtr->cmdPtr);
+
+	cmdPtr = Tcl_DuplicateObj(cmdPtr);
 	Tcl_IncrRefCount(cmdPtr);
 	StopCopy(csPtr);
 	Tcl_Preserve(interp);
@@ -9694,7 +9712,6 @@ CopyData(
 	    }
 	}
     }
-    ReleaseCopyState(csPtr);
     return result;
 }
 
@@ -9737,7 +9754,7 @@ DoRead(
     ChannelState *statePtr = chanPtr->state;
     char *p = dst;
 
-    assert (bytesToRead >= 0);
+    assert(bytesToRead >= 0);
 
     /*
      * Early out when we know a read will get the eofchar.
@@ -9753,15 +9770,18 @@ DoRead(
 
     if (GotFlag(statePtr, CHANNEL_STICKY_EOF)) {
 	SetFlag(statePtr, CHANNEL_EOF);
-	assert( statePtr->inputEncodingFlags & TCL_ENCODING_END );
-	assert( !GotFlag(statePtr, CHANNEL_BLOCKED|INPUT_SAW_CR) );
+	assert(statePtr->inputEncodingFlags & TCL_ENCODING_END);
+	assert(!GotFlag(statePtr, CHANNEL_BLOCKED|INPUT_SAW_CR));
 
 	/* TODO: Don't need this call */
 	UpdateInterest(chanPtr);
 	return 0;
     }
 
-    /* Special handling for zero-char read request. */
+    /*
+     * Special handling for zero-char read request.
+     */
+
     if (bytesToRead == 0) {
 	if (GotFlag(statePtr, CHANNEL_EOF)) {
 	    statePtr->inputEncodingFlags |= TCL_ENCODING_START;
@@ -9776,8 +9796,8 @@ DoRead(
     TclChannelPreserve((Tcl_Channel)chanPtr);
     while (bytesToRead) {
 	/*
-	 * Each pass through the loop is intended to process up to
-	 * one channel buffer.
+	 * Each pass through the loop is intended to process up to one channel
+	 * buffer.
 	 */
 
 	int bytesRead, bytesWritten;
@@ -9789,33 +9809,39 @@ DoRead(
 
 	while (!bufPtr ||			/* We got no buffer!   OR */
 		(!IsBufferFull(bufPtr) && 	/* Our buffer has room AND */
-		(BytesLeft(bufPtr) < bytesToRead) ) ) {
-						/* Not enough bytes in it
-						 * yet to fill the dst */
+		(BytesLeft(bufPtr) < bytesToRead))) {
+						/* Not enough bytes in it yet
+						 * to fill the dst */
 	    int code;
 
 	moreData:
 	    code = GetInput(chanPtr);
 	    bufPtr = statePtr->inQueueHead;
 
-	    assert (bufPtr != NULL);
+	    assert(bufPtr != NULL);
 
 	    if (GotFlag(statePtr, CHANNEL_EOF|CHANNEL_BLOCKED)) {
-		/* Further reads cannot do any more */
+		/*
+                 * Further reads cannot do any more.
+                 */
+
 		break;
 	    }
 
 	    if (code) {
-		/* Read error */
+		/*
+                 * Read error
+                 */
+
 		UpdateInterest(chanPtr);
 		TclChannelRelease((Tcl_Channel)chanPtr);
 		return -1;
 	    }
 
-	    assert (IsBufferFull(bufPtr));
+	    assert(IsBufferFull(bufPtr));
 	}
 
-	assert (bufPtr != NULL);
+	assert(bufPtr != NULL);
 
 	bytesRead = BytesLeft(bufPtr);
 	bytesWritten = bytesToRead;
@@ -9830,8 +9856,8 @@ DoRead(
 	    /*
 	     * Buffer is not empty.  How can that be?
 	     *
-	     * 0) We stopped early because we got all the bytes
-	     *    we were seeking.  That's fine.
+	     * 0) We stopped early because we got all the bytes we were
+	     *    seeking. That's fine.
 	     */
 
 	    if (bytesToRead == 0) {
@@ -9847,8 +9873,8 @@ DoRead(
 	    }
 
 	    /*
-	     * 2) The buffer holds a \r while in CRLF translation,
-	     *    followed by the end of the buffer.
+	     * 2) The buffer holds a \r while in CRLF translation, followed by
+	     *    the end of the buffer.
 	     */
 
 	    assert(statePtr->inputTranslation == TCL_TRANSLATE_CRLF);
@@ -9856,26 +9882,38 @@ DoRead(
 	    assert(BytesLeft(bufPtr) == 1);
 
 	    if (bufPtr->nextPtr == NULL) {
-		/* There's no more buffered data.... */
+		/*
+                 * There's no more buffered data...
+                 */
 
 		if (statePtr->flags & CHANNEL_EOF) {
-		    /* ...and there never will be. */
+		    /*
+                     * ...and there never will be.
+                     */
 
 		    *p++ = '\r';
 		    bytesToRead--;
 		    bufPtr->nextRemoved++;
 		} else if (statePtr->flags & CHANNEL_BLOCKED) {
-		    /* ...and we cannot get more now. */
+		    /*
+                     * ...and we cannot get more now.
+                     */
+
 		    SetFlag(statePtr, CHANNEL_NEED_MORE_DATA);
 		    break;
 		} else {
-		    /* ... so we need to get some. */
+		    /*
+                     * ...so we need to get some.
+                     */
+
 		    goto moreData;
 		}
 	    }
 
 	    if (bufPtr->nextPtr) {
-		/* There's a next buffer.  Shift orphan \r to it. */
+		/*
+                 * There's a next buffer.  Shift orphan \r to it.
+                 */
 
 		ChannelBuffer *nextPtr = bufPtr->nextPtr;
 
@@ -9900,8 +9938,8 @@ DoRead(
 	}
 
 	/*
-	 * When there's no buffered data to read, and we're at EOF,
-	 * escape to the caller.
+	 * When there's no buffered data to read, and we're at EOF, escape to
+	 * the caller.
 	 */
 
 	if (GotFlag(statePtr, CHANNEL_EOF)
@@ -9913,11 +9951,11 @@ DoRead(
 	ResetFlag(statePtr, CHANNEL_BLOCKED);
     }
 
-	assert(!GotFlag(statePtr, CHANNEL_EOF)
-		|| GotFlag(statePtr, CHANNEL_STICKY_EOF)
-		|| Tcl_InputBuffered((Tcl_Channel)chanPtr) == 0);
-	assert( !(GotFlag(statePtr, CHANNEL_EOF|CHANNEL_BLOCKED)
-		== (CHANNEL_EOF|CHANNEL_BLOCKED)) );
+    assert(!GotFlag(statePtr, CHANNEL_EOF)
+	    || GotFlag(statePtr, CHANNEL_STICKY_EOF)
+	    || Tcl_InputBuffered((Tcl_Channel)chanPtr) == 0);
+    assert(!(GotFlag(statePtr, CHANNEL_EOF|CHANNEL_BLOCKED)
+	    == (CHANNEL_EOF|CHANNEL_BLOCKED)));
     UpdateInterest(chanPtr);
     TclChannelRelease((Tcl_Channel)chanPtr);
     return (int)(p - dst);
@@ -10012,16 +10050,10 @@ StopCopy(
 	Tcl_DeleteChannelHandler(inChan, MBEvent, csPtr);
 	Tcl_DeleteChannelHandler(outChan, MBEvent, csPtr);
 	TclDecrRefCount(csPtr->cmdPtr);
-	csPtr->cmdPtr = NULL;
-    }
-    if (inStatePtr->csPtrR == NULL) {
-	return;
     }
-    ReleaseCopyState(inStatePtr->csPtrR);
     inStatePtr->csPtrR = NULL;
-    ReleaseCopyState(outStatePtr->csPtrW);
     outStatePtr->csPtrW = NULL;
-    ReleaseCopyState(csPtr);
+    ckfree(csPtr);
 }
 
 /*
@@ -11160,78 +11192,16 @@ DupChannelIntRep(
     register Tcl_Obj *copyPtr)	/* Object with internal rep to set. Must not
 				 * currently have an internal rep.*/
 {
-    ChannelState *statePtr  = GET_CHANNELSTATE(srcPtr);
+    ResolvedChanName *resPtr = srcPtr->internalRep.twoPtrValue.ptr1;
 
-    SET_CHANNELSTATE(copyPtr, statePtr);
-    SET_CHANNELINTERP(copyPtr, GET_CHANNELINTERP(srcPtr));
-    Tcl_Preserve(statePtr);
+    resPtr->refCount++;
+    copyPtr->internalRep.twoPtrValue.ptr1 = resPtr;
     copyPtr->typePtr = srcPtr->typePtr;
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * SetChannelFromAny --
- *
- *	Create an internal representation of type "Channel" for an object.
- *
- * Results:
- *	This operation always succeeds and returns TCL_OK.
- *
- * Side effects:
- *	Any old internal reputation for objPtr is freed and the internal
- *	representation is set to "Channel".
- *
- *----------------------------------------------------------------------
- */
-
-static int
-SetChannelFromAny(
-    Tcl_Interp *interp,		/* Used for error reporting if not NULL. */
-    register Tcl_Obj *objPtr)	/* The object to convert. */
-{
-    ChannelState *statePtr;
-
-    if (interp == NULL) {
-	return TCL_ERROR;
-    }
-    if (objPtr->typePtr == &chanObjType) {
-	/*
-	 * TODO: TAINT Flag and dup'd channel values?
-	 * The channel is valid until any call to DetachChannel occurs.
-	 * Ensure consistency checks are done.
-	 */
-
-	statePtr = GET_CHANNELSTATE(objPtr);
-	if (GotFlag(statePtr, CHANNEL_TAINTED|CHANNEL_CLOSED)) {
-	    ResetFlag(statePtr, CHANNEL_TAINTED);
-	    Tcl_Release(statePtr);
-	    objPtr->typePtr = NULL;
-	} else if (interp != GET_CHANNELINTERP(objPtr)) {
-	    Tcl_Release(statePtr);
-	    objPtr->typePtr = NULL;
-	}
-    }
-    if (objPtr->typePtr != &chanObjType) {
-	Tcl_Channel chan = Tcl_GetChannel(interp, TclGetString(objPtr), NULL);
-
-	if (chan == NULL) {
-	    return TCL_ERROR;
-	}
-
-	TclFreeIntRep(objPtr);
-	statePtr = ((Channel *) chan)->state;
-	Tcl_Preserve(statePtr);
-	SET_CHANNELSTATE(objPtr, statePtr);
-	SET_CHANNELINTERP(objPtr, interp);
-	objPtr->typePtr = &chanObjType;
-    }
-    return TCL_OK;
-}
-
-/*
- *----------------------------------------------------------------------
- *
  * FreeChannelIntRep --
  *
  *	Release statePtr storage.
@@ -11249,8 +11219,14 @@ static void
 FreeChannelIntRep(
     Tcl_Obj *objPtr)		/* Object with internal rep to free. */
 {
-    Tcl_Release(GET_CHANNELSTATE(objPtr));
+    ResolvedChanName *resPtr = objPtr->internalRep.twoPtrValue.ptr1;
+
     objPtr->typePtr = NULL;
+    if (resPtr->refCount-- > 1) {
+	return;
+    }
+    Tcl_Release(resPtr->statePtr);
+    ckfree(resPtr);
 }
 
 #if 0