Merge commit '29ccecd87709feda60d191f6aaba324ccad91f55' as 'tcl8.6'

1 files changed, 11250 insertions, 0 deletions

diff --git a/tcl8.6/generic/tclIO.c b/tcl8.6/generic/tclIO.c
new file mode 100644
index 0000000..64501fd
--- /dev/null
+++ b/tcl8.6/generic/tclIO.c
@@ -0,0 +1,11250 @@
+/*
+ * tclIO.c --
+ *
+ *	This file provides the generic portions (those that are the same on
+ *	all platforms and for all channel types) of Tcl's IO facilities.
+ *
+ * Copyright (c) 1998-2000 Ajuba Solutions
+ * Copyright (c) 1995-1997 Sun Microsystems, Inc.
+ * Contributions from Don Porter, NIST, 2014. (not subject to US copyright)
+ *
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ */
+
+#include "tclInt.h"
+#include "tclIO.h"
+#include <assert.h>
+
+/*
+ * For each channel handler registered in a call to Tcl_CreateChannelHandler,
+ * there is one record of the following type. All of records for a specific
+ * channel are chained together in a singly linked list which is stored in
+ * the channel structure.
+ */
+
+typedef struct ChannelHandler {
+    Channel *chanPtr;		/* The channel structure for this channel. */
+    int mask;			/* Mask of desired events. */
+    Tcl_ChannelProc *proc;	/* Procedure to call in the type of
+				 * Tcl_CreateChannelHandler. */
+    ClientData clientData;	/* Argument to pass to procedure. */
+    struct ChannelHandler *nextPtr;
+				/* Next one in list of registered handlers. */
+} ChannelHandler;
+
+/*
+ * This structure keeps track of the current ChannelHandler being invoked in
+ * the current invocation of Tcl_NotifyChannel. There is a potential
+ * problem if a ChannelHandler is deleted while it is the current one, since
+ * Tcl_NotifyChannel needs to look at the nextPtr field. To handle this
+ * problem, structures of the type below indicate the next handler to be
+ * processed for any (recursively nested) dispatches in progress. The
+ * nextHandlerPtr field is updated if the handler being pointed to is deleted.
+ * The nestedHandlerPtr field is used to chain together all recursive
+ * invocations, so that Tcl_DeleteChannelHandler can find all the recursively
+ * nested invocations of Tcl_NotifyChannel and compare the handler being
+ * deleted against the NEXT handler to be invoked in that invocation; when it
+ * finds such a situation, Tcl_DeleteChannelHandler updates the nextHandlerPtr
+ * field of the structure to the next handler.
+ */
+
+typedef struct NextChannelHandler {
+    ChannelHandler *nextHandlerPtr;	/* The next handler to be invoked in
+					 * this invocation. */
+    struct NextChannelHandler *nestedHandlerPtr;
+					/* Next nested invocation of
+					 * Tcl_NotifyChannel. */
+} NextChannelHandler;
+
+/*
+ * The following structure is used by Tcl_GetsObj() to encapsulates the
+ * state for a "gets" operation.
+ */
+
+typedef struct GetsState {
+    Tcl_Obj *objPtr;		/* The object to which UTF-8 characters
+				 * will be appended. */
+    char **dstPtr;		/* Pointer into objPtr's string rep where
+				 * next character should be stored. */
+    Tcl_Encoding encoding;	/* The encoding to use to convert raw bytes
+				 * to UTF-8.  */
+    ChannelBuffer *bufPtr;	/* The current buffer of raw bytes being
+				 * emptied. */
+    Tcl_EncodingState state;	/* The encoding state just before the last
+				 * external to UTF-8 conversion in
+				 * FilterInputBytes(). */
+    int rawRead;		/* The number of bytes removed from bufPtr
+				 * in the last call to FilterInputBytes(). */
+    int bytesWrote;		/* The number of bytes of UTF-8 data
+				 * appended to objPtr during the last call to
+				 * FilterInputBytes(). */
+    int charsWrote;		/* The corresponding number of UTF-8
+				 * characters appended to objPtr during the
+				 * last call to FilterInputBytes(). */
+    int totalChars;		/* The total number of UTF-8 characters
+				 * appended to objPtr so far, just before the
+				 * last call to FilterInputBytes(). */
+} GetsState;
+
+/*
+ * The following structure encapsulates the state for a background channel
+ * copy.  Note that the data buffer for the copy will be appended to this
+ * structure.
+ */
+
+typedef struct CopyState {
+    struct Channel *readPtr;	/* Pointer to input channel. */
+    struct Channel *writePtr;	/* Pointer to output channel. */
+    int readFlags;		/* Original read channel flags. */
+    int writeFlags;		/* Original write channel flags. */
+    Tcl_WideInt toRead;		/* Number of bytes to copy, or -1. */
+    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 bufSize;		/* Size of appended buffer. */
+    char buffer[1];		/* Copy buffer, this must be the last
+                                 * field. */
+} CopyState;
+
+/*
+ * All static variables used in this file are collected into a single instance
+ * of the following structure. For multi-threaded implementations, there is
+ * one instance of this structure for each thread.
+ *
+ * Notice that different structures with the same name appear in other files.
+ * The structure defined below is used in this file only.
+ */
+
+typedef struct ThreadSpecificData {
+    NextChannelHandler *nestedHandlerPtr;
+				/* This variable holds the list of nested
+				 * Tcl_NotifyChannel invocations. */
+    ChannelState *firstCSPtr;	/* List of all channels currently open,
+				 * indexed by ChannelState, as only one
+				 * ChannelState exists per set of stacked
+				 * channels. */
+    Tcl_Channel stdinChannel;	/* Static variable for the stdin channel. */
+    int stdinInitialized;
+    Tcl_Channel stdoutChannel;	/* Static variable for the stdout channel. */
+    int stdoutInitialized;
+    Tcl_Channel stderrChannel;	/* Static variable for the stderr channel. */
+    int stderrInitialized;
+    Tcl_Encoding binaryEncoding;
+} ThreadSpecificData;
+
+static Tcl_ThreadDataKey dataKey;
+
+/*
+ * Structure to record a close callback. One such record exists for
+ * each close callback registered for a channel.
+ */
+
+typedef struct CloseCallback {
+    Tcl_CloseProc *proc;		/* The procedure to call. */
+    ClientData clientData;		/* Arbitrary one-word data to pass
+					 * to the callback. */
+    struct CloseCallback *nextPtr;	/* For chaining close callbacks. */
+} CloseCallback;
+
+/*
+ * Static functions in this file:
+ */
+
+static ChannelBuffer *	AllocChannelBuffer(int length);
+static void		PreserveChannelBuffer(ChannelBuffer *bufPtr);
+static void		ReleaseChannelBuffer(ChannelBuffer *bufPtr);
+static int		IsShared(ChannelBuffer *bufPtr);
+static void		ChannelFree(Channel *chanPtr);
+static void		ChannelTimerProc(ClientData clientData);
+static int		ChanRead(Channel *chanPtr, char *dst, int dstSize);
+static int		CheckChannelErrors(ChannelState *statePtr,
+			    int direction);
+static int		CheckForDeadChannel(Tcl_Interp *interp,
+			    ChannelState *statePtr);
+static void		CheckForStdChannelsBeingClosed(Tcl_Channel chan);
+static void		CleanupChannelHandlers(Tcl_Interp *interp,
+			    Channel *chanPtr);
+static int		CloseChannel(Tcl_Interp *interp, Channel *chanPtr,
+			    int errorCode);
+static int		CloseChannelPart(Tcl_Interp *interp, Channel *chanPtr,
+			    int errorCode, int flags);
+static int		CloseWrite(Tcl_Interp *interp, Channel *chanPtr);
+static void		CommonGetsCleanup(Channel *chanPtr);
+static int		CopyData(CopyState *csPtr, int mask);
+static int		MoveBytes(CopyState *csPtr);
+
+static void		MBCallback(CopyState *csPtr, Tcl_Obj *errObj);
+static void		MBError(CopyState *csPtr, int mask, int errorCode);
+static int		MBRead(CopyState *csPtr);
+static int		MBWrite(CopyState *csPtr);
+static void		MBEvent(ClientData clientData, int mask);
+
+static void		CopyEventProc(ClientData clientData, int mask);
+static void		CreateScriptRecord(Tcl_Interp *interp,
+			    Channel *chanPtr, int mask, Tcl_Obj *scriptPtr);
+static void		DeleteChannelTable(ClientData clientData,
+			    Tcl_Interp *interp);
+static void		DeleteScriptRecord(Tcl_Interp *interp,
+			    Channel *chanPtr, int mask);
+static int		DetachChannel(Tcl_Interp *interp, Tcl_Channel chan);
+static void		DiscardInputQueued(ChannelState *statePtr,
+			    int discardSavedBuffers);
+static void		DiscardOutputQueued(ChannelState *chanPtr);
+static int		DoRead(Channel *chanPtr, char *dst, int bytesToRead,
+			    int allowShortReads);
+static int		DoReadChars(Channel *chan, Tcl_Obj *objPtr, int toRead,
+			    int appendFlag);
+static int		FilterInputBytes(Channel *chanPtr,
+			    GetsState *statePtr);
+static int		FlushChannel(Tcl_Interp *interp, Channel *chanPtr,
+			    int calledFromAsyncFlush);
+static int		TclGetsObjBinary(Tcl_Channel chan, Tcl_Obj *objPtr);
+static Tcl_Encoding	GetBinaryEncoding();
+static void		FreeBinaryEncoding(ClientData clientData);
+static Tcl_HashTable *	GetChannelTable(Tcl_Interp *interp);
+static int		GetInput(Channel *chanPtr);
+static int		HaveVersion(const Tcl_ChannelType *typePtr,
+			    Tcl_ChannelTypeVersion minimumVersion);
+static void		PeekAhead(Channel *chanPtr, char **dstEndPtr,
+			    GetsState *gsPtr);
+static int		ReadBytes(ChannelState *statePtr, Tcl_Obj *objPtr,
+			    int charsLeft);
+static int		ReadChars(ChannelState *statePtr, Tcl_Obj *objPtr,
+			    int charsLeft, int *factorPtr);
+static void		RecycleBuffer(ChannelState *statePtr,
+			    ChannelBuffer *bufPtr, int mustDiscard);
+static int		StackSetBlockMode(Channel *chanPtr, int mode);
+static int		SetBlockMode(Tcl_Interp *interp, Channel *chanPtr,
+			    int mode);
+static void		StopCopy(CopyState *csPtr);
+static void		TranslateInputEOL(ChannelState *statePtr, char *dst,
+			    const char *src, int *dstLenPtr, int *srcLenPtr);
+static void		UpdateInterest(Channel *chanPtr);
+static int		Write(Channel *chanPtr, const char *src,
+			    int srcLen, Tcl_Encoding encoding);
+static Tcl_Obj *	FixLevelCode(Tcl_Obj *msg);
+static void		SpliceChannel(Tcl_Channel chan);
+static void		CutChannel(Tcl_Channel chan);
+static int              WillRead(Channel *chanPtr);
+
+#define WriteChars(chanPtr, src, srcLen) \
+			Write(chanPtr, src, srcLen, chanPtr->state->encoding)
+#define WriteBytes(chanPtr, src, srcLen) \
+			Write(chanPtr, src, srcLen, tclIdentityEncoding)
+
+/*
+ * Simplifying helper macros. All may use their argument(s) multiple times.
+ * The ANSI C "prototypes" for the macros are listed below, together with a
+ * short description of what the macro does.
+ *
+ * --------------------------------------------------------------------------
+ * int BytesLeft(ChannelBuffer *bufPtr)
+ *
+ *	Returns the number of bytes of data remaining in the buffer.
+ *
+ * int SpaceLeft(ChannelBuffer *bufPtr)
+ *
+ *	Returns the number of bytes of space remaining at the end of the
+ *	buffer.
+ *
+ * int IsBufferReady(ChannelBuffer *bufPtr)
+ *
+ *	Returns whether a buffer has bytes available within it.
+ *
+ * int IsBufferEmpty(ChannelBuffer *bufPtr)
+ *
+ *	Returns whether a buffer is entirely empty. Note that this is not the
+ *	inverse of the above operation; trying to merge the two seems to lead
+ *	to occasional crashes...
+ *
+ * int IsBufferFull(ChannelBuffer *bufPtr)
+ *
+ *	Returns whether more data can be added to a buffer.
+ *
+ * int IsBufferOverflowing(ChannelBuffer *bufPtr)
+ *
+ *	Returns whether a buffer has more data in it than it should.
+ *
+ * char *InsertPoint(ChannelBuffer *bufPtr)
+ *
+ *	Returns a pointer to where characters should be added to the buffer.
+ *
+ * char *RemovePoint(ChannelBuffer *bufPtr)
+ *
+ *	Returns a pointer to where characters should be removed from the
+ *	buffer.
+ * --------------------------------------------------------------------------
+ */
+
+#define BytesLeft(bufPtr)	((bufPtr)->nextAdded - (bufPtr)->nextRemoved)
+
+#define SpaceLeft(bufPtr)	((bufPtr)->bufLength - (bufPtr)->nextAdded)
+
+#define IsBufferReady(bufPtr)	((bufPtr)->nextAdded > (bufPtr)->nextRemoved)
+
+#define IsBufferEmpty(bufPtr)	((bufPtr)->nextAdded == (bufPtr)->nextRemoved)
+
+#define IsBufferFull(bufPtr)	((bufPtr) && (bufPtr)->nextAdded >= (bufPtr)->bufLength)
+
+#define IsBufferOverflowing(bufPtr) ((bufPtr)->nextAdded>(bufPtr)->bufLength)
+
+#define InsertPoint(bufPtr)	((bufPtr)->buf + (bufPtr)->nextAdded)
+
+#define RemovePoint(bufPtr)	((bufPtr)->buf + (bufPtr)->nextRemoved)
+
+/*
+ * For working with channel state flag bits.
+ */
+
+#define SetFlag(statePtr, flag)		((statePtr)->flags |= (flag))
+#define ResetFlag(statePtr, flag)	((statePtr)->flags &= ~(flag))
+#define GotFlag(statePtr, flag)		((statePtr)->flags & (flag))
+
+/*
+ * Macro for testing whether a string (in optionName, length len) matches a
+ * value (prefix matching rules). Arguments are the minimum length to match
+ * and the value to match against. (Can't use Tcl_GetIndexFromObj as this is
+ * used in a situation where no objects are available.)
+ */
+
+#define HaveOpt(minLength, nameString) \
+	((len > (minLength)) && (optionName[1] == (nameString)[1]) \
+		&& (strncmp(optionName, (nameString), len) == 0))
+
+/*
+ * 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. */
+    int epoch;			/* The epoch of the channel when the lookup
+				 * was done. Use to verify validity. */
+    int refCount;		/* Share this struct among many Tcl_Obj. */
+} ResolvedChanName;
+
+static void		DupChannelIntRep(Tcl_Obj *objPtr, Tcl_Obj *copyPtr);
+static void		FreeChannelIntRep(Tcl_Obj *objPtr);
+
+static const Tcl_ObjType chanObjType = {
+    "channel",			/* name for this type */
+    FreeChannelIntRep,		/* freeIntRepProc */
+    DupChannelIntRep,		/* dupIntRepProc */
+    NULL,			/* updateStringProc */
+    NULL			/* setFromAnyProc */
+};
+
+#define BUSY_STATE(st, fl) \
+     ((((st)->csPtrR) && ((fl) & TCL_READABLE)) || \
+      (((st)->csPtrW) && ((fl) & TCL_WRITABLE)))
+
+#define MAX_CHANNEL_BUFFER_SIZE (1024*1024)
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * ChanClose, ChanRead, ChanSeek, ChanThreadAction, ChanWatch, ChanWrite --
+ *
+ *	Simplify the access to selected channel driver "methods" that are used
+ *	in multiple places in a stereotypical fashion. These are just thin
+ *	wrappers around the driver functions.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+static inline int
+ChanClose(
+    Channel *chanPtr,
+    Tcl_Interp *interp)
+{
+    if (chanPtr->typePtr->closeProc != TCL_CLOSE2PROC) {
+	return chanPtr->typePtr->closeProc(chanPtr->instanceData, interp);
+    } else {
+	return chanPtr->typePtr->close2Proc(chanPtr->instanceData, interp, 0);
+    }
+}
+
+static inline int
+ChanCloseHalf(
+    Channel *chanPtr,
+    Tcl_Interp *interp,
+    int flags)
+{
+    return chanPtr->typePtr->close2Proc(chanPtr->instanceData, interp, flags);
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * ChanRead --
+ *
+ *	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().
+ *
+ * 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.
+ *	TODO - Is this really the right place for that?
+ *
+ *---------------------------------------------------------------------------
+ */
+static int
+ChanRead(
+    Channel *chanPtr,
+    char *dst,
+    int dstSize)
+{
+    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.
+     */
+    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;
+    }
+    ResetFlag(chanPtr->state, CHANNEL_BLOCKED | CHANNEL_EOF);
+    chanPtr->state->inputEncodingFlags &= ~TCL_ENCODING_END;
+    if (WillRead(chanPtr) < 0) {
+        return -1;
+    }
+
+    bytesRead = chanPtr->typePtr->inputProc(chanPtr->instanceData,
+	    dst, dstSize, &result);
+
+    /* Stop any flag leakage through stacked channel levels */
+    if (GotFlag(chanPtr->state, CHANNEL_EOF)) {
+        chanPtr->state->inputEncodingFlags |= TCL_ENCODING_START;
+    }
+    ResetFlag(chanPtr->state, CHANNEL_BLOCKED | CHANNEL_EOF);
+    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 (bytesRead < dstSize) {
+	    SetFlag(chanPtr->state, CHANNEL_BLOCKED);
+	}
+    } else if (bytesRead == 0) {
+	SetFlag(chanPtr->state, CHANNEL_EOF);
+	chanPtr->state->inputEncodingFlags |= TCL_ENCODING_END;
+    } else if (bytesRead < 0) {
+	if ((result == EWOULDBLOCK) || (result == EAGAIN)) {
+	    SetFlag(chanPtr->state, CHANNEL_BLOCKED);
+	    result = EAGAIN;
+	}
+	Tcl_SetErrno(result);
+    }
+    return bytesRead;
+}
+
+static inline Tcl_WideInt
+ChanSeek(
+    Channel *chanPtr,
+    Tcl_WideInt offset,
+    int mode,
+    int *errnoPtr)
+{
+    /*
+     * Note that we prefer the wideSeekProc if that field is available in the
+     * type and non-NULL.
+     */
+
+    if (HaveVersion(chanPtr->typePtr, TCL_CHANNEL_VERSION_3) &&
+	    chanPtr->typePtr->wideSeekProc != NULL) {
+	return chanPtr->typePtr->wideSeekProc(chanPtr->instanceData,
+		offset, mode, errnoPtr);
+    }
+
+    if (offset<Tcl_LongAsWide(LONG_MIN) || offset>Tcl_LongAsWide(LONG_MAX)) {
+	*errnoPtr = EOVERFLOW;
+	return Tcl_LongAsWide(-1);
+    }
+
+    return Tcl_LongAsWide(chanPtr->typePtr->seekProc(chanPtr->instanceData,
+	    Tcl_WideAsLong(offset), mode, errnoPtr));
+}
+
+static inline void
+ChanThreadAction(
+    Channel *chanPtr,
+    int action)
+{
+    Tcl_DriverThreadActionProc *threadActionProc =
+	    Tcl_ChannelThreadActionProc(chanPtr->typePtr);
+
+    if (threadActionProc != NULL) {
+	threadActionProc(chanPtr->instanceData, action);
+    }
+}
+
+static inline void
+ChanWatch(
+    Channel *chanPtr,
+    int mask)
+{
+    chanPtr->typePtr->watchProc(chanPtr->instanceData, mask);
+}
+
+static inline int
+ChanWrite(
+    Channel *chanPtr,
+    const char *src,
+    int srcLen,
+    int *errnoPtr)
+{
+    return chanPtr->typePtr->outputProc(chanPtr->instanceData, src, srcLen,
+	    errnoPtr);
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * TclInitIOSubsystem --
+ *
+ *	Initialize all resources used by this subsystem on a per-process
+ *	basis.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Depends on the memory subsystems.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+void
+TclInitIOSubsystem(void)
+{
+    /*
+     * By fetching thread local storage we take care of allocating it for each
+     * thread.
+     */
+
+    (void) TCL_TSD_INIT(&dataKey);
+}
+
+/*
+ *-------------------------------------------------------------------------
+ *
+ * TclFinalizeIOSubsystem --
+ *
+ *	Releases all resources used by this subsystem on a per-process basis.
+ *	Closes all extant channels that have not already been closed because
+ *	they were not owned by any interp.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Depends on encoding and memory subsystems.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+	/* ARGSUSED */
+void
+TclFinalizeIOSubsystem(void)
+{
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+    Channel *chanPtr = NULL;	/* Iterates over open channels. */
+    ChannelState *statePtr;	/* State of channel stack */
+    int active = 1;		/* Flag == 1 while there's still work to do */
+    int doflushnb;
+
+    /* Fetch the pre-TIP#398 compatibility flag */
+    {
+        const char *s;
+        Tcl_DString ds;
+
+        s = TclGetEnv("TCL_FLUSH_NONBLOCKING_ON_EXIT", &ds);
+        doflushnb = ((s != NULL) && strcmp(s, "0"));
+        if (s != NULL) {
+            Tcl_DStringFree(&ds);
+        }
+    }
+
+    /*
+     * Walk all channel state structures known to this thread and close
+     * corresponding channels.
+     */
+
+    while (active) {
+	/*
+	 * Iterate through the open channel list, and find the first channel
+	 * that isn't dead. We start from the head of the list each time,
+	 * because the close action on one channel can close others.
+	 */
+
+	active = 0;
+	for (statePtr = tsdPtr->firstCSPtr;
+		statePtr != NULL;
+		statePtr = statePtr->nextCSPtr) {
+	    chanPtr = statePtr->topChanPtr;
+            if (GotFlag(statePtr, CHANNEL_DEAD)) {
+                continue;
+            }
+	    if (!GotFlag(statePtr, CHANNEL_INCLOSE | CHANNEL_CLOSED )
+                || GotFlag(statePtr, BG_FLUSH_SCHEDULED)) {
+                ResetFlag(statePtr, BG_FLUSH_SCHEDULED);
+		active = 1;
+		break;
+	    }
+	}
+
+	/*
+	 * We've found a live (or bg-closing) channel. Close it.
+	 */
+
+	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
+             * and not be "0".
+	     */
+            if (doflushnb) {
+                    /* 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");
+            }
+
+	    if ((chanPtr == (Channel *) tsdPtr->stdinChannel) ||
+		    (chanPtr == (Channel *) tsdPtr->stdoutChannel) ||
+		    (chanPtr == (Channel *) tsdPtr->stderrChannel)) {
+		/*
+		 * Decrement the refcount which was earlier artificially
+		 * bumped up to keep the channel from being closed.
+		 */
+
+		statePtr->refCount--;
+	    }
+
+	    if (statePtr->refCount <= 0) {
+		/*
+		 * Close it only if the refcount indicates that the channel is
+		 * not referenced from any interpreter. If it is, that
+		 * interpreter will close the channel when it gets destroyed.
+		 */
+
+		(void) Tcl_Close(NULL, (Tcl_Channel) chanPtr);
+	    } else {
+		/*
+		 * The refcount is greater than zero, so flush the channel.
+		 */
+
+		Tcl_Flush((Tcl_Channel) chanPtr);
+
+		/*
+		 * Call the device driver to actually close the underlying
+		 * device for this channel.
+		 */
+
+		(void) ChanClose(chanPtr, NULL);
+
+		/*
+		 * Finally, we clean up the fields in the channel data
+		 * structure since all of them have been deleted already. We
+		 * mark the channel with CHANNEL_DEAD to prevent any further
+		 * IO operations on it.
+		 */
+
+		chanPtr->instanceData = NULL;
+		SetFlag(statePtr, CHANNEL_DEAD);
+	    }
+	    TclChannelRelease((Tcl_Channel)chanPtr);
+	}
+    }
+
+    TclpFinalizeSockets();
+    TclpFinalizePipes();
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_SetStdChannel --
+ *
+ *	This function is used to change the channels that are used for
+ *	stdin/stdout/stderr in new interpreters.
+ *
+ * Results:
+ *	None
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_SetStdChannel(
+    Tcl_Channel channel,
+    int type)			/* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */
+{
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    switch (type) {
+    case TCL_STDIN:
+	tsdPtr->stdinInitialized = 1;
+	tsdPtr->stdinChannel = channel;
+	break;
+    case TCL_STDOUT:
+	tsdPtr->stdoutInitialized = 1;
+	tsdPtr->stdoutChannel = channel;
+	break;
+    case TCL_STDERR:
+	tsdPtr->stderrInitialized = 1;
+	tsdPtr->stderrChannel = channel;
+	break;
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GetStdChannel --
+ *
+ *	Returns the specified standard channel.
+ *
+ * Results:
+ *	Returns the specified standard channel, or NULL.
+ *
+ * Side effects:
+ *	May cause the creation of a standard channel and the underlying file.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_Channel
+Tcl_GetStdChannel(
+    int type)			/* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */
+{
+    Tcl_Channel channel = NULL;
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    /*
+     * If the channels were not created yet, create them now and store them in
+     * the static variables.
+     */
+
+    switch (type) {
+    case TCL_STDIN:
+	if (!tsdPtr->stdinInitialized) {
+	    tsdPtr->stdinChannel = TclpGetDefaultStdChannel(TCL_STDIN);
+	    tsdPtr->stdinInitialized = 1;
+
+	    /*
+	     * Artificially bump the refcount to ensure that the channel is
+	     * only closed on exit.
+	     *
+	     * NOTE: Must only do this if stdinChannel is not NULL. It can be
+	     * NULL in situations where Tcl is unable to connect to the
+	     * standard input.
+	     */
+
+	    if (tsdPtr->stdinChannel != NULL) {
+		Tcl_RegisterChannel(NULL, tsdPtr->stdinChannel);
+	    }
+	}
+	channel = tsdPtr->stdinChannel;
+	break;
+    case TCL_STDOUT:
+	if (!tsdPtr->stdoutInitialized) {
+	    tsdPtr->stdoutChannel = TclpGetDefaultStdChannel(TCL_STDOUT);
+	    tsdPtr->stdoutInitialized = 1;
+	    if (tsdPtr->stdoutChannel != NULL) {
+		Tcl_RegisterChannel(NULL, tsdPtr->stdoutChannel);
+	    }
+	}
+	channel = tsdPtr->stdoutChannel;
+	break;
+    case TCL_STDERR:
+	if (!tsdPtr->stderrInitialized) {
+	    tsdPtr->stderrChannel = TclpGetDefaultStdChannel(TCL_STDERR);
+	    tsdPtr->stderrInitialized = 1;
+	    if (tsdPtr->stderrChannel != NULL) {
+		Tcl_RegisterChannel(NULL, tsdPtr->stderrChannel);
+	    }
+	}
+	channel = tsdPtr->stderrChannel;
+	break;
+    }
+    return channel;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_CreateCloseHandler
+ *
+ *	Creates a close callback which will be called when the channel is
+ *	closed.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Causes the callback to be called in the future when the channel will
+ *	be closed.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_CreateCloseHandler(
+    Tcl_Channel chan,		/* The channel for which to create the close
+				 * callback. */
+    Tcl_CloseProc *proc,	/* The callback routine to call when the
+				 * channel will be closed. */
+    ClientData clientData)	/* Arbitrary data to pass to the close
+				 * callback. */
+{
+    ChannelState *statePtr = ((Channel *) chan)->state;
+    CloseCallback *cbPtr;
+
+    cbPtr = ckalloc(sizeof(CloseCallback));
+    cbPtr->proc = proc;
+    cbPtr->clientData = clientData;
+
+    cbPtr->nextPtr = statePtr->closeCbPtr;
+    statePtr->closeCbPtr = cbPtr;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_DeleteCloseHandler --
+ *
+ *	Removes a callback that would have been called on closing the channel.
+ *	If there is no matching callback then this function has no effect.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The callback will not be called in the future when the channel is
+ *	eventually closed.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_DeleteCloseHandler(
+    Tcl_Channel chan,		/* The channel for which to cancel the close
+				 * callback. */
+    Tcl_CloseProc *proc,	/* The procedure for the callback to
+				 * remove. */
+    ClientData clientData)	/* The callback data for the callback to
+				 * remove. */
+{
+    ChannelState *statePtr = ((Channel *) chan)->state;
+    CloseCallback *cbPtr, *cbPrevPtr;
+
+    for (cbPtr = statePtr->closeCbPtr, cbPrevPtr = NULL;
+	    cbPtr != NULL; cbPtr = cbPtr->nextPtr) {
+	if ((cbPtr->proc == proc) && (cbPtr->clientData == clientData)) {
+	    if (cbPrevPtr == NULL) {
+		statePtr->closeCbPtr = cbPtr->nextPtr;
+	    } else {
+		cbPrevPtr->nextPtr = cbPtr->nextPtr;
+	    }
+	    ckfree(cbPtr);
+	    break;
+	}
+	cbPrevPtr = cbPtr;
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * GetChannelTable --
+ *
+ *	Gets and potentially initializes the channel table for an interpreter.
+ *	If it is initializing the table it also inserts channels for stdin,
+ *	stdout and stderr if the interpreter is trusted.
+ *
+ * Results:
+ *	A pointer to the hash table created, for use by the caller.
+ *
+ * Side effects:
+ *	Initializes the channel table for an interpreter. May create channels
+ *	for stdin, stdout and stderr.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static Tcl_HashTable *
+GetChannelTable(
+    Tcl_Interp *interp)
+{
+    Tcl_HashTable *hTblPtr;	/* Hash table of channels. */
+    Tcl_Channel stdinChan, stdoutChan, stderrChan;
+
+    hTblPtr = Tcl_GetAssocData(interp, "tclIO", NULL);
+    if (hTblPtr == NULL) {
+	hTblPtr = ckalloc(sizeof(Tcl_HashTable));
+	Tcl_InitHashTable(hTblPtr, TCL_STRING_KEYS);
+	Tcl_SetAssocData(interp, "tclIO",
+		(Tcl_InterpDeleteProc *) DeleteChannelTable, hTblPtr);
+
+	/*
+	 * If the interpreter is trusted (not "safe"), insert channels for
+	 * stdin, stdout and stderr (possibly creating them in the process).
+	 */
+
+	if (Tcl_IsSafe(interp) == 0) {
+	    stdinChan = Tcl_GetStdChannel(TCL_STDIN);
+	    if (stdinChan != NULL) {
+		Tcl_RegisterChannel(interp, stdinChan);
+	    }
+	    stdoutChan = Tcl_GetStdChannel(TCL_STDOUT);
+	    if (stdoutChan != NULL) {
+		Tcl_RegisterChannel(interp, stdoutChan);
+	    }
+	    stderrChan = Tcl_GetStdChannel(TCL_STDERR);
+	    if (stderrChan != NULL) {
+		Tcl_RegisterChannel(interp, stderrChan);
+	    }
+	}
+    }
+    return hTblPtr;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * DeleteChannelTable --
+ *
+ *	Deletes the channel table for an interpreter, closing any open
+ *	channels whose refcount reaches zero. This procedure is invoked when
+ *	an interpreter is deleted, via the AssocData cleanup mechanism.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Deletes the hash table of channels. May close channels. May flush
+ *	output on closed channels. Removes any channeEvent handlers that were
+ *	registered in this interpreter.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+DeleteChannelTable(
+    ClientData clientData,	/* The per-interpreter data structure. */
+    Tcl_Interp *interp)		/* The interpreter being deleted. */
+{
+    Tcl_HashTable *hTblPtr;	/* The hash table. */
+    Tcl_HashSearch hSearch;	/* Search variable. */
+    Tcl_HashEntry *hPtr;	/* Search variable. */
+    Channel *chanPtr;		/* Channel being deleted. */
+    ChannelState *statePtr;	/* State of Channel being deleted. */
+    EventScriptRecord *sPtr, *prevPtr, *nextPtr;
+				/* Variables to loop over all channel events
+				 * registered, to delete the ones that refer
+				 * to the interpreter being deleted. */
+
+    /*
+     * Delete all the registered channels - this will close channels whose
+     * refcount reaches zero.
+     */
+
+    hTblPtr = clientData;
+    for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch); hPtr != NULL;
+	    hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch)) {
+	chanPtr = Tcl_GetHashValue(hPtr);
+	statePtr = chanPtr->state;
+
+	/*
+	 * Remove any fileevents registered in this interpreter.
+	 */
+
+	for (sPtr = statePtr->scriptRecordPtr, prevPtr = NULL;
+		sPtr != NULL; sPtr = nextPtr) {
+	    nextPtr = sPtr->nextPtr;
+	    if (sPtr->interp == interp) {
+		if (prevPtr == NULL) {
+		    statePtr->scriptRecordPtr = nextPtr;
+		} else {
+		    prevPtr->nextPtr = nextPtr;
+		}
+
+		Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
+			TclChannelEventScriptInvoker, sPtr);
+
+		TclDecrRefCount(sPtr->scriptPtr);
+		ckfree(sPtr);
+	    } else {
+		prevPtr = sPtr;
+	    }
+	}
+
+	/*
+	 * Cannot call Tcl_UnregisterChannel because that procedure calls
+	 * Tcl_GetAssocData to get the channel table, which might already be
+	 * inaccessible from the interpreter structure. Instead, we emulate
+	 * the behavior of Tcl_UnregisterChannel directly here.
+	 */
+
+	Tcl_DeleteHashEntry(hPtr);
+	statePtr->epoch++;
+	if (statePtr->refCount-- <= 1) {
+	    if (!GotFlag(statePtr, BG_FLUSH_SCHEDULED)) {
+		(void) Tcl_Close(interp, (Tcl_Channel) chanPtr);
+	    }
+	}
+
+    }
+    Tcl_DeleteHashTable(hTblPtr);
+    ckfree(hTblPtr);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * CheckForStdChannelsBeingClosed --
+ *
+ *	Perform special handling for standard channels being closed. When
+ *	given a standard channel, if the refcount is now 1, it means that the
+ *	last reference to the standard channel is being explicitly closed. Now
+ *	bump the refcount artificially down to 0, to ensure the normal
+ *	handling of channels being closed will occur. Also reset the static
+ *	pointer to the channel to NULL, to avoid dangling references.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Manipulates the refcount on standard channels. May smash the global
+ *	static pointer to a standard channel.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+CheckForStdChannelsBeingClosed(
+    Tcl_Channel chan)
+{
+    ChannelState *statePtr = ((Channel *) chan)->state;
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    if (tsdPtr->stdinInitialized
+	    && tsdPtr->stdinChannel != NULL
+	    && statePtr == ((Channel *)tsdPtr->stdinChannel)->state) {
+	if (statePtr->refCount < 2) {
+	    statePtr->refCount = 0;
+	    tsdPtr->stdinChannel = NULL;
+	    return;
+	}
+    } else if (tsdPtr->stdoutInitialized
+	    && tsdPtr->stdoutChannel != NULL
+	    && statePtr == ((Channel *)tsdPtr->stdoutChannel)->state) {
+	if (statePtr->refCount < 2) {
+	    statePtr->refCount = 0;
+	    tsdPtr->stdoutChannel = NULL;
+	    return;
+	}
+    } else if (tsdPtr->stderrInitialized
+	    && tsdPtr->stderrChannel != NULL
+	    && statePtr == ((Channel *)tsdPtr->stderrChannel)->state) {
+	if (statePtr->refCount < 2) {
+	    statePtr->refCount = 0;
+	    tsdPtr->stderrChannel = NULL;
+	    return;
+	}
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_IsStandardChannel --
+ *
+ *	Test if the given channel is a standard channel. No attempt is made to
+ *	check if the channel or the standard channels are initialized or
+ *	otherwise valid.
+ *
+ * Results:
+ *	Returns 1 if true, 0 if false.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_IsStandardChannel(
+    Tcl_Channel chan)		/* Channel to check. */
+{
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    if ((chan == tsdPtr->stdinChannel)
+	    || (chan == tsdPtr->stdoutChannel)
+	    || (chan == tsdPtr->stderrChannel)) {
+	return 1;
+    } else {
+	return 0;
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_RegisterChannel --
+ *
+ *	Adds an already-open channel to the channel table of an interpreter.
+ *	If the interpreter passed as argument is NULL, it only increments the
+ *	channel refCount.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	May increment the reference count of a channel.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_RegisterChannel(
+    Tcl_Interp *interp,		/* Interpreter in which to add the channel. */
+    Tcl_Channel chan)		/* The channel to add to this interpreter
+				 * channel table. */
+{
+    Tcl_HashTable *hTblPtr;	/* Hash table of channels. */
+    Tcl_HashEntry *hPtr;	/* Search variable. */
+    int isNew;			/* Is the hash entry new or does it exist? */
+    Channel *chanPtr;		/* The actual channel. */
+    ChannelState *statePtr;	/* State of the actual channel. */
+
+    /*
+     * Always (un)register bottom-most channel in the stack. This makes
+     * management of the channel list easier because no manipulation is
+     * necessary during (un)stack operation.
+     */
+
+    chanPtr = ((Channel *) chan)->state->bottomChanPtr;
+    statePtr = chanPtr->state;
+
+    if (statePtr->channelName == NULL) {
+	Tcl_Panic("Tcl_RegisterChannel: channel without name");
+    }
+    if (interp != NULL) {
+	hTblPtr = GetChannelTable(interp);
+	hPtr = Tcl_CreateHashEntry(hTblPtr, statePtr->channelName, &isNew);
+	if (!isNew) {
+	    if (chan == Tcl_GetHashValue(hPtr)) {
+		return;
+	    }
+
+	    Tcl_Panic("Tcl_RegisterChannel: duplicate channel names");
+	}
+	Tcl_SetHashValue(hPtr, chanPtr);
+    }
+    statePtr->refCount++;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_UnregisterChannel --
+ *
+ *	Deletes the hash entry for a channel associated with an interpreter.
+ *	If the interpreter given as argument is NULL, it only decrements the
+ *	reference count. (This all happens in the Tcl_DetachChannel helper
+ *	function).
+ *
+ *	Finally, if the reference count of the channel drops to zero, it is
+ *	deleted.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	Calls Tcl_DetachChannel which deletes the hash entry for a channel
+ *	associated with an interpreter.
+ *
+ *	May delete the channel, which can have a variety of consequences,
+ *	especially if we are forced to close the channel.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_UnregisterChannel(
+    Tcl_Interp *interp,		/* Interpreter in which channel is defined. */
+    Tcl_Channel chan)		/* Channel to delete. */
+{
+    ChannelState *statePtr;	/* State of the real channel. */
+
+    statePtr = ((Channel *) chan)->state->bottomChanPtr->state;
+
+    if (GotFlag(statePtr, CHANNEL_INCLOSE)) {
+	if (interp != NULL) {
+	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
+                    "illegal recursive call to close through close-handler"
+                    " of channel", -1));
+	}
+	return TCL_ERROR;
+    }
+
+    if (DetachChannel(interp, chan) != TCL_OK) {
+	return TCL_OK;
+    }
+
+    statePtr = ((Channel *) chan)->state->bottomChanPtr->state;
+
+    /*
+     * Perform special handling for standard channels being closed. If the
+     * refCount is now 1 it means that the last reference to the standard
+     * channel is being explicitly closed, so bump the refCount down
+     * artificially to 0. This will ensure that the channel is actually
+     * closed, below. Also set the static pointer to NULL for the channel.
+     */
+
+    CheckForStdChannelsBeingClosed(chan);
+
+    /*
+     * If the refCount reached zero, close the actual channel.
+     */
+
+    if (statePtr->refCount <= 0) {
+	Tcl_Preserve(statePtr);
+	if (!GotFlag(statePtr, BG_FLUSH_SCHEDULED)) {
+	    /*
+	     * We don't want to re-enter Tcl_Close().
+	     */
+
+	    if (!GotFlag(statePtr, CHANNEL_CLOSED)) {
+		if (Tcl_Close(interp, chan) != TCL_OK) {
+		    SetFlag(statePtr, CHANNEL_CLOSED);
+		    Tcl_Release(statePtr);
+		    return TCL_ERROR;
+		}
+	    }
+	}
+	SetFlag(statePtr, CHANNEL_CLOSED);
+	Tcl_Release(statePtr);
+    }
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_DetachChannel --
+ *
+ *	Deletes the hash entry for a channel associated with an interpreter.
+ *	If the interpreter given as argument is NULL, it only decrements the
+ *	reference count. Even if the ref count drops to zero, the channel is
+ *	NOT closed or cleaned up. This allows a channel to be detached from an
+ *	interpreter and left in the same state it was in when it was
+ *	originally returned by 'Tcl_OpenFileChannel', for example.
+ *
+ *	This function cannot be used on the standard channels, and will return
+ *	TCL_ERROR if that is attempted.
+ *
+ *	This function should only be necessary for special purposes in which
+ *	you need to generate a pristine channel from one that has already been
+ *	used. All ordinary purposes will almost always want to use
+ *	Tcl_UnregisterChannel instead.
+ *
+ *	Provided the channel is not attached to any other interpreter, it can
+ *	then be closed with Tcl_Close, rather than with Tcl_UnregisterChannel.
+ *
+ * Results:
+ *	A standard Tcl result. If the channel is not currently registered with
+ *	the given interpreter, TCL_ERROR is returned, otherwise TCL_OK.
+ *	However no error messages are left in the interp's result.
+ *
+ * Side effects:
+ *	Deletes the hash entry for a channel associated with an interpreter.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_DetachChannel(
+    Tcl_Interp *interp,		/* Interpreter in which channel is defined. */
+    Tcl_Channel chan)		/* Channel to delete. */
+{
+    if (Tcl_IsStandardChannel(chan)) {
+	return TCL_ERROR;
+    }
+
+    return DetachChannel(interp, chan);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * DetachChannel --
+ *
+ *	Deletes the hash entry for a channel associated with an interpreter.
+ *	If the interpreter given as argument is NULL, it only decrements the
+ *	reference count. Even if the ref count drops to zero, the channel is
+ *	NOT closed or cleaned up. This allows a channel to be detached from an
+ *	interpreter and left in the same state it was in when it was
+ *	originally returned by 'Tcl_OpenFileChannel', for example.
+ *
+ * Results:
+ *	A standard Tcl result. If the channel is not currently registered with
+ *	the given interpreter, TCL_ERROR is returned, otherwise TCL_OK.
+ *	However no error messages are left in the interp's result.
+ *
+ * Side effects:
+ *	Deletes the hash entry for a channel associated with an interpreter.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+DetachChannel(
+    Tcl_Interp *interp,		/* Interpreter in which channel is defined. */
+    Tcl_Channel chan)		/* Channel to delete. */
+{
+    Tcl_HashTable *hTblPtr;	/* Hash table of channels. */
+    Tcl_HashEntry *hPtr;	/* Search variable. */
+    Channel *chanPtr;		/* The real IO channel. */
+    ChannelState *statePtr;	/* State of the real channel. */
+
+    /*
+     * Always (un)register bottom-most channel in the stack. This makes
+     * management of the channel list easier because no manipulation is
+     * necessary during (un)stack operation.
+     */
+
+    chanPtr = ((Channel *) chan)->state->bottomChanPtr;
+    statePtr = chanPtr->state;
+
+    if (interp != NULL) {
+	hTblPtr = Tcl_GetAssocData(interp, "tclIO", NULL);
+	if (hTblPtr == NULL) {
+	    return TCL_ERROR;
+	}
+	hPtr = Tcl_FindHashEntry(hTblPtr, statePtr->channelName);
+	if (hPtr == NULL) {
+	    return TCL_ERROR;
+	}
+	if ((Channel *) Tcl_GetHashValue(hPtr) != chanPtr) {
+	    return TCL_ERROR;
+	}
+	Tcl_DeleteHashEntry(hPtr);
+	statePtr->epoch++;
+
+	/*
+	 * Remove channel handlers that refer to this interpreter, so that
+	 * they will not be present if the actual close is delayed and more
+	 * events happen on the channel. This may occur if the channel is
+	 * shared between several interpreters, or if the channel has async
+	 * flushing active.
+	 */
+
+	CleanupChannelHandlers(interp, chanPtr);
+    }
+
+    statePtr->refCount--;
+
+    return TCL_OK;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * Tcl_GetChannel --
+ *
+ *	Finds an existing Tcl_Channel structure by name in a given
+ *	interpreter. This function is public because it is used by
+ *	channel-type-specific functions.
+ *
+ * Results:
+ *	A Tcl_Channel or NULL on failure. If failed, interp's result object
+ *	contains an error message. *modePtr is filled with the modes in which
+ *	the channel was opened.
+ *
+ * Side effects:
+ *	None.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+Tcl_Channel
+Tcl_GetChannel(
+    Tcl_Interp *interp,		/* Interpreter in which to find or create the
+				 * channel. */
+    const char *chanName,	/* The name of the channel. */
+    int *modePtr)		/* Where to store the mode in which the
+				 * channel was opened? Will contain an ORed
+				 * combination of TCL_READABLE and
+				 * TCL_WRITABLE, if non-NULL. */
+{
+    Channel *chanPtr;		/* The actual channel. */
+    Tcl_HashTable *hTblPtr;	/* Hash table of channels. */
+    Tcl_HashEntry *hPtr;	/* Search variable. */
+    const char *name;		/* Translated name. */
+
+    /*
+     * Substitute "stdin", etc. Note that even though we immediately find the
+     * channel using Tcl_GetStdChannel, we still need to look it up in the
+     * specified interpreter to ensure that it is present in the channel
+     * table. Otherwise, safe interpreters would always have access to the
+     * standard channels.
+     */
+
+    name = chanName;
+    if ((chanName[0] == 's') && (chanName[1] == 't')) {
+	chanPtr = NULL;
+	if (strcmp(chanName, "stdin") == 0) {
+	    chanPtr = (Channel *) Tcl_GetStdChannel(TCL_STDIN);
+	} else if (strcmp(chanName, "stdout") == 0) {
+	    chanPtr = (Channel *) Tcl_GetStdChannel(TCL_STDOUT);
+	} else if (strcmp(chanName, "stderr") == 0) {
+	    chanPtr = (Channel *) Tcl_GetStdChannel(TCL_STDERR);
+	}
+	if (chanPtr != NULL) {
+	    name = chanPtr->state->channelName;
+	}
+    }
+
+    hTblPtr = GetChannelTable(interp);
+    hPtr = Tcl_FindHashEntry(hTblPtr, name);
+    if (hPtr == NULL) {
+	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+                "can not find channel named \"%s\"", chanName));
+	Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "CHANNEL", chanName, NULL);
+	return NULL;
+    }
+
+    /*
+     * Always return bottom-most channel in the stack. This one lives the
+     * longest - other channels may go away unnoticed. The other APIs
+     * compensate where necessary to retrieve the topmost channel again.
+     */
+
+    chanPtr = Tcl_GetHashValue(hPtr);
+    chanPtr = chanPtr->state->bottomChanPtr;
+    if (modePtr != NULL) {
+	*modePtr = chanPtr->state->flags & (TCL_READABLE|TCL_WRITABLE);
+    }
+
+    return (Tcl_Channel) chanPtr;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * TclGetChannelFromObj --
+ *
+ *	Finds an existing Tcl_Channel structure by name in a given
+ *	interpreter. This function is public because it is used by
+ *	channel-type-specific functions.
+ *
+ * Results:
+ *	A Tcl_Channel or NULL on failure. If failed, interp's result object
+ *	contains an error message. *modePtr is filled with the modes in which
+ *	the channel was opened.
+ *
+ * Side effects:
+ *	None.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+int
+TclGetChannelFromObj(
+    Tcl_Interp *interp,		/* Interpreter in which to find or create the
+				 * channel. */
+    Tcl_Obj *objPtr,
+    Tcl_Channel *channelPtr,
+    int *modePtr,		/* Where to store the mode in which the
+				 * channel was opened? Will contain an ORed
+				 * combination of TCL_READABLE and
+				 * TCL_WRITABLE, if non-NULL. */
+    int flags)
+{
+    ChannelState *statePtr;
+    ResolvedChanName *resPtr = NULL;
+    Tcl_Channel chan;
+
+    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;
+    }
+
+    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) {
+	*modePtr = statePtr->flags & (TCL_READABLE|TCL_WRITABLE);
+    }
+
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_CreateChannel --
+ *
+ *	Creates a new entry in the hash table for a Tcl_Channel record.
+ *
+ * Results:
+ *	Returns the new Tcl_Channel.
+ *
+ * Side effects:
+ *	Creates a new Tcl_Channel instance and inserts it into the hash table.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_Channel
+Tcl_CreateChannel(
+    const Tcl_ChannelType *typePtr, /* The channel type record. */
+    const char *chanName,	/* Name of channel to record. */
+    ClientData instanceData,	/* Instance specific data. */
+    int mask)			/* TCL_READABLE & TCL_WRITABLE to indicate if
+				 * the channel is readable, writable. */
+{
+    Channel *chanPtr;		/* The channel structure newly created. */
+    ChannelState *statePtr;	/* The stack-level independent state info for
+				 * the channel. */
+    const char *name;
+    char *tmp;
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    /*
+     * With the change of the Tcl_ChannelType structure to use a version in
+     * 8.3.2+, we have to make sure that our assumption that the structure
+     * remains a binary compatible size is true.
+     *
+     * If this assertion fails on some system, then it can be removed only if
+     * the user recompiles code with older channel drivers in the new system
+     * as well.
+     */
+
+    assert(sizeof(Tcl_ChannelTypeVersion) == sizeof(Tcl_DriverBlockModeProc *));
+    assert(typePtr->typeName != NULL);
+    if (NULL == typePtr->closeProc) {
+	Tcl_Panic("channel type %s must define closeProc", typePtr->typeName);
+    }
+    if ((TCL_READABLE & mask) && (NULL == typePtr->inputProc)) {
+	Tcl_Panic("channel type %s must define inputProc when used for reader channel", typePtr->typeName);
+    }
+    if ((TCL_WRITABLE & mask) &&  (NULL == typePtr->outputProc)) {
+	Tcl_Panic("channel type %s must define outputProc when used for writer channel", typePtr->typeName);
+    }
+    if (NULL == typePtr->watchProc) {
+	Tcl_Panic("channel type %s must define watchProc", typePtr->typeName);
+    }
+    if ((NULL!=typePtr->wideSeekProc) && (NULL == typePtr->seekProc)) {
+	Tcl_Panic("channel type %s must define seekProc if defining wideSeekProc", typePtr->typeName);
+    }
+
+    /*
+     * JH: We could subsequently memset these to 0 to avoid the numerous
+     * assignments to 0/NULL below.
+     */
+
+    chanPtr = ckalloc(sizeof(Channel));
+    statePtr = ckalloc(sizeof(ChannelState));
+    chanPtr->state = statePtr;
+
+    chanPtr->instanceData = instanceData;
+    chanPtr->typePtr = typePtr;
+
+    /*
+     * Set all the bits that are part of the stack-independent state
+     * information for the channel.
+     */
+
+    if (chanName != NULL) {
+	unsigned len = strlen(chanName) + 1;
+
+	/*
+         * Make sure we allocate at least 7 bytes, so it fits for "stdout"
+         * later.
+         */
+
+	tmp = ckalloc((len < 7) ? 7 : len);
+	strcpy(tmp, chanName);
+    } else {
+	tmp = ckalloc(7);
+	tmp[0] = '\0';
+    }
+    statePtr->channelName = tmp;
+    statePtr->flags = mask;
+
+    /*
+     * Set the channel to system default encoding.
+     *
+     * Note the strange bit of protection taking place here. If the system
+     * encoding name is reported back as "binary", something weird is
+     * happening. Tcl provides no "binary" encoding, so someone else has
+     * provided one. We ignore it so as not to interfere with the "magic"
+     * interpretation that Tcl_Channels give to the "-encoding binary" option.
+     */
+
+    statePtr->encoding = NULL;
+    name = Tcl_GetEncodingName(NULL);
+    if (strcmp(name, "binary") != 0) {
+	statePtr->encoding = Tcl_GetEncoding(NULL, name);
+    }
+    statePtr->inputEncodingState  = NULL;
+    statePtr->inputEncodingFlags  = TCL_ENCODING_START;
+    statePtr->outputEncodingState = NULL;
+    statePtr->outputEncodingFlags = TCL_ENCODING_START;
+
+    /*
+     * 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.
+     * ^Z) and does not append an EOF indicator to files.
+     */
+
+    statePtr->inputTranslation	= TCL_TRANSLATE_AUTO;
+    statePtr->outputTranslation	= TCL_PLATFORM_TRANSLATION;
+    statePtr->inEofChar		= 0;
+    statePtr->outEofChar	= 0;
+
+    statePtr->unreportedError	= 0;
+    statePtr->refCount		= 0;
+    statePtr->closeCbPtr	= NULL;
+    statePtr->curOutPtr		= NULL;
+    statePtr->outQueueHead	= NULL;
+    statePtr->outQueueTail	= NULL;
+    statePtr->saveInBufPtr	= NULL;
+    statePtr->inQueueHead	= NULL;
+    statePtr->inQueueTail	= NULL;
+    statePtr->chPtr		= NULL;
+    statePtr->interestMask	= 0;
+    statePtr->scriptRecordPtr	= NULL;
+    statePtr->bufSize		= CHANNELBUFFER_DEFAULT_SIZE;
+    statePtr->timer		= NULL;
+    statePtr->csPtrR		= NULL;
+    statePtr->csPtrW		= NULL;
+    statePtr->outputStage	= NULL;
+
+    /*
+     * As we are creating the channel, it is obviously the top for now.
+     */
+
+    statePtr->topChanPtr	= chanPtr;
+    statePtr->bottomChanPtr	= chanPtr;
+    chanPtr->downChanPtr	= NULL;
+    chanPtr->upChanPtr		= NULL;
+    chanPtr->inQueueHead	= NULL;
+    chanPtr->inQueueTail	= NULL;
+    chanPtr->refCount		= 0;
+
+    /*
+     * TIP #219, Tcl Channel Reflection API
+     */
+
+    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
+     * the list on exit.
+     *
+     * JH: Could call Tcl_SpliceChannel, but need to avoid NULL check.
+     *
+     * TIP #218.
+     * AK: Just initialize the field to NULL before invoking Tcl_SpliceChannel
+     *	   We need Tcl_SpliceChannel, for the threadAction calls. There is no
+     *	   real reason to duplicate all of this.
+     * NOTE: All drivers using thread actions now have to perform their TSD
+     *	     manipulation only in their thread action proc. Doing it when
+     *	     creating their instance structures will collide with the thread
+     *	     action activity and lead to damaged lists.
+     */
+
+    statePtr->nextCSPtr = NULL;
+    SpliceChannel((Tcl_Channel) chanPtr);
+
+    /*
+     * Install this channel in the first empty standard channel slot, if the
+     * channel was previously closed explicitly.
+     */
+
+    if ((tsdPtr->stdinChannel == NULL) && (tsdPtr->stdinInitialized == 1)) {
+	strcpy(tmp, "stdin");
+	Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDIN);
+	Tcl_RegisterChannel(NULL, (Tcl_Channel) chanPtr);
+    } else if ((tsdPtr->stdoutChannel == NULL) &&
+	    (tsdPtr->stdoutInitialized == 1)) {
+	strcpy(tmp, "stdout");
+	Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDOUT);
+	Tcl_RegisterChannel(NULL, (Tcl_Channel) chanPtr);
+    } else if ((tsdPtr->stderrChannel == NULL) &&
+	    (tsdPtr->stderrInitialized == 1)) {
+	strcpy(tmp, "stderr");
+	Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDERR);
+	Tcl_RegisterChannel(NULL, (Tcl_Channel) chanPtr);
+    }
+    return (Tcl_Channel) chanPtr;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_StackChannel --
+ *
+ *	Replaces an entry in the hash table for a Tcl_Channel record. The
+ *	replacement is a new channel with same name, it supercedes the
+ *	replaced channel. Input and output of the superceded channel is now
+ *	going through the newly created channel and allows the arbitrary
+ *	filtering/manipulation of the dataflow.
+ *
+ *	Andreas Kupries <a.kupries@westend.com>, 12/13/1998 "Trf-Patch for
+ *	filtering channels"
+ *
+ * Results:
+ *	Returns the new Tcl_Channel, which actually contains the saved
+ *	information about prevChan.
+ *
+ * Side effects:
+ *	A new channel structure is allocated and linked below the existing
+ *	channel. The channel operations and client data of the existing
+ *	channel are copied down to the newly created channel, and the current
+ *	channel has its operations replaced by the new typePtr.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_Channel
+Tcl_StackChannel(
+    Tcl_Interp *interp,		/* The interpreter we are working in */
+    const Tcl_ChannelType *typePtr,
+				/* The channel type record for the new
+				 * channel. */
+    ClientData instanceData,	/* Instance specific data for the new
+				 * channel. */
+    int mask,			/* TCL_READABLE & TCL_WRITABLE to indicate if
+				 * the channel is readable, writable. */
+    Tcl_Channel prevChan)	/* The channel structure to replace */
+{
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+    Channel *chanPtr, *prevChanPtr;
+    ChannelState *statePtr;
+
+    /*
+     * Find the given channel (prevChan) in the list of all channels. If we do
+     * not find it, then it was never registered correctly.
+     *
+     * This operation should occur at the top of a channel stack.
+     */
+
+    statePtr = (ChannelState *) tsdPtr->firstCSPtr;
+    prevChanPtr = ((Channel *) prevChan)->state->topChanPtr;
+
+    while ((statePtr != NULL) && (statePtr->topChanPtr != prevChanPtr)) {
+	statePtr = statePtr->nextCSPtr;
+    }
+
+    if (statePtr == NULL) {
+	if (interp) {
+	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+                    "couldn't find state for channel \"%s\"",
+		    Tcl_GetChannelName(prevChan)));
+	}
+	return NULL;
+    }
+
+    /*
+     * Here we check if the given "mask" matches the "flags" of the already
+     * existing channel.
+     *
+     *	  | - | R | W | RW |
+     *	--+---+---+---+----+	<=>  0 != (chan->mask & prevChan->mask)
+     *	- |   |   |   |    |
+     *	R |   | + |   | +  |	The superceding channel is allowed to restrict
+     *	W |   |   | + | +  |	the capabilities of the superceded one!
+     *	RW|   | + | + | +  |
+     *	--+---+---+---+----+
+     */
+
+    if ((mask & (statePtr->flags & (TCL_READABLE | TCL_WRITABLE))) == 0) {
+	if (interp) {
+	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+		    "reading and writing both disallowed for channel \"%s\"",
+		    Tcl_GetChannelName(prevChan)));
+	}
+	return NULL;
+    }
+
+    /*
+     * Flush the buffers. This ensures that any data still in them at this
+     * time is not handled by the new transformation. Restrict this to
+     * writable channels. Take care to hide a possible bg-copy in progress
+     * from Tcl_Flush and the CheckForChannelErrors inside.
+     */
+
+    if ((mask & TCL_WRITABLE) != 0) {
+	CopyState *csPtrR = statePtr->csPtrR;
+	CopyState *csPtrW = statePtr->csPtrW;
+
+	statePtr->csPtrR = NULL;
+	statePtr->csPtrW = NULL;
+
+	/*
+	 * TODO: Examine what can go wrong if Tcl_Flush() call disturbs
+	 * the stacking state of this channel during its operations.
+	 */
+	if (Tcl_Flush((Tcl_Channel) prevChanPtr) != TCL_OK) {
+	    statePtr->csPtrR = csPtrR;
+	    statePtr->csPtrW = csPtrW;
+	    if (interp) {
+		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+                        "could not flush channel \"%s\"",
+			Tcl_GetChannelName(prevChan)));
+	    }
+	    return NULL;
+	}
+
+	statePtr->csPtrR = csPtrR;
+	statePtr->csPtrW = csPtrW;
+    }
+
+    /*
+     * 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
+     * reading. As the buffers contain the untransformed form their contents
+     * are not only useless but actually distorts our view of the system.
+     *
+     * To preserve the information without having to read them again and to
+     * avoid problems with the location in the channel (seeking might be
+     * impossible) we move the buffers from the common state structure into
+     * the channel itself. We use the buffers in the channel below the new
+     * transformation to hold the data. In the future this allows us to write
+     * transformations which pre-read data and push the unused part back when
+     * they are going away.
+     */
+
+    if (((mask & TCL_READABLE) != 0) && (statePtr->inQueueHead != NULL)) {
+
+	/*
+	 * When statePtr->inQueueHead is not NULL, we know
+	 * prevChanPtr->inQueueHead must be NULL.
+	 */
+
+	assert(prevChanPtr->inQueueHead == NULL);
+	assert(prevChanPtr->inQueueTail == NULL);
+
+	prevChanPtr->inQueueHead = statePtr->inQueueHead;
+	prevChanPtr->inQueueTail = statePtr->inQueueTail;
+
+	statePtr->inQueueHead = NULL;
+	statePtr->inQueueTail = NULL;
+    }
+
+    chanPtr = ckalloc(sizeof(Channel));
+
+    /*
+     * Save some of the current state into the new structure, reinitialize the
+     * parts which will stay with the transformation.
+     *
+     * Remarks:
+     */
+
+    chanPtr->state		= statePtr;
+    chanPtr->instanceData	= instanceData;
+    chanPtr->typePtr		= typePtr;
+    chanPtr->downChanPtr	= prevChanPtr;
+    chanPtr->upChanPtr		= NULL;
+    chanPtr->inQueueHead	= NULL;
+    chanPtr->inQueueTail	= NULL;
+    chanPtr->refCount		= 0;
+
+    /*
+     * Place new block at the head of a possibly existing list of previously
+     * stacked channels.
+     */
+
+    prevChanPtr->upChanPtr	= chanPtr;
+    statePtr->topChanPtr	= chanPtr;
+
+    /*
+     * TIP #218, Channel Thread Actions.
+     *
+     * We call the thread actions for the new channel directly. We _cannot_
+     * use SpliceChannel, because the (thread-)global list of all channels
+     * always contains the _ChannelState_ for a stack of channels, not the
+     * individual channels. And SpliceChannel would not only call the thread
+     * actions, but also add the shared ChannelState to this list a second
+     * time, mangling it.
+     */
+
+    ChanThreadAction(chanPtr, TCL_CHANNEL_THREAD_INSERT);
+
+    return (Tcl_Channel) chanPtr;
+}
+
+void
+TclChannelPreserve(
+    Tcl_Channel chan)
+{
+    ((Channel *)chan)->refCount++;
+}
+
+void
+TclChannelRelease(
+    Tcl_Channel chan)
+{
+    Channel *chanPtr = (Channel *) chan;
+
+    if (chanPtr->refCount == 0) {
+	Tcl_Panic("Channel released more than preserved");
+    }
+    if (--chanPtr->refCount) {
+	return;
+    }
+    if (chanPtr->typePtr == NULL) {
+	ckfree(chanPtr);
+    }
+}
+
+static void
+ChannelFree(
+    Channel *chanPtr)
+{
+    if (chanPtr->refCount == 0) {
+	ckfree(chanPtr);
+	return;
+    }
+    chanPtr->typePtr = NULL;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_UnstackChannel --
+ *
+ *	Unstacks an entry in the hash table for a Tcl_Channel record. This is
+ *	the reverse to 'Tcl_StackChannel'.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	If TCL_ERROR is returned, the posix error code will be set with
+ *	Tcl_SetErrno. May leave a message in interp result as well.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_UnstackChannel(
+    Tcl_Interp *interp,		/* The interpreter we are working in */
+    Tcl_Channel chan)		/* The channel to unstack */
+{
+    Channel *chanPtr = (Channel *) chan;
+    ChannelState *statePtr = chanPtr->state;
+    int result = 0;
+
+    /*
+     * This operation should occur at the top of a channel stack.
+     */
+
+    chanPtr = statePtr->topChanPtr;
+
+    if (chanPtr->downChanPtr != NULL) {
+	/*
+	 * Instead of manipulating the per-thread / per-interp list/hashtable
+	 * 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
+	 * value we're holding on to will not be the right thing.
+	 */
+
+	Channel *downChanPtr = chanPtr->downChanPtr;
+
+	/*
+	 * Flush the buffers. This ensures that any data still in them at this
+	 * time _is_ handled by the transformation we are unstacking right
+	 * now. Restrict this to writable channels. Take care to hide a
+	 * possible bg-copy in progress from Tcl_Flush and the
+	 * CheckForChannelErrors inside.
+	 */
+
+	if (GotFlag(statePtr, TCL_WRITABLE)) {
+	    CopyState *csPtrR = statePtr->csPtrR;
+	    CopyState *csPtrW = statePtr->csPtrW;
+
+	    statePtr->csPtrR = NULL;
+	    statePtr->csPtrW = NULL;
+
+	    if (Tcl_Flush((Tcl_Channel) chanPtr) != TCL_OK) {
+		statePtr->csPtrR = csPtrR;
+		statePtr->csPtrW = csPtrW;
+
+		/*
+		 * TIP #219, Tcl Channel Reflection API.
+		 * Move error messages put by the driver into the chan/ip
+		 * bypass area into the regular interpreter result. Fall back
+		 * to the regular message if nothing was found in the
+		 * bypasses.
+		 */
+
+		if (!TclChanCaughtErrorBypass(interp, chan) && interp) {
+		    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+                            "could not flush channel \"%s\"",
+			    Tcl_GetChannelName((Tcl_Channel) chanPtr)));
+		}
+		return TCL_ERROR;
+	    }
+
+	    statePtr->csPtrR  = csPtrR;
+	    statePtr->csPtrW = csPtrW;
+	}
+
+	/*
+	 * Anything in the input queue and the push-back buffers of the
+	 * transformation going away is transformed data, but not yet read. As
+	 * unstacking means that the caller does not want to see transformed
+	 * data any more we have to discard these bytes. To avoid writing an
+	 * analogue to 'DiscardInputQueued' we move the information in the
+	 * push back buffers to the input queue and then call
+	 * 'DiscardInputQueued' on that.
+	 */
+
+	if (GotFlag(statePtr, TCL_READABLE) &&
+		((statePtr->inQueueHead != NULL) ||
+		(chanPtr->inQueueHead != NULL))) {
+	    if ((statePtr->inQueueHead != NULL) &&
+		    (chanPtr->inQueueHead != NULL)) {
+		statePtr->inQueueTail->nextPtr = chanPtr->inQueueHead;
+		statePtr->inQueueTail = chanPtr->inQueueTail;
+		statePtr->inQueueHead = statePtr->inQueueTail;
+	    } else if (chanPtr->inQueueHead != NULL) {
+		statePtr->inQueueHead = chanPtr->inQueueHead;
+		statePtr->inQueueTail = chanPtr->inQueueTail;
+	    }
+
+	    chanPtr->inQueueHead = NULL;
+	    chanPtr->inQueueTail = NULL;
+
+	    DiscardInputQueued(statePtr, 0);
+	}
+
+	/*
+	 * TIP #218, Channel Thread Actions.
+	 *
+	 * We call the thread actions for the new channel directly. We
+	 * _cannot_ use CutChannel, because the (thread-)global list of all
+	 * channels always contains the _ChannelState_ for a stack of
+	 * channels, not the individual channels. And SpliceChannel would not
+	 * only call the thread actions, but also remove the shared
+	 * ChannelState from this list despite there being more channels for
+	 * the state which are still active.
+	 */
+
+	ChanThreadAction(chanPtr, TCL_CHANNEL_THREAD_REMOVE);
+
+	statePtr->topChanPtr = downChanPtr;
+	downChanPtr->upChanPtr = NULL;
+
+	/*
+	 * Leave this link intact for closeproc
+	 *  chanPtr->downChanPtr = NULL;
+	 */
+
+	/*
+	 * Close and free the channel driver state.
+	 */
+
+	result = ChanClose(chanPtr, interp);
+	ChannelFree(chanPtr);
+
+	UpdateInterest(statePtr->topChanPtr);
+
+	if (result != 0) {
+	    Tcl_SetErrno(result);
+
+	    /*
+	     * TIP #219, Tcl Channel Reflection API.
+	     * Move error messages put by the driver into the chan/ip bypass
+	     * area into the regular interpreter result.
+	     */
+
+	    TclChanCaughtErrorBypass(interp, chan);
+	    return TCL_ERROR;
+	}
+    } else {
+	/*
+	 * This channel does not cover another one. Simply do a close, if
+	 * necessary.
+	 */
+
+	if (statePtr->refCount <= 0) {
+	    if (Tcl_Close(interp, chan) != TCL_OK) {
+		/*
+		 * TIP #219, Tcl Channel Reflection API.
+		 * "TclChanCaughtErrorBypass" is not required here, it was
+		 * done already by "Tcl_Close".
+		 */
+
+		return TCL_ERROR;
+	    }
+	}
+
+	/*
+	 * TIP #218, Channel Thread Actions.
+	 * Not required in this branch, this is done by Tcl_Close. If
+	 * Tcl_Close is not called then the ChannelState is still active in
+	 * the thread and no action has to be taken either.
+	 */
+    }
+
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GetStackedChannel --
+ *
+ *	Determines whether the specified channel is stacked upon another.
+ *
+ * Results:
+ *	NULL if the channel is not stacked upon another one, or a reference to
+ *	the channel it is stacked upon. This reference can be used in queries,
+ *	but modification is not allowed.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_Channel
+Tcl_GetStackedChannel(
+    Tcl_Channel chan)
+{
+    Channel *chanPtr = (Channel *) chan;
+				/* The actual channel. */
+
+    return (Tcl_Channel) chanPtr->downChanPtr;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GetTopChannel --
+ *
+ *	Returns the top channel of a channel stack.
+ *
+ * Results:
+ *	NULL if the channel is not stacked upon another one, or a reference to
+ *	the channel it is stacked upon. This reference can be used in queries,
+ *	but modification is not allowed.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_Channel
+Tcl_GetTopChannel(
+    Tcl_Channel chan)
+{
+    Channel *chanPtr = (Channel *) chan;
+				/* The actual channel. */
+
+    return (Tcl_Channel) chanPtr->state->topChanPtr;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GetChannelInstanceData --
+ *
+ *	Returns the client data associated with a channel.
+ *
+ * Results:
+ *	The client data.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+ClientData
+Tcl_GetChannelInstanceData(
+    Tcl_Channel chan)		/* Channel for which to return client data. */
+{
+    Channel *chanPtr = (Channel *) chan;
+				/* The actual channel. */
+
+    return chanPtr->instanceData;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GetChannelThread --
+ *
+ *	Given a channel structure, returns the thread managing it. TIP #10
+ *
+ * Results:
+ *	Returns the id of the thread managing the channel.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_ThreadId
+Tcl_GetChannelThread(
+    Tcl_Channel chan)		/* The channel to return the managing thread
+				 * for. */
+{
+    Channel *chanPtr = (Channel *) chan;
+				/* The actual channel. */
+
+    return chanPtr->state->managingThread;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GetChannelType --
+ *
+ *	Given a channel structure, returns the channel type structure.
+ *
+ * Results:
+ *	Returns a pointer to the channel type structure.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+const Tcl_ChannelType *
+Tcl_GetChannelType(
+    Tcl_Channel chan)		/* The channel to return type for. */
+{
+    Channel *chanPtr = (Channel *) chan;
+				/* The actual channel. */
+
+    return chanPtr->typePtr;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GetChannelMode --
+ *
+ *	Computes a mask indicating whether the channel is open for reading and
+ *	writing.
+ *
+ * Results:
+ *	An OR-ed combination of TCL_READABLE and TCL_WRITABLE.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_GetChannelMode(
+    Tcl_Channel chan)		/* The channel for which the mode is being
+				 * computed. */
+{
+    ChannelState *statePtr = ((Channel *) chan)->state;
+				/* State of actual channel. */
+
+    return (statePtr->flags & (TCL_READABLE | TCL_WRITABLE));
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GetChannelName --
+ *
+ *	Returns the string identifying the channel name.
+ *
+ * Results:
+ *	The string containing the channel name. This memory is owned by the
+ *	generic layer and should not be modified by the caller.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+const char *
+Tcl_GetChannelName(
+    Tcl_Channel chan)		/* The channel for which to return the name. */
+{
+    ChannelState *statePtr = ((Channel *) chan)->state;
+				/* State of actual channel. */
+
+    return statePtr->channelName;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GetChannelHandle --
+ *
+ *	Returns an OS handle associated with a channel.
+ *
+ * Results:
+ *	Returns TCL_OK and places the handle in handlePtr, or returns
+ *	TCL_ERROR on failure.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_GetChannelHandle(
+    Tcl_Channel chan,		/* The channel to get file from. */
+    int direction,		/* TCL_WRITABLE or TCL_READABLE. */
+    ClientData *handlePtr)	/* Where to store handle */
+{
+    Channel *chanPtr;		/* The actual channel. */
+    ClientData handle;
+    int result;
+
+    chanPtr = ((Channel *) chan)->state->bottomChanPtr;
+    if (!chanPtr->typePtr->getHandleProc) {
+        Tcl_SetChannelError(chan, Tcl_ObjPrintf(
+                "channel \"%s\" does not support OS handles",
+                Tcl_GetChannelName(chan)));
+	return TCL_ERROR;
+    }
+    result = chanPtr->typePtr->getHandleProc(chanPtr->instanceData, direction,
+	    &handle);
+    if (handlePtr) {
+	*handlePtr = handle;
+    }
+    return result;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * AllocChannelBuffer --
+ *
+ *	A channel buffer has BUFFER_PADDING bytes extra at beginning to hold
+ *	any bytes of a native-encoding character that got split by the end of
+ *	the previous buffer and need to be moved to the beginning of the next
+ *	buffer to make a contiguous string so it can be converted to UTF-8.
+ *
+ *	A channel buffer has BUFFER_PADDING bytes extra at the end to hold any
+ *	bytes of a native-encoding character (generated from a UTF-8
+ *	character) that overflow past the end of the buffer and need to be
+ *	moved to the next buffer.
+ *
+ * Results:
+ *	A newly allocated channel buffer.
+ *
+ * Side effects:
+ *	None.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+static ChannelBuffer *
+AllocChannelBuffer(
+    int length)			/* Desired length of channel buffer. */
+{
+    ChannelBuffer *bufPtr;
+    int n;
+
+    n = length + CHANNELBUFFER_HEADER_SIZE + BUFFER_PADDING + BUFFER_PADDING;
+    bufPtr = ckalloc(n);
+    bufPtr->nextAdded	= BUFFER_PADDING;
+    bufPtr->nextRemoved	= BUFFER_PADDING;
+    bufPtr->bufLength	= length + BUFFER_PADDING;
+    bufPtr->nextPtr	= NULL;
+    bufPtr->refCount	= 1;
+    return bufPtr;
+}
+
+static void
+PreserveChannelBuffer(
+    ChannelBuffer *bufPtr)
+{
+    if (bufPtr->refCount == 0) {
+	Tcl_Panic("Reuse of ChannelBuffer! %p", bufPtr);
+    }
+    bufPtr->refCount++;
+}
+
+static void
+ReleaseChannelBuffer(
+    ChannelBuffer *bufPtr)
+{
+    if (--bufPtr->refCount) {
+	return;
+    }
+    ckfree(bufPtr);
+}
+
+static int
+IsShared(
+    ChannelBuffer *bufPtr)
+{
+    return bufPtr->refCount > 1;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * RecycleBuffer --
+ *
+ *	Helper function to recycle input and output buffers. Ensures that two
+ *	input buffers are saved (one in the input queue and another in the
+ *	saveInBufPtr field) and that curOutPtr is set to a buffer. Only if
+ *	these conditions are met is the buffer freed to the OS.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	May free a buffer to the OS.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+RecycleBuffer(
+    ChannelState *statePtr,	/* ChannelState in which to recycle buffers. */
+    ChannelBuffer *bufPtr,	/* The buffer to recycle. */
+    int mustDiscard)		/* If nonzero, free the buffer to the OS,
+				 * always. */
+{
+    /*
+     * Do we have to free the buffer to the OS?
+     */
+    if (IsShared(bufPtr)) {
+	mustDiscard = 1;
+    }
+
+    if (mustDiscard) {
+	ReleaseChannelBuffer(bufPtr);
+	return;
+    }
+
+    /*
+     * 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) {
+	ReleaseChannelBuffer(bufPtr);
+	return;
+    }
+
+    /*
+     * Only save buffers for the input queue if the channel is readable.
+     */
+
+    if (GotFlag(statePtr, TCL_READABLE)) {
+	if (statePtr->inQueueHead == NULL) {
+	    statePtr->inQueueHead = bufPtr;
+	    statePtr->inQueueTail = bufPtr;
+	    goto keepBuffer;
+	}
+	if (statePtr->saveInBufPtr == NULL) {
+	    statePtr->saveInBufPtr = bufPtr;
+	    goto keepBuffer;
+	}
+    }
+
+    /*
+     * Only save buffers for the output queue if the channel is writable.
+     */
+
+    if (GotFlag(statePtr, TCL_WRITABLE)) {
+	if (statePtr->curOutPtr == NULL) {
+	    statePtr->curOutPtr = bufPtr;
+	    goto keepBuffer;
+	}
+    }
+
+    /*
+     * If we reached this code we return the buffer to the OS.
+     */
+
+    ReleaseChannelBuffer(bufPtr);
+    return;
+
+  keepBuffer:
+    bufPtr->nextRemoved = BUFFER_PADDING;
+    bufPtr->nextAdded = BUFFER_PADDING;
+    bufPtr->nextPtr = NULL;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * DiscardOutputQueued --
+ *
+ *	Discards all output queued in the output queue of a channel.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Recycles buffers.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+DiscardOutputQueued(
+    ChannelState *statePtr)	/* ChannelState for which to discard output. */
+{
+    ChannelBuffer *bufPtr;
+
+    while (statePtr->outQueueHead != NULL) {
+	bufPtr = statePtr->outQueueHead;
+	statePtr->outQueueHead = bufPtr->nextPtr;
+	RecycleBuffer(statePtr, bufPtr, 0);
+    }
+    statePtr->outQueueHead = NULL;
+    statePtr->outQueueTail = NULL;
+    bufPtr = statePtr->curOutPtr;
+    if (bufPtr && BytesLeft(bufPtr)) {
+	statePtr->curOutPtr = NULL;
+	RecycleBuffer(statePtr, bufPtr, 0);
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * CheckForDeadChannel --
+ *
+ *	This function checks is a given channel is Dead (a channel that has
+ *	been closed but not yet deallocated.)
+ *
+ * Results:
+ *	True (1) if channel is Dead, False (0) if channel is Ok
+ *
+ * Side effects:
+ *	None
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+CheckForDeadChannel(
+    Tcl_Interp *interp,		/* For error reporting (can be NULL) */
+    ChannelState *statePtr)	/* The channel state to check. */
+{
+    if (!GotFlag(statePtr, CHANNEL_DEAD)) {
+	return 0;
+    }
+
+    Tcl_SetErrno(EINVAL);
+    if (interp) {
+	Tcl_SetObjResult(interp, Tcl_NewStringObj(
+                "unable to access channel: invalid channel", -1));
+    }
+    return 1;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FlushChannel --
+ *
+ *	This function flushes as much of the queued output as is possible now.
+ *	If calledFromAsyncFlush is nonzero, it is being called in an event
+ *	handler to flush channel output asynchronously.
+ *
+ * Results:
+ *	0 if successful, else the error code that was returned by the channel
+ *	type operation. May leave a message in the interp result.
+ *
+ * Side effects:
+ *	May produce output on a channel. May block indefinitely if the channel
+ *	is synchronous. May schedule an async flush on the channel. May
+ *	recycle memory for buffers in the output queue.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+FlushChannel(
+    Tcl_Interp *interp,		/* For error reporting during close. */
+    Channel *chanPtr,		/* The channel to flush on. */
+    int calledFromAsyncFlush)	/* If nonzero then we are being called from an
+				 * asynchronous flush callback. */
+{
+    ChannelState *statePtr = chanPtr->state;
+				/* State of the channel stack. */
+    ChannelBuffer *bufPtr;	/* Iterates over buffered output queue. */
+    int written;		/* Amount of output data actually written in
+				 * current round. */
+    int errorCode = 0;		/* Stores POSIX error codes from channel
+				 * driver operations. */
+    int wroteSome = 0;		/* Set to one if any data was written to the
+				 * driver. */
+
+    /*
+     * Prevent writing on a dead channel -- a channel that has been closed but
+     * not yet deallocated. This can occur if the exit handler for the channel
+     * deallocation runs before all channels are deregistered in all
+     * interpreters.
+     */
+
+    if (CheckForDeadChannel(interp, statePtr)) {
+	return -1;
+    }
+
+    /*
+     * 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.
+     * 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.
+     */
+
+    bufPtr = statePtr->curOutPtr;
+    if (bufPtr && BytesLeft(bufPtr) && /* Keep empties off queue */
+	    (statePtr->outQueueHead == NULL || IsBufferFull(bufPtr)
+		    || !GotFlag(statePtr, CHANNEL_NONBLOCKING))) {
+	if (statePtr->outQueueHead == NULL) {
+	    statePtr->outQueueHead = bufPtr;
+	} else {
+	    statePtr->outQueueTail->nextPtr = bufPtr;
+	}
+	statePtr->outQueueTail = bufPtr;
+	statePtr->curOutPtr = NULL;
+    }
+
+    assert(!IsBufferFull(statePtr->curOutPtr));
+
+    /*
+     * If we are not being called from an async flush and an async flush
+     * is active, we just return without producing any output.
+     */
+
+    if (!calledFromAsyncFlush && GotFlag(statePtr, BG_FLUSH_SCHEDULED)) {
+	return 0;
+    }
+
+    /*
+     * Loop over the queued buffers and attempt to flush as much as possible
+     * of the queued output to the channel.
+     */
+
+    TclChannelPreserve((Tcl_Channel)chanPtr);
+    while (statePtr->outQueueHead) {
+	bufPtr = statePtr->outQueueHead;
+
+	/*
+	 * Produce the output on the channel.
+	 */
+
+	PreserveChannelBuffer(bufPtr);
+	written = ChanWrite(chanPtr, RemovePoint(bufPtr), BytesLeft(bufPtr),
+		&errorCode);
+
+	/*
+	 * If the write failed completely attempt to start the asynchronous
+	 * flush mechanism and break out of this loop - do not attempt to
+	 * write any more output at this time.
+	 */
+
+	if (written < 0) {
+	    /*
+	     * If the last attempt to write was interrupted, simply retry.
+	     */
+
+	    if (errorCode == EINTR) {
+		errorCode = 0;
+		ReleaseChannelBuffer(bufPtr);
+		continue;
+	    }
+
+	    /*
+	     * If the channel is non-blocking and we would have blocked, start
+	     * a background flushing handler and break out of the loop.
+	     */
+
+	    if ((errorCode == EWOULDBLOCK) || (errorCode == EAGAIN)) {
+		/*
+		 * This used to check for CHANNEL_NONBLOCKING, and panic if
+		 * the channel was blocking. However, it appears that setting
+		 * stdin to -blocking 0 has some effect on the stdout when
+		 * it's a tty channel (dup'ed underneath)
+		 */
+
+		if (!GotFlag(statePtr, BG_FLUSH_SCHEDULED) && !TclInExit()) {
+		    SetFlag(statePtr, BG_FLUSH_SCHEDULED);
+		    UpdateInterest(chanPtr);
+		}
+		errorCode = 0;
+		ReleaseChannelBuffer(bufPtr);
+		break;
+	    }
+
+	    /*
+	     * Decide whether to report the error upwards or defer it.
+	     */
+
+	    if (calledFromAsyncFlush) {
+		/*
+		 * 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.
+		 */
+
+		Tcl_Obj *msg = statePtr->chanMsg;
+
+		if (statePtr->unreportedError == 0) {
+		    statePtr->unreportedError = errorCode;
+		    statePtr->unreportedMsg = msg;
+		    if (msg != NULL) {
+			Tcl_IncrRefCount(msg);
+		    }
+		} else {
+		    /*
+		     * An old unreported error is kept, and this error thrown
+		     * away.
+		     */
+
+		    statePtr->chanMsg = NULL;
+		    if (msg != NULL) {
+			TclDecrRefCount(msg);
+		    }
+		}
+	    } else {
+		/*
+		 * TIP #219, Tcl Channel Reflection API.
+		 * Move error messages put by the driver into the chan bypass
+		 * area into the regular interpreter result. Fall back to the
+		 * regular message if nothing was found in the bypasses.
+		 */
+
+		Tcl_SetErrno(errorCode);
+		if (interp != NULL && !TclChanCaughtErrorBypass(interp,
+			(Tcl_Channel) chanPtr)) {
+		    Tcl_SetObjResult(interp,
+			    Tcl_NewStringObj(Tcl_PosixError(interp), -1));
+		}
+
+		/*
+		 * An unreportable bypassed message is kept, for the caller of
+		 * Tcl_Seek, Tcl_Write, etc.
+		 */
+	    }
+
+	    /*
+	     * When we get an error we throw away all the output currently
+	     * queued.
+	     */
+
+	    DiscardOutputQueued(statePtr);
+	    ReleaseChannelBuffer(bufPtr);
+	    break;
+	} else {
+	    /* TODO: Consider detecting and reacting to short writes
+	     * on blocking channels.  Ought not happen.  See iocmd-24.2. */
+	    wroteSome = 1;
+	}
+
+	bufPtr->nextRemoved += written;
+
+	/*
+	 * If this buffer is now empty, recycle it.
+	 */
+
+	if (IsBufferEmpty(bufPtr)) {
+	    statePtr->outQueueHead = bufPtr->nextPtr;
+	    if (statePtr->outQueueHead == NULL) {
+		statePtr->outQueueTail = NULL;
+	    }
+	    RecycleBuffer(statePtr, bufPtr, 0);
+	}
+	ReleaseChannelBuffer(bufPtr);
+    }	/* Closes "while". */
+
+    /*
+     * If we wrote some data while flushing in the background, we are done.
+     * We can't finish the background flush until we run out of data and the
+     * channel becomes writable again. This ensures that all of the pending
+     * data has been flushed at the system level.
+     */
+
+    if (GotFlag(statePtr, BG_FLUSH_SCHEDULED)) {
+	if (wroteSome) {
+	    goto done;
+	} else if (statePtr->outQueueHead == NULL) {
+	    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
+	     * able to write something.  Either we did write something
+	     * and wroteSome should be set, or there was nothing left to
+	     * write in this call, and we've completed the BG flush.
+	     * These are the two cases above.  If we get here, that means
+	     * there is some kind failure in the writable event machinery.
+	     *
+	     * The tls extension indeed suffers from flaws in its channel
+	     * event mgmt.  See http://core.tcl.tk/tcl/info/c31ca233ca.
+	     * Until that patch is broadly distributed, disable the
+	     * assertion checking here, so that programs using Tcl and
+	     * tls can be debugged.
+
+	    assert(!calledFromAsyncFlush);
+	     */
+	}
+    }
+
+    /*
+     * If the channel is flagged as closed, delete it when the refCount drops
+     * to zero, the output queue is empty and there is no output in the
+     * current output buffer.
+     */
+
+    if (GotFlag(statePtr, CHANNEL_CLOSED) && (statePtr->refCount <= 0) &&
+	    (statePtr->outQueueHead == NULL) &&
+	    ((statePtr->curOutPtr == NULL) ||
+	    IsBufferEmpty(statePtr->curOutPtr))) {
+	errorCode = CloseChannel(interp, chanPtr, errorCode);
+	goto done;
+    }
+
+    /*
+     * If the write-side of the channel is flagged as closed, delete it when
+     * the output queue is empty and there is no output in the current output
+     * buffer.
+     */
+
+    if (GotFlag(statePtr, CHANNEL_CLOSEDWRITE) &&
+	    (statePtr->outQueueHead == NULL) &&
+	    ((statePtr->curOutPtr == NULL) ||
+	    IsBufferEmpty(statePtr->curOutPtr))) {
+	errorCode = CloseChannelPart(interp, chanPtr, errorCode, TCL_CLOSE_WRITE);
+	goto done;
+    }
+
+  done:
+    TclChannelRelease((Tcl_Channel)chanPtr);
+    return errorCode;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * CloseChannel --
+ *
+ *	Utility procedure to close a channel and free associated resources.
+ *
+ *	If the channel was stacked, then the it will copy the necessary
+ *	elements of the NEXT channel into the TOP channel, in essence
+ *	unstacking the channel. The NEXT channel will then be freed.
+ *
+ *	If the channel was not stacked, then we will free all the bits for the
+ *	TOP channel, including the data structure itself.
+ *
+ * Results:
+ *	Error code from an unreported error or the driver close operation.
+ *
+ * Side effects:
+ *	May close the actual channel, may free memory, may change the value of
+ *	errno.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+CloseChannel(
+    Tcl_Interp *interp,		/* For error reporting. */
+    Channel *chanPtr,		/* The channel to close. */
+    int errorCode)		/* Status of operation so far. */
+{
+    int result = 0;		/* Of calling driver close operation. */
+    ChannelState *statePtr;	/* State of the channel stack. */
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    if (chanPtr == NULL) {
+	return result;
+    }
+    statePtr = chanPtr->state;
+
+    /*
+     * No more input can be consumed so discard any leftover input.
+     */
+
+    DiscardInputQueued(statePtr, 1);
+
+    /*
+     * Discard a leftover buffer in the current output buffer field.
+     */
+
+    if (statePtr->curOutPtr != NULL) {
+	ReleaseChannelBuffer(statePtr->curOutPtr);
+	statePtr->curOutPtr = NULL;
+    }
+
+    /*
+     * The caller guarantees that there are no more buffers queued for output.
+     */
+
+    if (statePtr->outQueueHead != NULL) {
+	Tcl_Panic("TclFlush, closed channel: queued output left");
+    }
+
+    /*
+     * If the EOF character is set in the channel, append that to the output
+     * device.
+     */
+
+    if ((statePtr->outEofChar != 0) && GotFlag(statePtr, TCL_WRITABLE)) {
+	int dummy;
+	char c = (char) statePtr->outEofChar;
+
+	(void) ChanWrite(chanPtr, &c, 1, &dummy);
+    }
+
+    /*
+     * TIP #219, Tcl Channel Reflection API.
+     * Move a leftover error message in the channel bypass into the
+     * interpreter bypass. Just clear it if there is no interpreter.
+     */
+
+    if (statePtr->chanMsg != NULL) {
+	if (interp != NULL) {
+	    Tcl_SetChannelErrorInterp(interp, statePtr->chanMsg);
+	}
+	TclDecrRefCount(statePtr->chanMsg);
+	statePtr->chanMsg = NULL;
+    }
+
+    /*
+     * Remove this channel from of the list of all channels.
+     */
+
+    CutChannel((Tcl_Channel) chanPtr);
+
+    /*
+     * Close and free the channel driver state.
+     * This may leave a TIP #219 error message in the interp.
+     */
+
+    result = ChanClose(chanPtr, interp);
+
+    /*
+     * Some resources can be cleared only if the bottom channel in a stack is
+     * closed. All the other channels in the stack are not allowed to remove.
+     */
+
+    if (chanPtr == statePtr->bottomChanPtr) {
+	if (statePtr->channelName != NULL) {
+	    ckfree(statePtr->channelName);
+	    statePtr->channelName = NULL;
+	}
+
+	Tcl_FreeEncoding(statePtr->encoding);
+    }
+
+    /*
+     * If we are being called synchronously, report either any latent error on
+     * the channel or the current error.
+     */
+
+    if (statePtr->unreportedError != 0) {
+	errorCode = statePtr->unreportedError;
+
+	/*
+	 * 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) {
+	    TclDecrRefCount(statePtr->chanMsg);
+	    statePtr->chanMsg = NULL;
+	}
+	if (interp) {
+	    Tcl_SetChannelErrorInterp(interp, statePtr->unreportedMsg);
+	}
+    }
+    if (errorCode == 0) {
+	errorCode = result;
+	if (errorCode != 0) {
+	    Tcl_SetErrno(errorCode);
+	}
+    }
+
+    /*
+     * Cancel any outstanding timer.
+     */
+
+    Tcl_DeleteTimerHandler(statePtr->timer);
+
+    /*
+     * Mark the channel as deleted by clearing the type structure.
+     */
+
+    if (chanPtr->downChanPtr != NULL) {
+	Channel *downChanPtr = chanPtr->downChanPtr;
+
+	statePtr->nextCSPtr = tsdPtr->firstCSPtr;
+	tsdPtr->firstCSPtr = statePtr;
+
+	statePtr->topChanPtr = downChanPtr;
+	downChanPtr->upChanPtr = NULL;
+
+	ChannelFree(chanPtr);
+
+	return Tcl_Close(interp, (Tcl_Channel) downChanPtr);
+    }
+
+    /*
+     * There is only the TOP Channel, so we free the remaining pointers we
+     * have and then ourselves. Since this is the last of the channels in the
+     * stack, make sure to free the ChannelState structure associated with it.
+     */
+
+    ChannelFree(chanPtr);
+
+    Tcl_EventuallyFree(statePtr, TCL_DYNAMIC);
+
+    return errorCode;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_CutChannel --
+ * CutChannel --
+ *
+ *	Removes a channel from the (thread-)global list of all channels (in
+ *	that thread). This is actually the statePtr for the stack of channel.
+ *
+ * Results:
+ *	Nothing.
+ *
+ * Side effects:
+ *	Resets the field 'nextCSPtr' of the specified channel state to NULL.
+ *
+ * NOTE:
+ *	The channel to cut out of the list must not be referenced in any
+ *	interpreter. This is something this procedure cannot check (despite
+ *	the refcount) because the caller usually wants fiddle with the channel
+ *	(like transfering it to a different thread) and thus keeps the
+ *	refcount artifically high to prevent its destruction.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+CutChannel(
+    Tcl_Channel chan)		/* The channel being removed. Must not be
+				 * referenced in any interpreter. */
+{
+    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 = ((Channel *) chan)->state;
+				/* State of the channel stack. */
+
+    /*
+     * Remove this channel from of the list of all channels (in the current
+     * thread).
+     */
+
+    if (tsdPtr->firstCSPtr && (statePtr == tsdPtr->firstCSPtr)) {
+	tsdPtr->firstCSPtr = statePtr->nextCSPtr;
+    } else {
+	for (prevCSPtr = tsdPtr->firstCSPtr;
+		prevCSPtr && (prevCSPtr->nextCSPtr != statePtr);
+		prevCSPtr = prevCSPtr->nextCSPtr) {
+	    /* Empty loop body. */
+	}
+	if (prevCSPtr == NULL) {
+	    Tcl_Panic("FlushChannel: damaged channel list");
+	}
+	prevCSPtr->nextCSPtr = statePtr->nextCSPtr;
+    }
+
+    statePtr->nextCSPtr = NULL;
+
+    /*
+     * TIP #218, Channel Thread Actions
+     */
+
+    ChanThreadAction((Channel *) chan, TCL_CHANNEL_THREAD_REMOVE);
+}
+
+void
+Tcl_CutChannel(
+    Tcl_Channel chan)		/* The channel being added. Must not be
+				 * referenced in any interpreter. */
+{
+    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. */
+
+    /*
+     * Remove this channel from of the list of all channels (in the current
+     * thread).
+     */
+
+    if (tsdPtr->firstCSPtr && (statePtr == tsdPtr->firstCSPtr)) {
+	tsdPtr->firstCSPtr = statePtr->nextCSPtr;
+    } else {
+	for (prevCSPtr = tsdPtr->firstCSPtr;
+		prevCSPtr && (prevCSPtr->nextCSPtr != statePtr);
+		prevCSPtr = prevCSPtr->nextCSPtr) {
+	    /* Empty loop body. */
+	}
+	if (prevCSPtr == NULL) {
+	    Tcl_Panic("FlushChannel: damaged channel list");
+	}
+	prevCSPtr->nextCSPtr = statePtr->nextCSPtr;
+    }
+
+    statePtr->nextCSPtr = NULL;
+
+    /*
+     * TIP #218, Channel Thread Actions
+     * For all transformations and the base channel.
+     */
+
+    for (; chanPtr != NULL ; chanPtr = chanPtr->upChanPtr) {
+	ChanThreadAction(chanPtr, TCL_CHANNEL_THREAD_REMOVE);
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_SpliceChannel --
+ * SpliceChannel --
+ *
+ *	Adds a channel to the (thread-)global list of all channels (in that
+ *	thread). Expects that the field 'nextChanPtr' in the channel is set to
+ *	NULL.
+ *
+ * Results:
+ *	Nothing.
+ *
+ * Side effects:
+ *	Nothing.
+ *
+ * NOTE:
+ *	The channel to splice into the list must not be referenced in any
+ *	interpreter. This is something this procedure cannot check (despite
+ *	the refcount) because the caller usually wants figgle with the channel
+ *	(like transfering it to a different thread) and thus keeps the
+ *	refcount artifically high to prevent its destruction.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+SpliceChannel(
+    Tcl_Channel chan)		/* The channel being added. Must not be
+				 * referenced in any interpreter. */
+{
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+    ChannelState *statePtr = ((Channel *) chan)->state;
+
+    if (statePtr->nextCSPtr != NULL) {
+	Tcl_Panic("SpliceChannel: trying to add channel used in different list");
+    }
+
+    statePtr->nextCSPtr = tsdPtr->firstCSPtr;
+    tsdPtr->firstCSPtr = statePtr;
+
+    /*
+     * TIP #10. Mark the current thread as the new one managing this channel.
+     *		Note: 'Tcl_GetCurrentThread' returns sensible values even for
+     *		a non-threaded core.
+     */
+
+    statePtr->managingThread = Tcl_GetCurrentThread();
+
+    /*
+     * TIP #218, Channel Thread Actions
+     */
+
+    ChanThreadAction((Channel *) chan, TCL_CHANNEL_THREAD_INSERT);
+}
+
+void
+Tcl_SpliceChannel(
+    Tcl_Channel chan)		/* The channel being added. Must not be
+				 * referenced in any interpreter. */
+{
+    Channel *chanPtr = ((Channel *) chan)->state->bottomChanPtr;
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+    ChannelState *statePtr = chanPtr->state;
+
+    if (statePtr->nextCSPtr != NULL) {
+	Tcl_Panic("SpliceChannel: trying to add channel used in different list");
+    }
+
+    statePtr->nextCSPtr = tsdPtr->firstCSPtr;
+    tsdPtr->firstCSPtr = statePtr;
+
+    /*
+     * TIP #10. Mark the current thread as the new one managing this channel.
+     *		Note: 'Tcl_GetCurrentThread' returns sensible values even for
+     *		a non-threaded core.
+     */
+
+    statePtr->managingThread = Tcl_GetCurrentThread();
+
+    /*
+     * TIP #218, Channel Thread Actions
+     * For all transformations and the base channel.
+     */
+
+    for (; chanPtr != NULL ; chanPtr = chanPtr->upChanPtr) {
+	ChanThreadAction(chanPtr, TCL_CHANNEL_THREAD_INSERT);
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_Close --
+ *
+ *	Closes a channel.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	Closes the channel if this is the last reference.
+ *
+ * NOTE:
+ *	Tcl_Close removes the channel as far as the user is concerned.
+ *	However, it may continue to exist for a while longer if it has a
+ *	background flush scheduled. The device itself is eventually closed and
+ *	the channel record removed, in CloseChannel, above.
+ *
+ *----------------------------------------------------------------------
+ */
+
+	/* ARGSUSED */
+int
+Tcl_Close(
+    Tcl_Interp *interp,		/* Interpreter for errors. */
+    Tcl_Channel chan)		/* The channel being closed. Must not be
+				 * referenced in any interpreter. */
+{
+    CloseCallback *cbPtr;	/* Iterate over close callbacks for this
+				 * channel. */
+    Channel *chanPtr;		/* The real IO channel. */
+    ChannelState *statePtr;	/* State of real IO channel. */
+    int result;			/* Of calling FlushChannel. */
+    int flushcode;
+    int stickyError;
+
+    if (chan == NULL) {
+	return TCL_OK;
+    }
+
+    /*
+     * Perform special handling for standard channels being closed. If the
+     * refCount is now 1 it means that the last reference to the standard
+     * channel is being explicitly closed, so bump the refCount down
+     * artificially to 0. This will ensure that the channel is actually
+     * closed, below. Also set the static pointer to NULL for the channel.
+     */
+
+    CheckForStdChannelsBeingClosed(chan);
+
+    /*
+     * This operation should occur at the top of a channel stack.
+     */
+
+    chanPtr = (Channel *) chan;
+    statePtr = chanPtr->state;
+    chanPtr = statePtr->topChanPtr;
+
+    if (statePtr->refCount > 0) {
+	Tcl_Panic("called Tcl_Close on channel with refCount > 0");
+    }
+
+    if (GotFlag(statePtr, CHANNEL_INCLOSE)) {
+	if (interp) {
+	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
+                    "illegal recursive call to close through close-handler"
+                    " of channel", -1));
+	}
+	return TCL_ERROR;
+    }
+    SetFlag(statePtr, CHANNEL_INCLOSE);
+
+    /*
+     * When the channel has an escape sequence driven encoding such as
+     * iso2022, the terminated escape sequence must write to the buffer.
+     */
+
+    stickyError = 0;
+
+    if (GotFlag(statePtr, TCL_WRITABLE) && (statePtr->encoding != NULL)
+	    && !(statePtr->outputEncodingFlags & TCL_ENCODING_START)) {
+
+	int code = CheckChannelErrors(statePtr, TCL_WRITABLE);
+
+	if (code == 0) {
+	    statePtr->outputEncodingFlags |= TCL_ENCODING_END;
+	    code = WriteChars(chanPtr, "", 0);
+	    statePtr->outputEncodingFlags &= ~TCL_ENCODING_END;
+	    statePtr->outputEncodingFlags |= TCL_ENCODING_START;
+	}
+	if (code < 0) {
+	    stickyError = Tcl_GetErrno();
+	}
+
+	/*
+	 * TIP #219, Tcl Channel Reflection API.
+	 * Move an error message found in the channel bypass into the
+	 * interpreter bypass. Just clear it if there is no interpreter.
+	 */
+
+	if (statePtr->chanMsg != NULL) {
+	    if (interp != NULL) {
+		Tcl_SetChannelErrorInterp(interp, statePtr->chanMsg);
+	    }
+	    TclDecrRefCount(statePtr->chanMsg);
+	    statePtr->chanMsg = NULL;
+	}
+    }
+
+    Tcl_ClearChannelHandlers(chan);
+
+    /*
+     * Invoke the registered close callbacks and delete their records.
+     */
+
+    while (statePtr->closeCbPtr != NULL) {
+	cbPtr = statePtr->closeCbPtr;
+	statePtr->closeCbPtr = cbPtr->nextPtr;
+	cbPtr->proc(cbPtr->clientData);
+	ckfree(cbPtr);
+    }
+
+    ResetFlag(statePtr, CHANNEL_INCLOSE);
+
+    /*
+     * If this channel supports it, close the read side, since we don't need
+     * it anymore and this will help avoid deadlocks on some channel types.
+     */
+
+    if (chanPtr->typePtr->closeProc == TCL_CLOSE2PROC) {
+	result = chanPtr->typePtr->close2Proc(chanPtr->instanceData, interp,
+		TCL_CLOSE_READ);
+    } else {
+	result = 0;
+    }
+
+    /*
+     * The call to FlushChannel will flush any queued output and invoke the
+     * close function of the channel driver, or it will set up the channel to
+     * be flushed and closed asynchronously.
+     */
+
+    SetFlag(statePtr, CHANNEL_CLOSED);
+
+    flushcode = FlushChannel(interp, chanPtr, 0);
+
+    /*
+     * TIP #219.
+     * Capture error messages put by the driver into the bypass area and put
+     * 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
+     * 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
+     * any channel message it generated into it.
+     */
+
+    if (TclChanCaughtErrorBypass(interp, NULL)) {
+	result = EINVAL;
+    }
+
+    if (stickyError != 0) {
+	Tcl_SetErrno(stickyError);
+	if (interp != NULL) {
+	    Tcl_SetObjResult(interp,
+			     Tcl_NewStringObj(Tcl_PosixError(interp), -1));
+	}
+	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)) ) {
+	Tcl_SetErrno(flushcode);
+	Tcl_SetObjResult(interp,
+		Tcl_NewStringObj(Tcl_PosixError(interp), -1));
+    }
+    if ((flushcode != 0) || (result != 0)) {
+	return TCL_ERROR;
+    }
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_CloseEx --
+ *
+ *	Closes one side of a channel, read or write.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	Closes one direction of the channel.
+ *
+ * NOTE:
+ *	Tcl_CloseEx closes the specified direction of the channel as far as
+ *	the user is concerned. The channel keeps existing however. You cannot
+ *	calls this function to close the last possible direction of the
+ *	channel. Use Tcl_Close for that.
+ *
+ *----------------------------------------------------------------------
+ */
+
+	/* ARGSUSED */
+int
+Tcl_CloseEx(
+    Tcl_Interp *interp,		/* Interpreter for errors. */
+    Tcl_Channel chan,		/* The channel being closed. May still be used
+				 * by some interpreter. */
+    int flags)			/* Flags telling us which side to close. */
+{
+    Channel *chanPtr;		/* The real IO channel. */
+    ChannelState *statePtr;	/* State of real IO channel. */
+
+    if (chan == NULL) {
+	return TCL_OK;
+    }
+
+    /* TODO: assert flags validity ? */
+
+    chanPtr = (Channel *) chan;
+    statePtr = chanPtr->state;
+
+    /*
+     * Does the channel support half-close anyway? Error if not.
+     */
+
+    if (!chanPtr->typePtr->close2Proc) {
+	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+                "half-close of channels not supported by %ss",
+		chanPtr->typePtr->typeName));
+	return TCL_ERROR;
+    }
+
+    /*
+     * Is the channel unstacked ? If not we fail.
+     */
+
+    if (chanPtr != statePtr->topChanPtr) {
+	Tcl_SetObjResult(interp, Tcl_NewStringObj(
+		"half-close not applicable to stack of transformations", -1));
+	return TCL_ERROR;
+    }
+
+    /*
+     * Check direction against channel mode. It is an error if we try to close
+     * a direction not supported by the channel (already closed, or never
+     * opened for that direction).
+     */
+
+    if (!(statePtr->flags & (TCL_READABLE | TCL_WRITABLE) & flags)) {
+	const char *msg;
+
+	if (flags & TCL_CLOSE_READ) {
+	    msg = "read";
+	} else {
+	    msg = "write";
+	}
+	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+                "Half-close of %s-side not possible, side not opened or"
+                " already closed", msg));
+	return TCL_ERROR;
+    }
+
+    /*
+     * A user may try to call half-close from within a channel close
+     * handler. That won't do.
+     */
+
+    if (statePtr->flags & CHANNEL_INCLOSE) {
+	if (interp) {
+	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
+                    "illegal recursive call to close through close-handler"
+                    " of channel", -1));
+	}
+	return TCL_ERROR;
+    }
+
+    if (flags & TCL_CLOSE_READ) {
+	/*
+	 * Call the finalization code directly. There are no events to handle,
+	 * there cannot be for the read-side.
+	 */
+
+	return CloseChannelPart(interp, chanPtr, 0, flags);
+    } else if (flags & TCL_CLOSE_WRITE) {
+	Tcl_Preserve(statePtr);
+	if (!GotFlag(statePtr, BG_FLUSH_SCHEDULED)) {
+	    /*
+	     * We don't want to re-enter CloseWrite().
+	     */
+
+	    if (!GotFlag(statePtr, CHANNEL_CLOSEDWRITE)) {
+		if (CloseWrite(interp, chanPtr) != TCL_OK) {
+		    SetFlag(statePtr, CHANNEL_CLOSEDWRITE);
+		    Tcl_Release(statePtr);
+		    return TCL_ERROR;
+		}
+	    }
+	}
+	SetFlag(statePtr, CHANNEL_CLOSEDWRITE);
+	Tcl_Release(statePtr);
+    }
+
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * CloseWrite --
+ *
+ *	Closes the write side a channel.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	Closes the write side of the channel.
+ *
+ * NOTE:
+ *	CloseWrite removes the channel as far as the user is concerned.
+ *	However, the ooutput data structures may continue to exist for a while
+ *	longer if it has a background flush scheduled. The device itself is
+ *	eventually closed and the channel structures modified, in
+ *	CloseChannelPart, below.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+CloseWrite(
+    Tcl_Interp *interp,		/* Interpreter for errors. */
+    Channel *chanPtr)		/* The channel whose write side is being
+                                 * 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) */
+
+    ChannelState *statePtr = chanPtr->state;
+                                /* State of real IO channel. */
+    int flushcode;
+    int result = 0;
+
+    /*
+     * The call to FlushChannel will flush any queued output and invoke the
+     * close function of the channel driver, or it will set up the channel to
+     * be flushed and closed asynchronously.
+     */
+
+    SetFlag(statePtr, CHANNEL_CLOSEDWRITE);
+
+    flushcode = FlushChannel(interp, chanPtr, 0);
+
+    /*
+     * TIP #219.
+     * Capture error messages put by the driver into the bypass area and put
+     * them into the regular interpreter result.
+     *
+     * 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.
+     */
+
+    if (TclChanCaughtErrorBypass(interp, NULL)) {
+	result = EINVAL;
+    }
+
+    if ((flushcode != 0) || (result != 0)) {
+	return TCL_ERROR;
+    }
+
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * CloseChannelPart --
+ *
+ *	Utility procedure to close a channel partially and free associated
+ *	resources. If the channel was stacked it will never be run (The higher
+ *	level forbid this). If the channel was not stacked, then we will free
+ *	all the bits of the chosen side (read, or write) for the TOP channel.
+ *
+ * Results:
+ *	Error code from an unreported error or the driver close2 operation.
+ *
+ * Side effects:
+ *	May free memory, may change the value of errno.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+CloseChannelPart(
+    Tcl_Interp *interp,		/* Interpreter for errors. */
+    Channel *chanPtr,		/* The channel being closed. May still be used
+				 * by some interpreter. */
+    int errorCode,		/* Status of operation so far. */
+    int flags)			/* Flags telling us which side to close. */
+{
+    ChannelState *statePtr;	/* State of real IO channel. */
+    int result;			/* Of calling the close2proc. */
+
+    statePtr = chanPtr->state;
+
+    if (flags & TCL_CLOSE_READ) {
+	/*
+	 * No more input can be consumed so discard any leftover input.
+	 */
+
+	DiscardInputQueued(statePtr, 1);
+    } else if (flags & TCL_CLOSE_WRITE) {
+	/*
+	 * The caller guarantees that there are no more buffers queued for
+	 * output.
+	 */
+
+	if (statePtr->outQueueHead != NULL) {
+	    Tcl_Panic("ClosechanHalf, closed write-side of channel: "
+		    "queued output left");
+	}
+
+	/*
+	 * If the EOF character is set in the channel, append that to the
+	 * output device.
+	 */
+
+	if ((statePtr->outEofChar != 0) && GotFlag(statePtr, TCL_WRITABLE)) {
+	    int dummy;
+	    char c = (char) statePtr->outEofChar;
+
+	    (void) ChanWrite(chanPtr, &c, 1, &dummy);
+	}
+
+	/*
+	 * TIP #219, Tcl Channel Reflection API.
+	 * Move a leftover error message in the channel bypass into the
+	 * interpreter bypass. Just clear it if there is no interpreter.
+	 */
+
+	if (statePtr->chanMsg != NULL) {
+	    if (interp != NULL) {
+		Tcl_SetChannelErrorInterp(interp, statePtr->chanMsg);
+	    }
+	    TclDecrRefCount(statePtr->chanMsg);
+	    statePtr->chanMsg = NULL;
+	}
+    }
+
+    /*
+     * Finally do what is asked of us. Close and free the channel driver state
+     * for the chosen side of the channel. This may leave a TIP #219 error
+     * message in the interp.
+     */
+
+    result = ChanCloseHalf(chanPtr, interp, flags);
+
+    /*
+     * If we are being called synchronously, report either any latent error on
+     * the channel or the current error.
+     */
+
+    if (statePtr->unreportedError != 0) {
+	errorCode = statePtr->unreportedError;
+
+	/*
+	 * 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) {
+	    TclDecrRefCount(statePtr->chanMsg);
+	    statePtr->chanMsg = NULL;
+	}
+	if (interp) {
+	    Tcl_SetChannelErrorInterp(interp, statePtr->unreportedMsg);
+	}
+    }
+    if (errorCode == 0) {
+	errorCode = result;
+	if (errorCode != 0) {
+	    Tcl_SetErrno(errorCode);
+	}
+    }
+
+    /*
+     * TIP #219.
+     * Capture error messages put by the driver into the bypass area and put
+     * them into the regular interpreter result. See also the bottom of
+     * CloseWrite().
+     */
+
+    if (TclChanCaughtErrorBypass(interp, (Tcl_Channel) chanPtr)) {
+	result = EINVAL;
+    }
+
+    if (result != 0) {
+	return TCL_ERROR;
+    }
+
+    /*
+     * Remove the closed side from the channel mode/flags.
+     */
+
+    ResetFlag(statePtr, flags & (TCL_READABLE | TCL_WRITABLE));
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ClearChannelHandlers --
+ *
+ *	Removes all channel handlers and event scripts from the channel,
+ *	cancels all background copies involving the channel and any interest
+ *	in events.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	See above. Deallocates memory.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_ClearChannelHandlers(
+    Tcl_Channel channel)
+{
+    ChannelHandler *chPtr, *chNext;	/* Iterate over channel handlers. */
+    EventScriptRecord *ePtr, *eNextPtr;	/* Iterate over eventscript records. */
+    Channel *chanPtr;			/* The real IO channel. */
+    ChannelState *statePtr;		/* State of real IO channel. */
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+    NextChannelHandler *nhPtr;
+
+    /*
+     * This operation should occur at the top of a channel stack.
+     */
+
+    chanPtr = (Channel *) channel;
+    statePtr = chanPtr->state;
+    chanPtr = statePtr->topChanPtr;
+
+    /*
+     * Cancel any outstanding timer.
+     */
+
+    Tcl_DeleteTimerHandler(statePtr->timer);
+
+    /*
+     * Remove any references to channel handlers for this channel that may be
+     * about to be invoked.
+     */
+
+    for (nhPtr = tsdPtr->nestedHandlerPtr; nhPtr != NULL;
+	    nhPtr = nhPtr->nestedHandlerPtr) {
+	if (nhPtr->nextHandlerPtr &&
+		(nhPtr->nextHandlerPtr->chanPtr == chanPtr)) {
+	    nhPtr->nextHandlerPtr = NULL;
+	}
+    }
+
+    /*
+     * Remove all the channel handler records attached to the channel itself.
+     */
+
+    for (chPtr = statePtr->chPtr; chPtr != NULL; chPtr = chNext) {
+	chNext = chPtr->nextPtr;
+	ckfree(chPtr);
+    }
+    statePtr->chPtr = NULL;
+
+    /*
+     * Cancel any pending copy operation.
+     */
+
+    StopCopy(statePtr->csPtrR);
+    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.
+     */
+
+    statePtr->interestMask = 0;
+
+    /*
+     * Remove any EventScript records for this channel.
+     */
+
+    for (ePtr = statePtr->scriptRecordPtr; ePtr != NULL; ePtr = eNextPtr) {
+	eNextPtr = ePtr->nextPtr;
+	TclDecrRefCount(ePtr->scriptPtr);
+	ckfree(ePtr);
+    }
+    statePtr->scriptRecordPtr = NULL;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_Write --
+ *
+ *	Puts a sequence of bytes into an output buffer, may queue the buffer
+ *	for output if it gets full, and also remembers whether the current
+ *	buffer is ready e.g. if it contains a newline and we are in line
+ *	buffering mode. Compensates stacking, i.e. will redirect the data from
+ *	the specified channel to the topmost channel in a stack.
+ *
+ *	No encoding conversions are applied to the bytes being read.
+ *
+ * Results:
+ *	The number of bytes written or -1 in case of error. If -1,
+ *	Tcl_GetErrno will return the error code.
+ *
+ * Side effects:
+ *	May buffer up output and may cause output to be produced on the
+ *	channel.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_Write(
+    Tcl_Channel chan,		/* The channel to buffer output for. */
+    const char *src,		/* Data to queue in output buffer. */
+    int srcLen)			/* Length of data in bytes, or < 0 for
+				 * strlen(). */
+{
+    /*
+     * Always use the topmost channel of the stack
+     */
+
+    Channel *chanPtr;
+    ChannelState *statePtr;	/* State info for channel */
+
+    statePtr = ((Channel *) chan)->state;
+    chanPtr = statePtr->topChanPtr;
+
+    if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
+	return -1;
+    }
+
+    if (srcLen < 0) {
+	srcLen = strlen(src);
+    }
+    if (WriteBytes(chanPtr, src, srcLen) < 0) {
+	return -1;
+    }
+    return srcLen;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_WriteRaw --
+ *
+ *	Puts a sequence of bytes into an output buffer, may queue the buffer
+ *	for output if it gets full, and also remembers whether the current
+ *	buffer is ready e.g. if it contains a newline and we are in line
+ *	buffering mode. Writes directly to the driver of the channel, does not
+ *	compensate for stacking.
+ *
+ *	No encoding conversions are applied to the bytes being read.
+ *
+ * Results:
+ *	The number of bytes written or -1 in case of error. If -1,
+ *	Tcl_GetErrno will return the error code.
+ *
+ * Side effects:
+ *	May buffer up output and may cause output to be produced on the
+ *	channel.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_WriteRaw(
+    Tcl_Channel chan,		/* The channel to buffer output for. */
+    const char *src,		/* Data to queue in output buffer. */
+    int srcLen)			/* Length of data in bytes, or < 0 for
+				 * strlen(). */
+{
+    Channel *chanPtr = ((Channel *) chan);
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
+    int errorCode, written;
+
+    if (CheckChannelErrors(statePtr, TCL_WRITABLE | CHANNEL_RAW_MODE) != 0) {
+	return -1;
+    }
+
+    if (srcLen < 0) {
+	srcLen = strlen(src);
+    }
+
+    /*
+     * Go immediately to the driver, do all the error handling by ourselves.
+     * The code was stolen from 'FlushChannel'.
+     */
+
+    written = ChanWrite(chanPtr, src, srcLen, &errorCode);
+    if (written < 0) {
+	Tcl_SetErrno(errorCode);
+    }
+
+    return written;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * Tcl_WriteChars --
+ *
+ *	Takes a sequence of UTF-8 characters and converts them for output
+ *	using the channel's current encoding, may queue the buffer for output
+ *	if it gets full, and also remembers whether the current buffer is
+ *	ready e.g. if it contains a newline and we are in line buffering
+ *	mode. Compensates stacking, i.e. will redirect the data from the
+ *	specified channel to the topmost channel in a stack.
+ *
+ * Results:
+ *	The number of bytes written or -1 in case of error. If -1,
+ *	Tcl_GetErrno will return the error code.
+ *
+ * Side effects:
+ *	May buffer up output and may cause output to be produced on the
+ *	channel.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_WriteChars(
+    Tcl_Channel chan,		/* The channel to buffer output for. */
+    const char *src,		/* UTF-8 characters to queue in output
+				 * buffer. */
+    int len)			/* Length of string in bytes, or < 0 for
+				 * strlen(). */
+{
+    Channel *chanPtr = (Channel *) chan;
+    ChannelState *statePtr = chanPtr->state;	/* State info for channel */
+    int result;
+    Tcl_Obj *objPtr;
+
+    if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
+	return -1;
+    }
+
+    chanPtr = statePtr->topChanPtr;
+
+    if (len < 0) {
+	len = strlen(src);
+    }
+    if (statePtr->encoding) {
+	return WriteChars(chanPtr, src, len);
+    }
+
+    /*
+     * Inefficient way to convert UTF-8 to byte-array, but the code
+     * parallels the way it is done for objects.  Special case for 1-byte
+     * (used by eg [puts] for the \n) could be extended to more efficient
+     * translation of the src string.
+     */
+
+    if ((len == 1) && (UCHAR(*src) < 0xC0)) {
+	return WriteBytes(chanPtr, src, len);
+    }
+
+    objPtr = Tcl_NewStringObj(src, len);
+    src = (char *) Tcl_GetByteArrayFromObj(objPtr, &len);
+    result = WriteBytes(chanPtr, src, len);
+    TclDecrRefCount(objPtr);
+    return result;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * Tcl_WriteObj --
+ *
+ *	Takes the Tcl object and queues its contents for output. If the
+ *	encoding of the channel is NULL, takes the byte-array representation
+ *	of the object and queues those bytes for output. Otherwise, takes the
+ *	characters in the UTF-8 (string) representation of the object and
+ *	converts them for output using the channel's current encoding. May
+ *	flush internal buffers to output if one becomes full or is ready for
+ *	some other reason, e.g. if it contains a newline and the channel is in
+ *	line buffering mode.
+ *
+ * Results:
+ *	The number of bytes written or -1 in case of error. If -1,
+ *	Tcl_GetErrno() will return the error code.
+ *
+ * Side effects:
+ *	May buffer up output and may cause output to be produced on the
+ *	channel.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_WriteObj(
+    Tcl_Channel chan,		/* The channel to buffer output for. */
+    Tcl_Obj *objPtr)		/* The object to write. */
+{
+    /*
+     * Always use the topmost channel of the stack
+     */
+
+    Channel *chanPtr;
+    ChannelState *statePtr;	/* State info for channel */
+    const char *src;
+    int srcLen;
+
+    statePtr = ((Channel *) chan)->state;
+    chanPtr = statePtr->topChanPtr;
+
+    if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
+	return -1;
+    }
+    if (statePtr->encoding == NULL) {
+	src = (char *) Tcl_GetByteArrayFromObj(objPtr, &srcLen);
+	return WriteBytes(chanPtr, src, srcLen);
+    } else {
+	src = TclGetStringFromObj(objPtr, &srcLen);
+	return WriteChars(chanPtr, src, srcLen);
+    }
+}
+
+static void
+WillWrite(
+    Channel *chanPtr)
+{
+    int inputBuffered;
+
+    if ((chanPtr->typePtr->seekProc != NULL) &&
+            ((inputBuffered = Tcl_InputBuffered((Tcl_Channel) chanPtr)) > 0)){
+        int ignore;
+
+        DiscardInputQueued(chanPtr->state, 0);
+        ChanSeek(chanPtr, -inputBuffered, SEEK_CUR, &ignore);
+    }
+}
+
+static int
+WillRead(
+    Channel *chanPtr)
+{
+    if (chanPtr->typePtr == NULL) {
+	/* 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.
+	 */
+
+        if (FlushChannel(NULL, chanPtr, 0) != 0) {
+            return -1;
+        }
+    }
+    return 0;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Write --
+ *
+ *	Convert srcLen bytes starting at src according to encoding and write
+ *	produced bytes into an output buffer, may queue the buffer for output
+ *	if it gets full, and also remembers whether the current buffer is
+ *	ready e.g. if it contains a newline and we are in line buffering mode.
+ *
+ * Results:
+ *	The number of bytes written or -1 in case of error. If -1,
+ *	Tcl_GetErrno will return the error code.
+ *
+ * Side effects:
+ *	May buffer up output and may cause output to be produced on the
+ *	channel.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+Write(
+    Channel *chanPtr,		/* The channel to buffer output for. */
+    const char *src,		/* UTF-8 string to write. */
+    int srcLen,			/* Length of UTF-8 string in bytes. */
+    Tcl_Encoding encoding)
+{
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
+    char *nextNewLine = NULL;
+    int endEncoding, saved = 0, total = 0, flushed = 0, needNlFlush = 0;
+
+    if (srcLen) {
+        WillWrite(chanPtr);
+    }
+
+    /*
+     * Write the terminated escape sequence even if srcLen is 0.
+     */
+
+    endEncoding = ((statePtr->outputEncodingFlags & TCL_ENCODING_END) != 0);
+
+    if (GotFlag(statePtr, CHANNEL_LINEBUFFERED)
+	    || (statePtr->outputTranslation != TCL_TRANSLATE_LF)) {
+	nextNewLine = memchr(src, '\n', srcLen);
+    }
+
+    while (srcLen + saved + endEncoding > 0) {
+	ChannelBuffer *bufPtr;
+	char *dst, safe[BUFFER_PADDING];
+	int result, srcRead, dstLen, dstWrote, srcLimit = srcLen;
+
+	if (nextNewLine) {
+	    srcLimit = nextNewLine - src;
+	}
+
+	/* Get space to write into */
+	bufPtr = statePtr->curOutPtr;
+	if (bufPtr == NULL) {
+	    bufPtr = AllocChannelBuffer(statePtr->bufSize);
+	    statePtr->curOutPtr = bufPtr;
+	}
+	if (saved) {
+	    /*
+	     * Here's some translated bytes left over from the last buffer
+	     * that we need to stick at the beginning of this buffer.
+	     */
+
+	    memcpy(InsertPoint(bufPtr), safe, (size_t) saved);
+	    bufPtr->nextAdded += saved;
+	    saved = 0;
+	}
+	PreserveChannelBuffer(bufPtr);
+	dst = InsertPoint(bufPtr);
+	dstLen = SpaceLeft(bufPtr);
+
+	result = Tcl_UtfToExternal(NULL, encoding, src, srcLimit,
+		statePtr->outputEncodingFlags,
+		&statePtr->outputEncodingState, dst,
+		dstLen + BUFFER_PADDING, &srcRead, &dstWrote, NULL);
+
+	/* 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 */
+	    ReleaseChannelBuffer(bufPtr);
+	    if (total == 0) {
+		Tcl_SetErrno(EINVAL);
+		return -1;
+	    }
+	    break;
+	}
+
+	bufPtr->nextAdded += dstWrote;
+	src += srcRead;
+	srcLen -= srcRead;
+	total += dstWrote;
+	dst += dstWrote;
+	dstLen -= dstWrote;
+
+	if (src == nextNewLine && dstLen > 0) {
+	    static char crln[3] = "\r\n";
+	    char *nl = NULL;
+	    int nlLen = 0;
+
+	    switch (statePtr->outputTranslation) {
+	    case TCL_TRANSLATE_LF:
+		nl = crln + 1;
+		nlLen = 1;
+		break;
+	    case TCL_TRANSLATE_CR:
+		nl = crln;
+		nlLen = 1;
+		break;
+	    case TCL_TRANSLATE_CRLF:
+		nl = crln;
+		nlLen = 2;
+		break;
+	    default:
+		Tcl_Panic("unknown output translation requested");
+		break;
+	    }
+
+	    result |= Tcl_UtfToExternal(NULL, encoding, nl, nlLen,
+		statePtr->outputEncodingFlags,
+		&statePtr->outputEncodingState, dst,
+		dstLen + BUFFER_PADDING, &srcRead, &dstWrote, NULL);
+
+	    assert (srcRead == nlLen);
+
+	    bufPtr->nextAdded += dstWrote;
+	    src++;
+	    srcLen--;
+	    total += dstWrote;
+	    dst += dstWrote;
+	    dstLen -= dstWrote;
+	    nextNewLine = memchr(src, '\n', srcLen);
+	    needNlFlush = 1;
+	}
+
+	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.
+	     */
+
+	    saved = -SpaceLeft(bufPtr);
+	    memcpy(safe, dst + dstLen, (size_t) saved);
+	    bufPtr->nextAdded = bufPtr->bufLength;
+	}
+
+	if ((srcLen + saved == 0) && (result == TCL_OK)) {
+	    endEncoding = 0;
+	}
+
+	if (IsBufferFull(bufPtr)) {
+	    if (FlushChannel(NULL, chanPtr, 0) != 0) {
+		ReleaseChannelBuffer(bufPtr);
+		return -1;
+	    }
+	    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.
+ 	     */
+	    if (needNlFlush && (saved == 0 || src[-1] != '\n')) {
+		needNlFlush = 0;
+	    }
+	}
+	ReleaseChannelBuffer(bufPtr);
+    }
+    if ((flushed < total) && (GotFlag(statePtr, CHANNEL_UNBUFFERED) ||
+	    (needNlFlush && GotFlag(statePtr, CHANNEL_LINEBUFFERED)))) {
+	if (FlushChannel(NULL, chanPtr, 0) != 0) {
+	    return -1;
+	}
+    }
+
+    return total;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * Tcl_Gets --
+ *
+ *	Reads a complete line of input from the channel into a Tcl_DString.
+ *
+ * Results:
+ *	Length of line read (in characters) or -1 if error, EOF, or blocked.
+ *	If -1, use Tcl_GetErrno() to retrieve the POSIX error code for the
+ *	error or condition that occurred.
+ *
+ * Side effects:
+ *	May flush output on the channel. May cause input to be consumed from
+ *	the channel.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+int
+Tcl_Gets(
+    Tcl_Channel chan,		/* Channel from which to read. */
+    Tcl_DString *lineRead)	/* The line read will be appended to this
+				 * DString as UTF-8 characters. The caller
+				 * must have initialized it and is responsible
+				 * for managing the storage. */
+{
+    Tcl_Obj *objPtr;
+    int charsStored;
+
+    TclNewObj(objPtr);
+    charsStored = Tcl_GetsObj(chan, objPtr);
+    if (charsStored > 0) {
+	TclDStringAppendObj(lineRead, objPtr);
+    }
+    TclDecrRefCount(objPtr);
+    return charsStored;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * Tcl_GetsObj --
+ *
+ *	Accumulate input from the input channel until end-of-line or
+ *	end-of-file has been seen. Bytes read from the input channel are
+ *	converted to UTF-8 using the encoding specified by the channel.
+ *
+ * Results:
+ *	Number of characters accumulated in the object or -1 if error,
+ *	blocked, or EOF. If -1, use Tcl_GetErrno() to retrieve the POSIX error
+ *	code for the error or condition that occurred.
+ *
+ * Side effects:
+ *	Consumes input from the channel.
+ *
+ *	On reading EOF, leave channel pointing at EOF char. On reading EOL,
+ *	leave channel pointing after EOL, but don't return EOL in dst buffer.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+int
+Tcl_GetsObj(
+    Tcl_Channel chan,		/* Channel from which to read. */
+    Tcl_Obj *objPtr)		/* The line read will be appended to this
+				 * object as UTF-8 characters. */
+{
+    GetsState gs;
+    Channel *chanPtr = (Channel *) chan;
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
+    ChannelBuffer *bufPtr;
+    int inEofChar, skip, copiedTotal, oldLength, oldFlags, oldRemoved;
+    Tcl_Encoding encoding;
+    char *dst, *dstEnd, *eol, *eof;
+    Tcl_EncodingState oldState;
+
+    if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) {
+	return -1;
+    }
+
+    /*
+     * If we're sitting ready to read the eofchar, there's no need to
+     * do it.
+     */
+
+    if (GotFlag(statePtr, CHANNEL_STICKY_EOF)) {
+	SetFlag(statePtr, CHANNEL_EOF);
+	assert( statePtr->inputEncodingFlags & TCL_ENCODING_END );
+	assert( !GotFlag(statePtr, CHANNEL_BLOCKED|INPUT_SAW_CR) );
+
+	/* TODO: Do we need this? */
+	UpdateInterest(chanPtr);
+	return -1;
+    }
+
+    /*
+     * A binary version of Tcl_GetsObj. This could also handle encodings that
+     * are ascii-7 pure (iso8859, utf-8, ...) with a final encoding conversion
+     * done on objPtr.
+     */
+
+    if ((statePtr->encoding == NULL)
+	    && ((statePtr->inputTranslation == TCL_TRANSLATE_LF)
+		    || (statePtr->inputTranslation == TCL_TRANSLATE_CR))) {
+	return TclGetsObjBinary(chan, objPtr);
+    }
+
+    /*
+     * This operation should occur at the top of a channel stack.
+     */
+
+    chanPtr = statePtr->topChanPtr;
+    TclChannelPreserve((Tcl_Channel)chanPtr);
+
+    bufPtr = statePtr->inQueueHead;
+    encoding = statePtr->encoding;
+
+    /*
+     * Preserved so we can restore the channel's state in case we don't find a
+     * newline in the available input.
+     */
+
+    TclGetStringFromObj(objPtr, &oldLength);
+    oldFlags = statePtr->inputEncodingFlags;
+    oldState = statePtr->inputEncodingState;
+    oldRemoved = BUFFER_PADDING;
+    if (bufPtr != NULL) {
+	oldRemoved = bufPtr->nextRemoved;
+    }
+
+    /*
+     * If there is no encoding, use "iso8859-1" -- Tcl_GetsObj() doesn't
+     * produce ByteArray objects.
+     */
+
+    if (encoding == NULL) {
+	encoding = GetBinaryEncoding();
+    }
+
+    /*
+     * Object used by FilterInputBytes to keep track of how much data has been
+     * consumed from the channel buffers.
+     */
+
+    gs.objPtr		= objPtr;
+    gs.dstPtr		= &dst;
+    gs.encoding		= encoding;
+    gs.bufPtr		= bufPtr;
+    gs.state		= oldState;
+    gs.rawRead		= 0;
+    gs.bytesWrote	= 0;
+    gs.charsWrote	= 0;
+    gs.totalChars	= 0;
+
+    dst = objPtr->bytes + oldLength;
+    dstEnd = dst;
+
+    skip = 0;
+    eof = NULL;
+    inEofChar = statePtr->inEofChar;
+
+    ResetFlag(statePtr, CHANNEL_BLOCKED);
+    while (1) {
+	if (dst >= dstEnd) {
+	    if (FilterInputBytes(chanPtr, &gs) != 0) {
+		goto restore;
+	    }
+	    dstEnd = dst + gs.bytesWrote;
+	}
+
+	/*
+	 * Remember if EOF char is seen, then look for EOL anyhow, because the
+	 * EOL might be before the EOF char.
+	 */
+
+	if (inEofChar != '\0') {
+	    for (eol = dst; eol < dstEnd; eol++) {
+		if (*eol == inEofChar) {
+		    dstEnd = eol;
+		    eof = eol;
+		    break;
+		}
+	    }
+	}
+
+	/*
+	 * On EOL, leave current file position pointing after the EOL, but
+	 * don't store the EOL in the output string.
+	 */
+
+	switch (statePtr->inputTranslation) {
+	case TCL_TRANSLATE_LF:
+	    for (eol = dst; eol < dstEnd; eol++) {
+		if (*eol == '\n') {
+		    skip = 1;
+		    goto gotEOL;
+		}
+	    }
+	    break;
+	case TCL_TRANSLATE_CR:
+	    for (eol = dst; eol < dstEnd; eol++) {
+		if (*eol == '\r') {
+		    skip = 1;
+		    goto gotEOL;
+		}
+	    }
+	    break;
+	case TCL_TRANSLATE_CRLF:
+	    for (eol = dst; eol < dstEnd; eol++) {
+		if (*eol == '\r') {
+		    eol++;
+
+		    /*
+		     * If a CR is at the end of the buffer, then check for a
+		     * LF at the begining of the next buffer, unless EOF char
+		     * was found already.
+		     */
+
+		    if (eol >= dstEnd) {
+			int offset;
+
+			if (eol != eof) {
+			    offset = eol - objPtr->bytes;
+			    dst = dstEnd;
+			    if (FilterInputBytes(chanPtr, &gs) != 0) {
+				goto restore;
+			    }
+			    dstEnd = dst + gs.bytesWrote;
+			    eol = objPtr->bytes + offset;
+			}
+			if (eol >= dstEnd) {
+			    skip = 0;
+			    goto gotEOL;
+			}
+		    }
+		    if (*eol == '\n') {
+			eol--;
+			skip = 2;
+			goto gotEOL;
+		    }
+		}
+	    }
+	    break;
+	case TCL_TRANSLATE_AUTO:
+	    eol = dst;
+	    skip = 1;
+	    if (GotFlag(statePtr, INPUT_SAW_CR)) {
+		ResetFlag(statePtr, INPUT_SAW_CR);
+		if ((eol < dstEnd) && (*eol == '\n')) {
+		    /*
+		     * Skip the raw bytes that make up the '\n'.
+		     */
+
+		    char tmp[TCL_UTF_MAX];
+		    int rawRead;
+
+		    bufPtr = gs.bufPtr;
+		    Tcl_ExternalToUtf(NULL, gs.encoding, RemovePoint(bufPtr),
+			    gs.rawRead, statePtr->inputEncodingFlags
+				| TCL_ENCODING_NO_TERMINATE, &gs.state, tmp,
+			    TCL_UTF_MAX, &rawRead, NULL, NULL);
+		    bufPtr->nextRemoved += rawRead;
+		    gs.rawRead -= rawRead;
+		    gs.bytesWrote--;
+		    gs.charsWrote--;
+		    memmove(dst, dst + 1, (size_t) (dstEnd - dst));
+		    dstEnd--;
+		}
+	    }
+	    for (eol = dst; eol < dstEnd; eol++) {
+		if (*eol == '\r') {
+		    eol++;
+		    if (eol == dstEnd) {
+			/*
+			 * If buffer ended on \r, peek ahead to see if a \n is
+			 * available, unless EOF char was found already.
+			 */
+
+			if (eol != eof) {
+			    int offset;
+
+			    offset = eol - objPtr->bytes;
+			    dst = dstEnd;
+			    PeekAhead(chanPtr, &dstEnd, &gs);
+			    eol = objPtr->bytes + offset;
+			}
+
+			if (eol >= dstEnd) {
+			    eol--;
+			    SetFlag(statePtr, INPUT_SAW_CR);
+			    goto gotEOL;
+			}
+		    }
+		    if (*eol == '\n') {
+			skip++;
+		    }
+		    eol--;
+		    goto gotEOL;
+		} else if (*eol == '\n') {
+		    goto gotEOL;
+		}
+	    }
+	}
+	if (eof != NULL) {
+	    /*
+	     * EOF character was seen. On EOF, leave current file position
+	     * pointing at the EOF character, but don't store the EOF
+	     * character in the output string.
+	     */
+
+	    dstEnd = eof;
+	    SetFlag(statePtr, CHANNEL_EOF | CHANNEL_STICKY_EOF);
+	    statePtr->inputEncodingFlags |= TCL_ENCODING_END;
+	    ResetFlag(statePtr, CHANNEL_BLOCKED|INPUT_SAW_CR);
+	}
+	if (GotFlag(statePtr, CHANNEL_EOF)) {
+	    skip = 0;
+	    eol = dstEnd;
+	    if (eol == objPtr->bytes + oldLength) {
+		/*
+		 * If we didn't append any bytes before encountering EOF,
+		 * caller needs to see -1.
+		 */
+
+		Tcl_SetObjLength(objPtr, oldLength);
+		CommonGetsCleanup(chanPtr);
+		copiedTotal = -1;
+		ResetFlag(statePtr, CHANNEL_BLOCKED);
+		goto done;
+	    }
+	    goto gotEOL;
+	}
+	dst = dstEnd;
+    }
+
+    /*
+     * Found EOL or EOF, but the output buffer may now contain too many UTF-8
+     * characters. We need to know how many raw bytes correspond to the number
+     * of UTF-8 characters we want, plus how many raw bytes correspond to the
+     * character(s) making up EOL (if any), so we can remove the correct
+     * number of bytes from the channel buffer.
+     */
+
+  gotEOL:
+    /*
+     * 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;
+	TclChannelPreserve((Tcl_Channel)chanPtr);
+    }
+
+    bufPtr = gs.bufPtr;
+    if (bufPtr == NULL) {
+	Tcl_Panic("Tcl_GetsObj: gotEOL reached with bufPtr==NULL");
+    }
+    statePtr->inputEncodingState = gs.state;
+    Tcl_ExternalToUtf(NULL, gs.encoding, RemovePoint(bufPtr), gs.rawRead,
+	    statePtr->inputEncodingFlags | TCL_ENCODING_NO_TERMINATE,
+	    &statePtr->inputEncodingState, dst,
+	    eol - dst + skip + TCL_UTF_MAX - 1, &gs.rawRead, NULL,
+	    &gs.charsWrote);
+    bufPtr->nextRemoved += gs.rawRead;
+
+    /*
+     * Recycle all the emptied buffers.
+     */
+
+    Tcl_SetObjLength(objPtr, eol - objPtr->bytes);
+    CommonGetsCleanup(chanPtr);
+    ResetFlag(statePtr, CHANNEL_BLOCKED);
+    copiedTotal = gs.totalChars + gs.charsWrote - skip;
+    goto done;
+
+    /*
+     * Couldn't get a complete line. This only happens if we get a error
+     * reading from the channel or we are non-blocking and there wasn't an EOL
+     * or EOF in the data available.
+     */
+
+  restore:
+    /*
+     * 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;
+	TclChannelPreserve((Tcl_Channel)chanPtr);
+    }
+    bufPtr = statePtr->inQueueHead;
+    if (bufPtr != NULL) {
+	bufPtr->nextRemoved = oldRemoved;
+	bufPtr = bufPtr->nextPtr;
+    }
+
+    for ( ; bufPtr != NULL; bufPtr = bufPtr->nextPtr) {
+	bufPtr->nextRemoved = BUFFER_PADDING;
+    }
+    CommonGetsCleanup(chanPtr);
+
+    statePtr->inputEncodingState = oldState;
+    statePtr->inputEncodingFlags = oldFlags;
+    Tcl_SetObjLength(objPtr, oldLength);
+
+    /*
+     * We didn't get a complete line so we need to indicate to UpdateInterest
+     * that the gets blocked. It will wait for more data instead of firing a
+     * timer, avoiding a busy wait. This is where we are assuming that the
+     * next operation is a gets. No more file events will be delivered on this
+     * channel until new data arrives or some operation is performed on the
+     * channel (e.g. gets, read, fconfigure) that changes the blocking state.
+     * Note that this means a file event will not be delivered even though a
+     * read would be able to consume the buffered data.
+     */
+
+    SetFlag(statePtr, CHANNEL_NEED_MORE_DATA);
+    copiedTotal = -1;
+
+    /*
+     * Update the notifier state so we don't block while there is still data
+     * in the buffers.
+     */
+
+  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)) );
+
+    /*
+     * 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;
+	TclChannelPreserve((Tcl_Channel)chanPtr);
+    }
+    UpdateInterest(chanPtr);
+    TclChannelRelease((Tcl_Channel)chanPtr);
+    return copiedTotal;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * TclGetsObjBinary --
+ *
+ *	A variation of Tcl_GetsObj that works directly on the buffers until
+ *	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.
+ *
+ * Results:
+ *	Number of characters accumulated in the object or -1 if error,
+ *	blocked, or EOF. If -1, use Tcl_GetErrno() to retrieve the POSIX error
+ *	code for the error or condition that occurred.
+ *
+ * Side effects:
+ *	Consumes input from the channel.
+ *
+ *	On reading EOF, leave channel pointing at EOF char. On reading EOL,
+ *	leave channel pointing after EOL, but don't return EOL in dst buffer.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+static int
+TclGetsObjBinary(
+    Tcl_Channel chan,		/* Channel from which to read. */
+    Tcl_Obj *objPtr)		/* The line read will be appended to this
+				 * object as UTF-8 characters. */
+{
+    Channel *chanPtr = (Channel *) chan;
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
+    ChannelBuffer *bufPtr;
+    int inEofChar, skip, copiedTotal, oldLength, oldFlags, oldRemoved;
+    int rawLen, byteLen, eolChar;
+    unsigned char *dst, *dstEnd, *eol, *eof, *byteArray;
+
+    /*
+     * This operation should occur at the top of a channel stack.
+     */
+
+    chanPtr = statePtr->topChanPtr;
+    TclChannelPreserve((Tcl_Channel)chanPtr);
+
+    bufPtr = statePtr->inQueueHead;
+
+    /*
+     * Preserved so we can restore the channel's state in case we don't find a
+     * newline in the available input.
+     */
+
+    byteArray = Tcl_GetByteArrayFromObj(objPtr, &byteLen);
+    oldFlags = statePtr->inputEncodingFlags;
+    oldRemoved = BUFFER_PADDING;
+    oldLength = byteLen;
+    if (bufPtr != NULL) {
+	oldRemoved = bufPtr->nextRemoved;
+    }
+
+    rawLen = 0;
+    skip = 0;
+    eof = NULL;
+    inEofChar = statePtr->inEofChar;
+
+    /*
+     * Only handle TCL_TRANSLATE_LF and TCL_TRANSLATE_CR.
+     */
+
+    eolChar = (statePtr->inputTranslation == TCL_TRANSLATE_LF) ? '\n' : '\r';
+
+    ResetFlag(statePtr, CHANNEL_BLOCKED);
+    while (1) {
+	/*
+	 * Subtract the number of bytes that were removed from channel
+	 * buffer during last call.
+	 */
+
+	if (bufPtr != NULL) {
+	    bufPtr->nextRemoved += rawLen;
+	    if (!IsBufferReady(bufPtr)) {
+		bufPtr = bufPtr->nextPtr;
+	    }
+	}
+
+	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.
+	     */
+	    if (GetInput(chanPtr) != 0) {
+		goto restore;
+	    }
+	    bufPtr = statePtr->inQueueTail;
+	    if (bufPtr == NULL) {
+		goto restore;
+	    }
+	} 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 */
+
+	    assert ( !GotFlag(statePtr, CHANNEL_STICKY_EOF) );
+	    assert ( !GotFlag(statePtr, CHANNEL_EOF) );
+	}
+
+	dst = (unsigned char *) RemovePoint(bufPtr);
+	dstEnd = dst + BytesLeft(bufPtr);
+
+	/*
+	 * Remember if EOF char is seen, then look for EOL anyhow, because the
+	 * EOL might be before the EOF char.
+	 * XXX - in the binary case, consider coincident search for eol/eof.
+	 */
+
+	if (inEofChar != '\0') {
+	    for (eol = dst; eol < dstEnd; eol++) {
+		if (*eol == inEofChar) {
+		    dstEnd = eol;
+		    eof = eol;
+		    break;
+		}
+	    }
+	}
+
+	/*
+	 * On EOL, leave current file position pointing after the EOL, but
+	 * don't store the EOL in the output string.
+	 */
+
+	for (eol = dst; eol < dstEnd; eol++) {
+	    if (*eol == eolChar) {
+		skip = 1;
+		goto gotEOL;
+	    }
+	}
+	if (eof != NULL) {
+	    /*
+	     * EOF character was seen. On EOF, leave current file position
+	     * pointing at the EOF character, but don't store the EOF
+	     * character in the output string.
+	     */
+
+	    SetFlag(statePtr, CHANNEL_EOF | CHANNEL_STICKY_EOF);
+	    statePtr->inputEncodingFlags |= TCL_ENCODING_END;
+	    ResetFlag(statePtr, CHANNEL_BLOCKED|INPUT_SAW_CR);
+	}
+	if (GotFlag(statePtr, CHANNEL_EOF)) {
+	    skip = 0;
+	    eol = dstEnd;
+	    if ((dst == dstEnd) && (byteLen == oldLength)) {
+		/*
+		 * If we didn't append any bytes before encountering EOF,
+		 * caller needs to see -1.
+		 */
+
+		byteArray = Tcl_SetByteArrayLength(objPtr, oldLength);
+		CommonGetsCleanup(chanPtr);
+		copiedTotal = -1;
+		ResetFlag(statePtr, CHANNEL_BLOCKED);
+		goto done;
+	    }
+	    goto gotEOL;
+	}
+	if (GotFlag(statePtr, CHANNEL_BLOCKED|CHANNEL_NONBLOCKING)
+		== (CHANNEL_BLOCKED|CHANNEL_NONBLOCKING)) {
+	    goto restore;
+	}
+
+	/*
+	 * Copy bytes from the channel buffer to the ByteArray.
+	 * This may realloc space, so keep track of result.
+	 */
+
+	rawLen = dstEnd - dst;
+	byteArray = Tcl_SetByteArrayLength(objPtr, byteLen + rawLen);
+	memcpy(byteArray + byteLen, dst, (size_t) rawLen);
+	byteLen += rawLen;
+    }
+
+    /*
+     * Found EOL or EOF, but the output buffer may now contain too many bytes.
+     * We need to know how many bytes correspond to the number we want, so we
+     * can remove the correct number of bytes from the channel buffer.
+     */
+
+  gotEOL:
+    if (bufPtr == NULL) {
+	Tcl_Panic("TclGetsObjBinary: gotEOL reached with bufPtr==NULL");
+    }
+
+    rawLen = eol - dst;
+    byteArray = Tcl_SetByteArrayLength(objPtr, byteLen + rawLen);
+    memcpy(byteArray + byteLen, dst, (size_t) rawLen);
+    byteLen += rawLen;
+    bufPtr->nextRemoved += rawLen + skip;
+
+    /*
+     * Convert the buffer if there was an encoding.
+     * XXX - unimplemented.
+     */
+
+    if (statePtr->encoding != NULL) {
+    }
+
+    /*
+     * Recycle all the emptied buffers.
+     */
+
+    CommonGetsCleanup(chanPtr);
+    ResetFlag(statePtr, CHANNEL_BLOCKED);
+    copiedTotal = byteLen;
+    goto done;
+
+    /*
+     * Couldn't get a complete line. This only happens if we get a error
+     * reading from the channel or we are non-blocking and there wasn't an EOL
+     * or EOF in the data available.
+     */
+
+  restore:
+    bufPtr = statePtr->inQueueHead;
+    if (bufPtr) {
+	bufPtr->nextRemoved = oldRemoved;
+	bufPtr = bufPtr->nextPtr;
+    }
+
+    for ( ; bufPtr != NULL; bufPtr = bufPtr->nextPtr) {
+	bufPtr->nextRemoved = BUFFER_PADDING;
+    }
+    CommonGetsCleanup(chanPtr);
+
+    statePtr->inputEncodingFlags = oldFlags;
+    byteArray = Tcl_SetByteArrayLength(objPtr, oldLength);
+
+    /*
+     * We didn't get a complete line so we need to indicate to UpdateInterest
+     * that the gets blocked. It will wait for more data instead of firing a
+     * timer, avoiding a busy wait. This is where we are assuming that the
+     * next operation is a gets. No more file events will be delivered on this
+     * channel until new data arrives or some operation is performed on the
+     * channel (e.g. gets, read, fconfigure) that changes the blocking state.
+     * Note that this means a file event will not be delivered even though a
+     * read would be able to consume the buffered data.
+     */
+
+    SetFlag(statePtr, CHANNEL_NEED_MORE_DATA);
+    copiedTotal = -1;
+
+    /*
+     * Update the notifier state so we don't block while there is still data
+     * in the buffers.
+     */
+
+  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)) );
+    UpdateInterest(chanPtr);
+    TclChannelRelease((Tcl_Channel)chanPtr);
+    return copiedTotal;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * FreeBinaryEncoding --
+ *
+ *	Frees any "iso8859-1" Tcl_Encoding created by [gets] on a binary
+ *	channel in a thread as part of that thread's finalization.
+ *
+ * Results:
+ *	None.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+static void
+FreeBinaryEncoding(
+    ClientData dummy)	/* Not used */
+{
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    if (tsdPtr->binaryEncoding != NULL) {
+	Tcl_FreeEncoding(tsdPtr->binaryEncoding);
+	tsdPtr->binaryEncoding = NULL;
+    }
+}
+
+static Tcl_Encoding
+GetBinaryEncoding()
+{
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    if (tsdPtr->binaryEncoding == NULL) {
+	tsdPtr->binaryEncoding = Tcl_GetEncoding(NULL, "iso8859-1");
+	Tcl_CreateThreadExitHandler(FreeBinaryEncoding, NULL);
+    }
+    if (tsdPtr->binaryEncoding == NULL) {
+	Tcl_Panic("binary encoding is not available");
+    }
+    return tsdPtr->binaryEncoding;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * FilterInputBytes --
+ *
+ *	Helper function for Tcl_GetsObj. Produces UTF-8 characters from raw
+ *	bytes read from the channel.
+ *
+ *	Consumes available bytes from channel buffers. When channel buffers
+ *	are exhausted, reads more bytes from channel device into a new channel
+ *	buffer. It is the caller's responsibility to free the channel buffers
+ *	that have been exhausted.
+ *
+ * Results:
+ *	The return value is -1 if there was an error reading from the channel,
+ *	0 otherwise.
+ *
+ * Side effects:
+ *	Status object keeps track of how much data from channel buffers has
+ *	been consumed and where UTF-8 bytes should be stored.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+static int
+FilterInputBytes(
+    Channel *chanPtr,		/* Channel to read. */
+    GetsState *gsPtr)		/* Current state of gets operation. */
+{
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
+    ChannelBuffer *bufPtr;
+    char *raw, *dst;
+    int offset, toRead, dstNeeded, spaceLeft, result, rawLen;
+    Tcl_Obj *objPtr;
+#define ENCODING_LINESIZE 20	/* Lower bound on how many bytes to convert at
+				 * a time. Since we don't know a priori how
+				 * many bytes of storage this many source
+				 * bytes will use, we actually need at least
+				 * ENCODING_LINESIZE * TCL_MAX_UTF bytes of
+				 * room. */
+
+    objPtr = gsPtr->objPtr;
+
+    /*
+     * Subtract the number of bytes that were removed from channel buffer
+     * during last call.
+     */
+
+    bufPtr = gsPtr->bufPtr;
+    if (bufPtr != NULL) {
+	bufPtr->nextRemoved += gsPtr->rawRead;
+	if (!IsBufferReady(bufPtr)) {
+	    bufPtr = bufPtr->nextPtr;
+	}
+    }
+    gsPtr->totalChars += gsPtr->charsWrote;
+
+    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.
+	 */
+
+    read:
+	if (GotFlag(statePtr, CHANNEL_NONBLOCKING|CHANNEL_BLOCKED)
+		== (CHANNEL_NONBLOCKING|CHANNEL_BLOCKED)) {
+	    gsPtr->charsWrote = 0;
+	    gsPtr->rawRead = 0;
+	    return -1;
+	}
+	if (GetInput(chanPtr) != 0) {
+	    gsPtr->charsWrote = 0;
+	    gsPtr->rawRead = 0;
+	    return -1;
+	}
+	bufPtr = statePtr->inQueueTail;
+	gsPtr->bufPtr = bufPtr;
+	if (bufPtr == NULL) {
+	    gsPtr->charsWrote = 0;
+	    gsPtr->rawRead = 0;
+	    return -1;
+	}
+    } 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 */
+
+	assert ( !GotFlag(statePtr, CHANNEL_STICKY_EOF) );
+	assert ( !GotFlag(statePtr, CHANNEL_EOF) );
+    }
+
+    /*
+     * Convert some of the bytes from the channel buffer to UTF-8. Space in
+     * objPtr's string rep is used to hold the UTF-8 characters. Grow the
+     * string rep if we need more space.
+     */
+
+    raw = RemovePoint(bufPtr);
+    rawLen = BytesLeft(bufPtr);
+
+    dst = *gsPtr->dstPtr;
+    offset = dst - objPtr->bytes;
+    toRead = ENCODING_LINESIZE;
+    if (toRead > rawLen) {
+	toRead = rawLen;
+    }
+    dstNeeded = toRead * TCL_UTF_MAX;
+    spaceLeft = objPtr->length - offset;
+    if (dstNeeded > spaceLeft) {
+	int length = offset + ((offset < dstNeeded) ? dstNeeded : offset);
+
+	if (Tcl_AttemptSetObjLength(objPtr, length) == 0) {
+	    length = offset + dstNeeded;
+	    if (Tcl_AttemptSetObjLength(objPtr, length) == 0) {
+		dstNeeded = TCL_UTF_MAX - 1 + toRead;
+		length = offset + dstNeeded;
+		Tcl_SetObjLength(objPtr, length);
+	    }
+	}
+	spaceLeft = length - offset;
+	dst = objPtr->bytes + offset;
+	*gsPtr->dstPtr = dst;
+    }
+    gsPtr->state = statePtr->inputEncodingState;
+    result = Tcl_ExternalToUtf(NULL, gsPtr->encoding, raw, rawLen,
+	    statePtr->inputEncodingFlags | TCL_ENCODING_NO_TERMINATE,
+	    &statePtr->inputEncodingState, dst, spaceLeft, &gsPtr->rawRead,
+	    &gsPtr->bytesWrote, &gsPtr->charsWrote);
+
+    /*
+     * Make sure that if we go through 'gets', that we reset the
+     * TCL_ENCODING_START flag still. [Bug #523988]
+     */
+
+    statePtr->inputEncodingFlags &= ~TCL_ENCODING_START;
+
+    if (result == TCL_CONVERT_MULTIBYTE) {
+	/*
+	 * The last few bytes in this channel buffer were the start of a
+	 * multibyte sequence. If this buffer was full, then move them to the
+	 * next buffer so the bytes will be contiguous.
+	 */
+
+	ChannelBuffer *nextPtr;
+	int extra;
+
+	nextPtr = bufPtr->nextPtr;
+	if (!IsBufferFull(bufPtr)) {
+	    if (gsPtr->rawRead > 0) {
+		/*
+		 * Some raw bytes were converted to UTF-8. Fall through,
+		 * returning those UTF-8 characters because a EOL might be
+		 * present in them.
+		 */
+	    } else if (GotFlag(statePtr, CHANNEL_EOF)) {
+		/*
+		 * There was a partial character followed by EOF on the
+		 * device. Fall through, returning that nothing was found.
+		 */
+
+		bufPtr->nextRemoved = bufPtr->nextAdded;
+	    } else {
+		/*
+		 * There are no more cached raw bytes left. See if we can get
+		 * some more, but avoid blocking on a non-blocking channel.
+		 */
+
+		goto read;
+	    }
+	} else {
+	    if (nextPtr == NULL) {
+		nextPtr = AllocChannelBuffer(statePtr->bufSize);
+		bufPtr->nextPtr = nextPtr;
+		statePtr->inQueueTail = nextPtr;
+	    }
+	    extra = rawLen - gsPtr->rawRead;
+	    memcpy(nextPtr->buf + (BUFFER_PADDING - extra),
+		    raw + gsPtr->rawRead, (size_t) extra);
+	    nextPtr->nextRemoved -= extra;
+	    bufPtr->nextAdded -= extra;
+	}
+    }
+
+    gsPtr->bufPtr = bufPtr;
+    return 0;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * PeekAhead --
+ *
+ *	Helper function used by Tcl_GetsObj(). Called when we've seen a \r at
+ *	the end of the UTF-8 string and want to look ahead one character to
+ *	see if it is a \n.
+ *
+ * Results:
+ *	*gsPtr->dstPtr is filled with a pointer to the start of the range of
+ *	UTF-8 characters that were found by peeking and *dstEndPtr is filled
+ *	with a pointer to the bytes just after the end of the range.
+ *
+ * Side effects:
+ *	If no more raw bytes were available in one of the channel buffers,
+ *	tries to perform a non-blocking read to get more bytes from the
+ *	channel device.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+static void
+PeekAhead(
+    Channel *chanPtr,		/* The channel to read. */
+    char **dstEndPtr,		/* Filled with pointer to end of new range of
+				 * UTF-8 characters. */
+    GetsState *gsPtr)		/* Current state of gets operation. */
+{
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
+    ChannelBuffer *bufPtr;
+    Tcl_DriverBlockModeProc *blockModeProc;
+    int bytesLeft;
+
+    bufPtr = gsPtr->bufPtr;
+
+    /*
+     * If there's any more raw input that's still buffered, we'll peek into
+     * that. Otherwise, only get more data from the channel driver if it looks
+     * like there might actually be more data. The assumption is that if the
+     * channel buffer is filled right up to the end, then there might be more
+     * data to read.
+     */
+
+    blockModeProc = NULL;
+    if (bufPtr->nextPtr == NULL) {
+	bytesLeft = BytesLeft(bufPtr) - gsPtr->rawRead;
+	if (bytesLeft == 0) {
+	    if (!IsBufferFull(bufPtr)) {
+		/*
+		 * Don't peek ahead if last read was short read.
+		 */
+
+		goto cleanup;
+	    }
+	    if (!GotFlag(statePtr, CHANNEL_NONBLOCKING)) {
+		blockModeProc = Tcl_ChannelBlockModeProc(chanPtr->typePtr);
+		if (blockModeProc == NULL) {
+		    /*
+		     * Don't peek ahead if cannot set non-blocking mode.
+		     */
+
+		    goto cleanup;
+		}
+		StackSetBlockMode(chanPtr, TCL_MODE_NONBLOCKING);
+	    }
+	}
+    }
+    if (FilterInputBytes(chanPtr, gsPtr) == 0) {
+	*dstEndPtr = *gsPtr->dstPtr + gsPtr->bytesWrote;
+    }
+    if (blockModeProc != NULL) {
+	StackSetBlockMode(chanPtr, TCL_MODE_BLOCKING);
+    }
+    return;
+
+  cleanup:
+    bufPtr->nextRemoved += gsPtr->rawRead;
+    gsPtr->rawRead = 0;
+    gsPtr->totalChars += gsPtr->charsWrote;
+    gsPtr->bytesWrote = 0;
+    gsPtr->charsWrote = 0;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * CommonGetsCleanup --
+ *
+ *	Helper function for Tcl_GetsObj() to restore the channel after a
+ *	"gets" operation.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Encoding may be freed.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+static void
+CommonGetsCleanup(
+    Channel *chanPtr)
+{
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
+    ChannelBuffer *bufPtr, *nextPtr;
+
+    bufPtr = statePtr->inQueueHead;
+    for ( ; bufPtr != NULL; bufPtr = nextPtr) {
+	nextPtr = bufPtr->nextPtr;
+	if (IsBufferReady(bufPtr)) {
+	    break;
+	}
+	RecycleBuffer(statePtr, bufPtr, 0);
+    }
+    statePtr->inQueueHead = bufPtr;
+    if (bufPtr == NULL) {
+	statePtr->inQueueTail = NULL;
+    } else {
+	/*
+	 * If any multi-byte characters were split across channel buffer
+	 * boundaries, the split-up bytes were moved to the next channel
+	 * buffer by FilterInputBytes(). Move the bytes back to their original
+	 * buffer because the caller could change the channel's encoding which
+	 * could change the interpretation of whether those bytes really made
+	 * up multi-byte characters after all.
+	 */
+
+	nextPtr = bufPtr->nextPtr;
+	for ( ; nextPtr != NULL; nextPtr = bufPtr->nextPtr) {
+	    int extra;
+
+	    extra = SpaceLeft(bufPtr);
+	    if (extra > 0) {
+		memcpy(InsertPoint(bufPtr),
+			nextPtr->buf + (BUFFER_PADDING - extra),
+			(size_t) extra);
+		bufPtr->nextAdded += extra;
+		nextPtr->nextRemoved = BUFFER_PADDING;
+	    }
+	    bufPtr = nextPtr;
+	}
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_Read --
+ *
+ *	Reads a given number of bytes from a channel. EOL and EOF translation
+ *	is done on the bytes being read, so the number of bytes consumed from
+ *	the channel may not be equal to the number of bytes stored in the
+ *	destination buffer.
+ *
+ *	No encoding conversions are applied to the bytes being read.
+ *
+ * Results:
+ *	The number of bytes read, or -1 on error. Use Tcl_GetErrno() to
+ *	retrieve the error code for the error that occurred.
+ *
+ * Side effects:
+ *	May cause input to be buffered.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_Read(
+    Tcl_Channel chan,		/* The channel from which to read. */
+    char *dst,			/* Where to store input read. */
+    int bytesToRead)		/* Maximum number of bytes to read. */
+{
+    Channel *chanPtr = (Channel *) chan;
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
+
+    /*
+     * This operation should occur at the top of a channel stack.
+     */
+
+    chanPtr = statePtr->topChanPtr;
+
+    if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) {
+	return -1;
+    }
+
+    return DoRead(chanPtr, dst, bytesToRead, 0);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ReadRaw --
+ *
+ *	Reads a given number of bytes from a channel. EOL and EOF translation
+ *	is done on the bytes being read, so the number of bytes consumed from
+ *	the channel may not be equal to the number of bytes stored in the
+ *	destination buffer.
+ *
+ *	No encoding conversions are applied to the bytes being read.
+ *
+ * Results:
+ *	The number of bytes read, or -1 on error. Use Tcl_GetErrno() to
+ *	retrieve the error code for the error that occurred.
+ *
+ * Side effects:
+ *	May cause input to be buffered.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_ReadRaw(
+    Tcl_Channel chan,		/* The channel from which to read. */
+    char *readBuf,		/* Where to store input read. */
+    int bytesToRead)		/* Maximum number of bytes to read. */
+{
+    Channel *chanPtr = (Channel *) chan;
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
+    int copied = 0;
+
+    assert(bytesToRead > 0);
+    if (CheckChannelErrors(statePtr, TCL_READABLE | CHANNEL_RAW_MODE) != 0) {
+	return -1;
+    }
+
+    /* First read bytes from the push-back buffers. */
+
+    while (chanPtr->inQueueHead && bytesToRead > 0) {
+	ChannelBuffer *bufPtr = chanPtr->inQueueHead;
+	int bytesInBuffer = BytesLeft(bufPtr);
+	int toCopy = (bytesInBuffer < bytesToRead) ? bytesInBuffer
+		: bytesToRead;
+
+	/* Copy the current chunk into the read buffer. */
+
+	memcpy(readBuf, RemovePoint(bufPtr), (size_t) toCopy);
+	bufPtr->nextRemoved += toCopy;
+	copied += toCopy;
+	readBuf += toCopy;
+	bytesToRead -= toCopy;
+
+	/* If the current buffer is empty recycle it. */
+
+	if (IsBufferEmpty(bufPtr)) {
+	    chanPtr->inQueueHead = bufPtr->nextPtr;
+	    if (chanPtr->inQueueHead == NULL) {
+		chanPtr->inQueueTail = NULL;
+	    }
+	    RecycleBuffer(chanPtr->state, bufPtr, 0);
+	}
+    }
+
+    /*
+     * 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) {
+
+	int nread = ChanRead(chanPtr, readBuf, bytesToRead);
+
+	if (nread > 0) {
+	    /* 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.
+	     */
+	    if (!GotFlag(statePtr, CHANNEL_BLOCKED) || copied == 0) {
+		copied = -1;
+	    }
+	} else {
+	    /*
+	     * nread == 0.  Driver is at EOF. Let that state filter up.
+	     */
+	}
+    }
+    return copied;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * Tcl_ReadChars --
+ *
+ *	Reads from the channel until the requested number of characters have
+ *	been seen, EOF is seen, or the channel would block. EOL and EOF
+ *	translation is done. If reading binary data, the raw bytes are wrapped
+ *	in a Tcl byte array object. Otherwise, the raw bytes are converted to
+ *	UTF-8 using the channel's current encoding and stored in a Tcl string
+ *	object.
+ *
+ * Results:
+ *	The number of characters read, or -1 on error. Use Tcl_GetErrno() to
+ *	retrieve the error code for the error that occurred.
+ *
+ * Side effects:
+ *	May cause input to be buffered.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+int
+Tcl_ReadChars(
+    Tcl_Channel chan,		/* The channel to read. */
+    Tcl_Obj *objPtr,		/* Input data is stored in this object. */
+    int toRead,			/* Maximum number of characters to store, or
+				 * -1 to read all available data (up to EOF or
+				 * when channel blocks). */
+    int appendFlag)		/* If non-zero, data read from the channel
+				 * will be appended to the object. Otherwise,
+				 * the data will replace the existing contents
+				 * of the object. */
+{
+    Channel *chanPtr = (Channel *) chan;
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
+
+    /*
+     * This operation should occur at the top of a channel stack.
+     */
+
+    chanPtr = statePtr->topChanPtr;
+
+    if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) {
+	/*
+	 * Update the notifier state so we don't block while there is still
+	 * data in the buffers.
+	 */
+
+	UpdateInterest(chanPtr);
+	return -1;
+    }
+
+    return DoReadChars(chanPtr, objPtr, toRead, appendFlag);
+}
+/*
+ *---------------------------------------------------------------------------
+ *
+ * DoReadChars --
+ *
+ *	Reads from the channel until the requested number of characters have
+ *	been seen, EOF is seen, or the channel would block. EOL and EOF
+ *	translation is done. If reading binary data, the raw bytes are wrapped
+ *	in a Tcl byte array object. Otherwise, the raw bytes are converted to
+ *	UTF-8 using the channel's current encoding and stored in a Tcl string
+ *	object.
+ *
+ * Results:
+ *	The number of characters read, or -1 on error. Use Tcl_GetErrno() to
+ *	retrieve the error code for the error that occurred.
+ *
+ * Side effects:
+ *	May cause input to be buffered.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+static int
+DoReadChars(
+    Channel *chanPtr,		/* The channel to read. */
+    Tcl_Obj *objPtr,		/* Input data is stored in this object. */
+    int toRead,			/* Maximum number of characters to store, or
+				 * -1 to read all available data (up to EOF or
+				 * when channel blocks). */
+    int appendFlag)		/* If non-zero, data read from the channel
+				 * will be appended to the object. Otherwise,
+				 * the data will replace the existing contents
+				 * of the object. */
+{
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
+    ChannelBuffer *bufPtr;
+    int copied, copiedNow, result;
+    Tcl_Encoding encoding = statePtr->encoding;
+    int binaryMode;
+#define UTF_EXPANSION_FACTOR	1024
+    int factor = UTF_EXPANSION_FACTOR;
+
+    binaryMode = (encoding == NULL)
+	    && (statePtr->inputTranslation == TCL_TRANSLATE_LF)
+	    && (statePtr->inEofChar == '\0');
+
+    if (appendFlag == 0) {
+	if (binaryMode) {
+	    Tcl_SetByteArrayLength(objPtr, 0);
+	} else {
+	    Tcl_SetObjLength(objPtr, 0);
+
+	    /*
+	     * We're going to access objPtr->bytes directly, so we must ensure
+	     * that this is actually a string object (otherwise it might have
+	     * been pure Unicode).
+	     *
+	     * Probably not needed anymore.
+	     */
+
+	    TclGetString(objPtr);
+	}
+    }
+
+    /*
+     * 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.
+     */
+
+    if (GotFlag(statePtr, CHANNEL_STICKY_EOF)) {
+	SetFlag(statePtr, CHANNEL_EOF);
+	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. */
+    if (toRead == 0) {
+	if (GotFlag(statePtr, CHANNEL_EOF)) {
+	    statePtr->inputEncodingFlags |= TCL_ENCODING_START;
+	}
+	ResetFlag(statePtr, CHANNEL_BLOCKED|CHANNEL_EOF);
+	statePtr->inputEncodingFlags &= ~TCL_ENCODING_END;
+	/* TODO: We don't need this call? */
+	UpdateInterest(chanPtr);
+	return 0;
+    }
+
+    /*
+     * This operation should occur at the top of a channel stack.
+     */
+
+    chanPtr = statePtr->topChanPtr;
+    TclChannelPreserve((Tcl_Channel)chanPtr);
+
+    /* Must clear the BLOCKED|EOF flags here since we check before reading */
+    if (GotFlag(statePtr, CHANNEL_EOF)) {
+	statePtr->inputEncodingFlags |= TCL_ENCODING_START;
+    }
+    ResetFlag(statePtr, CHANNEL_BLOCKED|CHANNEL_EOF);
+    statePtr->inputEncodingFlags &= ~TCL_ENCODING_END;
+    for (copied = 0; (unsigned) toRead > 0; ) {
+	copiedNow = -1;
+	if (statePtr->inQueueHead != NULL) {
+	    if (binaryMode) {
+		copiedNow = ReadBytes(statePtr, objPtr, toRead);
+	    } else {
+		copiedNow = ReadChars(statePtr, objPtr, toRead, &factor);
+	    }
+
+	    /*
+	     * If the current buffer is empty recycle it.
+	     */
+
+	    bufPtr = statePtr->inQueueHead;
+	    if (IsBufferEmpty(bufPtr)) {
+		ChannelBuffer *nextPtr = bufPtr->nextPtr;
+
+		RecycleBuffer(statePtr, bufPtr, 0);
+		statePtr->inQueueHead = nextPtr;
+		if (nextPtr == NULL) {
+		    statePtr->inQueueTail = NULL;
+		}
+	    }
+	}
+
+	if (copiedNow < 0) {
+	    if (GotFlag(statePtr, CHANNEL_EOF)) {
+		break;
+	    }
+	    if (GotFlag(statePtr, CHANNEL_NONBLOCKING|CHANNEL_BLOCKED)
+		    == (CHANNEL_NONBLOCKING|CHANNEL_BLOCKED)) {
+		break;
+	    }
+	    result = GetInput(chanPtr);
+	    if (chanPtr != statePtr->topChanPtr) {
+		TclChannelRelease((Tcl_Channel)chanPtr);
+		chanPtr = statePtr->topChanPtr;
+		TclChannelPreserve((Tcl_Channel)chanPtr);
+	    }
+	    if (result != 0) {
+		if (!GotFlag(statePtr, CHANNEL_BLOCKED)) {
+		    copied = -1;
+		}
+		break;
+	    }
+	} else {
+	    copied += copiedNow;
+	    toRead -= copiedNow;
+	}
+    }
+
+    /*
+     * 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);
+    }
+
+    /*
+     * 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;
+	TclChannelPreserve((Tcl_Channel)chanPtr);
+    }
+
+    /*
+     * 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)) );
+    UpdateInterest(chanPtr);
+    TclChannelRelease((Tcl_Channel)chanPtr);
+    return copied;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * ReadBytes --
+ *
+ *	Reads from the channel until the requested number of bytes have been
+ *	seen, EOF is seen, or the channel would block. Bytes from the channel
+ *	are stored in objPtr as a ByteArray object. EOL and EOF translation
+ *	are done.
+ *
+ *	'bytesToRead' can safely be a very large number because space is only
+ *	allocated to hold data read from the channel as needed.
+ *
+ * Results:
+ *	The return value is the number of bytes appended to the object, or
+ *	-1 to indicate that zero bytes were read due to an EOF.
+ *
+ * Side effects:
+ *	The storage of bytes in objPtr can cause (re-)allocation of memory.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+static int
+ReadBytes(
+    ChannelState *statePtr,	/* State of the channel to read. */
+    Tcl_Obj *objPtr,		/* Input data is appended to this ByteArray
+				 * object. Its length is how much space has
+				 * been allocated to hold data, not how many
+				 * bytes of data have been stored in the
+				 * object. */
+    int bytesToRead)		/* Maximum number of bytes to store, or < 0 to
+				 * get all available bytes. Bytes are obtained
+				 * from the first buffer in the queue - even
+				 * if this number is larger than the number of
+				 * bytes available in the first buffer, only
+				 * the bytes from the first buffer are
+				 * returned. */
+{
+    ChannelBuffer *bufPtr = statePtr->inQueueHead;
+    int srcLen = BytesLeft(bufPtr);
+    int toRead = bytesToRead>srcLen || bytesToRead<0 ? srcLen : bytesToRead;
+
+    TclAppendBytesToByteArray(objPtr, (unsigned char *) RemovePoint(bufPtr),
+	    toRead);
+    bufPtr->nextRemoved += toRead;
+    return toRead;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * ReadChars --
+ *
+ *	Reads from the channel until the requested number of UTF-8 characters
+ *	have been seen, EOF is seen, or the channel would block. Raw bytes
+ *	from the channel are converted to UTF-8 and stored in objPtr. EOL and
+ *	EOF translation is done.
+ *
+ *	'charsToRead' can safely be a very large number because space is only
+ *	allocated to hold data read from the channel as needed.
+ *
+ *	'charsToRead' may *not* be 0.
+ *
+ * Results:
+ *	The return value is the number of characters appended to the object,
+ *	*offsetPtr is filled with the number of bytes that were appended, and
+ *	*factorPtr is filled with the expansion factor used to guess how many
+ *	bytes of UTF-8 to allocate to hold N source bytes.
+ *
+ * Side effects:
+ *	None.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+static int
+ReadChars(
+    ChannelState *statePtr,	/* State of channel to read. */
+    Tcl_Obj *objPtr,		/* Input data is appended to this object.
+				 * objPtr->length is how much space has been
+				 * allocated to hold data, not how many bytes
+				 * of data have been stored in the object. */
+    int charsToRead,		/* Maximum number of characters to store, or
+				 * -1 to get all available characters.
+				 * Characters are obtained from the first
+				 * buffer in the queue -- even if this number
+				 * is larger than the number of characters
+				 * available in the first buffer, only the
+				 * characters from the first buffer are
+				 * returned. The execption is when there is
+				 * not any complete character in the first
+				 * buffer.  In that case, a recursive call
+				 * effectively obtains chars from the
+				 * second buffer. */
+    int *factorPtr)		/* On input, contains a guess of how many
+				 * bytes need to be allocated to hold the
+				 * result of converting N source bytes to
+				 * UTF-8. On output, contains another guess
+				 * based on the data seen so far. */
+{
+    Tcl_Encoding encoding = statePtr->encoding? statePtr->encoding
+	    : GetBinaryEncoding();
+    Tcl_EncodingState savedState = statePtr->inputEncodingState;
+    ChannelBuffer *bufPtr = statePtr->inQueueHead;
+    int savedIEFlags = statePtr->inputEncodingFlags;
+    int savedFlags = statePtr->flags;
+    char *dst, *src = RemovePoint(bufPtr);
+    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.
+     */
+
+    int toRead = ((charsToRead<0)||(charsToRead > srcLen)) ? srcLen : charsToRead;
+
+    /*
+     * 'factor' is how much we guess that the bytes in the source buffer will
+     * expand when converted to UTF-8 chars. This guess comes from analyzing
+     * how many characters were produced by the previous pass.
+     */
+
+    int factor = *factorPtr;
+    int dstLimit = TCL_UTF_MAX - 1 + toRead * factor / UTF_EXPANSION_FACTOR;
+
+    (void) TclGetStringFromObj(objPtr, &numBytes);
+    Tcl_AppendToObj(objPtr, NULL, dstLimit);
+    if (toRead == srcLen) {
+	unsigned int size;
+	dst = TclGetStringStorage(objPtr, &size) + numBytes;
+	dstLimit = size - numBytes;
+    } else {
+	dst = TclGetString(objPtr) + numBytes;
+    }
+
+    /*
+     * 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.
+     */
+
+    while (1) {
+	int dstDecoded, dstRead, dstWrote, srcRead, numChars, code;
+	int flags = statePtr->inputEncodingFlags | TCL_ENCODING_NO_TERMINATE;
+
+	if (charsToRead > 0) {
+	    flags |= TCL_ENCODING_CHAR_LIMIT;
+	    numChars = charsToRead;
+	}
+
+	/*
+	 * 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.
+	 */
+
+	assert(bufPtr->nextPtr == NULL || BytesLeft(bufPtr->nextPtr) == 0
+		|| (statePtr->inputEncodingFlags & TCL_ENCODING_END) == 0);
+
+	code = Tcl_ExternalToUtf(NULL, encoding, src, srcLen,
+		flags, &statePtr->inputEncodingState,
+		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.
+	 */
+
+	dstWrote = dstLimit;
+	dstRead = dstDecoded;
+	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?
+	     */
+
+	    if (statePtr->inEofChar && dst[dstRead] == statePtr->inEofChar) {
+		/*
+		 * 1) There's an eof char set on the channel, and
+		 *    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.
+		 *
+		 * 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.
+		     */
+		    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.
+		     */
+
+		    dstLimit = dstRead - 1 + TCL_UTF_MAX;
+		    statePtr->flags = savedFlags;
+		    statePtr->inputEncodingFlags = savedIEFlags;
+		    statePtr->inputEncodingState = savedState;
+		    continue;
+		}
+	    }
+
+	    /*
+	     * 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');
+	    assert(statePtr->inputTranslation == TCL_TRANSLATE_CRLF);
+
+	    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.
+		 */
+
+		dstLimit = dstRead - 1 + TCL_UTF_MAX;
+		statePtr->flags = savedFlags;
+		statePtr->inputEncodingFlags = savedIEFlags;
+		statePtr->inputEncodingState = savedState;
+		continue;
+	    }
+
+	    assert(dstWrote == 0);
+	    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?
+	     */
+
+	    if (code != TCL_OK) {
+		char buffer[TCL_UTF_MAX + 1];
+		int read, decoded, count;
+
+		/*
+		 * Didn't get everything the buffer could offer
+		 */
+
+		statePtr->flags = savedFlags;
+		statePtr->inputEncodingFlags = savedIEFlags;
+		statePtr->inputEncodingState = savedState;
+
+		assert(bufPtr->nextPtr == NULL
+			|| BytesLeft(bufPtr->nextPtr) == 0 || 0 ==
+			(statePtr->inputEncodingFlags & TCL_ENCODING_END));
+
+		Tcl_ExternalToUtf(NULL, encoding, src, srcLen,
+		(statePtr->inputEncodingFlags | TCL_ENCODING_NO_TERMINATE),
+		&statePtr->inputEncodingState, buffer, TCL_UTF_MAX + 1,
+		&read, &decoded, &count);
+
+		if (count == 2) {
+		    if (buffer[1] == '\n') {
+			/* \r\n translate to \n */
+			dst[0] = '\n';
+			bufPtr->nextRemoved += read;
+		    } else {
+			dst[0] = '\r';
+			bufPtr->nextRemoved += srcRead;
+		    }
+
+		    statePtr->inputEncodingFlags &= ~TCL_ENCODING_START;
+
+		    Tcl_SetObjLength(objPtr, numBytes + 1);
+		    return 1;
+		}
+
+	    } 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.
+		 */
+
+		dst[0] = '\r';
+		bufPtr->nextRemoved = bufPtr->nextAdded;
+		Tcl_SetObjLength(objPtr, numBytes + 1);
+		return 1;
+	    }
+
+	    /*
+	     * Revise the dstRead value so that the numChars calc
+	     * below correctly computes zero characters read.
+	     */
+
+	    dstRead = numChars;
+
+	    /* FALL THROUGH - get more data (dstWrote == 0) */
+	}
+
+	/*
+	 * 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);
+
+	if (charsToRead > 0 && numChars > charsToRead) {
+
+	    /*
+	     * 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!
+	     */
+
+	    dstLimit = Tcl_UtfAtIndex(dst, charsToRead) - 1 + TCL_UTF_MAX - dst;
+	    statePtr->flags = savedFlags;
+	    statePtr->inputEncodingFlags = savedIEFlags;
+	    statePtr->inputEncodingState = savedState;
+	    continue;
+	}
+
+	if (dstWrote == 0) {
+	    ChannelBuffer *nextPtr;
+
+	    /* We were not able to read any chars. */
+
+	    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.
+	     */
+
+	    if (dstRead == 1 && dst[0] == '\n') {
+		assert(statePtr->inputTranslation == TCL_TRANSLATE_AUTO);
+
+		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.
+	     */
+
+	    nextPtr = bufPtr->nextPtr;
+
+	    if (nextPtr == NULL) {
+		if (srcLen > 0) {
+		    SetFlag(statePtr, CHANNEL_NEED_MORE_DATA);
+		}
+		Tcl_SetObjLength(objPtr, numBytes);
+		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'.
+	     *
+	     * 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");
+	    }
+
+	    nextPtr->nextRemoved -= srcLen;
+	    memcpy(RemovePoint(nextPtr), src, (size_t) srcLen);
+	    RecycleBuffer(statePtr, bufPtr, 0);
+	    statePtr->inQueueHead = nextPtr;
+	    Tcl_SetObjLength(objPtr, numBytes);
+	    return ReadChars(statePtr, objPtr, charsToRead, factorPtr);
+	}
+
+	statePtr->inputEncodingFlags &= ~TCL_ENCODING_START;
+
+    consume:
+	bufPtr->nextRemoved += srcRead;
+	/*
+	 * 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;
+	}
+	Tcl_SetObjLength(objPtr, numBytes + dstWrote);
+	return numChars;
+    }
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * TranslateInputEOL --
+ *
+ *	Perform input EOL and EOF translation on the source buffer, leaving
+ *	the translated result in the destination buffer.
+ *
+ * Results:
+ *	The return value is 1 if the EOF character was found when copying
+ *	bytes to the destination buffer, 0 otherwise.
+ *
+ * Side effects:
+ *	None.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+static void
+TranslateInputEOL(
+    ChannelState *statePtr,	/* Channel being read, for EOL translation and
+				 * EOF character. */
+    char *dstStart,		/* Output buffer filled with chars by applying
+				 * appropriate EOL translation to source
+				 * characters. */
+    const char *srcStart,	/* Source characters. */
+    int *dstLenPtr,		/* On entry, the maximum length of output
+				 * buffer in bytes. On exit, the number of
+				 * bytes actually used in output buffer. */
+    int *srcLenPtr)		/* On entry, the length of source buffer. On
+				 * exit, the number of bytes read from the
+				 * source buffer. */
+{
+    const char *eof = NULL;
+    int dstLen = *dstLenPtr;
+    int srcLen = *srcLenPtr;
+    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.
+     */
+
+    switch (statePtr->inputTranslation) {
+    case TCL_TRANSLATE_LF:
+    case TCL_TRANSLATE_CR:
+	if (srcLen > dstLen) {
+	/* 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) {
+	    srcLen = 2 * dstLen;
+	}
+	break;
+    }
+
+    if (inEofChar != '\0') {
+	/*
+	 * Make sure we do not read past any logical end of channel input
+	 * created by the presence of the input eof char.
+	 */
+
+	if ((eof = memchr(srcStart, inEofChar, srcLen))) {
+	    srcLen = eof - srcStart;
+	}
+    }
+
+    switch (statePtr->inputTranslation) {
+    case TCL_TRANSLATE_LF:
+    case TCL_TRANSLATE_CR:
+	if (dstStart != srcStart) {
+	    memcpy(dstStart, srcStart, (size_t) srcLen);
+	}
+	if (statePtr->inputTranslation == TCL_TRANSLATE_CR) {
+	    char *dst = dstStart;
+	    char *dstEnd = dstStart + srcLen;
+
+	    while ((dst = memchr(dst, '\r', dstEnd - dst))) {
+		*dst++ = '\n';
+	    }
+	}
+	dstLen = srcLen;
+	break;
+    case TCL_TRANSLATE_CRLF: {
+	const char *crFound, *src = srcStart;
+	char *dst = dstStart;
+	int lesser = (dstLen < srcLen) ? dstLen : srcLen;
+
+	while ((crFound = memchr(src, '\r', lesser))) {
+	    int numBytes = crFound - src;
+	    memmove(dst, src, numBytes);
+
+	    dst += numBytes; dstLen -= numBytes;
+	    src += numBytes; srcLen -= numBytes;
+	    if (srcLen == 1) {
+		/* valid src bytes end in \r */
+		if (eof) {
+		    *dst++ = '\r';
+		    src++; srcLen--;
+		} else {
+		    lesser = 0;
+		    break;
+		}
+	    } else if (src[1] == '\n') {
+		*dst++ = '\n';
+		src += 2; srcLen -= 2;
+	    } else {
+		*dst++ = '\r';
+		src++; srcLen--;
+	    }
+	    dstLen--;
+	    lesser = (dstLen < srcLen) ? dstLen : srcLen;
+	}
+	memmove(dst, src, lesser);
+	srcLen = src + lesser - srcStart;
+	dstLen = dst + lesser - dstStart;
+	break;
+    }
+    case TCL_TRANSLATE_AUTO: {
+	const char *crFound, *src = srcStart;
+	char *dst = dstStart;
+	int lesser;
+
+	if ((statePtr->flags & INPUT_SAW_CR) && srcLen) {
+	    if (*src == '\n') { src++; srcLen--; }
+	    ResetFlag(statePtr, INPUT_SAW_CR);
+	}
+	lesser = (dstLen < srcLen) ? dstLen : srcLen;
+	while ((crFound = memchr(src, '\r', lesser))) {
+	    int numBytes = crFound - src;
+	    memmove(dst, src, numBytes);
+
+	    dst[numBytes] = '\n';
+	    dst += numBytes + 1; dstLen -= numBytes + 1;
+	    src += numBytes + 1; srcLen -= numBytes + 1;
+	    if (srcLen == 0) {
+		SetFlag(statePtr, INPUT_SAW_CR);
+	    } else if (*src == '\n') {
+		src++; srcLen--;
+	    }
+	    lesser = (dstLen < srcLen) ? dstLen : srcLen;
+	}
+	memmove(dst, src, lesser);
+	srcLen = src + lesser - srcStart;
+	dstLen = dst + lesser - dstStart;
+	break;
+    }
+    default:
+	Tcl_Panic("unknown input translation %d", statePtr->inputTranslation);
+    }
+    *dstLenPtr = dstLen;
+    *srcLenPtr = srcLen;
+
+    if (srcStart + srcLen == eof) {
+	/*
+	 * EOF character was seen in EOL translated range. Leave current file
+	 * position pointing at the EOF character, but don't store the EOF
+	 * character in the output string.
+	 */
+
+	SetFlag(statePtr, CHANNEL_EOF | CHANNEL_STICKY_EOF);
+	statePtr->inputEncodingFlags |= TCL_ENCODING_END;
+	ResetFlag(statePtr, CHANNEL_BLOCKED|INPUT_SAW_CR);
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_Ungets --
+ *
+ *	Causes the supplied string to be added to the input queue of the
+ *	channel, at either the head or tail of the queue.
+ *
+ * Results:
+ *	The number of bytes stored in the channel, or -1 on error.
+ *
+ * Side effects:
+ *	Adds input to the input queue of a channel.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_Ungets(
+    Tcl_Channel chan,		/* The channel for which to add the input. */
+    const char *str,		/* The input itself. */
+    int len,			/* The length of the input. */
+    int atEnd)			/* If non-zero, add at end of queue; otherwise
+				 * add at head of queue. */
+{
+    Channel *chanPtr;		/* The real IO channel. */
+    ChannelState *statePtr;	/* State of actual channel. */
+    ChannelBuffer *bufPtr;	/* Buffer to contain the data. */
+    int flags;
+
+    chanPtr = (Channel *) chan;
+    statePtr = chanPtr->state;
+
+    /*
+     * This operation should occur at the top of a channel stack.
+     */
+
+    chanPtr = statePtr->topChanPtr;
+
+    /*
+     * CheckChannelErrors clears too many flag bits in this one case.
+     */
+
+    flags = statePtr->flags;
+    if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) {
+	len = -1;
+	goto done;
+    }
+    statePtr->flags = flags;
+
+    /*
+     * Clear the EOF flags, and clear the BLOCKED bit.
+     */
+
+    if (GotFlag(statePtr, CHANNEL_EOF)) {
+	statePtr->inputEncodingFlags |= TCL_ENCODING_START;
+    }
+    ResetFlag(statePtr,
+	    CHANNEL_BLOCKED | CHANNEL_STICKY_EOF | CHANNEL_EOF | INPUT_SAW_CR);
+    statePtr->inputEncodingFlags &= ~TCL_ENCODING_END;
+
+    bufPtr = AllocChannelBuffer(len);
+    memcpy(InsertPoint(bufPtr), str, (size_t) len);
+    bufPtr->nextAdded += len;
+
+    if (statePtr->inQueueHead == NULL) {
+	bufPtr->nextPtr = NULL;
+	statePtr->inQueueHead = bufPtr;
+	statePtr->inQueueTail = bufPtr;
+    } else if (atEnd) {
+	bufPtr->nextPtr = NULL;
+	statePtr->inQueueTail->nextPtr = bufPtr;
+	statePtr->inQueueTail = bufPtr;
+    } else {
+	bufPtr->nextPtr = statePtr->inQueueHead;
+	statePtr->inQueueHead = bufPtr;
+    }
+
+    /*
+     * Update the notifier state so we don't block while there is still data
+     * in the buffers.
+     */
+
+  done:
+    UpdateInterest(chanPtr);
+    return len;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_Flush --
+ *
+ *	Flushes output data on a channel.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	May flush output queued on this channel.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_Flush(
+    Tcl_Channel chan)		/* The Channel to flush. */
+{
+    int result;			/* Of calling FlushChannel. */
+    Channel *chanPtr = (Channel *) chan;
+				/* The actual channel. */
+    ChannelState *statePtr = chanPtr->state;
+				/* State of actual channel. */
+
+    /*
+     * This operation should occur at the top of a channel stack.
+     */
+
+    chanPtr = statePtr->topChanPtr;
+
+    if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
+	return -1;
+    }
+
+    result = FlushChannel(NULL, chanPtr, 0);
+    if (result != 0) {
+	return TCL_ERROR;
+    }
+
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * DiscardInputQueued --
+ *
+ *	Discards any input read from the channel but not yet consumed by Tcl
+ *	reading commands.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	May discard input from the channel. If discardLastBuffer is zero,
+ *	leaves one buffer in place for back-filling.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+DiscardInputQueued(
+    ChannelState *statePtr,	/* Channel on which to discard the queued
+				 * input. */
+    int discardSavedBuffers)	/* If non-zero, discard all buffers including
+				 * last one. */
+{
+    ChannelBuffer *bufPtr, *nxtPtr;
+				/* Loop variables. */
+
+    bufPtr = statePtr->inQueueHead;
+    statePtr->inQueueHead = NULL;
+    statePtr->inQueueTail = NULL;
+    for (; bufPtr != NULL; bufPtr = nxtPtr) {
+	nxtPtr = bufPtr->nextPtr;
+	RecycleBuffer(statePtr, bufPtr, discardSavedBuffers);
+    }
+
+    /*
+     * If discardSavedBuffers is nonzero, must also discard any previously
+     * saved buffer in the saveInBufPtr field.
+     */
+
+    if (discardSavedBuffers && statePtr->saveInBufPtr != NULL) {
+	ReleaseChannelBuffer(statePtr->saveInBufPtr);
+	statePtr->saveInBufPtr = NULL;
+    }
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * GetInput --
+ *
+ *	Reads input data from a device into a channel buffer.
+ *
+ *	IMPORTANT!  This routine is only called on a chanPtr argument
+ *	that is the top channel of a stack!
+ *
+ * Results:
+ *	The return value is the Posix error code if an error occurred while
+ *	reading from the file, or 0 otherwise.
+ *
+ * Side effects:
+ *	Reads from the underlying device.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+static int
+GetInput(
+    Channel *chanPtr)		/* Channel to read input from. */
+{
+    int toRead;			/* How much to read? */
+    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 */
+
+    /*
+     * Verify that all callers know better than to call us when
+     * it's recorded that the next char waiting to be read is the
+     * eofchar.
+     */
+
+    assert( !GotFlag(statePtr, CHANNEL_STICKY_EOF) );
+
+    /*
+     * Prevent reading from a dead channel -- a channel that has been closed
+     * but not yet deallocated, which can happen if the exit handler for
+     * channel cleanup has run but the channel is still registered in some
+     * interpreter.
+     */
+
+    if (CheckForDeadChannel(NULL, statePtr)) {
+	return EINVAL;
+    }
+
+    /*
+     * 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.
+     */
+
+    /*
+     * 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
+     * placed in the area when it was stacked.
+     */
+
+    if (chanPtr->inQueueHead != NULL) {
+
+	/* TODO: Tests to cover this. */
+	assert(statePtr->inQueueHead == NULL);
+
+	statePtr->inQueueHead = chanPtr->inQueueHead;
+	statePtr->inQueueTail = chanPtr->inQueueTail;
+	chanPtr->inQueueHead = NULL;
+	chanPtr->inQueueTail = NULL;
+	return 0;
+    }
+
+    /*
+     * Nothing in the pushback area, fall back to the usual handling (driver,
+     * etc.)
+     */
+
+    /*
+     * See if we can fill an existing buffer. If we can, read only as much as
+     * will fit in it. Otherwise allocate a new buffer, add it to the input
+     * queue and attempt to fill it to the max.
+     */
+
+    bufPtr = statePtr->inQueueTail;
+
+    if ((bufPtr == NULL) || IsBufferFull(bufPtr)) {
+	bufPtr = statePtr->saveInBufPtr;
+	statePtr->saveInBufPtr = NULL;
+
+	/*
+	 * 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.
+	 * TODO: Tests to cover this.
+	 */
+
+	if ((bufPtr != NULL)
+		&& (bufPtr->bufLength - BUFFER_PADDING != statePtr->bufSize)) {
+	    ReleaseChannelBuffer(bufPtr);
+	    bufPtr = NULL;
+	}
+
+	if (bufPtr == NULL) {
+	    bufPtr = AllocChannelBuffer(statePtr->bufSize);
+	}
+	bufPtr->nextPtr = NULL;
+
+	toRead = SpaceLeft(bufPtr);
+	assert(toRead == statePtr->bufSize);
+
+	if (statePtr->inQueueTail == NULL) {
+	    statePtr->inQueueHead = bufPtr;
+	} else {
+	    statePtr->inQueueTail->nextPtr = bufPtr;
+	}
+	statePtr->inQueueTail = bufPtr;
+    } else {
+	toRead = SpaceLeft(bufPtr);
+    }
+
+    PreserveChannelBuffer(bufPtr);
+    nread = ChanRead(chanPtr, InsertPoint(bufPtr), toRead);
+
+    if (nread < 0) {
+	result = Tcl_GetErrno();
+    } else {
+	result = 0;
+	bufPtr->nextAdded += nread;
+    }
+
+    ReleaseChannelBuffer(bufPtr);
+    return result;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_Seek --
+ *
+ *	Implements seeking on Tcl Channels. This is a public function so that
+ *	other C facilities may be implemented on top of it.
+ *
+ * Results:
+ *	The new access point or -1 on error. If error, use Tcl_GetErrno() to
+ *	retrieve the POSIX error code for the error that occurred.
+ *
+ * Side effects:
+ *	May flush output on the channel. May discard queued input.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_WideInt
+Tcl_Seek(
+    Tcl_Channel chan,		/* The channel on which to 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 */
+    int inputBuffered, outputBuffered;
+				/* # bytes held in buffers. */
+    int result;			/* Of device driver operations. */
+    Tcl_WideInt curPos;		/* Position on the device. */
+    int wasAsync;		/* Was the channel nonblocking before the seek
+				 * operation? If so, must restore to
+				 * non-blocking mode after the seek. */
+
+    if (CheckChannelErrors(statePtr, TCL_WRITABLE | TCL_READABLE) != 0) {
+	return Tcl_LongAsWide(-1);
+    }
+
+    /*
+     * Disallow seek on dead channels - channels that have been closed but not
+     * yet been deallocated. Such channels can be found if the exit handler
+     * for channel cleanup has run but the channel is still registered in an
+     * interpreter.
+     */
+
+    if (CheckForDeadChannel(NULL, statePtr)) {
+	return Tcl_LongAsWide(-1);
+    }
+
+    /*
+     * This operation should occur at the top of a channel stack.
+     */
+
+    chanPtr = statePtr->topChanPtr;
+
+    /*
+     * Disallow seek on channels whose type does not have a seek procedure
+     * defined. This means that the channel does not support seeking.
+     */
+
+    if (chanPtr->typePtr->seekProc == NULL) {
+	Tcl_SetErrno(EINVAL);
+	return Tcl_LongAsWide(-1);
+    }
+
+    /*
+     * Compute how much input and output is buffered. If both input and output
+     * is buffered, cannot compute the current position.
+     */
+
+    inputBuffered = Tcl_InputBuffered(chan);
+    outputBuffered = Tcl_OutputBuffered(chan);
+
+    if ((inputBuffered != 0) && (outputBuffered != 0)) {
+	Tcl_SetErrno(EFAULT);
+	return Tcl_LongAsWide(-1);
+    }
+
+    /*
+     * If we are seeking relative to the current position, compute the
+     * corrected offset taking into account the amount of unread input.
+     */
+
+    if (mode == SEEK_CUR) {
+	offset -= inputBuffered;
+    }
+
+    /*
+     * Discard any queued input - this input should not be read after the
+     * seek.
+     */
+
+    DiscardInputQueued(statePtr, 0);
+
+    /*
+     * Reset EOF and BLOCKED flags. We invalidate them by moving the access
+     * point. Also clear CR related flags.
+     */
+
+    if (GotFlag(statePtr, CHANNEL_EOF)) {
+	statePtr->inputEncodingFlags |= TCL_ENCODING_START;
+    }
+    ResetFlag(statePtr, CHANNEL_EOF | CHANNEL_STICKY_EOF | CHANNEL_BLOCKED |
+	    INPUT_SAW_CR);
+    statePtr->inputEncodingFlags &= ~TCL_ENCODING_END;
+
+    /*
+     * If the channel is in asynchronous output mode, switch it back to
+     * synchronous mode and cancel any async flush that may be scheduled.
+     * After the flush, the channel will be put back into asynchronous output
+     * mode.
+     */
+
+    wasAsync = 0;
+    if (GotFlag(statePtr, CHANNEL_NONBLOCKING)) {
+	wasAsync = 1;
+	result = StackSetBlockMode(chanPtr, TCL_MODE_BLOCKING);
+	if (result != 0) {
+	    return Tcl_LongAsWide(-1);
+	}
+	ResetFlag(statePtr, CHANNEL_NONBLOCKING);
+	if (GotFlag(statePtr, BG_FLUSH_SCHEDULED)) {
+	    ResetFlag(statePtr, BG_FLUSH_SCHEDULED);
+	}
+    }
+
+    /*
+     * If the flush fails we cannot recover the original position. In that
+     * case the seek is not attempted because we do not know where the access
+     * position is - instead we return the error. FlushChannel has already
+     * called Tcl_SetErrno() to report the error upwards. If the flush
+     * succeeds we do the seek also.
+     */
+
+    if (FlushChannel(NULL, chanPtr, 0) != 0) {
+	curPos = -1;
+    } else {
+	/*
+	 * Now seek to the new position in the channel as requested by the
+	 * caller.
+	 */
+
+	curPos = ChanSeek(chanPtr, offset, mode, &result);
+	if (curPos == Tcl_LongAsWide(-1)) {
+	    Tcl_SetErrno(result);
+	}
+    }
+
+    /*
+     * Restore to nonblocking mode if that was the previous behavior.
+     *
+     * NOTE: Even if there was an async flush active we do not restore it now
+     * because we already flushed all the queued output, above.
+     */
+
+    if (wasAsync) {
+	SetFlag(statePtr, CHANNEL_NONBLOCKING);
+	result = StackSetBlockMode(chanPtr, TCL_MODE_NONBLOCKING);
+	if (result != 0) {
+	    return Tcl_LongAsWide(-1);
+	}
+    }
+
+    return curPos;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_Tell --
+ *
+ *	Returns the position of the next character to be read/written on this
+ *	channel.
+ *
+ * Results:
+ *	A nonnegative integer on success, -1 on failure. If failed, use
+ *	Tcl_GetErrno() to retrieve the POSIX error code for the error that
+ *	occurred.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+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 */
+    int inputBuffered, outputBuffered;
+				/* # bytes held in buffers. */
+    int result;			/* Of calling device driver. */
+    Tcl_WideInt curPos;		/* Position on device. */
+
+    if (CheckChannelErrors(statePtr, TCL_WRITABLE | TCL_READABLE) != 0) {
+	return Tcl_LongAsWide(-1);
+    }
+
+    /*
+     * Disallow tell on dead channels -- channels that have been closed but
+     * not yet been deallocated. Such channels can be found if the exit
+     * handler for channel cleanup has run but the channel is still registered
+     * in an interpreter.
+     */
+
+    if (CheckForDeadChannel(NULL, statePtr)) {
+	return Tcl_LongAsWide(-1);
+    }
+
+    /*
+     * This operation should occur at the top of a channel stack.
+     */
+
+    chanPtr = statePtr->topChanPtr;
+
+    /*
+     * Disallow tell on channels whose type does not have a seek procedure
+     * defined. This means that the channel does not support seeking.
+     */
+
+    if (chanPtr->typePtr->seekProc == NULL) {
+	Tcl_SetErrno(EINVAL);
+	return Tcl_LongAsWide(-1);
+    }
+
+    /*
+     * Compute how much input and output is buffered. If both input and output
+     * is buffered, cannot compute the current position.
+     */
+
+    inputBuffered = Tcl_InputBuffered(chan);
+    outputBuffered = Tcl_OutputBuffered(chan);
+
+    /*
+     * Get the current position in the device and compute the position where
+     * the next character will be read or written. Note that we prefer the
+     * wideSeekProc if that is available and non-NULL...
+     */
+
+    curPos = ChanSeek(chanPtr, Tcl_LongAsWide(0), SEEK_CUR, &result);
+    if (curPos == Tcl_LongAsWide(-1)) {
+	Tcl_SetErrno(result);
+	return Tcl_LongAsWide(-1);
+    }
+
+    if (inputBuffered != 0) {
+	return curPos - inputBuffered;
+    }
+    return curPos + outputBuffered;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * Tcl_SeekOld, Tcl_TellOld --
+ *
+ *	Backward-compatibility 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
+ *	supported by the type of channel, or the underlying OS operation
+ *	failed in some way).
+ *
+ * Side effects:
+ *	Seeks the channel to the current location. Sets errno on OS error.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+int
+Tcl_TruncateChannel(
+    Tcl_Channel chan,		/* Channel to truncate. */
+    Tcl_WideInt length)		/* Length to truncate it to. */
+{
+    Channel *chanPtr = (Channel *) chan;
+    Tcl_DriverTruncateProc *truncateProc =
+	    Tcl_ChannelTruncateProc(chanPtr->typePtr);
+    int result;
+
+    if (truncateProc == NULL) {
+	/*
+	 * Feature not supported and it's not emulatable. Pretend it's
+	 * returned an EINVAL, a very generic error!
+	 */
+
+	Tcl_SetErrno(EINVAL);
+	return TCL_ERROR;
+    }
+
+    if (!GotFlag(chanPtr->state, TCL_WRITABLE)) {
+	/*
+	 * 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;
+    }
+
+    /*
+     * Seek first to force a total flush of all pending buffers and ditch any
+     * pre-read input data.
+     */
+
+    WillWrite(chanPtr);
+
+    if (WillRead(chanPtr) < 0) {
+        return TCL_ERROR;
+    }
+
+    /*
+     * We're all flushed to disk now and we also don't have any unfortunate
+     * input baggage around either; can truncate with impunity.
+     */
+
+    result = truncateProc(chanPtr->instanceData, length);
+    if (result != 0) {
+	Tcl_SetErrno(result);
+	return TCL_ERROR;
+    }
+    return TCL_OK;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * CheckChannelErrors --
+ *
+ *	See if the channel is in an ready state and can perform the desired
+ *	operation.
+ *
+ * Results:
+ *	The return value is 0 if the channel is OK, otherwise the return value
+ *	is -1 and errno is set to indicate the error.
+ *
+ * Side effects:
+ *	May clear the EOF and/or BLOCKED bits if reading from channel.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+static int
+CheckChannelErrors(
+    ChannelState *statePtr,	/* Channel to check. */
+    int flags)			/* Test if channel supports desired operation:
+				 * TCL_READABLE, TCL_WRITABLE. Also indicates
+				 * Raw read or write for special close
+				 * processing */
+{
+    int direction = flags & (TCL_READABLE|TCL_WRITABLE);
+
+    /*
+     * Check for unreported error.
+     */
+
+    if (statePtr->unreportedError != 0) {
+	Tcl_SetErrno(statePtr->unreportedError);
+	statePtr->unreportedError = 0;
+
+	/*
+	 * TIP #219, Tcl Channel Reflection API.
+	 * Move a defered error message back into the channel bypass.
+	 */
+
+	if (statePtr->chanMsg != NULL) {
+	    TclDecrRefCount(statePtr->chanMsg);
+	}
+	statePtr->chanMsg = statePtr->unreportedMsg;
+	statePtr->unreportedMsg = NULL;
+	return -1;
+    }
+
+    /*
+     * Only the raw read and write operations are allowed during close in
+     * order to drain data from stacked channels.
+     */
+
+    if (GotFlag(statePtr, CHANNEL_CLOSED) && !(flags & CHANNEL_RAW_MODE)) {
+	Tcl_SetErrno(EACCES);
+	return -1;
+    }
+
+    /*
+     * Fail if the channel is not opened for desired operation.
+     */
+
+    if ((statePtr->flags & direction) == 0) {
+	Tcl_SetErrno(EACCES);
+	return -1;
+    }
+
+    /*
+     * Fail if the channel is in the middle of a background copy.
+     *
+     * Don't do this tests for raw channels here or else the chaining in the
+     * transformation drivers will fail with 'file busy' error instead of
+     * retrieving and transforming the data to copy.
+     */
+
+    if (BUSY_STATE(statePtr, flags) && ((flags & CHANNEL_RAW_MODE) == 0)) {
+	Tcl_SetErrno(EBUSY);
+	return -1;
+    }
+
+    if (direction == TCL_READABLE) {
+	ResetFlag(statePtr, CHANNEL_NEED_MORE_DATA);
+    }
+
+    return 0;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_Eof --
+ *
+ *	Returns 1 if the channel is at EOF, 0 otherwise.
+ *
+ * Results:
+ *	1 or 0, always.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_Eof(
+    Tcl_Channel chan)		/* Does this channel have EOF? */
+{
+    ChannelState *statePtr = ((Channel *) chan)->state;
+				/* State of real channel structure. */
+
+    return GotFlag(statePtr, CHANNEL_EOF) ? 1 : 0;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_InputBlocked --
+ *
+ *	Returns 1 if input is blocked on this channel, 0 otherwise.
+ *
+ * Results:
+ *	0 or 1, always.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_InputBlocked(
+    Tcl_Channel chan)		/* Is this channel blocked? */
+{
+    ChannelState *statePtr = ((Channel *) chan)->state;
+				/* State of real channel structure. */
+
+    return GotFlag(statePtr, CHANNEL_BLOCKED) ? 1 : 0;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_InputBuffered --
+ *
+ *	Returns the number of bytes of input currently buffered in the common
+ *	internal buffer of a channel.
+ *
+ * Results:
+ *	The number of input bytes buffered, or zero if the channel is not open
+ *	for reading.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_InputBuffered(
+    Tcl_Channel chan)		/* The channel to query. */
+{
+    ChannelState *statePtr = ((Channel *) chan)->state;
+				/* State of real channel structure. */
+    ChannelBuffer *bufPtr;
+    int bytesBuffered;
+
+    for (bytesBuffered = 0, bufPtr = statePtr->inQueueHead; bufPtr != NULL;
+	    bufPtr = bufPtr->nextPtr) {
+	bytesBuffered += BytesLeft(bufPtr);
+    }
+
+    /*
+     * Don't forget the bytes in the topmost pushback area.
+     */
+
+    for (bufPtr = statePtr->topChanPtr->inQueueHead; bufPtr != NULL;
+	    bufPtr = bufPtr->nextPtr) {
+	bytesBuffered += BytesLeft(bufPtr);
+    }
+
+    return bytesBuffered;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_OutputBuffered --
+ *
+ *    Returns the number of bytes of output currently buffered in the common
+ *    internal buffer of a channel.
+ *
+ * Results:
+ *    The number of output bytes buffered, or zero if the channel is not open
+ *    for writing.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_OutputBuffered(
+    Tcl_Channel chan)		/* The channel to query. */
+{
+    ChannelState *statePtr = ((Channel *) chan)->state;
+				/* State of real channel structure. */
+    ChannelBuffer *bufPtr;
+    int bytesBuffered;
+
+    for (bytesBuffered = 0, bufPtr = statePtr->outQueueHead; bufPtr != NULL;
+	    bufPtr = bufPtr->nextPtr) {
+	bytesBuffered += BytesLeft(bufPtr);
+    }
+    if (statePtr->curOutPtr != NULL) {
+	register ChannelBuffer *curOutPtr = statePtr->curOutPtr;
+
+	if (IsBufferReady(curOutPtr)) {
+	    bytesBuffered += BytesLeft(curOutPtr);
+	}
+    }
+
+    return bytesBuffered;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelBuffered --
+ *
+ *	Returns the number of bytes of input currently buffered in the
+ *	internal buffer (push back area) of a channel.
+ *
+ * Results:
+ *	The number of input bytes buffered, or zero if the channel is not open
+ *	for reading.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_ChannelBuffered(
+    Tcl_Channel chan)		/* The channel to query. */
+{
+    Channel *chanPtr = (Channel *) chan;
+				/* Real channel structure. */
+    ChannelBuffer *bufPtr;
+    int bytesBuffered = 0;
+
+    for (bufPtr = chanPtr->inQueueHead; bufPtr != NULL;
+	    bufPtr = bufPtr->nextPtr) {
+	bytesBuffered += BytesLeft(bufPtr);
+    }
+
+    return bytesBuffered;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_SetChannelBufferSize --
+ *
+ *	Sets the size of buffers to allocate to store input or output in the
+ *	channel. The size must be between 1 byte and 1 MByte.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Sets the size of buffers subsequently allocated for this channel.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_SetChannelBufferSize(
+    Tcl_Channel chan,		/* The channel whose buffer size to set. */
+    int sz)			/* The size to set. */
+{
+    ChannelState *statePtr;	/* State of real channel structure. */
+
+    /*
+     * Clip the buffer size to force it into the [1,1M] range
+     */
+
+    if (sz < 1) {
+	sz = 1;
+    } else if (sz > MAX_CHANNEL_BUFFER_SIZE) {
+	sz = MAX_CHANNEL_BUFFER_SIZE;
+    }
+
+    statePtr = ((Channel *) chan)->state;
+
+    if (statePtr->bufSize == sz) {
+	return;
+    }
+    statePtr->bufSize = sz;
+
+    /*
+     * If bufsize changes, need to get rid of old utility buffer.
+     */
+
+    if (statePtr->saveInBufPtr != NULL) {
+	RecycleBuffer(statePtr, statePtr->saveInBufPtr, 1);
+	statePtr->saveInBufPtr = NULL;
+    }
+    if ((statePtr->inQueueHead != NULL)
+	    && (statePtr->inQueueHead->nextPtr == NULL)
+	    && IsBufferEmpty(statePtr->inQueueHead)) {
+	RecycleBuffer(statePtr, statePtr->inQueueHead, 1);
+	statePtr->inQueueHead = NULL;
+	statePtr->inQueueTail = NULL;
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GetChannelBufferSize --
+ *
+ *	Retrieves the size of buffers to allocate for this channel.
+ *
+ * Results:
+ *	The size.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_GetChannelBufferSize(
+    Tcl_Channel chan)		/* The channel for which to find the buffer
+				 * size. */
+{
+    ChannelState *statePtr = ((Channel *) chan)->state;
+				/* State of real channel structure. */
+
+    return statePtr->bufSize;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_BadChannelOption --
+ *
+ *	This procedure generates a "bad option" error message in an (optional)
+ *	interpreter. It is used by channel drivers when a invalid Set/Get
+ *	option is requested. Its purpose is to concatenate the generic options
+ *	list to the specific ones and factorize the generic options error
+ *	message string.
+ *
+ * Results:
+ *	TCL_ERROR.
+ *
+ * Side effects:
+
+ *	An error message is generated in interp's result object to indicate
+ *	that a command was invoked with the a bad option. The message has the
+ *	form:
+ *		bad option "blah": should be one of
+ *		<...generic options...>+<...specific options...>
+ *	"blah" is the optionName argument and "<specific options>" is a space
+ *	separated list of specific option words. The function takes good care
+ *	of inserting minus signs before each option, commas after, and an "or"
+ *	before the last option.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_BadChannelOption(
+    Tcl_Interp *interp,		/* Current interpreter (can be NULL).*/
+    const char *optionName,	/* 'bad option' name */
+    const char *optionList)	/* Specific options list to append to the
+				 * standard generic options. Can be NULL for
+				 * generic options only. */
+{
+    if (interp != NULL) {
+	const char *genericopt =
+		"blocking buffering buffersize encoding eofchar translation";
+	const char **argv;
+	int argc, i;
+	Tcl_DString ds;
+        Tcl_Obj *errObj;
+
+	Tcl_DStringInit(&ds);
+	Tcl_DStringAppend(&ds, genericopt, -1);
+	if (optionList && (*optionList)) {
+	    TclDStringAppendLiteral(&ds, " ");
+	    Tcl_DStringAppend(&ds, optionList, -1);
+	}
+	if (Tcl_SplitList(interp, Tcl_DStringValue(&ds),
+		&argc, &argv) != TCL_OK) {
+	    Tcl_Panic("malformed option list in channel driver");
+	}
+	Tcl_ResetResult(interp);
+	errObj = Tcl_ObjPrintf("bad option \"%s\": should be one of ",
+                optionName);
+	argc--;
+	for (i = 0; i < argc; i++) {
+	    Tcl_AppendPrintfToObj(errObj, "-%s, ", argv[i]);
+	}
+	Tcl_AppendPrintfToObj(errObj, "or -%s", argv[i]);
+        Tcl_SetObjResult(interp, errObj);
+	Tcl_DStringFree(&ds);
+	ckfree(argv);
+    }
+    Tcl_SetErrno(EINVAL);
+    return TCL_ERROR;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GetChannelOption --
+ *
+ *	Gets a mode associated with an IO channel. If the optionName arg is
+ *	non NULL, retrieves the value of that option. If the optionName arg is
+ *	NULL, retrieves a list of alternating option names and values for the
+ *	given channel.
+ *
+ * Results:
+ *	A standard Tcl result. Also sets the supplied DString to the string
+ *	value of the option(s) returned.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_GetChannelOption(
+    Tcl_Interp *interp,		/* For error reporting - can be NULL. */
+    Tcl_Channel chan,		/* Channel on which to get option. */
+    const char *optionName,	/* Option to get. */
+    Tcl_DString *dsPtr)		/* Where to store value(s). */
+{
+    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 */
+    int flags;
+
+    /*
+     * Disallow options on dead channels -- channels that have been closed but
+     * not yet been deallocated. Such channels can be found if the exit
+     * handler for channel cleanup has run but the channel is still registered
+     * in an interpreter.
+     */
+
+    if (CheckForDeadChannel(interp, statePtr)) {
+	return TCL_ERROR;
+    }
+
+    /*
+     * This operation should occur at the top of a channel stack.
+     */
+
+    chanPtr = statePtr->topChanPtr;
+
+    /*
+     * If we are in the middle of a background copy, use the saved flags.
+     */
+
+    if (statePtr->csPtrR) {
+	flags = statePtr->csPtrR->readFlags;
+    } else if (statePtr->csPtrW) {
+	flags = statePtr->csPtrW->writeFlags;
+    } else {
+	flags = statePtr->flags;
+    }
+
+    /*
+     * If the optionName is NULL it means that we want a list of all options
+     * and values.
+     */
+
+    if (optionName == NULL) {
+	len = 0;
+    } else {
+	len = strlen(optionName);
+    }
+
+    if (len == 0 || HaveOpt(2, "-blocking")) {
+	if (len == 0) {
+	    Tcl_DStringAppendElement(dsPtr, "-blocking");
+	}
+	Tcl_DStringAppendElement(dsPtr,
+		(flags & CHANNEL_NONBLOCKING) ? "0" : "1");
+	if (len > 0) {
+	    return TCL_OK;
+	}
+    }
+    if (len == 0 || HaveOpt(7, "-buffering")) {
+	if (len == 0) {
+	    Tcl_DStringAppendElement(dsPtr, "-buffering");
+	}
+	if (flags & CHANNEL_LINEBUFFERED) {
+	    Tcl_DStringAppendElement(dsPtr, "line");
+	} else if (flags & CHANNEL_UNBUFFERED) {
+	    Tcl_DStringAppendElement(dsPtr, "none");
+	} else {
+	    Tcl_DStringAppendElement(dsPtr, "full");
+	}
+	if (len > 0) {
+	    return TCL_OK;
+	}
+    }
+    if (len == 0 || HaveOpt(7, "-buffersize")) {
+	if (len == 0) {
+	    Tcl_DStringAppendElement(dsPtr, "-buffersize");
+	}
+	TclFormatInt(optionVal, statePtr->bufSize);
+	Tcl_DStringAppendElement(dsPtr, optionVal);
+	if (len > 0) {
+	    return TCL_OK;
+	}
+    }
+    if (len == 0 || HaveOpt(2, "-encoding")) {
+	if (len == 0) {
+	    Tcl_DStringAppendElement(dsPtr, "-encoding");
+	}
+	if (statePtr->encoding == NULL) {
+	    Tcl_DStringAppendElement(dsPtr, "binary");
+	} else {
+	    Tcl_DStringAppendElement(dsPtr,
+		    Tcl_GetEncodingName(statePtr->encoding));
+	}
+	if (len > 0) {
+	    return TCL_OK;
+	}
+    }
+    if (len == 0 || HaveOpt(2, "-eofchar")) {
+	if (len == 0) {
+	    Tcl_DStringAppendElement(dsPtr, "-eofchar");
+	}
+	if (((flags & (TCL_READABLE|TCL_WRITABLE)) ==
+		(TCL_READABLE|TCL_WRITABLE)) && (len == 0)) {
+	    Tcl_DStringStartSublist(dsPtr);
+	}
+	if (flags & TCL_READABLE) {
+	    if (statePtr->inEofChar == 0) {
+		Tcl_DStringAppendElement(dsPtr, "");
+	    } else {
+		char buf[4];
+
+		sprintf(buf, "%c", statePtr->inEofChar);
+		Tcl_DStringAppendElement(dsPtr, buf);
+	    }
+	}
+	if (flags & TCL_WRITABLE) {
+	    if (statePtr->outEofChar == 0) {
+		Tcl_DStringAppendElement(dsPtr, "");
+	    } else {
+		char buf[4];
+
+		sprintf(buf, "%c", statePtr->outEofChar);
+		Tcl_DStringAppendElement(dsPtr, buf);
+	    }
+	}
+	if (!(flags & (TCL_READABLE|TCL_WRITABLE))) {
+	    /*
+	     * Not readable or writable (e.g. server socket)
+	     */
+
+	    Tcl_DStringAppendElement(dsPtr, "");
+	}
+	if (((flags & (TCL_READABLE|TCL_WRITABLE)) ==
+		(TCL_READABLE|TCL_WRITABLE)) && (len == 0)) {
+	    Tcl_DStringEndSublist(dsPtr);
+	}
+	if (len > 0) {
+	    return TCL_OK;
+	}
+    }
+    if (len == 0 || HaveOpt(1, "-translation")) {
+	if (len == 0) {
+	    Tcl_DStringAppendElement(dsPtr, "-translation");
+	}
+	if (((flags & (TCL_READABLE|TCL_WRITABLE)) ==
+		(TCL_READABLE|TCL_WRITABLE)) && (len == 0)) {
+	    Tcl_DStringStartSublist(dsPtr);
+	}
+	if (flags & TCL_READABLE) {
+	    if (statePtr->inputTranslation == TCL_TRANSLATE_AUTO) {
+		Tcl_DStringAppendElement(dsPtr, "auto");
+	    } else if (statePtr->inputTranslation == TCL_TRANSLATE_CR) {
+		Tcl_DStringAppendElement(dsPtr, "cr");
+	    } else if (statePtr->inputTranslation == TCL_TRANSLATE_CRLF) {
+		Tcl_DStringAppendElement(dsPtr, "crlf");
+	    } else {
+		Tcl_DStringAppendElement(dsPtr, "lf");
+	    }
+	}
+	if (flags & TCL_WRITABLE) {
+	    if (statePtr->outputTranslation == TCL_TRANSLATE_AUTO) {
+		Tcl_DStringAppendElement(dsPtr, "auto");
+	    } else if (statePtr->outputTranslation == TCL_TRANSLATE_CR) {
+		Tcl_DStringAppendElement(dsPtr, "cr");
+	    } else if (statePtr->outputTranslation == TCL_TRANSLATE_CRLF) {
+		Tcl_DStringAppendElement(dsPtr, "crlf");
+	    } else {
+		Tcl_DStringAppendElement(dsPtr, "lf");
+	    }
+	}
+	if (!(flags & (TCL_READABLE|TCL_WRITABLE))) {
+	    /*
+	     * Not readable or writable (e.g. server socket)
+	     */
+
+	    Tcl_DStringAppendElement(dsPtr, "auto");
+	}
+	if (((flags & (TCL_READABLE|TCL_WRITABLE)) ==
+		(TCL_READABLE|TCL_WRITABLE)) && (len == 0)) {
+	    Tcl_DStringEndSublist(dsPtr);
+	}
+	if (len > 0) {
+	    return TCL_OK;
+	}
+    }
+
+    if (chanPtr->typePtr->getOptionProc != NULL) {
+	/*
+	 * Let the driver specific handle additional options and result code
+	 * and message.
+	 */
+
+	return chanPtr->typePtr->getOptionProc(chanPtr->instanceData, interp,
+		optionName, dsPtr);
+    } else {
+	/*
+	 * No driver specific options case.
+	 */
+
+	if (len == 0) {
+	    return TCL_OK;
+	}
+	return Tcl_BadChannelOption(interp, optionName, NULL);
+    }
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * Tcl_SetChannelOption --
+ *
+ *	Sets an option on a channel.
+ *
+ * Results:
+ *	A standard Tcl result. On error, sets interp's result object if
+ *	interp is not NULL.
+ *
+ * Side effects:
+ *	May modify an option on a device.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+int
+Tcl_SetChannelOption(
+    Tcl_Interp *interp,		/* For error reporting - can be NULL. */
+    Tcl_Channel chan,		/* Channel on which to set mode. */
+    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 */
+    size_t len;			/* Length of optionName string. */
+    int argc;
+    const char **argv;
+
+    /*
+     * If the channel is in the middle of a background copy, fail.
+     */
+
+    if (statePtr->csPtrR || statePtr->csPtrW) {
+	if (interp) {
+	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
+                    "unable to set channel options: background copy in"
+                    " progress", -1));
+	}
+	return TCL_ERROR;
+    }
+
+    /*
+     * Disallow options on dead channels -- channels that have been closed but
+     * not yet been deallocated. Such channels can be found if the exit
+     * handler for channel cleanup has run but the channel is still registered
+     * in an interpreter.
+     */
+
+    if (CheckForDeadChannel(NULL, statePtr)) {
+	return TCL_ERROR;
+    }
+
+    /*
+     * This operation should occur at the top of a channel stack.
+     */
+
+    chanPtr = statePtr->topChanPtr;
+
+    len = strlen(optionName);
+
+    if (HaveOpt(2, "-blocking")) {
+	int newMode;
+
+	if (Tcl_GetBoolean(interp, newValue, &newMode) == TCL_ERROR) {
+	    return TCL_ERROR;
+	}
+	if (newMode) {
+	    newMode = TCL_MODE_BLOCKING;
+	} else {
+	    newMode = TCL_MODE_NONBLOCKING;
+	}
+	return SetBlockMode(interp, chanPtr, newMode);
+    } else if (HaveOpt(7, "-buffering")) {
+	len = strlen(newValue);
+	if ((newValue[0] == 'f') && (strncmp(newValue, "full", len) == 0)) {
+	    ResetFlag(statePtr, CHANNEL_UNBUFFERED | CHANNEL_LINEBUFFERED);
+	} else if ((newValue[0] == 'l') &&
+		(strncmp(newValue, "line", len) == 0)) {
+	    ResetFlag(statePtr, CHANNEL_UNBUFFERED);
+	    SetFlag(statePtr, CHANNEL_LINEBUFFERED);
+	} else if ((newValue[0] == 'n') &&
+		(strncmp(newValue, "none", len) == 0)) {
+	    ResetFlag(statePtr, CHANNEL_LINEBUFFERED);
+	    SetFlag(statePtr, CHANNEL_UNBUFFERED);
+	} else if (interp) {
+            Tcl_SetObjResult(interp, Tcl_NewStringObj(
+                    "bad value for -buffering: must be one of"
+                    " full, line, or none", -1));
+            return TCL_ERROR;
+	}
+	return TCL_OK;
+    } else if (HaveOpt(7, "-buffersize")) {
+	int newBufferSize;
+
+	if (Tcl_GetInt(interp, newValue, &newBufferSize) == TCL_ERROR) {
+	    return TCL_ERROR;
+	}
+	Tcl_SetChannelBufferSize(chan, newBufferSize);
+	return TCL_OK;
+    } else if (HaveOpt(2, "-encoding")) {
+	Tcl_Encoding encoding;
+
+	if ((newValue[0] == '\0') || (strcmp(newValue, "binary") == 0)) {
+	    encoding = NULL;
+	} else {
+	    encoding = Tcl_GetEncoding(interp, newValue);
+	    if (encoding == NULL) {
+		return TCL_ERROR;
+	    }
+	}
+
+	/*
+	 * When the channel has an escape sequence driven encoding such as
+	 * iso2022, the terminated escape sequence must write to the buffer.
+	 */
+
+	if ((statePtr->encoding != NULL)
+		&& !(statePtr->outputEncodingFlags & TCL_ENCODING_START)
+		&& (CheckChannelErrors(statePtr, TCL_WRITABLE) == 0)) {
+	    statePtr->outputEncodingFlags |= TCL_ENCODING_END;
+	    WriteChars(chanPtr, "", 0);
+	}
+	Tcl_FreeEncoding(statePtr->encoding);
+	statePtr->encoding = encoding;
+	statePtr->inputEncodingState = NULL;
+	statePtr->inputEncodingFlags = TCL_ENCODING_START;
+	statePtr->outputEncodingState = NULL;
+	statePtr->outputEncodingFlags = TCL_ENCODING_START;
+	ResetFlag(statePtr, CHANNEL_NEED_MORE_DATA);
+	UpdateInterest(chanPtr);
+	return TCL_OK;
+    } else if (HaveOpt(2, "-eofchar")) {
+	if (Tcl_SplitList(interp, newValue, &argc, &argv) == TCL_ERROR) {
+	    return TCL_ERROR;
+	}
+	if (argc == 0) {
+	    statePtr->inEofChar = 0;
+	    statePtr->outEofChar = 0;
+	} else if (argc == 1 || argc == 2) {
+	    int outIndex = (argc - 1);
+	    int inValue = (int) argv[0][0];
+	    int outValue = (int) argv[outIndex][0];
+
+	    if (inValue & 0x80 || outValue & 0x80) {
+		if (interp) {
+		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
+                            "bad value for -eofchar: must be non-NUL ASCII"
+                            " character", -1));
+		}
+		ckfree(argv);
+		return TCL_ERROR;
+	    }
+	    if (GotFlag(statePtr, TCL_READABLE)) {
+		statePtr->inEofChar = inValue;
+	    }
+	    if (GotFlag(statePtr, TCL_WRITABLE)) {
+		statePtr->outEofChar = outValue;
+	    }
+	} else {
+	    if (interp) {
+		Tcl_SetObjResult(interp, Tcl_NewStringObj(
+			"bad value for -eofchar: should be a list of zero,"
+			" one, or two elements", -1));
+	    }
+	    ckfree(argv);
+	    return TCL_ERROR;
+	}
+	if (argv != NULL) {
+	    ckfree(argv);
+	}
+
+	/*
+	 * [Bug 930851] Reset EOF and BLOCKED flags. Changing the character
+	 * which signals eof can transform a current eof condition into a 'go
+	 * ahead'. Ditto for blocked.
+	 */
+
+	if (GotFlag(statePtr, CHANNEL_EOF)) {
+	    statePtr->inputEncodingFlags |= TCL_ENCODING_START;
+	}
+	ResetFlag(statePtr, CHANNEL_EOF|CHANNEL_STICKY_EOF|CHANNEL_BLOCKED);
+	statePtr->inputEncodingFlags &= ~TCL_ENCODING_END;
+	return TCL_OK;
+    } else if (HaveOpt(1, "-translation")) {
+	const char *readMode, *writeMode;
+
+	if (Tcl_SplitList(interp, newValue, &argc, &argv) == TCL_ERROR) {
+	    return TCL_ERROR;
+	}
+
+	if (argc == 1) {
+	    readMode = GotFlag(statePtr, TCL_READABLE) ? argv[0] : NULL;
+	    writeMode = GotFlag(statePtr, TCL_WRITABLE) ? argv[0] : NULL;
+	} else if (argc == 2) {
+	    readMode = GotFlag(statePtr, TCL_READABLE) ? argv[0] : NULL;
+	    writeMode = GotFlag(statePtr, TCL_WRITABLE) ? argv[1] : NULL;
+	} else {
+	    if (interp) {
+		Tcl_SetObjResult(interp, Tcl_NewStringObj(
+			"bad value for -translation: must be a one or two"
+			" element list", -1));
+	    }
+	    ckfree(argv);
+	    return TCL_ERROR;
+	}
+
+	if (readMode) {
+	    TclEolTranslation translation;
+
+	    if (*readMode == '\0') {
+		translation = statePtr->inputTranslation;
+	    } else if (strcmp(readMode, "auto") == 0) {
+		translation = TCL_TRANSLATE_AUTO;
+	    } else if (strcmp(readMode, "binary") == 0) {
+		translation = TCL_TRANSLATE_LF;
+		statePtr->inEofChar = 0;
+		Tcl_FreeEncoding(statePtr->encoding);
+		statePtr->encoding = NULL;
+	    } else if (strcmp(readMode, "lf") == 0) {
+		translation = TCL_TRANSLATE_LF;
+	    } else if (strcmp(readMode, "cr") == 0) {
+		translation = TCL_TRANSLATE_CR;
+	    } else if (strcmp(readMode, "crlf") == 0) {
+		translation = TCL_TRANSLATE_CRLF;
+	    } else if (strcmp(readMode, "platform") == 0) {
+		translation = TCL_PLATFORM_TRANSLATION;
+	    } else {
+		if (interp) {
+		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
+			    "bad value for -translation: must be one of "
+                            "auto, binary, cr, lf, crlf, or platform", -1));
+		}
+		ckfree(argv);
+		return TCL_ERROR;
+	    }
+
+	    /*
+	     * Reset the EOL flags since we need to look at any buffered data
+	     * to see if the new translation mode allows us to complete the
+	     * line.
+	     */
+
+	    if (translation != statePtr->inputTranslation) {
+		statePtr->inputTranslation = translation;
+		ResetFlag(statePtr, INPUT_SAW_CR | CHANNEL_NEED_MORE_DATA);
+		UpdateInterest(chanPtr);
+	    }
+	}
+	if (writeMode) {
+	    if (*writeMode == '\0') {
+		/* Do nothing. */
+	    } else if (strcmp(writeMode, "auto") == 0) {
+		/*
+		 * This is a hack to get TCP sockets to produce output in CRLF
+		 * mode if they are being set into AUTO mode. A better
+		 * solution for achieving this effect will be coded later.
+		 */
+
+		if (strcmp(Tcl_ChannelName(chanPtr->typePtr), "tcp") == 0) {
+		    statePtr->outputTranslation = TCL_TRANSLATE_CRLF;
+		} else {
+		    statePtr->outputTranslation = TCL_PLATFORM_TRANSLATION;
+		}
+	    } else if (strcmp(writeMode, "binary") == 0) {
+		statePtr->outEofChar = 0;
+		statePtr->outputTranslation = TCL_TRANSLATE_LF;
+		Tcl_FreeEncoding(statePtr->encoding);
+		statePtr->encoding = NULL;
+	    } else if (strcmp(writeMode, "lf") == 0) {
+		statePtr->outputTranslation = TCL_TRANSLATE_LF;
+	    } else if (strcmp(writeMode, "cr") == 0) {
+		statePtr->outputTranslation = TCL_TRANSLATE_CR;
+	    } else if (strcmp(writeMode, "crlf") == 0) {
+		statePtr->outputTranslation = TCL_TRANSLATE_CRLF;
+	    } else if (strcmp(writeMode, "platform") == 0) {
+		statePtr->outputTranslation = TCL_PLATFORM_TRANSLATION;
+	    } else {
+		if (interp) {
+		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
+			    "bad value for -translation: must be one of "
+                            "auto, binary, cr, lf, crlf, or platform", -1));
+		}
+		ckfree(argv);
+		return TCL_ERROR;
+	    }
+	}
+	ckfree(argv);
+	return TCL_OK;
+    } else if (chanPtr->typePtr->setOptionProc != NULL) {
+	return chanPtr->typePtr->setOptionProc(chanPtr->instanceData, interp,
+		optionName, newValue);
+    } else {
+	return Tcl_BadChannelOption(interp, optionName, NULL);
+    }
+
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * CleanupChannelHandlers --
+ *
+ *	Removes channel handlers that refer to the supplied interpreter, so
+ *	that if the actual channel is not closed now, these handlers will not
+ *	run on subsequent events on the channel. This would be erroneous,
+ *	because the interpreter no longer has a reference to this channel.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Removes channel handlers.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+CleanupChannelHandlers(
+    Tcl_Interp *interp,
+    Channel *chanPtr)
+{
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
+    EventScriptRecord *sPtr, *prevPtr, *nextPtr;
+
+    /*
+     * Remove fileevent records on this channel that refer to the given
+     * interpreter.
+     */
+
+    for (sPtr = statePtr->scriptRecordPtr, prevPtr = NULL;
+	    sPtr != NULL; sPtr = nextPtr) {
+	nextPtr = sPtr->nextPtr;
+	if (sPtr->interp == interp) {
+	    if (prevPtr == NULL) {
+		statePtr->scriptRecordPtr = nextPtr;
+	    } else {
+		prevPtr->nextPtr = nextPtr;
+	    }
+
+	    Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
+		    TclChannelEventScriptInvoker, sPtr);
+
+	    TclDecrRefCount(sPtr->scriptPtr);
+	    ckfree(sPtr);
+	} else {
+	    prevPtr = sPtr;
+	}
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_NotifyChannel --
+ *
+ *	This procedure is called by a channel driver when a driver detects an
+ *	event on a channel. This procedure is responsible for actually
+ *	handling the event by invoking any channel handler callbacks.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Whatever the channel handler callback procedure does.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_NotifyChannel(
+    Tcl_Channel channel,	/* Channel that detected an event. */
+    int mask)			/* OR'ed combination of TCL_READABLE,
+				 * TCL_WRITABLE, or TCL_EXCEPTION: indicates
+				 * which events were detected. */
+{
+    Channel *chanPtr = (Channel *) channel;
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
+    ChannelHandler *chPtr;
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+    NextChannelHandler nh;
+    Channel *upChanPtr;
+    const Tcl_ChannelType *upTypePtr;
+
+    /*
+     * In contrast to the other API functions this procedure walks towards the
+     * top of a stack and not down from it.
+     *
+     * The channel calling this procedure is the one who generated the event,
+     * and thus does not take part in handling it. IOW, its HandlerProc is not
+     * called, instead we begin with the channel above it.
+     *
+     * This behaviour also allows the transformation channels to generate
+     * their own events and pass them upward.
+     */
+
+    while (mask && (chanPtr->upChanPtr != NULL)) {
+	Tcl_DriverHandlerProc *upHandlerProc;
+
+	upChanPtr = chanPtr->upChanPtr;
+	upTypePtr = upChanPtr->typePtr;
+	upHandlerProc = Tcl_ChannelHandlerProc(upTypePtr);
+	if (upHandlerProc != NULL) {
+	    mask = upHandlerProc(upChanPtr->instanceData, mask);
+	}
+
+	/*
+	 * ELSE: Ignore transformations which are unable to handle the event
+	 * coming from below. Assume that they don't change the mask and pass
+	 * it on.
+	 */
+
+	chanPtr = upChanPtr;
+    }
+
+    channel = (Tcl_Channel) chanPtr;
+
+    /*
+     * Here we have either reached the top of the stack or the mask is empty.
+     * We break out of the procedure if it is the latter.
+     */
+
+    if (!mask) {
+	return;
+    }
+
+    /*
+     * We are now above the topmost channel in a stack and have events left.
+     * Now call the channel handlers as usual.
+     *
+     * Preserve the channel struct in case the script closes it.
+     */
+
+    TclChannelPreserve((Tcl_Channel)channel);
+    Tcl_Preserve(statePtr);
+
+    /*
+     * If we are flushing in the background, be sure to call FlushChannel for
+     * writable events. Note that we have to discard the writable event so we
+     * don't call any write handlers before the flush is complete.
+     */
+
+    if (GotFlag(statePtr, BG_FLUSH_SCHEDULED) && (mask & TCL_WRITABLE)) {
+	if (0 == FlushChannel(NULL, chanPtr, 1)) {
+	    mask &= ~TCL_WRITABLE;
+	}
+    }
+
+    /*
+     * Add this invocation to the list of recursive invocations of
+     * Tcl_NotifyChannel.
+     */
+
+    nh.nextHandlerPtr = NULL;
+    nh.nestedHandlerPtr = tsdPtr->nestedHandlerPtr;
+    tsdPtr->nestedHandlerPtr = &nh;
+
+    for (chPtr = statePtr->chPtr; chPtr != NULL; ) {
+	/*
+	 * If this channel handler is interested in any of the events that
+	 * have occurred on the channel, invoke its procedure.
+	 */
+
+	if ((chPtr->mask & mask) != 0) {
+	    nh.nextHandlerPtr = chPtr->nextPtr;
+	    chPtr->proc(chPtr->clientData, chPtr->mask & mask);
+	    chPtr = nh.nextHandlerPtr;
+	} else {
+	    chPtr = chPtr->nextPtr;
+	}
+    }
+
+    /*
+     * Update the notifier interest, since it may have changed after invoking
+     * event handlers. Skip that if the channel was deleted in the call to the
+     * channel handler.
+     */
+
+    if (chanPtr->typePtr != NULL) {
+	/*
+	 * TODO: This call may not be needed.  If a handler induced a
+	 * change in interest, that handler should have made its own
+	 * UpdateInterest() call, one would think.
+	 */
+	UpdateInterest(chanPtr);
+    }
+
+    Tcl_Release(statePtr);
+    TclChannelRelease(channel);
+
+    tsdPtr->nestedHandlerPtr = nh.nestedHandlerPtr;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * UpdateInterest --
+ *
+ *	Arrange for the notifier to call us back at appropriate times based on
+ *	the current state of the channel.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	May schedule a timer or driver handler.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+UpdateInterest(
+    Channel *chanPtr)		/* Channel to update. */
+{
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
+    int mask = statePtr->interestMask;
+
+    if (chanPtr->typePtr == NULL) {
+	/* Do not update interest on a closed channel */
+	return;
+    }
+
+    /*
+     * If there are flushed buffers waiting to be written, then we need to
+     * watch for the channel to become writable.
+     */
+
+    if (GotFlag(statePtr, BG_FLUSH_SCHEDULED)) {
+	mask |= TCL_WRITABLE;
+    }
+
+    /*
+     * If there is data in the input queue, and we aren't waiting for more
+     * data, then we need to schedule a timer so we don't block in the
+     * notifier. Also, cancel the read interest so we don't get duplicate
+     * events.
+     */
+
+    if (mask & TCL_READABLE) {
+	if (!GotFlag(statePtr, CHANNEL_NEED_MORE_DATA)
+		&& (statePtr->inQueueHead != NULL)
+		&& IsBufferReady(statePtr->inQueueHead)) {
+	    mask &= ~TCL_READABLE;
+
+	    /*
+	     * Andreas Kupries, April 11, 2003
+	     *
+	     * Some operating systems (Solaris 2.6 and higher (but not Solaris
+	     * 2.5, go figure)) generate READABLE and EXCEPTION events when
+	     * select()'ing [*] on a plain file, even if EOF was not yet
+	     * reached. This is a problem in the following situation:
+	     *
+	     * - An extension asks to get both READABLE and EXCEPTION events.
+	     * - It reads data into a buffer smaller than the buffer used by
+	     *	 Tcl itself.
+	     * - It does not process all events in the event queue, but only
+	     *	 one, at least in some situations.
+	     *
+	     * In that case we can get into a situation where
+	     *
+	     * - Tcl drops READABLE here, because it has data in its own
+	     *	 buffers waiting to be read by the extension.
+	     * - A READABLE event is syntesized via timer.
+	     * - The OS still reports the EXCEPTION condition on the file.
+	     * - And the extension gets the EXCPTION event first, and handles
+	     *	 this as EOF.
+	     *
+	     * End result ==> Premature end of reading from a file.
+	     *
+	     * The concrete example is 'Expect', and its [expect] command
+	     * (and at the C-level, deep in the bowels of Expect,
+	     * 'exp_get_next_event'. See marker 'SunOS' for commentary in
+	     * that function too).
+	     *
+	     * [*] As the Tcl notifier does. See also for marker 'SunOS' in
+	     * file 'exp_event.c' of Expect.
+	     *
+	     * Our solution here is to drop the interest in the EXCEPTION
+	     * events too. This compiles on all platforms, and also passes the
+	     * testsuite on all of them.
+	     */
+
+	    mask &= ~TCL_EXCEPTION;
+
+	    if (!statePtr->timer) {
+		statePtr->timer = Tcl_CreateTimerHandler(SYNTHETIC_EVENT_TIME,
+                        ChannelTimerProc, chanPtr);
+	    }
+	}
+    }
+    ChanWatch(chanPtr, mask);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ChannelTimerProc --
+ *
+ *	Timer handler scheduled by UpdateInterest to monitor the channel
+ *	buffers until they are empty.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	May invoke channel handlers.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+ChannelTimerProc(
+    ClientData clientData)
+{
+    Channel *chanPtr = clientData;
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
+
+    if (!GotFlag(statePtr, CHANNEL_NEED_MORE_DATA)
+	    && (statePtr->interestMask & TCL_READABLE)
+	    && (statePtr->inQueueHead != NULL)
+	    && IsBufferReady(statePtr->inQueueHead)) {
+	/*
+	 * Restart the timer in case a channel handler reenters the event loop
+	 * before UpdateInterest gets called by Tcl_NotifyChannel.
+	 */
+
+	statePtr->timer = Tcl_CreateTimerHandler(SYNTHETIC_EVENT_TIME,
+                ChannelTimerProc,chanPtr);
+	Tcl_Preserve(statePtr);
+	Tcl_NotifyChannel((Tcl_Channel) chanPtr, TCL_READABLE);
+	Tcl_Release(statePtr);
+    } else {
+	statePtr->timer = NULL;
+	UpdateInterest(chanPtr);
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_CreateChannelHandler --
+ *
+ *	Arrange for a given procedure to be invoked whenever the channel
+ *	indicated by the chanPtr arg becomes readable or writable.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	From now on, whenever the I/O channel given by chanPtr becomes ready
+ *	in the way indicated by mask, proc will be invoked. See the manual
+ *	entry for details on the calling sequence to proc. If there is already
+ *	an event handler for chan, proc and clientData, then the mask will be
+ *	updated.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_CreateChannelHandler(
+    Tcl_Channel chan,		/* The channel to create the handler for. */
+    int mask,			/* OR'ed combination of TCL_READABLE,
+				 * TCL_WRITABLE, and TCL_EXCEPTION: indicates
+				 * conditions under which proc should be
+				 * called. Use 0 to disable a registered
+				 * handler. */
+    Tcl_ChannelProc *proc,	/* Procedure to call for each selected
+				 * event. */
+    ClientData clientData)	/* Arbitrary data to pass to proc. */
+{
+    ChannelHandler *chPtr;
+    Channel *chanPtr = (Channel *) chan;
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
+
+    /*
+     * Check whether this channel handler is not already registered. If it is
+     * not, create a new record, else reuse existing record (smash current
+     * values).
+     */
+
+    for (chPtr = statePtr->chPtr; chPtr != NULL; chPtr = chPtr->nextPtr) {
+	if ((chPtr->chanPtr == chanPtr) && (chPtr->proc == proc) &&
+		(chPtr->clientData == clientData)) {
+	    break;
+	}
+    }
+    if (chPtr == NULL) {
+	chPtr = ckalloc(sizeof(ChannelHandler));
+	chPtr->mask = 0;
+	chPtr->proc = proc;
+	chPtr->clientData = clientData;
+	chPtr->chanPtr = chanPtr;
+	chPtr->nextPtr = statePtr->chPtr;
+	statePtr->chPtr = chPtr;
+    }
+
+    /*
+     * The remainder of the initialization below is done regardless of whether
+     * or not this is a new record or a modification of an old one.
+     */
+
+    chPtr->mask = mask;
+
+    /*
+     * Recompute the interest mask for the channel - this call may actually be
+     * disabling an existing handler.
+     */
+
+    statePtr->interestMask = 0;
+    for (chPtr = statePtr->chPtr; chPtr != NULL; chPtr = chPtr->nextPtr) {
+	statePtr->interestMask |= chPtr->mask;
+    }
+
+    UpdateInterest(statePtr->topChanPtr);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_DeleteChannelHandler --
+ *
+ *	Cancel a previously arranged callback arrangement for an IO channel.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	If a callback was previously registered for this chan, proc and
+ *	clientData, it is removed and the callback will no longer be called
+ *	when the channel becomes ready for IO.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_DeleteChannelHandler(
+    Tcl_Channel chan,		/* The channel for which to remove the
+				 * callback. */
+    Tcl_ChannelProc *proc,	/* The procedure in the callback to delete. */
+    ClientData clientData)	/* The client data in the callback to
+				 * delete. */
+{
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+    ChannelHandler *chPtr, *prevChPtr;
+    Channel *chanPtr = (Channel *) chan;
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
+    NextChannelHandler *nhPtr;
+
+    /*
+     * Find the entry and the previous one in the list.
+     */
+
+    for (prevChPtr = NULL, chPtr = statePtr->chPtr; chPtr != NULL;
+	    chPtr = chPtr->nextPtr) {
+	if ((chPtr->chanPtr == chanPtr) && (chPtr->clientData == clientData)
+		&& (chPtr->proc == proc)) {
+	    break;
+	}
+	prevChPtr = chPtr;
+    }
+
+    /*
+     * If not found, return without doing anything.
+     */
+
+    if (chPtr == NULL) {
+	return;
+    }
+
+    /*
+     * If Tcl_NotifyChannel is about to process this handler, tell it to
+     * process the next one instead - we are going to delete *this* one.
+     */
+
+    for (nhPtr = tsdPtr->nestedHandlerPtr; nhPtr != NULL;
+	    nhPtr = nhPtr->nestedHandlerPtr) {
+	if (nhPtr->nextHandlerPtr == chPtr) {
+	    nhPtr->nextHandlerPtr = chPtr->nextPtr;
+	}
+    }
+
+    /*
+     * Splice it out of the list of channel handlers.
+     */
+
+    if (prevChPtr == NULL) {
+	statePtr->chPtr = chPtr->nextPtr;
+    } else {
+	prevChPtr->nextPtr = chPtr->nextPtr;
+    }
+    ckfree(chPtr);
+
+    /*
+     * Recompute the interest list for the channel, so that infinite loops
+     * will not result if Tcl_DeleteChannelHandler is called inside an event.
+     */
+
+    statePtr->interestMask = 0;
+    for (chPtr = statePtr->chPtr; chPtr != NULL; chPtr = chPtr->nextPtr) {
+	statePtr->interestMask |= chPtr->mask;
+    }
+
+    UpdateInterest(statePtr->topChanPtr);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * DeleteScriptRecord --
+ *
+ *	Delete a script record for this combination of channel, interp and
+ *	mask.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Deletes a script record and cancels a channel event handler.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+DeleteScriptRecord(
+    Tcl_Interp *interp,		/* Interpreter in which script was to be
+				 * executed. */
+    Channel *chanPtr,		/* The channel for which to delete the script
+				 * record (if any). */
+    int mask)			/* Events in mask must exactly match mask of
+				 * script to delete. */
+{
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
+    EventScriptRecord *esPtr, *prevEsPtr;
+
+    for (esPtr = statePtr->scriptRecordPtr, prevEsPtr = NULL; esPtr != NULL;
+	    prevEsPtr = esPtr, esPtr = esPtr->nextPtr) {
+	if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
+	    if (esPtr == statePtr->scriptRecordPtr) {
+		statePtr->scriptRecordPtr = esPtr->nextPtr;
+	    } else {
+		CLANG_ASSERT(prevEsPtr);
+		prevEsPtr->nextPtr = esPtr->nextPtr;
+	    }
+
+	    Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
+		    TclChannelEventScriptInvoker, esPtr);
+
+	    TclDecrRefCount(esPtr->scriptPtr);
+	    ckfree(esPtr);
+
+	    break;
+	}
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * CreateScriptRecord --
+ *
+ *	Creates a record to store a script to be executed when a specific
+ *	event fires on a specific channel.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Causes the script to be stored for later execution.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+CreateScriptRecord(
+    Tcl_Interp *interp,		/* Interpreter in which to execute the stored
+				 * script. */
+    Channel *chanPtr,		/* Channel for which script is to be stored */
+    int mask,			/* Set of events for which script will be
+				 * invoked. */
+    Tcl_Obj *scriptPtr)		/* Pointer to script object. */
+{
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
+    EventScriptRecord *esPtr;
+    int makeCH;
+
+    for (esPtr=statePtr->scriptRecordPtr; esPtr!=NULL; esPtr=esPtr->nextPtr) {
+	if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
+	    TclDecrRefCount(esPtr->scriptPtr);
+	    esPtr->scriptPtr = NULL;
+	    break;
+	}
+    }
+
+    makeCH = (esPtr == NULL);
+
+    if (makeCH) {
+	esPtr = ckalloc(sizeof(EventScriptRecord));
+    }
+
+    /*
+     * Initialize the structure before calling Tcl_CreateChannelHandler,
+     * because a reflected channel calling 'chan postevent' aka
+     * 'Tcl_NotifyChannel' in its 'watch'Proc will invoke
+     * 'TclChannelEventScriptInvoker' immediately, and we do not wish it to
+     * see uninitialized memory and crash. See [Bug 2918110].
+     */
+
+    esPtr->chanPtr = chanPtr;
+    esPtr->interp = interp;
+    esPtr->mask = mask;
+    Tcl_IncrRefCount(scriptPtr);
+    esPtr->scriptPtr = scriptPtr;
+
+    if (makeCH) {
+	esPtr->nextPtr = statePtr->scriptRecordPtr;
+	statePtr->scriptRecordPtr = esPtr;
+
+	Tcl_CreateChannelHandler((Tcl_Channel) chanPtr, mask,
+		TclChannelEventScriptInvoker, esPtr);
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclChannelEventScriptInvoker --
+ *
+ *	Invokes a script scheduled by "fileevent" for when the channel becomes
+ *	ready for IO. This function is invoked by the channel handler which
+ *	was created by the Tcl "fileevent" command.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Whatever the script does.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+TclChannelEventScriptInvoker(
+    ClientData clientData,	/* The script+interp record. */
+    int mask)			/* Not used. */
+{
+    Tcl_Interp *interp;		/* Interpreter in which to eval the script. */
+    Channel *chanPtr;		/* The channel for which this handler is
+				 * registered. */
+    EventScriptRecord *esPtr;	/* The event script + interpreter to eval it
+				 * in. */
+    int result;			/* Result of call to eval script. */
+
+    esPtr = clientData;
+    chanPtr = esPtr->chanPtr;
+    mask = esPtr->mask;
+    interp = esPtr->interp;
+
+    /*
+     * We must preserve the interpreter so we can report errors on it later.
+     * Note that we do not need to preserve the channel because that is done
+     * by Tcl_NotifyChannel before calling channel handlers.
+     */
+
+    Tcl_Preserve(interp);
+    TclChannelPreserve((Tcl_Channel)chanPtr);
+    result = Tcl_EvalObjEx(interp, esPtr->scriptPtr, TCL_EVAL_GLOBAL);
+
+    /*
+     * On error, cause a background error and remove the channel handler and
+     * the script record.
+     *
+     * NOTE: Must delete channel handler before causing the background error
+     * because the background error may want to reinstall the handler.
+     */
+
+    if (result != TCL_OK) {
+	if (chanPtr->typePtr != NULL) {
+	    DeleteScriptRecord(interp, chanPtr, mask);
+	}
+	Tcl_BackgroundException(interp, result);
+    }
+    TclChannelRelease((Tcl_Channel)chanPtr);
+    Tcl_Release(interp);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_FileEventObjCmd --
+ *
+ *	This procedure implements the "fileevent" Tcl command. See the user
+ *	documentation for details on what it does. This command is based on
+ *	the Tk command "fileevent" which in turn is based on work contributed
+ *	by Mark Diekhans.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	May create a channel handler for the specified channel.
+ *
+ *----------------------------------------------------------------------
+ */
+
+	/* ARGSUSED */
+int
+Tcl_FileEventObjCmd(
+    ClientData clientData,	/* Not used. */
+    Tcl_Interp *interp,		/* Interpreter in which the channel for which
+				 * to create the handler is found. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    Channel *chanPtr;		/* The channel to create the handler for. */
+    ChannelState *statePtr;	/* State info for channel */
+    Tcl_Channel chan;		/* The opaque type for the channel. */
+    const char *chanName;
+    int modeIndex;		/* Index of mode argument. */
+    int mask;
+    static const char *const modeOptions[] = {"readable", "writable", NULL};
+    static const int maskArray[] = {TCL_READABLE, TCL_WRITABLE};
+
+    if ((objc != 3) && (objc != 4)) {
+	Tcl_WrongNumArgs(interp, 1, objv, "channelId event ?script?");
+	return TCL_ERROR;
+    }
+    if (Tcl_GetIndexFromObj(interp, objv[2], modeOptions, "event name", 0,
+	    &modeIndex) != TCL_OK) {
+	return TCL_ERROR;
+    }
+    mask = maskArray[modeIndex];
+
+    chanName = TclGetString(objv[1]);
+    chan = Tcl_GetChannel(interp, chanName, NULL);
+    if (chan == NULL) {
+	return TCL_ERROR;
+    }
+    chanPtr = (Channel *) chan;
+    statePtr = chanPtr->state;
+    if ((statePtr->flags & mask) == 0) {
+	Tcl_SetObjResult(interp, Tcl_ObjPrintf("channel is not %s",
+		(mask == TCL_READABLE) ? "readable" : "writable"));
+	return TCL_ERROR;
+    }
+
+    /*
+     * If we are supposed to return the script, do so.
+     */
+
+    if (objc == 3) {
+	EventScriptRecord *esPtr;
+
+	for (esPtr = statePtr->scriptRecordPtr; esPtr != NULL;
+		esPtr = esPtr->nextPtr) {
+	    if ((esPtr->interp == interp) && (esPtr->mask == mask)) {
+		Tcl_SetObjResult(interp, esPtr->scriptPtr);
+		break;
+	    }
+	}
+	return TCL_OK;
+    }
+
+    /*
+     * If we are supposed to delete a stored script, do so.
+     */
+
+    if (*(TclGetString(objv[3])) == '\0') {
+	DeleteScriptRecord(interp, chanPtr, mask);
+	return TCL_OK;
+    }
+
+    /*
+     * Make the script record that will link between the event and the script
+     * to invoke. This also creates a channel event handler which will
+     * evaluate the script in the supplied interpreter.
+     */
+
+    CreateScriptRecord(interp, chanPtr, mask, objv[3]);
+
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ZeroTransferTimerProc --
+ *
+ *	Timer handler scheduled by TclCopyChannel so that -command is
+ *	called asynchronously even when -size is 0.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Calls CopyData for -command invocation.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+ZeroTransferTimerProc(
+    ClientData clientData)
+{
+    /* calling CopyData with mask==0 still implies immediate invocation of the
+     *  -command callback, and completion of the fcopy.
+     */
+    CopyData(clientData, 0);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclCopyChannel --
+ *
+ *	This routine copies data from one channel to another, either
+ *	synchronously or asynchronously. If a command script is supplied, the
+ *	operation runs in the background. The script is invoked when the copy
+ *	completes. Otherwise the function waits until the copy is completed
+ *	before returning.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	May schedule a background copy operation that causes both channels to
+ *	be marked busy.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+TclCopyChannelOld(
+    Tcl_Interp *interp,		/* Current interpreter. */
+    Tcl_Channel inChan,		/* Channel to read from. */
+    Tcl_Channel outChan,	/* Channel to write to. */
+    int toRead,			/* Amount of data to copy, or -1 for all. */
+    Tcl_Obj *cmdPtr)		/* Pointer to script to execute or NULL. */
+{
+    return TclCopyChannel(interp, inChan, outChan, (Tcl_WideInt) toRead,
+            cmdPtr);
+}
+
+int
+TclCopyChannel(
+    Tcl_Interp *interp,		/* Current interpreter. */
+    Tcl_Channel inChan,		/* Channel to read from. */
+    Tcl_Channel outChan,	/* Channel to write to. */
+    Tcl_WideInt toRead,		/* Amount of data to copy, or -1 for all. */
+    Tcl_Obj *cmdPtr)		/* Pointer to script to execute or NULL. */
+{
+    Channel *inPtr = (Channel *) inChan;
+    Channel *outPtr = (Channel *) outChan;
+    ChannelState *inStatePtr, *outStatePtr;
+    int readFlags, writeFlags;
+    CopyState *csPtr;
+    int nonBlocking = (cmdPtr) ? CHANNEL_NONBLOCKING : 0;
+    int moveBytes;
+
+    inStatePtr = inPtr->state;
+    outStatePtr = outPtr->state;
+
+    if (BUSY_STATE(inStatePtr, TCL_READABLE)) {
+	if (interp) {
+	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+                    "channel \"%s\" is busy", Tcl_GetChannelName(inChan)));
+	}
+	return TCL_ERROR;
+    }
+    if (BUSY_STATE(outStatePtr, TCL_WRITABLE)) {
+	if (interp) {
+	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+                    "channel \"%s\" is busy", Tcl_GetChannelName(outChan)));
+	}
+	return TCL_ERROR;
+    }
+
+    readFlags = inStatePtr->flags;
+    writeFlags = outStatePtr->flags;
+
+    /*
+     * Set up the blocking mode appropriately. Background copies need
+     * non-blocking channels. Foreground copies need blocking channels. If
+     * there is an error, restore the old blocking mode.
+     */
+
+    if (nonBlocking != (readFlags & CHANNEL_NONBLOCKING)) {
+	if (SetBlockMode(interp, inPtr, nonBlocking ?
+		TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+    }
+    if ((inPtr!=outPtr) && (nonBlocking!=(writeFlags&CHANNEL_NONBLOCKING)) &&
+	    (SetBlockMode(NULL, outPtr, nonBlocking ?
+		    TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING) != TCL_OK) &&
+	    (nonBlocking != (readFlags & CHANNEL_NONBLOCKING))) {
+	SetBlockMode(NULL, inPtr, (readFlags & CHANNEL_NONBLOCKING)
+		? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING);
+	return TCL_ERROR;
+    }
+
+    /*
+     * Make sure the output side is unbuffered.
+     */
+
+    outStatePtr->flags = (outStatePtr->flags & ~CHANNEL_LINEBUFFERED)
+	    | CHANNEL_UNBUFFERED;
+
+    /*
+     * Test for conditions where we know we can just move bytes from input
+     * channel to output channel with no transformation or even examination
+     * of the bytes themselves.
+     */
+
+    moveBytes = inStatePtr->inEofChar == '\0'	/* No eofChar to stop input */
+	    && inStatePtr->inputTranslation == TCL_TRANSLATE_LF
+	    && outStatePtr->outputTranslation == TCL_TRANSLATE_LF
+	    && inStatePtr->encoding == outStatePtr->encoding;
+
+    /*
+     * Allocate a new CopyState to maintain info about the current copy in
+     * progress. This structure will be deallocated when the copy is
+     * completed.
+     */
+
+    csPtr = ckalloc(sizeof(CopyState) + !moveBytes * inStatePtr->bufSize);
+    csPtr->bufSize = !moveBytes * inStatePtr->bufSize;
+    csPtr->readPtr = inPtr;
+    csPtr->writePtr = outPtr;
+    csPtr->readFlags = readFlags;
+    csPtr->writeFlags = writeFlags;
+    csPtr->toRead = toRead;
+    csPtr->total = (Tcl_WideInt) 0;
+    csPtr->interp = interp;
+    if (cmdPtr) {
+	Tcl_IncrRefCount(cmdPtr);
+    }
+    csPtr->cmdPtr = cmdPtr;
+
+    inStatePtr->csPtrR  = csPtr;
+    outStatePtr->csPtrW = csPtr;
+
+    if (moveBytes) {
+	return MoveBytes(csPtr);
+    }
+
+    /*
+     * Special handling of -size 0 async transfers, so that the -command is
+     * still called asynchronously.
+     */
+
+    if ((nonBlocking == CHANNEL_NONBLOCKING) && (toRead == 0)) {
+        Tcl_CreateTimerHandler(0, ZeroTransferTimerProc, csPtr);
+        return 0;
+    }
+
+    /*
+     * Start copying data between the channels.
+     */
+
+    return CopyData(csPtr, 0);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * CopyData --
+ *
+ *	This function implements the lowest level of the copying mechanism for
+ *	TclCopyChannel.
+ *
+ * Results:
+ *	Returns TCL_OK on success, else TCL_ERROR.
+ *
+ * Side effects:
+ *	Moves data between channels, may create channel handlers.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+MBCallback(
+    CopyState *csPtr,
+    Tcl_Obj *errObj)
+{
+    Tcl_Obj *cmdPtr = Tcl_DuplicateObj(csPtr->cmdPtr);
+    Tcl_WideInt total = csPtr->total;
+    Tcl_Interp *interp = csPtr->interp;
+    int code;
+
+    Tcl_IncrRefCount(cmdPtr);
+    StopCopy(csPtr);
+
+    /* TODO: What if cmdPtr is not a list?! */
+
+    Tcl_ListObjAppendElement(NULL, cmdPtr, Tcl_NewWideIntObj(total));
+    if (errObj) {
+	Tcl_ListObjAppendElement(NULL, cmdPtr, errObj);
+    }
+
+    Tcl_Preserve(interp);
+    code = Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL);
+    if (code != TCL_OK) {
+	Tcl_BackgroundException(interp, code);
+    }
+    Tcl_Release(interp);
+    TclDecrRefCount(cmdPtr);
+}
+
+static void
+MBError(
+    CopyState *csPtr,
+    int mask,
+    int errorCode)
+{
+    Tcl_Channel inChan = (Tcl_Channel) csPtr->readPtr;
+    Tcl_Channel outChan = (Tcl_Channel) csPtr->writePtr;
+    Tcl_Obj *errObj;
+
+    Tcl_SetErrno(errorCode);
+
+    errObj = Tcl_ObjPrintf( "error %sing \"%s\": %s",
+	    (mask & TCL_READABLE) ? "read" : "writ",
+	    Tcl_GetChannelName((mask & TCL_READABLE) ? inChan : outChan),
+	    Tcl_PosixError(csPtr->interp));
+
+    if (csPtr->cmdPtr) {
+	MBCallback(csPtr, errObj);
+    } else {
+	Tcl_SetObjResult(csPtr->interp, errObj);
+	StopCopy(csPtr);
+    }
+}
+
+static void
+MBEvent(
+    ClientData clientData,
+    int mask)
+{
+    CopyState *csPtr = (CopyState *) clientData;
+    Tcl_Channel inChan = (Tcl_Channel) csPtr->readPtr;
+    Tcl_Channel outChan = (Tcl_Channel) csPtr->writePtr;
+    ChannelState *inStatePtr = csPtr->readPtr->state;
+
+    if (mask & TCL_WRITABLE) {
+	Tcl_DeleteChannelHandler(inChan, MBEvent, csPtr);
+	Tcl_DeleteChannelHandler(outChan, MBEvent, csPtr);
+	switch (MBWrite(csPtr)) {
+	case TCL_OK:
+	    MBCallback(csPtr, NULL);
+	    break;
+	case TCL_CONTINUE:
+	    Tcl_CreateChannelHandler(inChan, TCL_READABLE, MBEvent, csPtr);
+	    break;
+	}
+    } else if (mask & TCL_READABLE) {
+	if (TCL_OK == MBRead(csPtr)) {
+	    /* When at least one full buffer is present, stop reading. */
+	    if (IsBufferFull(inStatePtr->inQueueHead)
+		    || !Tcl_InputBlocked(inChan)) {
+		Tcl_DeleteChannelHandler(inChan, MBEvent, csPtr);
+	    }
+
+	    /* Successful read -- set up to write the bytes we read */
+	    Tcl_CreateChannelHandler(outChan, TCL_WRITABLE, MBEvent, csPtr);
+	}
+    }
+}
+
+static int
+MBRead(
+    CopyState *csPtr)
+{
+    ChannelState *inStatePtr = csPtr->readPtr->state;
+    ChannelBuffer *bufPtr = inStatePtr->inQueueHead;
+    int code;
+
+    if (bufPtr && BytesLeft(bufPtr) > 0) {
+	return TCL_OK;
+    }
+
+    code = GetInput(inStatePtr->topChanPtr);
+    if (code == 0 || GotFlag(inStatePtr, CHANNEL_BLOCKED)) {
+	return TCL_OK;
+    } else {
+	MBError(csPtr, TCL_READABLE, code);
+	return TCL_ERROR;
+    }
+}
+
+static int
+MBWrite(
+    CopyState *csPtr)
+{
+    ChannelState *inStatePtr = csPtr->readPtr->state;
+    ChannelState *outStatePtr = csPtr->writePtr->state;
+    ChannelBuffer *bufPtr = inStatePtr->inQueueHead;
+    ChannelBuffer *tail = NULL;
+    int code;
+    Tcl_WideInt inBytes = 0;
+
+    /* Count up number of bytes waiting in the input queue */
+    while (bufPtr) {
+	inBytes += BytesLeft(bufPtr);
+	tail = bufPtr;
+	if (csPtr->toRead != -1 && csPtr->toRead < inBytes) {
+	    /* Queue has enough bytes to complete the copy */
+	    break;
+	}
+	bufPtr = bufPtr->nextPtr;
+    }
+
+    if (bufPtr) {
+	/* Split the overflowing buffer in two */
+	int extra = (int) (inBytes - csPtr->toRead);
+        /* Note that going with int for extra assumes that inBytes is not too
+         * much over toRead to require a wide itself. If that gets violated
+         * 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.
+         */
+
+	bufPtr = AllocChannelBuffer(extra);
+
+	tail->nextAdded -= extra;
+	memcpy(InsertPoint(bufPtr), InsertPoint(tail), extra);
+	bufPtr->nextAdded += extra;
+	bufPtr->nextPtr = tail->nextPtr;
+	tail->nextPtr = NULL;
+	inBytes = csPtr->toRead;
+    }
+
+    /* Update the byte counts */
+    if (csPtr->toRead != -1) {
+	csPtr->toRead -= inBytes;
+    }
+    csPtr->total += inBytes;
+
+    /* Move buffers from input to output channels */
+    if (outStatePtr->outQueueTail) {
+	outStatePtr->outQueueTail->nextPtr = inStatePtr->inQueueHead;
+    } else {
+	outStatePtr->outQueueHead = inStatePtr->inQueueHead;
+    }
+    outStatePtr->outQueueTail = tail;
+    inStatePtr->inQueueHead = bufPtr;
+    if (inStatePtr->inQueueTail == tail) {
+	inStatePtr->inQueueTail = bufPtr;
+    }
+    if (bufPtr == NULL) {
+	inStatePtr->inQueueTail = NULL;
+    }
+
+    code = FlushChannel(csPtr->interp, outStatePtr->topChanPtr, 0);
+    if (code) {
+	MBError(csPtr, TCL_WRITABLE, code);
+	return TCL_ERROR;
+    }
+    if (csPtr->toRead == 0 || GotFlag(inStatePtr, CHANNEL_EOF)) {
+	return TCL_OK;
+    }
+    return TCL_CONTINUE;
+}
+
+static int
+MoveBytes(
+    CopyState *csPtr)		/* State of copy operation. */
+{
+    ChannelState *outStatePtr = csPtr->writePtr->state;
+    ChannelBuffer *bufPtr = outStatePtr->curOutPtr;
+    int errorCode;
+
+    if (bufPtr && BytesLeft(bufPtr)) {
+	/* If we start with unflushed bytes in the destination
+	 * channel, flush them out of the way first. */
+
+	errorCode = FlushChannel(csPtr->interp, outStatePtr->topChanPtr, 0);
+	if (errorCode != 0) {
+	    MBError(csPtr, TCL_WRITABLE, errorCode);
+	    return TCL_ERROR;
+	}
+    }
+
+    if (csPtr->cmdPtr) {
+	Tcl_Channel inChan = (Tcl_Channel) csPtr->readPtr;
+	Tcl_CreateChannelHandler(inChan, TCL_READABLE, MBEvent, csPtr);
+	return TCL_OK;
+    }
+
+    while (1) {
+	int code;
+
+	if (TCL_ERROR == MBRead(csPtr)) {
+	    return TCL_ERROR;
+	}
+	code = MBWrite(csPtr);
+	if (code == TCL_OK) {
+	    Tcl_SetObjResult(csPtr->interp, Tcl_NewWideIntObj(csPtr->total));
+	    StopCopy(csPtr);
+	    return TCL_OK;
+	}
+	if (code == TCL_ERROR) {
+	    return TCL_ERROR;
+	}
+	/* code == TCL_CONTINUE --> continue the loop */
+    }
+    return TCL_OK;	/* Silence compiler warnings */
+}
+
+static int
+CopyData(
+    CopyState *csPtr,		/* State of copy operation. */
+    int mask)			/* Current channel event flags. */
+{
+    Tcl_Interp *interp;
+    Tcl_Obj *cmdPtr, *errObj = NULL, *bufObj = NULL, *msg = NULL;
+    Tcl_Channel inChan, outChan;
+    ChannelState *inStatePtr, *outStatePtr;
+    int result = TCL_OK, size, sizeb;
+    Tcl_WideInt total;
+    const char *buffer;
+    int inBinary, outBinary, sameEncoding;
+				/* Encoding control */
+    int underflow;		/* Input underflow */
+
+    inChan	= (Tcl_Channel) csPtr->readPtr;
+    outChan	= (Tcl_Channel) csPtr->writePtr;
+    inStatePtr	= csPtr->readPtr->state;
+    outStatePtr	= csPtr->writePtr->state;
+    interp	= csPtr->interp;
+    cmdPtr	= csPtr->cmdPtr;
+
+    /*
+     * Copy the data the slow way, using the translation mechanism.
+     *
+     * Note: We have make sure that we use the topmost channel in a stack for
+     * the copying. The caller uses Tcl_GetChannel to access it, and thus gets
+     * the bottom of the stack.
+     */
+
+    inBinary = (inStatePtr->encoding == NULL);
+    outBinary = (outStatePtr->encoding == NULL);
+    sameEncoding = (inStatePtr->encoding == outStatePtr->encoding);
+
+    if (!(inBinary || sameEncoding)) {
+	TclNewObj(bufObj);
+	Tcl_IncrRefCount(bufObj);
+    }
+
+    while (csPtr->toRead != (Tcl_WideInt) 0) {
+	/*
+	 * Check for unreported background errors.
+	 */
+
+	Tcl_GetChannelError(inChan, &msg);
+	if ((inStatePtr->unreportedError != 0) || (msg != NULL)) {
+	    Tcl_SetErrno(inStatePtr->unreportedError);
+	    inStatePtr->unreportedError = 0;
+	    goto readError;
+	}
+	Tcl_GetChannelError(outChan, &msg);
+	if ((outStatePtr->unreportedError != 0) || (msg != NULL)) {
+	    Tcl_SetErrno(outStatePtr->unreportedError);
+	    outStatePtr->unreportedError = 0;
+	    goto writeError;
+	}
+
+	if (cmdPtr && (mask == 0)) {
+	    /*
+	     * In async mode, we skip reading synchronously and fake an
+	     * underflow instead to prime the readable fileevent.
+	     */
+
+	    size = 0;
+	    underflow = 1;
+	} else {
+	    /*
+	     * Read up to bufSize bytes.
+	     */
+
+	    if ((csPtr->toRead == (Tcl_WideInt) -1)
+                    || (csPtr->toRead > (Tcl_WideInt) csPtr->bufSize)) {
+		sizeb = csPtr->bufSize;
+	    } else {
+		sizeb = (int) csPtr->toRead;
+	    }
+
+	    if (inBinary || sameEncoding) {
+		size = DoRead(inStatePtr->topChanPtr, csPtr->buffer, sizeb,
+                              !GotFlag(inStatePtr, CHANNEL_NONBLOCKING));
+	    } else {
+		size = DoReadChars(inStatePtr->topChanPtr, bufObj, sizeb,
+			0 /* No append */);
+	    }
+	    underflow = (size >= 0) && (size < sizeb);	/* Input underflow */
+	}
+
+	if (size < 0) {
+	readError:
+	    if (interp) {
+		TclNewObj(errObj);
+		Tcl_AppendStringsToObj(errObj, "error reading \"",
+			Tcl_GetChannelName(inChan), "\": ", NULL);
+		if (msg != NULL) {
+		    Tcl_AppendObjToObj(errObj, msg);
+		} else {
+		    Tcl_AppendStringsToObj(errObj, Tcl_PosixError(interp),
+			    NULL);
+		}
+	    }
+	    if (msg != NULL) {
+		Tcl_DecrRefCount(msg);
+	    }
+	    break;
+	} else if (underflow) {
+	    /*
+	     * We had an underflow on the read side. If we are at EOF, and not
+	     * in the synchronous part of an asynchronous fcopy, then the
+	     * copying is done, otherwise set up a channel handler to detect
+	     * when the channel becomes readable again.
+	     */
+
+	    if ((size == 0) && Tcl_Eof(inChan) && !(cmdPtr && (mask == 0))) {
+		break;
+	    }
+	    if (cmdPtr && (!Tcl_Eof(inChan) || (mask == 0)) &&
+                !(mask & TCL_READABLE)) {
+		if (mask & TCL_WRITABLE) {
+		    Tcl_DeleteChannelHandler(outChan, CopyEventProc, csPtr);
+		}
+		Tcl_CreateChannelHandler(inChan, TCL_READABLE, CopyEventProc,
+			csPtr);
+	    }
+	    if (size == 0) {
+		if (!GotFlag(inStatePtr, CHANNEL_NONBLOCKING)) {
+		    /* We allowed a short read.  Keep trying. */
+		    continue;
+		}
+		if (bufObj != NULL) {
+		    TclDecrRefCount(bufObj);
+		    bufObj = NULL;
+		}
+		return TCL_OK;
+	    }
+	}
+
+	/*
+	 * Now write the buffer out.
+	 */
+
+	if (inBinary || sameEncoding) {
+	    buffer = csPtr->buffer;
+	    sizeb = size;
+	} else {
+	    buffer = TclGetStringFromObj(bufObj, &sizeb);
+	}
+
+	if (outBinary || sameEncoding) {
+	    sizeb = WriteBytes(outStatePtr->topChanPtr, buffer, sizeb);
+	} else {
+	    sizeb = WriteChars(outStatePtr->topChanPtr, buffer, sizeb);
+	}
+
+	/*
+	 * [Bug 2895565]. At this point 'size' still contains the number of
+	 * bytes or characters which have been read. We keep this to later to
+	 * update the totals and toRead information, see marker (UP) below. We
+	 * must not overwrite it with 'sizeb', which is the number of written
+	 * bytes or characters, and both EOL translation and encoding
+	 * conversion may have changed this number unpredictably in relation
+	 * to 'size' (It can be smaller or larger, in the latter case able to
+	 * drive toRead below -1, causing infinite looping). Completely
+	 * unsuitable for updating totals and toRead.
+	 */
+
+	if (sizeb < 0) {
+	writeError:
+	    if (interp) {
+		TclNewObj(errObj);
+		Tcl_AppendStringsToObj(errObj, "error writing \"",
+			Tcl_GetChannelName(outChan), "\": ", NULL);
+		if (msg != NULL) {
+		    Tcl_AppendObjToObj(errObj, msg);
+		} else {
+		    Tcl_AppendStringsToObj(errObj, Tcl_PosixError(interp),
+			    NULL);
+		}
+	    }
+	    if (msg != NULL) {
+		Tcl_DecrRefCount(msg);
+	    }
+	    break;
+	}
+
+	/*
+	 * Update the current byte count. Do it now so the count is valid
+	 * before a return or break takes us out of the loop. The invariant at
+	 * the top of the loop should be that csPtr->toRead holds the number
+	 * of bytes left to copy.
+	 */
+
+	if (csPtr->toRead != -1) {
+	    csPtr->toRead -= size;
+	}
+	csPtr->total += size;
+
+	/*
+	 * Break loop if EOF && (size>0)
+	 */
+
+	if (Tcl_Eof(inChan)) {
+	    break;
+	}
+
+	/*
+	 * Check to see if the write is happening in the background. If so,
+	 * stop copying and wait for the channel to become writable again.
+	 * After input underflow we already installed a readable handler
+	 * therefore we don't need a writable handler.
+	 */
+
+	if (!underflow && GotFlag(outStatePtr, BG_FLUSH_SCHEDULED)) {
+	    if (!(mask & TCL_WRITABLE)) {
+		if (mask & TCL_READABLE) {
+		    Tcl_DeleteChannelHandler(inChan, CopyEventProc, csPtr);
+		}
+		Tcl_CreateChannelHandler(outChan, TCL_WRITABLE,
+			CopyEventProc, csPtr);
+	    }
+	    if (bufObj != NULL) {
+		TclDecrRefCount(bufObj);
+		bufObj = NULL;
+	    }
+	    return TCL_OK;
+	}
+
+	/*
+	 * For background copies, we only do one buffer per invocation so we
+	 * don't starve the rest of the system.
+	 */
+
+	if (cmdPtr && (csPtr->toRead != 0)) {
+	    /*
+	     * The first time we enter this code, there won't be a channel
+	     * handler established yet, so do it here.
+	     */
+
+	    if (mask == 0) {
+		Tcl_CreateChannelHandler(outChan, TCL_WRITABLE, CopyEventProc,
+			csPtr);
+	    }
+	    if (bufObj != NULL) {
+		TclDecrRefCount(bufObj);
+		bufObj = NULL;
+	    }
+	    return TCL_OK;
+	}
+    } /* while */
+
+    if (bufObj != NULL) {
+	TclDecrRefCount(bufObj);
+	bufObj = NULL;
+    }
+
+    /*
+     * Make the callback or return the number of bytes transferred. The local
+     * total is used because StopCopy frees csPtr.
+     */
+
+    total = csPtr->total;
+    if (cmdPtr && interp) {
+	int code;
+
+	/*
+	 * Get a private copy of the command so we can mutate it by adding
+	 * arguments. Note that StopCopy frees our saved reference to the
+	 * original command obj.
+	 */
+
+	cmdPtr = Tcl_DuplicateObj(cmdPtr);
+	Tcl_IncrRefCount(cmdPtr);
+	StopCopy(csPtr);
+	Tcl_Preserve(interp);
+
+	Tcl_ListObjAppendElement(interp, cmdPtr, Tcl_NewWideIntObj(total));
+	if (errObj) {
+	    Tcl_ListObjAppendElement(interp, cmdPtr, errObj);
+	}
+	code = Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL);
+	if (code != TCL_OK) {
+	    Tcl_BackgroundException(interp, code);
+	    result = TCL_ERROR;
+	}
+	TclDecrRefCount(cmdPtr);
+	Tcl_Release(interp);
+    } else {
+	StopCopy(csPtr);
+	if (interp) {
+	    if (errObj) {
+		Tcl_SetObjResult(interp, errObj);
+		result = TCL_ERROR;
+	    } else {
+		Tcl_ResetResult(interp);
+		Tcl_SetObjResult(interp, Tcl_NewWideIntObj(total));
+	    }
+	}
+    }
+    return result;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * DoRead --
+ *
+ *	Stores up to "bytesToRead" bytes in memory pointed to by "dst".
+ *	These bytes come from reading the channel "chanPtr" and
+ *	performing the configured translations.  No encoding conversions
+ *	are applied to the bytes being read.
+ *
+ * Results:
+ *	The number of bytes actually stored (<= bytesToRead),
+ * 	or -1 if there is an error in reading the channel.  Use
+ * 	Tcl_GetErrno() to retrieve the error code for the error
+ *	that occurred.
+ *
+ *	The number of bytes stored can be less than the number
+ * 	requested when
+ *	  - EOF is reached on the channel; or
+ *	  - the channel is non-blocking, and we've read all we can
+ *	    without blocking.
+ *	  - a channel reading error occurs (and we return -1)
+ *
+ * Side effects:
+ *	May cause input to be buffered.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+DoRead(
+    Channel *chanPtr,		/* The channel from which to read. */
+    char *dst,			/* Where to store input read. */
+    int bytesToRead,		/* Maximum number of bytes to read. */
+    int allowShortReads)	/* Allow half-blocking (pipes,sockets) */
+{
+    ChannelState *statePtr = chanPtr->state;
+    char *p = dst;
+
+    assert (bytesToRead >= 0);
+
+    /*
+     * Early out when we know a read will get the eofchar.
+     *
+     * NOTE: This seems to be a bug.  The special handling for
+     * a zero-char read request ought to come first.  As coded
+     * the EOF due to eofchar has distinguishing behavior from
+     * the EOF due to reported EOF on the underlying device, and
+     * that seems undesirable.  However recent history indicates
+     * that new inconsistent behavior in a patchlevel has problems
+     * too.  Keep on keeping on for now.
+     */
+
+    if (GotFlag(statePtr, CHANNEL_STICKY_EOF)) {
+	SetFlag(statePtr, CHANNEL_EOF);
+	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. */
+    if (bytesToRead == 0) {
+	if (GotFlag(statePtr, CHANNEL_EOF)) {
+	    statePtr->inputEncodingFlags |= TCL_ENCODING_START;
+	}
+	ResetFlag(statePtr, CHANNEL_BLOCKED|CHANNEL_EOF);
+	statePtr->inputEncodingFlags &= ~TCL_ENCODING_END;
+	/* TODO: Don't need this call */
+	UpdateInterest(chanPtr);
+	return 0;
+    }
+
+    TclChannelPreserve((Tcl_Channel)chanPtr);
+    while (bytesToRead) {
+	/*
+	 * Each pass through the loop is intended to process up to
+	 * one channel buffer.
+	 */
+
+	int bytesRead, bytesWritten;
+	ChannelBuffer *bufPtr = statePtr->inQueueHead;
+
+	/*
+	 * Don't read more data if we have what we need.
+	 */
+
+	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 */
+	    int code;
+
+	moreData:
+	    code = GetInput(chanPtr);
+	    bufPtr = statePtr->inQueueHead;
+
+	    assert (bufPtr != NULL);
+
+	    if (GotFlag(statePtr, CHANNEL_EOF|CHANNEL_BLOCKED)) {
+		/* Further reads cannot do any more */
+		break;
+	    }
+
+	    if (code) {
+		/* Read error */
+		UpdateInterest(chanPtr);
+		TclChannelRelease((Tcl_Channel)chanPtr);
+		return -1;
+	    }
+
+	    assert (IsBufferFull(bufPtr));
+	}
+
+	assert (bufPtr != NULL);
+
+	bytesRead = BytesLeft(bufPtr);
+	bytesWritten = bytesToRead;
+
+	TranslateInputEOL(statePtr, p, RemovePoint(bufPtr),
+		&bytesWritten, &bytesRead);
+	bufPtr->nextRemoved += bytesRead;
+	p += bytesWritten;
+	bytesToRead -= bytesWritten;
+
+	if (!IsBufferEmpty(bufPtr)) {
+	    /*
+	     * Buffer is not empty.  How can that be?
+	     *
+	     * 0) We stopped early because we got all the bytes
+	     *    we were seeking.  That's fine.
+	     */
+
+	    if (bytesToRead == 0) {
+		break;
+	    }
+
+	    /*
+	     * 1) We're @EOF because we saw eof char.
+	     */
+
+	    if (GotFlag(statePtr, CHANNEL_STICKY_EOF)) {
+		break;
+	    }
+
+	    /*
+	     * 2) The buffer holds a \r while in CRLF translation,
+	     *    followed by the end of the buffer.
+	     */
+
+	    assert(statePtr->inputTranslation == TCL_TRANSLATE_CRLF);
+	    assert(RemovePoint(bufPtr)[0] == '\r');
+	    assert(BytesLeft(bufPtr) == 1);
+
+	    if (bufPtr->nextPtr == NULL) {
+		/* There's no more buffered data.... */
+
+		if (statePtr->flags & CHANNEL_EOF) {
+		    /* ...and there never will be. */
+
+		    *p++ = '\r';
+		    bytesToRead--;
+		    bufPtr->nextRemoved++;
+		} else if (statePtr->flags & CHANNEL_BLOCKED) {
+		    /* ...and we cannot get more now. */
+		    SetFlag(statePtr, CHANNEL_NEED_MORE_DATA);
+		    break;
+		} else {
+		    /* ... so we need to get some. */
+		    goto moreData;
+		}
+	    }
+
+	    if (bufPtr->nextPtr) {
+		/* There's a next buffer.  Shift orphan \r to it. */
+
+		ChannelBuffer *nextPtr = bufPtr->nextPtr;
+
+		nextPtr->nextRemoved -= 1;
+		RemovePoint(nextPtr)[0] = '\r';
+		bufPtr->nextRemoved++;
+	    }
+	}
+
+	if (IsBufferEmpty(bufPtr)) {
+	    statePtr->inQueueHead = bufPtr->nextPtr;
+	    if (statePtr->inQueueHead == NULL) {
+		statePtr->inQueueTail = NULL;
+	    }
+	    RecycleBuffer(statePtr, bufPtr, 0);
+	    bufPtr = statePtr->inQueueHead;
+	}
+
+	if ((GotFlag(statePtr, CHANNEL_NONBLOCKING) || allowShortReads)
+		&& GotFlag(statePtr, CHANNEL_BLOCKED)) {
+	    break;
+	}
+
+	/*
+	 * When there's no buffered data to read, and we're at EOF,
+	 * escape to the caller.
+	 */
+
+	if (GotFlag(statePtr, CHANNEL_EOF)
+		&& (bufPtr == NULL || IsBufferEmpty(bufPtr))) {
+	    break;
+	}
+    }
+    if (bytesToRead == 0) {
+	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)) );
+    UpdateInterest(chanPtr);
+    TclChannelRelease((Tcl_Channel)chanPtr);
+    return (int)(p - dst);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * CopyEventProc --
+ *
+ *	This routine is invoked as a channel event handler for the background
+ *	copy operation. It is just a trivial wrapper around the CopyData
+ *	routine.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+CopyEventProc(
+    ClientData clientData,
+    int mask)
+{
+    (void) CopyData(clientData, mask);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * StopCopy --
+ *
+ *	This routine halts a copy that is in progress.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Removes any pending channel handlers and restores the blocking and
+ *	buffering modes of the channels. The CopyState is freed.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+StopCopy(
+    CopyState *csPtr)		/* State for bg copy to stop . */
+{
+    ChannelState *inStatePtr, *outStatePtr;
+    Tcl_Channel inChan, outChan;
+
+    int nonBlocking;
+
+    if (!csPtr) {
+	return;
+    }
+
+    inChan = (Tcl_Channel) csPtr->readPtr;
+    outChan = (Tcl_Channel) csPtr->writePtr;
+    inStatePtr = csPtr->readPtr->state;
+    outStatePtr = csPtr->writePtr->state;
+
+    /*
+     * Restore the old blocking mode and output buffering mode.
+     */
+
+    nonBlocking = csPtr->readFlags & CHANNEL_NONBLOCKING;
+    if (nonBlocking != (inStatePtr->flags & CHANNEL_NONBLOCKING)) {
+	SetBlockMode(NULL, csPtr->readPtr,
+		nonBlocking ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING);
+    }
+    if (csPtr->readPtr != csPtr->writePtr) {
+	nonBlocking = csPtr->writeFlags & CHANNEL_NONBLOCKING;
+	if (nonBlocking != (outStatePtr->flags & CHANNEL_NONBLOCKING)) {
+	    SetBlockMode(NULL, csPtr->writePtr,
+		    nonBlocking ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING);
+	}
+    }
+    ResetFlag(outStatePtr, CHANNEL_LINEBUFFERED | CHANNEL_UNBUFFERED);
+    outStatePtr->flags |=
+	    csPtr->writeFlags & (CHANNEL_LINEBUFFERED | CHANNEL_UNBUFFERED);
+
+    if (csPtr->cmdPtr) {
+	Tcl_DeleteChannelHandler(inChan, CopyEventProc, csPtr);
+	if (inChan != outChan) {
+	    Tcl_DeleteChannelHandler(outChan, CopyEventProc, csPtr);
+	}
+	Tcl_DeleteChannelHandler(inChan, MBEvent, csPtr);
+	Tcl_DeleteChannelHandler(outChan, MBEvent, csPtr);
+	TclDecrRefCount(csPtr->cmdPtr);
+    }
+    inStatePtr->csPtrR = NULL;
+    outStatePtr->csPtrW = NULL;
+    ckfree(csPtr);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * StackSetBlockMode --
+ *
+ *	This function sets the blocking mode for a channel, iterating through
+ *	each channel in a stack and updates the state flags.
+ *
+ * Results:
+ *	0 if OK, result code from failed blockModeProc otherwise.
+ *
+ * Side effects:
+ *	Modifies the blocking mode of the channel and possibly generates an
+ *	error.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+StackSetBlockMode(
+    Channel *chanPtr,		/* Channel to modify. */
+    int mode)			/* One of TCL_MODE_BLOCKING or
+				 * TCL_MODE_NONBLOCKING. */
+{
+    int result = 0;
+    Tcl_DriverBlockModeProc *blockModeProc;
+    ChannelState *statePtr = chanPtr->state;
+
+    /*
+     * Start at the top of the channel stack
+     * TODO: Examine what can go wrong when blockModeProc calls
+     * disturb the stacking state of the channel.
+     */
+
+    chanPtr = statePtr->topChanPtr;
+    while (chanPtr != NULL) {
+	blockModeProc = Tcl_ChannelBlockModeProc(chanPtr->typePtr);
+	if (blockModeProc != NULL) {
+	    result = blockModeProc(chanPtr->instanceData, mode);
+	    if (result != 0) {
+		Tcl_SetErrno(result);
+		return result;
+	    }
+	}
+	chanPtr = chanPtr->downChanPtr;
+    }
+    return 0;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * SetBlockMode --
+ *
+ *	This function sets the blocking mode for a channel and updates the
+ *	state flags.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	Modifies the blocking mode of the channel and possibly generates an
+ *	error.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+SetBlockMode(
+    Tcl_Interp *interp,		/* Interp for error reporting. */
+    Channel *chanPtr,		/* Channel to modify. */
+    int mode)			/* One of TCL_MODE_BLOCKING or
+				 * TCL_MODE_NONBLOCKING. */
+{
+    int result = 0;
+    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */
+
+    result = StackSetBlockMode(chanPtr, mode);
+    if (result != 0) {
+	if (interp != NULL) {
+	    /*
+	     * TIP #219.
+	     * Move error messages put by the driver into the bypass area and
+	     * put them into the regular interpreter result. Fall back to the
+	     * regular message if nothing was found in the bypass.
+	     *
+	     * Note that we cannot have a message in the interpreter bypass
+	     * area, StackSetBlockMode is restricted to the channel bypass.
+	     * We still need the interp as the destination of the move.
+	     */
+
+	    if (!TclChanCaughtErrorBypass(interp, (Tcl_Channel) chanPtr)) {
+		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+                        "error setting blocking mode: %s",
+			Tcl_PosixError(interp)));
+	    }
+	} else {
+	    /*
+	     * TIP #219.
+	     * If we have no interpreter to put a bypass message into we have
+	     * to clear it, to prevent its propagation and use in other places
+	     * unrelated to the actual occurence of the problem.
+	     */
+
+	    Tcl_SetChannelError((Tcl_Channel) chanPtr, NULL);
+	}
+	return TCL_ERROR;
+    }
+    if (mode == TCL_MODE_BLOCKING) {
+	ResetFlag(statePtr, CHANNEL_NONBLOCKING | BG_FLUSH_SCHEDULED);
+    } else {
+	SetFlag(statePtr, CHANNEL_NONBLOCKING);
+    }
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GetChannelNames --
+ *
+ *	Return the names of all open channels in the interp.
+ *
+ * Results:
+ *	TCL_OK or TCL_ERROR.
+ *
+ * Side effects:
+ *	Interp result modified with list of channel names.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_GetChannelNames(
+    Tcl_Interp *interp)		/* Interp for error reporting. */
+{
+    return Tcl_GetChannelNamesEx(interp, NULL);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GetChannelNamesEx --
+ *
+ *	Return the names of open channels in the interp filtered filtered
+ *	through a pattern. If pattern is NULL, it returns all the open
+ *	channels.
+ *
+ * Results:
+ *	TCL_OK or TCL_ERROR.
+ *
+ * Side effects:
+ *	Interp result modified with list of channel names.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_GetChannelNamesEx(
+    Tcl_Interp *interp,		/* Interp for error reporting. */
+    const char *pattern)	/* Pattern to filter on. */
+{
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+    ChannelState *statePtr;
+    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. */
+
+    if (interp == NULL) {
+	return TCL_OK;
+    }
+
+    /*
+     * Get the channel table that stores the channels registered for this
+     * interpreter.
+     */
+
+    hTblPtr = GetChannelTable(interp);
+    TclNewObj(resultPtr);
+    if ((pattern != NULL) && TclMatchIsTrivial(pattern)
+	    && !((pattern[0] == 's') && (pattern[1] == 't')
+	    && (pattern[2] == 'd'))) {
+	if ((Tcl_FindHashEntry(hTblPtr, pattern) != NULL)
+		&& (Tcl_ListObjAppendElement(interp, resultPtr,
+		Tcl_NewStringObj(pattern, -1)) != TCL_OK)) {
+	    goto error;
+	}
+	goto done;
+    }
+
+    for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch); hPtr != NULL;
+	    hPtr = Tcl_NextHashEntry(&hSearch)) {
+	statePtr = ((Channel *) Tcl_GetHashValue(hPtr))->state;
+
+	if (statePtr->topChanPtr == (Channel *) tsdPtr->stdinChannel) {
+	    name = "stdin";
+	} else if (statePtr->topChanPtr == (Channel *) tsdPtr->stdoutChannel) {
+	    name = "stdout";
+	} else if (statePtr->topChanPtr == (Channel *) tsdPtr->stderrChannel) {
+	    name = "stderr";
+	} else {
+	    /*
+	     * This is also stored in Tcl_GetHashKey(hTblPtr, hPtr), but it's
+	     * simpler to just grab the name from the statePtr.
+	     */
+
+	    name = statePtr->channelName;
+	}
+
+	if (((pattern == NULL) || Tcl_StringMatch(name, pattern)) &&
+		(Tcl_ListObjAppendElement(interp, resultPtr,
+			Tcl_NewStringObj(name, -1)) != TCL_OK)) {
+	error:
+	    TclDecrRefCount(resultPtr);
+	    return TCL_ERROR;
+	}
+    }
+
+  done:
+    Tcl_SetObjResult(interp, resultPtr);
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_IsChannelRegistered --
+ *
+ *	Checks whether the channel is associated with the interp. See also
+ *	Tcl_RegisterChannel and Tcl_UnregisterChannel.
+ *
+ * Results:
+ *	0 if the channel is not registered in the interpreter, 1 else.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_IsChannelRegistered(
+    Tcl_Interp *interp,		/* The interp to query of the channel */
+    Tcl_Channel chan)		/* The channel to check */
+{
+    Tcl_HashTable *hTblPtr;	/* Hash table of channels. */
+    Tcl_HashEntry *hPtr;	/* Search variable. */
+    Channel *chanPtr;		/* The real IO channel. */
+    ChannelState *statePtr;	/* State of the real channel. */
+
+    /*
+     * Always check bottom-most channel in the stack. This is the one that
+     * gets registered.
+     */
+
+    chanPtr = ((Channel *) chan)->state->bottomChanPtr;
+    statePtr = chanPtr->state;
+
+    hTblPtr = Tcl_GetAssocData(interp, "tclIO", NULL);
+    if (hTblPtr == NULL) {
+	return 0;
+    }
+    hPtr = Tcl_FindHashEntry(hTblPtr, statePtr->channelName);
+    if (hPtr == NULL) {
+	return 0;
+    }
+    if ((Channel *) Tcl_GetHashValue(hPtr) != chanPtr) {
+	return 0;
+    }
+
+    return 1;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_IsChannelShared --
+ *
+ *	Checks whether the channel is shared by multiple interpreters.
+ *
+ * Results:
+ *	A boolean value (0 = Not shared, 1 = Shared).
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_IsChannelShared(
+    Tcl_Channel chan)		/* The channel to query */
+{
+    ChannelState *statePtr = ((Channel *) chan)->state;
+				/* State of real channel structure. */
+
+    return ((statePtr->refCount > 1) ? 1 : 0);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_IsChannelExisting --
+ *
+ *	Checks whether a channel of the given name exists in the
+ *	(thread)-global list of all channels. See Tcl_GetChannelNamesEx for
+ *	function exposed at the Tcl level.
+ *
+ * Results:
+ *	A boolean value (0 = Does not exist, 1 = Does exist).
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_IsChannelExisting(
+    const char *chanName)	/* The name of the channel to look for. */
+{
+    ChannelState *statePtr;
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+    const char *name;
+    int chanNameLen;
+
+    chanNameLen = strlen(chanName);
+    for (statePtr = tsdPtr->firstCSPtr; statePtr != NULL;
+	    statePtr = statePtr->nextCSPtr) {
+	if (statePtr->topChanPtr == (Channel *) tsdPtr->stdinChannel) {
+	    name = "stdin";
+	} else if (statePtr->topChanPtr == (Channel *) tsdPtr->stdoutChannel) {
+	    name = "stdout";
+	} else if (statePtr->topChanPtr == (Channel *) tsdPtr->stderrChannel) {
+	    name = "stderr";
+	} else {
+	    name = statePtr->channelName;
+	}
+
+	if ((*chanName == *name) &&
+		(memcmp(name, chanName, (size_t) chanNameLen + 1) == 0)) {
+	    return 1;
+	}
+    }
+
+    return 0;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelName --
+ *
+ *	Return the name of the channel type.
+ *
+ * Results:
+ *	A pointer the name of the channel type.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+const char *
+Tcl_ChannelName(
+    const Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
+{
+    return chanTypePtr->typeName;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelVersion --
+ *
+ *	Return the of version of the channel type.
+ *
+ * Results:
+ *	One of the TCL_CHANNEL_VERSION_* constants from tcl.h
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_ChannelTypeVersion
+Tcl_ChannelVersion(
+    const Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
+{
+    if (chanTypePtr->version == TCL_CHANNEL_VERSION_2) {
+	return TCL_CHANNEL_VERSION_2;
+    } else if (chanTypePtr->version == TCL_CHANNEL_VERSION_3) {
+	return TCL_CHANNEL_VERSION_3;
+    } else if (chanTypePtr->version == TCL_CHANNEL_VERSION_4) {
+	return TCL_CHANNEL_VERSION_4;
+    } else if (chanTypePtr->version == TCL_CHANNEL_VERSION_5) {
+	return TCL_CHANNEL_VERSION_5;
+    } else {
+	/*
+	 * In <v2 channel versions, the version field is occupied by the
+	 * Tcl_DriverBlockModeProc
+	 */
+
+	return TCL_CHANNEL_VERSION_1;
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * HaveVersion --
+ *
+ *	Return whether a channel type is (at least) of a given version.
+ *
+ * Results:
+ *	True if the minimum version is exceeded by the version actually
+ *	present.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+HaveVersion(
+    const Tcl_ChannelType *chanTypePtr,
+    Tcl_ChannelTypeVersion minimumVersion)
+{
+    Tcl_ChannelTypeVersion actualVersion = Tcl_ChannelVersion(chanTypePtr);
+
+    return (PTR2INT(actualVersion)) >= (PTR2INT(minimumVersion));
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelBlockModeProc --
+ *
+ *	Return the Tcl_DriverBlockModeProc of the channel type.
+ *
+ * Results:
+ *	A pointer to the proc.
+ *
+ * Side effects:
+ *	None.
+ *
+ *---------------------------------------------------------------------- */
+
+Tcl_DriverBlockModeProc *
+Tcl_ChannelBlockModeProc(
+    const Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
+{
+    if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_2)) {
+	return chanTypePtr->blockModeProc;
+    }
+
+    /*
+     * The v1 structure had the blockModeProc in a different place.
+     */
+
+    return (Tcl_DriverBlockModeProc *) chanTypePtr->version;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelCloseProc --
+ *
+ *	Return the Tcl_DriverCloseProc of the channel type.
+ *
+ * Results:
+ *	A pointer to the proc.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverCloseProc *
+Tcl_ChannelCloseProc(
+    const Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
+{
+    return chanTypePtr->closeProc;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelClose2Proc --
+ *
+ *	Return the Tcl_DriverClose2Proc of the channel type.
+ *
+ * Results:
+ *	A pointer to the proc.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverClose2Proc *
+Tcl_ChannelClose2Proc(
+    const Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
+{
+    return chanTypePtr->close2Proc;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelInputProc --
+ *
+ *	Return the Tcl_DriverInputProc of the channel type.
+ *
+ * Results:
+ *	A pointer to the proc.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverInputProc *
+Tcl_ChannelInputProc(
+    const Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
+{
+    return chanTypePtr->inputProc;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelOutputProc --
+ *
+ *	Return the Tcl_DriverOutputProc of the channel type.
+ *
+ * Results:
+ *	A pointer to the proc.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverOutputProc *
+Tcl_ChannelOutputProc(
+    const Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
+{
+    return chanTypePtr->outputProc;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelSeekProc --
+ *
+ *	Return the Tcl_DriverSeekProc of the channel type.
+ *
+ * Results:
+ *	A pointer to the proc.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverSeekProc *
+Tcl_ChannelSeekProc(
+    const Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
+{
+    return chanTypePtr->seekProc;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelSetOptionProc --
+ *
+ *	Return the Tcl_DriverSetOptionProc of the channel type.
+ *
+ * Results:
+ *	A pointer to the proc.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverSetOptionProc *
+Tcl_ChannelSetOptionProc(
+    const Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
+{
+    return chanTypePtr->setOptionProc;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelGetOptionProc --
+ *
+ *	Return the Tcl_DriverGetOptionProc of the channel type.
+ *
+ * Results:
+ *	A pointer to the proc.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverGetOptionProc *
+Tcl_ChannelGetOptionProc(
+    const Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
+{
+    return chanTypePtr->getOptionProc;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelWatchProc --
+ *
+ *	Return the Tcl_DriverWatchProc of the channel type.
+ *
+ * Results:
+ *	A pointer to the proc.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverWatchProc *
+Tcl_ChannelWatchProc(
+    const Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
+{
+    return chanTypePtr->watchProc;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelGetHandleProc --
+ *
+ *	Return the Tcl_DriverGetHandleProc of the channel type.
+ *
+ * Results:
+ *	A pointer to the proc.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverGetHandleProc *
+Tcl_ChannelGetHandleProc(
+    const Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
+{
+    return chanTypePtr->getHandleProc;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelFlushProc --
+ *
+ *	Return the Tcl_DriverFlushProc of the channel type.
+ *
+ * Results:
+ *	A pointer to the proc.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverFlushProc *
+Tcl_ChannelFlushProc(
+    const Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
+{
+    if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_2)) {
+	return chanTypePtr->flushProc;
+    }
+    return NULL;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelHandlerProc --
+ *
+ *	Return the Tcl_DriverHandlerProc of the channel type.
+ *
+ * Results:
+ *	A pointer to the proc.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverHandlerProc *
+Tcl_ChannelHandlerProc(
+    const Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
+{
+    if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_2)) {
+	return chanTypePtr->handlerProc;
+    }
+    return NULL;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelWideSeekProc --
+ *
+ *	Return the Tcl_DriverWideSeekProc of the channel type.
+ *
+ * Results:
+ *	A pointer to the proc.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverWideSeekProc *
+Tcl_ChannelWideSeekProc(
+    const Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
+{
+    if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_3)) {
+	return chanTypePtr->wideSeekProc;
+    }
+    return NULL;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelThreadActionProc --
+ *
+ *	TIP #218, Channel Thread Actions. Return the
+ *	Tcl_DriverThreadActionProc of the channel type.
+ *
+ * Results:
+ *	A pointer to the proc.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverThreadActionProc *
+Tcl_ChannelThreadActionProc(
+    const Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
+{
+    if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_4)) {
+	return chanTypePtr->threadActionProc;
+    }
+    return NULL;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_SetChannelErrorInterp --
+ *
+ *	TIP #219, Tcl Channel Reflection API.
+ *	Store an error message for the I/O system.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Discards a previously stored message.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_SetChannelErrorInterp(
+    Tcl_Interp *interp,		/* Interp to store the data into. */
+    Tcl_Obj *msg)		/* Error message to store. */
+{
+    Interp *iPtr = (Interp *) interp;
+
+    if (iPtr->chanMsg != NULL) {
+	TclDecrRefCount(iPtr->chanMsg);
+	iPtr->chanMsg = NULL;
+    }
+
+    if (msg != NULL) {
+	iPtr->chanMsg = FixLevelCode(msg);
+	Tcl_IncrRefCount(iPtr->chanMsg);
+    }
+    return;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_SetChannelError --
+ *
+ *	TIP #219, Tcl Channel Reflection API.
+ *	Store an error message for the I/O system.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Discards a previously stored message.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_SetChannelError(
+    Tcl_Channel chan,		/* Channel to store the data into. */
+    Tcl_Obj *msg)		/* Error message to store. */
+{
+    ChannelState *statePtr = ((Channel *) chan)->state;
+
+    if (statePtr->chanMsg != NULL) {
+	TclDecrRefCount(statePtr->chanMsg);
+	statePtr->chanMsg = NULL;
+    }
+
+    if (msg != NULL) {
+	statePtr->chanMsg = FixLevelCode(msg);
+	Tcl_IncrRefCount(statePtr->chanMsg);
+    }
+    return;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FixLevelCode --
+ *
+ *	TIP #219, Tcl Channel Reflection API.
+ *	Scans an error message for bad -code / -level directives. Returns a
+ *	modified copy with such directives corrected, and the input if it had
+ *	no problems.
+ *
+ * Results:
+ *	A Tcl_Obj*
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static Tcl_Obj *
+FixLevelCode(
+    Tcl_Obj *msg)
+{
+    int explicitResult, numOptions, lc, lcn;
+    Tcl_Obj **lv, **lvn;
+    int res, i, j, val, lignore, cignore;
+    int newlevel = -1, newcode = -1;
+
+    /* ASSERT msg != NULL */
+
+    /*
+     * Process the caught message.
+     *
+     * Syntax = (option value)... ?message?
+     *
+     * Bad message syntax causes a panic, because the other side uses
+     * Tcl_GetReturnOptions and list construction functions to marshall the
+     * information. Hence an error means that we've got serious breakage.
+     */
+
+    res = Tcl_ListObjGetElements(NULL, msg, &lc, &lv);
+    if (res != TCL_OK) {
+	Tcl_Panic("Tcl_SetChannelError: bad syntax of message");
+    }
+
+    explicitResult = (1 == (lc % 2));
+    numOptions = lc - explicitResult;
+
+    /*
+     * No options, nothing to do.
+     */
+
+    if (numOptions == 0) {
+	return msg;
+    }
+
+    /*
+     * Check for -code x, x != 1|error, and -level x, x != 0
+     */
+
+    for (i = 0; i < numOptions; i += 2) {
+	if (0 == strcmp(TclGetString(lv[i]), "-code")) {
+	    /*
+	     * !"error", !integer, integer != 1 (numeric code for error)
+	     */
+
+	    res = TclGetIntFromObj(NULL, lv[i+1], &val);
+	    if (((res == TCL_OK) && (val != 1)) || ((res != TCL_OK) &&
+		    (0 != strcmp(TclGetString(lv[i+1]), "error")))) {
+		newcode = 1;
+	    }
+	} else if (0 == strcmp(TclGetString(lv[i]), "-level")) {
+	    /*
+	     * !integer, integer != 0
+	     */
+
+	    res = TclGetIntFromObj(NULL, lv [i+1], &val);
+	    if ((res != TCL_OK) || (val != 0)) {
+		newlevel = 0;
+	    }
+	}
+    }
+
+    /*
+     * -code, -level are either not present or ok. Nothing to do.
+     */
+
+    if ((newlevel < 0) && (newcode < 0)) {
+	return msg;
+    }
+
+    lcn = numOptions;
+    if (explicitResult) {
+	lcn ++;
+    }
+    if (newlevel >= 0) {
+	lcn += 2;
+    }
+    if (newcode >= 0) {
+	lcn += 2;
+    }
+
+    lvn = ckalloc(lcn * sizeof(Tcl_Obj *));
+
+    /*
+     * New level/code information is spliced into the first occurence of
+     * -level, -code, further occurences are ignored. The options cannot be
+     * not present, we would not come here. Options which are ok are simply
+     * copied over.
+     */
+
+    lignore = cignore = 0;
+    for (i=0, j=0; i<numOptions; i+=2) {
+	if (0 == strcmp(TclGetString(lv[i]), "-level")) {
+	    if (newlevel >= 0) {
+		lvn[j++] = lv[i];
+		lvn[j++] = Tcl_NewIntObj(newlevel);
+		newlevel = -1;
+		lignore = 1;
+		continue;
+	    } else if (lignore) {
+		continue;
+	    }
+	} else if (0 == strcmp(TclGetString(lv[i]), "-code")) {
+	    if (newcode >= 0) {
+		lvn[j++] = lv[i];
+		lvn[j++] = Tcl_NewIntObj(newcode);
+		newcode = -1;
+		cignore = 1;
+		continue;
+	    } else if (cignore) {
+		continue;
+	    }
+	}
+
+	/*
+	 * Keep everything else, possibly copied down.
+	 */
+
+	lvn[j++] = lv[i];
+	lvn[j++] = lv[i+1];
+    }
+    if (newlevel >= 0) {
+	Tcl_Panic("Defined newlevel not used in rewrite");
+    }
+    if (newcode >= 0) {
+	Tcl_Panic("Defined newcode not used in rewrite");
+    }
+
+    if (explicitResult) {
+	lvn[j++] = lv[i];
+    }
+
+    msg = Tcl_NewListObj(j, lvn);
+
+    ckfree(lvn);
+    return msg;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GetChannelErrorInterp --
+ *
+ *	TIP #219, Tcl Channel Reflection API.
+ *	Return the message stored by the channel driver.
+ *
+ * Results:
+ *	Tcl error message object.
+ *
+ * Side effects:
+ *	Resets the stored data to NULL.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_GetChannelErrorInterp(
+    Tcl_Interp *interp,		/* Interp to query. */
+    Tcl_Obj **msg)		/* Place for error message. */
+{
+    Interp *iPtr = (Interp *) interp;
+
+    *msg = iPtr->chanMsg;
+    iPtr->chanMsg = NULL;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GetChannelError --
+ *
+ *	TIP #219, Tcl Channel Reflection API.
+ *	Return the message stored by the channel driver.
+ *
+ * Results:
+ *	Tcl error message object.
+ *
+ * Side effects:
+ *	Resets the stored data to NULL.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_GetChannelError(
+    Tcl_Channel chan,		/* Channel to query. */
+    Tcl_Obj **msg)		/* Place for error message. */
+{
+    ChannelState *statePtr = ((Channel *) chan)->state;
+
+    *msg = statePtr->chanMsg;
+    statePtr->chanMsg = NULL;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ChannelTruncateProc --
+ *
+ *	TIP #208 (subsection relating to truncation, based on TIP #206).
+ *	Return the Tcl_DriverTruncateProc of the channel type.
+ *
+ * Results:
+ *	A pointer to the proc.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_DriverTruncateProc *
+Tcl_ChannelTruncateProc(
+    const Tcl_ChannelType *chanTypePtr)
+				/* Pointer to channel type. */
+{
+    if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_5)) {
+	return chanTypePtr->truncateProc;
+    }
+    return NULL;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * DupChannelIntRep --
+ *
+ *	Initialize the internal representation of a new Tcl_Obj to a copy of
+ *	the internal representation of an existing string object.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	copyPtr's internal rep is set to a copy of srcPtr's internal
+ *	representation.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+DupChannelIntRep(
+    register Tcl_Obj *srcPtr,	/* Object with internal rep to copy. Must have
+				 * an internal rep of type "Channel". */
+    register Tcl_Obj *copyPtr)	/* Object with internal rep to set. Must not
+				 * currently have an internal rep.*/
+{
+    ResolvedChanName *resPtr = srcPtr->internalRep.twoPtrValue.ptr1;
+
+    resPtr->refCount++;
+    copyPtr->internalRep.twoPtrValue.ptr1 = resPtr;
+    copyPtr->typePtr = srcPtr->typePtr;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * FreeChannelIntRep --
+ *
+ *	Release statePtr storage.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	May cause state to be freed.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+FreeChannelIntRep(
+    Tcl_Obj *objPtr)		/* Object with internal rep to free. */
+{
+    ResolvedChanName *resPtr = objPtr->internalRep.twoPtrValue.ptr1;
+
+    objPtr->typePtr = NULL;
+    if (--resPtr->refCount) {
+	return;
+    }
+    Tcl_Release(resPtr->statePtr);
+    ckfree(resPtr);
+}
+
+#if 0
+/*
+ * For future debugging work, a simple function to print the flags of a
+ * channel in semi-readable form.
+ */
+
+static int
+DumpFlags(
+    char *str,
+    int flags)
+{
+    char buf[20];
+    int i = 0;
+
+#define ChanFlag(chr, bit)      (buf[i++] = ((flags & (bit)) ? (chr) : '_'))
+
+    ChanFlag('r', TCL_READABLE);
+    ChanFlag('w', TCL_WRITABLE);
+    ChanFlag('n', CHANNEL_NONBLOCKING);
+    ChanFlag('l', CHANNEL_LINEBUFFERED);
+    ChanFlag('u', CHANNEL_UNBUFFERED);
+    ChanFlag('F', BG_FLUSH_SCHEDULED);
+    ChanFlag('c', CHANNEL_CLOSED);
+    ChanFlag('E', CHANNEL_EOF);
+    ChanFlag('S', CHANNEL_STICKY_EOF);
+    ChanFlag('B', CHANNEL_BLOCKED);
+    ChanFlag('/', INPUT_SAW_CR);
+    ChanFlag('D', CHANNEL_DEAD);
+    ChanFlag('R', CHANNEL_RAW_MODE);
+    ChanFlag('x', CHANNEL_INCLOSE);
+
+    buf[i] ='\0';
+
+    fprintf(stderr, "%s: %s\n", str, buf);
+    return 0;
+}
+#endif
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * tab-width: 8
+ * indent-tabs-mode: nil
+ * End:
+ */